loadtoagent 1.3.7 → 1.3.9

package/renderer/app-graph-orchestration.js

@@ -25,6 +25,14 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
   } = context;
   const t = (key, params) => window.LoadToAgentI18n.t(key, params);
 
+  function syncControlRoomDisclosureButtons() {
+    const groups = Array.from(document.querySelectorAll("#liveSessionGrid .control-room-project-group"));
+    const canExpand = groups.some(group => !group.open);
+    const canCollapse = groups.some(group => group.open);
+    if ($("#controlRoomExpandAll")) $("#controlRoomExpandAll").disabled = !canExpand;
+    if ($("#controlRoomCollapseAll")) $("#controlRoomCollapseAll").disabled = !canCollapse;
+  }
+
   function renderAgentMap(sessions, motionKind = "refresh") {
     const liveSessionGrid = $("#liveSessionGrid");
     rememberDisclosureStates(liveSessionGrid);
@@ -45,9 +53,7 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       $("#agentMapToolbar")?.classList.add("hidden");
       $("#controlRoomProjectToolbar")?.classList.remove("hidden");
       $("#controlRoomListToolbar")?.classList.remove("hidden");
-      if ($("#controlRoomPageSummary")) $("#controlRoomPageSummary").textContent = t("control.page_summary", { start: 0, end: 0, total: 0 });
-      if ($("#controlRoomPagePrev")) $("#controlRoomPagePrev").disabled = true;
-      if ($("#controlRoomPageNext")) $("#controlRoomPageNext").disabled = true;
+      syncControlRoomDisclosureButtons();
       return 0;
     }
 
@@ -71,30 +77,18 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       scheduleAgentWorkflowConnections();
     } else {
       const runtime = runtimeAgentSummary(model, liveTmuxEntries(state.snapshot && state.snapshot.tmux));
-      const pageSize = Math.max(1, Number(state.controlRoomPageSize || 4));
-      const maxPage = Math.max(0, Math.ceil(roots.length / pageSize) - 1);
-      state.controlRoomPage = Math.min(maxPage, Math.max(0, Number(state.controlRoomPage || 0)));
-      const startIndex = state.controlRoomPage * pageSize;
-      const endIndex = Math.min(roots.length, startIndex + pageSize);
-      const visibleRoots = roots.slice(startIndex, endIndex);
-      liveSessionGrid.innerHTML = runtimeSeparatedOverview(visibleRoots, model, roots);
+      liveSessionGrid.innerHTML = runtimeSeparatedOverview(roots, model, roots);
       restoreDisclosureStates(liveSessionGrid);
       $("#graphBreadcrumbs").innerHTML = "";
       $("#agentMapToolbar")?.classList.add("hidden");
       $("#controlRoomProjectToolbar")?.classList.remove("hidden");
       $("#controlRoomListToolbar")?.classList.remove("hidden");
-      if ($("#controlRoomPageSummary")) $("#controlRoomPageSummary").textContent = t("control.page_summary", {
-        start: roots.length ? startIndex + 1 : 0,
-        end: endIndex,
-        total: roots.length,
-      });
-      if ($("#controlRoomPagePrev")) $("#controlRoomPagePrev").disabled = state.controlRoomPage === 0;
-      if ($("#controlRoomPageNext")) $("#controlRoomPageNext").disabled = state.controlRoomPage >= maxPage;
+      syncControlRoomDisclosureButtons();
       $("#graphResetBtn").classList.add("hidden");
       return runtime.activeCount;
     }
     return model.nodes.filter(isControlRoomSession).length;
   }
 
-  return { renderAgentMap };
+  return { renderAgentMap, syncControlRoomDisclosureButtons };
 };

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,
@@ -34,12 +35,29 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     graphDescendantCount,
     sessionWorkspaceLabel,
     controlRoomProject = session => ({ key: String(session?.workspace || session?.id || "unknown"), label: sessionWorkspaceLabel(session) }),
