loadtoagent 1.3.8 → 1.3.9

package/README.ko.md

@@ -81,6 +81,18 @@ LoadToAgent는 시작할 때 현재 패키지 버전과 GitHub의 최신 정식
 
 홈의 `10분 시작 가이드`도 같은 네 단계를 직접 눌러 연습하게 해 줍니다. 완료 상태는 이 컴퓨터에 저장되며 언제든 다시 펼칠 수 있습니다.
 
+### 대화를 이어 보내고 실제 전달 상태 확인하기
+
+작업의 **대화 내용** 탭에서 **내용을 이어서 보내기**를 사용하면 지원되는 연결 세션에 새 메시지를 보낼 수 있습니다. 별도 채팅을 만들지 않고 같은 작업과 같은 AI 세션에서 대화가 이어집니다.
+
+LoadToAgent는 전달 상태를 실제로 관측한 세 단계로 보여 줍니다.
+
+1. 앱에서 전송 요청을 보냈는지
+2. 같은 사용자 메시지가 AI 세션 기록에 나타났는지
+3. 그 메시지 뒤에 새 AI 응답 시작 신호가 나타났는지
+
+12초 안에 세션 기록에서 수신이 확인되지 않으면 AI가 응답을 준비한다고 단정하지 않고 `전달 확인 지연`으로 표시합니다. AI의 중간 진행 문장도 별도 상자로 분리하지 않고 시간순 대화 안에 그대로 보여 주며, 마지막 완료 메시지에만 **최종 답변** 표시를 붙입니다. 모든 상태 문구는 로컬 세션 파일에서 확인한 근거를 설명하며 외부 AI 창의 동작을 추측하지 않습니다.
+
 ## 한눈에 볼 수 있는 것
 
 | 화면 | 확인할 수 있는 내용 |
@@ -89,7 +101,7 @@ LoadToAgent는 시작할 때 현재 패키지 버전과 GitHub의 최신 정식
 | 연결 관계 | 사용자 요청, 선택한 메인 AI, 직접 나눠 맡긴 도움 AI |
 | 명령·백그라운드 실행 | AI가 시작한 일반 명령과 백그라운드 명령의 내용, 작업 폴더, 실행 ID와 현재 상태 |
 | 응답·상태 확인함 | 최근 24시간 세션에서 내 응답이 필요한 요청과 현재 실행의 실패·지연·일시정지 위험만 확인 |
-| 작업 상세 | 대화, 도구 호출, 진행 과정, 모델, 작업 폴더, 상태 |
+| 작업 상세 | 시간순 대화, 근거가 확인된 전달 상태, 도구 호출, 진행 과정, 모델, 작업 폴더, 상태 |
 | 관리 요약 | 최근 실행 이벤트, 상태 정보 확인 수준, 완료 신호, 로그에서 찾은 산출물 후보와 테스트 기록, 실행 제어 |
 | 토큰 | 입력·출력·캐시·추론·전체 사용량과 보고된 컨텍스트 점유율 |
 | AI 세션 터미널 | 선택한 AI의 이전 대화와 기존 PTY·tmux 화면을 나란히 보며 같은 세션에 이어서 입력 |

package/README.md

@@ -81,6 +81,18 @@ On startup, LoadToAgent compares its package version with the newest stable GitH
 
 The `10-minute start guide` on Home lets you practice the same four steps. Progress is saved on this computer and the guide can be reopened at any time.
 
+### Continue a conversation and verify delivery
+
+Open a task's **Conversation** tab and use **Continue the conversation** to send another message to a supported connected session. The message stays in the same task and session instead of opening a separate chat.
+
+LoadToAgent shows delivery as three observable steps:
+
+1. the app dispatched the send request;
+2. the exact user message appeared in the AI session log;
+3. a new AI response-start signal appeared after that message.
+
+If the session log does not confirm receipt within 12 seconds, the app reports a delivery-confirmation delay instead of claiming that the AI is already preparing a response. Intermediate AI updates remain in chronological chat order, and only the latest completed message is marked **Final answer**. These labels describe local evidence from the session files; they do not guess what an external AI window is doing.
+
 ## What LoadToAgent shows
 
 | View | What you get |
@@ -89,7 +101,7 @@ The `10-minute start guide` on Home lets you practice the same four steps. Progr
 | Relationship view | The request origin, selected agent, and every directly delegated subagent |
 | Execution units | Foreground shells, background shells, and background jobs started by an AI, including command, workspace, execution ID, and live status |
 | Operations and attention inbox | Prioritized failures, stalls, context risk, approvals, decisions, and input requests with immediate actions |
-| Session detail | Conversation, tool activity, lifecycle events, model, workspace, and status |
+| Session detail | Chronological conversation, evidence-based delivery state, tool activity, lifecycle events, model, workspace, and status |
 | Management summary | Checkpoints, observation confidence, completion summary, artifacts, verification, and run controls |
 | Token view | Input, output, cached, reasoning, total, and reported context-window usage |
 | Session terminal | The selected AI's prior conversation beside its existing PTY or tmux pane, with input continuing in that exact session |

package/README.zh-CN.md

@@ -81,6 +81,18 @@ LoadToAgent 启动时会比较当前包版本与最新的稳定 GitHub Release
 
 首页的`10 分钟入门指南`可以带你实际完成同样的四个步骤。进度只保存在本机，并且可随时重新打开。
 
+### 继续对话并确认实际传递状态
+
+打开任务的**对话**页，使用**继续对话**即可向受支持的已连接会话发送新消息。消息会保留在同一个任务和 AI 会话中，不会另开聊天。
+
+LoadToAgent 会按照实际可观测证据显示三个传递步骤：
+
+1. 应用是否已发出发送请求；
+2. 相同的用户消息是否已出现在 AI 会话记录中；
+3. 该消息之后是否出现了新的 AI 回复开始信号。
+
+如果 12 秒内仍未在会话记录中确认收到消息，应用会显示“传递确认延迟”，而不会直接声称 AI 正在准备回复。AI 的中间进度消息也会按时间顺序保留在对话中，不再放入单独的折叠区域；只有最后一条已完成消息会标记为**最终回答**。所有状态文字都说明本地会话文件中的可验证证据，不会猜测外部 AI 窗口正在做什么。
+
 ## LoadToAgent 可以展示什么
 
 | 视图 | 内容 |
@@ -89,7 +101,7 @@ LoadToAgent 启动时会比较当前包版本与最新的稳定 GitHub Release
 | 关系视图 | 用户请求、当前代理以及它直接委派的所有子代理 |
 | 执行单元 | AI 启动的前台 Shell、后台 Shell 与后台任务，包括命令、工作目录、执行 ID 和实时状态 |
 | 运行概览与待确认收件箱 | 按优先级集中展示失败、停滞、上下文风险、审批、决策和输入请求，并可立即处理 |
-| 会话详情 | 对话、工具活动、执行过程、模型、工作目录和状态 |
+| 会话详情 | 按时间排列的对话、基于证据的传递状态、工具活动、执行过程、模型、工作目录和状态 |
 | 管理摘要 | 检查点、观测置信度、完成摘要、产物、验证结果和执行控制 |
 | Token 视图 | 输入、输出、缓存、推理、总量和已报告的上下文占用率 |
 | 终端控制 | 本地 Shell，以及向 LoadToAgent 自有终端安全发送命令 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loadtoagent",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "description": "A local desktop dashboard for Claude, Codex, Gemini, and Grok sessions.",
   "main": "main.js",
   "author": "wincube AX",

package/renderer/app-agent-actions.js

@@ -12,6 +12,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     selectView,
     providerInfo,
     isLiveSession,
+    conversationMessageKey,
   } = context;
 
   function agentCommandTargets(session) {
@@ -91,12 +92,6 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     return session?.parentId ? `${session.id}:${route}` : session.id;
   }
 
-  function conversationMessageKey(message) {
-    const id = String(message?.id || "").trim();
-    if (id) return `id:${id}`;
-    return `${message?.role || ""}:${String(message?.text || "").replace(/\s+/g, " ").trim()}:${message?.timestamp || ""}`;
-  }
-
   function beginConversationMessage(session, command) {
     const detail = state.details.get(session.id);
     const baselineMessages = [...(session.messages || []), ...(detail?.messages || [])];
@@ -105,6 +100,8 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       text: command,
       timestamp: new Date().toISOString(),
       status: "sending",
+      phase: "sending",
+      dispatchedAt: null,
       presented: false,
       baselineMessageKeys: new Set(baselineMessages.map(conversationMessageKey)),
     };
