langchain_agentx_stream_ui 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,19 +1,25 @@
 import {
   ErrorCard,
+  MermaidDiagram,
   MultiAgentSession,
   NodeRegistry,
   PermissionCard,
+  PlantUMLBlock,
+  PlantUMLDiagram,
   ReasoningBubble,
+  RichMarkdown,
   StepCard,
   TextBubble,
   ToolCallCard,
   UnknownCard,
+  configureMermaid,
+  configurePlantumlServer,
   createActiveSessionBridge,
   createDefaultRegistry,
   createMultiSessionStore,
   markEventIdSeen,
   shouldSkipDuplicateEvent
-} from "./chunk-W6QQHTJ4.js";
+} from "./chunk-A4W6B7C3.js";
 import {
   DefaultToolBody,
   InteractionBusContext,
@@ -74,6 +80,7 @@ import {
   iterMountCandidates,
   projectCanonical,
   projectTimeline,
+  reduceAgentLoopEvent,
   reduceEvents,
   reduceTree,
   replayEvents,
@@ -98,8 +105,9 @@ import {
   useSessionIds,
   useSessionMeta,
   useSessionStatus,
+  useSessionViewOptions,
   useTimeline
-} from "./chunk-G2KYJCMM.js";
+} from "./chunk-3B4WC67E.js";
 import {
   Agent,
   AgentToolBody,
@@ -145,7 +153,7 @@ import {
 } from "./chunk-4RIOBLGB.js";
 
 // src/view/AgentSession.tsx
-import { useEffect, useMemo, useRef } from "react";
+import { useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
 
 // src/core/store.ts
 import { createStore } from "zustand/vanilla";
@@ -225,8 +233,307 @@ function createSessionStore(initialTree = createEmptyTree(), storeOptions) {
   }));
 }
 
