loadtoagent 1.3.11 → 1.3.12

package/package.json

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

package/renderer/app-dashboard.js

@@ -145,16 +145,53 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     return !isProjectlessSession(session) && projectContainsPath(state.workspace, sessionOriginPath(session));
   }
 
+  function unlinkedLiveTmuxSessions() {
+    const displayedSessionIds = new Set(displaySessions().map((session) => String(session.id || "")));
+    const allSessionsById = new Map((state.snapshot?.sessions || []).map((session) => [String(session.id || ""), session]));
+    const sessions = [];
+    for (const distro of state.snapshot?.tmux?.distros || []) {
+      for (const tmuxSession of distro.sessions || []) {
+        for (const window of tmuxSession.windows || []) {
+          for (const pane of window.panes || []) {
+            if (!pane.agent || pane.dead || !pane.cwd || !isProviderVisible(pane.agent.provider)) continue;
+            const linkedSessionId = String(pane.agent.linkedSessionId || "");
+            const linkedSession = linkedSessionId ? allSessionsById.get(linkedSessionId) : null;
+            if (linkedSessionId && displayedSessionIds.has(linkedSessionId)) continue;
+            // A tmux process can remain alive for days after its linked AI task
+            // becomes idle. Do not promote that stale shell back into the Home
+            // project count merely because the old conversation aged out of the
+            // recent-session list. A still-running linked task remains eligible.
+            if (linkedSession && !isControlRoomSession(linkedSession)) continue;
+            sessions.push({
+              id: `tmux:${pane.id}`,
+              provider: pane.agent.provider,
+              status: "running",
+              originCwd: pane.cwd,
+              cwd: pane.cwd,
+              workspace: tmuxSession.name,
+              title: pane.agent.title || tmuxSession.name,
+            });
+          }
+        }
+      }
+    }
+    return sessions;
+  }
+
   function renderWorkspaces() {
     const rootSessions = displaySessions().filter((session) => !session.parentId);
     const liveRootSessions = rootSessions.filter(isControlRoomSession);
+    const tmuxRootSessions = unlinkedLiveTmuxSessions();
+    const allLiveRootSessions = [...liveRootSessions, ...tmuxRootSessions];
     const projects = observedProjects(rootSessions);
-    const liveProjects = observedProjects(liveRootSessions);
+    const liveProjects = observedProjects(allLiveRootSessions)
+      .filter((project) => Number(project.count || 0) > 0);
     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));
+      || projects.some((project) => normalizedProjectPath(project.path) === normalizedProjectPath(state.workspace))
+      || liveProjects.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} ${Number(item.liveCount || 0) ? "has-live-sessions" : ""} ${state.workspace === item.path ? "selected" : ""}"
       data-workspace="${esc(item.path)}" title="${esc(item.path)}"