@@ -120,6 +117,25 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (!entry) return;
     entry.status = status;
     entry.error = error;
+    if (status === "awaiting") {
+      entry.dispatchedAt = entry.dispatchedAt || new Date().toISOString();
+      entry.phase = "confirming";
+      const delay = Number(window.LoadToAgentConversationDelivery?.CONFIRMATION_DELAY_MS || 12_000);
+      clearTimeout(entry.confirmationTimer);
+      entry.confirmationTimer = setTimeout(() => {
+        entry.confirmationTimer = 0;
+        const pending = state.pendingConversationMessages.get(sessionId) || [];
+        if (!pending.includes(entry) || entry.status !== "awaiting") return;
+        state.drawerForceLatest = true;
+        context.render?.();
+        context.renderDrawer?.();
+      }, delay + 40);
+    } else if (status === "failed") {
+      entry.phase = "failed";
+      entry.failedAt = new Date().toISOString();
+      clearTimeout(entry.confirmationTimer);
+      entry.confirmationTimer = 0;
+    }
     state.drawerForceLatest = true;
     context.renderDrawer?.();
   }

package/renderer/app-drawer-content.js

@@ -6,6 +6,7 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
   const {
     esc, uiLocale, state, messageContentHtml, compact, fullNumber, timeOnly, providerInfo, statusIcon, agentPathTaskName, snapshotSession,
     controlRoomAgentGoal, inferredExecutionSummary, executionActivityLabel, executionActivityStatus,
+    conversationDeliveryState, observeConversationDelivery,
   } = context;
   const t = (key, params) => window.LoadToAgentI18n.t(key, params);
 
@@ -57,12 +58,17 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const answerKind = assistant && options.answerKind
       ? `<span class="chat-answer-kind${options.live ? " is-live" : ""}">${esc(options.answerKind)}</span>`
       : "";
+    const deliveryStatusKey = {
+      sending: "drawer.message_sending",
+      confirming: "drawer.message_confirming",
+      delayed: "drawer.message_unconfirmed",
+      received: "drawer.message_received",
+      responding: "drawer.message_responding",
+      failed: "drawer.message_failed",
+    };
     const deliveryStatus = !assistant && message.deliveryStatus
-      ? `<span class="chat-delivery-status ${esc(message.deliveryStatus)}">${esc(t(message.deliveryStatus === "failed"
-        ? "drawer.message_failed"
-        : message.deliveryStatus === "sending"
-          ? "drawer.message_sending"
-          : "drawer.message_sent"))}</span>`
+      ? `<span class="chat-delivery-status ${esc(message.deliveryStatus)}">${esc(t(deliveryStatusKey[message.deliveryStatus]
+        || "drawer.message_sent"))}</span>`
       : "";
     const optimisticClasses = message.optimistic
       ? ` is-optimistic is-${esc(message.deliveryStatus || "awaiting")}${message.animate ? " is-new" : ""}`
@@ -81,21 +87,24 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const pending = state.pendingConversationMessages.get(session.id) || [];
     if (!pending.length) return { session, forceLatestLive: false };
     const messages = [...(session.messages || [])];
-    const messageKey = (message) => {
-      const id = String(message?.id || "").trim();
-      if (id) return `id:${id}`;
-      return `${message?.role || ""}:${String(message?.text || "").replace(/\s+/g, " ").trim()}:${message?.timestamp || ""}`;
-    };
-    const normalizedText = (value) => String(value || "").replace(/\s+/g, " ").trim();
     const retained = [];
     let forceLatestLive = false;
     for (const entry of pending) {
-      const newMessages = messages.filter(message => !entry.baselineMessageKeys?.has(messageKey(message)));
-      const actualUser = newMessages.find(message =>
-        message.role === "user" && normalizedText(message.text) === normalizedText(entry.text));
-      const newAssistant = newMessages.find(message => message.role === "assistant" && normalizedText(message.text));
-      if (actualUser && newAssistant) continue;
-      if (!actualUser) {
+      const delivery = conversationDeliveryState({ ...session, messages }, entry);
+      if (!delivery) continue;
+      observeConversationDelivery(session, entry, delivery);
+      if (delivery.phase === "responded") {
+        clearTimeout(entry.confirmationTimer);
+        continue;
+      }
+      const tracking = {
+        phase: delivery.phase,
+        elapsedMs: delivery.elapsedMs,
+        error: entry.error || "",
+        receivedAt: delivery.receivedAt,
+        responseObservedAt: delivery.responseObservedAt,
+      };
+      if (!delivery.userMessage) {
         messages.push({
           id: entry.id,
           role: "user",
@@ -103,12 +112,21 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
           timestamp: entry.timestamp,
           optimistic: true,
           animate: !entry.presented,
-          deliveryStatus: entry.status,
+          deliveryStatus: delivery.phase,
+          deliveryTracking: tracking,
         });
         entry.presented = true;
+      } else {
+        const actualIndex = messages.indexOf(delivery.userMessage);
+        if (actualIndex >= 0) {
+          messages[actualIndex] = {
+            ...delivery.userMessage,
+            deliveryStatus: delivery.phase,
+            deliveryTracking: tracking,
+          };
+        }
       }
-      if (newAssistant) entry.status = "resolved";
-      if (entry.status === "sending" || entry.status === "awaiting") forceLatestLive = true;
+      forceLatestLive = true;
       retained.push(entry);
     }
     if (retained.length) state.pendingConversationMessages.set(session.id, retained);
@@ -117,23 +135,6 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     return { session: { ...session, messages }, forceLatestLive };
   }
 
-  function progressUpdatesHtml(turn, session) {
-    if (!turn.progress.length) return "";
-    const rows = turn.progress.map((message, index) => {
-      const fullTime = new Date(message.timestamp).toLocaleString(uiLocale());
-      return `<article data-progress-message-id="${esc(message.id || "")}">
-        <header><b>${esc(t("drawer.progress_update_item", { count: index + 1 }))}</b><time title="${esc(fullTime)}">${esc(timeOnly(message.timestamp))}</time></header>
-        ${messageContentHtml(message, session.id)}
-      </article>`;
-    }).join("");
-    return `<details class="chat-progress-updates" data-progress-count="${turn.progress.length}"
-      data-disclosure-key="${esc(`drawer:${session.id}:turn:${turn.id}:progress`)}">
-      <summary><span><b>${esc(t("drawer.progress_updates", { count: turn.progress.length }))}</b>
-      <small>${esc(t("drawer.progress_updates_help"))}</small></span><i aria-hidden="true">↓</i></summary>
-      <div class="chat-progress-list">${rows}</div>
-      </details>`;
-  }
-
   function subagentCallEvents(session) {
     const spawns = session?.collaboration?.spawns || [];
     const children = (session?.childIds || [])
@@ -261,18 +262,70 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     });
     return items.map(item => {
       if (item.kind === "call") return subagentCallHtml(item.call, { showAnchor: false });
-      const finalMessage = item.message.id === representativeId;
+      const finalMessage = item.index === turn.assistants.length - 1
+        || (representativeId && item.message.id === representativeId);
       return conversationRowHtml(item.message, session, {
         userLabel: labels.userLabel,
         assistantLabel: labels.assistantLabel,
         answerKind: finalMessage
           ? t(turn.live ? "drawer.current_progress" : turn.awaitingFinal ? "drawer.last_progress" : "drawer.final_answer")
-          : t("drawer.main_progress_before_call"),
+          : "",
         live: turn.live && finalMessage,
       });
     }).join("");
   }
 