+// src/transport/applicationKind.ts
+var ApplicationKindMismatchError = class extends Error {
+  name = "ApplicationKindMismatchError";
+  expected;
+  actual;
+  constructor(expected, actual) {
+    super(
+      `application_kind mismatch: expected ${expected}, got ${actual ?? "(missing)"}`
+    );
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+var MissingApplicationKindError = class extends Error {
+  name = "MissingApplicationKindError";
+  constructor() {
+    super("application_kind missing in SSE meta frame");
+  }
+};
+
+// src/transport/createAgentxSseSource.ts
+var EXPECTED_PROTOCOL_VERSION = "1";
+var SseTransportTerminalError = class extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.name = "SseTransportTerminalError";
+    this.kind = kind;
+  }
+};
+function transportLog(message, level = "warn") {
+  const line = `[langchain_agentx_stream_ui] SSE transport: ${message}`;
+  if (level === "error") {
+    console.error(line);
+  } else {
+    console.warn(line);
+  }
+}
+function buildResumeStreamUrl(baseUrl, lastEventId, queryParam = "last_event_id") {
+  if (!lastEventId) return baseUrl;
+  const sep = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${sep}${encodeURIComponent(queryParam)}=${encodeURIComponent(lastEventId)}`;
+}
+function createAgentxSseSource(options) {
+  const {
+    url,
+    autoReconnect = true,
+    reconnectDelayMs = 1e3,
+    onLastEventId,
+    EventSourceImpl = EventSource,
+    expectedApplicationKind
+  } = options;
+  return {
+    start(handler, signal) {
+      return new Promise((resolve, reject) => {
+        let es = null;
+        let handshakeOk = false;
+        let lastEventId = null;
+        let fatal = false;
+        let streamTerminal = false;
+        let bufferedDelta = null;
+        let flushTimer = null;
+        const flushBufferedDelta = () => {
+          if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+          }
+          if (!bufferedDelta) return;
+          handler(bufferedDelta.event, bufferedDelta.ctx);
+          bufferedDelta = null;
+        };
+        const isBufferedDeltaEvent = (event) => event.event_type === "text-delta" || event.event_type === "reasoning-delta";
+        const mergeDeltaEvent = (prev, next) => {
+          if (prev.event_type !== next.event_type) return null;
+          if (prev.step_index !== next.step_index) return null;
+          if (prev.tool_name !== next.tool_name) return null;
+          if (prev.session_id !== next.session_id) return null;
+          const prevData = prev.data;
+          const nextData = next.data;
+          const prevChunk = prevData.delta ?? prevData.text ?? prevData.content ?? "";
+          const nextChunk = nextData.delta ?? nextData.text ?? nextData.content ?? "";
+          return {
+            ...next,
+            data: {
+              ...next.data,
+              text: `${prevChunk}${nextChunk}`
+            }
+          };
+        };
+        const cleanup = () => {
+          es?.close();
+          es = null;
+        };
+        const finish = (error) => {
+          flushBufferedDelta();
+          cleanup();
+          if (error) reject(error);
+          else resolve();
+        };
+        const failHandshake = (error) => {
+          fatal = true;
+          transportLog(error.message, "error");
+          cleanup();
+          finish(error);
+        };
+        const failPrematureClose = () => {
+          const error = new SseTransportTerminalError(
+            "premature_close",
+            "SSE connection lost before stream finished"
+          );
+          transportLog(error.message, "error");
+          cleanup();
+          finish(error);
+        };
+        const connect = (resumeFromId) => {
+          if (signal.aborted || fatal) {
+            finish();
+            return;
+          }
+          const connectUrl = resumeFromId != null && resumeFromId !== "" ? buildResumeStreamUrl(url, resumeFromId) : url;
+          es = new EventSourceImpl(connectUrl);
+          handshakeOk = false;
+          es.addEventListener("meta", (event) => {
+            try {
+              const meta = JSON.parse(event.data);
+              if (meta.protocol_version !== EXPECTED_PROTOCOL_VERSION) {
+                failHandshake(
+                  new Error(`Unsupported protocol_version: ${meta.protocol_version}`)
+                );
+                return;
+              }
+              if (expectedApplicationKind) {
+                const actual = meta.application_kind;
+                if (actual === void 0 || actual === null) {
+                  failHandshake(new MissingApplicationKindError());
+                  return;
+                }
+                if (actual !== expectedApplicationKind) {
+                  failHandshake(
+                    new ApplicationKindMismatchError(expectedApplicationKind, actual)
+                  );
+                  return;
+                }
+              }
+              handshakeOk = true;
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Failed to decode meta frame";
+              failHandshake(new Error(message));
+            }
+          });
+          es.addEventListener("agentx", (event) => {
+            if (!handshakeOk) {
+              failHandshake(new Error("Received agentx frame before meta handshake"));
+              return;
+            }
+            try {
+              const agentEvent = JSON.parse(event.data);
+              const sseEventId = event.lastEventId || void 0;
+              if (sseEventId) {
+                lastEventId = sseEventId;
+                onLastEventId?.(sseEventId);
+              }
+              const ctx = sseEventId ? { sseEventId } : void 0;
+              if (isBufferedDeltaEvent(agentEvent)) {
+                if (bufferedDelta) {
+                  const merged = mergeDeltaEvent(bufferedDelta.event, agentEvent);
+                  if (merged) {
+                    bufferedDelta = { event: merged, ctx };
+                  } else {
+                    flushBufferedDelta();
+                    bufferedDelta = { event: agentEvent, ctx };
+                  }
+                } else {
+                  bufferedDelta = { event: agentEvent, ctx };
+                }
+                if (!flushTimer) {
+                  flushTimer = setTimeout(() => {
+                    flushBufferedDelta();
+                  }, 16);
+                }
+              } else {
+                flushBufferedDelta();
+                handler(agentEvent, ctx);
+                if (agentEvent.event_type === "finish" || agentEvent.event_type === "error") {
+                  streamTerminal = true;
+                }
+              }
+            } catch (err) {
+              const message = err instanceof Error ? err.message : "Failed to decode agentx frame";
+              transportLog(`Dropped agentx frame: ${message}`, "warn");
+            }
+          });
+          es.onerror = () => {
+            flushBufferedDelta();
+            if (signal.aborted || fatal || streamTerminal) {
+              cleanup();
+              finish();
+              return;
+            }
+            if (!handshakeOk) {
+              const error = new SseTransportTerminalError(
+                "handshake_failed",
+                "SSE connection failed before meta handshake"
+              );
+              transportLog(error.message, "error");
+              cleanup();
+              finish(error);
+              return;
+            }
+            if (autoReconnect) {
+              cleanup();
+              setTimeout(() => connect(lastEventId), reconnectDelayMs);
+              return;
+            }
+            failPrematureClose();
+          };
+        };
+        signal.addEventListener("abort", () => {
+          flushBufferedDelta();
+          fatal = true;
+          finish();
+        }, { once: true });
+        connect();
+      });
+    }
+  };
+}
+function createMockSource(events) {
+  return {
+    async start(handler, signal) {
+      for (const event of events) {
+        if (signal.aborted) break;
+        handler(event);
+      }
+    }
+  };
+}
+
+// src/view/agentLoop/ScopedSessionStore.tsx
+import { useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+function ScopedSessionStoreProvider({
+  tree,
+  children
+}) {
+  const storeRef = useRef(createSessionStore(tree, { initialEventCount: 1 }));
+  useEffect(() => {
+    storeRef.current.setState({ tree });
+  }, [tree]);
+  return /* @__PURE__ */ jsx(SessionStoreContext.Provider, { value: storeRef.current, children });
+}
+
+// src/view/agentLoop/AgentLoopView.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function AgentLoopViewBody({
+  showTaskListFooter = true,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  return /* @__PURE__ */ jsx2("div", { className: "lax-agent-loop-view", "data-testid": "lax-agent-loop-view", children: /* @__PURE__ */ jsx2(
+    SessionTimeline,
+    {
+      virtualized,
+      virtualizeThreshold,
+      groupParallelTools,
+      showTaskListFooter
+    }
+  ) });
+}
+function AgentLoopView({
+  tree,
+  showTaskListFooter = true,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  if (tree) {
+    return /* @__PURE__ */ jsx2(ScopedSessionStoreProvider, { tree, children: /* @__PURE__ */ jsx2(
+      AgentLoopViewBody,
+      {
+        showTaskListFooter,
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx2(
+    AgentLoopViewBody,
+    {
+      showTaskListFooter,
+      virtualized,
+      virtualizeThreshold,
+      groupParallelTools
+    }
+  );
+}
+
 // src/view/AgentSession.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 function DebugPanel() {
   const status = useSessionStatus();
   const errors = useInternalErrors();
@@ -236,7 +543,7 @@ function DebugPanel() {
       "status: ",
       status
     ] }),
-    /* @__PURE__ */ jsx("ul", { children: errors.map((err, i) => /* @__PURE__ */ jsxs("li", { children: [
+    /* @__PURE__ */ jsx3("ul", { children: errors.map((err, i) => /* @__PURE__ */ jsxs("li", { children: [
       "[",
       err.eventType,
       "] ",
@@ -244,20 +551,2686 @@ function DebugPanel() {
     ] }, `${err.eventIndex}-${i}`)) })
   ] });
 }
-function AgentSession({
+function AgentSession({
+  source,
+  initialEvents,
+  registry,
+  tierOverrides: _tierOverrides,
+  onError,
+  autoReconnect: _autoReconnect,
+  debug = false,
+  virtualized = false,
+  virtualizeThreshold,
+  interactionBus,
+  toolDisplayRegistry,
+  defaultBodyMode = "preview",
+  groupParallelTools = false,
+  permissionUiMode = "standalone",
+  markdownRenderer,
+  displayMode = "normal",
+  verbose = false,
+  exploreFullscreenBash = true,
+  memoryDir = null,
+  workspaceRoot = null,
+  children
+}) {
+  const storeRef = useRef2(null);
+  if (storeRef.current === null) {
+    const replayOpts = {
+      tierOverrides: _tierOverrides,
+      collectDebug: debug
+    };
+    const initialTree = initialEvents && initialEvents.length > 0 ? replayEvents(initialEvents, replayOpts) : void 0;
+    storeRef.current = createSessionStore(initialTree, {
+      tierOverrides: _tierOverrides,
+      debug,
+      initialEventCount: initialEvents?.length ?? 0
+    });
+  }
+  const registryRef = useMemo(() => registry ?? createDefaultRegistry(), [registry]);
+  const busRef = useMemo(
+    () => interactionBus ?? getNoopInteractionBus(),
+    [interactionBus]
+  );
+  const toolDisplayRef = useMemo(
+    () => ({
+      registry: toolDisplayRegistry ?? createDefaultToolRegistry(),
+      defaultBodyMode
+    }),
+    [toolDisplayRegistry, defaultBodyMode]
+  );
+  const sessionViewRef = useMemo(
+    () => ({
+      ...DEFAULT_SESSION_VIEW_OPTIONS,
+      groupParallelTools,
+      permissionUiMode,
+      verboseReasoning: debug,
+      displayMode,
+      verbose,
+      exploreFullscreenBash,
+      memoryDir,
+      workspaceRoot
+    }),
+    [
+      groupParallelTools,
+      permissionUiMode,
+      debug,
+      displayMode,
+      verbose,
+      exploreFullscreenBash,
+      memoryDir,
+      workspaceRoot
+    ]
+  );
+  useEffect2(() => {
+    const store = storeRef.current;
+    const controller = new AbortController();
+    void source.start((event, ctx) => {
+      store.getState().applyEvent(event, ctx);
+    }, controller.signal).catch((err) => {
+      if (err instanceof SseTransportTerminalError) {
+        const { tree } = store.getState();
+        if (tree.status === "running" || tree.status === "connecting") {
+          store.setState({ tree: { ...tree, status: "error" } });
+        }
+      }
+    });
+    return () => {
+      controller.abort();
+    };
+  }, [source, onError]);
+  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,
+      {
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ),
+    debug ? /* @__PURE__ */ jsx3(DebugPanel, {}) : null
+  ] }) }) }) }) }) }) });
+}
+
+// src/view/workflow/WorkflowSession.tsx
+import { useEffect as useEffect8, useMemo as useMemo9, useRef as useRef3 } from "react";
+
+// src/core/context/WorkflowSessionContext.tsx
+import { createContext, useContext } from "react";
+import { useStore } from "zustand";
+var WorkflowSessionStoreContext = createContext(null);
+function useWorkflowSessionStoreApi() {
+  const store = useContext(WorkflowSessionStoreContext);
+  if (!store) {
+    throw new Error("useWorkflowSessionStoreApi must be used within WorkflowSession");
+  }
+  return store;
+}
+function useWorkflowSessionStatus() {
+  const store = useWorkflowSessionStoreApi();
+  return useStore(store, (s) => s.state.status);
+}
+
+// src/core/context/WorkflowLoopReplayContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WorkflowLoopReplayContext = createContext2(
+  void 0
+);
+function WorkflowLoopReplayProvider({
+  onRequestLoopReplay,
+  children
+}) {
+  return /* @__PURE__ */ jsx4(WorkflowLoopReplayContext.Provider, { value: onRequestLoopReplay, children });
+}
+function useWorkflowLoopReplayHandler() {
+  return useContext2(WorkflowLoopReplayContext);
+}
+
+// src/core/context/WorkflowScaleContext.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+
+// src/view/workflow/workflowScaleOptions.ts
+var DEFAULT_WORKFLOW_SCALE_OPTIONS = {
+  stageVirtualizeThreshold: 40,
+  completedStagePageSize: 25,
+  evictCompletedLoops: true,
+  onlyExpandActiveRunning: true,
+  parallelItemVirtualizeThreshold: 40,
+  maxHydratedCompletedLoops: 4
+};
+
+// src/core/context/WorkflowScaleContext.tsx
+var WorkflowScaleContext = createContext3(
+  DEFAULT_WORKFLOW_SCALE_OPTIONS
+);
+function useWorkflowScaleOptions() {
+  return useContext3(WorkflowScaleContext);
+}
+
+// src/core/workflowSessionStore.ts
+import { createStore as createStore2 } from "zustand/vanilla";
+
+// src/types/workflowContainer.ts
+function createEmptyWorkflowContainerTreeState() {
+  return {
+    rootContainerIds: [],
+    activeContainerIds: [],
+    containersById: {}
+  };
+}
+function containerTreeToSnapshot(tree) {
+  const containers = {};
+  for (const [id, node] of Object.entries(tree.containersById)) {
+    const { loopSessionId: _loop, ...projection } = node;
+    containers[id] = projection;
+  }
+  return {
+    root_container_ids: [...tree.rootContainerIds],
+    active_container_ids: [...tree.activeContainerIds],
+    containers
+  };
+}
+
+// src/types/workflowSession.ts
+function createEmptyWorkflowProgress() {
+  return {
+    workflowId: null,
+    workflowPath: null,
+    status: "running",
+    stages: [],
+    parallelItems: {}
+  };
+}
+function createEmptyWorkflowSessionState() {
+  return {
+    status: "connecting",
+    meta: { workflowRunId: null, startedAt: null, lastEventId: null },
+    containerTree: createEmptyWorkflowContainerTreeState(),
+    workflowProgress: createEmptyWorkflowProgress(),
+    loopTreesBySessionId: {},
+    stageDoneSummariesByContainerId: {},
+    hotCompletedLoopSessionIds: [],
+    activeLoopSessionId: null,
+    openScopeStack: [],
+    internalErrors: []
+  };
+}
+
+// src/core/workflow/workflowLoopTreeUtils.ts
+function createWorkflowRunningLoopTree(seedMs = Date.now()) {
+  const tree = createEmptyTree();
+  tree.status = "running";
+  tree.meta.startedAt = seedMs;
+  return tree;
+}
+
+// src/types/workflowDisplay.ts
+function readDisplayPayload(data) {
+  const display = data.display;
+  if (display != null && typeof display === "object" && !Array.isArray(display)) {
+    return display;
+  }
+  return null;
+}
+
+// src/core/workflow/workflowContainerProjector.ts
+var OPEN_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "workflow-start",
+  "subworkflow-start",
+  "stage-start",
+  "parallel-item-start",
+  "parallel-aggregate-start",
+  "route-branch-start"
+]);
+var CLOSE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "workflow-end",
+  "workflow-failed",
+  "subworkflow-end",
+  "stage-done",
+  "stage-failed",
+  "parallel-item-done",
+  "parallel-item-failed",
+  "parallel-aggregate-done",
+  "parallel-aggregate-failed",
+  "route-branch-done",
+  "route-branch-failed"
+]);
+var EVENT_TYPE_TO_SCOPE = {
+  "workflow-start": "workflow",
+  "workflow-end": "workflow",
+  "workflow-failed": "workflow",
+  "subworkflow-start": "subworkflow",
+  "subworkflow-end": "subworkflow",
+  "stage-start": "stage",
+  "stage-done": "stage",
+  "stage-failed": "stage",
+  "parallel-item-start": "item",
+  "parallel-item-done": "item",
+  "parallel-item-failed": "item",
+  "parallel-aggregate-start": "aggregate",
+  "parallel-aggregate-done": "aggregate",
+  "parallel-aggregate-failed": "aggregate",
+  "route-branch-start": "branch",
+  "route-branch-done": "branch",
+  "route-branch-failed": "branch"
+};
+var CONTENT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "reasoning-start",
+  "reasoning-delta",
+  "reasoning-end",
+  "text-start",
+  "text-delta",
+  "text-end",
+  "tool-input",
+  "tool-input-start",
+  "tool-input-delta",
+  "tool-call",
+  "tool-result",
+  "tool-error",
+  "tool-progress"
+]);
+var SCOPE_PRIORITY = {
+  workflow: 0,
+  subworkflow: 1,
+  aggregate: 2,
+  stage: 3,
+  item: 3,
+  branch: 3
+};
+var FAILED_CLOSE_TYPES = /* @__PURE__ */ new Set([
+  "workflow-failed",
+  "stage-failed",
+  "parallel-item-failed",
+  "parallel-aggregate-failed",
+  "route-branch-failed"
+]);
+function buildContainerId(workflowPath, scope, scopeKey) {
+  return `${workflowPath}|${scope}:${scopeKey}`;
+}
+function readString(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+function resolveScopeKey(eventType, data) {
+  if (eventType === "workflow-start" || eventType === "workflow-end" || eventType === "workflow-failed") {
+    const workflowId = readString(data, "workflow_id");
+    if (workflowId) return workflowId;
+    return readString(data, "workflow_path") ?? "workflow";
+  }
+  if (eventType === "subworkflow-start" || eventType === "subworkflow-end") {
+    return readString(data, "child_workflow_id") ?? "subworkflow";
+  }
+  if (eventType === "stage-start" || eventType === "stage-done" || eventType === "stage-failed") {
+    const stageKey = readString(data, "stage_key");
+    if (stageKey) return stageKey;
+    const stageIndex = data.stage_index;
+    return typeof stageIndex === "number" ? String(stageIndex) : "stage";
+  }
+  if (eventType === "parallel-item-start" || eventType === "parallel-item-done" || eventType === "parallel-item-failed") {
+    const itemKey = readString(data, "item_key");
+    if (itemKey) return itemKey;
+    const itemIndex = data.item_index;
+    return typeof itemIndex === "number" ? String(itemIndex) : "item";
+  }
+  if (eventType === "parallel-aggregate-start" || eventType === "parallel-aggregate-done" || eventType === "parallel-aggregate-failed") {
+    return readString(data, "aggregate_key") ?? "aggregate";
+  }
+  if (eventType === "route-branch-start" || eventType === "route-branch-done" || eventType === "route-branch-failed") {
+    return readString(data, "branch_key") ?? readString(data, "branch_node") ?? "branch";
+  }
+  const display = readDisplayPayload(data);
+  if (display?.debug_key) return display.debug_key;
+  return "unknown";
+}
+function displayStatus(data, fallback) {
+  const display = readDisplayPayload(data);
+  if (display?.status) return display.status;
+  return fallback;
+}
+function closeStatus(eventType) {
+  return FAILED_CLOSE_TYPES.has(eventType) ? "failed" : "completed";
+}
+function readPreview(data, ...keys) {
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === "string") return value;
+  }
+  return "";
+}
+function contentBlockFromEvent(event) {
+  const { event_type: eventType } = event;
+  const payload = event.data ?? {};
+  if (eventType === "reasoning-start" || eventType === "reasoning-delta" || eventType === "reasoning-end") {
+    let preview = readPreview(payload, "delta", "text", "reasoning");
+    if (!preview && eventType === "reasoning-start") preview = "Thinking\u2026";
+    return { kind: "reasoning", preview, tool_name: null };
+  }
+  if (eventType === "text-start" || eventType === "text-delta" || eventType === "text-end") {
+    const preview = readPreview(payload, "delta", "text");
+    return { kind: "text", preview, tool_name: null };
+  }
+  if (CONTENT_EVENT_TYPES.has(eventType)) {
+    const toolName = event.tool_name ?? readString(payload, "tool_name");
+    const preview = readPreview(payload, "summary", "output", "input", "delta") || toolName || eventType;
+    return {
+      kind: "tool",
+      preview,
+      tool_name: toolName ?? null
+    };
+  }
+  return null;
+}
+function resolveContentScopeKey(data) {
+  for (const keyName of ["stage_key", "item_key", "branch_key", "debug_key"]) {
+    const value = readString(data, keyName);
+    if (value) return value;
+  }
+  const display = readDisplayPayload(data);
+  return display?.debug_key ?? null;
+}
+var WorkflowContainerActiveSet = class {
+  openOrder = [];
+  nodes = {};
+  restoreNode(node) {
+    this.nodes[node.container_id] = { ...node };
+    if (node.is_open && !this.openOrder.includes(node.container_id)) {
+      this.openOrder.push(node.container_id);
+    }
+  }
+  open(node) {
+    this.nodes[node.container_id] = node;
+    if (!this.openOrder.includes(node.container_id)) {
+      this.openOrder.push(node.container_id);
+    }
+  }
+  close(containerId, status) {
+    const node = this.nodes[containerId];
+    if (!node) return;
+    node.status = status;
+    node.is_open = false;
+    const idx = this.openOrder.indexOf(containerId);
+    if (idx !== -1) this.openOrder.splice(idx, 1);
+  }
+  get activeIds() {
+    return [...this.openOrder];
+  }
+  getNode(containerId) {
+    return this.nodes[containerId];
+  }
+  get nodesById() {
+    return this.nodes;
+  }
+  rankContainer(containerId) {
+    const node = this.nodes[containerId];
+    if (!node) return [-1, -1, -1, -1];
+    const openIndex = this.openOrder.indexOf(containerId);
+    const scopePriority = SCOPE_PRIORITY[node.scope] ?? 0;
+    return [node.workflow_depth, scopePriority, node.workflow_path.length, openIndex];
+  }
+  deepestActive() {
+    if (this.openOrder.length === 0) return null;
+    return this.openOrder.reduce(
+      (best, cid) => this.compareRank(cid, best) > 0 ? cid : best
+    );
+  }
+  resolveContentTarget(workflowPath, scopeKey) {
+    if (scopeKey) {
+      for (let i = this.openOrder.length - 1; i >= 0; i -= 1) {
+        const containerId = this.openOrder[i];
+        const node = this.nodes[containerId];
+        if (node.scope_key === scopeKey && node.is_open) {
+          if (workflowPath === null || node.workflow_path === workflowPath) {
+            return containerId;
+          }
+        }
+      }
+    }
+    if (workflowPath) {
+      const candidates = this.openOrder.filter((cid) => {
+        const node = this.nodes[cid];
+        if (!node.is_open) return false;
+        return node.workflow_path === workflowPath || workflowPath.startsWith(`${node.workflow_path}>`);
+      });
+      if (candidates.length > 0) {
+        return candidates.reduce(
+          (best, cid) => this.compareRank(cid, best) > 0 ? cid : best
+        );
+      }
+    }
+    return this.deepestActive();
+  }
+  closeDescendantsOfPath(workflowPath, status) {
+    const toClose = this.openOrder.filter((cid) => {
+      const node = this.nodes[cid];
+      return node.workflow_path === workflowPath || node.workflow_path.startsWith(`${workflowPath}>`);
+    });
+    for (const containerId of toClose) {
+      this.close(containerId, status);
+    }
+  }
+  compareRank(a, b) {
+    const ra = this.rankContainer(a);
+    const rb = this.rankContainer(b);
+    for (let i = 0; i < ra.length; i += 1) {
+      if (ra[i] > rb[i]) return 1;
+      if (ra[i] < rb[i]) return -1;
+    }
+    return 0;
+  }
+  /** 供 StateMachine 比较容器深度 rank */
+  compareContainerRank(a, b) {
+    return this.compareRank(a, b);
+  }
+};
+var WorkflowContainerStateMachine = class {
+  active = new WorkflowContainerActiveSet();
+  rootIds = [];
+  suppressContentContainerIds = /* @__PURE__ */ new Set();
+  get activeSet() {
+    return this.active;
+  }
+  setSuppressContentContainerIds(ids) {
+    this.suppressContentContainerIds = ids;
+  }
+  rehydrate(snapshot) {
+    this.rootIds.length = 0;
+    this.rootIds.push(...snapshot.root_container_ids);
+    for (const node of Object.values(snapshot.containers)) {
+      this.active.restoreNode(node);
+    }
+  }
+  apply(event) {
+    const eventType = event.event_type;
+    const data = event.data ?? {};
+    if (OPEN_EVENT_TYPES.has(eventType)) {
+      this.openContainer(eventType, data);
+      return "open";
+    }
+    if (CLOSE_EVENT_TYPES.has(eventType)) {
+      this.closeContainer(eventType, data);
+      return "close";
+    }
+    if (CONTENT_EVENT_TYPES.has(eventType)) {
+      this.appendContent(event);
+      return "append-content";
+    }
+    return null;
+  }
+  snapshot() {
+    return {
+      root_container_ids: [...this.rootIds],
+      containers: { ...this.active.nodesById },
+      active_container_ids: this.active.activeIds
+    };
+  }
+  openContainer(eventType, data) {
+    const scope = EVENT_TYPE_TO_SCOPE[eventType];
+    if (!scope) return;
+    const workflowPath = readString(data, "workflow_path") ?? "";
+    const workflowDepth = typeof data.workflow_depth === "number" ? data.workflow_depth : 0;
+    const scopeKey = resolveScopeKey(eventType, data);
+    const containerId = buildContainerId(workflowPath, scope, scopeKey);
+    const display = readDisplayPayload(data);
+    const title = display?.title ?? scopeKey;
+    const subtitle = display?.description ?? "";
+    const pattern = display?.pattern ?? "";
+    const status = displayStatus(data, "running");
+    const parentId = this.resolveParentId(workflowPath, scope);
+    const node = {
+      container_id: containerId,
+      scope,
+      workflow_path: workflowPath,
+      workflow_depth: workflowDepth,
+      scope_key: scopeKey,
+      title,
+      subtitle,
+      status,
+      pattern,
+      parent_container_id: parentId,
+      display,
+      content_blocks: [],
+      is_open: true
+    };
+    this.active.open(node);
+    if (scope === "workflow" && !this.rootIds.includes(containerId)) {
+      this.rootIds.push(containerId);
+    }
+  }
+  closeContainer(eventType, data) {
+    const scope = EVENT_TYPE_TO_SCOPE[eventType];
+    if (!scope) return;
+    const workflowPath = readString(data, "workflow_path") ?? "";
+    const scopeKey = resolveScopeKey(eventType, data);
+    const containerId = buildContainerId(workflowPath, scope, scopeKey);
+    const status = displayStatus(data, closeStatus(eventType));
+    this.active.close(containerId, status);
+    if (scope === "workflow") {
+      this.active.closeDescendantsOfPath(workflowPath, status);
+    }
+  }
+  appendContent(event) {
+    const data = event.data ?? {};
+    const workflowPath = readString(data, "workflow_path") ?? null;
+    const scopeKey = resolveContentScopeKey(data);
+    const targetId = this.active.resolveContentTarget(workflowPath, scopeKey);
+    if (!targetId) return;
+    if (this.suppressContentContainerIds.has(targetId)) return;
+    const block = contentBlockFromEvent(event);
+    if (!block) return;
+    const node = this.active.getNode(targetId);
+    if (!node) return;
+    const last = node.content_blocks[node.content_blocks.length - 1];
+    if (last && last.kind === block.kind && (block.kind === "reasoning" || block.kind === "text")) {
+      if (block.preview) {
+        if (block.kind === "reasoning" && last.preview === "Thinking\u2026") {
+          last.preview = block.preview;
+        } else {
+          last.preview = `${last.preview}${block.preview}`;
+        }
+      }
+      return;
+    }
+    node.content_blocks.push(block);
+  }
+  resolveParentId(workflowPath, scope) {
+    if (scope === "workflow") return null;
+    const openNodes = this.active.activeIds.map((cid) => this.active.getNode(cid)).filter((node) => node.is_open);
+    if (openNodes.length === 0) return null;
+    const prefixCandidates = openNodes.filter(
+      (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 workflowCandidates = openNodes.filter((node) => node.scope === "workflow");
+    if (workflowCandidates.length > 0) {
+      return workflowCandidates.reduce(
+        (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
+      ).container_id;
+    }
+    return openNodes.reduce(
+      (best, node) => this.active.compareContainerRank(node.container_id, best.container_id) > 0 ? node : best
+    ).container_id;
+  }
+};
+var WorkflowContainerTreeProjector = class {
+  machine = new WorkflowContainerStateMachine();
+  rehydrate(snapshot) {
+    this.machine.rehydrate(snapshot);
+  }
+  setSuppressContentContainerIds(ids) {
+    this.machine.setSuppressContentContainerIds(ids);
+  }
+  consume(event) {
+    return this.machine.apply(event);
+  }
+  consumeAll(events) {
+    for (const event of events) {
+      this.consume(event);
+    }
+    return this.snapshot();
+  }
+  snapshot() {
+    return this.machine.snapshot();
+  }
+};
+function reduceContainerSnapshot(snapshot, event, options) {
+  const projector = new WorkflowContainerTreeProjector();
+  projector.rehydrate(snapshot);
+  if (options?.suppressContentContainerIds?.size) {
+    projector.setSuppressContentContainerIds(options.suppressContentContainerIds);
+  }
+  projector.consume(event);
+  return projector.snapshot();
+}
+function resolveContentTargetFromSnapshot(snapshot, workflowPath, scopeKey) {
+  const active = new WorkflowContainerActiveSet();
+  for (const containerId of snapshot.active_container_ids) {
+    const node = snapshot.containers[containerId];
+    if (node?.is_open) active.restoreNode(node);
+  }
+  return active.resolveContentTarget(workflowPath, scopeKey);
+}
+function mergeRuntimeContainerNodes(prev, snapshot) {
+  const out = {};
+  for (const [containerId, node] of Object.entries(snapshot.containers)) {
+    out[containerId] = {
+      ...node,
+      loopSessionId: prev[containerId]?.loopSessionId ?? null
+    };
+  }
+  return out;
+}
+
+// src/core/workflow/loopSessionUtils.ts
+function readString2(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+var LOOP_TASK_OPEN_SCOPES = {
+  "stage-start": "stage",
+  "parallel-item-start": "item",
+  "route-branch-start": "branch"
+};
+function buildLoopSessionId(workflowId, taskKey) {
+  return `${workflowId}-${taskKey}`;
+}
+function deriveLoopSessionIdFromStructureOpen(event) {
+  if (!LOOP_TASK_OPEN_SCOPES[event.event_type]) return null;
+  const data = event.data ?? {};
+  const workflowId = readString2(data, "workflow_id");
+  if (!workflowId) return null;
+  const taskKey = resolveScopeKey(event.event_type, data);
+  if (!taskKey || taskKey === "unknown") return null;
+  return buildLoopSessionId(workflowId, taskKey);
+}
+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");
+  if (!taskKey) return null;
+  return buildLoopSessionId(workflowId, taskKey);
+}
+function loopTaskScopeForStructureOpen(eventType) {
+  return LOOP_TASK_OPEN_SCOPES[eventType];
+}
+
+// src/core/workflowStructureEvents.ts
+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"
+]);
+function isWorkflowStructureEventType(eventType) {
+  return WORKFLOW_STRUCTURE_EVENT_TYPES.has(eventType);
+}
+
+// src/core/workflowReducer.ts
+function readString3(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : void 0;
+}
+function mapContainerStatusToProgressStatus(status) {
+  switch (status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    case "running":
+      return "running";
+    default:
+      return "pending";
+  }
+}
+function syncWorkflowProgressFromContainerTree(tree, prev) {
+  const workflowNodes = Object.values(tree.containersById).filter((n) => n.scope === "workflow");
+  const rootWorkflow = workflowNodes.find((n) => tree.rootContainerIds.includes(n.container_id)) ?? workflowNodes[0];
+  const stages = Object.values(tree.containersById).filter((n) => n.scope === "stage").sort((a, b) => {
+    const ai = a.display?.progress_current ?? 0;
+    const bi = b.display?.progress_current ?? 0;
+    if (ai !== bi) return ai - bi;
+    return a.scope_key.localeCompare(b.scope_key);
+  }).map((node, index) => ({
+    stageKey: node.scope_key,
+    stageIndex: node.display?.progress_current ?? index,
+    stageTotal: node.display?.progress_total,
+    status: mapContainerStatusToProgressStatus(node.status),
+    error: node.display?.status_reason
+  }));
+  const parallelItems = {};
+  for (const node of Object.values(tree.containersById)) {
+    if (node.scope !== "item") continue;
+    parallelItems[node.scope_key] = {
+      itemKey: node.scope_key,
+      itemIndex: node.display?.item_index ?? 0,
+      itemTotal: node.display?.item_total,
+      status: mapContainerStatusToProgressStatus(node.status),
+      loopSessionId: node.loopSessionId,
+      error: node.display?.status_reason
+    };
+  }
+  let runStatus = prev.status;
+  if (rootWorkflow) {
+    if (rootWorkflow.status === "completed") runStatus = "done";
+    else if (rootWorkflow.status === "failed") runStatus = "error";
+    else runStatus = "running";
+  }
+  return {
+    workflowId: rootWorkflow?.scope_key ?? prev.workflowId,
+    workflowPath: rootWorkflow?.workflow_path ?? prev.workflowPath,
+    status: runStatus,
+    stages,
+    parallelItems
+  };
+}
+function loopBoundContainerIds(containersById) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [containerId, node] of Object.entries(containersById)) {
+    if (node.loopSessionId) ids.add(containerId);
+  }
+  return ids;
+}
+function applyStructureToContainerTree(tree, event) {
+  const snapshot = reduceContainerSnapshot(containerTreeToSnapshot(tree), event, {
+    suppressContentContainerIds: loopBoundContainerIds(tree.containersById)
+  });
+  let containersById = mergeRuntimeContainerNodes(tree.containersById, snapshot);
+  containersById = enrichWorkflowRootFromStages(
+    containersById,
+    snapshot.root_container_ids
+  );
+  return {
+    rootContainerIds: snapshot.root_container_ids,
+    activeContainerIds: snapshot.active_container_ids,
+    containersById
+  };
+}
+function prebindLoopSessionFromStructureOpen(tree, event) {
+  const loopSessionId = deriveLoopSessionIdFromStructureOpen(event);
+  const scope = loopTaskScopeForStructureOpen(event.event_type);
+  if (!loopSessionId || !scope) return tree;
+  const data = event.data ?? {};
+  const workflowPath = readString3(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;
+  if (node.loopSessionId === loopSessionId && node.content_blocks.length === 0) {
+    return tree;
+  }
+  return {
+    ...tree,
+    containersById: {
+      ...tree.containersById,
+      [containerId]: {
+        ...node,
+        loopSessionId,
+        content_blocks: []
+      }
+    }
+  };
+}
+function enrichWorkflowRootFromStages(containersById, rootContainerIds) {
+  const rootId = rootContainerIds[0];
+  if (!rootId) return containersById;
+  const root = containersById[rootId];
+  if (!root || root.scope !== "workflow") return containersById;
+  const stages = Object.values(containersById).filter(
+    (node) => node.scope === "stage" && node.workflow_path === root.workflow_path && node.workflow_depth === root.workflow_depth
+  );
+  if (stages.length === 0) return containersById;
+  const pattern = root.pattern || root.display?.pattern || stages.find((s) => s.pattern)?.pattern || stages.find((s) => s.display?.pattern)?.display?.pattern || "chaining";
+  const inferredTotal = stages.reduce(
+    (max, s) => Math.max(max, s.display?.progress_total ?? 0),
+    0
+  );
+  const progressTotal = root.display?.progress_total ?? (inferredTotal > 0 ? inferredTotal : stages.length);
+  const settled = stages.filter(
+    (s) => s.status === "completed" || s.status === "failed"
+  ).length;
+  const progressCurrent = root.status === "completed" || root.status === "failed" ? progressTotal : Math.max(root.display?.progress_current ?? 0, settled);
+  if (root.pattern === pattern && root.display?.pattern === pattern && root.display?.progress_total === progressTotal && root.display?.progress_current === progressCurrent) {
+    return containersById;
+  }
+  const display = root.display ? {
+    ...root.display,
+    pattern,
+    progress_total: progressTotal,
+    progress_current: progressCurrent
+  } : root.display;
+  return {
+    ...containersById,
+    [rootId]: {
+      ...root,
+      pattern,
+      display
+    }
+  };
+}
+function findContainerByLoopSession(tree, loopSessionId) {
+  for (const [containerId, node] of Object.entries(tree.containersById)) {
+    if (node.loopSessionId === loopSessionId) return containerId;
+  }
+  return null;
+}
+var WORKFLOW_DEFAULT_LOOP_SESSION_ID = "workflow-loop-default";
+function resolveAgentLoopSessionId(event) {
+  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;
+  return WORKFLOW_DEFAULT_LOOP_SESSION_ID;
+}
+function bindLoopSessionToContainerTree(tree, event) {
+  const sessionId = resolveAgentLoopSessionId(event);
+  if (!sessionId) return tree;
+  if (findContainerByLoopSession(tree, sessionId)) return tree;
+  const data = event.data ?? {};
+  const workflowPath = readString3(data, "workflow_path") ?? null;
+  const scopeKey = resolveContentScopeKey(data);
+  let targetId = null;
+  if (scopeKey) {
+    targetId = resolveContentTargetFromSnapshot(
+      containerTreeToSnapshot(tree),
+      workflowPath,
+      scopeKey
+    );
+  }
+  if (!targetId) {
+    for (const containerId of tree.activeContainerIds) {
+      const node2 = tree.containersById[containerId];
+      if ((node2?.scope === "item" || node2?.scope === "stage") && !node2.loopSessionId) {
+        targetId = containerId;
+        break;
+      }
+    }
+  }
+  if (!targetId) {
+    targetId = resolveContentTargetFromSnapshot(
+      containerTreeToSnapshot(tree),
+      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;
+  }
+  return {
+    ...tree,
+    containersById: {
+      ...tree.containersById,
+      [targetId]: { ...node, loopSessionId: sessionId }
+    }
+  };
+}
+function applyStructureEvent(state, event) {
+  let containerTree = applyStructureToContainerTree(state.containerTree, event);
+  containerTree = prebindLoopSessionFromStructureOpen(containerTree, event);
+  const loopSessionId = deriveLoopSessionIdFromStructureOpen(event);
+  let nextState = { ...state, containerTree };
+  if (loopSessionId) {
+    nextState = ensureLoopTree(nextState, loopSessionId);
+  }
+  const workflowProgress = syncWorkflowProgressFromContainerTree(
+    containerTree,
+    state.workflowProgress
+  );
+  let status = nextState.status;
+  if (workflowProgress.status === "done") status = "done";
+  else if (workflowProgress.status === "error") status = "error";
+  else if (status === "connecting") status = "running";
+  const base = {
+    ...nextState,
+    status,
+    containerTree,
+    workflowProgress
+  };
+  if (event.session_id && !state.meta.workflowRunId) {
+    return {
+      ...base,
+      meta: { ...state.meta, workflowRunId: event.session_id }
+    };
+  }
+  return base;
+}
+function ensureLoopTree(state, loopSessionId) {
+  if (state.loopTreesBySessionId[loopSessionId]) return state;
+  const loopTree = createWorkflowRunningLoopTree();
+  return {
+    ...state,
+    loopTreesBySessionId: {
+      ...state.loopTreesBySessionId,
+      [loopSessionId]: loopTree
+    },
+    activeLoopSessionId: state.activeLoopSessionId ?? loopSessionId
+  };
+}
+function reduceWorkflowSession(state, event, eventIndex, options) {
+  if (event.event_type === "task-list-snapshot") {
+    const data = event.data;
+    const taskListId = typeof data.task_list_id === "string" ? data.task_list_id : void 0;
+    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);
+    return {
+      ...next2,
+      loopTreesBySessionId: {
+        ...next2.loopTreesBySessionId,
+        [loopSessionId2]: reducedLoop2
+      },
+      activeLoopSessionId: loopSessionId2
+    };
+  }
+  if (isWorkflowStructureEventType(event.event_type)) {
+    return applyStructureEvent(state, event);
+  }
+  const loopSessionId = resolveAgentLoopSessionId(event) ?? WORKFLOW_DEFAULT_LOOP_SESSION_ID;
+  let containerTree = bindLoopSessionToContainerTree(state.containerTree, event);
+  containerTree = applyStructureToContainerTree(containerTree, event);
+  let next = ensureLoopTree({ ...state, containerTree }, loopSessionId);
+  const loopTree = next.loopTreesBySessionId[loopSessionId];
+  const reducedLoop = reduceTree(loopTree, event, eventIndex, options);
+  const workflowProgress = syncWorkflowProgressFromContainerTree(
+    next.containerTree,
+    next.workflowProgress
+  );
+  return {
+    ...next,
+    workflowProgress,
+    loopTreesBySessionId: {
+      ...next.loopTreesBySessionId,
+      [loopSessionId]: reducedLoop
+    },
+    activeLoopSessionId: loopSessionId,
+    status: reducedLoop.status === "error" ? "error" : next.status === "connecting" ? "running" : next.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);
+    }
+  }
+  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 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);
+    }
+  }
+  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 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
+  };
+}
+
+// src/core/workflowSessionStore.ts
+function safeReduceWorkflow(state, event, eventIndex, options) {
+  try {
+    return { state: reduceWorkflowSession(state, event, eventIndex, options) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    if (import.meta.env?.DEV) {
+      console.error("[langchain_agentx_stream_ui] workflow reducer error:", err);
+    }
+    return {
+      state: {
+        ...state,
+        internalErrors: [
+          ...state.internalErrors,
+          { eventIndex, eventType: event.event_type, message, stack }
+        ]
+      }
+    };
+  }
+}
+function createWorkflowSessionStore(initialState = createEmptyWorkflowSessionState(), storeOptions) {
+  const reduceOpts = {
+    tierOverrides: storeOptions?.tierOverrides
+  };
+  const initialEventCount = storeOptions?.initialEventCount ?? 0;
+  const seenEventIds = new Set(storeOptions?.initialSeenEventIds);
+  const evictCompletedLoops = storeOptions?.evictCompletedLoops ?? true;
+  const maxHydratedCompletedLoops = storeOptions?.maxHydratedCompletedLoops ?? 4;
+  const pinnedLoopSessionIds = {};
+  const finalizeState = (reduced) => {
+    if (!evictCompletedLoops) return reduced;
+    return evictInactiveLoopTrees(reduced, pinnedLoopSessionIds);
+  };
+  return createStore2((set, get) => ({
+    state: initialState,
+    eventCount: initialEventCount,
+    applyEvent(event, ctx) {
+      const sseEventId = ctx?.sseEventId;
+      if (shouldSkipDuplicateEvent(seenEventIds, sseEventId)) return;
+      const { state, eventCount } = get();
+      const { state: reduced } = safeReduceWorkflow(state, event, eventCount, reduceOpts);
+      const evicted = finalizeState(reduced);
+      const nextMeta = sseEventId ? { ...evicted.meta, lastEventId: sseEventId } : evicted.meta;
+      markEventIdSeen(seenEventIds, sseEventId);
+      set({
+        state: {
+          ...evicted,
+          meta: nextMeta,
+          status: evicted.status === "connecting" ? "running" : evicted.status
+        },
+        eventCount: eventCount + 1
+      });
+    },
+    applyEvents(events) {
+      for (const event of events) {
+        get().applyEvent(event);
+      }
+    },
+    reset() {
+      seenEventIds.clear();
+      set({
+        state: createEmptyWorkflowSessionState(),
+        eventCount: 0
+      });
+    },
+    markAsError(error) {
+      const { state } = 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
+            }
+          ]
+        }
+      });
+    },
+    /**
+     * P2：将 completed loop 加入 LRU 热缓存并淘汰溢出。
+     * running 保护由 collectProtectedLoopSessionIds 按状态自动覆盖，不再依赖永久 pin。
+     */
+    pinLoopSession(loopSessionId) {
+      set((current) => {
+        let next = touchCompletedLoopSession(current.state, loopSessionId);
+        next = evictCompletedLoopOverflow(next, maxHydratedCompletedLoops);
+        next = finalizeState(next);
+        return { state: next };
+      });
+    },
+    /**
+     * P2：宿主 replay 后灌入 loop 树，touch LRU 并淘汰溢出。
+     * completed loop 受 hotCompletedLoopSessionIds 保护，不再永久 pin。
+     */
+    hydrateLoopSession(loopSessionId, events) {
+      const { state, eventCount } = get();
+      let tree = state.loopTreesBySessionId[loopSessionId] ?? createEmptyTree();
+      let idx = eventCount;
+      for (const event of events) {
+        tree = reduceTree(tree, event, idx, reduceOpts);
+        idx += 1;
+      }
+      set((current) => {
+        let next = {
+          ...current.state,
+          loopTreesBySessionId: {
+            ...current.state.loopTreesBySessionId,
+            [loopSessionId]: tree
+          }
+        };
+        next = touchCompletedLoopSession(next, loopSessionId);
+        next = evictCompletedLoopOverflow(next, maxHydratedCompletedLoops);
+        next = finalizeState(next);
+        return { state: next };
+      });
+    }
+  }));
+}
+
+// src/view/workflow/WorkflowChrome.tsx
+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";
+
+// src/view/workflow/WorkflowContainerLine.tsx
+import { Fragment, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function WorkflowContainerLine({
+  title,
+  description,
+  uiStatus,
+  meta = [],
+  statusLabel,
+  showDot = true,
+  variant = "default",
+  onToggle,
+  expanded,
+  interactive,
+  titleTestId,
+  descriptionTestId,
+  headerTestId,
+  debugScopeKey,
+  verbose = false,
+  className = "",
+  style
+}) {
+  const lineClass = [
+    "lax-workflow-container-line",
+    variant === "root" ? "lax-workflow-container-line--root" : "",
+    onToggle && interactive !== false ? "lax-workflow-container-line--interactive" : "",
+    className
+  ].filter(Boolean).join(" ");
+  const content = /* @__PURE__ */ jsxs2(Fragment, { children: [
+    showDot ? /* @__PURE__ */ jsx5(
+      "span",
+      {
+        className: "lax-workflow-container-line__status-dot lax-workflow-stage-container__status-dot",
+        "data-status": uiStatus,
+        "aria-hidden": true
+      }
+    ) : null,
+    /* @__PURE__ */ jsx5("span", { className: "lax-workflow-container-line__title", "data-testid": titleTestId, children: title }),
+    description ? /* @__PURE__ */ jsxs2(
+      "span",
+      {
+        className: "lax-workflow-container-line__desc",
+        "data-testid": descriptionTestId,
+        children: [
+          "(",
+          description,
+          ")"
+        ]
+      }
+    ) : null,
+    meta.length > 0 ? /* @__PURE__ */ jsx5("span", { className: "lax-workflow-container-line__meta", "data-testid": titleTestId ? `${titleTestId}-meta` : void 0, children: meta.join(" \xB7 ") }) : null,
+    verbose && debugScopeKey ? /* @__PURE__ */ jsx5("span", { className: "lax-workflow-container-line__debug", "data-testid": "lax-workflow-id", children: debugScopeKey }) : null,
+    /* @__PURE__ */ jsx5("span", { className: "lax-workflow-container-line__status", children: statusLabel })
+  ] });
+  if (onToggle && interactive !== false) {
+    return /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        className: `${lineClass} lax-workflow-stage-container__header`,
+        onClick: onToggle,
+        "aria-expanded": expanded,
+        "data-testid": headerTestId,
+        style,
+        children: content
+      }
+    );
+  }
+  if (onToggle) {
+    return /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: `${lineClass} lax-workflow-container-line--static-toggle`,
+        onClick: onToggle,
+        onKeyDown: (event) => {
+          if (event.key === "Enter" || event.key === " ") {
+            event.preventDefault();
+            onToggle();
+          }
+        },
+        role: "button",
+        tabIndex: 0,
+        "aria-expanded": expanded,
+        "data-testid": headerTestId,
+        style,
+        children: content
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx5("div", { className: lineClass, style, children: content });
+}
+
+// src/view/workflow/WorkflowExpandTrigger.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function WorkflowExpandTrigger({
+  summary,
+  summaryTestId,
+  teaser,
+  expandHint,
+  onToggle,
+  expanded = false,
+  testId,
+  teaserTestId,
+  className = ""
+}) {
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      type: "button",
+      className: `lax-workflow-expand-trigger${className ? ` ${className}` : ""}`,
+      onClick: onToggle,
+      "aria-expanded": expanded,
+      "data-testid": testId,
+      children: [
+        /* @__PURE__ */ jsxs3("span", { className: "lax-workflow-expand-trigger__summary", "data-testid": summaryTestId, children: [
+          "\u23BF ",
+          summary
+        ] }),
+        teaser ? /* @__PURE__ */ jsx6(
+          "span",
+          {
+            className: "lax-workflow-expand-trigger__teaser",
+            "data-testid": teaserTestId,
+            children: teaser
+          }
+        ) : null,
+        expandHint ? /* @__PURE__ */ jsx6("span", { className: "lax-workflow-expand-trigger__hint", children: expandHint }) : null
+      ]
+    }
+  );
+}
+
+// src/view/workflow/workflowContainerLineUtils.ts
+function formatContainerScopeMetaLabel(scope) {
+  return scope;
+}
+function withScopeMeta(node, parts) {
+  return [formatContainerScopeMetaLabel(node.scope), ...parts];
+}
+function mapContainerUiStatus(status) {
+  switch (status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    case "running":
+    case "retrying":
+      return "running";
+    case "skipped":
+      return "skipped";
+    default:
+      return "pending";
+  }
+}
+function mapContainerStatusLabel(status) {
+  switch (status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    case "running":
+      return "Running\u2026";
+    case "retrying":
+      return "Retrying\u2026";
+    case "skipped":
+      return "skipped";
+    case "blocked":
+      return "blocked";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "pending";
+  }
+}
+function mapWorkflowRootStatusLabel(status) {
+  switch (status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "error";
+    default:
+      return "running";
+  }
+}
+function buildStageProgressMeta(node) {
+  const display = node.display;
+  if (display?.progress_label) return display.progress_label;
+  if (display?.progress_current != null && display?.progress_total != null) {
+    return `Step ${display.progress_current}/${display.progress_total}`;
+  }
+  return null;
+}
+function buildWorkflowRootMeta(node) {
+  const meta = [];
+  if (node.pattern) meta.push(node.pattern);
+  const display = node.display;
+  if (display?.progress_current != null && display?.progress_total != null) {
+    meta.push(`${display.progress_current}/${display.progress_total}`);
+  }
+  return withScopeMeta(node, meta);
+}
+function buildStageLineMeta(node) {
+  const progress = buildStageProgressMeta(node);
+  return withScopeMeta(node, progress ? [progress] : []);
+}
+function buildAggregateLineMeta(node) {
+  return withScopeMeta(node, []);
+}
+function buildRouteLineMeta(node) {
+  const meta = [];
+  const decision = node.display?.decision_label;
+  if (decision) meta.push(decision);
+  const progress = buildStageProgressMeta(node);
+  if (progress) meta.push(progress);
+  return withScopeMeta(node, meta);
+}
+function workflowIndentUnit(depth) {
+  return depth >= 4 ? "0.75rem" : "1rem";
+}
+function countSettledItems(items) {
+  let settled = 0;
+  for (const item of items) {
+    if (item.status === "completed" || item.status === "failed") {
+      settled += 1;
+    }
+  }
+  return { settled, total: items.length };
+}
+function buildAggregateStatusLabel(node, siblingItems = []) {
+  const display = node.display;
+  let current = display?.progress_current;
+  let total = display?.progress_total;
+  if ((current == null || total == null) && siblingItems.length > 0) {
+    const { settled, total: itemTotal } = countSettledItems(siblingItems);
+    current = settled;
+    total = itemTotal;
+  }
+  if (node.status === "pending" || node.status === "blocked") {
+    if (current != null && total != null) {
+      return `waiting (${current}/${total})`;
+    }
+    return "waiting";
+  }
+  if (current != null && total != null && (node.status === "running" || node.status === "retrying")) {
+    return `waiting (${current}/${total})`;
+  }
+  return mapContainerStatusLabel(node.status);
+}
+function mapAggregateUiStatus(node) {
+  if (node.status === "pending" || node.status === "blocked") return "pending";
+  if (node.status === "completed") return "done";
+  if (node.status === "failed") return "failed";
+  if (node.status === "running" || node.status === "retrying") return "running";
+  return mapContainerUiStatus(node.status);
+}
+
+// src/view/workflow/WorkflowAggregateContainer.tsx
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function mergeTeaser(node) {
+  const blocks = node.content_blocks;
+  if (blocks.length === 0) return "";
+  const last = blocks[blocks.length - 1];
+  return last?.preview ?? "";
+}
+function WorkflowAggregateContainer({
+  node,
+  loopTree,
+  siblingItems = [],
+  depth = 1,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  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 testId = `lax-workflow-aggregate-${node.scope_key}`;
+  const uiStatus = mapAggregateUiStatus(node);
+  const statusLabel = buildAggregateStatusLabel(node, siblingItems);
+  const [expanded, setExpanded] = useState(isRunning);
+  useEffect3(() => {
+    if (isRunning) setExpanded(true);
+    if (isDone) setExpanded(false);
+  }, [isRunning, isDone]);
+  const toggleExpanded = useCallback(() => {
+    setExpanded((prev) => !prev);
+  }, []);
+  const shellToggle = isRunning ? toggleExpanded : isDone && expanded ? toggleExpanded : void 0;
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      className: `lax-workflow-aggregate lax-workflow-stage-container lax-workflow-stage-container--${isWaiting ? "pending" : isDone ? "done" : "running"}`,
+      "data-testid": testId,
+      "data-container-scope": "aggregate",
+      style: { "--lax-workflow-depth": depth },
+      children: [
+        /* @__PURE__ */ jsx7(
+          WorkflowContainerLine,
+          {
+            title: node.title,
+            description: node.subtitle || void 0,
+            uiStatus,
+            meta: buildAggregateLineMeta(node),
+            statusLabel,
+            onToggle: shellToggle,
+            interactive: isRunning,
+            expanded,
+            titleTestId: `${testId}-title`,
+            descriptionTestId: `${testId}-desc`
+          }
+        ),
+        isWaiting && waitingTeaser ? /* @__PURE__ */ jsxs4("div", { className: "lax-workflow-aggregate__waiting-teaser", "data-testid": `${testId}-waiting`, children: [
+          "\u23BF ",
+          waitingTeaser
+        ] }) : null,
+        expanded && isRunning && loopTree ? /* @__PURE__ */ jsx7("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx7(
+          AgentLoopView,
+          {
+            tree: loopTree,
+            showTaskListFooter: false,
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools
+          }
+        ) }) : null,
+        isDone && !expanded ? /* @__PURE__ */ jsx7(
+          WorkflowExpandTrigger,
+          {
+            summary: `${node.title} \xB7 done`,
+            teaser: teaser || void 0,
+            onToggle: () => setExpanded(true),
+            expanded: false,
+            testId: `${testId}-done`,
+            teaserTestId: `${testId}-teaser`
+          }
+        ) : null,
+        isDone && expanded && loopTree ? /* @__PURE__ */ jsx7("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx7(
+          AgentLoopView,
+          {
+            tree: loopTree,
+            showTaskListFooter: false,
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools
+          }
+        ) }) : null
+      ]
+    }
+  );
+}
+
+// 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";
+
+// src/core/workflow/workflowParallelGroupMetrics.ts
+function readDisplayMetrics(items) {
+  let hasMetrics = false;
+  let running = 0;
+  let completed = 0;
+  let failed = 0;
+  let total = 0;
+  for (const item of items) {
+    const metrics = item.display;
+    if (metrics?.metrics_total != null || metrics?.metrics_running != null || metrics?.metrics_completed != null || metrics?.metrics_failed != null) {
+      hasMetrics = true;
+    }
+    running += metrics?.metrics_running ?? 0;
+    completed += metrics?.metrics_completed ?? 0;
+    failed += metrics?.metrics_failed ?? 0;
+    total += metrics?.metrics_total ?? 0;
+  }
+  if (!hasMetrics) return null;
+  if (total <= 0) total = items.length;
+  return { total, running, completed, failed };
+}
+function computeParallelGroupMetrics(items) {
+  const fromDisplay = readDisplayMetrics(items);
+  if (fromDisplay) return fromDisplay;
+  let running = 0;
+  let completed = 0;
+  let failed = 0;
+  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;
+    }
+  }
+  return {
+    total: items.length,
+    running,
+    completed,
+    failed
+  };
+}
+function formatParallelGroupSummary(metrics) {
+  if (metrics.running > 0) {
+    const n2 = metrics.running;
+    return `Running ${n2} agent${n2 === 1 ? "" : "s"}\u2026`;
+  }
+  if (metrics.failed > 0) {
+    const ok = metrics.completed;
+    return `Done (${ok} agent${ok === 1 ? "" : "s"}) \xB7 ${metrics.failed} failed`;
+  }
+  const n = metrics.total;
+  return `Done (${n} agent${n === 1 ? "" : "s"})`;
+}
+
+// src/view/workflow/WorkflowStageContainer.tsx
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useState as useState2 } from "react";
+import { useStore as useStore2 } from "zustand";
+
+// src/core/workflow/loopTreeUtils.ts
+function hasTimelineNodes(tree) {
+  if (!tree) return false;
+  return tree.rootChildren.length > 0 || Object.keys(tree.byId).length > 0;
+}
+
+// src/view/workflow/workflowStageDoneBody.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function WorkflowStageDoneBody({
+  loopTree,
+  testId,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools,
+  bodyClassName = "lax-workflow-stage-container__body"
+}) {
+  if (loopTree && hasTimelineNodes(loopTree)) {
+    return /* @__PURE__ */ jsx8("div", { className: bodyClassName, "data-testid": testId, children: /* @__PURE__ */ jsx8(
+      AgentLoopView,
+      {
+        tree: loopTree,
+        showTaskListFooter: false,
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx8(
+    "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" })
+    }
+  );
+}
+
+// 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 jsx9, 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}`;
+  return `lax-workflow-container-${node.scope_key}`;
+}
+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({
+  node,
+  loopTree,
+  depth = 0,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  const { verbose } = useSessionViewOptions();
+  const scale = useWorkflowScaleOptions();
+  const store = useWorkflowSessionStoreApi();
+  const replayHandler = useWorkflowLoopReplayHandler();
+  const activeLoopSessionId = useStore2(store, (s) => s.state.activeLoopSessionId);
+  const activeContainerIds = useStore2(store, (s) => s.state.containerTree.activeContainerIds);
+  const cachedSummary = useStore2(
+    store,
+    (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 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 [expanded, setExpanded] = useState2(shouldAutoExpandRunning);
+  useEffect4(() => {
+    if (shouldAutoExpandRunning) {
+      setExpanded(true);
+      return;
+    }
+    if (isRunning && !isSkipped && scale.onlyExpandActiveRunning) {
+      setExpanded(false);
+      return;
+    }
+    if (isDone || isSkipped) {
+      setExpanded(false);
+    }
+  }, [shouldAutoExpandRunning, isRunning, isDone, isSkipped, scale.onlyExpandActiveRunning]);
+  const requestLoopHydration = useCallback2(() => {
+    const loopSessionId = node.loopSessionId;
+    if (!loopSessionId || loopTree) return;
+    pinLoopSession(loopSessionId);
+    void replayHandler?.(loopSessionId);
+  }, [node.loopSessionId, loopTree, pinLoopSession, replayHandler]);
+  const toggleExpanded = useCallback2(() => {
+    setExpanded((prev) => {
+      const next = !prev;
+      if (next && isDone && node.loopSessionId && !loopTree) {
+        requestLoopHydration();
+      }
+      return next;
+    });
+  }, [isDone, node.loopSessionId, loopTree, requestLoopHydration]);
+  useEffect4(() => {
+    const onKeyDown = (event) => {
+      if (!(event.ctrlKey || event.metaKey) || event.key.toLowerCase() !== "o") return;
+      setExpanded(true);
+      requestLoopHydration();
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [requestLoopHydration]);
+  const displayTitle = node.title;
+  const usesScopedLoop = Boolean(node.loopSessionId);
+  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 testId = containerTestId(node);
+  const isItem = node.scope === "item";
+  const canToggleShell = isRunning && !isSkipped || isDone;
+  const shellToggle = canToggleShell ? toggleExpanded : void 0;
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: `lax-workflow-stage-container lax-workflow-stage-container--${uiStatus}${isSkipped ? " lax-workflow-stage-container--skipped" : ""}${isItem ? " lax-workflow-parallel-item" : " lax-workflow-stage"}`,
+      "data-testid": testId,
+      "data-stage-status": uiStatus,
+      "data-container-scope": node.scope,
+      "data-active": isActive ? "true" : void 0,
+      style: {
+        "--lax-workflow-depth": depth,
+        "--lax-workflow-indent-unit": workflowIndentUnit(depth)
+      },
+      children: [
+        /* @__PURE__ */ jsx9(
+          WorkflowContainerLine,
+          {
+            title: displayTitle,
+            description: node.subtitle || void 0,
+            uiStatus,
+            meta: buildStageLineMeta(node),
+            statusLabel,
+            onToggle: shellToggle,
+            interactive: canToggleShell,
+            expanded,
+            headerTestId: isDone ? `${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: [
+          teaserText ? /* @__PURE__ */ jsx9(
+            "span",
+            {
+              className: "lax-workflow-stage-container__done-teaser-line",
+              "data-testid": `${testId}-teaser`,
+              children: `\u23BF ${teaserText}`
+            }
+          ) : null,
+          expandHint ? /* @__PURE__ */ jsx9("span", { className: "lax-workflow-expand-trigger__hint", children: expandHint }) : null
+        ] }) : null,
+        expanded && isRunning && !usesScopedLoop && node.content_blocks.length > 0 ? /* @__PURE__ */ jsx9(
+          "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(
+              "div",
+              {
+                className: "lax-workflow-stage-container__teaser",
+                children: block.preview
+              },
+              `${block.kind}-${index}`
+            ))
+          }
+        ) : null,
+        expanded && isRunning && runningLoopTree ? /* @__PURE__ */ jsx9(
+          "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(
+              AgentLoopView,
+              {
+                tree: runningLoopTree,
+                showTaskListFooter: false,
+                virtualized,
+                virtualizeThreshold,
+                groupParallelTools
+              }
+            )
+          }
+        ) : null,
+        isDone && expanded ? loopTree ? /* @__PURE__ */ jsx9(
+          WorkflowStageDoneBody,
+          {
+            node,
+            loopTree,
+            testId: bodyTestId(node),
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools,
+            bodyClassName: isItem ? "lax-workflow-parallel-item__body lax-workflow-stage-container__body" : "lax-workflow-stage-container__body"
+          }
+        ) : /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            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." })
+            ]
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/view/workflow/WorkflowParallelGroup.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+function resolveLoopTree(node, loopTreesBySessionId) {
+  if (!node.loopSessionId) return void 0;
+  return loopTreesBySessionId[node.loopSessionId];
+}
+function WorkflowParallelGroup({
+  groupKey,
+  items,
+  loopTreesBySessionId,
+  depth = 1,
+  virtualized,
+  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 allSettled = metrics.total > 0 && metrics.running === 0 && metrics.completed + metrics.failed >= metrics.total;
+  const shouldAutoExpandGroup = hasRunning && (!scale.onlyExpandActiveRunning || hasActiveItem);
+  const [expanded, setExpanded] = useState3(shouldAutoExpandGroup);
+  useEffect5(() => {
+    if (shouldAutoExpandGroup) {
+      setExpanded(true);
+      return;
+    }
+    if (hasRunning && scale.onlyExpandActiveRunning) {
+      setExpanded(false);
+      return;
+    }
+    if (allSettled) {
+      setExpanded(false);
+    }
+  }, [shouldAutoExpandGroup, hasRunning, allSettled, scale.onlyExpandActiveRunning]);
+  const toggleExpanded = useCallback3(() => {
+    setExpanded((prev) => !prev);
+  }, []);
+  useEffect5(() => {
+    const onKeyDown = (event) => {
+      if (!(event.ctrlKey || event.metaKey) || event.key.toLowerCase() !== "o") return;
+      setExpanded(true);
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, []);
+  const renderItem = (index) => {
+    const item = items[index];
+    return /* @__PURE__ */ jsx10(
+      WorkflowStageContainer,
+      {
+        node: item,
+        loopTree: resolveLoopTree(item, loopTreesBySessionId),
+        depth,
+        virtualized,
+        virtualizeThreshold,
+        groupParallelTools
+      },
+      item.container_id
+    );
+  };
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      className: "lax-workflow-parallel-group",
+      "data-testid": `lax-workflow-parallel-group-${groupKey}`,
+      children: [
+        /* @__PURE__ */ jsx10(
+          WorkflowExpandTrigger,
+          {
+            summary,
+            expandHint: !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
+      ]
+    }
+  );
+}
+
+// src/view/workflow/WorkflowRootContainer.tsx
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+function WorkflowRootContainer({
+  node,
+  children
+}) {
+  const { verbose } = useSessionViewOptions();
+  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(
+      WorkflowContainerLine,
+      {
+        variant: "root",
+        title: node.title,
+        description: node.subtitle || void 0,
+        uiStatus,
+        meta: buildWorkflowRootMeta(node),
+        statusLabel,
+        titleTestId: "lax-workflow-root-title",
+        descriptionTestId: "lax-workflow-root-desc",
+        debugScopeKey: node.scope_key,
+        verbose
+      }
+    ),
+    children ? /* @__PURE__ */ jsx11("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";
+function WorkflowRouteContainer({
+  node,
+  loopTree,
+  depth = 1,
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  const { verbose } = useSessionViewOptions();
+  const isSkipped = node.status === "skipped";
+  const uiStatus = mapContainerUiStatus(node.status);
+  const isRunning = !isSkipped && (node.status === "running" || node.status === "retrying");
+  const isDone = !isSkipped && (node.status === "completed" || node.status === "failed");
+  const testId = `lax-workflow-route-${node.scope_key}`;
+  const doneSummary = useMemo5(
+    () => loopTree && isDone ? buildStageDoneSummary(loopTree) : null,
+    [loopTree, isDone]
+  );
+  const staticContentTeaser = !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 [expanded, setExpanded] = useState4(isRunning);
+  useEffect6(() => {
+    if (isSkipped) return;
+    if (isRunning) setExpanded(true);
+    if (isDone) setExpanded(false);
+  }, [isRunning, isDone, isSkipped]);
+  const toggleExpanded = useCallback4(() => {
+    if (!isSkipped) setExpanded((prev) => !prev);
+  }, [isSkipped]);
+  const shellToggle = isSkipped ? void 0 : isRunning ? toggleExpanded : isDone && expanded ? toggleExpanded : void 0;
+  const depthStyle = {
+    "--lax-workflow-depth": depth,
+    "--lax-workflow-indent-unit": workflowIndentUnit(depth)
+  };
+  return /* @__PURE__ */ jsxs8(
+    "div",
+    {
+      className: `lax-workflow-route-branch lax-workflow-stage-container lax-workflow-stage-container--${uiStatus}${isSkipped ? " lax-workflow-route-branch--skipped" : ""}`,
+      "data-testid": testId,
+      "data-route-status": node.status,
+      "data-container-scope": "branch",
+      style: depthStyle,
+      children: [
+        /* @__PURE__ */ jsx12(
+          WorkflowContainerLine,
+          {
+            title: node.title,
+            description: node.subtitle || void 0,
+            uiStatus,
+            meta: buildRouteLineMeta(node),
+            statusLabel: isSkipped ? "skipped" : mapContainerStatusLabel(node.status),
+            onToggle: shellToggle,
+            interactive: !isSkipped && isRunning,
+            expanded,
+            titleTestId: `${testId}-title`,
+            descriptionTestId: `${testId}-desc`
+          }
+        ),
+        !isSkipped && expanded && isRunning && loopTree ? /* @__PURE__ */ jsx12("div", { className: "lax-workflow-stage-container__body", "data-testid": `${testId}-body`, children: /* @__PURE__ */ jsx12(
+          AgentLoopView,
+          {
+            tree: loopTree,
+            showTaskListFooter: false,
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools
+          }
+        ) }) : null,
+        !isSkipped && isDone && !expanded ? /* @__PURE__ */ jsx12(
+          WorkflowExpandTrigger,
+          {
+            summary: `${node.title} \xB7 ${doneLabel}`,
+            teaser: teaserText || void 0,
+            expandHint,
+            onToggle: () => setExpanded(true),
+            expanded: false,
+            testId: `${testId}-done`,
+            teaserTestId: teaserText ? `${testId}-teaser` : void 0
+          }
+        ) : null,
+        !isSkipped && isDone && expanded ? /* @__PURE__ */ jsx12(
+          WorkflowStageDoneBody,
+          {
+            node,
+            loopTree,
+            testId: `${testId}-body`,
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// 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";
+function buildDoneSummary(node) {
+  const display = node.display;
+  if (display?.progress_total != null) {
+    const total = display.progress_total;
+    const current = node.status === "completed" ? total : display.progress_current ?? total;
+    return `${current}/${total} \xB7 done`;
+  }
+  return "done";
+}
+function WorkflowSubworkflowContainer({
+  node,
+  depth = 1,
+  children
+}) {
+  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 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);
+  useEffect7(() => {
+    if (isRunning) setExpanded(true);
+    if (isDone) setExpanded(false);
+  }, [isRunning, isDone]);
+  const toggleExpanded = useCallback5(() => {
+    setExpanded((prev) => !prev);
+  }, []);
+  const shellToggle = isRunning ? toggleExpanded : isDone && expanded ? toggleExpanded : void 0;
+  const depthStyle = {
+    "--lax-workflow-depth": depth,
+    "--lax-workflow-indent-unit": workflowIndentUnit(depth)
+  };
+  const showShellLine = !(isDone && !expanded);
+  return /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      className: "lax-workflow-subworkflow",
+      "data-testid": testId,
+      "data-container-scope": "subworkflow",
+      style: depthStyle,
+      children: [
+        showShellLine ? /* @__PURE__ */ jsx13(
+          WorkflowContainerLine,
+          {
+            variant: "root",
+            title: node.title,
+            description: node.subtitle || void 0,
+            uiStatus,
+            meta: buildWorkflowRootMeta(node),
+            statusLabel: mapWorkflowRootStatusLabel(node.status),
+            onToggle: shellToggle,
+            interactive: isRunning,
+            expanded,
+            titleTestId: `${testId}-title`,
+            descriptionTestId: `${testId}-desc`,
+            debugScopeKey: node.scope_key,
+            verbose
+          }
+        ) : null,
+        expanded && children ? /* @__PURE__ */ jsx13(
+          "div",
+          {
+            className: "lax-workflow-subworkflow-boundary",
+            "data-testid": `${testId}-boundary`,
+            style: depthStyle,
+            children
+          }
+        ) : null,
+        isDone && !expanded ? /* @__PURE__ */ jsx13(
+          WorkflowExpandTrigger,
+          {
+            summary: `${node.title} \xB7 ${buildDoneSummary(node)}`,
+            summaryTestId: `${testId}-title`,
+            teaser: teaser || void 0,
+            onToggle: () => setExpanded(true),
+            expanded: false,
+            testId: `${testId}-done`,
+            teaserTestId: teaser ? `${testId}-teaser` : void 0
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/view/workflow/WorkflowChrome.tsx
+import { Fragment as Fragment2, jsx as jsx14, 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));
+}
+function resolveLoopTree2(node, loopTreesBySessionId) {
+  if (!node.loopSessionId) return void 0;
+  return loopTreesBySessionId[node.loopSessionId];
+}
+function collectSiblingItems(node, containersById) {
+  if (!node.parent_container_id) return [];
+  return collectChildContainers(containersById, node.parent_container_id).filter(
+    (child) => child.scope === "item"
+  );
+}
+function renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps) {
+  const loopTree = resolveLoopTree2(node, loopTreesBySessionId);
+  switch (node.scope) {
+    case "aggregate":
+      return /* @__PURE__ */ jsx14(
+        WorkflowAggregateContainer,
+        {
+          node,
+          loopTree,
+          siblingItems: collectSiblingItems(node, containerTree.containersById),
+          depth,
+          ...viewProps
+        },
+        node.container_id
+      );
+    case "branch":
+      return /* @__PURE__ */ jsx14(
+        WorkflowRouteContainer,
+        {
+          node,
+          loopTree,
+          depth,
+          ...viewProps
+        },
+        node.container_id
+      );
+    default:
+      return /* @__PURE__ */ jsx14(
+        WorkflowStageContainer,
+        {
+          node,
+          loopTree,
+          depth,
+          ...viewProps
+        },
+        node.container_id
+      );
+  }
+}
+function renderItemSiblings(items, groupKey, depth, containerTree, loopTreesBySessionId, viewProps) {
+  if (items.length >= 2) {
+    return /* @__PURE__ */ jsx14(
+      WorkflowParallelGroup,
+      {
+        groupKey,
+        items,
+        loopTreesBySessionId,
+        depth,
+        ...viewProps
+      }
+    );
+  }
+  if (items.length === 1) {
+    return renderLeafContainer(items[0], depth, containerTree, loopTreesBySessionId, viewProps);
+  }
+  return null;
+}
+function renderContainerChildren(parentId, containerTree, loopTreesBySessionId, viewProps, depth) {
+  const children = collectChildContainers(containerTree.containersById, parentId);
+  const items = children.filter((node) => node.scope === "item");
+  const rest = children.filter((node) => node.scope !== "item");
+  return /* @__PURE__ */ jsxs10(Fragment2, { children: [
+    renderItemSiblings(items, parentId, depth, containerTree, loopTreesBySessionId, viewProps),
+    rest.map((node) => renderContainerNode(node, containerTree, loopTreesBySessionId, viewProps, depth))
+  ] });
+}
+function renderContainerNode(node, containerTree, loopTreesBySessionId, viewProps, depth) {
+  const nested = renderContainerChildren(
+    node.container_id,
+    containerTree,
+    loopTreesBySessionId,
+    viewProps,
+    depth + 1
+  );
+  const hasNested = collectChildContainers(containerTree.containersById, node.container_id).length > 0;
+  if (node.scope === "subworkflow") {
+    return /* @__PURE__ */ jsx14(
+      WorkflowSubworkflowContainer,
+      {
+        node,
+        depth,
+        children: hasNested ? nested : null
+      },
+      node.container_id
+    );
+  }
+  if (node.scope === "stage") {
+    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
+        ]
+      },
+      node.container_id
+    );
+  }
+  if (node.scope === "aggregate" || node.scope === "branch") {
+    return /* @__PURE__ */ jsxs10("div", { className: "lax-workflow-container-children", children: [
+      renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps),
+      hasNested ? nested : null
+    ] }, node.container_id);
+  }
+  return renderLeafContainer(node, depth, containerTree, loopTreesBySessionId, viewProps);
+}
+function renderWorkflowStageContent(node, containerTree, loopTreesBySessionId, viewProps) {
+  return renderContainerNode(node, containerTree, loopTreesBySessionId, viewProps, 1);
+}
+function renderWorkflowStageRow(node, containerTree, loopTreesBySessionId, viewProps, as = "li") {
+  const className = "lax-workflow-stage-list__item";
+  const content = renderWorkflowStageContent(
+    node,
+    containerTree,
+    loopTreesBySessionId,
+    viewProps
+  );
+  if (as === "div") {
+    return /* @__PURE__ */ jsx14("div", { className, role: "listitem", children: content }, node.container_id);
+  }
+  return /* @__PURE__ */ jsx14("li", { className, children: content }, node.container_id);
+}
+function WorkflowStageListPanel({
+  stages,
+  containerTree,
+  loopTreesBySessionId,
+  viewProps
+}) {
+  const scale = useWorkflowScaleOptions();
+  const [extraCompletedPages, setExtraCompletedPages] = useState6(0);
+  const maxVisibleDoneCount = scale.completedStagePageSize + extraCompletedPages * scale.completedStagePageSize;
+  const partition = useMemo7(
+    () => partitionWorkflowStages(stages, maxVisibleDoneCount),
+    [stages, maxVisibleDoneCount]
+  );
+  if (partition.visible.length === 0) return null;
+  const showMoreCount = Math.min(
+    scale.completedStagePageSize,
+    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(
+      (node) => renderWorkflowStageRow(node, containerTree, loopTreesBySessionId, viewProps)
+    ) }),
+    partition.hiddenCount > 0 ? /* @__PURE__ */ jsxs10(
+      "button",
+      {
+        type: "button",
+        className: "lax-workflow-stage-list__show-all",
+        "data-testid": "lax-workflow-stage-show-more",
+        onClick: () => setExtraCompletedPages((p) => p + 1),
+        children: [
+          "+",
+          partition.hiddenCount,
+          " completed stages hidden \xB7 Show ",
+          showMoreCount,
+          " more"
+        ]
+      }
+    ) : null,
+    extraCompletedPages > 0 && partition.hiddenCount === 0 ? /* @__PURE__ */ jsx14(
+      "button",
+      {
+        type: "button",
+        className: "lax-workflow-stage-list__show-all",
+        "data-testid": "lax-workflow-stage-show-less",
+        onClick: () => setExtraCompletedPages(0),
+        children: "Show fewer completed stages"
+      }
+    ) : null,
+    partition.hiddenCount > 0 ? /* @__PURE__ */ jsxs10(
+      "p",
+      {
+        className: "lax-workflow-stage-list__hidden-hint",
+        "data-testid": "lax-workflow-stage-hidden-hint",
+        children: [
+          partition.hiddenCount,
+          " completed stage",
+          partition.hiddenCount !== 1 ? "s" : "",
+          " hidden \u2014 running, pending, and failed stages are always visible."
+        ]
+      }
+    ) : null
+  ] });
+}
+function renderWorkflowChildren(workflowNode, containerTree, loopTreesBySessionId, viewProps) {
+  const children = collectChildContainers(
+    containerTree.containersById,
+    workflowNode.container_id
+  );
+  const stages = children.filter((node) => node.scope === "stage");
+  const items = children.filter((node) => node.scope === "item");
+  const other = children.filter(
+    (node) => node.scope !== "stage" && node.scope !== "item"
+  );
+  return /* @__PURE__ */ jsxs10(Fragment2, { children: [
+    stages.length > 0 ? /* @__PURE__ */ jsx14(
+      WorkflowStageListPanel,
+      {
+        stages,
+        containerTree,
+        loopTreesBySessionId,
+        viewProps
+      }
+    ) : null,
+    renderItemSiblings(items, workflowNode.container_id, 1, containerTree, loopTreesBySessionId, viewProps),
+    other.map(
+      (node) => renderContainerNode(node, containerTree, loopTreesBySessionId, viewProps, 1)
+    )
+  ] });
+}
+function WorkflowChrome({
+  containerTree,
+  loopTreesBySessionId = {},
+  virtualized,
+  virtualizeThreshold,
+  groupParallelTools
+}) {
+  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(
+      WorkflowContainerLine,
+      {
+        variant: "root",
+        title: "Workflow",
+        uiStatus: "pending",
+        statusLabel: "pending"
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx14("div", { className: "lax-workflow-chrome", "data-testid": "lax-workflow-chrome", children: rootNodes.map((workflowNode) => /* @__PURE__ */ jsx14(WorkflowRootContainer, { node: workflowNode, 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";
+
+// src/view/workflow/workflowTaskListMerge.ts
+var STATUS_ORDER = {
+  in_progress: 0,
+  pending: 1,
+  completed: 2
+};
+function mergeWorkflowLoopTasks(loopTreesBySessionId) {
+  const merged = [];
+  const loopIds = Object.keys(loopTreesBySessionId).sort();
+  for (const loopSessionId of loopIds) {
+    const tree = loopTreesBySessionId[loopSessionId];
+    if (!tree) continue;
+    for (const task of Object.values(tree.tasks)) {
+      merged.push({ ...task, loopSessionId });
+    }
+  }
+  return merged.sort((a, b) => {
+    const sa = STATUS_ORDER[a.status] ?? 99;
+    const sb = STATUS_ORDER[b.status] ?? 99;
+    if (sa !== sb) return sa - sb;
+    const loopCmp = a.loopSessionId.localeCompare(b.loopSessionId);
+    if (loopCmp !== 0) return loopCmp;
+    return a.id.localeCompare(b.id);
+  });
+}
+function deriveWorkflowTaskPhase(trees) {
+  if (trees.length === 0) return "hidden";
+  if (trees.some((tree) => tree.taskPhase === "visible")) return "visible";
+  if (trees.every((tree) => tree.taskPhase === "hidden-after-completion")) {
+    return "hidden-after-completion";
+  }
+  return "hidden";
+}
+function deriveWorkflowTaskFooterState(state) {
+  const trees = Object.values(state.loopTreesBySessionId);
+  return {
+    tasks: mergeWorkflowLoopTasks(state.loopTreesBySessionId),
+    taskPhase: deriveWorkflowTaskPhase(trees),
+    hasEverShownTaskList: trees.some((tree) => tree.hasEverShownTaskList),
+    sessionStatus: state.status
+  };
+}
+function shouldShowWorkflowTaskListFooter(state) {
+  const { tasks, taskPhase, hasEverShownTaskList, sessionStatus } = deriveWorkflowTaskFooterState(state);
+  return shouldShowTaskListFooter(taskPhase, tasks, hasEverShownTaskList, sessionStatus);
+}
+function formatWorkflowTaskFooterLabel(state) {
+  const { tasks } = deriveWorkflowTaskFooterState(state);
+  return formatTaskFooterLabel(tasks);
+}
+function groupWorkflowTasksByLoop(tasks) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const bucket = groups.get(task.loopSessionId) ?? [];
+    bucket.push(task);
+    groups.set(task.loopSessionId, bucket);
+  }
+  return Array.from(groups.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([loopSessionId, groupTasks]) => ({ loopSessionId, tasks: groupTasks }));
+}
+function loopSessionDisplayLabel(loopSessionId) {
+  const marker = "-";
+  const idx = loopSessionId.lastIndexOf(marker);
+  if (idx !== -1 && idx < loopSessionId.length - 1) {
+    return loopSessionId.slice(idx + 1);
+  }
+  return loopSessionId;
+}
+
+// src/view/workflow/WorkflowTaskListFooter.tsx
+import { jsx as jsx15, 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 })
+  ] });
+}
+function WorkflowTaskListFooter() {
+  const store = useWorkflowSessionStoreApi();
+  const state = useStore4(store, (s) => s.state);
+  const [expanded, setExpanded] = useState7(false);
+  const footerState = useMemo8(() => deriveWorkflowTaskFooterState(state), [state]);
+  const visible = shouldShowWorkflowTaskListFooter(state);
+  if (!visible) {
+    return null;
+  }
+  const label = formatWorkflowTaskFooterLabel(state);
+  const groups = groupWorkflowTasksByLoop(footerState.tasks);
+  return /* @__PURE__ */ jsxs11("div", { className: "lax-workflow-task-list-footer", "data-testid": "lax-workflow-task-list-footer", children: [
+    /* @__PURE__ */ jsxs11(
+      "button",
+      {
+        type: "button",
+        className: "lax-task-list-footer__pill lax-workflow-task-list-footer__pill",
+        "data-testid": "lax-workflow-task-list-footer-pill",
+        "aria-expanded": expanded,
+        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" })
+        ]
+      }
+    ),
+    expanded ? /* @__PURE__ */ jsx15(MessageResponse, { children: /* @__PURE__ */ jsx15("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 })
+        ]
+      },
+      group.loopSessionId
+    )) }) }) : null
+  ] });
+}
+
+// src/view/workflow/WorkflowSession.tsx
+import { useStore as useStore5 } from "zustand";
+import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function WorkflowSession({
   source,
   initialEvents,
   registry,
-  tierOverrides: _tierOverrides,
+  tierOverrides,
   onError,
-  autoReconnect: _autoReconnect,
-  debug = false,
-  virtualized = false,
-  virtualizeThreshold,
   interactionBus,
   toolDisplayRegistry,
   defaultBodyMode = "preview",
-  groupParallelTools = false,
   permissionUiMode = "standalone",
   markdownRenderer,
   displayMode = "normal",
@@ -265,39 +3238,44 @@ function AgentSession({
   exploreFullscreenBash = true,
   memoryDir = null,
   workspaceRoot = null,
+  virtualized = false,
+  virtualizeThreshold,
+  groupParallelTools = false,
+  workflowScale,
+  onRequestLoopReplay,
   children
 }) {
-  const storeRef = useRef(null);
+  const storeRef = useRef3(null);
   if (storeRef.current === null) {
-    const replayOpts = {
-      tierOverrides: _tierOverrides,
-      collectDebug: debug
-    };
-    const initialTree = initialEvents && initialEvents.length > 0 ? replayEvents(initialEvents, replayOpts) : void 0;
-    storeRef.current = createSessionStore(initialTree, {
-      tierOverrides: _tierOverrides,
-      debug,
-      initialEventCount: initialEvents?.length ?? 0
+    const initialState = initialEvents && initialEvents.length > 0 ? reduceWorkflowEvents(initialEvents, { tierOverrides }) : void 0;
+    storeRef.current = createWorkflowSessionStore(initialState, {
+      tierOverrides,
+      initialEventCount: initialEvents?.length ?? 0,
+      evictCompletedLoops: workflowScale?.evictCompletedLoops ?? DEFAULT_WORKFLOW_SCALE_OPTIONS.evictCompletedLoops,
+      maxHydratedCompletedLoops: workflowScale?.maxHydratedCompletedLoops ?? DEFAULT_WORKFLOW_SCALE_OPTIONS.maxHydratedCompletedLoops
     });
   }
-  const registryRef = useMemo(() => registry ?? createDefaultRegistry(), [registry]);
-  const busRef = useMemo(
+  const scaleOptions = useMemo9(
+    () => ({ ...DEFAULT_WORKFLOW_SCALE_OPTIONS, ...workflowScale }),
+    [workflowScale]
+  );
+  const registryRef = useMemo9(() => registry ?? createDefaultRegistry(), [registry]);
+  const busRef = useMemo9(
     () => interactionBus ?? getNoopInteractionBus(),
     [interactionBus]
   );
-  const toolDisplayRef = useMemo(
+  const toolDisplayRef = useMemo9(
     () => ({
       registry: toolDisplayRegistry ?? createDefaultToolRegistry(),
       defaultBodyMode
     }),
     [toolDisplayRegistry, defaultBodyMode]
   );
-  const sessionViewRef = useMemo(
+  const sessionViewRef = useMemo9(
     () => ({
       ...DEFAULT_SESSION_VIEW_OPTIONS,
       groupParallelTools,
       permissionUiMode,
-      verboseReasoning: debug,
       displayMode,
       verbose,
       exploreFullscreenBash,
@@ -307,7 +3285,6 @@ function AgentSession({
     [
       groupParallelTools,
       permissionUiMode,
-      debug,
       displayMode,
       verbose,
       exploreFullscreenBash,
@@ -315,31 +3292,52 @@ function AgentSession({
       workspaceRoot
     ]
   );
-  useEffect(() => {
+  const containerTree = useStore5(
+    storeRef.current,
+    (s) => s.state.containerTree
+  );
+  const loopTreesBySessionId = useStore5(
+    storeRef.current,
+    (s) => s.state.loopTreesBySessionId
+  );
+  useEffect8(() => {
     const store = storeRef.current;
     const controller = new AbortController();
     void source.start((event, ctx) => {
       store.getState().applyEvent(event, ctx);
     }, controller.signal).catch((err) => {
-      const error = err instanceof Error ? err : new Error(String(err));
-      store.getState().markAsError(error);
-      onError?.(error);
+      if (err instanceof SseTransportTerminalError) {
+        const { state } = store.getState();
+        if (state.status === "running") {
+          store.setState({ state: { ...state, status: "error" } });
+        }
+      }
     });
     return () => {
       controller.abort();
     };
   }, [source, onError]);
-  return /* @__PURE__ */ jsx(SessionStoreContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(InteractionBusContext.Provider, { value: busRef, children: /* @__PURE__ */ jsx(NodeRegistryContext.Provider, { value: registryRef, children: /* @__PURE__ */ jsx(MarkdownRendererContext.Provider, { value: markdownRenderer, children: /* @__PURE__ */ jsx(ToolDisplayOptionsContext.Provider, { value: toolDisplayRef, children: /* @__PURE__ */ jsx(SessionViewOptionsContext.Provider, { value: sessionViewRef, children: /* @__PURE__ */ jsxs("div", { className: "lax-agent-session", "data-testid": "lax-agent-session", children: [
-    children ?? /* @__PURE__ */ jsx(
-      SessionTimeline,
-      {
-        virtualized,
-        virtualizeThreshold,
-        groupParallelTools
-      }
-    ),
-    debug ? /* @__PURE__ */ jsx(DebugPanel, {}) : null
-  ] }) }) }) }) }) }) });
+  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(
+    "div",
+    {
+      className: "lax-agent-session lax-workflow-session",
+      "data-testid": "lax-workflow-session",
+      children: [
+        /* @__PURE__ */ jsx16(
+          WorkflowChrome,
+          {
+            containerTree,
+            loopTreesBySessionId,
+            virtualized,
+            virtualizeThreshold,
+            groupParallelTools
+          }
+        ),
+        /* @__PURE__ */ jsx16(WorkflowTaskListFooter, {}),
+        children
+      ]
+    }
+  ) }) }) }) }) }) }) }) });
 }
 
 // src/view/tools/groupParallelTools.ts
@@ -379,202 +3377,21 @@ function buildTimelineEntries(rootIds, byId, options = {}) {
 }
 
 // src/view/nodes/SubAgentNode.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
 function SubAgentBlock({ nodeId }) {
   const node = useNodeTyped(nodeId, "subagent");
   const childIds = useChildren(nodeId);
   const registry = useNodeRegistry();
   if (!node) return null;
-  return /* @__PURE__ */ jsxs2("div", { className: "lax-subagent-block", "data-status": node.status, children: [
-    /* @__PURE__ */ jsxs2("div", { className: "lax-subagent-block__header", children: [
+  return /* @__PURE__ */ jsxs13("div", { className: "lax-subagent-block", "data-status": node.status, children: [
+    /* @__PURE__ */ jsxs13("div", { className: "lax-subagent-block__header", children: [
       "SubAgent: ",
       node.subagentId
     ] }),
-    /* @__PURE__ */ jsx2("div", { className: "lax-subagent-block__children", children: childIds.map((childId) => /* @__PURE__ */ jsx2(TimelineItem, { nodeId: childId, registry }, childId)) })
+    /* @__PURE__ */ jsx17("div", { className: "lax-subagent-block__children", children: childIds.map((childId) => /* @__PURE__ */ jsx17(TimelineItem, { nodeId: childId, registry }, childId)) })
   ] });
 }
 
-// src/transport/createAgentxSseSource.ts
-var EXPECTED_PROTOCOL_VERSION = "1";
-function defaultOnError(error) {
-  console.error("[langchain_agentx_stream_ui] SSE error:", error);
-}
-function buildResumeStreamUrl(baseUrl, lastEventId, queryParam = "last_event_id") {
-  if (!lastEventId) return baseUrl;
-  const sep = baseUrl.includes("?") ? "&" : "?";
-  return `${baseUrl}${sep}${encodeURIComponent(queryParam)}=${encodeURIComponent(lastEventId)}`;
-}
-function createAgentxSseSource(options) {
-  const {
-    url,
-    onError = defaultOnError,
-    autoReconnect = true,
-    reconnectDelayMs = 1e3,
-    onLastEventId,
-    EventSourceImpl = EventSource
-  } = options;
-  return {
-    start(handler, signal) {
-      return new Promise((resolve, reject) => {
-        let es = null;
-        let handshakeOk = false;
-        let lastEventId = null;
-        let fatal = false;
-        let bufferedDelta = null;
-        let flushTimer = null;
-        const flushBufferedDelta = () => {
-          if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-          }
-          if (!bufferedDelta) return;
-          handler(bufferedDelta.event, bufferedDelta.ctx);
-          bufferedDelta = null;
-        };
-        const isBufferedDeltaEvent = (event) => event.event_type === "text-delta" || event.event_type === "reasoning-delta";
-        const mergeDeltaEvent = (prev, next) => {
-          if (prev.event_type !== next.event_type) return null;
-          if (prev.step_index !== next.step_index) return null;
-          if (prev.tool_name !== next.tool_name) return null;
-          if (prev.session_id !== next.session_id) return null;
-          const prevData = prev.data;
-          const nextData = next.data;
-          const prevChunk = prevData.delta ?? prevData.text ?? prevData.content ?? "";
-          const nextChunk = nextData.delta ?? nextData.text ?? nextData.content ?? "";
-          return {
-            ...next,
-            data: {
-              ...next.data,
-              text: `${prevChunk}${nextChunk}`
-            }
-          };
-        };
-        const cleanup = () => {
-          es?.close();
-          es = null;
-        };
-        const finish = (error) => {
-          flushBufferedDelta();
-          cleanup();
-          if (error) reject(error);
-          else resolve();
-        };
-        const connect = (resumeFromId) => {
-          if (signal.aborted || fatal) {
-            finish();
-            return;
-          }
-          const connectUrl = resumeFromId != null && resumeFromId !== "" ? buildResumeStreamUrl(url, resumeFromId) : url;
-          es = new EventSourceImpl(connectUrl);
-          handshakeOk = false;
-          es.addEventListener("meta", (event) => {
-            try {
-              const meta = JSON.parse(event.data);
-              if (meta.protocol_version !== EXPECTED_PROTOCOL_VERSION) {
-                fatal = true;
-                const error = new Error(
-                  `Unsupported protocol_version: ${meta.protocol_version}`
-                );
-                onError(error);
-                cleanup();
-                finish(error);
-                return;
-              }
-              handshakeOk = true;
-            } catch (err) {
-              fatal = true;
-              const error = err instanceof Error ? err : new Error("Failed to decode meta frame");
-              onError(error);
-              cleanup();
-              finish(error);
-            }
-          });
-          es.addEventListener("agentx", (event) => {
-            if (!handshakeOk) {
-              fatal = true;
-              const error = new Error("Received agentx frame before meta handshake");
-              onError(error);
-              cleanup();
-              finish(error);
-              return;
-            }
-            try {
-              const agentEvent = JSON.parse(event.data);
-              const sseEventId = event.lastEventId || void 0;
-              if (sseEventId) {
-                lastEventId = sseEventId;
-                onLastEventId?.(sseEventId);
-              }
-              const ctx = sseEventId ? { sseEventId } : void 0;
-              if (isBufferedDeltaEvent(agentEvent)) {
-                if (bufferedDelta) {
-                  const merged = mergeDeltaEvent(bufferedDelta.event, agentEvent);
-                  if (merged) {
-                    bufferedDelta = { event: merged, ctx };
-                  } else {
-                    flushBufferedDelta();
-                    bufferedDelta = { event: agentEvent, ctx };
-                  }
-                } else {
-                  bufferedDelta = { event: agentEvent, ctx };
-                }
-                if (!flushTimer) {
-                  flushTimer = setTimeout(() => {
-                    flushBufferedDelta();
-                  }, 16);
-                }
-              } else {
-                flushBufferedDelta();
-                handler(agentEvent, ctx);
-              }
-            } catch (err) {
-              onError(
-                new Error(
-                  err instanceof Error ? `Failed to decode agentx frame: ${err.message}` : "Failed to decode agentx frame"
-                )
-              );
-            }
-          });
-          es.onerror = () => {
-            flushBufferedDelta();
-            if (signal.aborted || fatal) {
-              cleanup();
-              finish();
-              return;
-            }
-            if (!autoReconnect) {
-              fatal = true;
-              const error = new Error("SSE connection error");
-              onError(error);
-              cleanup();
-              finish(error);
-              return;
-            }
-            cleanup();
-            setTimeout(() => connect(lastEventId), reconnectDelayMs);
-          };
-        };
-        signal.addEventListener("abort", () => {
-          flushBufferedDelta();
-          fatal = true;
-          finish();
-        }, { once: true });
-        connect();
-      });
-    }
-  };
-}
-function createMockSource(events) {
-  return {
-    async start(handler, signal) {
-      for (const event of events) {
-        if (signal.aborted) break;
-        handler(event);
-      }
-    }
-  };
-}
-
 // src/transport/createReplaySource.ts
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
@@ -606,8 +3423,10 @@ function createReplaySource(events, opts) {
 }
 export {
   Agent,
+  AgentLoopView,
   AgentSession,
   AgentToolBody,
+  ApplicationKindMismatchError,
   AskUserQuestion,
   AskUserQuestionToolBody,
   Bash,
@@ -619,6 +3438,7 @@ export {
   DEFAULT_EVENT_TIERS,
   DEFAULT_SESSION_VIEW_OPTIONS,
   DEFAULT_VIRTUALIZE_THRESHOLD,
+  DEFAULT_WORKFLOW_SCALE_OPTIONS,
   DefaultToolBody,
   DiffView,
   EXPECTED_PROTOCOL_VERSION,
@@ -635,19 +3455,25 @@ export {
   MAX_PREVIEW_LINES,
   MIN_HINT_DISPLAY_MS,
   MarkdownBlock,
+  MermaidDiagram,
+  MissingApplicationKindError,
   MultiAgentSession,
   NodeRegistry,
   PermissionCard,
+  PlantUMLBlock,
+  PlantUMLDiagram,
   ProjectionContext,
   Read,
   ReadToolBody,
   ReasoningBubble,
   RenderableTimelineProjector,
+  RichMarkdown,
   SHELL_PROGRESS_MIN_ELAPSED_SECONDS,
   SessionTimeline,
   Skill,
   SkillToolBody,
   Spinner,
+  SseTransportTerminalError,
   StepCard,
   SubAgentBlock,
   SystemSummaryAccumulator,
@@ -663,10 +3489,16 @@ export {
   TruncatedContent,
   UnknownCard,
   VirtualTimeline,
+  WORKFLOW_STRUCTURE_EVENT_TYPES,
   WebFetch,
   WebFetchToolBody,
   WebSearch,
   WebSearchToolBody,
+  WorkflowChrome,
+  WorkflowLoopReplayProvider,
+  WorkflowScaleContext,
+  WorkflowSession,
+  WorkflowTaskListFooter,
   Write,
   WriteToolBody,
   buildBashBodyBlocks,
@@ -679,17 +3511,21 @@ export {
   buildTimelineEntries,
   classifyEvent,
   commandAsHint,
+  configureMermaid,
+  configurePlantumlServer,
   createActiveSessionBridge,
   createAgentxSseSource,
   createDefaultRegistry,
   createDefaultToolRegistry,
   createEmptyTree,
+  createEmptyWorkflowSessionState,
   createInteractionBus,
   createMockSource,
   createMultiSessionStore,
   createProjectionContext,
   createReplaySource,
   createSessionStore,
+  createWorkflowSessionStore,
   displayPath,
   entryKey,
   formatAgentTitle,
@@ -708,12 +3544,17 @@ export {
   isGitOperationCommand,
   isGroupableToolName,
   isMcpToolName,
+  isWorkflowStructureEventType,
   iterMountCandidates,
   parseDiffText,
+  partitionWorkflowStages,
   projectCanonical,
   projectTimeline,
+  reduceAgentLoopEvent,
   reduceEvents,
   reduceTree,
+  reduceWorkflowEvents,
+  reduceWorkflowSession,
   replayEvents,
   replayTree,
   resolveEffectiveToolBodyMode,
@@ -738,6 +3579,8 @@ export {
   useSessionIds,
   useSessionMeta,
   useSessionStatus,
-  useTimeline
+  useTimeline,
+  useWorkflowSessionStatus,
+  useWorkflowSessionStoreApi
 };
 //# sourceMappingURL=index.js.map