loadtoagent 1.3.7 → 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/main.js

@@ -523,7 +523,7 @@ async function setupRuntime() {
 
 function bridgePresence() {
   if (!terminalManager) return [];
-  const environment = process.platform === 'win32' ? 'windows' : (process.platform === 'darwin' ? 'macos' : 'linux');
+  const localEnvironment = process.platform === 'win32' ? 'windows' : (process.platform === 'darwin' ? 'macos' : 'linux');
   return terminalManager.list()
     .filter(session => !session.transient && session.type === 'agent' && (session.status === 'running' || session.status === 'starting'))
     .map(session => ({
@@ -535,7 +535,8 @@ function bridgePresence() {
       pid: session.pid,
       cwd: session.cwd,
       startedAt: session.createdAt,
-      environment,
+      environment: session.distro && process.platform === 'win32' ? 'wsl' : localEnvironment,
+      distro: session.distro || '',
       kind: 'bridge',
       label: 'LoadToAgent 외부 터미널 브리지',
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loadtoagent",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "A local desktop dashboard for Claude, Codex, Gemini, and Grok sessions.",
   "main": "main.js",
   "author": "wincube AX",
@@ -43,6 +43,7 @@
   "scripts": {
     "start": "electron .",
     "test": "node scripts/regression-test.js",
+    "test:accuracy": "node scripts/accuracy-evaluation.js",
     "test:terminal": "electron scripts/terminal-integration-test.js",
     "test:terminal:mac-stress": "node scripts/mac-terminal-stress-check.js",
     "test:terminal-restart": "node scripts/terminal-restart-persistence-check.js",

package/renderer/app-agent-actions.js

@@ -12,6 +12,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     selectView,
     providerInfo,
     isLiveSession,
+    conversationMessageKey,
   } = context;
 
   function agentCommandTargets(session) {
@@ -91,6 +92,54 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     return session?.parentId ? `${session.id}:${route}` : session.id;
   }
 
+  function beginConversationMessage(session, command) {
+    const detail = state.details.get(session.id);
+    const baselineMessages = [...(session.messages || []), ...(detail?.messages || [])];
+    const entry = {
+      id: `local:${session.id}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`,
+      text: command,
+      timestamp: new Date().toISOString(),
+      status: "sending",
+      phase: "sending",
+      dispatchedAt: null,
+      presented: false,
+      baselineMessageKeys: new Set(baselineMessages.map(conversationMessageKey)),
+    };
+    const pending = state.pendingConversationMessages.get(session.id) || [];
+    pending.push(entry);
+    state.pendingConversationMessages.set(session.id, pending);
+    state.drawerForceLatest = true;
+    context.renderDrawer?.();
+    return entry;
+  }
+
+  function updateConversationMessage(sessionId, entry, status, error = "") {
+    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?.();
+  }
+
   function agentControlMode(session, targets) {
     if (targets.length && isLiveSession(session)) return "direct";
     const resume = agentResumeSupport(session);
@@ -194,7 +243,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     const placeholder = editable ? t(options.conversation ? "agent.conversation_placeholder" : "agent.command_example") : status;
     const availabilityClass = mode === "direct" ? "connected" : ["resume", "handoff", "origin-resume"].includes(mode) ? "resume-ready" : "unavailable";
     return `<form class="agent-command-panel ${availabilityClass} control-${mode} ${options.conversation ? "conversation-composer" : ""}"
-      data-agent-command-form="${esc(session.id)}" data-agent-command-route-selected="${esc(route)}" data-agent-command-routing="${routingEnabled ? "conversation" : "session"}">
+      data-agent-command-form="${esc(session.id)}" data-agent-command-route-selected="${esc(route)}" data-agent-command-routing="${options.conversation ? "conversation" : "session"}">
       <header>
         <span class="agent-command-icon" aria-hidden="true">›_</span>
         <span><b>${esc(t(options.conversation ? "agent.conversation_title" : "agent.command_title"))}</b><small>${esc(status)}</small></span>
@@ -255,7 +304,8 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (state.agentCommandSending.has(sessionId)) return;
     const session = snapshotSession(sessionId);
     if (!session || !window.LoadToAgentTerminal) return context.toast(t("agent.latest_not_found"));
-    const routingEnabled = form?.dataset.agentCommandRouting === "conversation" && Boolean(session.parentId);
+    const conversationSubmission = form?.dataset.agentCommandRouting === "conversation";
+    const routingEnabled = conversationSubmission && Boolean(session.parentId);
     const requestedRoute = routingEnabled ? form?.dataset.agentCommandRouteSelected || selectedAgentCommandRoute(session) : "direct";
     const routeContext = routingEnabled
       ? routedAgentCommandContext(session, requestedRoute)
@@ -274,26 +324,20 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (mode === "resume" || mode === "handoff" || mode === "origin-resume") {
       if (input) state.agentCommandDrafts.set(sessionId, input.value);
       if (!command) return context.toast(t("agent.enter_command"));
-      if (routingEnabled && routeContext.route === "parent") {
+      if (conversationSubmission) {
         state.agentCommandSending.add(sessionId);
-        const submit = form.querySelector('[type="submit"]');
-        if (submit) {
-          submit.disabled = true;
-          submit.textContent = t("agent.sending");
-        }
+        const pendingMessage = beginConversationMessage(session, command);
         try {
           await window.LoadToAgentTerminal.resumeForAgent(targetSession, routedCommand, true, { focus: false });
           state.agentCommandDrafts.delete(sessionId);
-          if (input) input.value = "";
-          context.toast(t("agent.command_routed_via_parent"));
+          updateConversationMessage(sessionId, pendingMessage, "awaiting");
+          context.toast(t(routingEnabled && routeContext.route === "parent" ? "agent.command_routed_via_parent" : "agent.command_sent_background"));
         } catch (error) {
+          updateConversationMessage(sessionId, pendingMessage, "failed", errorText(error, "agent.send_failed"));
           context.toast(errorText(error, "agent.send_failed"));
         } finally {
           state.agentCommandSending.delete(sessionId);
-          if (submit && submit.isConnected) {
-            submit.disabled = false;
-            submit.textContent = t("agent.send_via_parent");
-          }
+          context.renderDrawer?.();
         }
         return;
       }
@@ -307,6 +351,8 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       return context.toast(t(agentCommandTargets(session).length ? "agent.select_target_first" : "agent.no_writable_terminal"));
     if (!command) return context.toast(t("agent.enter_command"));
     state.agentCommandSending.add(sessionId);
+    if (input) state.agentCommandDrafts.set(sessionId, input.value);
+    const pendingMessage = conversationSubmission ? beginConversationMessage(session, command) : null;
     const submit = form.querySelector('[type="submit"]');
     if (submit) {
       submit.disabled = true;
@@ -316,28 +362,33 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       await window.LoadToAgentTerminal.dispatchAgentCommand(targetSession, routedCommand, target.id);
       state.agentCommandDrafts.delete(sessionId);
       if (input) input.value = "";
+      updateConversationMessage(sessionId, pendingMessage, "awaiting");
       context.toast(t(routingEnabled && routeContext.route === "parent" ? "agent.command_routed_via_parent" : "agent.command_sent", { target: target.label }));
     } catch (error) {
-      if (session.parentId) {
-        context.toast(errorText(error, "agent.send_failed"));
-        return;
-      }
-      const latest = snapshotSession(sessionId) || session;
+      const latest = snapshotSession(targetSession.id) || targetSession;
       const support = agentResumeSupport(latest);
-      if (!agentCommandTargets(latest).length && support.supported) {
+      const shouldRecover = support.supported
+        && (conversationSubmission || !agentCommandTargets(latest).length);
+      if (shouldRecover) {
         try {
           state.agentCommandDrafts.set(sessionId, command);
-          await window.LoadToAgentTerminal.resumeForAgent(latest, command, true);
+          await window.LoadToAgentTerminal.resumeForAgent(latest, routedCommand, true, { focus: conversationSubmission ? false : true });
           state.agentCommandDrafts.delete(sessionId);
           if (input) input.value = "";
+          updateConversationMessage(sessionId, pendingMessage, "awaiting");
           context.toast(t("agent.recovered_and_sent"));
           return;
         } catch (resumeError) {
+          updateConversationMessage(sessionId, pendingMessage, "failed", errorText(resumeError, "agent.recovery_failed"));
           context.toast(errorText(resumeError, "agent.recovery_failed"));
         }
-      } else context.toast(errorText(error, "agent.send_failed"));
+      } else {
+        updateConversationMessage(sessionId, pendingMessage, "failed", errorText(error, "agent.send_failed"));
+        context.toast(errorText(error, "agent.send_failed"));
+      }
     } finally {
       state.agentCommandSending.delete(sessionId);
+      if (conversationSubmission) context.renderDrawer?.();
       if (submit && submit.isConnected) {
         submit.disabled = false;
         submit.textContent = t(routingEnabled && routeContext.route === "parent" ? "agent.send_via_parent" : "agent.send_now");

package/renderer/app-dashboard.js

@@ -51,7 +51,11 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
   }
 
   function normalizedProjectPath(value) {
-    return String(value || "").trim().replace(/\\/g, "/").replace(/\/+$/, "").toLocaleLowerCase();
+    let normalized = String(value || "").trim().replace(/\\/g, "/");
+    normalized = normalized.replace(/^\/\/\?\/([a-z]:\/)/i, "$1");
+    const wslWindowsMount = normalized.match(/^\/mnt\/([a-z])(?:\/(.*))?$/i);
+    if (wslWindowsMount) normalized = `${wslWindowsMount[1]}:/${wslWindowsMount[2] || ""}`;
+    return normalized.replace(/\/+$/, "").toLocaleLowerCase();
   }
 
   function projectContainsPath(projectPath, candidatePath) {
@@ -67,8 +71,15 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
 
   function observedProjects(sessions = displaySessions().filter((session) => !session.parentId)) {
     const projects = new Map();
-    const saved = state.workspaces.map((item) => ({ ...item, key: normalizedProjectPath(item.path) }));
-    saved.forEach((item) => projects.set(item.key, { path: item.path, name: item.name || projectName(item.path), saved: true, count: 0 }));
+    const saved = state.workspaces.map((item, index) => ({ ...item, key: normalizedProjectPath(item.path), order: index }));
+    saved.forEach((item) => projects.set(item.key, {
+      path: item.path,
+      name: item.name || projectName(item.path),
+      saved: true,
+      order: item.order,
+      count: 0,
+      liveCount: 0,
+    }));
     sessions.filter((session) => !session.parentId && !isProjectlessSession(session)).forEach((session) => {
       const originPath = sessionOriginPath(session);
       if (!originPath) return;
@@ -77,8 +88,16 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
         .sort((a, b) => b.key.length - a.key.length)[0];
       const path = owner ? owner.path : originPath;
       const key = normalizedProjectPath(path);
-      const project = projects.get(key) || { path, name: projectName(path), saved: false, count: 0 };
+      const project = projects.get(key) || {
+        path,
+        name: projectName(path),
+        saved: false,
+        order: Number.MAX_SAFE_INTEGER,
+        count: 0,
+        liveCount: 0,
+      };
       project.count += 1;
+      if (isControlRoomSession(session)) project.liveCount += 1;
       project.lastActivityAt = !project.lastActivityAt || Date.parse(session.updatedAt || 0) > Date.parse(project.lastActivityAt || 0)
         ? session.updatedAt
         : project.lastActivityAt;
@@ -93,7 +112,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
       item.name = parts.slice(-2).join("/") || item.name;
     });
     return items.sort((a, b) => Number(b.count || 0) - Number(a.count || 0)
-      || Number(b.saved) - Number(a.saved)
+      || Number(a.order ?? Number.MAX_SAFE_INTEGER) - Number(b.order ?? Number.MAX_SAFE_INTEGER)
       || String(a.name).localeCompare(String(b.name), uiLocale()));
   }
 
@@ -130,24 +149,20 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     const rootSessions = displaySessions().filter((session) => !session.parentId);
     const liveRootSessions = rootSessions.filter(isControlRoomSession);
     const projects = observedProjects(rootSessions);
-    const savedProjectOrder = new Map(state.workspaces.map((workspace, index) => [normalizedProjectPath(workspace.path), index]));
-    const liveProjects = observedProjects(liveRootSessions).sort((a, b) => {
-      const aOrder = savedProjectOrder.get(normalizedProjectPath(a.path));
-      const bOrder = savedProjectOrder.get(normalizedProjectPath(b.path));
-      if (aOrder != null || bOrder != null) return (aOrder ?? Number.MAX_SAFE_INTEGER) - (bOrder ?? Number.MAX_SAFE_INTEGER);
-      return Number(b.count || 0) - Number(a.count || 0) || String(a.name).localeCompare(String(b.name), uiLocale());
-    });
+    const liveProjects = observedProjects(liveRootSessions);
     const projectlessCount = rootSessions.filter(isProjectlessSession).length;
     const liveProjectlessCount = liveRootSessions.filter(isProjectlessSession).length;
     const savedWorkspaceExists = state.workspace === "all"
       || (state.workspace === PROJECTLESS_WORKSPACE && projectlessCount > 0)
       || projects.some((project) => normalizedProjectPath(project.path) === normalizedProjectPath(state.workspace));
     if (!savedWorkspaceExists) state.workspace = "all";
-    const projectButton = (item, compactClass = "") => `<button type="button" class="workspace-item observed-project ${compactClass} ${state.workspace === item.path ? "selected" : ""}"
+    const projectButton = (item, compactClass = "") => `<button type="button" class="workspace-item observed-project ${compactClass} ${Number(item.liveCount || 0) ? "has-live-sessions" : ""} ${state.workspace === item.path ? "selected" : ""}"
       data-workspace="${esc(item.path)}" title="${esc(item.path)}"
+      data-live-session-count="${Number(item.liveCount || 0)}"
       aria-label="${esc(t("project.filter_named", { name: item.name, count: item.count }))}"
       aria-pressed="${state.workspace === item.path ? "true" : "false"}">
       <strong>${esc(item.name)}</strong><small>${Number(item.count || 0)}</small>
+      ${Number(item.liveCount || 0) ? `<span class="workspace-live-state" title="${esc(t("project.in_progress"))}"><i aria-hidden="true"></i><b>${esc(t("project.in_progress"))}</b></span>` : ""}
       </button>`;
     const mobileHtml =
       `<button type="button" class="workspace-item ${state.workspace === "all" ? "selected" : ""}"
@@ -551,6 +566,32 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     return true;
   }
 
+  function ensureProjectOrder(projectKeys = []) {
+    if (!Array.isArray(state.projectOrder)) state.projectOrder = [];
+    const known = new Set(state.projectOrder);
+    for (const value of projectKeys) {
+      const key = String(value || "");
+      if (!key || known.has(key)) continue;
+      state.projectOrder.push(key);
+      known.add(key);
+    }
+    return state.projectOrder;
+  }
+
+  function moveProjectOrder(sourceId, targetId, placeAfter = false) {
+    const source = String(sourceId || "");
+    const target = String(targetId || "");
+    if (!source || !target || source === target) return false;
+    const order = ensureProjectOrder([source, target]);
+    const sourceIndex = order.indexOf(source);
+    if (sourceIndex < 0 || !order.includes(target)) return false;
+    order.splice(sourceIndex, 1);
+    const targetIndex = order.indexOf(target);
+    order.splice(targetIndex + (placeAfter ? 1 : 0), 0, source);
+    state.projectOrder = order;
+    return true;
+  }
+
   function graphFilteredSessions() {
     let sessions = displaySessions();
     if (state.providerFilters.size) sessions = sessions.filter((session) => state.providerFilters.has(session.provider));
@@ -607,6 +648,8 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     graphFilteredSessions,
     stableSessionSort,
     moveSessionOrder,
+    ensureProjectOrder,
+    moveProjectOrder,
     renderProviderVisibilitySettings,
   };
 };