+  function deliveryProgressHtml(tracking) {
+    if (!tracking) {
+      return `<div class="chat-delivery-progress phase-observed" data-delivery-phase="observed" role="status" aria-live="polite">
+        <header><span aria-hidden="true"></span><div><b>${esc(t("drawer.delivery_observed_title"))}</b><small>${esc(t("drawer.delivery_observed_detail"))}</small></div></header>
+        <ol>
+          <li class="done"><i aria-hidden="true">✓</i><span><b>${esc(t("drawer.delivery_observed_message"))}</b><small>${esc(t("drawer.delivery_observed_message_help"))}</small></span></li>
+          <li class="active"><i aria-hidden="true">2</i><span><b>${esc(t("drawer.delivery_observed_session"))}</b><small>${esc(t("drawer.delivery_observed_session_help"))}</small></span></li>
+        </ol>
+        <footer><i aria-hidden="true">◎</i><span>${esc(t("drawer.delivery_evidence_observed"))}</span></footer>
+      </div>`;
+    }
+    const phase = tracking.phase || "confirming";
+    const copy = {
+      sending: ["drawer.delivery_sending_title", "drawer.delivery_sending_detail", "drawer.delivery_evidence_sending"],
+      confirming: ["drawer.delivery_confirming_title", "drawer.delivery_confirming_detail", "drawer.delivery_evidence_confirming"],
+      delayed: ["drawer.delivery_delayed_title", "drawer.delivery_delayed_detail", "drawer.delivery_evidence_delayed"],
+      received: ["drawer.delivery_received_title", "drawer.delivery_received_detail", "drawer.delivery_evidence_received"],
+      responding: ["drawer.delivery_responding_title", "drawer.delivery_responding_detail", "drawer.delivery_evidence_responding"],
+      failed: ["drawer.delivery_failed_title", "drawer.delivery_failed_detail", "drawer.delivery_evidence_failed"],
+    }[phase] || ["drawer.delivery_confirming_title", "drawer.delivery_confirming_detail", "drawer.delivery_evidence_confirming"];
+    const stepState = (step) => {
+      if (phase === "failed") return step === 0 ? "error" : "pending";
+      if (phase === "sending") return step === 0 ? "active" : "pending";
+      if (phase === "confirming" || phase === "delayed") {
+        if (step === 0) return "done";
+        if (step === 1) return phase === "delayed" ? "warning" : "active";
+        return "pending";
+      }
+      if (phase === "received") return step < 2 ? "done" : "active";
+      if (phase === "responding") return step < 2 ? "done" : "active";
+      return "pending";
+    };
+    const steps = [
+      ["drawer.delivery_step_dispatch", "drawer.delivery_step_dispatch_help"],
+      ["drawer.delivery_step_received", "drawer.delivery_step_received_help"],
+      ["drawer.delivery_step_response", "drawer.delivery_step_response_help"],
+    ].map(([label, detail], index) => {
+      const status = stepState(index);
+      const marker = status === "done" ? "✓" : status === "error" ? "!" : String(index + 1);
+      return `<li class="${status}"><i aria-hidden="true">${marker}</i><span><b>${esc(t(label))}</b><small>${esc(t(detail))}</small></span></li>`;
+    }).join("");
+    const detail = phase === "failed" && tracking.error
+      ? t("drawer.delivery_failed_with_reason", { reason: tracking.error })
+      : t(copy[1]);
+    return `<div class="chat-delivery-progress phase-${esc(phase)}" data-delivery-phase="${esc(phase)}" role="status" aria-live="polite">
+      <header><span aria-hidden="true"></span><div><b>${esc(t(copy[0]))}</b><small>${esc(detail)}</small></div></header>
+      <ol>${steps}</ol>
+      <footer><i aria-hidden="true">◎</i><span>${esc(t(copy[2]))}</span></footer>
+    </div>`;
+  }
+
   function chatHtml(session, options = {}) {
     const overlay = conversationOverlay(session);
     session = overlay.session;
@@ -283,7 +336,6 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const assistantLabel = options.assistantLabel || providerInfo(session.provider).label;
     const conversationLabel = options.conversationLabel || t("drawer.conversation");
     const turns = conversationTurns(session, { ...options, forceLatestLive: overlay.forceLatestLive });
-    const progressCount = turns.reduce((sum, turn) => sum + turn.progress.length, 0);
     const omitted = Number(session.omittedMessages || 0);
     const notice =
       omitted || session.truncated
@@ -291,14 +343,8 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
         : "";
     const rows = turns.map((turn, turnIndex) => {
       const user = conversationRowHtml(turn.user, session, { userLabel, assistantLabel });
-      const representative = conversationRowHtml(turn.representative, session, {
-        userLabel,
-        assistantLabel,
-        answerKind: t(turn.live ? "drawer.current_progress" : turn.awaitingFinal ? "drawer.last_progress" : "drawer.final_answer"),
-        live: turn.live,
-      });
       const waiting = turn.live && !turn.representative
-        ? `<div class="chat-turn-waiting"><span aria-hidden="true"></span><b>${esc(t("drawer.preparing_response"))}</b></div>`
+        ? deliveryProgressHtml(turn.user?.deliveryTracking)
         : "";
       const turnStartedAt = Date.parse(turn.user?.timestamp || turn.representative?.timestamp || 0);
       const nextTurnTimestamp = turns[turnIndex + 1]?.user?.timestamp;
@@ -308,11 +354,9 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
         if (Number.isFinite(turnStartedAt) && calledAt < turnStartedAt) return false;
         return !Number.isFinite(nextTurnStartedAt) || calledAt < nextTurnStartedAt;
       });
-      const timeline = turnCalls.length
-        ? turnWithSubagentCallsHtml(turn, session, turnCalls, { userLabel, assistantLabel })
-        : `${representative}${waiting}${progressUpdatesHtml(turn, session)}`;
+      const timeline = turnWithSubagentCallsHtml(turn, session, turnCalls, { userLabel, assistantLabel });
       return `<section class="chat-turn${turn.live ? " is-live" : ""}" data-conversation-turn="${esc(turn.id)}">
-        ${user}${timeline}${turnCalls.length ? waiting : ""}
+        ${user}${timeline}${waiting}
       </section>`;
     }).join("");
     const unmatchedCalls = calls.filter(call => !turns.some((turn, turnIndex) => {
@@ -325,7 +369,7 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const callOnlyRows = unmatchedCalls.map(subagentCallHtml).join("");
     const emptyConversation = turns.length || calls.length ? "" : `<div class="empty-state compact"><h3>${esc(t("drawer.no_user_ai_conversation"))}</h3></div>`;
     return `${notice}<div class="chat-history-head">
-      <span>${esc(t("drawer.turn_summary", { label: conversationLabel, count: turns.length, updates: progressCount ? ` · ${t("drawer.progress_updates", { count: progressCount })}` : "" }))}</span>
+      <span>${esc(t("drawer.turn_summary", { label: conversationLabel, count: turns.length, updates: "" }))}</span>
       <button type="button" data-scroll-latest>${esc(t("drawer.latest_conversation"))} ↓</button>
       </div>
       <div class="chat-list">${callOnlyRows}${rows}${emptyConversation}<div class="chat-latest-anchor" aria-label="${esc(t("drawer.latest_conversation"))}">

package/renderer/app-drawer.js

@@ -7,11 +7,20 @@ window.LoadToAgentAppFactories.createDrawer = function createDrawer(context = {}
   const {
     $, $$, esc, state, motionPreference, motionState, STATUS, markGuideStep, rememberDialogTrigger, restoreDialogTrigger, setDialogOpenState,
     providerInfo, isLiveSession, controlRoomStatus = session => session?.status, subagentWorkState, subagentWorkLabel, isProjectlessSession, sessionOriginPath, sessionWorkspaceLabel,
+    pendingConversationDelivery = () => null,
     agentResumeSupport, originAppInfo, selectedSession, snapshotSession, loadSessionDetail, loadSubagentParentDetail,
     chatHtml, lifecycleHtml, tokensHtml, outcomeHtml, subagentCoordinationEvents, subagentConversationHtml, executionActivityDetailHtml,
     agentCommandComposer,
     rememberDisclosureStates = () => {}, restoreDisclosureStates = () => {},
   } = context;
+  const deliveryLabelKey = (phase) => ({
+    sending: "control.delivery_sending",
+    confirming: "control.delivery_confirming",
+    delayed: "control.delivery_delayed",
+    received: "control.delivery_received",
+    responding: "control.delivery_responding",
+    failed: "control.delivery_failed",
+  })[phase] || "control.delivery_confirming";
 
   function openDrawer(id) {
     rememberDialogTrigger();
@@ -98,6 +107,8 @@ window.LoadToAgentAppFactories.createDrawer = function createDrawer(context = {}
     if (!session) return closeDrawer();
     const provider = providerInfo(session.provider);
     const presentationStatus = controlRoomStatus(session);
+    const delivery = pendingConversationDelivery(session);
+    const presentationLabel = delivery ? t(deliveryLabelKey(delivery.phase)) : STATUS[presentationStatus] || presentationStatus;
     const subagentMode = state.drawerMode === "subagent" && Boolean(session.parentId);
     const executionMode = state.drawerMode === "execution" && Boolean(state.drawerExecutionId);
     const snapshot = snapshotSession(session.id);
@@ -116,8 +127,8 @@ window.LoadToAgentAppFactories.createDrawer = function createDrawer(context = {}
     $("#drawerProvider").textContent = executionMode
       ? `${activity?.runtime || activity?.tool || t("drawer.execution_unit")} · ${activity ? context.executionActivityStatus(activity) : t("drawer.unknown")}`
       : subagentMode
-      ? `${t("control.subagent")} · ${STATUS[presentationStatus] || presentationStatus}`
-      : `${provider.company} · ${STATUS[presentationStatus] || presentationStatus}`;
+      ? `${t("control.subagent")} · ${presentationLabel}`
+      : `${provider.company} · ${presentationLabel}`;
     const drawerTitle = executionMode
       ? context.inferredExecutionSummary(activity || {}).text
       : subagentMode ? session.title || session.taskName || (session.delegation && session.delegation.taskName) : session.title;

package/renderer/app-graph-view.js

@@ -22,6 +22,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     isLiveSession,
     isControlRoomSession = isLiveSession,
     controlRoomStatus = session => session?.status,
+    pendingConversationDelivery = () => null,
     sessionRetentionMinutes = () => 0,
     subagentWorkState,
     subagentWorkLabel,
@@ -41,6 +42,22 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     starting: t("ui.preparing"), running: t("ui.working"), waiting: t("ui.waiting_for_review"), idle: t("ui.idle"),
     completed: t("ui.completed"), failed: t("ui.problem"), cancelled: t("ui.stopped"),
   })[status] || STATUS[status] || status;
+  const deliveryLabelKey = (phase) => ({
+    sending: "control.delivery_sending",
+    confirming: "control.delivery_confirming",
+    delayed: "control.delivery_delayed",
+    received: "control.delivery_received",
+    responding: "control.delivery_responding",
+    failed: "control.delivery_failed",
+  })[phase] || "control.delivery_confirming";
+  const deliverySummaryKey = (phase) => ({
+    sending: "drawer.delivery_sending_title",
+    confirming: "drawer.delivery_confirming_title",
+    delayed: "drawer.delivery_delayed_title",
+    received: "drawer.delivery_received_title",
+    responding: "drawer.delivery_responding_title",
+    failed: "drawer.delivery_failed_title",
+  })[phase] || "drawer.delivery_confirming_title";
 
   function graphNode(session, options = {}) {
     const provider = providerInfo(session.provider);
@@ -50,7 +67,8 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     const percent = Math.max(0, Math.min(100, Number(context.percent || 0)));
     const running = isLiveSession(session);
     const presentationStatus = controlRoomStatus(session);
-    const retained = isControlRoomSession(session) && !running;
+    const delivery = pendingConversationDelivery(session);
+    const retained = isControlRoomSession(session) && !running && !delivery;
     const childCount = (session.childIds || []).length;
     const childMetrics = session.collaboration && session.collaboration.metrics;
     const cumulativeChildren = childMetrics ? childMetrics.cumulativeCreated : childCount;
@@ -62,7 +80,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
           ? delegation.taskName || session.taskName
           : session.title;
     const goalPreview = readablePreview(displayedTask, options.focus ? 118 : 96);
-    const currentWork = latestWorkCopy(session);
+    const currentWork = delivery ? t(deliverySummaryKey(delivery.phase)) : latestWorkCopy(session);
     const currentPreview = readablePreview(currentWork, options.focus ? 132 : 108);
     const role = session.parentId
       ? t("graph.helper_ai_identity", {
@@ -79,7 +97,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
           <span class="provider-mark">${esc(provider.mark)}</span>
           <span class="agent-identity"><b>${esc(role)}</b><small>${esc(provider.label)} · ${esc(session.model || t("graph.model_unknown"))}</small></span>
           ${executionModeBadge(session, true)}
-          <span class="status-pill ${statusClass(presentationStatus)}">${esc(statusLabel(presentationStatus))}</span>
+          <span class="status-pill ${statusClass(presentationStatus)}">${esc(delivery ? t(deliveryLabelKey(delivery.phase)) : statusLabel(presentationStatus))}</span>
         </span>
         <span class="agent-task-label">
           ${session.parentId ? t("graph.assigned_task", { source: delegation.assignmentSource === "protected"
@@ -124,6 +142,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     const usage = session.usage || {};
     const directChildren = graphChildren(session, model).length;
     const presentationStatus = controlRoomStatus(session);
+    const delivery = pendingConversationDelivery(session);
     const identity = session.parentId
       ? t("graph.helper_ai_named", { name: session.agentName || agentRoleLabel(session.agentRole) })
       : t("project.origin_named", { name: sessionWorkspaceLabel(session) });
@@ -132,7 +151,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     const assignedWork = delegation.assignmentObserved && delegation.assignment ? delegation.assignment : taskName || session.title;
     const sharedGoal = delegation.sharedGoal || session.sharedGoal || "";
     const outcome = delegation.result || session.result || "";
-    const outcomeText = outcome || latestWorkCopy(session);
+    const outcomeText = delivery ? t(deliverySummaryKey(delivery.phase)) : outcome || latestWorkCopy(session);
     const assignedWorkPreview = readablePreview(assignedWork, session.parentId ? 110 : 104);
     const taskLabel = session.parentId ? `${label || agentRoleLabel(session.agentRole)}${taskName ? t("graph.assigned_name_suffix", { name: taskName }) : ""}` : label;
     const assignmentSourceNote = session.parentId && delegation.assignmentSource === "protected"
@@ -197,7 +216,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
         <em>${esc(identity)} · ${directChildren ? `${t("graph.helper_ai_count", { count: directChildren })} · ` : ""}${esc(timeAgo(session.updatedAt))}</em>
         ${assignmentSourceNote}${sharedGoalCopy}${outcomeCopy}
       </span>
-      <span class="agent-flow-provider"><i>${esc(provider.mark)}</i><small>${esc(statusLabel(presentationStatus))}</small></span>
+      <span class="agent-flow-provider"><i>${esc(provider.mark)}</i><small>${esc(delivery ? t(deliveryLabelKey(delivery.phase)) : statusLabel(presentationStatus))}</small></span>
     </button>`;
   }
 
@@ -447,8 +466,9 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
   function controlRoomSession(root, model) {
     const provider = providerInfo(root.provider);
     const presentationStatus = controlRoomStatus(root);
+    const delivery = pendingConversationDelivery(root);
     const waiting = presentationStatus === "waiting";
-    const retained = isControlRoomSession(root) && !isLiveSession(root);
+    const retained = isControlRoomSession(root) && !isLiveSession(root) && !delivery;
     const descendants = controlRoomDescendants(root, model);
     const actors = [root, ...descendants];
     const executionItems = actors.flatMap(owner => (owner.executions || []).map(activity => ({ activity, owner })));
@@ -463,14 +483,14 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
       ...completedChildren.map(child => ({ kind: "child", child, timestamp: child.completedAt || child.updatedAt })),
       ...completedExecutions.map(item => ({ kind: "execution", item, timestamp: item.activity.updatedAt || item.activity.startedAt })),
     ].sort((a, b) => Date.parse(b.timestamp || 0) - Date.parse(a.timestamp || 0)).slice(0, 3);
-    const current = controlRoomSummary(latestWorkCopy(root) || root.statusDetail || root.title, 74);
+    const current = controlRoomSummary(delivery ? t(deliverySummaryKey(delivery.phase)) : latestWorkCopy(root) || root.statusDetail || root.title, 74);
     const title = controlRoomAgentGoal(root, 64);
     const unitCount = activeUnits.length;
     const main = `<button type="button" class="control-room-main" data-open-session="${esc(root.id)}"
       data-control-summary="${esc(title.text)}"
       data-motion-key="control-main:${esc(root.id)}" data-motion-value="${esc(root.updatedAt || "")}:${esc(root.status || "")}"
       style="${providerStyle(root.provider)}">
-      <span class="control-main-top"><span class="provider-mark">${esc(provider.mark)}</span><span><small>${esc(t("control.main_agent"))}</small><b>${esc(provider.label)} · ${esc(root.model || t("session.model_unknown"))}</b></span><em><i aria-hidden="true"></i>${esc(statusLabel(presentationStatus))}</em></span>
+      <span class="control-main-top"><span class="provider-mark">${esc(provider.mark)}</span><span><small>${esc(t("control.main_agent"))}</small><b>${esc(provider.label)} · ${esc(root.model || t("session.model_unknown"))}</b></span><em><i aria-hidden="true"></i>${esc(delivery ? t(deliveryLabelKey(delivery.phase)) : statusLabel(presentationStatus))}</em></span>
       <strong title="${esc(title.full)}">${esc(title.text)}</strong>
       <span class="control-main-now"><small>${esc(t("graph.current_work"))}</small><b title="${esc(current.full)}">${esc(current.text)}</b></span>
       <span class="control-main-meta"><small>${esc(t("control.unit_counts", { helpers: activeChildren.length, executions: activeExecutions.length }))}</small><b>${esc(t("graph.view_conversation"))} →</b></span>
@@ -484,9 +504,11 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
       ? completedUnits.map(unit => unit.kind === "child" ? controlRoomChildNode(unit.child) : controlRoomExecutionNode(unit.item)).join("")
       : `<div class="control-room-complete-empty"><span>✓</span><small>${esc(t("control.completed_empty"))}</small></div>`;
     const waitingWithBackground = waiting && activeExecutions.some(item => item.activity.mode === "background" || item.activity.kind === "background");
-    const sessionStateKey = waitingWithBackground
-      ? "control.waiting_background_session"
-      : (waiting ? "control.waiting_session" : (retained ? "control.recently_completed" : "control.live_session"));
+    const sessionStateKey = delivery
+      ? deliveryLabelKey(delivery.phase)
+      : waitingWithBackground
+        ? "control.waiting_background_session"
+        : (waiting ? "control.waiting_session" : (retained ? "control.recently_completed" : "control.live_session"));
     const retention = retained ? `<small class="control-session-retention">${esc(t("control.auto_history_in_minutes", { minutes: sessionRetentionMinutes(root) }))}</small>` : "";
     const archive = retained ? `<button type="button" class="control-session-archive" data-session-archive="${esc(root.id)}">${esc(t("control.move_to_history"))}</button>` : "";
     return `<article class="control-room-session ${waiting ? "is-waiting" : ""} ${waitingWithBackground ? "has-background-work" : ""}" data-control-session="${esc(root.id)}" data-session-sortable="${esc(root.id)}"

package/renderer/app.js

@@ -585,6 +585,54 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     const completedAt = Date.parse(session?.completedAt || session?.endedAt || 0);
     return Number.isFinite(completedAt) ? completedAt : 0;
   }
+  function conversationMessageKey(message) {
+    const delivery = window.LoadToAgentConversationDelivery;
+    if (delivery?.messageKey) return delivery.messageKey(message);
+    const id = String(message?.id || "").trim();
+    if (id) return `id:${id}`;
+    return `${message?.role || ""}:${String(message?.text || "").replace(/\s+/g, " ").trim()}:${message?.timestamp || ""}`;
+  }
+  function conversationDeliveryState(session, entry, now = Date.now()) {
+    return window.LoadToAgentConversationDelivery?.deliveryState?.(session, entry, now) || null;
+  }
+  function pendingConversationDelivery(session, now = Date.now()) {
+    const pending = state.pendingConversationMessages.get(String(session?.id || "")) || [];
+    const retained = [];
+    let latest = null;
+    for (const entry of pending) {
+      const delivery = conversationDeliveryState(session, entry, now);
+      if (!delivery) continue;
+      observeConversationDelivery(session, entry, delivery);
+      if (delivery.phase === "responded") {
+        clearTimeout(entry.confirmationTimer);
+        continue;
+      }
+      retained.push(entry);
+      latest = { ...delivery, entry };
+    }
+    if (retained.length !== pending.length) {
+      if (retained.length) state.pendingConversationMessages.set(String(session?.id || ""), retained);
+      else state.pendingConversationMessages.delete(String(session?.id || ""));
+    }
+    return latest;
+  }
+  function observeConversationDelivery(session, entry, delivery) {
+    if (!entry || !delivery || entry.observedPhase === delivery.phase) return;
+    const previousPhase = entry.observedPhase || "";
+    entry.observedPhase = delivery.phase;
+    entry.phase = delivery.phase;
+    entry.phaseChangedAt = new Date().toISOString();
+    console.info("[LoadToAgent:conversation-delivery]", {
+      event: "conversation-delivery-phase-changed",
+      sessionId: String(session?.id || ""),
+      previousPhase,
+      phase: delivery.phase,
+      elapsedMs: Math.round(Number(delivery.elapsedMs || 0)),
+      userMessageObserved: Boolean(delivery.userMessage),
+      responseStartObserved: Boolean(delivery.responseStartEvent),
+      assistantMessageObserved: Boolean(delivery.assistantMessage),
+    });
+  }
   function loadSessionArchives() {
     try {
       const saved = JSON.parse(localStorage.getItem(SESSION_ARCHIVE_STORAGE_KEY) || "{}");
@@ -614,6 +662,10 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
   }
   function isControlRoomSession(session, now = Date.now()) {
     if (!session) return false;
+    if (pendingConversationDelivery(session, now)) {
+      state.controlRoomObservedIds.add(String(session.id || ""));
+      return true;
+    }
     if (isLiveSession(session)) {
       state.controlRoomObservedIds.add(String(session.id || ""));
       return true;
@@ -786,6 +838,10 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     isLiveSession,
     hasRunningExecution,
     sessionResponseTimestamp,
+    conversationMessageKey,
+    conversationDeliveryState,
+    pendingConversationDelivery,
+    observeConversationDelivery,
     loadSessionArchives,
     saveSessionArchives,
     isSessionManuallyArchived,

package/renderer/conversation-delivery.js

@@ -0,0 +1,74 @@
+"use strict";
+
+(function exposeConversationDelivery(root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) module.exports = api;
+  if (root) root.LoadToAgentConversationDelivery = api;
+})(typeof window === "object" ? window : null, function createConversationDelivery() {
+  const CONFIRMATION_DELAY_MS = 12_000;
+
+  function normalizedText(value) {
+    return String(value || "").replace(/\s+/g, " ").trim();
+  }
+
+  function messageKey(message) {
+    const id = String(message?.id || "").trim();
+    if (id) return `id:${id}`;
+    return `${message?.role || ""}:${normalizedText(message?.text)}:${message?.timestamp || ""}`;
+  }
+
+  function newMessagesForEntry(session, entry) {
+    const baseline = entry?.baselineMessageKeys instanceof Set
+      ? entry.baselineMessageKeys
+      : new Set(entry?.baselineMessageKeys || []);
+    return (session?.messages || []).filter(message => !baseline.has(messageKey(message)));
+  }
+
+  function deliveryState(session, entry, now = Date.now()) {
+    if (!entry) return null;
+    const newMessages = newMessagesForEntry(session, entry);
+    const expectedText = normalizedText(entry.text);
+    const userMessage = newMessages.find(message =>
+      message?.role === "user" && normalizedText(message.text) === expectedText) || null;
+    const assistantMessage = newMessages.find(message =>
+      message?.role === "assistant" && normalizedText(message.text)) || null;
+    const dispatchedAt = Date.parse(entry.dispatchedAt || entry.timestamp || 0);
+    const elapsedMs = Number.isFinite(dispatchedAt) ? Math.max(0, Number(now) - dispatchedAt) : 0;
+    const userObservedAt = Date.parse(userMessage?.timestamp || 0);
+    const responseStartEvent = userMessage
+      ? (session?.lifecycle || []).find(event => {
+        const eventAt = Date.parse(event?.timestamp || 0);
+        return Number.isFinite(eventAt)
+          && (!Number.isFinite(userObservedAt) || eventAt >= userObservedAt)
+          && event?.status === "running"
+          && /start|turn|run/i.test(String(event?.type || event?.label || ""));
+      }) || null
+      : null;
+
+    let phase = "confirming";
+    if (entry.status === "failed") phase = "failed";
+    else if (assistantMessage) phase = "responded";
+    else if (userMessage && responseStartEvent) phase = "responding";
+    else if (userMessage) phase = "received";
+    else if (entry.status === "sending") phase = "sending";
+    else if (elapsedMs >= CONFIRMATION_DELAY_MS) phase = "delayed";
+
+    return {
+      phase,
+      elapsedMs,
+      userMessage,
+      assistantMessage,
+      responseStartEvent,
+      receivedAt: userMessage?.timestamp || null,
+      responseObservedAt: assistantMessage?.timestamp || responseStartEvent?.timestamp || null,
+    };
+  }
+
+  return {
+    CONFIRMATION_DELAY_MS,
+    normalizedText,
+    messageKey,
+    newMessagesForEntry,
+    deliveryState,
+  };
+});

package/renderer/i18n-messages.js

@@ -257,7 +257,7 @@
     "agent.handing_off": {"ko":"이어받는 중…","en":"Handing off…","zh-CN":"正在接管…"},
     "agent.handoff_and_send": {"ko":"관리 터미널로 전환하고 보내기 ↵","en":"Switch to a managed terminal and send ↵","zh-CN":"切换到托管终端并发送 ↵"},
     "agent.connecting": {"ko":"연결하는 중…","en":"Connecting…","zh-CN":"正在连接…"},
-    "agent.background_and_send": {"ko":"백그라운드 터미널에서 재개하고 보내기 ↵","en":"Resume in a background terminal and send ↵","zh-CN":"在后台终端恢复并发送 ↵"},
+    "agent.background_and_send": {"ko":"내용을 이어서 보내기","en":"Continue the conversation","zh-CN":"继续对话"},
     "agent.copy_bridge": {"ko":"연결용 시작 명령 복사","en":"Copy connection start command","zh-CN":"复制连接启动命令"},
     "agent.command_example": {"ko":"예: 이전 작업에 이어서 테스트를 실행하고 결과를 알려줘","en":"Example: Continue the previous work, run the tests, and report the results","zh-CN":"示例：继续之前的工作，运行测试并告知结果"},
     "agent.command_title": {"ko":"연결된 입력 채널에 지시 보내기","en":"Send an instruction through the linked input channel","zh-CN":"通过已连接的输入通道发送指令"},
@@ -286,7 +286,7 @@
     "agent.select_target_first": {"ko":"지시를 보낼 터미널을 먼저 선택하세요.","en":"Choose a terminal before sending an instruction.","zh-CN":"请先选择要发送指令的终端。"},
     "agent.no_writable_terminal": {"ko":"이 AI에 연결된 입력 가능한 터미널이 없습니다.","en":"There is no writable terminal connected to this AI.","zh-CN":"没有连接到此 AI 的可输入终端。"},
     "agent.command_sent": {"ko":"{target}에 지시를 보냈습니다.","en":"Sent the instruction to {target}.","zh-CN":"已将指令发送到 {target}。"},
-    "agent.command_sent_background": {"ko":"대화에 메시지를 보냈습니다. 세션 연결과 AI 응답은 백그라운드에서 이어집니다.","en":"Sent the message. Session reconnection and the AI response will continue in the background.","zh-CN":"消息已发送。会话重连和 AI 回复将在后台继续。"},
+    "agent.command_sent_background": {"ko":"전송 요청을 보냈습니다. 실제 수신과 응답 시작은 대화 상태에서 확인합니다.","en":"The send request was submitted. Check the conversation status for confirmed receipt and response start.","zh-CN":"发送请求已提交，请在对话状态中确认实际接收和回复开始。"},
     "agent.recovered_and_sent": {"ko":"원래 터미널 연결이 종료되어 같은 AI 세션으로 복구한 뒤 지시를 보냈습니다.","en":"The original terminal connection ended, so the AI session was restored before sending the instruction.","zh-CN":"原终端连接已结束，因此恢复同一 AI 会话后发送了指令。"},
     "agent.recovery_failed": {"ko":"터미널 연결이 끊어졌고 세션 복구에도 실패했습니다.","en":"The terminal disconnected and session recovery also failed.","zh-CN":"终端连接已断开，会话恢复也失败。"},
     "agent.send_failed": {"ko":"터미널에 지시를 보내지 못했습니다.","en":"Could not send the instruction to the terminal.","zh-CN":"无法向终端发送指令。"},
@@ -352,7 +352,43 @@
     "drawer.preparing_response": {"ko":"AI가 현재 응답을 준비하고 있습니다","en":"The AI is preparing a response","zh-CN":"AI 正在准备回复"},
     "drawer.message_sending": {"ko":"보내는 중","en":"Sending","zh-CN":"发送中"},
     "drawer.message_sent": {"ko":"전송됨","en":"Sent","zh-CN":"已发送"},
+    "drawer.message_confirming": {"ko":"수신 확인 중","en":"Confirming receipt","zh-CN":"正在确认接收"},
+    "drawer.message_unconfirmed": {"ko":"수신 미확인","en":"Receipt unconfirmed","zh-CN":"尚未确认接收"},
+    "drawer.message_received": {"ko":"AI 수신 확인","en":"Received by AI session","zh-CN":"AI 会话已接收"},
+    "drawer.message_responding": {"ko":"응답 중","en":"Responding","zh-CN":"正在回复"},
     "drawer.message_failed": {"ko":"전송 실패","en":"Send failed","zh-CN":"发送失败"},
+    "drawer.delivery_sending_title": {"ko":"메시지를 보내고 있습니다","en":"Sending your message","zh-CN":"正在发送消息"},
+    "drawer.delivery_sending_detail": {"ko":"관리 터미널에 전송 요청을 전달하는 중입니다.","en":"The send request is being passed to the managed terminal.","zh-CN":"正在将发送请求传递给托管终端。"},
+    "drawer.delivery_confirming_title": {"ko":"AI 세션의 수신을 확인하고 있습니다","en":"Confirming receipt in the AI session","zh-CN":"正在确认 AI 会话是否接收"},
+    "drawer.delivery_confirming_detail": {"ko":"전송 요청은 성공했습니다. AI 대화 기록에 메시지가 나타나는지 확인 중입니다.","en":"The send request succeeded. Waiting for the message to appear in the AI conversation log.","zh-CN":"发送请求已成功，正在等待消息出现在 AI 对话记录中。"},
+    "drawer.delivery_delayed_title": {"ko":"아직 AI 수신을 확인하지 못했습니다","en":"AI receipt is not confirmed yet","zh-CN":"尚未确认 AI 已接收"},
+    "drawer.delivery_delayed_detail": {"ko":"전송 요청은 완료됐지만 AI 대화 기록에는 아직 메시지가 없습니다. 응답 중이라고 단정하지 않습니다.","en":"The send request completed, but the message is not yet in the AI conversation log. The app is not claiming the AI is responding.","zh-CN":"发送请求已完成，但 AI 对话记录中尚无该消息，因此应用不会声称 AI 正在回复。"},
+    "drawer.delivery_received_title": {"ko":"AI 세션에서 메시지를 확인했습니다","en":"Message confirmed in the AI session","zh-CN":"已在 AI 会话中确认消息"},
+    "drawer.delivery_received_detail": {"ko":"대화 기록에 메시지가 들어왔습니다. AI 실행 시작 신호를 기다리고 있습니다.","en":"The message is in the conversation log. Waiting for an AI execution-start signal.","zh-CN":"消息已进入对话记录，正在等待 AI 执行开始信号。"},
+    "drawer.delivery_responding_title": {"ko":"AI가 이 메시지에 응답하고 있습니다","en":"The AI is responding to this message","zh-CN":"AI 正在回复此消息"},
+    "drawer.delivery_responding_detail": {"ko":"메시지 수신과 새 실행 시작을 모두 확인했습니다. 첫 응답을 기다리는 중입니다.","en":"Both message receipt and a new execution start were observed. Waiting for the first response.","zh-CN":"已确认消息接收和新执行开始，正在等待首条回复。"},
+    "drawer.delivery_failed_title": {"ko":"메시지를 보내지 못했습니다","en":"The message could not be sent","zh-CN":"消息发送失败"},
+    "drawer.delivery_failed_detail": {"ko":"전송 요청이 실패했습니다. AI는 이 메시지를 받지 못했을 수 있습니다.","en":"The send request failed. The AI may not have received this message.","zh-CN":"发送请求失败，AI 可能没有收到此消息。"},
+    "drawer.delivery_failed_with_reason": {"ko":"전송 요청이 실패했습니다: {reason}","en":"The send request failed: {reason}","zh-CN":"发送请求失败：{reason}"},
+    "drawer.delivery_observed_title": {"ko":"AI 세션이 실행 중입니다","en":"The AI session is running","zh-CN":"AI 会话正在运行"},
+    "drawer.delivery_observed_detail": {"ko":"대화 기록과 세션 실행 상태를 기준으로 확인했습니다. 이 앱에서 시작하지 않은 전송 단계는 추적하지 않습니다.","en":"Confirmed from the conversation log and session runtime state. Send steps started outside this app are not tracked.","zh-CN":"已根据对话记录和会话运行状态确认；不会跟踪在本应用之外发起的发送步骤。"},
+    "drawer.delivery_observed_message": {"ko":"대화 기록 확인","en":"Conversation log confirmed","zh-CN":"已确认对话记录"},
+    "drawer.delivery_observed_message_help": {"ko":"사용자 메시지가 실제 기록에 있습니다","en":"The user message exists in the actual log","zh-CN":"用户消息已存在于实际记录中"},
+    "drawer.delivery_observed_session": {"ko":"AI 실행 상태 확인","en":"AI runtime state confirmed","zh-CN":"已确认 AI 运行状态"},
+    "drawer.delivery_observed_session_help": {"ko":"현재 세션이 실행 중으로 관측됩니다","en":"The current session is observed as running","zh-CN":"当前会话被观察为正在运行"},
+    "drawer.delivery_evidence_sending": {"ko":"확인 근거 · 터미널 전송 요청 진행 중","en":"Evidence · terminal send request in progress","zh-CN":"确认依据 · 终端发送请求进行中"},
+    "drawer.delivery_evidence_confirming": {"ko":"확인 근거 · 전송 요청 성공, 대화 기록 미확인","en":"Evidence · send request succeeded, conversation log not yet confirmed","zh-CN":"确认依据 · 发送请求成功，对话记录尚未确认"},
+    "drawer.delivery_evidence_delayed": {"ko":"확인 근거 · 12초 이상 대화 기록에서 메시지 미발견","en":"Evidence · message absent from the conversation log for over 12 seconds","zh-CN":"确认依据 · 超过 12 秒未在对话记录中发现消息"},
+    "drawer.delivery_evidence_received": {"ko":"확인 근거 · 대화 기록에서 사용자 메시지 발견","en":"Evidence · user message found in the conversation log","zh-CN":"确认依据 · 已在对话记录中发现用户消息"},
+    "drawer.delivery_evidence_responding": {"ko":"확인 근거 · 사용자 메시지와 새 실행 시작 이벤트 발견","en":"Evidence · user message and new execution-start event observed","zh-CN":"确认依据 · 已发现用户消息和新的执行开始事件"},
+    "drawer.delivery_evidence_failed": {"ko":"확인 근거 · 터미널 전송 오류","en":"Evidence · terminal send error","zh-CN":"确认依据 · 终端发送错误"},
+    "drawer.delivery_evidence_observed": {"ko":"확인 근거 · 사용자 메시지 기록 + 세션 실행 상태","en":"Evidence · user-message log + session runtime state","zh-CN":"确认依据 · 用户消息记录 + 会话运行状态"},
+    "drawer.delivery_step_dispatch": {"ko":"앱에서 전송 요청","en":"Send request from app","zh-CN":"应用发起发送请求"},
+    "drawer.delivery_step_dispatch_help": {"ko":"관리 터미널에 메시지를 전달합니다","en":"Pass the message to the managed terminal","zh-CN":"将消息传递给托管终端"},
+    "drawer.delivery_step_received": {"ko":"AI 세션에서 수신 확인","en":"Confirm receipt in AI session","zh-CN":"确认 AI 会话接收"},
+    "drawer.delivery_step_received_help": {"ko":"실제 대화 기록에서 같은 메시지를 찾습니다","en":"Find the same message in the actual conversation log","zh-CN":"在实际对话记录中查找相同消息"},
+    "drawer.delivery_step_response": {"ko":"AI 응답 시작 확인","en":"Confirm AI response start","zh-CN":"确认 AI 开始回复"},
+    "drawer.delivery_step_response_help": {"ko":"새 실행 이벤트나 응답 메시지를 확인합니다","en":"Observe a new execution event or response message","zh-CN":"观察新的执行事件或回复消息"},
     "drawer.progress_updates": {"ko":"진행 업데이트 {count}개","en":"{count} progress updates","zh-CN":"{count} 条进度更新"},
     "drawer.progress_updates_help": {"ko":"중간 작업 설명과 원문 전체 보기","en":"View intermediate notes and full text","zh-CN":"查看中间说明和完整原文"},
     "drawer.progress_update_item": {"ko":"진행 {count}","en":"Update {count}","zh-CN":"进度 {count}"},
@@ -1371,6 +1407,12 @@
     "control.live_session": {"ko":"실행 중인 세션","en":"Live session","zh-CN":"运行中的会话"},
     "control.waiting_session": {"ko":"대기 중인 세션","en":"Waiting session","zh-CN":"等待中的会话"},
     "control.waiting_background_session": {"ko":"응답 대기 · 백그라운드 실행 중","en":"Waiting for response · background work running","zh-CN":"等待回复 · 后台任务运行中"},
+    "control.delivery_sending": {"ko":"메시지 전송 중","en":"Sending message","zh-CN":"正在发送消息"},
+    "control.delivery_confirming": {"ko":"AI 수신 확인 중","en":"Confirming AI receipt","zh-CN":"正在确认 AI 接收"},
+    "control.delivery_delayed": {"ko":"전달 확인 지연","en":"Delivery confirmation delayed","zh-CN":"发送确认延迟"},
+    "control.delivery_received": {"ko":"AI 메시지 수신 확인","en":"AI message receipt confirmed","zh-CN":"已确认 AI 接收消息"},
+    "control.delivery_responding": {"ko":"AI 응답 생성 중","en":"AI response in progress","zh-CN":"AI 正在生成回复"},
+    "control.delivery_failed": {"ko":"메시지 전송 실패","en":"Message send failed","zh-CN":"消息发送失败"},
     "control.auto_history_in_minutes": {"ko":"{minutes}분 뒤 지난 기록으로 이동","en":"Moves to history in {minutes} min","zh-CN":"{minutes} 分钟后移至历史记录"},
     "control.move_to_history": {"ko":"지난 기록으로 이동","en":"Move to history","zh-CN":"移至历史记录"},
     "control.project_group_actions": {"ko":"프로젝트 그룹 열기와 닫기","en":"Project group expand and collapse controls","zh-CN":"项目组展开和折叠控件"},

package/renderer/index.html

@@ -468,6 +468,7 @@
   <script src="../node_modules/@xterm/xterm/lib/xterm.js"></script>
   <script src="../node_modules/@xterm/addon-fit/lib/addon-fit.js"></script>
   <script src="i18n-messages.js"></script>
+  <script src="conversation-delivery.js"></script>
   <script src="i18n.js"></script>
   <script src="shared.js"></script>
   <script src="app.js"></script>

package/renderer/styles-components.css

@@ -525,6 +525,30 @@ button[aria-busy="true"] {
   animation: control-room-pulse 1s ease-in-out infinite;
 }
 
+.chat-delivery-status.confirming,
+.chat-delivery-status.received,
+.chat-delivery-status.responding {
+  background: rgba(91,169,255,.09);
+  color: #8fc3ff !important;
+}
+
+.chat-delivery-status.confirming::before,
+.chat-delivery-status.responding::before {
+  display: inline-block;
+  width: 5px;
+  height: 5px;
+  margin-right: 5px;
+  border-radius: 50%;
+  background: #71b2ff;
+  content: "";
+  animation: control-room-pulse 1s ease-in-out infinite;
+}
+
+.chat-delivery-status.delayed {
+  background: rgba(246,190,75,.11);
+  color: #f1c66f !important;
+}
+
 .chat-delivery-status.failed {
   background: rgba(255,107,127,.1);
   color: #ff9baa !important;
@@ -1120,100 +1144,177 @@ button[aria-busy="true"] {
   animation: control-room-pulse 1.35s ease-in-out infinite;
 }
 
-.chat-progress-updates {
+.chat-delivery-progress {
+  display: grid;
+  gap: 11px;
   margin-left: 43px;
-  border: 1px solid #263342;
-  border-radius: 11px;
-  background: #0a1017;
-  overflow: hidden;
+  padding: 13px;
+  border: 1px solid rgba(91,169,255,.24);
+  border-radius: 12px;
+  background: linear-gradient(145deg,rgba(35,76,125,.13),rgba(10,15,22,.76));
+  color: #b9c7d8;
 }
 
-.chat-progress-updates > summary {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  padding: 11px 13px;
-  cursor: pointer;
-  list-style: none;
+.chat-delivery-progress > header {
+  display: grid;
+  grid-template-columns: 8px minmax(0,1fr);
+  align-items: start;
+  gap: 9px;
 }
 
-.chat-progress-updates > summary::-webkit-details-marker {
-  display: none;
+.chat-delivery-progress > header > span {
+  width: 7px;
+  height: 7px;
+  margin-top: 5px;
+  border-radius: 50%;
+  background: #71b2ff;
+  box-shadow: 0 0 0 4px rgba(91,169,255,.09);
+  animation: control-room-pulse 1.35s ease-in-out infinite;
 }
 
-.chat-progress-updates > summary span,
-.chat-progress-updates > summary small {
-  display: block;
+.chat-delivery-progress > header > div {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
 }
 
-.chat-progress-updates > summary b {
-  color: #aebbc9;
+.chat-delivery-progress > header b {
+  color: #d8e6f7;
   font-size: 12px;
 }
 
-.chat-progress-updates > summary small {
-  margin-top: 3px;
-  color: #68778a;
-  font-size: 11px;
+.chat-delivery-progress > header small,
+.chat-delivery-progress li small,
+.chat-delivery-progress footer {
+  color: #8494a8;
+  font-size: 10px;
+  line-height: 1.5;
+}
+
+.chat-delivery-progress ol {
+  display: grid;
+  grid-template-columns: repeat(3,minmax(0,1fr));
+  gap: 7px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.chat-delivery-progress.phase-observed ol {
+  grid-template-columns: repeat(2,minmax(0,1fr));
+}
+
+.chat-delivery-progress li {
+  display: grid;
+  grid-template-columns: 22px minmax(0,1fr);
+  align-items: start;
+  gap: 7px;
+  min-width: 0;
+  padding: 8px;
+  border: 1px solid #202b38;
+  border-radius: 9px;
+  background: rgba(9,14,21,.62);
 }
 
-.chat-progress-updates > summary i {
+.chat-delivery-progress li > i {
+  width: 21px;
+  height: 21px;
+  display: grid;
+  place-items: center;
+  border: 1px solid #334154;
+  border-radius: 50%;
   color: #718196;
-  font-size: 12px;
+  font-size: 9px;
   font-style: normal;
-  transition: transform var(--motion-fast) ease;
+  font-weight: 800;
 }
 
-.chat-progress-updates[open] > summary i {
-  transform: rotate(180deg);
+.chat-delivery-progress li > span {
+  display: grid;
+  gap: 2px;
+  min-width: 0;
 }
 
-.chat-progress-list {
-  display: grid;
-  gap: 8px;
-  padding: 0 10px 10px;
+.chat-delivery-progress li b {
+  color: #aebdce;
+  font-size: 10px;
 }
 
-.chat-progress-list article {
-  padding: 10px;
-  border: 1px solid #202b38;
-  border-radius: 9px;
-  background: #0d141d;
+.chat-delivery-progress li.done {
+  border-color: rgba(89,223,167,.2);
+  background: rgba(35,104,78,.08);
 }
 
-.chat-progress-list article > header {
-  display: flex;
-  justify-content: space-between;
-  gap: 10px;
-  margin-bottom: 7px;
-  color: #7e8da0;
-  font-size: 11px;
+.chat-delivery-progress li.done > i {
+  border-color: rgba(89,223,167,.35);
+  background: rgba(89,223,167,.1);
+  color: #70d9ad;
 }
 
-.chat-progress-list .chat-content {
-  font-size: 12px;
+.chat-delivery-progress li.active {
+  border-color: rgba(91,169,255,.3);
+  background: rgba(48,102,171,.1);
+}
+
+.chat-delivery-progress li.active > i {
+  border-color: rgba(91,169,255,.48);
+  color: #8fc3ff;
+  animation: control-room-pulse 1.2s ease-in-out infinite;
+}
+
+.chat-delivery-progress li.warning {
+  border-color: rgba(246,190,75,.32);
+  background: rgba(116,80,17,.11);
 }
 
-.chat-turn-waiting {
+.chat-delivery-progress li.warning > i {
+  border-color: rgba(246,190,75,.46);
+  color: #f1c66f;
+}
+
+.chat-delivery-progress li.error {
+  border-color: rgba(255,107,127,.34);
+  background: rgba(94,31,44,.12);
+}
+
+.chat-delivery-progress li.error > i {
+  border-color: rgba(255,107,127,.46);
+  color: #ff9baa;
+}
+
+.chat-delivery-progress footer {
   display: flex;
   align-items: center;
-  gap: 8px;
-  margin-left: 43px;
-  padding: 11px 13px;
-  border: 1px solid rgba(71,214,153,.22);
-  border-radius: 10px;
-  background: rgba(34,118,83,.08);
-  color: #91bca9;
-  font-size: 12px;
+  gap: 6px;
+  padding-top: 9px;
+  border-top: 1px solid #1f2a37;
 }
 
-.chat-turn-waiting span {
-  width: 6px;
-  height: 6px;
-  border-radius: 50%;
-  background: #59dfa7;
-  animation: control-room-pulse 1.35s ease-in-out infinite;
+.chat-delivery-progress footer i {
+  color: #6e829a;
+  font-style: normal;
+}
+
+.chat-delivery-progress.phase-delayed {
+  border-color: rgba(246,190,75,.28);
+  background: linear-gradient(145deg,rgba(111,75,18,.13),rgba(10,15,22,.76));
+}
+
+.chat-delivery-progress.phase-delayed > header > span {
+  background: #efbd5d;
+  box-shadow: 0 0 0 4px rgba(246,190,75,.09);
+  animation: none;
+}
+
+.chat-delivery-progress.phase-failed {
+  border-color: rgba(255,107,127,.3);
+  background: linear-gradient(145deg,rgba(94,31,44,.14),rgba(10,15,22,.76));
+}
+
+.chat-delivery-progress.phase-failed > header > span {
+  background: #ff7e91;
+  box-shadow: 0 0 0 4px rgba(255,107,127,.08);
+  animation: none;
 }
 
 .subagent-call-moment {

package/renderer/styles-responsive-shell.css

@@ -405,8 +405,7 @@
     align-items: flex-start;
   }
 
-  .chat-progress-updates,
-  .chat-turn-waiting,
+  .chat-delivery-progress,
   .subagent-call-moment,
   .subagent-call-event {
     margin-left: 0;
@@ -417,6 +416,11 @@
     width: 100%;
   }
 
+  .chat-delivery-progress ol,
+  .chat-delivery-progress.phase-observed ol {
+    grid-template-columns: 1fr;
+  }
+
   .json-object>div {
     grid-template-columns: 1fr;
   }