langchain_agentx_stream_ui 0.1.9 → 0.2.2

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   fixDiagramSvg,
   markEventIdSeen,
   shouldSkipDuplicateEvent
-} from "./chunk-2T26L3VT.js";
+} from "./chunk-DGC43A5L.js";
 import {
   DefaultToolBody,
   InteractionBusContext,
@@ -32,8 +32,8 @@ import {
   getNoopInteractionBus,
   resolveToolBody,
   useInteractionBus
-} from "./chunk-6DYISADG.js";
-import "./chunk-DP7V33X7.js";
+} from "./chunk-T626YBJX.js";
+import "./chunk-6Z4ZF36Z.js";
 import {
   CollapseKind,
   CollapsedExploreNode,
@@ -111,7 +111,7 @@ import {
   useSessionStatus,
   useSessionViewOptions,
   useTimeline
-} from "./chunk-ZNXAQ4ZZ.js";
+} from "./chunk-OFXC2GZI.js";
 import {
   Agent,
   AgentToolBody,
@@ -138,7 +138,7 @@ import {
   WriteToolBody,
   createDefaultToolRegistry,
   formatAgentTitle
-} from "./chunk-7CLAU74Y.js";
+} from "./chunk-YUZXTGJJ.js";
 import {
   BodyBlockList,
   DiffView,
@@ -154,7 +154,7 @@ import {
   formatTimeoutFooter,
   parseDiffText,
   truncateCommand
-} from "./chunk-4RIOBLGB.js";
+} from "./chunk-GBY5DJ7L.js";
 
 // src/view/AgentSession.tsx
 import { useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
@@ -275,6 +275,14 @@ function transportLog(message, level = "warn") {
     console.warn(line);
   }
 }