@@ -188,7 +225,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     const desktopHtml =
       `<button type="button" class="workspace-item control-room-project-chip ${state.workspace === "all" ? "selected" : ""}"
         data-workspace="all" aria-pressed="${state.workspace === "all" ? "true" : "false"}">
-      <strong>${esc(t("control.all_projects"))}</strong><small>${liveRootSessions.length}</small>
+      <strong>${esc(t("control.all_projects"))}</strong><small>${allLiveRootSessions.length}</small>
       </button>` +
       liveProjects.map((item) => projectButton(item, "control-room-project-chip")).join("") +
       (liveProjectlessCount
@@ -636,6 +673,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     sessionWorkspaceLabel,
     controlRoomProject,
     matchesWorkspaceFilter,
+    unlinkedLiveTmuxSessions,
     renderWorkspaces,
     renderGlobalStats,
     formatBytes,

package/renderer/app-drawer-content.js

@@ -55,8 +55,11 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const label = assistant ? options.assistantLabel : options.userLabel;
     const avatar = assistant ? providerInfo(session.provider).mark : "ME";
     const fullTime = new Date(message.timestamp).toLocaleString(uiLocale());
+    const workingIndicator = options.live
+      ? `<span class="chat-working-dots" aria-hidden="true"><i></i><i></i><i></i></span>`
+      : "";
     const answerKind = assistant && options.answerKind
-      ? `<span class="chat-answer-kind${options.live ? " is-live" : ""}">${esc(options.answerKind)}</span>`
+      ? `<span class="chat-answer-kind${options.live ? " is-live" : ""}">${esc(options.answerKind)}${workingIndicator}</span>`
       : "";
     const deliveryStatusKey = {
       sending: "drawer.message_sending",

package/renderer/app-events-filters.js

@@ -61,7 +61,9 @@ window.LoadToAgentAppFactories.createFilterEventBindings = function createFilter
       const item = event.target.closest("[data-workspace]");
       if (item) {
         const label = item.querySelector("strong")?.textContent.trim() || t("project.all");
-        state.workspace = item.dataset.workspace;
+        state.workspace = item.dataset.workspace !== "all" && state.workspace === item.dataset.workspace
+          ? "all"
+          : item.dataset.workspace;
         state.visibleLimit = 30;
         renderWorkspaces();
         renderSessions("filter");

package/renderer/app-graph-orchestration.js

@@ -17,6 +17,7 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
     stableSessionSort = sessions => [...sessions],
     runtimeAgentSummary,
     liveTmuxEntries,
+    filteredLiveTmuxEntries,
     runtimeSeparatedOverview,
     focusedGraph,
     scheduleAgentWorkflowConnections,
@@ -39,6 +40,7 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       && liveSessionGrid.contains(document.activeElement);
     rememberDisclosureStates(liveSessionGrid);
     const model = connectedGraphSessions(sessions);
+    const tmuxEntries = filteredLiveTmuxEntries(model, liveTmuxEntries(state.snapshot && state.snapshot.tmux));
     const focus =
       state.graphFocusId && model.byId.get(state.graphFocusId) && model.included.has(state.graphFocusId) ? model.byId.get(state.graphFocusId) : null;
     if (state.graphFocusId && !focus) state.graphFocusId = null;
@@ -48,7 +50,7 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       : state.controlRoomSort === "context"
         ? [...rootSessions].sort((a, b) => Number((b.context && b.context.percent) || 0) - Number((a.context && a.context.percent) || 0))
         : stableSessionSort(rootSessions);
-    if (!model.nodes.length) {
+    if (!model.nodes.length && !tmuxEntries.length) {
       if (!preserveFocusedComposer) liveSessionGrid.innerHTML = "";
       $("#graphBreadcrumbs").innerHTML = "";
       $("#graphResetBtn").classList.add("hidden");
@@ -78,8 +80,8 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       $("#graphResetBtn").classList.remove("hidden");
       scheduleAgentWorkflowConnections();
     } else {
-      const runtime = runtimeAgentSummary(model, liveTmuxEntries(state.snapshot && state.snapshot.tmux));
-      if (!preserveFocusedComposer) liveSessionGrid.innerHTML = runtimeSeparatedOverview(roots, model, roots);
+      const runtime = runtimeAgentSummary(model, tmuxEntries);
+      if (!preserveFocusedComposer) liveSessionGrid.innerHTML = runtimeSeparatedOverview(roots, model, roots, tmuxEntries);
       restoreDisclosureStates(liveSessionGrid);
       $("#graphBreadcrumbs").innerHTML = "";
       $("#agentMapToolbar")?.classList.add("hidden");
@@ -87,7 +89,7 @@ window.LoadToAgentAppFactories.createGraphOrchestration = function createGraphOr
       $("#controlRoomListToolbar")?.classList.remove("hidden");
       syncControlRoomDisclosureButtons();
       $("#graphResetBtn").classList.add("hidden");
-      return runtime.activeCount;
+      return runtime.activeCount + tmuxEntries.length;
     }
     return model.nodes.filter(isControlRoomSession).length;
   }

package/renderer/app-graph-view.js

@@ -35,6 +35,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     graphDescendantCount,
     sessionWorkspaceLabel,
     controlRoomProject = session => ({ key: String(session?.workspace || session?.id || "unknown"), label: sessionWorkspaceLabel(session) }),
+    matchesWorkspaceFilter = () => true,
     ensureProjectOrder = projectKeys => projectKeys,
   } = context;
   const t = (key, params) => window.LoadToAgentI18n.t(key, params);
@@ -280,11 +281,49 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     );
   }
 
