langchain_agentx_stream_ui 0.1.8 → 0.2.0

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   fixDiagramSvg,
   markEventIdSeen,
   shouldSkipDuplicateEvent
-} from "./chunk-WPW3TQQF.js";
+} from "./chunk-2T26L3VT.js";
 import {
   DefaultToolBody,
   InteractionBusContext,
@@ -111,7 +111,7 @@ import {
   useSessionStatus,
   useSessionViewOptions,
   useTimeline
-} from "./chunk-LBJFJF22.js";
+} from "./chunk-ZNXAQ4ZZ.js";
 import {
   Agent,
   AgentToolBody,
@@ -768,6 +768,30 @@ function createWorkflowRunningLoopTree(seedMs = Date.now()) {
   tree.meta.startedAt = seedMs;
   return tree;
 }
+function finalizeWorkflowLoopTree(tree, terminalStatus = "done") {
+  if (tree.status === "done" || tree.status === "error") {
+    return tree;
+  }
+  const byId = { ...tree.byId };
+  for (const [id, node] of Object.entries(byId)) {
+    if (!node) continue;
+    if ((node.kind === "text" || node.kind === "reasoning") && node.status === "streaming") {
+      byId[id] = { ...node, status: "done" };
+    }
+    if (node.kind === "tool_call" && node.status === "running") {
+      byId[id] = {
+        ...node,
+        status: terminalStatus === "error" ? "failed" : "done"
+      };
+    }
+  }
+  return {
+    ...tree,
+    byId,
+    activeRoundId: null,
+    status: terminalStatus
+  };
+}
 
 // src/types/workflowDisplay.ts
 function readDisplayPayload(data) {
@@ -926,7 +950,7 @@ function contentBlockFromEvent(event) {
   return null;
 }
 function resolveContentScopeKey(data) {
-  for (const keyName of ["stage_key", "item_key", "branch_key", "debug_key"]) {
+  for (const keyName of ["stage_key", "item_key", "branch_key", "aggregate_key", "debug_key"]) {
     const value = readString(data, keyName);
     if (value) return value;
   }
@@ -1145,17 +1169,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");
@@ -1226,6 +1257,7 @@ function readString2(data, key) {
 var LOOP_TASK_OPEN_SCOPES = {
   "stage-start": "stage",
   "parallel-item-start": "item",
+  "parallel-aggregate-start": "aggregate",
   "route-branch-start": "branch"
 };
 function buildLoopSessionId(workflowId, taskKey) {
@@ -1244,7 +1276,7 @@ function deriveLoopSessionIdFromAgentEvent(event) {
   const data = event.data ?? {};
   const workflowId = readString2(data, "workflow_id") ?? readString2(data, "workflow_path");
   if (!workflowId) return null;
-  const taskKey = readString2(data, "stage_key") ?? readString2(data, "item_key") ?? readString2(data, "branch_key");
+  const taskKey = readString2(data, "stage_key") ?? readString2(data, "item_key") ?? readString2(data, "branch_key") ?? readString2(data, "aggregate_key");
   if (!taskKey) return null;
   return buildLoopSessionId(workflowId, taskKey);
 }
@@ -1295,11 +1327,426 @@ function filterAgentLoopReplayEvents(events) {
   );
 }
 
-// src/core/workflowReducer.ts
+// 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();
+  const dash = trimmed.lastIndexOf("-");
+  if (dash <= 0 || dash >= trimmed.length - 1) return null;
+  return {
+    workflowId: trimmed.slice(0, dash),
+    taskKey: trimmed.slice(dash + 1)
+  };
+}
+function isEmbeddedChildLoopSession(sessionId, rootWorkflowId) {
+  const parts = parseLoopSessionParts(sessionId);
+  if (!parts) return false;
+  if (parts.workflowId === rootWorkflowId) return false;
+  if (parts.workflowId.startsWith(`${rootWorkflowId}-`)) return false;
+  if (rootWorkflowId.startsWith(`${parts.workflowId}-`)) return false;
+  return parts.workflowId.split("-").length >= 3;
+}
+function readWorkflowIdFromData(data) {
+  const value = data.workflow_id;
+  return typeof value === "string" ? value : void 0;
+}
+function readStageKeyFromData(data) {
+  const value = data.stage_key;
+  return typeof value === "string" ? value : void 0;
+}
+function shouldPrebindLoopSessionFromStructureOpen(eventType, eventSessionId, derivedLoopSessionId, data = {}) {
+  if (!eventSessionId) return true;
+  if (eventType !== "stage-start") return true;
+  if (eventSessionId === derivedLoopSessionId) return true;
+  const rootWorkflowId = readWorkflowIdFromData(data);
+  const stageKey = readStageKeyFromData(data);
+  const parsed = parseLoopSessionParts(eventSessionId);
+  if (rootWorkflowId && stageKey && parsed) {
+    if (parsed.workflowId === rootWorkflowId && parsed.taskKey !== stageKey) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveRootWorkflow(tree) {
+  const rootId = tree.rootContainerIds[0];
+  if (!rootId) return null;
+  const root = tree.containersById[rootId];
+  if (!root || root.scope !== "workflow") return null;
+  return {
+    workflowId: root.scope_key,
+    workflowPath: root.workflow_path
+  };
+}
+function humanizeTaskTitle(taskKey) {
+  if (taskKey === "aggregate") return "Merge Perspectives";
+  if (taskKey === "architecture") return "Architecture Path";
+  if (taskKey === "implementation") return "Implementation Path";
+  return taskKey.split("_").map((part) => part ? part[0].toUpperCase() + part.slice(1) : part).join(" ");
+}
+function findEmbeddedHostStage(tree, rootWorkflowPath, childWorkflowId) {
+  const childPath = `${rootWorkflowPath}>${childWorkflowId}`;
+  const subId = buildContainerId(childPath, "subworkflow", childWorkflowId);
+  const existingSub = tree.containersById[subId];
+  if (existingSub?.parent_container_id) {
+    return tree.containersById[existingSub.parent_container_id] ?? null;
+  }
+  const runningStages = tree.activeContainerIds.map((id) => tree.containersById[id]).filter(
+    (node) => node != null && node.scope === "stage" && node.workflow_path === rootWorkflowPath && node.is_open
+  );
+  if (runningStages.length === 0) return null;
+  return runningStages.reduce(
+    (best, node) => (node.display?.progress_current ?? 0) >= (best.display?.progress_current ?? 0) ? node : best
+  );
+}
+function upsertRuntimeNode(tree, node) {
+  const activeContainerIds = tree.activeContainerIds.includes(node.container_id) ? tree.activeContainerIds : node.is_open ? [...tree.activeContainerIds, node.container_id] : tree.activeContainerIds;
+  return {
+    ...tree,
+    activeContainerIds,
+    containersById: {
+      ...tree.containersById,
+      [node.container_id]: node
+    }
+  };
+}
+function completeOpenItemsUnderSubworkflow(tree, subworkflowId) {
+  let next = tree;
+  for (const node of Object.values(tree.containersById)) {
+    if (node.parent_container_id === subworkflowId && node.scope === "item" && node.status === "running") {
+      next = upsertRuntimeNode(next, {
+        ...node,
+        status: "completed",
+        is_open: false
+      });
+    }
+  }
+  const activeContainerIds = next.activeContainerIds.filter(
+    (id) => next.containersById[id]?.is_open
+  );
+  return { ...next, activeContainerIds };
+}
+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)) {
+    return tree;
+  }
+  const hostStage = findEmbeddedHostStage(tree, root.workflowPath, parts.workflowId);
+  if (!hostStage) return tree;
+  let next = tree;
+  if (hostStage.loopSessionId) {
+    next = upsertRuntimeNode(next, { ...hostStage, loopSessionId: null });
+  }
+  const childPath = `${root.workflowPath}>${parts.workflowId}`;
+  const subId = buildContainerId(childPath, "subworkflow", parts.workflowId);
+  let subNode = next.containersById[subId];
+  if (!subNode) {
+    subNode = {
+      container_id: subId,
+      scope: "subworkflow",
+      workflow_path: childPath,
+      workflow_depth: hostStage.workflow_depth + 1,
+      scope_key: parts.workflowId,
+      title: "Dual-Perspective Review",
+      subtitle: "Nested parallel sub-workflow",
+      status: "running",
+      pattern: "parallelization",
+      parent_container_id: hostStage.container_id,
+      display: {
+        title: "Dual-Perspective Review",
+        description: "Nested parallel sub-workflow",
+        pattern: "parallelization",
+        status: "running"
+      },
+      content_blocks: [],
+      is_open: true,
+      loopSessionId: null
+    };
+    next = upsertRuntimeNode(next, subNode);
+  }
+  const leafScope = resolveLeafScope(parts.taskKey);
+  const leafId = buildContainerId(childPath, leafScope, parts.taskKey);
+  let leafNode = next.containersById[leafId];
+  if (!leafNode) {
+    leafNode = {
+      container_id: leafId,
+      scope: leafScope,
+      workflow_path: childPath,
+      workflow_depth: hostStage.workflow_depth + 1,
+      scope_key: parts.taskKey,
+      title: humanizeTaskTitle(parts.taskKey),
+      subtitle: "",
+      status: "running",
+      pattern: "parallelization",
+      parent_container_id: subId,
+      display: {
+        title: humanizeTaskTitle(parts.taskKey),
+        pattern: "parallelization",
+        status: "running"
+      },
+      content_blocks: [],
+      is_open: true,
+      loopSessionId: null
+    };
+    next = upsertRuntimeNode(next, leafNode);
+  }
+  if (leafScope === "aggregate") {
+    next = completeOpenItemsUnderSubworkflow(next, subId);
+  }
+  if (leafNode.loopSessionId !== loopSessionId) {
+    next = upsertRuntimeNode(next, {
+      ...leafNode,
+      loopSessionId,
+      content_blocks: []
+    });
+  }
+  return next;
+}
+function findContainerIdByLoopSession(tree, loopSessionId) {
+  for (const [containerId, node] of Object.entries(tree.containersById)) {
+    if (node.loopSessionId === loopSessionId) return containerId;
+  }
+  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([
+  "parallel-aggregate-start",
+  "parallel-aggregate-done",
+  "parallel-aggregate-failed"
+]);
+function patchEmbeddedStructureEvent(event, rootWorkflowId) {
+  if (!EMBEDDED_AGGREGATE_STRUCTURE_EVENTS.has(event.event_type)) {
+    return event;
+  }
+  if (!event.session_id || !isEmbeddedChildLoopSession(event.session_id, rootWorkflowId)) {
+    return event;
+  }
+  const parts = parseLoopSessionParts(event.session_id);
+  if (!parts) return event;
+  const data = event.data ?? {};
+  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 {
+    ...event,
+    data: {
+      ...data,
+      workflow_path: childPath,
+      workflow_depth: workflowDepth
+    }
+  };
+}
+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;
+}
+function settleCompletedStageSubtree(tree, stageContainerId) {
+  let next = tree;
+  for (const node of Object.values(tree.containersById)) {
+    if (node.container_id !== stageContainerId && !isDescendantOf(tree.containersById, stageContainerId, node.container_id)) {
+      continue;
+    }
+    if (node.container_id === stageContainerId) continue;
+    if (node.status === "completed" || node.status === "failed") continue;
+    next = upsertRuntimeNode(next, {
+      ...node,
+      status: "completed",
+      is_open: false
+    });
+  }
+  const activeContainerIds = next.activeContainerIds.filter(
+    (id) => next.containersById[id]?.is_open
+  );
+  return { ...next, activeContainerIds };
+}
+function readWorkflowId(data) {
+  return readWorkflowIdFromData(data);
+}
+
+// src/core/workflowReducer.ts
+function readString5(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
 function mapContainerStatusToProgressStatus(status) {
   switch (status) {
     case "completed":
@@ -1376,23 +1823,43 @@ function applyStructureToContainerTree(tree, event) {
   };
 }
 function prebindLoopSessionFromStructureOpen(tree, event) {
-  const loopSessionId = deriveLoopSessionIdFromStructureOpen(event);
+  const derivedLoopSessionId = deriveLoopSessionIdFromStructureOpen(event);
   const scope = loopTaskScopeForStructureOpen(event.event_type);
-  if (!loopSessionId || !scope) return tree;
+  if (!derivedLoopSessionId || !scope) return tree;
   const data = event.data ?? {};
-  const workflowPath = readString3(data, "workflow_path") ?? "";
+  let loopSessionId = resolveStructureOpenLoopSessionId(
+    event.event_type,
+    event.session_id,
+    derivedLoopSessionId,
+    data
+  );
+  if (!shouldPrebindLoopSessionFromStructureOpen(
+    event.event_type,
+    event.session_id,
+    derivedLoopSessionId,
+    data
+  )) {
+    loopSessionId = derivedLoopSessionId;
+  }
+  let nextTree = event.event_type === "parallel-aggregate-start" ? ensureEmbeddedSubworkflowContainers(tree, loopSessionId) : tree;
+  const workflowPath = readString5(data, "workflow_path") ?? "";
   const scopeKey = resolveScopeKey(event.event_type, data);
   const containerId = buildContainerId(workflowPath, scope, scopeKey);
-  const node = tree.containersById[containerId];
-  if (!node) return tree;
+  let targetId = containerId;
+  const embeddedTargetId = findContainerIdByLoopSession(nextTree, loopSessionId);
+  if (embeddedTargetId) {
+    targetId = embeddedTargetId;
+  }
+  const node = nextTree.containersById[targetId];
+  if (!node) return nextTree;
   if (node.loopSessionId === loopSessionId && node.content_blocks.length === 0) {
-    return tree;
+    return nextTree;
   }
   return {
-    ...tree,
+    ...nextTree,
     containersById: {
-      ...tree.containersById,
-      [containerId]: {
+      ...nextTree.containersById,
+      [targetId]: {
         ...node,
         loopSessionId,
         content_blocks: []
@@ -1438,10 +1905,7 @@ function enrichWorkflowRootFromStages(containersById, rootContainerIds) {
   };
 }
 function findContainerByLoopSession(tree, loopSessionId) {
-  for (const [containerId, node] of Object.entries(tree.containersById)) {
-    if (node.loopSessionId === loopSessionId) return containerId;
-  }
-  return null;
+  return findContainerIdByLoopSession(tree, loopSessionId);
 }
 var WORKFLOW_DEFAULT_LOOP_SESSION_ID = "workflow-loop-default";
 function resolveAgentLoopSessionId(event, activeLoopSessionId) {
@@ -1456,56 +1920,184 @@ function resolveAgentLoopSessionId(event, activeLoopSessionId) {
 function bindLoopSessionToContainerTree(tree, event, activeLoopSessionId) {
   const sessionId = resolveAgentLoopSessionId(event, activeLoopSessionId);
   if (!sessionId) return tree;
-  if (findContainerByLoopSession(tree, sessionId)) return tree;
+  let nextTree = ensureEmbeddedSubworkflowContainers(tree, sessionId);
+  if (findContainerByLoopSession(nextTree, sessionId)) return nextTree;
   const data = event.data ?? {};
-  const workflowPath = readString3(data, "workflow_path") ?? null;
+  const workflowPath = readString5(data, "workflow_path") ?? null;
   const scopeKey = resolveContentScopeKey(data);
-  let targetId = null;
-  if (scopeKey) {
+  let targetId = findContainerByLoopSession(nextTree, sessionId);
+  if (!targetId && scopeKey) {
     targetId = resolveContentTargetFromSnapshot(
-      containerTreeToSnapshot(tree),
+      containerTreeToSnapshot(nextTree),
       workflowPath,
       scopeKey
     );
   }
   if (!targetId) {
-    for (const containerId of tree.activeContainerIds) {
-      const node2 = tree.containersById[containerId];
-      if ((node2?.scope === "item" || node2?.scope === "stage") && !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) {
     targetId = resolveContentTargetFromSnapshot(
-      containerTreeToSnapshot(tree),
+      containerTreeToSnapshot(nextTree),
       workflowPath,
       null
     );
   }
-  if (!targetId) return tree;
-  const node = tree.containersById[targetId];
-  if (!node || node.loopSessionId) return tree;
-  if (node.scope !== "stage" && node.scope !== "item" && node.scope !== "branch") {
-    return tree;
+  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;
   }
   return {
-    ...tree,
+    ...nextTree,
     containersById: {
-      ...tree.containersById,
+      ...nextTree.containersById,
       [targetId]: { ...node, loopSessionId: sessionId }
     }
   };
 }
+var LOOP_TASK_STRUCTURE_CLOSE_EVENTS = /* @__PURE__ */ new Set([
+  "stage-done",
+  "stage-failed",
+  "parallel-item-done",
+  "parallel-item-failed",
+  "parallel-aggregate-done",
+  "parallel-aggregate-failed",
+  "route-branch-done",
+  "route-branch-failed"
+]);
+function resolveStructureCloseLoopSessionId(event) {
+  const data = event.data ?? {};
+  const derived = deriveLoopSessionIdFromStructureOpen(event) ?? deriveLoopSessionIdFromAgentEvent(event);
+  if (!derived && !event.session_id) return null;
+  if (!derived) return event.session_id ?? null;
+  return resolveStructureOpenLoopSessionId(
+    event.event_type,
+    event.session_id,
+    derived,
+    data
+  );
+}
+function finalizeLoopTreesForCompletedContainers(state, containerTree) {
+  let loopTreesBySessionId = state.loopTreesBySessionId;
+  for (const node of Object.values(containerTree.containersById)) {
+    if (!node.loopSessionId) continue;
+    if (node.status !== "completed" && node.status !== "failed") continue;
+    const loopTree = loopTreesBySessionId[node.loopSessionId];
+    if (!loopTree || loopTree.status === "done" || loopTree.status === "error") continue;
+    loopTreesBySessionId = {
+      ...loopTreesBySessionId,
+      [node.loopSessionId]: finalizeWorkflowLoopTree(
+        loopTree,
+        node.status === "failed" ? "error" : "done"
+      )
+    };
+  }
+  return { ...state, loopTreesBySessionId };
+}
+function clearActiveLoopIfFinalized(state) {
+  const activeId = state.activeLoopSessionId;
+  if (!activeId) return state;
+  const loop = state.loopTreesBySessionId[activeId];
+  if (loop && (loop.status === "done" || loop.status === "error")) {
+    return { ...state, activeLoopSessionId: null };
+  }
+  return state;
+}
+function resolveRootWorkflowId(containerTree) {
+  const rootId = containerTree.rootContainerIds[0];
+  const root = rootId ? containerTree.containersById[rootId] : void 0;
+  return root?.scope === "workflow" ? root.scope_key : null;
+}
+function findContainerForLoopSession(tree, loopSessionId) {
+  return Object.values(tree.containersById).find(
+    (node) => node.loopSessionId === loopSessionId
+  );
+}
+function reconcileLoopTreeWithContainerStatus(containerTree, loopSessionId, loopTree) {
+  const container = findContainerForLoopSession(containerTree, loopSessionId);
+  if (!container) return loopTree;
+  if (container.status === "completed") {
+    return finalizeWorkflowLoopTree(loopTree, "done");
+  }
+  if (container.status === "failed") {
+    return finalizeWorkflowLoopTree(loopTree, "error");
+  }
+  return loopTree;
+}
+function finalizeLoopTreeOnStructureClose(state, event) {
+  if (!LOOP_TASK_STRUCTURE_CLOSE_EVENTS.has(event.event_type)) {
+    return state;
+  }
+  const loopSessionId = resolveStructureCloseLoopSessionId(event);
+  if (!loopSessionId) return state;
+  const loopTree = state.loopTreesBySessionId[loopSessionId];
+  if (!loopTree) return state;
+  const terminalStatus = event.event_type.endsWith("-failed") ? "error" : "done";
+  return {
+    ...state,
+    loopTreesBySessionId: {
+      ...state.loopTreesBySessionId,
+      [loopSessionId]: finalizeWorkflowLoopTree(loopTree, terminalStatus)
+    }
+  };
+}
 function applyStructureEvent(state, event) {
-  let containerTree = applyStructureToContainerTree(state.containerTree, event);
-  containerTree = prebindLoopSessionFromStructureOpen(containerTree, event);
-  const loopSessionId = deriveLoopSessionIdFromStructureOpen(event);
+  const rootWorkflowId = resolveRootWorkflowId(state.containerTree);
+  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(
+    projectedEvent.event_type,
+    projectedEvent.session_id,
+    derivedLoopSessionId,
+    structureData
+  ) : null;
+  if (structureLoopSessionId && useEmbeddedSynthesis) {
+    containerTree = ensureEmbeddedSubworkflowContainers(containerTree, structureLoopSessionId);
+  }
+  containerTree = prebindLoopSessionFromStructureOpen(containerTree, projectedEvent);
+  if (projectedEvent.event_type === "stage-done" || projectedEvent.event_type === "stage-failed") {
+    const stageKey = readString5(structureData, "stage_key");
+    const workflowPath = readString5(structureData, "workflow_path") ?? "";
+    if (stageKey) {
+      const stageId = buildContainerId(workflowPath, "stage", stageKey);
+      if (containerTree.containersById[stageId]) {
+        containerTree = settleCompletedStageSubtree(containerTree, stageId);
+      }
+    }
+  }
+  const loopSessionId = structureLoopSessionId ?? derivedLoopSessionId;
   let nextState = { ...state, containerTree };
   if (loopSessionId) {
     nextState = ensureLoopTree(nextState, loopSessionId);
   }
+  nextState = finalizeLoopTreeOnStructureClose(nextState, projectedEvent);
+  nextState = finalizeLoopTreesForCompletedContainers(nextState, containerTree);
+  nextState = clearActiveLoopIfFinalized(nextState);
   const workflowProgress = syncWorkflowProgressFromContainerTree(
     containerTree,
     state.workflowProgress
@@ -1547,7 +2139,12 @@ function reduceWorkflowSession(state, event, eventIndex, options) {
     const loopSessionId2 = taskListId ?? event.session_id ?? "workflow-loop-default";
     let next2 = ensureLoopTree(state, loopSessionId2);
     const loopTree2 = next2.loopTreesBySessionId[loopSessionId2];
-    const reducedLoop2 = reduceTree(loopTree2, event, eventIndex, options);
+    let reducedLoop2 = reduceTree(loopTree2, event, eventIndex, options);
+    reducedLoop2 = reconcileLoopTreeWithContainerStatus(
+      next2.containerTree,
+      loopSessionId2,
+      reducedLoop2
+    );
     return {
       ...next2,
       loopTreesBySessionId: {
@@ -1569,7 +2166,12 @@ function reduceWorkflowSession(state, event, eventIndex, options) {
   containerTree = applyStructureToContainerTree(containerTree, event);
   let next = ensureLoopTree({ ...state, containerTree }, loopSessionId);
   const loopTree = next.loopTreesBySessionId[loopSessionId];
-  const reducedLoop = reduceTree(loopTree, event, eventIndex, options);
+  let reducedLoop = reduceTree(loopTree, event, eventIndex, options);
+  reducedLoop = reconcileLoopTreeWithContainerStatus(
+    next.containerTree,
+    loopSessionId,
+    reducedLoop
+  );
   const workflowProgress = syncWorkflowProgressFromContainerTree(
     next.containerTree,
     next.workflowProgress
@@ -1736,6 +2338,18 @@ function evictCompletedLoopOverflow(state, maxHydratedCompletedLoops) {
 }
 
 // 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) };
@@ -1756,6 +2370,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
@@ -1772,6 +2419,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;
@@ -1798,26 +2446,20 @@ 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
+        )
       });
     },
     /**
@@ -1857,6 +2499,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
+        )
+      }));
     }
   }));
 }
@@ -1865,7 +2572,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";
@@ -1998,6 +2705,17 @@ function WorkflowExpandTrigger({
   );
 }
 
+// src/view/workflow/WorkflowMarkdownPreview.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function WorkflowMarkdownPreview({
+  content,
+  testId,
+  className = "lax-workflow-markdown-preview"
+}) {
+  if (!content.trim()) return null;
+  return /* @__PURE__ */ jsx7("div", { className, "data-testid": testId, children: /* @__PURE__ */ jsx7(RichMarkdown, { content, deferDiagrams: true }) });
+}
+
 // src/view/workflow/workflowContainerLineUtils.ts
 function formatContainerScopeMetaLabel(scope) {
   return scope;
@@ -2122,15 +2840,37 @@ 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 jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
-function mergeTeaser(node) {
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function mergeContentPreview(node) {
   const blocks = node.content_blocks;
   if (blocks.length === 0) return "";
-  const last = blocks[blocks.length - 1];
-  return last?.preview ?? "";
+  return blocks.map((block) => block.preview?.trim() ?? "").filter(Boolean).join("\n\n");
 }
-function WorkflowAggregateContainer({
+function WorkflowAggregateContainerInner({
   node,
   loopTree,
   siblingItems = [],
@@ -2142,8 +2882,8 @@ function WorkflowAggregateContainer({
   const isRunning = node.status === "running" || node.status === "retrying";
   const isWaiting = node.status === "pending" || node.status === "blocked";
   const isDone = node.status === "completed" || node.status === "failed";
-  const teaser = useMemo2(() => mergeTeaser(node), [node]);
-  const waitingTeaser = isWaiting ? teaser || node.subtitle || "" : "";
+  const contentPreview = useMemo2(() => mergeContentPreview(node), [node]);
+  const waitingTeaser = isWaiting ? contentPreview || node.subtitle || "" : "";
   const testId = `lax-workflow-aggregate-${node.scope_key}`;
   const uiStatus = mapAggregateUiStatus(node);
   const statusLabel = buildAggregateStatusLabel(node, siblingItems);
@@ -2156,6 +2896,14 @@ function WorkflowAggregateContainer({
     setExpanded((prev) => !prev);
   }, []);
   const shellToggle = isRunning ? toggleExpanded : isDone && expanded ? toggleExpanded : void 0;
+  const markdownPreview = contentPreview ? /* @__PURE__ */ jsx8(
+    WorkflowMarkdownPreview,
+    {
+      content: contentPreview,
+      testId: `${testId}-markdown`,
+      className: "lax-workflow-aggregate__markdown lax-workflow-markdown-preview"
+    }
+  ) : null;
   return /* @__PURE__ */ jsxs4(
     "div",
     {
@@ -2164,7 +2912,7 @@ function WorkflowAggregateContainer({
       "data-container-scope": "aggregate",
       style: { "--lax-workflow-depth": depth },
       children: [
-        /* @__PURE__ */ jsx7(
+        /* @__PURE__ */ jsx8(
           WorkflowContainerLine,
           {
             title: node.title,
@@ -2180,10 +2928,16 @@ function WorkflowAggregateContainer({
           }
         ),
         isWaiting && waitingTeaser ? /* @__PURE__ */ jsxs4("div", { className: "lax-workflow-aggregate__waiting-teaser", "data-testid": `${testId}-waiting`, children: [
-          "\u23BF ",
-          waitingTeaser
+          /* @__PURE__ */ jsx8("span", { className: "lax-workflow-aggregate__waiting-prefix", children: "\u23BF " }),
+          /* @__PURE__ */ jsx8(
+            WorkflowMarkdownPreview,
+            {
+              content: waitingTeaser,
+              className: "lax-workflow-aggregate__markdown lax-workflow-markdown-preview"
+            }
+          )
         ] }) : null,
-        expanded && isRunning && loopTree ? /* @__PURE__ */ jsx7("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx7(
+        expanded && isRunning && loopTree ? /* @__PURE__ */ jsx8("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx8(
           AgentLoopView,
           {
             tree: loopTree,
@@ -2193,18 +2947,28 @@ function WorkflowAggregateContainer({
             groupParallelTools
           }
         ) }) : null,
-        isDone && !expanded ? /* @__PURE__ */ jsx7(
-          WorkflowExpandTrigger,
+        expanded && isRunning && !loopTree && contentPreview ? /* @__PURE__ */ jsx8(
+          "div",
           {
-            summary: `${node.title} \xB7 done`,
-            teaser: teaser || void 0,
-            onToggle: () => setExpanded(true),
-            expanded: false,
-            testId: `${testId}-done`,
-            teaserTestId: `${testId}-teaser`
+            className: "lax-workflow-stage-container__body lax-workflow-stage-container__content-preview",
+            "data-testid": `${testId}-body`,
+            children: markdownPreview
           }
         ) : null,
-        isDone && expanded && loopTree ? /* @__PURE__ */ jsx7("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx7(
+        isDone && !expanded ? /* @__PURE__ */ jsxs4("div", { className: "lax-workflow-aggregate__done", "data-testid": `${testId}-done`, children: [
+          /* @__PURE__ */ jsx8(
+            WorkflowExpandTrigger,
+            {
+              summary: `${node.title} \xB7 done`,
+              onToggle: () => setExpanded(true),
+              expanded: false,
+              expandHint: contentPreview ? "(click to expand)" : void 0,
+              testId: `${testId}-done-trigger`
+            }
+          ),
+          markdownPreview ? /* @__PURE__ */ jsx8("div", { className: "lax-workflow-aggregate__done-preview", "data-testid": `${testId}-teaser`, children: markdownPreview }) : null
+        ] }) : null,
+        isDone && expanded && loopTree ? /* @__PURE__ */ jsx8("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx8(
           AgentLoopView,
           {
             tree: loopTree,
@@ -2213,14 +2977,37 @@ function WorkflowAggregateContainer({
             virtualizeThreshold,
             groupParallelTools
           }
-        ) }) : null
+        ) }) : null,
+        isDone && expanded && !loopTree && contentPreview ? /* @__PURE__ */ jsx8(
+          "div",
+          {
+            className: "lax-workflow-stage-container__body lax-workflow-stage-container__content-preview",
+            "data-testid": `${testId}-body`,
+            children: markdownPreview
+          }
+        ) : null
       ]
     }
   );
 }
+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 { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useState as useState3, memo as memo3 } from "react";
 import { useStore as useStore3 } from "zustand";
 
 // src/core/workflow/workflowParallelGroupMetrics.ts
@@ -2287,7 +3074,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
@@ -2297,7 +3084,7 @@ function hasTimelineNodes(tree) {
 }
 
 // src/view/workflow/workflowStageDoneBody.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 function WorkflowStageDoneBody({
   loopTree,
   testId,
@@ -2307,7 +3094,7 @@ function WorkflowStageDoneBody({
   bodyClassName = "lax-workflow-stage-container__body"
 }) {
   if (loopTree && hasTimelineNodes(loopTree)) {
-    return /* @__PURE__ */ jsx8("div", { className: bodyClassName, "data-testid": testId, children: /* @__PURE__ */ jsx8(
+    return /* @__PURE__ */ jsx9("div", { className: bodyClassName, "data-testid": testId, children: /* @__PURE__ */ jsx9(
       AgentLoopView,
       {
         tree: loopTree,
@@ -2318,12 +3105,12 @@ function WorkflowStageDoneBody({
       }
     ) });
   }
-  return /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsx9(
     "div",
     {
       className: `${bodyClassName} lax-workflow-stage-container__empty-hint`,
       "data-testid": testId,
-      children: /* @__PURE__ */ jsx8("span", { className: "lax-workflow-stage-container__empty-hint-text", children: "\uFF08\u6B64\u9636\u6BB5\u6682\u65E0 Agent \u65F6\u95F4\u7EBF\u5185\u5BB9\uFF09" })
+      children: /* @__PURE__ */ jsx9("span", { className: "lax-workflow-stage-container__empty-hint-text", children: "\uFF08\u6B64\u9636\u6BB5\u6682\u65E0 Agent \u65F6\u95F4\u7EBF\u5185\u5BB9\uFF09" })
     }
   );
 }
@@ -2362,12 +3149,15 @@ function partitionWorkflowStages(stages, maxVisibleDoneCount) {
 }
 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/WorkflowStageContainer.tsx
-import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
 function containerTestId(node) {
   if (node.scope === "item") return `lax-workflow-parallel-${node.scope_key}`;
   if (node.scope === "stage") return `lax-workflow-stage-${node.scope_key}`;
@@ -2377,13 +3167,14 @@ 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
 }) {
   const { verbose } = useSessionViewOptions();
   const scale = useWorkflowScaleOptions();
@@ -2446,13 +3237,13 @@ function WorkflowStageContainer({
     return () => window.removeEventListener("keydown", onKeyDown);
   }, [requestLoopHydration]);
   const displayTitle = node.title;
-  const usesScopedLoop = Boolean(node.loopSessionId);
+  const usesScopedLoop = Boolean(node.loopSessionId) && !suppressHostScopedLoop;
   const runningLoopTree = loopTree ?? (usesScopedLoop && isRunning && isActive ? createWorkflowRunningLoopTree() : void 0);
   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 statusLabel = isDone ? doneLabel : suppressHostScopedLoop && isRunning ? "running" : mapContainerStatusLabel(node.status);
   const testId = containerTestId(node);
   const isItem = node.scope === "item";
   const canToggleShell = isRunning && !isSkipped || isDone;
@@ -2470,7 +3261,7 @@ function WorkflowStageContainer({
         "--lax-workflow-indent-unit": workflowIndentUnit(depth)
       },
       children: [
-        /* @__PURE__ */ jsx9(
+        /* @__PURE__ */ jsx10(
           WorkflowContainerLine,
           {
             title: displayTitle,
@@ -2488,7 +3279,7 @@ function WorkflowStageContainer({
           }
         ),
         isDone && !expanded && (teaserText || expandHint) ? /* @__PURE__ */ jsxs5("div", { className: "lax-workflow-stage-container__done-teaser", children: [
-          teaserText ? /* @__PURE__ */ jsx9(
+          teaserText ? /* @__PURE__ */ jsx10(
             "span",
             {
               className: "lax-workflow-stage-container__done-teaser-line",
@@ -2496,14 +3287,14 @@ function WorkflowStageContainer({
               children: `\u23BF ${teaserText}`
             }
           ) : null,
-          expandHint ? /* @__PURE__ */ jsx9("span", { className: "lax-workflow-expand-trigger__hint", children: expandHint }) : null
+          expandHint ? /* @__PURE__ */ jsx10("span", { className: "lax-workflow-expand-trigger__hint", children: expandHint }) : null
         ] }) : null,
-        expanded && isRunning && !usesScopedLoop && node.content_blocks.length > 0 ? /* @__PURE__ */ jsx9(
+        expanded && isRunning && !usesScopedLoop && node.content_blocks.length > 0 ? /* @__PURE__ */ jsx10(
           "div",
           {
             className: "lax-workflow-stage-container__body lax-workflow-stage-container__content-preview",
             "data-testid": bodyTestId(node),
-            children: node.content_blocks.map((block, index) => /* @__PURE__ */ jsx9(
+            children: node.content_blocks.map((block, index) => /* @__PURE__ */ jsx10(
               "div",
               {
                 className: "lax-workflow-stage-container__teaser",
@@ -2513,12 +3304,12 @@ function WorkflowStageContainer({
             ))
           }
         ) : null,
-        expanded && isRunning && runningLoopTree ? /* @__PURE__ */ jsx9(
+        expanded && isRunning && runningLoopTree ? /* @__PURE__ */ jsx10(
           "div",
           {
             className: isItem ? "lax-workflow-parallel-item__body lax-workflow-stage-container__body" : "lax-workflow-stage-container__body",
             "data-testid": bodyTestId(node),
-            children: /* @__PURE__ */ jsx9(
+            children: /* @__PURE__ */ jsx10(
               AgentLoopView,
               {
                 tree: runningLoopTree,
@@ -2530,7 +3321,7 @@ function WorkflowStageContainer({
             )
           }
         ) : null,
-        isDone && expanded ? loopTree ? /* @__PURE__ */ jsx9(
+        isDone && expanded ? loopTree ? /* @__PURE__ */ jsx10(
           WorkflowStageDoneBody,
           {
             node,
@@ -2547,8 +3338,8 @@ function WorkflowStageContainer({
             className: "lax-workflow-stage-container__body lax-workflow-loop-replay-pending",
             "data-testid": bodyTestId(node),
             children: [
-              teaserText ? /* @__PURE__ */ jsx9("p", { className: "lax-workflow-stage-container__teaser", children: teaserText }) : null,
-              /* @__PURE__ */ jsx9("p", { className: "lax-workflow-loop-replay-pending__hint", children: replayHandler ? "Loading loop details\u2026" : "Loop details evicted from memory." })
+              teaserText ? /* @__PURE__ */ jsx10("p", { className: "lax-workflow-stage-container__teaser", children: teaserText }) : null,
+              /* @__PURE__ */ jsx10("p", { className: "lax-workflow-loop-replay-pending__hint", children: replayHandler ? "Loading loop details\u2026" : "Loop details evicted from memory." })
             ]
           }
         ) : null
@@ -2556,14 +3347,21 @@ function WorkflowStageContainer({
     }
   );
 }
+function workflowStageContainerPropsEqual(prev, next) {
+  if (prev.suppressHostScopedLoop !== next.suppressHostScopedLoop) 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 jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
 function resolveLoopTree(node, loopTreesBySessionId) {
   if (!node.loopSessionId) return void 0;
   return loopTreesBySessionId[node.loopSessionId];
 }
-function WorkflowParallelGroup({
+function WorkflowParallelGroupInner({
   groupKey,
   items,
   loopTreesBySessionId,
@@ -2579,12 +3377,13 @@ function WorkflowParallelGroup({
   const metrics = useMemo4(() => computeParallelGroupMetrics(items), [items]);
   const summary = formatParallelGroupSummary(metrics);
   const hasRunning = metrics.running > 0;
+  const isNestedGroup = groupKey.includes(">");
   const hasActiveItem = useMemo4(
     () => items.some((item) => isActiveWorkflowContainer(item, activeLoopSessionId, activeContainerIds)),
     [items, activeLoopSessionId, activeContainerIds]
   );
   const allSettled = metrics.total > 0 && metrics.running === 0 && metrics.completed + metrics.failed >= metrics.total;
-  const shouldAutoExpandGroup = hasRunning && (!scale.onlyExpandActiveRunning || hasActiveItem);
+  const shouldAutoExpandGroup = hasRunning && (isNestedGroup || !scale.onlyExpandActiveRunning || hasActiveItem);
   const [expanded, setExpanded] = useState3(shouldAutoExpandGroup);
   useEffect5(() => {
     if (shouldAutoExpandGroup) {
@@ -2612,7 +3411,7 @@ function WorkflowParallelGroup({
   }, []);
   const renderItem = (index) => {
     const item = items[index];
-    return /* @__PURE__ */ jsx10(
+    return /* @__PURE__ */ jsx11(
       WorkflowStageContainer,
       {
         node: item,
@@ -2631,25 +3430,43 @@ function WorkflowParallelGroup({
       className: "lax-workflow-parallel-group",
       "data-testid": `lax-workflow-parallel-group-${groupKey}`,
       children: [
-        /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx11(
           WorkflowExpandTrigger,
           {
             summary,
-            expandHint: !expanded && !hasRunning ? "(ctrl+o to expand)" : null,
+            expandHint: !expanded && hasRunning ? "(click to expand agents)" : !expanded && !hasRunning ? "(ctrl+o to expand)" : null,
             onToggle: toggleExpanded,
             expanded,
             testId: `lax-workflow-parallel-group-summary-${groupKey}`,
             className: "lax-workflow-parallel-group__summary"
           }
         ),
-        expanded ? /* @__PURE__ */ jsx10("div", { className: "lax-workflow-parallel-list", "data-testid": "lax-workflow-parallel-list", children: items.map((_, index) => renderItem(index)) }) : null
+        expanded ? /* @__PURE__ */ jsx11("div", { className: "lax-workflow-parallel-list", "data-testid": "lax-workflow-parallel-list", children: items.map((_, index) => renderItem(index)) }) : null
       ]
     }
   );
 }
+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 jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
 function WorkflowRootContainer({
   node,
   children
@@ -2658,7 +3475,7 @@ function WorkflowRootContainer({
   const uiStatus = mapContainerUiStatus(node.status);
   const statusLabel = mapWorkflowRootStatusLabel(node.status);
   return /* @__PURE__ */ jsxs7("div", { className: "lax-workflow-root", "data-testid": "lax-workflow-root", children: [
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(
       WorkflowContainerLine,
       {
         variant: "root",
@@ -2673,13 +3490,13 @@ function WorkflowRootContainer({
         verbose
       }
     ),
-    children ? /* @__PURE__ */ jsx11("div", { className: "lax-workflow-container-tree", children }) : null
+    children ? /* @__PURE__ */ jsx12("div", { className: "lax-workflow-container-tree", children }) : null
   ] });
 }
 
 // src/view/workflow/WorkflowRouteContainer.tsx
 import { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo5, useState as useState4 } from "react";
-import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
 function WorkflowRouteContainer({
   node,
   loopTree,
@@ -2725,7 +3542,7 @@ function WorkflowRouteContainer({
       "data-container-scope": "branch",
       style: depthStyle,
       children: [
-        /* @__PURE__ */ jsx12(
+        /* @__PURE__ */ jsx13(
           WorkflowContainerLine,
           {
             title: node.title,
@@ -2740,7 +3557,7 @@ function WorkflowRouteContainer({
             descriptionTestId: `${testId}-desc`
           }
         ),
-        !isSkipped && expanded && isRunning && loopTree ? /* @__PURE__ */ jsx12("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx12(
+        !isSkipped && expanded && isRunning && loopTree ? /* @__PURE__ */ jsx13("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx13(
           AgentLoopView,
           {
             tree: loopTree,
@@ -2750,7 +3567,7 @@ function WorkflowRouteContainer({
             groupParallelTools
           }
         ) }) : null,
-        !isSkipped && isDone && !expanded ? /* @__PURE__ */ jsx12(
+        !isSkipped && isDone && !expanded ? /* @__PURE__ */ jsx13(
           WorkflowExpandTrigger,
           {
             summary: `${node.title} \xB7 ${doneLabel}`,
@@ -2762,7 +3579,7 @@ function WorkflowRouteContainer({
             teaserTestId: teaserText ? `${testId}-teaser` : void 0
           }
         ) : null,
-        !isSkipped && isDone && expanded ? /* @__PURE__ */ jsx12(
+        !isSkipped && isDone && expanded ? /* @__PURE__ */ jsx13(
           WorkflowStageDoneBody,
           {
             node,
@@ -2780,7 +3597,7 @@ function WorkflowRouteContainer({
 
 // src/view/workflow/WorkflowSubworkflowContainer.tsx
 import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMemo6, useState as useState5 } from "react";
-import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
 function buildDoneSummary(node) {
   const display = node.display;
   if (display?.progress_total != null) {
@@ -2826,7 +3643,7 @@ function WorkflowSubworkflowContainer({
       "data-container-scope": "subworkflow",
       style: depthStyle,
       children: [
-        showShellLine ? /* @__PURE__ */ jsx13(
+        showShellLine ? /* @__PURE__ */ jsx14(
           WorkflowContainerLine,
           {
             variant: "root",
@@ -2844,7 +3661,7 @@ function WorkflowSubworkflowContainer({
             verbose
           }
         ) : null,
-        expanded && children ? /* @__PURE__ */ jsx13(
+        expanded && children ? /* @__PURE__ */ jsx14(
           "div",
           {
             className: "lax-workflow-subworkflow-boundary",
@@ -2853,15 +3670,16 @@ function WorkflowSubworkflowContainer({
             children
           }
         ) : null,
-        isDone && !expanded ? /* @__PURE__ */ jsx13(
+        !expanded && children ? /* @__PURE__ */ jsx14(
           WorkflowExpandTrigger,
           {
-            summary: `${node.title} \xB7 ${buildDoneSummary(node)}`,
+            summary: `${node.title} \xB7 ${isDone ? buildDoneSummary(node) : "running"}`,
             summaryTestId: `${testId}-title`,
             teaser: teaser || void 0,
+            expandHint: isRunning ? "(click to expand subworkflow)" : void 0,
             onToggle: () => setExpanded(true),
             expanded: false,
-            testId: `${testId}-done`,
+            testId: isDone ? `${testId}-done` : `${testId}-running-collapsed`,
             teaserTestId: teaser ? `${testId}-teaser` : void 0
           }
         ) : null
@@ -2871,7 +3689,7 @@ function WorkflowSubworkflowContainer({
 }
 
 // src/view/workflow/WorkflowChrome.tsx
-import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
 function collectChildContainers(containersById, parentId) {
   return Object.values(containersById).filter((node) => node.parent_container_id === parentId).sort((a, b) => a.scope_key.localeCompare(b.scope_key));
 }
@@ -2885,11 +3703,11 @@ 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);
   switch (node.scope) {
     case "aggregate":
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         WorkflowAggregateContainer,
         {
           node,
@@ -2901,7 +3719,7 @@ function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, v
         node.container_id
       );
     case "branch":
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         WorkflowRouteContainer,
         {
           node,
@@ -2912,12 +3730,13 @@ function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, v
         node.container_id
       );
     default:
-      return /* @__PURE__ */ jsx14(
+      return /* @__PURE__ */ jsx15(
         WorkflowStageContainer,
         {
           node,
           loopTree,
           depth,
+          suppressHostScopedLoop: options?.suppressHostScopedLoop,
           ...viewProps
         },
         node.container_id
@@ -2926,7 +3745,7 @@ function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, v
 }
 function renderItemSiblings(items, groupKey, depth, containerTree, loopTreesBySessionId, viewProps) {
   if (items.length >= 2) {
-    return /* @__PURE__ */ jsx14(
+    return /* @__PURE__ */ jsx15(
       WorkflowParallelGroup,
       {
         groupKey,
@@ -2942,6 +3761,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");
@@ -2961,7 +3785,7 @@ function renderContainerNode(node, containerTree, loopTreesBySessionId, viewProp
   );
   const hasNested = collectChildContainers(containerTree.containersById, node.container_id).length > 0;
   if (node.scope === "subworkflow") {
-    return /* @__PURE__ */ jsx14(
+    return /* @__PURE__ */ jsx15(
       WorkflowSubworkflowContainer,
       {
         node,
@@ -2972,14 +3796,22 @@ function renderContainerNode(node, containerTree, loopTreesBySessionId, viewProp
     );
   }
   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),
-          hasNested ? /* @__PURE__ */ jsx14("div", { className: "lax-workflow-container-children", children: nested }) : null
+          renderLeafContainer(
+            node,
+            depth,
+            containerTree,
+            loopTreesBySessionId,
+            viewProps,
+            { suppressHostScopedLoop }
+          ),
+          hasNested ? /* @__PURE__ */ jsx15("div", { className: "lax-workflow-container-children", children: nested }) : null
         ]
       },
       node.container_id
@@ -3005,9 +3837,9 @@ function renderWorkflowStageRow(node, containerTree, loopTreesBySessionId, viewP
     viewProps
   );
   if (as === "div") {
-    return /* @__PURE__ */ jsx14("div", { className, role: "listitem", children: content }, node.container_id);
+    return /* @__PURE__ */ jsx15("div", { className, role: "listitem", children: content }, node.container_id);
   }
-  return /* @__PURE__ */ jsx14("li", { className, children: content }, node.container_id);
+  return /* @__PURE__ */ jsx15("li", { className, children: content }, node.container_id);
 }
 function WorkflowStageListPanel({
   stages,
@@ -3028,7 +3860,7 @@ function WorkflowStageListPanel({
     partition.totalDoneCount - partition.visibleDoneCount
   );
   return /* @__PURE__ */ jsxs10(Fragment2, { children: [
-    /* @__PURE__ */ jsx14("ol", { className: "lax-workflow-stage-list", "data-testid": "lax-workflow-stage-list", children: partition.visible.map(
+    /* @__PURE__ */ jsx15("ol", { className: "lax-workflow-stage-list", "data-testid": "lax-workflow-stage-list", children: partition.visible.map(
       (node) => renderWorkflowStageRow(node, containerTree, loopTreesBySessionId, viewProps)
     ) }),
     partition.hiddenCount > 0 ? /* @__PURE__ */ jsxs10(
@@ -3047,7 +3879,7 @@ function WorkflowStageListPanel({
         ]
       }
     ) : null,
-    extraCompletedPages > 0 && partition.hiddenCount === 0 ? /* @__PURE__ */ jsx14(
+    extraCompletedPages > 0 && partition.hiddenCount === 0 ? /* @__PURE__ */ jsx15(
       "button",
       {
         type: "button",
@@ -3083,7 +3915,7 @@ function renderWorkflowChildren(workflowNode, containerTree, loopTreesBySessionI
     (node) => node.scope !== "stage" && node.scope !== "item"
   );
   return /* @__PURE__ */ jsxs10(Fragment2, { children: [
-    stages.length > 0 ? /* @__PURE__ */ jsx14(
+    stages.length > 0 ? /* @__PURE__ */ jsx15(
       WorkflowStageListPanel,
       {
         stages,
@@ -3108,7 +3940,7 @@ function WorkflowChrome({
   const viewProps = { virtualized, virtualizeThreshold, groupParallelTools };
   const rootNodes = containerTree.rootContainerIds.map((id) => containerTree.containersById[id]).filter((node) => node != null);
   if (rootNodes.length === 0) {
-    return /* @__PURE__ */ jsx14("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: /* @__PURE__ */ jsx14(
+    return /* @__PURE__ */ jsx15("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: /* @__PURE__ */ jsx15(
       WorkflowContainerLine,
       {
         variant: "root",
@@ -3118,7 +3950,7 @@ function WorkflowChrome({
       }
     ) });
   }
-  return /* @__PURE__ */ jsx14("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: rootNodes.map((workflowNode) => /* @__PURE__ */ jsx14(WorkflowRootContainer, { node: workflowNode, children: renderWorkflowChildren(
+  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,
@@ -3199,11 +4031,11 @@ function loopSessionDisplayLabel(loopSessionId) {
 }
 
 // src/view/workflow/WorkflowTaskListFooter.tsx
-import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+import { jsx as jsx16, jsxs as jsxs11 } from "react/jsx-runtime";
 function MessageResponse({ children }) {
   return /* @__PURE__ */ jsxs11("div", { className: "lax-message-response", children: [
-    /* @__PURE__ */ jsx15("span", { className: "lax-message-response__marker", children: "\u23BF " }),
-    /* @__PURE__ */ jsx15("span", { className: "lax-message-response__content", children })
+    /* @__PURE__ */ jsx16("span", { className: "lax-message-response__marker", children: "\u23BF " }),
+    /* @__PURE__ */ jsx16("span", { className: "lax-message-response__content", children })
   ] });
 }
 function WorkflowTaskListFooter() {
@@ -3228,18 +4060,18 @@ function WorkflowTaskListFooter() {
         onClick: () => setExpanded((v) => !v),
         children: [
           label,
-          /* @__PURE__ */ jsx15("span", { className: "lax-task-list-footer__hint", children: expanded ? " \xB7 \u2191 to hide" : " \xB7 \u2193 to view" })
+          /* @__PURE__ */ jsx16("span", { className: "lax-task-list-footer__hint", children: expanded ? " \xB7 \u2191 to hide" : " \xB7 \u2193 to view" })
         ]
       }
     ),
-    expanded ? /* @__PURE__ */ jsx15(MessageResponse, { children: /* @__PURE__ */ jsx15("div", { className: "lax-workflow-task-list-groups", children: groups.map((group) => /* @__PURE__ */ jsxs11(
+    expanded ? /* @__PURE__ */ jsx16(MessageResponse, { children: /* @__PURE__ */ jsx16("div", { className: "lax-workflow-task-list-groups", children: groups.map((group) => /* @__PURE__ */ jsxs11(
       "div",
       {
         className: "lax-workflow-task-list-group",
         "data-testid": `lax-workflow-task-group-${group.loopSessionId}`,
         children: [
-          /* @__PURE__ */ jsx15("div", { className: "lax-workflow-task-list-group-title", children: loopSessionDisplayLabel(group.loopSessionId) }),
-          /* @__PURE__ */ jsx15(TaskList, { tasks: group.tasks })
+          /* @__PURE__ */ jsx16("div", { className: "lax-workflow-task-list-group-title", children: loopSessionDisplayLabel(group.loopSessionId) }),
+          /* @__PURE__ */ jsx16(TaskList, { tasks: group.tasks })
         ]
       },
       group.loopSessionId
@@ -3249,7 +4081,7 @@ function WorkflowTaskListFooter() {
 
 // src/view/workflow/WorkflowSession.tsx
 import { useStore as useStore5 } from "zustand";
-import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs12 } from "react/jsx-runtime";
 function WorkflowSession({
   source,
   initialEvents,
@@ -3328,6 +4160,14 @@ function WorkflowSession({
     storeRef.current,
     (s) => s.state.loopTreesBySessionId
   );
+  const sessionStatus = useStore5(
+    storeRef.current,
+    (s) => s.state.status
+  );
+  const internalErrors = useStore5(
+    storeRef.current,
+    (s) => s.state.internalErrors
+  );
   useEffect8(() => {
     const store = storeRef.current;
     const controller = new AbortController();
@@ -3335,23 +4175,32 @@ function WorkflowSession({
       store.getState().applyEvent(event, ctx);
     }, controller.signal).catch((err) => {
       if (err instanceof SseTransportTerminalError) {
-        const { state } = store.getState();
-        if (state.status === "running") {
-          store.setState({ state: { ...state, status: "error" } });
-        }
+        store.getState().markAsError(err);
+        onError?.(err);
+      } else if (err instanceof Error) {
+        onError?.(err);
       }
     });
     return () => {
       controller.abort();
     };
   }, [source, onError]);
-  return /* @__PURE__ */ jsx16(WorkflowSessionStoreContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx16(WorkflowScaleContext.Provider, { value: scaleOptions, children: /* @__PURE__ */ jsx16(WorkflowLoopReplayProvider, { onRequestLoopReplay, children: /* @__PURE__ */ jsx16(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx16(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx16(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx16(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx16(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs12(
+  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: [
-        /* @__PURE__ */ jsx16(
+        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,
           {
             containerTree,
@@ -3361,7 +4210,7 @@ function WorkflowSession({
             groupParallelTools
           }
         ),
-        /* @__PURE__ */ jsx16(WorkflowTaskListFooter, {}),
+        /* @__PURE__ */ jsx17(WorkflowTaskListFooter, {}),
         children
       ]
     }
@@ -3405,7 +4254,7 @@ function buildTimelineEntries(rootIds, byId, options = {}) {
 }
 
 // src/view/nodes/SubAgentNode.tsx
-import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+import { jsx as jsx18, jsxs as jsxs13 } from "react/jsx-runtime";
 function SubAgentBlock({ nodeId }) {
   const node = useNodeTyped(nodeId, "subagent");
   const childIds = useChildren(nodeId);
@@ -3416,7 +4265,7 @@ function SubAgentBlock({ nodeId }) {
       "SubAgent: ",
       node.subagentId
     ] }),
-    /* @__PURE__ */ jsx17("div", { className: "lax-subagent-block__children", children: childIds.map((childId) => /* @__PURE__ */ jsx17(TimelineItem, { nodeId: childId, registry }, childId)) })
+    /* @__PURE__ */ jsx18("div", { className: "lax-subagent-block__children", children: childIds.map((childId) => /* @__PURE__ */ jsx18(TimelineItem, { nodeId: childId, registry }, childId)) })
   ] });
 }