+function isSseStreamTerminalEvent(agentEvent, expectedApplicationKind) {
+  const eventType = agentEvent.event_type;
+  if (eventType === "error") return true;
+  if (expectedApplicationKind === "workflow") {
+    return eventType === "workflow-end" || eventType === "workflow-failed";
+  }
+  return eventType === "finish";
+}
 function buildResumeStreamUrl(baseUrl, lastEventId, queryParam = "last_event_id") {
   if (!lastEventId) return baseUrl;
   const sep = baseUrl.includes("?") ? "&" : "?";
@@ -420,7 +428,7 @@ function createAgentxSseSource(options) {
               } else {
                 flushBufferedDelta();
                 handler(agentEvent, ctx);
-                if (agentEvent.event_type === "finish" || agentEvent.event_type === "error") {
+                if (isSseStreamTerminalEvent(agentEvent, expectedApplicationKind)) {
                   streamTerminal = true;
                 }
               }
@@ -626,6 +634,8 @@ function AgentSession({
       workspaceRoot
     ]
   );
+  const onErrorRef = useRef2(onError);
+  onErrorRef.current = onError;
   useEffect2(() => {
     const store = storeRef.current;
     const controller = new AbortController();
@@ -637,12 +647,15 @@ function AgentSession({
         if (tree.status === "running" || tree.status === "connecting") {
           store.setState({ tree: { ...tree, status: "error" } });
         }
+        onErrorRef.current?.(err);
+      } else if (err instanceof Error) {
+        onErrorRef.current?.(err);
       }
     });
     return () => {
       controller.abort();
     };
-  }, [source, onError]);
+  }, [source]);
   return /* @__PURE__ */ jsx3(SessionStoreContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx3(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx3(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx3(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx3(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx3(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs("div", { className: "lax-agent-session", "data-testid": "lax-agent-session", children: [
     children ?? /* @__PURE__ */ jsx3(
       AgentLoopView,
@@ -762,6 +775,9 @@ function createEmptyWorkflowSessionState() {
 }
 
 // src/core/workflow/workflowLoopTreeUtils.ts
+function isWorkflowLoopTreeActive(tree) {
+  return tree?.status === "running" || tree?.status === "connecting";
+}
 function createWorkflowRunningLoopTree(seedMs = Date.now()) {
   const tree = createEmptyTree();
   tree.status = "running";
@@ -793,6 +809,168 @@ function finalizeWorkflowLoopTree(tree, terminalStatus = "done") {
   };
 }
 
+// src/core/workflow/stageDoneSummary.ts
+function countToolUses(tree) {
+  return Object.values(tree.byId).filter((node) => node.kind === "tool_call").length;
+}
+function computeDurationSeconds(tree) {
+  const started = tree.meta.startedAt;
+  if (started == null) return null;
+  let maxTs = started;
+  for (const node of Object.values(tree.byId)) {
+    if ("endedAt" in node && typeof node.endedAt === "number") {
+      maxTs = Math.max(maxTs, node.endedAt);
+    }
+    if ("startedAt" in node && typeof node.startedAt === "number") {
+      maxTs = Math.max(maxTs, node.startedAt);
+    }
+  }
+  const seconds = Math.round((maxTs - started) / 1e3);
+  return seconds > 0 ? seconds : null;
+}
+function lastTextContent(tree) {
+  const textNodes = Object.values(tree.byId).filter((node) => node.kind === "text");
+  if (textNodes.length === 0) return "";
+  return textNodes[textNodes.length - 1].accumulated.trim();
+}
+function buildStageDoneSummary(tree) {
+  if (tree.status !== "done" && tree.status !== "error") return null;
+  const toolUses = countToolUses(tree);
+  const duration = computeDurationSeconds(tree);
+  const durationSuffix = duration != null ? ` \xB7 ${duration}s` : "";
+  const label = toolUses > 0 ? `Done (${toolUses} tool use${toolUses === 1 ? "" : "s"}${durationSuffix})` : `Done (1 agent turn${durationSuffix})`;
+  const fullText = lastTextContent(tree);
+  const lines = fullText.split("\n").map((line) => line.trim()).filter(Boolean);
+  const teaser = lines[0] ?? "";
+  const extraLines = Math.max(0, lines.length - 1);
+  return { label, teaser, extraLines };
+}
+function formatTeaserExpandHint(extraLines, verbose) {
+  if (extraLines <= 0) return null;
+  const shown = verbose ? Math.min(extraLines, 2) : 0;
+  const hidden = extraLines - shown;
+  if (hidden <= 0) return null;
+  return `\u2026 +${hidden} lines (ctrl+o to expand)`;
+}
+
+// src/core/workflow/workflowLoopEviction.ts
+function containersByLoopSessionId(tree) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of Object.values(tree.containersById)) {
+    if (node.loopSessionId) map.set(node.loopSessionId, node);
+  }
+  return map;
+}
+function hasRunningParallelSibling(node, tree) {
+  if (node.scope !== "item" || !node.parent_container_id) return false;
+  for (const sibling of Object.values(tree.containersById)) {
+    if (sibling.container_id === node.container_id) continue;
+    if (sibling.scope !== "item") continue;
+    if (sibling.parent_container_id !== node.parent_container_id) continue;
+    if (sibling.status === "running" || sibling.status === "retrying") return true;
+  }
+  return false;
+}
+function collectProtectedLoopSessionIds(state, pinnedLoopSessionIds) {
+  const protectedIds = new Set(Object.keys(pinnedLoopSessionIds));
+  const byLoop = containersByLoopSessionId(state.containerTree);
+  if (state.activeLoopSessionId) {
+    const activeContainer = byLoop.get(state.activeLoopSessionId);
+    if (activeContainer && (activeContainer.status === "running" || activeContainer.status === "retrying")) {
+      protectedIds.add(state.activeLoopSessionId);
+    }
+  }
+  for (const containerId of state.containerTree.activeContainerIds) {
+    const node = state.containerTree.containersById[containerId];
+    if (!node?.loopSessionId) continue;
+    if (node.status === "running" || node.status === "retrying") {
+      protectedIds.add(node.loopSessionId);
+    }
+  }
+  for (const node of Object.values(state.containerTree.containersById)) {
+    if (!node.loopSessionId) continue;
+    if (node.status === "running" || node.status === "retrying") {
+      protectedIds.add(node.loopSessionId);
+    }
+    if ((node.status === "completed" || node.status === "failed") && hasRunningParallelSibling(node, state.containerTree)) {
+      protectedIds.add(node.loopSessionId);
+    }
+  }
+  return protectedIds;
+}
+function evictInactiveLoopTrees(state, pinnedLoopSessionIds) {
+  const protectedIds = collectProtectedLoopSessionIds(state, pinnedLoopSessionIds);
+  for (const id of state.hotCompletedLoopSessionIds) {
+    protectedIds.add(id);
+  }
+  const byLoop = containersByLoopSessionId(state.containerTree);
+  const nextLoops = { ...state.loopTreesBySessionId };
+  const nextSummaries = {
+    ...state.stageDoneSummariesByContainerId
+  };
+  for (const [loopSessionId, tree] of Object.entries(state.loopTreesBySessionId)) {
+    if (protectedIds.has(loopSessionId)) continue;
+    const container = byLoop.get(loopSessionId);
+    if (!container) continue;
+    if (container.status !== "completed" && container.status !== "failed") continue;
+    const summary = buildStageDoneSummary(tree);
+    if (summary) {
+      nextSummaries[container.container_id] = summary;
+    }
+    delete nextLoops[loopSessionId];
+  }
+  return {
+    ...state,
+    loopTreesBySessionId: nextLoops,
+    stageDoneSummariesByContainerId: nextSummaries
+  };
+}
+function touchCompletedLoopSession(state, loopSessionId) {
+  const ids = state.hotCompletedLoopSessionIds.filter((id) => id !== loopSessionId);
+  ids.push(loopSessionId);
+  return {
+    ...state,
+    hotCompletedLoopSessionIds: ids
+  };
+}
+function evictCompletedLoopOverflow(state, maxHydratedCompletedLoops) {
+  if (state.hotCompletedLoopSessionIds.length <= maxHydratedCompletedLoops) {
+    return state;
+  }
+  const overflow = state.hotCompletedLoopSessionIds.length - maxHydratedCompletedLoops;
+  const candidateEvictIds = state.hotCompletedLoopSessionIds.slice(0, overflow);
+  let trimmedIds = state.hotCompletedLoopSessionIds.slice(overflow);
+  const byLoop = containersByLoopSessionId(state.containerTree);
+  const nextLoops = { ...state.loopTreesBySessionId };
+  const nextSummaries = {
+    ...state.stageDoneSummariesByContainerId
+  };
+  for (const id of candidateEvictIds) {
+    const tree = nextLoops[id];
+    if (!tree) continue;
+    const container = byLoop.get(id);
+    if (container && hasRunningParallelSibling(container, state.containerTree)) {
+      if (!trimmedIds.includes(id)) {
+        trimmedIds = [id, ...trimmedIds];
+      }
+      continue;
+    }
+    if (container) {
+      const summary = buildStageDoneSummary(tree);
+      if (summary) {
+        nextSummaries[container.container_id] = summary;
+      }
+    }
+    delete nextLoops[id];
+  }
+  return {
+    ...state,
+    loopTreesBySessionId: nextLoops,
+    stageDoneSummariesByContainerId: nextSummaries,
+    hotCompletedLoopSessionIds: trimmedIds
+  };
+}
+
 // src/types/workflowDisplay.ts
 function readDisplayPayload(data) {
   const display = data.display;
@@ -1169,17 +1347,24 @@ var WorkflowContainerStateMachine = class {
       (node) => workflowPath === node.workflow_path || workflowPath.startsWith(`${node.workflow_path}>`)
     );
     if (prefixCandidates.length > 0) {
-      const parent = prefixCandidates.reduce(
-        (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
-      );
-      if (parent.workflow_path === workflowPath && parent.scope === "workflow") {
-        return parent.container_id;
-      }
-      if (workflowPath.startsWith(`${parent.workflow_path}>`)) {
-        return parent.container_id;
-      }
-      if (parent.workflow_path === workflowPath && parent.scope !== scope) {
-        return parent.container_id;
+      const parentCandidates = prefixCandidates.filter((node) => {
+        if (scope === "item") return node.scope !== "item";
+        if (scope === "aggregate") return node.scope !== "item" && node.scope !== "aggregate";
+        return node.scope !== scope;
+      });
+      if (parentCandidates.length > 0) {
+        const parent = parentCandidates.reduce(
+          (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
+        );
+        if (parent.workflow_path === workflowPath && parent.scope === "workflow") {
+          return parent.container_id;
+        }
+        if (workflowPath.startsWith(`${parent.workflow_path}>`)) {
+          return parent.container_id;
+        }
+        if (parent.workflow_path === workflowPath && parent.scope !== scope) {
+          return parent.container_id;
+        }
       }
     }
     const workflowCandidates = openNodes.filter((node) => node.scope === "workflow");
@@ -1277,6 +1462,167 @@ function loopTaskScopeForStructureOpen(eventType) {
   return LOOP_TASK_OPEN_SCOPES[eventType];
 }
 
+// src/core/workflowStructureEvents.ts
+var WORKFLOW_STRUCTURE_EVENT_PREFIXES = [
+  "workflow-",
+  "stage-",
+  "parallel-",
+  "route-",
+  "subworkflow-"
+];
+var WORKFLOW_STRUCTURE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "workflow-start",
+  "workflow-end",
+  "workflow-failed",
+  "subworkflow-start",
+  "subworkflow-end",
+  "stage-start",
+  "stage-done",
+  "stage-failed",
+  "parallel-item-start",
+  "parallel-item-done",
+  "parallel-item-failed",
+  "parallel-aggregate-start",
+  "parallel-aggregate-done",
+  "parallel-aggregate-failed",
+  "route-branch-start",
+  "route-branch-done",
+  "route-branch-failed"
+]);
+var AGENT_LOOP_REPLAY_EVENT_TYPES = new Set(
+  Object.keys(DEFAULT_EVENT_TIERS)
+);
+function isWorkflowStructureEventType(eventType) {
+  if (WORKFLOW_STRUCTURE_EVENT_TYPES.has(eventType)) return true;
+  return WORKFLOW_STRUCTURE_EVENT_PREFIXES.some((prefix) => eventType.startsWith(prefix));
+}
+function isAgentLoopReplayEventType(eventType) {
+  return AGENT_LOOP_REPLAY_EVENT_TYPES.has(eventType);
+}
+function filterAgentLoopReplayEvents(events) {
+  return events.filter(
+    (event) => isAgentLoopReplayEventType(event.event_type) && !isWorkflowStructureEventType(event.event_type)
+  );
+}
+
+// src/core/workflow/workflowPathUtils.ts
+function splitWorkflowPathSegments(workflowPath) {
+  return workflowPath.split(">").filter(Boolean);
+}
+function parentWorkflowPath(workflowPath) {
+  const segments = splitWorkflowPathSegments(workflowPath);
+  if (segments.length <= 1) return null;
+  return segments.slice(0, -1).join(">");
+}
+function lastWorkflowPathSegment(workflowPath) {
+  const segments = splitWorkflowPathSegments(workflowPath);
+  return segments.length > 0 ? segments[segments.length - 1] : null;
+}
+function isWorkflowPathUnderAncestor(workflowPath, ancestorPath) {
+  if (workflowPath === ancestorPath) return false;
+  const prefix = `${ancestorPath}>`;
+  return workflowPath.startsWith(prefix);
+}
+function isWorkflowPathEqualOrUnder(workflowPath, ancestorPath) {
+  return workflowPath === ancestorPath || isWorkflowPathUnderAncestor(workflowPath, ancestorPath);
+}
+
+// src/core/workflow/nativeNestedUtils.ts
+function readString3(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(data, key) {
+  const value = data[key];
+  return typeof value === "number" ? value : void 0;
+}
+function isNativeNestedStructureEvent(event) {
+  if (!isWorkflowStructureEventType(event.event_type)) return false;
+  const data = event.data ?? {};
+  const path = readString3(data, "workflow_path") ?? "";
+  const depth = readNumber(data, "workflow_depth") ?? 0;
+  return depth >= 1 && path.includes(">");
+}
+function resolveHostStageContainerId(tree, workflowPath) {
+  const parentPath = parentWorkflowPath(workflowPath);
+  const childSegment = lastWorkflowPathSegment(workflowPath);
+  if (!parentPath || !childSegment) return null;
+  const stageId = buildContainerId(parentPath, "stage", childSegment);
+  return tree.containersById[stageId] != null ? stageId : null;
+}
+function isHostStageNestedChildPath(tree, workflowPath) {
+  return resolveHostStageContainerId(tree, workflowPath) != null;
+}
+function hasNativeNestedStructureInTree(tree) {
+  for (const node of Object.values(tree.containersById)) {
+    if (node.workflow_depth < 1) continue;
+    if (!node.workflow_path.includes(">")) continue;
+    if (isHostStageNestedChildPath(tree, node.workflow_path)) {
+      return true;
+    }
+  }
+  return false;
+}
+function clearHostStageLoopSession(tree, hostStageId) {
+  if (!hostStageId) return tree;
+  const hostStage = tree.containersById[hostStageId];
+  if (!hostStage || hostStage.scope !== "stage" || !hostStage.loopSessionId) return tree;
+  return {
+    ...tree,
+    containersById: {
+      ...tree.containersById,
+      [hostStageId]: { ...hostStage, loopSessionId: null }
+    }
+  };
+}
+function isNestedHostStageShell(tree, stageNode) {
+  if (stageNode.scope !== "stage") return false;
+  return Object.values(tree.containersById).some(
+    (node) => node.scope === "subworkflow" && node.parent_container_id === stageNode.container_id
+  );
+}
+function clearHostStageLoopOnNestedChildOpen(tree, event) {
+  const eventType = event.event_type;
+  if (eventType !== "subworkflow-start" && eventType !== "parallel-item-start") return tree;
+  const data = event.data ?? {};
+  const workflowPath = readString3(data, "workflow_path");
+  if (!workflowPath) return tree;
+  if (eventType === "subworkflow-start") {
+    const childWorkflowId = readString3(data, "child_workflow_id");
+    if (!childWorkflowId) return tree;
+    const subId = buildContainerId(workflowPath, "subworkflow", childWorkflowId);
+    const sub = tree.containersById[subId];
+    const hostStageId = sub?.parent_container_id ?? resolveHostStageContainerId(tree, workflowPath);
+    return clearHostStageLoopSession(tree, hostStageId);
+  }
+  return clearHostStageLoopSession(tree, resolveHostStageContainerId(tree, workflowPath));
+}
+function dropStaleEmbeddedPathsOnNativeSubworkflowStart(tree, event) {
+  if (event.event_type !== "subworkflow-start" || !isNativeNestedStructureEvent(event)) {
+    return tree;
+  }
+  const data = event.data ?? {};
+  const nativeChildPath = readString3(data, "workflow_path");
+  if (!nativeChildPath) return tree;
+  const rootAnchor = splitWorkflowPathSegments(nativeChildPath)[0];
+  if (!rootAnchor) return tree;
+  let changed = false;
+  const containersById = { ...tree.containersById };
+  let activeContainerIds = [...tree.activeContainerIds];
+  for (const [id, node] of Object.entries(tree.containersById)) {
+    if (node.workflow_depth < 1) continue;
+    if (!node.workflow_path.startsWith(`${rootAnchor}>`)) continue;
+    if (node.workflow_path === nativeChildPath || isWorkflowPathEqualOrUnder(node.workflow_path, nativeChildPath)) {
+      continue;
+    }
+    if (isHostStageNestedChildPath(tree, node.workflow_path)) continue;
+    delete containersById[id];
+    activeContainerIds = activeContainerIds.filter((cid) => cid !== id);
+    changed = true;
+  }
+  return changed ? { ...tree, containersById, activeContainerIds } : tree;
+}
+
 // src/core/workflow/embeddedSubworkflowUtils.ts
 function parseLoopSessionParts(sessionId) {
   const trimmed = sessionId.trim();
@@ -1378,7 +1724,20 @@ function completeOpenItemsUnderSubworkflow(tree, subworkflowId) {
 function resolveLeafScope(taskKey) {
   return taskKey === "aggregate" ? "aggregate" : "item";
 }
+function shouldUseEmbeddedSynthesis(treeOrState, pendingEvent) {
+  const tree = "containerTree" in treeOrState ? treeOrState.containerTree : treeOrState;
+  if (pendingEvent && isNativeNestedStructureEvent(pendingEvent)) {
+    return false;
+  }
+  if (hasNativeNestedStructureInTree(tree)) {
+    return false;
+  }
+  return true;
+}
 function ensureEmbeddedSubworkflowContainers(tree, loopSessionId) {
+  if (!shouldUseEmbeddedSynthesis(tree)) {
+    return tree;
+  }
   const root = resolveRootWorkflow(tree);
   const parts = parseLoopSessionParts(loopSessionId);
   if (!root || !parts || !isEmbeddedChildLoopSession(loopSessionId, root.workflowId)) {
@@ -1461,11 +1820,39 @@ function findContainerIdByLoopSession(tree, loopSessionId) {
   }
   return null;
 }
+var PARALLEL_ITEM_STRUCTURE_EVENTS = /* @__PURE__ */ new Set([
+  "parallel-item-start",
+  "parallel-item-done",
+  "parallel-item-failed"
+]);
+function readItemKey(data) {
+  const value = data.item_key;
+  return typeof value === "string" ? value : void 0;
+}
+function resolveParallelItemLoopSessionId(eventType, eventSessionId, derivedLoopSessionId, data) {
+  if (!PARALLEL_ITEM_STRUCTURE_EVENTS.has(eventType) || !eventSessionId) return null;
+  if (eventSessionId === derivedLoopSessionId) return null;
+  const itemKey = readItemKey(data);
+  const parsed = parseLoopSessionParts(eventSessionId);
+  if (itemKey && parsed?.taskKey === itemKey) {
+    return eventSessionId;
+  }
+  return null;
+}
 function resolveStructureOpenLoopSessionId(eventType, eventSessionId, derivedLoopSessionId, data) {
   const rootWorkflowId = readWorkflowId(data) ?? "";
   if ((eventType === "parallel-aggregate-start" || eventType === "parallel-aggregate-done" || eventType === "parallel-aggregate-failed") && eventSessionId && isEmbeddedChildLoopSession(eventSessionId, rootWorkflowId)) {
     return eventSessionId;
   }
+  const parallelItemSessionId = resolveParallelItemLoopSessionId(
+    eventType,
+    eventSessionId,
+    derivedLoopSessionId,
+    data
+  );
+  if (parallelItemSessionId) {
+    return parallelItemSessionId;
+  }
   return derivedLoopSessionId;
 }
 var EMBEDDED_AGGREGATE_STRUCTURE_EVENTS = /* @__PURE__ */ new Set([
@@ -1483,7 +1870,7 @@ function patchEmbeddedStructureEvent(event, rootWorkflowId) {
   const parts = parseLoopSessionParts(event.session_id);
   if (!parts) return event;
   const data = event.data ?? {};
-  const rootPath = readString3(data, "workflow_path") ?? rootWorkflowId;
+  const rootPath = readString4(data, "workflow_path") ?? rootWorkflowId;
   const childPath = `${rootPath}>${parts.workflowId}`;
   const workflowDepth = typeof data.workflow_depth === "number" ? data.workflow_depth + 1 : 1;
   return {
@@ -1495,14 +1882,17 @@ function patchEmbeddedStructureEvent(event, rootWorkflowId) {
     }
   };
 }
-function readString3(data, key) {
+function readString4(data, key) {
   const value = data[key];
   return typeof value === "string" ? value : void 0;
 }
 function isDescendantOf(containersById, ancestorId, nodeId) {
+  const seen = /* @__PURE__ */ new Set();
   let current = containersById[nodeId]?.parent_container_id ?? null;
   while (current) {
     if (current === ancestorId) return true;
+    if (seen.has(current)) return false;
+    seen.add(current);
     current = containersById[current]?.parent_container_id ?? null;
   }
   return false;
@@ -1515,6 +1905,9 @@ function settleCompletedStageSubtree(tree, stageContainerId) {
     }
     if (node.container_id === stageContainerId) continue;
     if (node.status === "completed" || node.status === "failed") continue;
+    if (node.status === "running" || node.status === "retrying" || node.status === "pending" || node.status === "blocked") {
+      continue;
+    }
     next = upsertRuntimeNode(next, {
       ...node,
       status: "completed",
@@ -1530,51 +1923,8 @@ function readWorkflowId(data) {
   return readWorkflowIdFromData(data);
 }
 
-// src/core/workflowStructureEvents.ts
-var WORKFLOW_STRUCTURE_EVENT_PREFIXES = [
-  "workflow-",
-  "stage-",
-  "parallel-",
-  "route-",
-  "subworkflow-"
-];
-var WORKFLOW_STRUCTURE_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "workflow-start",
-  "workflow-end",
-  "workflow-failed",
-  "subworkflow-start",
-  "subworkflow-end",
-  "stage-start",
-  "stage-done",
-  "stage-failed",
-  "parallel-item-start",
-  "parallel-item-done",
-  "parallel-item-failed",
-  "parallel-aggregate-start",
-  "parallel-aggregate-done",
-  "parallel-aggregate-failed",
-  "route-branch-start",
-  "route-branch-done",
-  "route-branch-failed"
-]);
-var AGENT_LOOP_REPLAY_EVENT_TYPES = new Set(
-  Object.keys(DEFAULT_EVENT_TIERS)
-);
-function isWorkflowStructureEventType(eventType) {
-  if (WORKFLOW_STRUCTURE_EVENT_TYPES.has(eventType)) return true;
-  return WORKFLOW_STRUCTURE_EVENT_PREFIXES.some((prefix) => eventType.startsWith(prefix));
-}
-function isAgentLoopReplayEventType(eventType) {
-  return AGENT_LOOP_REPLAY_EVENT_TYPES.has(eventType);
-}
-function filterAgentLoopReplayEvents(events) {
-  return events.filter(
-    (event) => isAgentLoopReplayEventType(event.event_type) && !isWorkflowStructureEventType(event.event_type)
-  );
-}
-
 // src/core/workflowReducer.ts
-function readString4(data, key) {
+function readString5(data, key) {
   const value = data[key];
   return typeof value === "string" ? value : void 0;
 }
@@ -1673,7 +2023,7 @@ function prebindLoopSessionFromStructureOpen(tree, event) {
     loopSessionId = derivedLoopSessionId;
   }
   let nextTree = event.event_type === "parallel-aggregate-start" ? ensureEmbeddedSubworkflowContainers(tree, loopSessionId) : tree;
-  const workflowPath = readString4(data, "workflow_path") ?? "";
+  const workflowPath = readString5(data, "workflow_path") ?? "";
   const scopeKey = resolveScopeKey(event.event_type, data);
   const containerId = buildContainerId(workflowPath, scope, scopeKey);
   let targetId = containerId;
@@ -1739,22 +2089,31 @@ function findContainerByLoopSession(tree, loopSessionId) {
   return findContainerIdByLoopSession(tree, loopSessionId);
 }
 var WORKFLOW_DEFAULT_LOOP_SESSION_ID = "workflow-loop-default";
-function resolveAgentLoopSessionId(event, activeLoopSessionId) {
+function resolveAgentLoopSessionId(event, activeLoopSessionId, containerTree) {
   if (event.session_id) return event.session_id;
   if (isWorkflowStructureEventType(event.event_type)) return null;
   if (event.event_type === "task-list-snapshot") return null;
   const derived = deriveLoopSessionIdFromAgentEvent(event);
   if (derived) return derived;
+  const byLoop = containersByLoopSessionId(containerTree);
+  if (activeLoopSessionId) {
+    const activeContainer = byLoop.get(activeLoopSessionId);
+    if (activeContainer && (activeContainer.status === "running" || activeContainer.status === "retrying")) {
+      return activeLoopSessionId;
+    }
+  }
+  const runningLoopIds = [...byLoop.entries()].filter(([, node]) => node.status === "running" || node.status === "retrying").map(([loopSessionId]) => loopSessionId);
+  if (runningLoopIds.length === 1) return runningLoopIds[0];
   if (activeLoopSessionId) return activeLoopSessionId;
   return WORKFLOW_DEFAULT_LOOP_SESSION_ID;
 }
 function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
-  const sessionId = resolveAgentLoopSessionId(event, activeLoopSessionId);
+  const sessionId = resolveAgentLoopSessionId(event, activeLoopSessionId, tree);
   if (!sessionId) return tree;
   let nextTree = ensureEmbeddedSubworkflowContainers(tree, sessionId);
   if (findContainerByLoopSession(nextTree, sessionId)) return nextTree;
   const data = event.data ?? {};
-  const workflowPath = readString4(data, "workflow_path") ?? null;
+  const workflowPath = readString5(data, "workflow_path") ?? null;
   const scopeKey = resolveContentScopeKey(data);
   let targetId = findContainerByLoopSession(nextTree, sessionId);
   if (!targetId && scopeKey) {
@@ -1765,12 +2124,17 @@ function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
     );
   }
   if (!targetId) {
-    for (const containerId of nextTree.activeContainerIds) {
-      const node2 = nextTree.containersById[containerId];
-      if ((node2?.scope === "item" || node2?.scope === "stage" || node2?.scope === "aggregate") && !node2.loopSessionId) {
+    const fallbackScopes = ["item", "aggregate", "stage"];
+    for (const scope of fallbackScopes) {
+      for (const containerId of nextTree.activeContainerIds) {
+        const node2 = nextTree.containersById[containerId];
+        if (!node2 || node2.loopSessionId) continue;
+        if (node2.scope !== scope) continue;
+        if (node2.scope === "stage" && isNestedHostStageShell(nextTree, node2)) continue;
         targetId = containerId;
         break;
       }
+      if (targetId) break;
     }
   }
   if (!targetId) {
@@ -1783,6 +2147,9 @@ function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
   if (!targetId) return nextTree;
   const node = nextTree.containersById[targetId];
   if (!node || node.loopSessionId) return nextTree;
+  if (node.scope === "stage" && isNestedHostStageShell(nextTree, node)) {
+    return nextTree;
+  }
   if (node.scope !== "stage" && node.scope !== "item" && node.scope !== "branch" && node.scope !== "aggregate") {
     return nextTree;
   }
@@ -1882,8 +2249,15 @@ function finalizeLoopTreeOnStructureClose(state, event) {
 }
 function applyStructureEvent(state, event) {
   const rootWorkflowId = resolveRootWorkflowId(state.containerTree);
-  const projectedEvent = rootWorkflowId != null ? patchEmbeddedStructureEvent(event, rootWorkflowId) : event;
+  const useEmbeddedSynthesis = shouldUseEmbeddedSynthesis(state, event);
+  const projectedEvent = rootWorkflowId != null && useEmbeddedSynthesis ? patchEmbeddedStructureEvent(event, rootWorkflowId) : event;
   let containerTree = applyStructureToContainerTree(state.containerTree, projectedEvent);
+  if (projectedEvent.event_type === "subworkflow-start" || projectedEvent.event_type === "parallel-item-start") {
+    containerTree = clearHostStageLoopOnNestedChildOpen(containerTree, projectedEvent);
+  }
+  if (projectedEvent.event_type === "subworkflow-start") {
+    containerTree = dropStaleEmbeddedPathsOnNativeSubworkflowStart(containerTree, projectedEvent);
+  }
   const derivedLoopSessionId = deriveLoopSessionIdFromStructureOpen(projectedEvent);
   const structureData = projectedEvent.data ?? {};
   const structureLoopSessionId = derivedLoopSessionId ? resolveStructureOpenLoopSessionId(
@@ -1892,13 +2266,13 @@ function applyStructureEvent(state, event) {
     derivedLoopSessionId,
     structureData
   ) : null;
-  if (structureLoopSessionId) {
+  if (structureLoopSessionId && useEmbeddedSynthesis) {
     containerTree = ensureEmbeddedSubworkflowContainers(containerTree, structureLoopSessionId);
   }
   containerTree = prebindLoopSessionFromStructureOpen(containerTree, projectedEvent);
   if (projectedEvent.event_type === "stage-done" || projectedEvent.event_type === "stage-failed") {
-    const stageKey = readString4(structureData, "stage_key");
-    const workflowPath = readString4(structureData, "workflow_path") ?? "";
+    const stageKey = readString5(structureData, "stage_key");
+    const workflowPath = readString5(structureData, "workflow_path") ?? "";
     if (stageKey) {
       const stageId = buildContainerId(workflowPath, "stage", stageKey);
       if (containerTree.containersById[stageId]) {
@@ -1973,7 +2347,7 @@ function reduceWorkflowSession(state, event, eventIndex, options) {
   if (isWorkflowStructureEventType(event.event_type)) {
     return applyStructureEvent(state, event);
   }
-  const loopSessionId = resolveAgentLoopSessionId(event, state.activeLoopSessionId) ?? WORKFLOW_DEFAULT_LOOP_SESSION_ID;
+  const loopSessionId = resolveAgentLoopSessionId(event, state.activeLoopSessionId, state.containerTree) ?? WORKFLOW_DEFAULT_LOOP_SESSION_ID;
   let containerTree = bindLoopSessionToContainerTree(
     state.containerTree,
     event,
@@ -1992,6 +2366,11 @@ function reduceWorkflowSession(state, event, eventIndex, options) {
     next.containerTree,
     next.workflowProgress
   );
+  let status = next.status;
+  if (workflowProgress.status === "done") status = "done";
+  else if (workflowProgress.status === "error") status = "error";
+  else if (reducedLoop.status === "error") status = "error";
+  else if (status === "connecting") status = "running";
   return {
     ...next,
     workflowProgress,
@@ -2000,160 +2379,107 @@ function reduceWorkflowSession(state, event, eventIndex, options) {
       [loopSessionId]: reducedLoop
     },
     activeLoopSessionId: loopSessionId,
-    status: reducedLoop.status === "error" ? "error" : next.status === "connecting" ? "running" : next.status
+    status
   };
 }
-function reduceWorkflowEvents(events, options) {
-  return events.reduce(
-    (state, event, index) => reduceWorkflowSession(state, event, index, options),
-    createEmptyWorkflowSessionState()
-  );
-}
-
-// src/core/workflow/stageDoneSummary.ts
-function countToolUses(tree) {
-  return Object.values(tree.byId).filter((node) => node.kind === "tool_call").length;
-}
-function computeDurationSeconds(tree) {
-  const started = tree.meta.startedAt;
-  if (started == null) return null;
-  let maxTs = started;
-  for (const node of Object.values(tree.byId)) {
-    if ("endedAt" in node && typeof node.endedAt === "number") {
-      maxTs = Math.max(maxTs, node.endedAt);
-    }
-    if ("startedAt" in node && typeof node.startedAt === "number") {
-      maxTs = Math.max(maxTs, node.startedAt);
-    }
+function finalizeWorkflowSessionOnStreamComplete(state) {
+  if (state.status === "done" || state.status === "error") {
+    return { ...state, activeLoopSessionId: null };
   }
-  const seconds = Math.round((maxTs - started) / 1e3);
-  return seconds > 0 ? seconds : null;
-}
-function lastTextContent(tree) {
-  const textNodes = Object.values(tree.byId).filter((node) => node.kind === "text");
-  if (textNodes.length === 0) return "";
-  return textNodes[textNodes.length - 1].accumulated.trim();
-}
-function buildStageDoneSummary(tree) {
-  if (tree.status !== "done" && tree.status !== "error") return null;
-  const toolUses = countToolUses(tree);
-  const duration = computeDurationSeconds(tree);
-  const durationSuffix = duration != null ? ` \xB7 ${duration}s` : "";
-  const label = toolUses > 0 ? `Done (${toolUses} tool use${toolUses === 1 ? "" : "s"}${durationSuffix})` : `Done (1 agent turn${durationSuffix})`;
-  const fullText = lastTextContent(tree);
-  const lines = fullText.split("\n").map((line) => line.trim()).filter(Boolean);
-  const teaser = lines[0] ?? "";
-  const extraLines = Math.max(0, lines.length - 1);
-  return { label, teaser, extraLines };
-}
-function formatTeaserExpandHint(extraLines, verbose) {
-  if (extraLines <= 0) return null;
-  const shown = verbose ? Math.min(extraLines, 2) : 0;
-  const hidden = extraLines - shown;
-  if (hidden <= 0) return null;
-  return `\u2026 +${hidden} lines (ctrl+o to expand)`;
-}
-
-// src/core/workflow/workflowLoopEviction.ts
-function containersByLoopSessionId(tree) {
-  const map = /* @__PURE__ */ new Map();
-  for (const node of Object.values(tree.containersById)) {
-    if (node.loopSessionId) map.set(node.loopSessionId, node);
+  const tree = state.containerTree;
+  const rootId = tree.rootContainerIds[0];
+  if (!rootId) {
+    return { ...state, status: "done", activeLoopSessionId: null };
   }
-  return map;
-}
-function collectProtectedLoopSessionIds(state, pinnedLoopSessionIds) {
-  const protectedIds = new Set(Object.keys(pinnedLoopSessionIds));
-  const byLoop = containersByLoopSessionId(state.containerTree);
-  if (state.activeLoopSessionId) {
-    const activeContainer = byLoop.get(state.activeLoopSessionId);
-    if (activeContainer && (activeContainer.status === "running" || activeContainer.status === "retrying")) {
-      protectedIds.add(state.activeLoopSessionId);
-    }
+  const root = tree.containersById[rootId];
+  if (!root) {
+    return { ...state, status: "done", activeLoopSessionId: null };
   }
-  for (const containerId of state.containerTree.activeContainerIds) {
-    const node = state.containerTree.containersById[containerId];
-    if (!node?.loopSessionId) continue;
-    if (node.status === "running" || node.status === "retrying") {
-      protectedIds.add(node.loopSessionId);
-    }
+  const topLevelStages = Object.values(tree.containersById).filter(
+    (node) => node.scope === "stage" && node.workflow_path === root.workflow_path && node.workflow_depth === root.workflow_depth
+  );
+  const progressTotal = root.display?.progress_total ?? (topLevelStages.reduce(
+    (max, s) => Math.max(max, s.display?.progress_total ?? 0),
+    0
+  ) || topLevelStages.length);
+  const settledStageCount = topLevelStages.filter(
+    (s) => s.status === "completed" || s.status === "failed" || s.status === "skipped"
+  ).length;
+  const progressCurrent = Math.max(
+    root.display?.progress_current ?? 0,
+    settledStageCount
+  );
+  const rootParallelItems = Object.values(tree.containersById).filter(
+    (node) => node.scope === "item" && node.workflow_path === root.workflow_path && node.workflow_depth === root.workflow_depth
+  );
+  const rootParallelSettled = topLevelStages.length === 0 && rootParallelItems.length > 0 && rootParallelItems.every(
+    (item) => item.status === "completed" || item.status === "failed" || item.status === "skipped"
+  ) && !Object.values(tree.containersById).some(
+    (node) => node.container_id !== rootId && node.workflow_path === root.workflow_path && node.workflow_depth === root.workflow_depth && (node.status === "running" || node.status === "retrying" || node.status === "pending")
+  );
+  const workflowVisuallyComplete = root.status === "completed" || root.status === "failed" || progressTotal > 0 && progressCurrent >= progressTotal || rootParallelSettled;
+  if (!workflowVisuallyComplete) {
+    return state;
   }
-  for (const node of Object.values(state.containerTree.containersById)) {
-    if (!node.loopSessionId) continue;
-    if (node.status === "running" || node.status === "retrying") {
-      protectedIds.add(node.loopSessionId);
+  let containersById = { ...tree.containersById };
+  for (const [id, node] of Object.entries(containersById)) {
+    if (node.status === "running" || node.status === "pending") {
+      containersById[id] = { ...node, status: "completed", is_open: false };
     }
   }
-  return protectedIds;
-}
-function evictInactiveLoopTrees(state, pinnedLoopSessionIds) {
-  const protectedIds = collectProtectedLoopSessionIds(state, pinnedLoopSessionIds);
-  for (const id of state.hotCompletedLoopSessionIds) {
-    protectedIds.add(id);
+  const settledRoot = containersById[rootId] ?? root;
+  if (settledRoot.status !== "completed" && settledRoot.status !== "failed") {
+    containersById = {
+      ...containersById,
+      [rootId]: { ...settledRoot, status: "completed", is_open: false }
+    };
   }
-  const byLoop = containersByLoopSessionId(state.containerTree);
-  const nextLoops = { ...state.loopTreesBySessionId };
-  const nextSummaries = {
-    ...state.stageDoneSummariesByContainerId
-  };
-  for (const [loopSessionId, tree] of Object.entries(state.loopTreesBySessionId)) {
-    if (protectedIds.has(loopSessionId)) continue;
-    const container = byLoop.get(loopSessionId);
-    if (!container) continue;
-    if (container.status !== "completed" && container.status !== "failed") continue;
-    const summary = buildStageDoneSummary(tree);
-    if (summary) {
-      nextSummaries[container.container_id] = summary;
+  const loopTreesBySessionId = { ...state.loopTreesBySessionId };
+  for (const [loopSessionId, loopTree] of Object.entries(loopTreesBySessionId)) {
+    if (loopTree.status === "running" || loopTree.status === "connecting") {
+      loopTreesBySessionId[loopSessionId] = finalizeWorkflowLoopTree(loopTree, "done");
     }
-    delete nextLoops[loopSessionId];
   }
-  return {
-    ...state,
-    loopTreesBySessionId: nextLoops,
-    stageDoneSummariesByContainerId: nextSummaries
+  const containerTree = {
+    ...tree,
+    containersById,
+    activeContainerIds: tree.activeContainerIds.filter(
+      (id) => containersById[id]?.is_open
+    )
   };
-}
-function touchCompletedLoopSession(state, loopSessionId) {
-  const ids = state.hotCompletedLoopSessionIds.filter((id) => id !== loopSessionId);
-  ids.push(loopSessionId);
+  const workflowProgress = syncWorkflowProgressFromContainerTree(
+    containerTree,
+    state.workflowProgress
+  );
   return {
     ...state,
-    hotCompletedLoopSessionIds: ids
+    status: workflowProgress.status === "error" ? "error" : "done",
+    containerTree,
+    workflowProgress,
+    loopTreesBySessionId,
+    activeLoopSessionId: null
   };
 }
-function evictCompletedLoopOverflow(state, maxHydratedCompletedLoops) {
-  if (state.hotCompletedLoopSessionIds.length <= maxHydratedCompletedLoops) {
-    return state;
-  }
-  const overflow = state.hotCompletedLoopSessionIds.length - maxHydratedCompletedLoops;
-  const evictedIds = new Set(state.hotCompletedLoopSessionIds.slice(0, overflow));
-  const trimmedIds = state.hotCompletedLoopSessionIds.slice(overflow);
-  const byLoop = containersByLoopSessionId(state.containerTree);
-  const nextLoops = { ...state.loopTreesBySessionId };
-  const nextSummaries = {
-    ...state.stageDoneSummariesByContainerId
-  };
-  for (const id of evictedIds) {
-    const tree = nextLoops[id];
-    if (!tree) continue;
-    const container = byLoop.get(id);
-    if (container) {
-      const summary = buildStageDoneSummary(tree);
-      if (summary) {
-        nextSummaries[container.container_id] = summary;
-      }
-    }
-    delete nextLoops[id];
-  }
-  return {
-    ...state,
-    loopTreesBySessionId: nextLoops,
-    stageDoneSummariesByContainerId: nextSummaries,
-    hotCompletedLoopSessionIds: trimmedIds
-  };
+function reduceWorkflowEvents(events, options) {
+  return events.reduce(
+    (state, event, index) => reduceWorkflowSession(state, event, index, options),
+    createEmptyWorkflowSessionState()
+  );
 }
 
 // src/core/workflowSessionStore.ts
+var DEFAULT_HYDRATE_CHUNK_SIZE = 50;
+function nextAnimationFrame() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+}
+function withoutHydrating(ids, loopSessionId) {
+  if (!ids[loopSessionId]) return ids;
+  const next = { ...ids };
+  delete next[loopSessionId];
+  return next;
+}
 function safeReduceWorkflow(state, event, eventIndex, options) {
   try {
     return { state: reduceWorkflowSession(state, event, eventIndex, options) };
@@ -2174,6 +2500,39 @@ function safeReduceWorkflow(state, event, eventIndex, options) {
     };
   }
 }
+function finalizeWorkflowSessionOnStreamError(state, message, eventIndex, stack) {
+  const containersById = {
+    ...state.containerTree.containersById
+  };
+  for (const [id, node] of Object.entries(containersById)) {
+    if (node.status === "running" || node.status === "pending") {
+      containersById[id] = { ...node, status: "failed", is_open: false };
+    }
+  }
+  const loopTreesBySessionId = { ...state.loopTreesBySessionId };
+  for (const [loopSessionId, tree] of Object.entries(loopTreesBySessionId)) {
+    if (tree.status === "running" || tree.status === "connecting") {
+      loopTreesBySessionId[loopSessionId] = finalizeWorkflowLoopTree(tree, "error");
+    }
+  }
+  return {
+    ...state,
+    status: "error",
+    containerTree: {
+      ...state.containerTree,
+      containersById,
+      activeContainerIds: state.containerTree.activeContainerIds.filter(
+        (id) => containersById[id]?.is_open
+      )
+    },
+    loopTreesBySessionId,
+    activeLoopSessionId: null,
+    internalErrors: [
+      ...state.internalErrors,
+      { eventIndex, eventType: "stream-error", message, stack }
+    ]
+  };
+}
 function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionState(), storeOptions) {
   const reduceOpts = {
     tierOverrides: storeOptions?.tierOverrides
@@ -2190,6 +2549,7 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
   return createStore2((set, get) => ({
     state: initialState,
     eventCount: initialEventCount,
+    hydratingLoopSessionIds: {},
     applyEvent(event, ctx) {
       const sseEventId = ctx?.sseEventId;
       if (shouldSkipDuplicateEvent(seenEventIds, sseEventId)) return;
@@ -2216,28 +2576,29 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
       seenEventIds.clear();
       set({
         state: createEmptyWorkflowSessionState(),
-        eventCount: 0
+        eventCount: 0,
+        hydratingLoopSessionIds: {}
       });
     },
     markAsError(error) {
-      const { state } = get();
+      const { state, eventCount } = get();
       const message = error?.message ?? "Workflow stream error";
       set({
-        state: {
-          ...state,
-          status: "error",
-          internalErrors: [
-            ...state.internalErrors,
-            {
-              eventIndex: get().eventCount,
-              eventType: "stream-error",
-              message,
-              stack: error?.stack
-            }
-          ]
-        }
+        state: finalizeWorkflowSessionOnStreamError(
+          state,
+          message,
+          eventCount,
+          error?.stack
+        )
       });
     },
+    markStreamComplete() {
+      set((current) => ({
+        state: finalizeState(
+          finalizeWorkflowSessionOnStreamComplete(current.state)
+        )
+      }));
+    },
     /**
      * P2：将 completed loop 加入 LRU 热缓存并淘汰溢出。
      * running 保护由 collectProtectedLoopSessionIds 按状态自动覆盖，不再依赖永久 pin。
@@ -2275,6 +2636,71 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
         next = finalizeState(next);
         return { state: next };
       });
+    },
+    async hydrateLoopSessionAsync(loopSessionId, events, options) {
+      const { hydratingLoopSessionIds } = get();
+      if (hydratingLoopSessionIds[loopSessionId]) return;
+      const filtered = filterAgentLoopReplayEvents(events);
+      if (filtered.length === 0) return;
+      const chunkSize = options?.chunkSize ?? DEFAULT_HYDRATE_CHUNK_SIZE;
+      const signal = options?.signal;
+      set((current) => ({
+        hydratingLoopSessionIds: {
+          ...current.hydratingLoopSessionIds,
+          [loopSessionId]: true
+        }
+      }));
+      try {
+        let tree = get().state.loopTreesBySessionId[loopSessionId] ?? createEmptyTree();
+        let idx = get().eventCount;
+        for (let offset = 0; offset < filtered.length; offset += chunkSize) {
+          if (signal?.aborted) {
+            throw new DOMException("Hydrate aborted", "AbortError");
+          }
+          const chunk = filtered.slice(offset, offset + chunkSize);
+          for (const event of chunk) {
+            tree = reduceTree(tree, event, idx, reduceOpts);
+            idx += 1;
+          }
+          const isLastChunk = offset + chunkSize >= filtered.length;
+          set((current) => {
+            let next = {
+              ...current.state,
+              loopTreesBySessionId: {
+                ...current.state.loopTreesBySessionId,
+                [loopSessionId]: tree
+              }
+            };
+            if (isLastChunk) {
+              next = touchCompletedLoopSession(next, loopSessionId);
+              next = evictCompletedLoopOverflow(next, maxHydratedCompletedLoops);
+            }
+            next = finalizeState(next);
+            return { state: next };
+          });
+          if (!isLastChunk) {
+            await nextAnimationFrame();
+          }
+        }
+      } catch {
+        set((current) => {
+          const { [loopSessionId]: _removed, ...restLoops } = current.state.loopTreesBySessionId;
+          return {
+            state: { ...current.state, loopTreesBySessionId: restLoops },
+            hydratingLoopSessionIds: withoutHydrating(
+              current.hydratingLoopSessionIds,
+              loopSessionId
+            )
+          };
+        });
+        return;
+      }
+      set((current) => ({
+        hydratingLoopSessionIds: withoutHydrating(
+          current.hydratingLoopSessionIds,
+          loopSessionId
+        )
+      }));
     }
   }));
 }
@@ -2283,7 +2709,7 @@ function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionSta
 import { useMemo as useMemo7, useState as useState6 } from "react";
 
 // src/view/workflow/WorkflowAggregateContainer.tsx
-import { useCallback, useEffect as useEffect3, useMemo as useMemo2, useState } from "react";
+import { useCallback, useEffect as useEffect3, useMemo as useMemo2, useState, memo } from "react";
 
 // src/view/workflow/WorkflowContainerLine.tsx
 import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
@@ -2427,6 +2853,76 @@ function WorkflowMarkdownPreview({
   return /* @__PURE__ */ jsx7("div", { className, "data-testid": testId, children: /* @__PURE__ */ jsx7(RichMarkdown, { content, deferDiagrams: true }) });
 }
 
+// src/view/workflow/workflowStageListUtils.ts
+var ACTIVE_CONTAINER_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "retrying",
+  "pending",
+  "blocked"
+]);
+function isDescendantContainer(containersById, ancestorId, nodeId) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = containersById[nodeId]?.parent_container_id ?? null;
+  while (current) {
+    if (current === ancestorId) return true;
+    if (seen.has(current)) return false;
+    seen.add(current);
+    current = containersById[current]?.parent_container_id ?? null;
+  }
+  return false;
+}
+function subtreeHasActiveWork(containersById, rootContainerId) {
+  for (const node of Object.values(containersById)) {
+    if (node.container_id === rootContainerId) continue;
+    if (!isDescendantContainer(containersById, rootContainerId, node.container_id)) continue;
+    if (ACTIVE_CONTAINER_STATUSES.has(node.status)) return true;
+  }
+  return false;
+}
+function stageSortKey(node) {
+  return node.display?.progress_current ?? 0;
+}
+function partitionWorkflowStages(stages, maxVisibleDoneCount, containersById) {
+  const sorted = [...stages].sort(
+    (a, b) => stageSortKey(a) - stageSortKey(b) || a.scope_key.localeCompare(b.scope_key)
+  );
+  const always = [];
+  const done = [];
+  for (const stage of sorted) {
+    if (containersById && subtreeHasActiveWork(containersById, stage.container_id)) {
+      always.push(stage);
+      continue;
+    }
+    if (stage.status === "running" || stage.status === "retrying" || stage.status === "failed" || stage.status === "pending" || stage.status === "blocked") {
+      always.push(stage);
+    } else if (stage.status === "completed" || stage.status === "skipped") {
+      done.push(stage);
+    } else {
+      always.push(stage);
+    }
+  }
+  const visibleDone = done.slice(Math.max(0, done.length - maxVisibleDoneCount));
+  const visible = [...always, ...visibleDone].sort(
+    (a, b) => stageSortKey(a) - stageSortKey(b) || a.scope_key.localeCompare(b.scope_key)
+  );
+  const hiddenCount = stages.length - visible.length;
+  return {
+    visible,
+    hiddenCount,
+    total: stages.length,
+    visibleDoneCount: visibleDone.length,
+    totalDoneCount: done.length
+  };
+}
+function isActiveWorkflowContainer(node, activeLoopSessionId, activeContainerIds) {
+  if (activeContainerIds.includes(node.container_id)) return true;
+  if (node.status === "completed" || node.status === "failed" || node.status === "skipped") {
+    return false;
+  }
+  if (node.loopSessionId && node.loopSessionId === activeLoopSessionId) return true;
+  return false;
+}
+
 // src/view/workflow/workflowContainerLineUtils.ts
 function formatContainerScopeMetaLabel(scope) {
   return scope;
@@ -2496,6 +2992,27 @@ function buildWorkflowRootMeta(node) {
   }
   return withScopeMeta(node, meta);
 }
+function buildEffectiveWorkflowRootMeta(node, containersById) {
+  const meta = [];
+  if (node.pattern) meta.push(node.pattern);
+  const topStages = Object.values(containersById).filter(
+    (n) => n.scope === "stage" && n.parent_container_id === node.container_id
+  );
+  const total = node.display?.progress_total ?? Math.max(topStages.length, 1);
+  let settled = 0;
+  for (const stage of topStages) {
+    if (subtreeHasActiveWork(containersById, stage.container_id)) continue;
+    if (stage.status === "completed" || stage.status === "failed" || stage.status === "skipped") {
+      settled += 1;
+    }
+  }
+  if (total > 0) meta.push(`${settled}/${total}`);
+  return withScopeMeta(node, meta);
+}
+function isWorkflowRootVisuallyActive(node, containersById) {
+  if (node.status === "running" || node.status === "retrying") return true;
+  return subtreeHasActiveWork(containersById, node.container_id);
+}
 function buildStageLineMeta(node) {
   const progress = buildStageProgressMeta(node);
   return withScopeMeta(node, progress ? [progress] : []);
@@ -2551,6 +3068,29 @@ function mapAggregateUiStatus(node) {
   return mapContainerUiStatus(node.status);
 }
 
+// src/view/workflow/workflowContainerMemo.ts
+function displayVisualEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a.progress_current !== b.progress_current) return false;
+  if (a.status !== b.status) return false;
+  return true;
+}
+function workflowContainerNodeVisualEqual(a, b) {
+  if (a.container_id !== b.container_id) return false;
+  if (a.status !== b.status) return false;
+  if (a.is_open !== b.is_open) return false;
+  if (a.loopSessionId !== b.loopSessionId) return false;
+  if (a.title !== b.title) return false;
+  if (a.subtitle !== b.subtitle) return false;
+  if (a.content_blocks.length !== b.content_blocks.length) return false;
+  if (!displayVisualEqual(a.display, b.display)) return false;
+  return true;
+}
+function workflowContainerViewPropsEqual(prev, next) {
+  return prev.depth === next.depth && prev.virtualized === next.virtualized && prev.virtualizeThreshold === next.virtualizeThreshold && prev.groupParallelTools === next.groupParallelTools;
+}
+
 // src/view/workflow/WorkflowAggregateContainer.tsx
 import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
 function mergeContentPreview(node) {
@@ -2558,7 +3098,7 @@ function mergeContentPreview(node) {
   if (blocks.length === 0) return "";
   return blocks.map((block) => block.preview?.trim() ?? "").filter(Boolean).join("\n\n");
 }
-function WorkflowAggregateContainer({
+function WorkflowAggregateContainerInner({
   node,
   loopTree,
   siblingItems = [],
@@ -2678,12 +3218,59 @@ function WorkflowAggregateContainer({
     }
   );
 }
+function workflowAggregateContainerPropsEqual(prev, next) {
+  if (prev.loopTree !== next.loopTree) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  if (prev.siblingItems.length !== next.siblingItems.length) return false;
+  for (let i = 0; i < prev.siblingItems.length; i += 1) {
+    if (!workflowContainerNodeVisualEqual(prev.siblingItems[i], next.siblingItems[i])) {
+      return false;
+    }
+  }
+  return workflowContainerNodeVisualEqual(prev.node, next.node);
+}
+var WorkflowAggregateContainer = memo(
+  WorkflowAggregateContainerInner,
+  workflowAggregateContainerPropsEqual
+);
 
 // src/view/workflow/WorkflowParallelGroup.tsx
-import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useState as useState3 } from "react";
-import { useStore as useStore3 } from "zustand";
+import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useState as useState3, memo as memo3 } from "react";
 
 // src/core/workflow/workflowParallelGroupMetrics.ts
+var ACTIVE_ITEM_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "retrying",
+  "pending",
+  "blocked"
+]);
+function countMetricsFromContainerStatus(items) {
+  let running = 0;
+  let completed = 0;
+  let failed = 0;
+  for (const item of items) {
+    if (ACTIVE_ITEM_STATUSES.has(item.status)) {
+      running += 1;
+      continue;
+    }
+    switch (item.status) {
+      case "completed":
+        completed += 1;
+        break;
+      case "failed":
+        failed += 1;
+        break;
+      default:
+        break;
+    }
+  }
+  return {
+    total: items.length,
+    running,
+    completed,
+    failed
+  };
+}
 function readDisplayMetrics(items) {
   let hasMetrics = false;
   let running = 0;
@@ -2704,34 +3291,29 @@ function readDisplayMetrics(items) {
   if (total <= 0) total = items.length;
   return { total, running, completed, failed };
 }
+function mergeParallelGroupMetrics(fromDisplay, fromStatus, itemCount) {
+  return {
+    total: Math.max(fromDisplay.total, fromStatus.total, itemCount),
+    running: Math.max(fromDisplay.running, fromStatus.running),
+    completed: Math.max(fromDisplay.completed, fromStatus.completed),
+    failed: Math.max(fromDisplay.failed, fromStatus.failed)
+  };
+}
 function computeParallelGroupMetrics(items) {
+  const fromStatus = countMetricsFromContainerStatus(items);
   const fromDisplay = readDisplayMetrics(items);
-  if (fromDisplay) return fromDisplay;
-  let running = 0;
-  let completed = 0;
-  let failed = 0;
+  if (!fromDisplay) return fromStatus;
+  return mergeParallelGroupMetrics(fromDisplay, fromStatus, items.length);
+}
+function parallelGroupHasActiveWork(items, loopTreesBySessionId = {}) {
+  const metrics = computeParallelGroupMetrics(items);
+  if (metrics.running > 0) return true;
   for (const item of items) {
-    switch (item.status) {
-      case "running":
-      case "retrying":
-        running += 1;
-        break;
-      case "completed":
-        completed += 1;
-        break;
-      case "failed":
-        failed += 1;
-        break;
-      default:
-        break;
-    }
+    const loopSessionId = item.loopSessionId;
+    if (!loopSessionId) continue;
+    if (isWorkflowLoopTreeActive(loopTreesBySessionId[loopSessionId])) return true;
   }
-  return {
-    total: items.length,
-    running,
-    completed,
-    failed
-  };
+  return false;
 }
 function formatParallelGroupSummary(metrics) {
   if (metrics.running > 0) {
@@ -2747,7 +3329,7 @@ function formatParallelGroupSummary(metrics) {
 }
 
 // src/view/workflow/WorkflowStageContainer.tsx
-import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useState as useState2 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useState as useState2, memo as memo2 } from "react";
 import { useStore as useStore2 } from "zustand";
 
 // src/core/workflow/loopTreeUtils.ts
@@ -2788,44 +3370,6 @@ function WorkflowStageDoneBody({
   );
 }
 
-// src/view/workflow/workflowStageListUtils.ts
-function stageSortKey(node) {
-  return node.display?.progress_current ?? 0;
-}
-function partitionWorkflowStages(stages, maxVisibleDoneCount) {
-  const sorted = [...stages].sort(
-    (a, b) => stageSortKey(a) - stageSortKey(b) || a.scope_key.localeCompare(b.scope_key)
-  );
-  const always = [];
-  const done = [];
-  for (const stage of sorted) {
-    if (stage.status === "running" || stage.status === "retrying" || stage.status === "failed" || stage.status === "pending" || stage.status === "blocked") {
-      always.push(stage);
-    } else if (stage.status === "completed" || stage.status === "skipped") {
-      done.push(stage);
-    } else {
-      always.push(stage);
-    }
-  }
-  const visibleDone = done.slice(Math.max(0, done.length - maxVisibleDoneCount));
-  const visible = [...always, ...visibleDone].sort(
-    (a, b) => stageSortKey(a) - stageSortKey(b) || a.scope_key.localeCompare(b.scope_key)
-  );
-  const hiddenCount = stages.length - visible.length;
-  return {
-    visible,
-    hiddenCount,
-    total: stages.length,
-    visibleDoneCount: visibleDone.length,
-    totalDoneCount: done.length
-  };
-}
-function isActiveWorkflowContainer(node, activeLoopSessionId, activeContainerIds) {
-  if (activeContainerIds.includes(node.container_id)) return true;
-  if (node.loopSessionId && node.loopSessionId === activeLoopSessionId) return true;
-  return false;
-}
-
 // src/view/workflow/WorkflowStageContainer.tsx
 import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
 function containerTestId(node) {
@@ -2837,16 +3381,17 @@ function bodyTestId(node) {
   if (node.scope === "item") return `lax-workflow-parallel-body-${node.scope_key}`;
   return `lax-workflow-stage-body-${node.scope_key}`;
 }
-function WorkflowStageContainer({
+function WorkflowStageContainerInner({
   node,
   loopTree,
   depth = 0,
   virtualized,
   virtualizeThreshold,
-  groupParallelTools
+  groupParallelTools,
+  suppressHostScopedLoop = false,
+  subtreeHasActiveWork: subtreeHasActiveWork2 = false
 }) {
   const { verbose } = useSessionViewOptions();
-  const scale = useWorkflowScaleOptions();
   const store = useWorkflowSessionStoreApi();
   const replayHandler = useWorkflowLoopReplayHandler();
   const activeLoopSessionId = useStore2(store, (s) => s.state.activeLoopSessionId);
@@ -2856,31 +3401,30 @@ function WorkflowStageContainer({
     (s) => s.state.stageDoneSummariesByContainerId[node.container_id]
   );
   const pinLoopSession = useStore2(store, (s) => s.pinLoopSession);
-  const uiStatus = mapContainerUiStatus(node.status);
   const isRunning = node.status === "running" || node.status === "retrying";
   const isDone = node.status === "completed" || node.status === "failed";
   const isSkipped = node.status === "skipped";
+  const loopStillActive = isWorkflowLoopTreeActive(loopTree);
+  const effectivelyRunning = isRunning || loopStillActive || subtreeHasActiveWork2 && isDone;
+  const effectivelyDone = isDone && !subtreeHasActiveWork2 && !loopStillActive;
+  const uiStatus = mapContainerUiStatus(effectivelyRunning ? "running" : node.status);
   const isActive = isActiveWorkflowContainer(node, activeLoopSessionId, activeContainerIds);
   const doneSummaryFromTree = useMemo3(
     () => loopTree && isDone ? buildStageDoneSummary(loopTree) : null,
     [loopTree, isDone]
   );
   const doneSummary = doneSummaryFromTree ?? (isDone ? cachedSummary : null);
-  const shouldAutoExpandRunning = isRunning && !isSkipped && (!scale.onlyExpandActiveRunning || isActive);
+  const shouldAutoExpandRunning = effectivelyRunning && !isSkipped;
   const [expanded, setExpanded] = useState2(shouldAutoExpandRunning);
   useEffect4(() => {
     if (shouldAutoExpandRunning) {
       setExpanded(true);
       return;
     }
-    if (isRunning && !isSkipped && scale.onlyExpandActiveRunning) {
-      setExpanded(false);
-      return;
-    }
-    if (isDone || isSkipped) {
+    if (effectivelyDone || isSkipped) {
       setExpanded(false);
     }
-  }, [shouldAutoExpandRunning, isRunning, isDone, isSkipped, scale.onlyExpandActiveRunning]);
+  }, [shouldAutoExpandRunning, effectivelyDone, isSkipped]);
   const requestLoopHydration = useCallback2(() => {
     const loopSessionId = node.loopSessionId;
     if (!loopSessionId || loopTree) return;
@@ -2905,17 +3449,18 @@ function WorkflowStageContainer({
     window.addEventListener("keydown", onKeyDown);
     return () => window.removeEventListener("keydown", onKeyDown);
   }, [requestLoopHydration]);
+  const testId = containerTestId(node);
+  const isItem = node.scope === "item";
   const displayTitle = node.title;
-  const usesScopedLoop = Boolean(node.loopSessionId);
-  const runningLoopTree = loopTree ?? (usesScopedLoop && isRunning && isActive ? createWorkflowRunningLoopTree() : void 0);
+  const usesScopedLoop = Boolean(node.loopSessionId) && !suppressHostScopedLoop;
+  const runningLoopTree = loopTree ?? (usesScopedLoop && effectivelyRunning ? createWorkflowRunningLoopTree() : void 0);
+  const itemLoopVirtualized = isItem ? false : virtualized;
   const staticContentTeaser = !usesScopedLoop && !loopTree && node.content_blocks.length > 0 ? node.content_blocks[node.content_blocks.length - 1].preview : "";
   const teaserText = doneSummary?.teaser || staticContentTeaser;
   const expandHint = doneSummary ? formatTeaserExpandHint(doneSummary.extraLines, verbose) : null;
   const doneLabel = doneSummary?.label ?? "done";
-  const statusLabel = isDone ? doneLabel : mapContainerStatusLabel(node.status);
-  const testId = containerTestId(node);
-  const isItem = node.scope === "item";
-  const canToggleShell = isRunning && !isSkipped || isDone;
+  const statusLabel = effectivelyDone ? doneLabel : suppressHostScopedLoop && effectivelyRunning ? "running" : mapContainerStatusLabel(effectivelyRunning ? "running" : node.status);
+  const canToggleShell = effectivelyRunning && !isSkipped || effectivelyDone;
   const shellToggle = canToggleShell ? toggleExpanded : void 0;
   return /* @__PURE__ */ jsxs5(
     "div",
@@ -2941,13 +3486,13 @@ function WorkflowStageContainer({
             onToggle: shellToggle,
             interactive: canToggleShell,
             expanded,
-            headerTestId: isDone ? `${testId}-done` : void 0,
+            headerTestId: effectivelyDone ? `${testId}-done` : void 0,
             titleTestId: `${testId}-title`,
             descriptionTestId: `${testId}-desc`,
             className: isItem ? "lax-workflow-parallel-item__header" : void 0
           }
         ),
-        isDone && !expanded && (teaserText || expandHint) ? /* @__PURE__ */ jsxs5("div", { className: "lax-workflow-stage-container__done-teaser", children: [
+        effectivelyDone && !expanded && (teaserText || expandHint) ? /* @__PURE__ */ jsxs5("div", { className: "lax-workflow-stage-container__done-teaser", children: [
           teaserText ? /* @__PURE__ */ jsx10(
             "span",
             {
@@ -2973,7 +3518,7 @@ function WorkflowStageContainer({
             ))
           }
         ) : null,
-        expanded && isRunning && runningLoopTree ? /* @__PURE__ */ jsx10(
+        expanded && effectivelyRunning && runningLoopTree ? /* @__PURE__ */ jsx10(
           "div",
           {
             className: isItem ? "lax-workflow-parallel-item__body lax-workflow-stage-container__body" : "lax-workflow-stage-container__body",
@@ -2983,20 +3528,20 @@ function WorkflowStageContainer({
               {
                 tree: runningLoopTree,
                 showTaskListFooter: false,
-                virtualized,
+                virtualized: itemLoopVirtualized,
                 virtualizeThreshold,
                 groupParallelTools
               }
             )
           }
         ) : null,
-        isDone && expanded ? loopTree ? /* @__PURE__ */ jsx10(
+        effectivelyDone && expanded ? loopTree ? /* @__PURE__ */ jsx10(
           WorkflowStageDoneBody,
           {
             node,
             loopTree,
             testId: bodyTestId(node),
-            virtualized,
+            virtualized: itemLoopVirtualized,
             virtualizeThreshold,
             groupParallelTools,
             bodyClassName: isItem ? "lax-workflow-parallel-item__body lax-workflow-stage-container__body" : "lax-workflow-stage-container__body"
@@ -3016,6 +3561,14 @@ function WorkflowStageContainer({
     }
   );
 }
+function workflowStageContainerPropsEqual(prev, next) {
+  if (prev.suppressHostScopedLoop !== next.suppressHostScopedLoop) return false;
+  if (prev.subtreeHasActiveWork !== next.subtreeHasActiveWork) return false;
+  if (prev.loopTree !== next.loopTree) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  return workflowContainerNodeVisualEqual(prev.node, next.node);
+}
+var WorkflowStageContainer = memo2(WorkflowStageContainerInner, workflowStageContainerPropsEqual);
 
 // src/view/workflow/WorkflowParallelGroup.tsx
 import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
@@ -3023,7 +3576,7 @@ function resolveLoopTree(node, loopTreesBySessionId) {
   if (!node.loopSessionId) return void 0;
   return loopTreesBySessionId[node.loopSessionId];
 }
-function WorkflowParallelGroup({
+function WorkflowParallelGroupInner({
   groupKey,
   items,
   loopTreesBySessionId,
@@ -3032,33 +3585,23 @@ function WorkflowParallelGroup({
   virtualizeThreshold,
   groupParallelTools
 }) {
-  const scale = useWorkflowScaleOptions();
-  const store = useWorkflowSessionStoreApi();
-  const activeLoopSessionId = useStore3(store, (s) => s.state.activeLoopSessionId);
-  const activeContainerIds = useStore3(store, (s) => s.state.containerTree.activeContainerIds);
   const metrics = useMemo4(() => computeParallelGroupMetrics(items), [items]);
   const summary = formatParallelGroupSummary(metrics);
-  const hasRunning = metrics.running > 0;
-  const hasActiveItem = useMemo4(
-    () => items.some((item) => isActiveWorkflowContainer(item, activeLoopSessionId, activeContainerIds)),
-    [items, activeLoopSessionId, activeContainerIds]
+  const hasActiveWork = useMemo4(
+    () => parallelGroupHasActiveWork(items, loopTreesBySessionId),
+    [items, loopTreesBySessionId]
   );
   const allSettled = metrics.total > 0 && metrics.running === 0 && metrics.completed + metrics.failed >= metrics.total;
-  const shouldAutoExpandGroup = hasRunning && (!scale.onlyExpandActiveRunning || hasActiveItem);
-  const [expanded, setExpanded] = useState3(shouldAutoExpandGroup);
+  const [expanded, setExpanded] = useState3(hasActiveWork);
   useEffect5(() => {
-    if (shouldAutoExpandGroup) {
+    if (hasActiveWork) {
       setExpanded(true);
       return;
     }
-    if (hasRunning && scale.onlyExpandActiveRunning) {
-      setExpanded(false);
-      return;
-    }
     if (allSettled) {
       setExpanded(false);
     }
-  }, [shouldAutoExpandGroup, hasRunning, allSettled, scale.onlyExpandActiveRunning]);
+  }, [hasActiveWork, allSettled]);
   const toggleExpanded = useCallback3(() => {
     setExpanded((prev) => !prev);
   }, []);
@@ -3095,7 +3638,7 @@ function WorkflowParallelGroup({
           WorkflowExpandTrigger,
           {
             summary,
-            expandHint: !expanded && !hasRunning ? "(ctrl+o to expand)" : null,
+            expandHint: !expanded && hasActiveWork ? "(click to expand agents)" : !expanded && !hasActiveWork ? "(ctrl+o to expand)" : null,
             onToggle: toggleExpanded,
             expanded,
             testId: `lax-workflow-parallel-group-summary-${groupKey}`,
@@ -3107,16 +3650,37 @@ function WorkflowParallelGroup({
     }
   );
 }
+function workflowParallelGroupPropsEqual(prev, next) {
+  if (prev.groupKey !== next.groupKey) return false;
+  if (!workflowContainerViewPropsEqual(prev, next)) return false;
+  if (prev.items.length !== next.items.length) return false;
+  for (let i = 0; i < prev.items.length; i += 1) {
+    const prevItem = prev.items[i];
+    const nextItem = next.items[i];
+    if (!workflowContainerNodeVisualEqual(prevItem, nextItem)) return false;
+    const loopSessionId = prevItem.loopSessionId;
+    if (loopSessionId) {
+      if (prev.loopTreesBySessionId[loopSessionId] !== next.loopTreesBySessionId[loopSessionId]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var WorkflowParallelGroup = memo3(WorkflowParallelGroupInner, workflowParallelGroupPropsEqual);
 
 // src/view/workflow/WorkflowRootContainer.tsx
 import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
 function WorkflowRootContainer({
   node,
-  children
+  children,
+  containersById
 }) {
   const { verbose } = useSessionViewOptions();
-  const uiStatus = mapContainerUiStatus(node.status);
-  const statusLabel = mapWorkflowRootStatusLabel(node.status);
+  const visuallyActive = containersById ? isWorkflowRootVisuallyActive(node, containersById) : node.status === "running" || node.status === "retrying";
+  const uiStatus = mapContainerUiStatus(visuallyActive ? "running" : node.status);
+  const statusLabel = mapWorkflowRootStatusLabel(visuallyActive ? "running" : node.status);
+  const meta = containersById ? buildEffectiveWorkflowRootMeta(node, containersById) : buildWorkflowRootMeta(node);
   return /* @__PURE__ */ jsxs7("div", { className: "lax-workflow-root", "data-testid": "lax-workflow-root", children: [
     /* @__PURE__ */ jsx12(
       WorkflowContainerLine,
@@ -3125,7 +3689,7 @@ function WorkflowRootContainer({
         title: node.title,
         description: node.subtitle || void 0,
         uiStatus,
-        meta: buildWorkflowRootMeta(node),
+        meta,
         statusLabel,
         titleTestId: "lax-workflow-root-title",
         descriptionTestId: "lax-workflow-root-desc",
@@ -3253,31 +3817,36 @@ function buildDoneSummary(node) {
 function WorkflowSubworkflowContainer({
   node,
   depth = 1,
-  children
+  children,
+  subtreeHasActiveWork: subtreeHasActiveWork2 = false
 }) {
   const { verbose } = useSessionViewOptions();
-  const uiStatus = mapContainerUiStatus(node.status);
   const isRunning = node.status === "running" || node.status === "retrying";
   const isDone = node.status === "completed" || node.status === "failed";
+  const effectivelyRunning = isRunning || subtreeHasActiveWork2;
+  const effectivelyDone = isDone && !subtreeHasActiveWork2;
+  const uiStatus = mapContainerUiStatus(
+    effectivelyRunning ? "running" : node.status
+  );
   const testId = `lax-workflow-subworkflow-${node.scope_key}`;
   const teaser = useMemo6(() => {
     if (node.content_blocks.length === 0) return "";
     return node.content_blocks[node.content_blocks.length - 1]?.preview ?? "";
   }, [node.content_blocks]);
-  const [expanded, setExpanded] = useState5(isRunning);
+  const [expanded, setExpanded] = useState5(effectivelyRunning);
   useEffect7(() => {
-    if (isRunning) setExpanded(true);
-    if (isDone) setExpanded(false);
-  }, [isRunning, isDone]);
+    if (effectivelyRunning) setExpanded(true);
+    else if (effectivelyDone) setExpanded(false);
+  }, [effectivelyRunning, effectivelyDone]);
   const toggleExpanded = useCallback5(() => {
     setExpanded((prev) => !prev);
   }, []);
-  const shellToggle = isRunning ? toggleExpanded : isDone && expanded ? toggleExpanded : void 0;
+  const shellToggle = effectivelyRunning ? toggleExpanded : effectivelyDone && expanded ? toggleExpanded : void 0;
   const depthStyle = {
     "--lax-workflow-depth": depth,
     "--lax-workflow-indent-unit": workflowIndentUnit(depth)
   };
-  const showShellLine = !(isDone && !expanded);
+  const showShellLine = !(effectivelyDone && !expanded);
   return /* @__PURE__ */ jsxs9(
     "div",
     {
@@ -3294,9 +3863,11 @@ function WorkflowSubworkflowContainer({
             description: node.subtitle || void 0,
             uiStatus,
             meta: buildWorkflowRootMeta(node),
-            statusLabel: mapWorkflowRootStatusLabel(node.status),
+            statusLabel: mapWorkflowRootStatusLabel(
+              effectivelyRunning ? "running" : node.status
+            ),
             onToggle: shellToggle,
-            interactive: isRunning,
+            interactive: effectivelyRunning,
             expanded,
             titleTestId: `${testId}-title`,
             descriptionTestId: `${testId}-desc`,
@@ -3313,15 +3884,16 @@ function WorkflowSubworkflowContainer({
             children
           }
         ) : null,
-        isDone && !expanded ? /* @__PURE__ */ jsx14(
+        !expanded && children ? /* @__PURE__ */ jsx14(
           WorkflowExpandTrigger,
           {
-            summary: `${node.title} \xB7 ${buildDoneSummary(node)}`,
+            summary: `${node.title} \xB7 ${effectivelyDone ? buildDoneSummary(node) : "running"}`,
             summaryTestId: `${testId}-title`,
             teaser: teaser || void 0,
+            expandHint: effectivelyRunning ? "(click to expand subworkflow)" : void 0,
             onToggle: () => setExpanded(true),
             expanded: false,
-            testId: `${testId}-done`,
+            testId: effectivelyDone ? `${testId}-done` : `${testId}-running-collapsed`,
             teaserTestId: teaser ? `${testId}-teaser` : void 0
           }
         ) : null
@@ -3345,8 +3917,9 @@ function collectSiblingItems(node, containersById) {
     (child) => child.scope === "item"
   );
 }
-function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps) {
+function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps, options) {
   const loopTree = resolveLoopTree2(node, loopTreesBySessionId);
+  const subtreeActive = options?.subtreeHasActiveWork ?? subtreeHasActiveWork(containerTree.containersById, node.container_id);
   switch (node.scope) {
     case "aggregate":
       return /* @__PURE__ */ jsx15(
@@ -3378,6 +3951,8 @@ function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, v
           node,
           loopTree,
           depth,
+          suppressHostScopedLoop: options?.suppressHostScopedLoop,
+          subtreeHasActiveWork: subtreeActive,
           ...viewProps
         },
         node.container_id
@@ -3402,6 +3977,11 @@ function renderItemSiblings(items, groupKey, depth, containerTree, loopTreesBySe
   }
   return null;
 }
+function stageHasSubworkflowChild(stageId, containerTree) {
+  return collectChildContainers(containerTree.containersById, stageId).some(
+    (node) => node.scope === "subworkflow"
+  );
+}
 function renderContainerChildren(parentId, containerTree, loopTreesBySessionId, viewProps, depth) {
   const children = collectChildContainers(containerTree.containersById, parentId);
   const items = children.filter((node) => node.scope === "item");
@@ -3426,19 +4006,31 @@ function renderContainerNode(node, containerTree, loopTreesBySessionId, viewProp
       {
         node,
         depth,
+        subtreeHasActiveWork: subtreeHasActiveWork(
+          containerTree.containersById,
+          node.container_id
+        ),
         children: hasNested ? nested : null
       },
       node.container_id
     );
   }
   if (node.scope === "stage") {
+    const suppressHostScopedLoop = stageHasSubworkflowChild(node.container_id, containerTree);
     return /* @__PURE__ */ jsxs10(
       "div",
       {
         className: "lax-workflow-nested-block",
         "data-testid": `lax-workflow-nested-${node.scope}-${node.scope_key}`,
         children: [
-          renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps),
+          renderLeafContainer(
+            node,
+            depth,
+            containerTree,
+            loopTreesBySessionId,
+            viewProps,
+            { suppressHostScopedLoop }
+          ),
           hasNested ? /* @__PURE__ */ jsx15("div", { className: "lax-workflow-container-children", children: nested }) : null
         ]
       },
@@ -3479,8 +4071,8 @@ function WorkflowStageListPanel({
   const [extraCompletedPages, setExtraCompletedPages] = useState6(0);
   const maxVisibleDoneCount = scale.completedStagePageSize + extraCompletedPages * scale.completedStagePageSize;
   const partition = useMemo7(
-    () => partitionWorkflowStages(stages, maxVisibleDoneCount),
-    [stages, maxVisibleDoneCount]
+    () => partitionWorkflowStages(stages, maxVisibleDoneCount, containerTree.containersById),
+    [stages, maxVisibleDoneCount, containerTree.containersById]
   );
   if (partition.visible.length === 0) return null;
   const showMoreCount = Math.min(
@@ -3578,17 +4170,25 @@ function WorkflowChrome({
       }
     ) });
   }
-  return /* @__PURE__ */ jsx15("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: rootNodes.map((workflowNode) => /* @__PURE__ */ jsx15(WorkflowRootContainer, { node: workflowNode, children: renderWorkflowChildren(
-    workflowNode,
-    containerTree,
-    loopTreesBySessionId,
-    viewProps
-  ) }, workflowNode.container_id)) });
+  return /* @__PURE__ */ jsx15("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: rootNodes.map((workflowNode) => /* @__PURE__ */ jsx15(
+    WorkflowRootContainer,
+    {
+      node: workflowNode,
+      containersById: containerTree.containersById,
+      children: renderWorkflowChildren(
+        workflowNode,
+        containerTree,
+        loopTreesBySessionId,
+        viewProps
+      )
+    },
+    workflowNode.container_id
+  )) });
 }
 
 // src/view/workflow/WorkflowTaskListFooter.tsx
 import { useMemo as useMemo8, useState as useState7 } from "react";
-import { useStore as useStore4 } from "zustand";
+import { useStore as useStore3 } from "zustand";
 
 // src/view/workflow/workflowTaskListMerge.ts
 var STATUS_ORDER = {
@@ -3668,7 +4268,7 @@ function MessageResponse({ children }) {
 }
 function WorkflowTaskListFooter() {
   const store = useWorkflowSessionStoreApi();
-  const state = useStore4(store, (s) => s.state);
+  const state = useStore3(store, (s) => s.state);
   const [expanded, setExpanded] = useState7(false);
   const footerState = useMemo8(() => deriveWorkflowTaskFooterState(state), [state]);
   const visible = shouldShowWorkflowTaskListFooter(state);
@@ -3708,7 +4308,7 @@ function WorkflowTaskListFooter() {
 }
 
 // src/view/workflow/WorkflowSession.tsx
-import { useStore as useStore5 } from "zustand";
+import { useStore as useStore4 } from "zustand";
 import { jsx as jsx17, jsxs as jsxs12 } from "react/jsx-runtime";
 function WorkflowSession({
   source,
@@ -3731,6 +4331,7 @@ function WorkflowSession({
   groupParallelTools = false,
   workflowScale,
   onRequestLoopReplay,
+  onStreamComplete,
   children
 }) {
   const storeRef = useRef3(null);
@@ -3780,37 +4381,61 @@ function WorkflowSession({
       workspaceRoot
     ]
   );
-  const containerTree = useStore5(
+  const containerTree = useStore4(
     storeRef.current,
     (s) => s.state.containerTree
   );
-  const loopTreesBySessionId = useStore5(
+  const loopTreesBySessionId = useStore4(
     storeRef.current,
     (s) => s.state.loopTreesBySessionId
   );
+  const sessionStatus = useStore4(
+    storeRef.current,
+    (s) => s.state.status
+  );
+  const internalErrors = useStore4(
+    storeRef.current,
+    (s) => s.state.internalErrors
+  );
+  const onErrorRef = useRef3(onError);
+  const onStreamCompleteRef = useRef3(onStreamComplete);
+  onErrorRef.current = onError;
+  onStreamCompleteRef.current = onStreamComplete;
   useEffect8(() => {
     const store = storeRef.current;
     const controller = new AbortController();
     void source.start((event, ctx) => {
       store.getState().applyEvent(event, ctx);
-    }, controller.signal).catch((err) => {
+    }, controller.signal).then(() => {
+      store.getState().markStreamComplete();
+      onStreamCompleteRef.current?.();
+    }).catch((err) => {
       if (err instanceof SseTransportTerminalError) {
-        const { state } = store.getState();
-        if (state.status === "running") {
-          store.setState({ state: { ...state, status: "error" } });
-        }
+        store.getState().markAsError(err);
+        onErrorRef.current?.(err);
+      } else if (err instanceof Error) {
+        onErrorRef.current?.(err);
       }
     });
     return () => {
       controller.abort();
     };
-  }, [source, onError]);
+  }, [source]);
   return /* @__PURE__ */ jsx17(WorkflowSessionStoreContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx17(WorkflowScaleContext.Provider, { value: scaleOptions, children: /* @__PURE__ */ jsx17(WorkflowLoopReplayProvider, { onRequestLoopReplay, children: /* @__PURE__ */ jsx17(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx17(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx17(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx17(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx17(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs12(
     "div",
     {
       className: "lax-agent-session lax-workflow-session",
       "data-testid": "lax-workflow-session",
       children: [
+        sessionStatus === "error" || internalErrors.length > 0 ? /* @__PURE__ */ jsx17(
+          "div",
+          {
+            className: "lax-workflow-error",
+            "data-testid": "lax-workflow-error",
+            role: "alert",
+            children: internalErrors[internalErrors.length - 1]?.message ?? "Workflow stream error"
+          }
+        ) : null,
         /* @__PURE__ */ jsx17(
           WorkflowChrome,
           {
@@ -4018,6 +4643,7 @@ export {
   createReplaySource,
   createSessionStore,
   createWorkflowSessionStore,
+  deriveLoopSessionIdFromAgentEvent,
   displayPath,
   entryKey,
   filterAgentLoopReplayEvents,