+  function tmuxEntrySession(entry) {
+    return {
+      id: `tmux:${entry?.pane?.id || ""}`,
+      provider: entry?.agent?.provider || "",
+      status: "running",
+      title: entry?.agent?.title || entry?.tmuxSession?.name || "",
+      workspace: "",
+      originCwd: entry?.pane?.cwd || "",
+      cwd: entry?.pane?.cwd || "",
+    };
+  }
+
+  function filteredLiveTmuxEntries(model, entries = liveTmuxEntries(state.snapshot && state.snapshot.tmux)) {
+    const sessionsById = new Map((state.snapshot?.sessions || []).map((session) => [String(session.id || ""), session]));
+    const modelSessionIds = new Set((model?.nodes || []).map((session) => String(session.id || "")));
+    const query = String(state.search || "").replace(/\s+/g, " ").trim().toLowerCase();
+    return entries.filter((entry) => {
+      const linkedId = String(entry?.agent?.linkedSessionId || "");
+      const linkedSession = linkedId ? sessionsById.get(linkedId) : null;
+      if (linkedId && modelSessionIds.has(linkedId)) return false;
+      if (linkedSession && !isControlRoomSession(linkedSession)) return false;
+      const session = tmuxEntrySession(entry);
+      if (!session.originCwd || !matchesWorkspaceFilter(session)) return false;
+      if (!query) return true;
+      return [
+        session.title,
+        session.workspace,
+        session.originCwd,
+        entry?.distro?.name,
+        entry?.window?.name,
+        entry?.pane?.command,
+        entry?.agent?.command,
+      ].join(" ").toLowerCase().includes(query);
+    });
+  }
+
   function liveTmuxPaneCard(entry) {
     const { distro, tmuxSession, window, pane, agent } = entry;
     const provider = providerInfo(agent.provider);
     const linked = agent.linkedSessionId ? (state.snapshot?.sessions || []).find((session) => session.id === agent.linkedSessionId) || null : null;
-    const title = linked ? linked.title : pane.title || t("graph.tmux_task", { provider: provider.label });
+    const title = linked
+      ? linked.title
+      : agent.title || pane.title || t("graph.tmux_task", { provider: provider.label });
     const stateLabel = pane.dead ? t("graph.ended") : pane.active ? t("graph.selected_pane") : t("graph.background_running");
     return `<article class="live-tmux-card ${pane.active ? "active" : ""} ${pane.dead ? "dead" : ""}"
       style="${providerStyle(agent.provider)}"
@@ -525,50 +564,69 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
     </article>`;
   }
 