+    ensureProjectOrder = projectKeys => projectKeys,
   } = context;
   const t = (key, params) => window.LoadToAgentI18n.t(key, params);
   const statusLabel = (status) => ({
     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);
@@ -49,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;
@@ -61,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", {
@@ -78,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"
@@ -123,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) });
@@ -131,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"
@@ -196,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>`;
   }
 
@@ -446,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 })));
@@ -462,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>
@@ -483,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" : "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)}"
@@ -519,20 +542,30 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
       if (!groups.has(key)) groups.set(key, { name, roots: [] });
       groups.get(key).roots.push(root);
     });
-    const projectGroups = [...groups.entries()].map(([key, { name, roots: projectRoots }], index) => {
+    const defaultOrderedGroups = [...groups.entries()].sort(([leftKey], [rightKey]) =>
+      Number(allGroups.get(rightKey)?.roots.length || 0) - Number(allGroups.get(leftKey)?.roots.length || 0));
+    const projectOrder = ensureProjectOrder(defaultOrderedGroups.map(([key]) => key));
+    const projectRank = new Map(projectOrder.map((key, index) => [key, index]));
+    const orderedGroups = defaultOrderedGroups.sort(([leftKey], [rightKey]) =>
+      Number(projectRank.get(leftKey) ?? Number.MAX_SAFE_INTEGER) - Number(projectRank.get(rightKey) ?? Number.MAX_SAFE_INTEGER));
+    const projectGroups = orderedGroups.map(([key, { name, roots: projectRoots }], index) => {
       const projectTotals = allGroups.get(key)?.roots || projectRoots;
       const activeCount = projectTotals.filter((root) => isLiveSession(root)).length;
-      const attentionCount = projectTotals.filter((root) => !isLiveSession(root) && isControlRoomSession(root)).length;
+      const attentionCount = projectTotals.filter((root) =>
+        !isLiveSession(root)
+        && isControlRoomSession(root)
+        && ["waiting", "failed", "paused"].includes(root.status)).length;
       const summary = attentionCount
         ? t("control.project_live_attention_summary", { active: activeCount, attention: attentionCount })
         : t("control.project_live_summary", { active: activeCount });
       const disclosureKey = `control-project:${key}`;
       const presentation = index === 0 ? "is-primary" : "is-secondary";
       const projectFocusId = projectRoots[0]?.id || "";
-      return `<details class="control-room-project-group ${presentation}" data-control-project="${esc(name)}" data-disclosure-key="${esc(disclosureKey)}" ${index === 0 ? "open" : ""}>
-        <summary class="control-project-header" data-project-toggle="${esc(name)}">
+      return `<details class="control-room-project-group ${presentation}" data-control-project="${esc(name)}" data-project-sortable="${esc(key)}" data-disclosure-key="${esc(disclosureKey)}">
+        <summary class="control-project-header" data-project-toggle="${esc(name)}" draggable="true" aria-grabbed="false"
+          aria-keyshortcuts="Alt+ArrowUp Alt+ArrowDown" aria-label="${esc(t("project.drag_label", { name }))}" aria-describedby="projectReorderHelp">
           <span class="control-project-heading"><i aria-hidden="true">□</i><b>${esc(name)}</b><small>${esc(summary)}</small><em>${projectTotals.length}</em></span>
-          <span class="control-project-handle" role="img" aria-label="프로젝트 그룹" title="프로젝트 그룹 · 세션은 최근 활동순으로 표시됩니다"></span>
+          <span class="control-project-handle" aria-hidden="true" title="${esc(t("project.reorder_hint"))}"></span>
         </summary>
         <button type="button" class="control-project-flow-link" data-graph-focus="${esc(projectFocusId)}"><span>${esc(t("control.open_full_flow"))} ↗</span></button>
         <div class="control-project-body">${projectRoots.map(root => controlRoomSession(root, model)).join("")}</div>

package/renderer/app-quality.js

@@ -98,12 +98,16 @@ window.LoadToAgentAppFactories.createQualityEnhancements = function createQualit
       state.sessionOrder = Array.isArray(dashboard.sessionOrder)
         ? dashboard.sessionOrder.filter(id => typeof id === "string" && id.length <= 500).slice(0, 1_000)
         : [];
+      state.projectOrder = Array.isArray(dashboard.projectOrder)
+        ? dashboard.projectOrder.filter(id => typeof id === "string" && id.length <= 2_000).slice(0, 1_000)
+        : [];
     } else {
       state.search = "";
       state.providerFilters.clear();
       state.workspace = "all";
       state.sort = "recent";
       state.sessionOrder = [];
+      state.projectOrder = [];
     }
     const search = $("#searchInput");
     if (search) search.value = state.search;
@@ -133,6 +137,7 @@ window.LoadToAgentAppFactories.createQualityEnhancements = function createQualit
       sort: ["recent", "tokens", "context"].includes(state.sort) ? state.sort : "recent",
       controlRoomSort: ["recent", "tokens", "context"].includes(state.controlRoomSort) ? state.controlRoomSort : "recent",
       sessionOrder: (state.sessionOrder || []).filter(id => typeof id === "string" && id.length <= 500).slice(0, 1_000),
+      projectOrder: (state.projectOrder || []).filter(id => typeof id === "string" && id.length <= 2_000).slice(0, 1_000),
     };
     try {
       localStorage.setItem(DASHBOARD_STORAGE_KEY, JSON.stringify(value));

package/renderer/app.js

@@ -24,6 +24,7 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     search: "",
     sort: "recent",
     sessionOrder: [],
+    projectOrder: [],
     sessionArchives: new Map(),
     controlRoomObservedIds: new Set(),
     selectedId: null,
@@ -36,8 +37,6 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     drawerForceLatest: false,
     visibleLimit: 30,
     graphFocusId: null,
-    controlRoomPage: 0,
-    controlRoomPageSize: 4,
     controlRoomSort: "recent",
     supervisionFocusId: null,
     graphExpandedProviders: new Set(),
@@ -50,6 +49,7 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     agentCommandTargets: new Map(),
     agentCommandRoutes: new Map(),
     agentCommandSending: new Set(),
+    pendingConversationMessages: new Map(),
     stopRequests: new Set(),
     runControlRequests: new Set(),
     managementFilter: "all",
@@ -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,14 +662,22 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
   }
   function isControlRoomSession(session, now = Date.now()) {
     if (!session) return false;
-    if (isLiveSession(session) || hasRunningExecution(session)) {
+    if (pendingConversationDelivery(session, now)) {
+      state.controlRoomObservedIds.add(String(session.id || ""));
+      return true;
+    }
+    if (isLiveSession(session)) {
+      state.controlRoomObservedIds.add(String(session.id || ""));
+      return true;
+    }
+    if (isSessionManuallyArchived(session)) return false;
+    if (hasRunningExecution(session)) {
       state.controlRoomObservedIds.add(String(session.id || ""));
       return true;
     }
     if (!state.controlRoomObservedIds.has(String(session.id || ""))) return false;
     const responseAt = sessionResponseTimestamp(session);
     const retained = Boolean(responseAt
-      && !isSessionManuallyArchived(session)
       && Math.max(0, Number(now) - responseAt) < SESSION_RETENTION_MS);
     if (!retained && responseAt && Math.max(0, Number(now) - responseAt) >= SESSION_RETENTION_MS) {
       state.controlRoomObservedIds.delete(String(session.id || ""));
@@ -629,7 +685,11 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     return retained;
   }
   function controlRoomStatus(session, now = Date.now()) {
-    return isLiveSession(session) ? session.status : (isControlRoomSession(session, now) ? "waiting" : session?.status);
+    // Retention controls where a recently active session is shown, not what
+    // state it is in. Preserve the observed provider status so an idle or
+    // completed session is never presented as waiting for user input.
+    isControlRoomSession(session, now);
+    return session?.status;
   }
   function sessionRetentionMinutes(session, now = Date.now()) {
     const remaining = SESSION_RETENTION_MS - Math.max(0, Number(now) - sessionResponseTimestamp(session));
@@ -778,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

@@ -213,6 +213,7 @@
     "project.all": {"ko":"모든 프로젝트 폴더","en":"All project folders","zh-CN":"所有项目文件夹"},
     "project.empty": {"ko":"AI 세션이 감지되면 작업 시작 폴더별로 자동 분류됩니다.","en":"Detected AI sessions are grouped automatically by their work-origin folder.","zh-CN":"检测到 AI 会话后，将按任务起始文件夹自动分组。"},
     "project.filter_named": {"ko":"{name} 폴더에서 시작한 AI 세션 {count}개 보기","en":"Show {count} AI sessions started from the {name} folder","zh-CN":"查看从 {name} 文件夹启动的 {count} 个 AI 会话"},
+    "project.in_progress": {"ko":"진행 중","en":"In progress","zh-CN":"进行中"},
     "project.origin": {"ko":"작업 시작 폴더","en":"Work origin folder","zh-CN":"任务起始文件夹"},
     "project.origin_named": {"ko":"작업 시작 폴더 · {name}","en":"Work origin folder · {name}","zh-CN":"任务起始文件夹 · {name}"},
     "bootstrap.module_missing": {"ko":"앱 모듈을 찾지 못했습니다: {name}","en":"App module not found: {name}","zh-CN":"找不到应用模块：{name}"},
@@ -256,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":"通过已连接的输入通道发送指令"},
@@ -285,6 +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":"전송 요청을 보냈습니다. 실제 수신과 응답 시작은 대화 상태에서 확인합니다.","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":"无法向终端发送指令。"},
@@ -348,6 +350,45 @@
     "drawer.current_progress": {"ko":"현재 진행 상황","en":"Current progress","zh-CN":"当前进度"},
     "drawer.last_progress": {"ko":"마지막 진행 상황","en":"Latest progress","zh-CN":"最近进度"},
     "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}"},
@@ -438,6 +479,10 @@
     "session.reorder_hint": {"ko":"끌어서 위치 변경 · Alt+↑/↓ 키도 사용 가능","en":"Drag to reorder · Alt+↑/↓ also works","zh-CN":"拖动调整位置 · 也可使用 Alt+↑/↓"},
     "session.reorder_help": {"ko":"세션 카드를 끌어 놓아 위치를 바꿀 수 있습니다. 키보드에서는 카드에 초점을 둔 뒤 Alt와 위아래 화살표 키를 사용하세요.","en":"Drag and drop a session card to change its position. With a keyboard, focus the card and use Alt with the up or down arrow key.","zh-CN":"拖放会话卡片可调整位置。使用键盘时，请聚焦卡片并按 Alt 加上或下方向键。"},
     "session.position_changed": {"ko":"세션 위치를 변경했습니다.","en":"Session position updated.","zh-CN":"会话位置已更新。"},
+    "project.drag_label": {"ko":"{name} 프로젝트 위치 변경","en":"Reorder {name} project","zh-CN":"调整 {name} 项目的位置"},
+    "project.reorder_hint": {"ko":"끌어서 프로젝트 위치 변경 · 닫힌 상태와 Alt+↑/↓ 키도 지원","en":"Drag to reorder · works while collapsed and with Alt+↑/↓","zh-CN":"拖动调整项目位置 · 折叠状态及 Alt+↑/↓ 均可用"},
+    "project.reorder_help": {"ko":"프로젝트 헤더를 끌어 놓아 위치를 바꿀 수 있습니다. 프로젝트가 닫혀 있어도 이동할 수 있으며, 키보드에서는 헤더에 초점을 둔 뒤 Alt와 위아래 화살표 키를 사용하세요.","en":"Drag and drop a project header to change its position, even while collapsed. With a keyboard, focus the header and use Alt with the up or down arrow key.","zh-CN":"拖放项目标题可调整位置，折叠时也可以操作。使用键盘时，请聚焦标题并按 Alt 加上或下方向键。"},
+    "project.position_changed": {"ko":"프로젝트 위치를 변경했습니다.","en":"Project position updated.","zh-CN":"项目位置已更新。"},
     "bootstrap.open_in_app": {"ko":"LoadToAgent 프로그램에서 열면 이 컴퓨터의 AI 작업 기록을 불러옵니다.","en":"Open this page in LoadToAgent to load AI work history from this computer.","zh-CN":"请在 LoadToAgent 应用中打开此页面，以加载此电脑上的 AI 工作记录。"},
     "bootstrap.opened_attention_list": {"ko":"확인이 필요한 세션 목록을 열었습니다.","en":"Opened the list of sessions that need your review.","zh-CN":"已打开需要您确认的会话列表。"},
     "bootstrap.initialization_failed": {"ko":"초기화 실패: {message}","en":"Initialization failed: {message}","zh-CN":"初始化失败：{message}"},
@@ -698,6 +743,7 @@
     "terminal.agent.no_input_target": {"ko":"이 AI가 실행 중인 입력 가능한 터미널을 찾지 못했습니다. 외부 터미널에서 시작한 AI는 LoadToAgent가 직접 입력할 수 없습니다.","en":"No active terminal that accepts input was found for this AI. LoadToAgent cannot type into an AI started in an external terminal.","zh-CN":"找不到此 AI 正在运行且可输入的终端。LoadToAgent 无法直接向在外部终端中启动的 AI 输入内容。"},
     "terminal.agent.reconnected": {"ko":"{provider} 세션 {sessionId}을 다시 연결했습니다. 이어서 지시할 수 있습니다.","en":"Reconnected {provider} session {sessionId}. You can continue giving instructions.","zh-CN":"已重新连接 {provider} 会话 {sessionId}，您可以继续发出指令。"},
     "terminal.agent.resume_terminal_failed": {"ko":"AI 세션을 재개할 터미널을 만들지 못했습니다.","en":"Could not create a terminal to resume the AI session.","zh-CN":"无法创建用于恢复 AI 会话的终端。"},
+    "terminal.agent.wsl_distro_missing": {"ko":"이 세션은 WSL에서 시작됐지만 사용할 Linux 배포판을 확인할 수 없습니다. tmux 화면을 새로고침한 뒤 다시 시도해 주세요.","en":"This session started in WSL, but its Linux distribution could not be identified. Refresh the tmux view and try again.","zh-CN":"此会话在 WSL 中启动，但无法识别其 Linux 发行版。请刷新 tmux 视图后重试。"},
     "terminal.agent.resume_title": {"ko":"{provider} · {session} 이어서 작업","en":"{provider} · Continue {session}","zh-CN":"{provider} · 继续 {session}"},
     "terminal.agent.resumed_and_sent": {"ko":"{provider} 세션 {sessionId}을 이어받아 지시를 보냈습니다.","en":"Resumed {provider} session {sessionId} and sent the instructions.","zh-CN":"已恢复 {provider} 会话 {sessionId} 并发送指令。"},
     "terminal.agent.select_target": {"ko":"지시를 보낼 터미널을 먼저 선택하세요.","en":"Select the terminal to send instructions to first.","zh-CN":"请先选择要发送指令的终端。"},
@@ -1361,8 +1407,19 @@
     "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":"项目组展开和折叠控件"},
+    "control.expand_all_projects": {"ko":"모두 열기","en":"Expand all","zh-CN":"全部展开"},
+    "control.collapse_all_projects": {"ko":"모두 닫기","en":"Collapse all","zh-CN":"全部折叠"},
+    "control.all_projects_expanded": {"ko":"모든 프로젝트 그룹을 열었습니다.","en":"Expanded all project groups.","zh-CN":"已展开所有项目组。"},
+    "control.all_projects_collapsed": {"ko":"모든 프로젝트 그룹을 닫았습니다.","en":"Collapsed all project groups.","zh-CN":"已折叠所有项目组。"},
     "control.moved_to_history": {"ko":"세션을 지난 기록으로 옮겼습니다.","en":"Session moved to history.","zh-CN":"会话已移至历史记录。"},
     "control.live_summary": {"ko":"메인 {sessions} · 서브 {helpers} · 실행 {executions}","en":"{sessions} lead · {helpers} helper · {executions} commands","zh-CN":"主 {sessions} · 协助 {helpers} · 执行 {executions}"},
     "control.main_assignment": {"ko":"메인 에이전트가 시킨 일","en":"Assigned by the lead agent","zh-CN":"主智能体分配的任务"},