-  function runtimeSeparatedOverview(roots, model, allRoots = roots) {
+  function runtimeSeparatedOverview(roots, model, allRoots = roots, tmuxEntries = filteredLiveTmuxEntries(model)) {
     const projectDescriptor = (root) => {
       const project = controlRoomProject(root);
       return { key: project.key, name: project.label };
     };
+    const addGroupItem = (groups, key, name, field, value) => {
+      if (!groups.has(key)) groups.set(key, { name, roots: [], tmuxEntries: [] });
+      groups.get(key)[field].push(value);
+    };
     const allGroups = new Map();
     allRoots.forEach((root) => {
       const { key, name } = projectDescriptor(root);
-      if (!allGroups.has(key)) allGroups.set(key, { name, roots: [] });
-      allGroups.get(key).roots.push(root);
+      addGroupItem(allGroups, key, name, "roots", root);
     });
     const groups = new Map();
     roots.forEach((root) => {
       const { key, name } = projectDescriptor(root);
-      if (!groups.has(key)) groups.set(key, { name, roots: [] });
-      groups.get(key).roots.push(root);
+      addGroupItem(groups, key, name, "roots", root);
+    });
+    tmuxEntries.forEach((entry) => {
+      const { key, name } = projectDescriptor(tmuxEntrySession(entry));
+      addGroupItem(allGroups, key, name, "tmuxEntries", entry);
+      addGroupItem(groups, key, name, "tmuxEntries", entry);
     });
     const defaultOrderedGroups = [...groups.entries()].sort(([leftKey], [rightKey]) =>
-      Number(allGroups.get(rightKey)?.roots.length || 0) - Number(allGroups.get(leftKey)?.roots.length || 0));
+      Number((allGroups.get(rightKey)?.roots.length || 0) + (allGroups.get(rightKey)?.tmuxEntries.length || 0))
+      - Number((allGroups.get(leftKey)?.roots.length || 0) + (allGroups.get(leftKey)?.tmuxEntries.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) =>
+    const projectGroups = orderedGroups.map(([key, { name, roots: projectRoots, tmuxEntries: projectTmuxEntries }], index) => {
+      const projectTotals = allGroups.get(key) || { roots: projectRoots, tmuxEntries: projectTmuxEntries };
+      const activeCount = projectTotals.roots.filter((root) => isLiveSession(root)).length;
+      const attentionCount = projectTotals.roots.filter((root) =>
         !isLiveSession(root)
         && isControlRoomSession(root)
         && ["waiting", "failed", "paused"].includes(root.status)).length;
-      const summary = attentionCount
+      const sessionSummary = attentionCount
         ? t("control.project_live_attention_summary", { active: activeCount, attention: attentionCount })
         : t("control.project_live_summary", { active: activeCount });
+      const tmuxSummary = projectTotals.tmuxEntries.length
+        ? t("control.project_tmux_summary", { count: projectTotals.tmuxEntries.length })
+        : "";
+      const summary = projectTotals.roots.length ? [sessionSummary, tmuxSummary].filter(Boolean).join(" · ") : tmuxSummary;
       const disclosureKey = `control-project:${key}`;
       const presentation = index === 0 ? "is-primary" : "is-secondary";
       const projectFocusId = projectRoots[0]?.id || "";
+      const totalCount = projectTotals.roots.length + projectTotals.tmuxEntries.length;
+      const tmuxCards = projectTmuxEntries.length
+        ? `<section class="control-project-tmux-section">
+          <header><span><i aria-hidden="true">▦</i><b>${esc(t("graph.tmux_session"))}</b></span><small>${esc(t("control.project_tmux_help"))}</small></header>
+          <div class="live-tmux-grid">${projectTmuxEntries.map((entry) => liveTmuxPaneCard(entry)).join("")}</div>
+        </section>`
+        : "";
       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-heading"><i aria-hidden="true">□</i><b>${esc(name)}</b><small>${esc(summary)}</small><em>${totalCount}</em></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>
+        ${projectFocusId ? `<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("")}${tmuxCards}</div>
       </details>`;
     }).join("");
     return `<div class="control-room-overview" data-control-room-overview="true">
@@ -892,7 +950,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
   }
 
   return {
-    graphNode, compactGraphNode, providerFlowLane, workflowCompactNode, liveTmuxEntries, liveTmuxPaneCard, runtimeSeparatedOverview,
+    graphNode, compactGraphNode, providerFlowLane, workflowCompactNode, liveTmuxEntries, tmuxEntrySession, filteredLiveTmuxEntries, liveTmuxPaneCard, runtimeSeparatedOverview,
     controlRoomIntent, controlRoomSummary, controlRoomAgentGoal, inferredExecutionSummary,
     workflowMetrics, workflowChildrenSummary, splitSubagents, completedSubagentDisclosure, agentPathTaskName, communicationEndpoint,
     workflowCommunicationPanel, executionActivityLabel, executionActivityStatus, executionActivityCard, executionActivityPanel, focusedGraph,

package/renderer/app-session-render.js

@@ -168,7 +168,11 @@ window.LoadToAgentAppFactories.createSessionRenderer = function createSessionRen
     const graphLiveCount = showMap ? renderAgentMap(graphFilteredSessions(), motionKind) : 0;
     const regular = state.view === "all" ? sessions.filter((session) => !isControlRoomSession(session)) : state.view === "active" ? [] : sessions;
     const visible = regular.slice(0, state.visibleLimit);
-    const resultCount = attentionView ? attentionCount : graphLiveCount + regular.length;
+    const resultCount = attentionView
+      ? attentionCount
+      : state.view === "active"
+        ? graphLiveCount
+        : regular.length;
     $("#sessionResultSummary").textContent = window.LoadToAgentI18n.t("quality.results_summary", { count: resultCount });
     const activeEmpty = state.view === "active" && graphLiveCount === 0;
     $("#activeEmptyState").classList.toggle("hidden", !activeEmpty);

package/renderer/i18n-messages.js

@@ -1476,6 +1476,8 @@
     "control.project_filter": {"ko":"프로젝트별 실행 세션 필터","en":"Filter live sessions by project","zh-CN":"按项目筛选运行会话"},
     "control.project_live_attention_summary": {"ko":"실행 중 {active} · 확인 필요 {attention}","en":"{active} running · {attention} need attention","zh-CN":"运行中 {active} · 需确认 {attention}"},
     "control.project_live_summary": {"ko":"실행 중 {active}","en":"{active} running","zh-CN":"运行中 {active}"},
+    "control.project_tmux_summary": {"ko":"tmux {count}개","en":"{count} tmux","zh-CN":"tmux {count} 个"},
+    "control.project_tmux_help": {"ko":"이 프로젝트 경로에서 직접 감지한 AI 터미널","en":"AI terminals detected directly from this project path","zh-CN":"从此项目路径直接检测到的 AI 终端"},
     "control.recent_activity": {"ko":"최근 활동순","en":"Recent activity","zh-CN":"最近活动"},
     "control.search_sessions": {"ko":"실행 세션 검색","en":"Search live sessions","zh-CN":"搜索运行会话"},
     "control.sort_sessions": {"ko":"실행 세션 정렬","en":"Sort live sessions","zh-CN":"排序运行会话"},

package/renderer/styles-components.css

@@ -1125,6 +1125,9 @@ button[aria-busy="true"] {
 
 .chat-answer-kind.is-live {
   position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
   padding-left: 18px;
   border-color: rgba(71,214,153,.3);
   background: rgba(34,118,83,.12);
@@ -1144,6 +1147,51 @@ button[aria-busy="true"] {
   animation: control-room-pulse 1.35s ease-in-out infinite;
 }
 
+.chat-working-dots {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  height: 9px;
+}
+
+.chat-working-dots i {
+  width: 3px;
+  height: 3px;
+  border-radius: 50%;
+  background: currentColor;
+  box-shadow: 0 0 5px rgba(89,223,167,.45);
+  animation: chat-working-dot 1.05s ease-in-out infinite;
+}
+
+.chat-working-dots i:nth-child(2) {
+  animation-delay: 140ms;
+}
+
+.chat-working-dots i:nth-child(3) {
+  animation-delay: 280ms;
+}
+
+@keyframes chat-working-dot {
+  0%,
+  60%,
+  100% {
+    opacity: .38;
+    transform: translateY(1px);
+  }
+  30% {
+    opacity: 1;
+    transform: translateY(-2px);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .chat-working-dots i {
+    opacity: .72;
+    animation: none;
+    transform: none;
+  }
+}
+
 .chat-delivery-progress {
   display: grid;
   gap: 11px;

package/renderer/styles-control-room.css

@@ -780,6 +780,51 @@ body details.control-room-project-group > summary.control-project-header {
   padding: 9px 10px;
 }
 
+.control-project-tmux-section {
+  padding: 12px 14px 14px;
+  border-top: 1px solid rgba(104,130,151,.17);
+  background: rgba(8,14,20,.42);
+}
+
+.control-project-tmux-section > header {
+  min-height: 28px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 0 2px 8px;
+}
+
+.control-project-tmux-section > header > span {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  color: #78dfbd;
+}
+
+.control-project-tmux-section > header i {
+  font-size: 12px;
+  font-style: normal;
+}
+
+.control-project-tmux-section > header b {
+  color: #c8ddd6;
+  font-size: 12px;
+}
+
+.control-project-tmux-section > header small {
+  overflow: hidden;
+  color: #708493;
+  font-size: 12px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.control-project-tmux-section .live-tmux-grid {
+  grid-template-columns: repeat(auto-fit,minmax(260px,1fr));
+  padding: 0;
+}
+
 .control-room-project-group:not([open]) .control-project-header {
   min-height: 50px !important;
 }

package/src/agentMonitor/codexParser.js

@@ -2,7 +2,7 @@
 
 const path = require('path');
 const { createCodexCollaboration } = require('./codexCollaboration');
-const { createExecutionTracker } = require('./executionActivity');
+const { createExecutionTracker, reconcileExecutionActivities } = require('./executionActivity');
 
 const COLLABORATION_TOOLS = new Set([
   'spawn_agent',
@@ -459,7 +459,11 @@ function createCodexParser(dependencies) {
     const collaboration = state.collaboration.finalize(session.collaboration.retainedAgents);
     session.collaboration.spawns = collaboration.spawns;
     session.collaboration.communications = collaboration.communications;
-    session.executions = state.executionTracker.finalize();
+    session.executions = reconcileExecutionActivities(state.executionTracker.finalize(), {
+      staleAfterMs: STALE_TURN_THRESHOLD_MS,
+      turnFinished: state.lastTurnCompleted,
+      waitingForUser: session.status === 'waiting',
+    });
     const windowInfo = modelContextWindow('codex', session.model, state.observedWindow);
     session.context = contextInfo(session.turnUsage.total || session.turnUsage.input, windowInfo);
 

package/src/agentMonitor/executionActivity.js

@@ -278,11 +278,10 @@ function reconcileExecutionActivities(activities = [], options = {}) {
     if (!activity || activity.status !== 'running') return activity;
     const observedAt = Date.parse(activity.updatedAt || activity.startedAt || 0);
     const observationAge = Number.isFinite(observedAt) ? Math.max(0, now - observedAt) : Number.POSITIVE_INFINITY;
+    const observationStale = staleAfterMs > 0 && observationAge >= staleAfterMs;
     const foregroundEnded = activity.mode !== 'background' && turnSettled;
-    const backgroundUnobserved = activity.mode === 'background'
-      && staleAfterMs > 0
-      && observationAge >= staleAfterMs;
-    if (!foregroundEnded && !backgroundUnobserved) return activity;
+    const executionUnobserved = observationStale;
+    if (!foregroundEnded && !executionUnobserved) return activity;
     return {
       ...activity,
       status: 'unverified',