perstack 0.0.53 → 0.0.55

package/dist/bin/cli.js

@@ -4,22 +4,24 @@ import { writeFile, mkdir, readFile } from 'fs/promises';
 import * as path10 from 'path';
 import path10__default from 'path';
 import { createApiClient } from '@perstack/api-client';
-import { registerAdapter, parseWithFriendlyError, runCommandInputSchema, startCommandInputSchema, defaultMaxRetries, defaultTimeout, defaultPerstackApiBaseUrl, checkpointSchema, jobSchema, runSettingSchema, BaseAdapter, createRuntimeInitEvent, createEmptyUsage, createStartRunEvent, createCompleteRunEvent, getFilteredEnv, createStreamingTextEvent, createCallToolsEvent, createResolveToolResultsEvent, createRuntimeEvent, perstackConfigSchema, expertSchema, isAdapterAvailable as isAdapterAvailable$1, getRegisteredRuntimes as getRegisteredRuntimes$1, getAdapter as getAdapter$1 } from '@perstack/core';
+import { registerAdapter, parseWithFriendlyError, runCommandInputSchema, validateEventFilter, createFilteredEventListener, startCommandInputSchema, defaultMaxRetries, defaultTimeout, defaultPerstackApiBaseUrl, checkpointSchema, jobSchema, runSettingSchema, BaseAdapter, createRuntimeInitEvent, createEmptyUsage, createStartRunEvent, createCompleteRunEvent, getFilteredEnv, createCallToolsEvent, createResolveToolResultsEvent, createRuntimeEvent, perstackConfigSchema, expertSchema, isAdapterAvailable as isAdapterAvailable$1, getRegisteredRuntimes as getRegisteredRuntimes$1, getAdapter as getAdapter$1 } from '@perstack/core';
 import { collectToolDefinitionsForExpert } from '@perstack/runtime';
 import TOML from 'smol-toml';
 import dotenv from 'dotenv';
 import * as fs from 'fs';
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { render, useApp, Box, Static, Text, useInput } from 'ink';
-import { createContext, useState, useEffect, useCallback, useMemo, useRef, useReducer, useContext, useInsertionEffect } from 'react';
+import { render, useApp, useInput, Box, Text } from 'ink';
+import { createContext, useMemo, useReducer, useState, useEffect, useCallback, useRef, useContext } from 'react';
+import { useTextInput, SelectableList, useListNavigation } from '@perstack/tui-components';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useRun } from '@perstack/react';
 import { spawn, execSync } from 'child_process';
 import * as os from 'os';
 
 // package.json
 var package_default = {
   name: "perstack",
-  version: "0.0.53",
+  version: "0.0.55",
   description: "PerStack CLI"};
 function getEnv(envPath) {
   const env = Object.fromEntries(
@@ -350,16 +352,6 @@ async function defaultStoreEvent(event) {
   await mkdir(runDir, { recursive: true });
   await writeFile(eventPath, JSON.stringify(event));
 }
-function getEventsByRun(jobId, runId) {
-  const runDir = defaultGetRunDir(jobId, runId);
-  if (!existsSync(runDir)) {
-    return [];
-  }
-  return readdirSync(runDir).filter((file) => file.startsWith("event-")).map((file) => {
-    const [_, timestamp, stepNumber, type] = file.split(".")[0].split("-");
-    return { timestamp: Number(timestamp), stepNumber: Number(stepNumber), type };
-  }).sort((a, b) => a.stepNumber - b.stepNumber);
-}
 function getEventContents(jobId, runId, maxStepNumber) {
   const runDir = defaultGetRunDir(jobId, runId);
   if (!existsSync(runDir)) {
@@ -650,8 +642,8 @@ function createStorageAdapter(storage, basePath) {
 
 // src/lib/log/filter.ts
 var ERROR_EVENT_TYPES = /* @__PURE__ */ new Set(["stopRunByError", "retry"]);
-var TOOL_EVENT_TYPES = /* @__PURE__ */ new Set(["callTools", "resolveToolResults", "callInteractiveTool"]);
-var DELEGATION_EVENT_TYPES = /* @__PURE__ */ new Set(["callDelegate", "stopRunByDelegate"]);
+var TOOL_EVENT_TYPES = /* @__PURE__ */ new Set(["callTools", "resolveToolResults", "stopRunByInteractiveTool"]);
+var DELEGATION_EVENT_TYPES = /* @__PURE__ */ new Set(["stopRunByDelegate"]);
 function parseStepFilter(step) {
   const trimmed = step.trim();
   const rangeMatch = trimmed.match(/^(\d+)-(\d+)$/);
@@ -867,8 +859,8 @@ function addContextEvents(allEvents, matchedEvents, contextSize) {
 
 // src/lib/log/formatter.ts
 var ERROR_EVENT_TYPES2 = /* @__PURE__ */ new Set(["stopRunByError", "retry"]);
-var TOOL_EVENT_TYPES2 = /* @__PURE__ */ new Set(["callTools", "resolveToolResults", "callInteractiveTool"]);
-var DELEGATION_EVENT_TYPES2 = /* @__PURE__ */ new Set(["callDelegate", "stopRunByDelegate"]);
+var TOOL_EVENT_TYPES2 = /* @__PURE__ */ new Set(["callTools", "resolveToolResults", "stopRunByInteractiveTool"]);
+var DELEGATION_EVENT_TYPES2 = /* @__PURE__ */ new Set(["stopRunByDelegate"]);
 function createSummary(events) {
   if (events.length === 0) {
     return {
@@ -1048,11 +1040,10 @@ function formatEvent(event, verbose) {
     lines.push(`  Message: ${errorEvent.error.message}`);
     lines.push(`  Retryable: ${errorEvent.error.isRetryable}`);
   }
-  if (event.type === "callDelegate" && "toolCalls" in event) {
+  if (event.type === "stopRunByDelegate" && "checkpoint" in event) {
     const delegateEvent = event;
-    for (const tc of delegateEvent.toolCalls) {
-      const expertKey = tc.args.expertKey ?? tc.args.expert ?? "unknown";
-      lines.push(`  Delegate to: ${expertKey}`);
+    for (const d of delegateEvent.checkpoint.delegateTo ?? []) {
+      lines.push(`  Delegate to: ${d.expert.key}`);
     }
   }
   if (event.type === "completeRun" && "text" in event) {
@@ -1363,7 +1354,6 @@ var summarizeOutput = (lines, maxLines) => {
 // src/tui/constants.ts
 var UI_CONSTANTS = {
   MAX_VISIBLE_LIST_ITEMS: 25,
-  MAX_EVENTS: 1e3,
   TRUNCATE_TEXT_MEDIUM: 80,
   TRUNCATE_TEXT_DEFAULT: 100};
 var RENDER_CONSTANTS = {
@@ -1372,7 +1362,6 @@ var RENDER_CONSTANTS = {
   LIST_DIR_MAX_ITEMS: 4
 };
 var INDICATOR = {
-  CHEVRON_RIGHT: ">",
   BULLET: "\u25CF",
   TREE: "\u2514",
   ELLIPSIS: "..."
@@ -1413,654 +1402,149 @@ var KEY_HINTS = {
   CTRL_QUIT: `${KEY_BINDINGS.CTRL_QUIT}:Quit`,
   CONFIRM: `${KEY_BINDINGS.SELECT}:Confirm`
 };
-var useExpertActions = (options) => {
-  const {
-    needsQueryInput,
-    inputState,
-    dispatch,
-    setExpertName,
-    onComplete,
-    markAsStarted,
-    configuredExperts,
-    recentExperts
-  } = options;
-  const allExperts = useMemo(() => {
-    const configured = (configuredExperts || []).map((e) => ({
-      ...e,
-      source: "configured"
-    }));
-    const recent = (recentExperts || []).filter((e) => !configured.some((c) => c.key === e.key)).map((e) => ({ ...e, source: "recent" }));
-    return [...configured, ...recent];
-  }, [configuredExperts, recentExperts]);
-  const handleExpertSelect = useCallback(
-    (expertKey) => {
-      setExpertName(expertKey);
-      const needsQuery = needsQueryInput || inputState.type === "browsingExperts";
-      dispatch({ type: "SELECT_EXPERT", expertKey, needsQuery });
-      if (!needsQuery) {
-        markAsStarted();
-        onComplete(expertKey, "");
-      }
-    },
-    [needsQueryInput, inputState.type, dispatch, setExpertName, onComplete, markAsStarted]
-  );
-  return { allExperts, handleExpertSelect };
-};
-
-// src/tui/utils/error-handling.ts
-var createErrorHandler = (onError) => (error, context) => {
-  const err = error instanceof Error ? error : new Error(`${context}: ${String(error)}`);
-  onError?.(err);
-};
-
-// src/tui/hooks/core/use-error-handler.ts
-var useErrorHandler = (onError) => {
-  return useMemo(() => createErrorHandler(onError), [onError]);
-};
-
-// src/tui/hooks/actions/use-history-actions.ts
-var useHistoryActions = (options) => {
-  const {
-    allExperts,
-    historyJobs,
-    onLoadCheckpoints,
-    onLoadEvents,
-    onResumeFromCheckpoint,
-    onLoadHistoricalEvents,
-    setHistoricalEvents,
-    setCurrentStep,
-    setContextWindowUsage,
-    dispatch,
-    setExpertName,
-    onError
-  } = options;
-  const [selectedJob, setSelectedJob] = useState(null);
-  const handleError = useErrorHandler(onError);
-  const handleJobSelect = useCallback(
-    async (job) => {
-      try {
-        setSelectedJob(job);
-        setExpertName(job.expertKey);
-        if (onLoadCheckpoints) {
-          const checkpoints = await onLoadCheckpoints(job);
-          dispatch({ type: "SELECT_JOB", job, checkpoints });
-        }
-      } catch (error) {
-        handleError(error, "Failed to load checkpoints");
-      }
-    },
-    [onLoadCheckpoints, dispatch, setExpertName, handleError]
-  );
-  const handleJobResume = useCallback(
-    async (job) => {
-      try {
-        setSelectedJob(job);
-        setExpertName(job.expertKey);
-        if (onLoadCheckpoints && onResumeFromCheckpoint) {
-          const checkpoints = await onLoadCheckpoints(job);
-          const latestCheckpoint = checkpoints[0];
-          if (latestCheckpoint) {
-            if (onLoadHistoricalEvents) {
-              const events = await onLoadHistoricalEvents(latestCheckpoint);
-              setHistoricalEvents(events);
-            }
-            setCurrentStep(latestCheckpoint.stepNumber);
-            setContextWindowUsage(latestCheckpoint.contextWindowUsage);
-            dispatch({ type: "RESUME_CHECKPOINT", expertKey: job.expertKey });
-            onResumeFromCheckpoint(latestCheckpoint);
-          }
-        }
-      } catch (error) {
-        handleError(error, "Failed to resume job");
-      }
-    },
-    [
-      onLoadCheckpoints,
-      onResumeFromCheckpoint,
-      onLoadHistoricalEvents,
-      setHistoricalEvents,
-      setCurrentStep,
-      setContextWindowUsage,
-      dispatch,
-      setExpertName,
-      handleError
-    ]
-  );
-  const handleCheckpointSelect = useCallback(
-    async (checkpoint) => {
-      try {
-        if (selectedJob && onLoadEvents) {
-          const eventsData = await onLoadEvents(selectedJob, checkpoint);
-          dispatch({ type: "SELECT_CHECKPOINT", job: selectedJob, checkpoint, events: eventsData });
-        }
-      } catch (error) {
-        handleError(error, "Failed to load events");
-      }
-    },
-    [selectedJob, onLoadEvents, dispatch, handleError]
-  );
-  const handleCheckpointResume = useCallback(
-    async (checkpoint) => {
-      if (onResumeFromCheckpoint) {
-        if (onLoadHistoricalEvents) {
-          const events = await onLoadHistoricalEvents(checkpoint);
-          setHistoricalEvents(events);
-        }
-        setCurrentStep(checkpoint.stepNumber);
-        setContextWindowUsage(checkpoint.contextWindowUsage);
-        dispatch({ type: "RESUME_CHECKPOINT", expertKey: selectedJob?.expertKey || "" });
-        onResumeFromCheckpoint(checkpoint);
-      }
-    },
-    [
-      onResumeFromCheckpoint,
-      onLoadHistoricalEvents,
-      setHistoricalEvents,
-      setCurrentStep,
-      setContextWindowUsage,
-      dispatch,
-      selectedJob?.expertKey
-    ]
-  );
-  const handleBackFromEvents = useCallback(async () => {
-    try {
-      if (selectedJob && onLoadCheckpoints) {
-        const checkpoints = await onLoadCheckpoints(selectedJob);
-        dispatch({ type: "GO_BACK_FROM_EVENTS", job: selectedJob, checkpoints });
-      }
-    } catch (error) {
-      handleError(error, "Failed to go back from events");
-    }
-  }, [selectedJob, onLoadCheckpoints, dispatch, handleError]);
-  const handleBackFromCheckpoints = useCallback(() => {
-    if (historyJobs) {
-      setSelectedJob(null);
-      dispatch({ type: "GO_BACK_FROM_CHECKPOINTS", historyJobs });
-    }
-  }, [historyJobs, dispatch]);
-  const handleEventSelect = useCallback(
-    (state, event) => {
-      dispatch({
-        type: "SELECT_EVENT",
-        checkpoint: state.checkpoint,
-        events: state.events,
-        selectedEvent: event
-      });
-    },
-    [dispatch]
-  );
-  const handleBackFromEventDetail = useCallback(
-    (state) => {
-      dispatch({
-        type: "GO_BACK_FROM_EVENT_DETAIL",
-        checkpoint: state.checkpoint,
-        events: state.events
-      });
-    },
-    [dispatch]
-  );
-  const handleBack = useCallback(
-    (currentState) => {
-      switch (currentState.type) {
-        case "browsingEventDetail":
-          handleBackFromEventDetail(currentState);
-          break;
-        case "browsingEvents":
-          handleBackFromEvents();
-          break;
-        case "browsingCheckpoints":
-          handleBackFromCheckpoints();
-          break;
-      }
-    },
-    [handleBackFromEventDetail, handleBackFromEvents, handleBackFromCheckpoints]
-  );
-  const handleSwitchToExperts = useCallback(() => {
-    dispatch({ type: "BROWSE_EXPERTS", experts: allExperts });
-  }, [dispatch, allExperts]);
-  const handleSwitchToHistory = useCallback(() => {
-    if (historyJobs) {
-      dispatch({ type: "BROWSE_HISTORY", jobs: historyJobs });
-    }
-  }, [dispatch, historyJobs]);
-  return {
-    selectedJob,
-    handleJobSelect,
-    handleJobResume,
-    handleCheckpointSelect,
-    handleCheckpointResume,
-    handleEventSelect,
-    handleBack,
-    handleSwitchToExperts,
-    handleSwitchToHistory
-  };
-};
-var useLatestRef = (value) => {
-  const ref = useRef(value);
-  useInsertionEffect(() => {
-    ref.current = value;
+var ListBrowser = ({
+  title,
+  items,
+  renderItem,
+  onSelect,
+  emptyMessage = "No items found",
+  extraKeyHandler,
+  onBack,
+  maxItems = UI_CONSTANTS.MAX_VISIBLE_LIST_ITEMS
+}) => {
+  const { selectedIndex, handleNavigation } = useListNavigation({
+    items,
+    onSelect,
+    onBack
+  });
+  useInput((inputChar, key) => {
+    if (extraKeyHandler?.(inputChar, key, items[selectedIndex])) return;
+    handleNavigation(inputChar, key);
   });
-  return ref;
+  const { scrollOffset, displayItems } = useMemo(() => {
+    const offset = Math.max(0, Math.min(selectedIndex - maxItems + 1, items.length - maxItems));
+    return {
+      scrollOffset: offset,
+      displayItems: items.slice(offset, offset + maxItems)
+    };
+  }, [items, selectedIndex, maxItems]);
+  const hasMoreAbove = scrollOffset > 0;
+  const hasMoreBelow = scrollOffset + maxItems < items.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: title }),
+      items.length > maxItems && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        " ",
+        "(",
+        selectedIndex + 1,
+        "/",
+        items.length,
+        ")"
+      ] })
+    ] }),
+    hasMoreAbove && /* @__PURE__ */ jsx(Text, { color: "gray", children: INDICATOR.ELLIPSIS }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: displayItems.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: emptyMessage }) : displayItems.map((item, index) => {
+      const actualIndex = scrollOffset + index;
+      return renderItem(item, actualIndex === selectedIndex, actualIndex);
+    }) }),
+    hasMoreBelow && /* @__PURE__ */ jsx(Text, { color: "gray", children: INDICATOR.ELLIPSIS })
+  ] });
 };
-
-// src/tui/hooks/actions/use-run-actions.ts
-var useRunActions = (options) => {
-  const {
-    expertName,
-    dispatch,
-    setQuery,
-    onComplete,
-    onContinue,
-    onReady,
-    stepStoreAddEvent,
-    handleEvent
-  } = options;
-  const [hasStarted, setHasStarted] = useState(false);
-  const markAsStarted = useCallback(() => setHasStarted(true), []);
-  const expertNameRef = useLatestRef(expertName);
-  const onContinueRef = useLatestRef(onContinue);
-  useEffect(() => {
-    onReady((event) => {
-      stepStoreAddEvent(event);
-      const result = handleEvent(event);
-      if (result?.initialized) {
-        dispatch({ type: "INITIALIZE_RUNTIME" });
-      } else if (result?.completed && onContinueRef.current) {
-        dispatch({ type: "END_RUN", expertName: expertNameRef.current || "", reason: "completed" });
-      } else if (result?.stopped && onContinueRef.current) {
-        dispatch({ type: "END_RUN", expertName: expertNameRef.current || "", reason: "stopped" });
-      }
-    });
-  }, [onReady, stepStoreAddEvent, handleEvent, dispatch, onContinueRef, expertNameRef]);
-  const handleQuerySubmit = useCallback(
-    (query) => {
-      setQuery(query);
-      dispatch({ type: "START_RUN" });
-      if (hasStarted && onContinue) {
-        onContinue(query);
-      } else {
-        markAsStarted();
-        onComplete(expertName || "", query);
+var BrowsingCheckpointsInput = ({
+  job,
+  checkpoints,
+  onCheckpointSelect,
+  onCheckpointResume,
+  onBack,
+  showEventsHint = true
+}) => /* @__PURE__ */ jsx(
+  ListBrowser,
+  {
+    title: `Checkpoints for ${job.expertKey} ${KEY_HINTS.NAVIGATE} ${KEY_HINTS.RESUME} ${showEventsHint ? KEY_HINTS.EVENTS : ""} ${KEY_HINTS.BACK}`.trim(),
+    items: checkpoints,
+    onSelect: onCheckpointResume,
+    onBack,
+    emptyMessage: "No checkpoints found",
+    extraKeyHandler: (char, _key, selected) => {
+      if (char === "e" && selected) {
+        onCheckpointSelect(selected);
+        return true;
       }
+      return false;
     },
-    [hasStarted, onContinue, onComplete, expertName, setQuery, dispatch, markAsStarted]
-  );
-  return { hasStarted, markAsStarted, handleQuerySubmit };
-};
-var TOOL_RESULT_EVENT_TYPES = /* @__PURE__ */ new Set(["resolveToolResults", "attemptCompletion"]);
-var STREAMING_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "startReasoning",
-  "streamReasoning",
-  "startRunResult",
-  "streamRunResult"
-]);
-var isToolCallsEvent = (event) => "type" in event && event.type === "callTools" && "toolCalls" in event;
-var isToolCallEvent = (event) => "type" in event && (event.type === "callInteractiveTool" || event.type === "callDelegate") && "toolCall" in event;
-var isToolResultsEvent = (event) => "type" in event && event.type === "resolveToolResults" && "toolResults" in event;
-var isToolResultEvent = (event) => "type" in event && TOOL_RESULT_EVENT_TYPES.has(event.type) && "toolResult" in event;
-var checkIsSuccess = (result) => {
-  const textPart = result.find((r) => r.type === "textPart");
-  if (!textPart || typeof textPart.text !== "string") return true;
-  const text = textPart.text.toLowerCase();
-  return !text.startsWith("error") && !text.includes("failed");
-};
-var extractQuery = (event) => {
-  const userMessage = event.inputMessages.find((m) => m.type === "userMessage");
-  if (userMessage?.type !== "userMessage") return void 0;
-  return userMessage.contents.find((c) => c.type === "textPart")?.text;
-};
-var formatRuntimeName = (runtime) => {
-  if (runtime === "claude-code") return "Claude Code";
-  if (runtime === "local") return "Local";
-  return runtime.charAt(0).toUpperCase() + runtime.slice(1);
-};
-var processEventToLogs = (state, event, addLog) => {
-  if (!("runId" in event)) return;
-  const runId = event.runId;
-  if (event.type === "dockerBuildProgress") {
-    const buildEvent = event;
-    addLog({
-      id: `docker-build-${event.id}`,
-      type: "docker-build",
-      stage: buildEvent.stage,
-      service: buildEvent.service,
-      message: buildEvent.message,
-      progress: buildEvent.progress
-    });
-    return;
-  }
-  if (event.type === "dockerContainerStatus") {
-    const containerEvent = event;
-    addLog({
-      id: `docker-container-${event.id}`,
-      type: "docker-container",
-      status: containerEvent.status,
-      service: containerEvent.service,
-      message: containerEvent.message
-    });
-    return;
-  }
-  if (event.type === "proxyAccess") {
-    const proxyEvent = event;
-    addLog({
-      id: `proxy-access-${event.id}`,
-      type: "proxy-access",
-      action: proxyEvent.action,
-      domain: proxyEvent.domain,
-      port: proxyEvent.port,
-      reason: proxyEvent.reason
-    });
-    return;
-  }
-  if (event.type === "completeReasoning") {
-    const reasoningEvent = event;
-    addLog({
-      id: `completeReasoning-${event.id}`,
-      type: "completeReasoning",
-      text: reasoningEvent.text
-    });
-    state.isReasoningStreaming = false;
-    state.streamingReasoning = void 0;
-    return;
-  }
-  if (event.type === "retry") {
-    const retryEvent = event;
-    addLog({
-      id: `retry-${event.id}`,
-      type: "retry",
-      reason: retryEvent.reason
-    });
-    state.streamingText = void 0;
-    state.streamingReasoning = void 0;
-    return;
-  }
-  if (event.type === "initializeRuntime") {
-    if (!state.rootRunId) {
-      state.rootRunId = runId;
-    } else if (runId !== state.rootRunId) {
-      const expertName = event.expertName ?? "unknown";
-      const runtime = formatRuntimeName(
-        event.runtime ?? event.model?.split(":")[0] ?? "unknown"
-      );
-      const version = event.runtimeVersion ?? "unknown";
-      const query = event.query;
-      state.pendingDelegations.set(runId, { expertName, runtime, version, query });
-      addLog({
-        id: `delegation-started-${runId}`,
-        type: "delegation-started",
-        expertName,
-        runtime,
-        version,
-        query
-      });
-    }
-    return;
-  }
-  const isDelegation = state.rootRunId && runId !== state.rootRunId;
-  if (event.type === "streamingText" && "text" in event) {
-    if (!isDelegation) {
-      state.streamingText = event.text;
-    }
-    return;
-  }
-  if (event.type === "completeRun") {
-    if (isDelegation) {
-      const pending = state.pendingDelegations.get(runId);
-      if (pending) {
-        addLog({
-          id: `delegation-completed-${runId}`,
-          type: "delegation-completed",
-          expertName: pending.expertName,
-          runtime: pending.runtime,
-          version: pending.version,
-          result: event.text
-        });
-        state.pendingDelegations.delete(runId);
-      }
-    } else if (!state.completionLogged) {
-      const text = event.text || state.streamingText;
-      if (text) {
-        addLog({ id: `completion-${runId}`, type: "completion", text });
-      }
-      state.completionLogged = true;
-      state.isComplete = true;
-      state.streamingText = void 0;
-      state.streamingReasoning = void 0;
-    }
-    return;
+    renderItem: (cp, isSelected) => /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : "gray", children: [
+      isSelected ? ">" : " ",
+      " Step ",
+      cp.stepNumber,
+      " (",
+      cp.id,
+      ")"
+    ] }, cp.id)
   }
-  if (event.type === "stopRunByError") {
-    const errorEvent = event;
-    addLog({
-      id: `error-${event.id}`,
-      type: "error",
-      errorName: errorEvent.error.name,
-      message: errorEvent.error.message,
-      statusCode: errorEvent.error.statusCode
-    });
-    state.isComplete = true;
-    state.streamingText = void 0;
-    state.streamingReasoning = void 0;
-    return;
-  }
-  if (isDelegation) return;
-  if (event.type === "startRun") {
-    const query = extractQuery(event);
-    if (query) {
-      if (state.completionLogged) {
-        state.completionLogged = false;
-        state.isComplete = false;
-        state.queryLogged = false;
-      }
-      if (!state.queryLogged) {
-        addLog({ id: `query-${runId}`, type: "query", text: query });
-        state.queryLogged = true;
-      }
-    }
-  } else if (isToolCallsEvent(event)) {
-    for (const toolCall of event.toolCalls) {
-      if (!state.tools.has(toolCall.id)) {
-        state.tools.set(toolCall.id, {
-          id: toolCall.id,
-          toolName: toolCall.toolName,
-          args: toolCall.args,
-          logged: false
-        });
-      }
-    }
-  } else if (isToolCallEvent(event)) {
-    const { toolCall } = event;
-    if (!state.tools.has(toolCall.id)) {
-      state.tools.set(toolCall.id, {
-        id: toolCall.id,
-        toolName: toolCall.toolName,
-        args: toolCall.args,
-        logged: false
-      });
-    }
-  } else if (isToolResultsEvent(event)) {
-    for (const toolResult of event.toolResults) {
-      const tool = state.tools.get(toolResult.id);
-      if (tool && !tool.logged && Array.isArray(toolResult.result)) {
-        tool.result = toolResult.result;
-        tool.isSuccess = checkIsSuccess(toolResult.result);
-        addLog({
-          id: `tool-${tool.id}`,
-          type: "tool",
-          toolName: tool.toolName,
-          args: tool.args,
-          result: tool.result,
-          isSuccess: tool.isSuccess
-        });
-        tool.logged = true;
-      }
-    }
-  } else if (isToolResultEvent(event)) {
-    const { toolResult } = event;
-    const tool = state.tools.get(toolResult.id);
-    if (tool && !tool.logged && Array.isArray(toolResult.result)) {
-      tool.result = toolResult.result;
-      tool.isSuccess = checkIsSuccess(toolResult.result);
-      addLog({
-        id: `tool-${tool.id}`,
-        type: "tool",
-        toolName: tool.toolName,
-        args: tool.args,
-        result: tool.result,
-        isSuccess: tool.isSuccess
-      });
-      tool.logged = true;
+);
+var BrowsingEventDetailInput = ({ event, onBack }) => {
+  useInput((input, key) => {
+    if (input === "b" || key.escape) {
+      onBack();
     }
-  }
-};
-var useEventStore = () => {
-  const [events, setEvents] = useState([]);
-  const [logs, setLogs] = useState([]);
-  const [streamingText, setStreamingText] = useState();
-  const [streamingReasoning, setStreamingReasoning] = useState();
-  const [isComplete, setIsComplete] = useState(false);
-  const stateRef = useRef({
-    tools: /* @__PURE__ */ new Map(),
-    pendingDelegations: /* @__PURE__ */ new Map(),
-    queryLogged: false,
-    completionLogged: false,
-    isComplete: false
   });
-  const processedCountRef = useRef(0);
-  const needsRebuildRef = useRef(false);
-  const addEvent = useCallback((event) => {
-    if ("type" in event && STREAMING_EVENT_TYPES.has(event.type)) {
-      if (event.type === "startReasoning") {
-        stateRef.current.streamingReasoning = "";
-        stateRef.current.isReasoningStreaming = true;
-        setStreamingReasoning("");
-      } else if (event.type === "streamReasoning") {
-        const delta = event.delta;
-        stateRef.current.streamingReasoning = (stateRef.current.streamingReasoning ?? "") + delta;
-        setStreamingReasoning(stateRef.current.streamingReasoning);
-      } else if (event.type === "startRunResult") {
-        stateRef.current.isRunResultStreaming = true;
-        stateRef.current.streamingText = "";
-        setStreamingText("");
-      } else if (event.type === "streamRunResult") {
-        const delta = event.delta;
-        stateRef.current.streamingText = (stateRef.current.streamingText ?? "") + delta;
-        setStreamingText(stateRef.current.streamingText);
-      }
-      return;
-    }
-    setEvents((prev) => {
-      const newEvents = [...prev, event];
-      if (newEvents.length > UI_CONSTANTS.MAX_EVENTS) {
-        needsRebuildRef.current = true;
-        return newEvents.slice(-1e3);
-      }
-      return newEvents;
-    });
-  }, []);
-  const setHistoricalEvents = useCallback((historicalEvents) => {
-    needsRebuildRef.current = true;
-    setEvents(
-      historicalEvents.length > UI_CONSTANTS.MAX_EVENTS ? historicalEvents.slice(-1e3) : historicalEvents
-    );
-  }, []);
-  useEffect(() => {
-    if (needsRebuildRef.current) {
-      stateRef.current = {
-        tools: /* @__PURE__ */ new Map(),
-        pendingDelegations: /* @__PURE__ */ new Map(),
-        queryLogged: false,
-        completionLogged: false,
-        isComplete: false
-      };
-      setLogs([]);
-      processedCountRef.current = 0;
-      needsRebuildRef.current = false;
-    }
-    const newEvents = events.slice(processedCountRef.current);
-    const newLogs = [];
-    const addLog = (entry) => newLogs.push(entry);
-    for (const event of newEvents) {
-      processEventToLogs(stateRef.current, event, addLog);
-    }
-    processedCountRef.current = events.length;
-    if (newLogs.length > 0) {
-      setLogs((prev) => [...prev, ...newLogs]);
-    }
-    setStreamingText(stateRef.current.streamingText);
-    setStreamingReasoning(stateRef.current.streamingReasoning);
-    setIsComplete(stateRef.current.isComplete);
-  }, [events]);
-  return {
-    logs,
-    streamingText,
-    streamingReasoning,
-    isComplete,
-    eventCount: events.length,
-    addEvent,
-    setHistoricalEvents
-  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Event Detail" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        KEY_HINTS.BACK
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Type: " }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: event.type })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Step: " }),
+        /* @__PURE__ */ jsx(Text, { children: event.stepNumber })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Timestamp: " }),
+        /* @__PURE__ */ jsx(Text, { children: formatTimestamp2(event.timestamp) })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "ID: " }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: event.id })
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Run ID: " }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: event.runId })
+      ] })
+    ] })
+  ] });
 };
-var inputReducer = (_state, action) => {
-  switch (action.type) {
-    case "SELECT_EXPERT":
-      if (action.needsQuery) {
-        return { type: "enteringQuery", expertName: action.expertKey };
-      }
-      return { type: "running" };
-    case "START_RUN":
-    case "INITIALIZE_RUNTIME":
-      return { type: "running" };
-    case "END_RUN":
-      return { type: "enteringQuery", expertName: action.expertName };
-    case "BROWSE_HISTORY":
-      return { type: "browsingHistory", jobs: action.jobs };
-    case "BROWSE_EXPERTS":
-      return { type: "browsingExperts", experts: action.experts };
-    case "SELECT_JOB":
-      return { type: "browsingCheckpoints", job: action.job, checkpoints: action.checkpoints };
-    case "SELECT_CHECKPOINT":
-      return {
-        type: "browsingEvents",
-        checkpoint: action.checkpoint,
-        events: action.events
-      };
-    case "RESUME_CHECKPOINT":
-      return { type: "enteringQuery", expertName: action.expertKey };
-    case "GO_BACK_FROM_EVENTS":
-      return { type: "browsingCheckpoints", job: action.job, checkpoints: action.checkpoints };
-    case "GO_BACK_FROM_CHECKPOINTS":
-      return { type: "browsingHistory", jobs: action.historyJobs };
-    case "SELECT_EVENT":
-      return {
-        type: "browsingEventDetail",
-        checkpoint: action.checkpoint,
-        events: action.events,
-        selectedEvent: action.selectedEvent
-      };
-    case "GO_BACK_FROM_EVENT_DETAIL":
-      return {
-        type: "browsingEvents",
-        checkpoint: action.checkpoint,
-        events: action.events
-      };
-    default:
-      return assertNever(action);
-  }
-};
-var getInitialState = (options) => {
-  if (options.showHistory && options.historyJobs) {
-    return { type: "browsingHistory", jobs: options.historyJobs };
-  }
-  if (options.needsQueryInput) {
-    return { type: "enteringQuery", expertName: options.initialExpertName || "" };
+var BrowsingEventsInput = ({
+  checkpoint,
+  events,
+  onEventSelect,
+  onBack
+}) => /* @__PURE__ */ jsx(
+  ListBrowser,
+  {
+    title: `Events for Step ${checkpoint.stepNumber} ${KEY_HINTS.NAVIGATE} ${KEY_HINTS.SELECT} ${KEY_HINTS.BACK}`,
+    items: events,
+    onSelect: onEventSelect,
+    onBack,
+    emptyMessage: "No events found",
+    renderItem: (ev, isSelected) => /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : "gray", children: [
+      isSelected ? ">" : " ",
+      " [",
+      ev.type,
+      "] Step ",
+      ev.stepNumber,
+      " (",
+      formatTimestamp2(ev.timestamp),
+      ")"
+    ] }, ev.id)
   }
-  return { type: "running" };
-};
-var useInputState = (options) => {
-  const [state, dispatch] = useReducer(inputReducer, options, getInitialState);
-  return { state, dispatch };
-};
+);
 var useRuntimeInfo = (options) => {
   const [runtimeInfo, setRuntimeInfo] = useState({
     status: "initializing",
@@ -2126,13 +1610,6 @@ var useRuntimeInfo = (options) => {
       }));
       return null;
     }
-    if (event.type === "streamingText") {
-      setRuntimeInfo((prev) => ({
-        ...prev,
-        streamingText: (prev.streamingText ?? "") + event.text
-      }));
-      return null;
-    }
     if ("stepNumber" in event) {
       const isComplete = event.type === "completeRun";
       const isStopped = STOP_EVENT_TYPES.includes(event.type);
@@ -2170,72 +1647,6 @@ var useRuntimeInfo = (options) => {
     setContextWindowUsage
   };
 };
-var useTextInput = (options) => {
-  const [input, setInput] = useState("");
-  const inputRef = useLatestRef(input);
-  const onSubmitRef = useLatestRef(options.onSubmit);
-  const onCancelRef = useLatestRef(options.onCancel);
-  const handleInput = useCallback(
-    (inputChar, key) => {
-      if (key.escape) {
-        setInput("");
-        onCancelRef.current?.();
-        return;
-      }
-      if (key.return && inputRef.current.trim()) {
-        onSubmitRef.current(inputRef.current.trim());
-        setInput("");
-        return;
-      }
-      if (key.backspace || key.delete) {
-        setInput((prev) => prev.slice(0, -1));
-        return;
-      }
-      if (!key.ctrl && !key.meta && inputChar) {
-        setInput((prev) => prev + inputChar);
-      }
-    },
-    [inputRef, onSubmitRef, onCancelRef]
-  );
-  const reset = useCallback(() => {
-    setInput("");
-  }, []);
-  return { input, handleInput, reset };
-};
-var useListNavigation = (options) => {
-  const { items, onSelect, onBack } = options;
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  useEffect(() => {
-    if (selectedIndex >= items.length && items.length > 0) {
-      setSelectedIndex(items.length - 1);
-    }
-  }, [items.length, selectedIndex]);
-  const handleNavigation = useCallback(
-    (inputChar, key) => {
-      if (key.upArrow && items.length > 0) {
-        setSelectedIndex((prev) => Math.max(0, prev - 1));
-        return true;
-      }
-      if (key.downArrow && items.length > 0) {
-        setSelectedIndex((prev) => Math.min(items.length - 1, prev + 1));
-        return true;
-      }
-      if (key.return && items[selectedIndex]) {
-        onSelect?.(items[selectedIndex]);
-        return true;
-      }
-      if ((key.escape || inputChar === "b") && onBack) {
-        onBack();
-        return true;
-      }
-      return false;
-    },
-    [items, selectedIndex, onSelect, onBack]
-  );
-  return { selectedIndex, handleNavigation };
-};
-
-// src/tui/hooks/ui/use-expert-selector.ts
 var useExpertSelector = (options) => {
   const { experts, onExpertSelect, extraKeyHandler } = options;
   const [inputMode, setInputMode] = useState(false);
@@ -2272,321 +1683,162 @@ var useExpertSelector = (options) => {
     handleKeyInput
   };
 };
-var useAppState = (props) => {
-  const {
-    needsQueryInput,
-    showHistory,
-    initialExpertName,
-    initialQuery,
-    initialConfig,
-    configuredExperts,
-    recentExperts,
-    historyJobs,
-    onComplete,
-    onContinue,
-    onResumeFromCheckpoint,
-    onLoadCheckpoints,
-    onLoadEvents,
-    onLoadHistoricalEvents,
-    onReady
-  } = props;
-  const eventStore = useEventStore();
-  const {
-    runtimeInfo,
-    handleEvent,
-    setExpertName,
-    setQuery,
-    setCurrentStep,
-    setContextWindowUsage
-  } = useRuntimeInfo({ initialExpertName, initialConfig });
-  const { state: inputState, dispatch } = useInputState({
-    showHistory,
-    needsQueryInput,
-    initialExpertName,
-    configuredExperts,
-    recentExperts,
-    historyJobs
-  });
-  const { markAsStarted, handleQuerySubmit } = useRunActions({
-    expertName: runtimeInfo.expertName,
-    dispatch,
-    setQuery,
-    onComplete,
-    onContinue,
-    onReady,
-    stepStoreAddEvent: eventStore.addEvent,
-    handleEvent
-  });
-  useEffect(() => {
-    if (initialExpertName && initialQuery) {
-      setQuery(initialQuery);
-      dispatch({ type: "START_RUN" });
-      markAsStarted();
-      onComplete(initialExpertName, initialQuery);
-    }
-  }, [markAsStarted, initialExpertName, onComplete, setQuery, initialQuery, dispatch]);
-  const { allExperts, handleExpertSelect } = useExpertActions({
-    needsQueryInput,
-    inputState,
-    dispatch,
-    setExpertName,
-    onComplete,
-    markAsStarted,
-    configuredExperts,
-    recentExperts
-  });
-  const history = useHistoryActions({
-    allExperts,
-    historyJobs,
-    onLoadCheckpoints,
-    onLoadEvents,
-    onResumeFromCheckpoint,
-    onLoadHistoricalEvents,
-    setHistoricalEvents: eventStore.setHistoricalEvents,
-    setCurrentStep,
-    setContextWindowUsage,
-    dispatch,
-    setExpertName
-  });
-  const handleBack = useCallback(() => {
-    history.handleBack(inputState);
-  }, [history.handleBack, inputState]);
-  const inputAreaContextValue = useMemo(
-    () => ({
-      onExpertSelect: handleExpertSelect,
-      onQuerySubmit: handleQuerySubmit,
-      onJobSelect: history.handleJobSelect,
-      onJobResume: history.handleJobResume,
-      onCheckpointSelect: history.handleCheckpointSelect,
-      onCheckpointResume: history.handleCheckpointResume,
-      onEventSelect: history.handleEventSelect,
-      onBack: handleBack,
-      onSwitchToExperts: history.handleSwitchToExperts,
-      onSwitchToHistory: history.handleSwitchToHistory
-    }),
-    [
-      handleExpertSelect,
-      handleQuerySubmit,
-      history.handleJobSelect,
-      history.handleJobResume,
-      history.handleCheckpointSelect,
-      history.handleCheckpointResume,
-      history.handleEventSelect,
-      handleBack,
-      history.handleSwitchToExperts,
-      history.handleSwitchToHistory
-    ]
-  );
+function isBaseStep(step) {
+  if (typeof step !== "object" || step === null) return false;
+  const stepType = step.type;
+  return stepType === "selectExpert" || stepType === "loadingVersions" || stepType === "selectVersion" || stepType === "error";
+}
+function useExpertVersionWizard({
+  experts,
+  onFetchVersions,
+  customStepFromVersion
+}) {
+  const [step, setStep] = useState({ type: "selectExpert" });
+  const handleExpertSelect = async (expertName) => {
+    setStep({ type: "loadingVersions", expertName });
+    try {
+      const versions = await onFetchVersions(expertName);
+      if (versions.length === 0) {
+        setStep({ type: "error", message: `No versions found for ${expertName}` });
+        return;
+      }
+      setStep({ type: "selectVersion", expertName, versions });
+    } catch (error) {
+      setStep({
+        type: "error",
+        message: error instanceof Error ? error.message : "Failed to fetch versions"
+      });
+    }
+  };
+  const handleVersionSelect = (version) => {
+    const customStep = customStepFromVersion(version);
+    setStep(customStep);
+  };
+  const handleBack = (customBackHandler) => {
+    if (isBaseStep(step)) {
+      switch (step.type) {
+        case "selectVersion":
+          setStep({ type: "selectExpert" });
+          break;
+        case "error":
+          setStep({ type: "selectExpert" });
+          break;
+      }
+    } else if (customBackHandler) {
+      customBackHandler(step);
+    }
+  };
+  const renderBaseStep = (options) => {
+    if (!isBaseStep(step)) {
+      return null;
+    }
+    switch (step.type) {
+      case "selectExpert":
+        return /* @__PURE__ */ jsx(
+          WizardExpertSelector,
+          {
+            title: options?.title ?? "Select an Expert:",
+            experts,
+            onSelect: handleExpertSelect
+          }
+        );
+      case "loadingVersions":
+        return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
+          "Loading versions for ",
+          step.expertName,
+          "..."
+        ] }) });
+      case "selectVersion":
+        return /* @__PURE__ */ jsx(
+          VersionSelector,
+          {
+            expertName: step.expertName,
+            versions: step.versions,
+            onSelect: handleVersionSelect,
+            onBack: handleBack,
+            title: options?.versionSelectorTitle
+          }
+        );
+      case "error":
+        return /* @__PURE__ */ jsx(ErrorStep, { message: step.message, onBack: handleBack });
+      default:
+        return null;
+    }
+  };
+  const handlers = {
+    handleExpertSelect,
+    handleVersionSelect,
+    handleBack
+  };
   return {
-    eventStore,
-    runtimeInfo,
-    inputState,
-    inputAreaContextValue
+    step,
+    setStep,
+    handlers,
+    renderBaseStep,
+    isBaseStep: isBaseStep(step)
   };
+}
+var ExpertList = ({
+  experts,
+  selectedIndex,
+  showSource = false,
+  inline = false,
+  maxItems
+}) => {
+  const displayExperts = maxItems ? experts.slice(0, maxItems) : experts;
+  if (displayExperts.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No experts found." });
+  }
+  const items = displayExperts.map((expert, index) => /* @__PURE__ */ jsxs(Text, { color: index === selectedIndex ? "cyan" : "gray", children: [
+    index === selectedIndex ? ">" : " ",
+    " ",
+    showSource ? expert.key : expert.name,
+    showSource && expert.source && /* @__PURE__ */ jsxs(Fragment, { children: [
+      " ",
+      /* @__PURE__ */ jsxs(Text, { color: expert.source === "configured" ? "green" : "yellow", children: [
+        "[",
+        expert.source === "configured" ? "config" : "recent",
+        "]"
+      ] })
+    ] }),
+    inline ? " " : ""
+  ] }, expert.key));
+  return inline ? /* @__PURE__ */ jsx(Box, { children: items }) : /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items });
 };
-var ListBrowser = ({
-  title,
-  items,
-  renderItem,
-  onSelect,
-  emptyMessage = "No items found",
-  extraKeyHandler,
-  onBack,
-  maxItems = UI_CONSTANTS.MAX_VISIBLE_LIST_ITEMS
+var ExpertSelectorBase = ({
+  experts,
+  hint,
+  onExpertSelect,
+  showSource = false,
+  inline = false,
+  maxItems = UI_CONSTANTS.MAX_VISIBLE_LIST_ITEMS,
+  extraKeyHandler
 }) => {
-  const { selectedIndex, handleNavigation } = useListNavigation({
-    items,
-    onSelect,
-    onBack
-  });
-  useInput((inputChar, key) => {
-    if (extraKeyHandler?.(inputChar, key, items[selectedIndex])) return;
-    handleNavigation(inputChar, key);
+  const { inputMode, input, selectedIndex, handleKeyInput } = useExpertSelector({
+    experts,
+    onExpertSelect,
+    extraKeyHandler
   });
-  const { scrollOffset, displayItems } = useMemo(() => {
-    const offset = Math.max(0, Math.min(selectedIndex - maxItems + 1, items.length - maxItems));
-    return {
-      scrollOffset: offset,
-      displayItems: items.slice(offset, offset + maxItems)
-    };
-  }, [items, selectedIndex, maxItems]);
-  const hasMoreAbove = scrollOffset > 0;
-  const hasMoreBelow = scrollOffset + maxItems < items.length;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: title }),
-      items.length > maxItems && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-        " ",
-        "(",
-        selectedIndex + 1,
-        "/",
-        items.length,
-        ")"
-      ] })
+  useInput(handleKeyInput);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: inline ? "row" : "column", children: [
+    !inputMode && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: hint }) }),
+      /* @__PURE__ */ jsx(
+        ExpertList,
+        {
+          experts,
+          selectedIndex,
+          showSource,
+          inline,
+          maxItems
+        }
+      )
     ] }),
-    hasMoreAbove && /* @__PURE__ */ jsx(Text, { color: "gray", children: INDICATOR.ELLIPSIS }),
-    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: displayItems.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: emptyMessage }) : displayItems.map((item, index) => {
-      const actualIndex = scrollOffset + index;
-      return renderItem(item, actualIndex === selectedIndex, actualIndex);
-    }) }),
-    hasMoreBelow && /* @__PURE__ */ jsx(Text, { color: "gray", children: INDICATOR.ELLIPSIS })
-  ] });
-};
-var BrowsingCheckpointsInput = ({
-  job,
-  checkpoints,
-  onCheckpointSelect,
-  onCheckpointResume,
-  onBack
-}) => /* @__PURE__ */ jsx(
-  ListBrowser,
-  {
-    title: `Checkpoints for ${job.expertKey} ${KEY_HINTS.NAVIGATE} ${KEY_HINTS.RESUME} ${KEY_HINTS.EVENTS} ${KEY_HINTS.BACK}`,
-    items: checkpoints,
-    onSelect: onCheckpointResume,
-    onBack,
-    emptyMessage: "No checkpoints found",
-    extraKeyHandler: (char, _key, selected) => {
-      if (char === "e" && selected) {
-        onCheckpointSelect(selected);
-        return true;
-      }
-      return false;
-    },
-    renderItem: (cp, isSelected) => /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : "gray", children: [
-      isSelected ? ">" : " ",
-      " Step ",
-      cp.stepNumber,
-      " (",
-      cp.id,
-      ")"
-    ] }, cp.id)
-  }
-);
-var BrowsingEventDetailInput = ({ event, onBack }) => {
-  useInput((input, key) => {
-    if (input === "b" || key.escape) {
-      onBack();
-    }
-  });
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx(Text, { bold: true, children: "Event Detail" }),
-      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        " ",
-        KEY_HINTS.BACK
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Type: " }),
-        /* @__PURE__ */ jsx(Text, { color: "cyan", children: event.type })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Step: " }),
-        /* @__PURE__ */ jsx(Text, { children: event.stepNumber })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Timestamp: " }),
-        /* @__PURE__ */ jsx(Text, { children: formatTimestamp2(event.timestamp) })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "ID: " }),
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: event.id })
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Run ID: " }),
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: event.runId })
-      ] })
-    ] })
-  ] });
-};
-var BrowsingEventsInput = ({
-  checkpoint,
-  events,
-  onEventSelect,
-  onBack
-}) => /* @__PURE__ */ jsx(
-  ListBrowser,
-  {
-    title: `Events for Step ${checkpoint.stepNumber} ${KEY_HINTS.NAVIGATE} ${KEY_HINTS.SELECT} ${KEY_HINTS.BACK}`,
-    items: events,
-    onSelect: onEventSelect,
-    onBack,
-    emptyMessage: "No events found",
-    renderItem: (ev, isSelected) => /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : "gray", children: [
-      isSelected ? ">" : " ",
-      " [",
-      ev.type,
-      "] Step ",
-      ev.stepNumber,
-      " (",
-      formatTimestamp2(ev.timestamp),
-      ")"
-    ] }, ev.id)
-  }
-);
-var ExpertList = ({
-  experts,
-  selectedIndex,
-  showSource = false,
-  inline = false,
-  maxItems
-}) => {
-  const displayExperts = maxItems ? experts.slice(0, maxItems) : experts;
-  if (displayExperts.length === 0) {
-    return /* @__PURE__ */ jsx(Text, { color: "gray", children: "No experts found." });
-  }
-  const items = displayExperts.map((expert, index) => /* @__PURE__ */ jsxs(Text, { color: index === selectedIndex ? "cyan" : "gray", children: [
-    index === selectedIndex ? ">" : " ",
-    " ",
-    showSource ? expert.key : expert.name,
-    showSource && expert.source && /* @__PURE__ */ jsxs(Fragment, { children: [
-      " ",
-      /* @__PURE__ */ jsxs(Text, { color: expert.source === "configured" ? "green" : "yellow", children: [
-        "[",
-        expert.source === "configured" ? "config" : "recent",
-        "]"
-      ] })
-    ] }),
-    inline ? " " : ""
-  ] }, expert.key));
-  return inline ? /* @__PURE__ */ jsx(Box, { children: items }) : /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items });
-};
-var ExpertSelectorBase = ({
-  experts,
-  hint,
-  onExpertSelect,
-  showSource = false,
-  inline = false,
-  maxItems = UI_CONSTANTS.MAX_VISIBLE_LIST_ITEMS,
-  extraKeyHandler
-}) => {
-  const { inputMode, input, selectedIndex, handleKeyInput } = useExpertSelector({
-    experts,
-    onExpertSelect,
-    extraKeyHandler
-  });
-  useInput(handleKeyInput);
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: inline ? "row" : "column", children: [
-    !inputMode && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: hint }) }),
-      /* @__PURE__ */ jsx(
-        ExpertList,
-        {
-          experts,
-          selectedIndex,
-          showSource,
-          inline,
-          maxItems
-        }
-      )
-    ] }),
-    inputMode && /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Expert: " }),
-      /* @__PURE__ */ jsx(Text, { color: "white", children: input }),
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
-    ] })
+    inputMode && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Expert: " }),
+      /* @__PURE__ */ jsx(Text, { color: "white", children: input }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+    ] })
   ] });
 };
 var BrowsingExpertsInput = ({
@@ -2654,7 +1906,7 @@ var BrowsingHistoryInput = ({
     ] }, job.jobId)
   }
 );
-var BrowserRouter = ({ inputState }) => {
+var BrowserRouter = ({ inputState, showEventsHint = true }) => {
   const ctx = useInputAreaContext();
   const handleEventSelect = useCallback(
     (event) => {
@@ -2692,7 +1944,8 @@ var BrowserRouter = ({ inputState }) => {
           checkpoints: inputState.checkpoints,
           onCheckpointSelect: ctx.onCheckpointSelect,
           onCheckpointResume: ctx.onCheckpointResume,
-          onBack: ctx.onBack
+          onBack: ctx.onBack,
+          showEventsHint
         }
       );
     case "browsingEvents":
@@ -2711,256 +1964,180 @@ var BrowserRouter = ({ inputState }) => {
       return assertNever(inputState);
   }
 };
-function ErrorStep({ message, onBack }) {
-  useInput(() => onBack());
+var ActionRowSimple = ({
+  indicatorColor,
+  text,
+  textDimColor = false
+}) => /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+  /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { color: indicatorColor, children: INDICATOR.BULLET }) }),
+  /* @__PURE__ */ jsx(Text, { color: "white", dimColor: textDimColor, children: text })
+] }) });
+var ActionRow = ({ indicatorColor, label, summary, children }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: indicatorColor, children: INDICATOR.BULLET }),
+    /* @__PURE__ */ jsx(Text, { color: "white", children: label }),
+    summary && /* @__PURE__ */ jsx(Text, { color: "white", dimColor: true, children: summary })
+  ] }),
+  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: INDICATOR.TREE }) }),
+    children
+  ] })
+] });
+var CheckpointActionRow = ({ action }) => {
+  if (action.type === "parallelGroup") {
+    return renderParallelGroup(action);
+  }
+  const actionElement = renderAction(action);
+  if (!actionElement) return null;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs(Text, { color: "red", children: [
-      "Error: ",
-      message
-    ] }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press any key to go back" }) })
+    action.reasoning && renderReasoning(action.reasoning),
+    actionElement
   ] });
-}
-var RunSetting = ({
-  info,
-  eventCount,
-  isEditing,
-  expertName,
-  onQuerySubmit
-}) => {
-  const { input, handleInput } = useTextInput({
-    onSubmit: onQuerySubmit ?? (() => {
+};
+function renderParallelGroup(group) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    group.reasoning && renderReasoning(group.reasoning),
+    group.activities.map((activity, index) => {
+      const actionElement = renderAction(activity);
+      if (!actionElement) return null;
+      return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: actionElement }, activity.id || `${activity.type}-${index}`);
     })
-  });
-  useInput(handleInput, { isActive: isEditing });
-  const displayExpertName = expertName ?? info.expertName;
-  const skills = info.activeSkills.length > 0 ? info.activeSkills.join(", ") : "";
-  const step = info.currentStep !== void 0 ? String(info.currentStep) : "";
-  const usagePercent = (info.contextWindowUsage * 100).toFixed(1);
-  return /* @__PURE__ */ jsxs(
-    Box,
-    {
-      flexDirection: "column",
-      borderStyle: "single",
-      borderColor: "gray",
-      borderTop: true,
-      borderBottom: false,
-      borderLeft: false,
-      borderRight: false,
-      children: [
-        /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: info.runtime === "local" ? "Local" : info.runtime === "claude-code" ? "Claude Code" : (info.runtime ?? "docker").charAt(0).toUpperCase() + (info.runtime ?? "docker").slice(1) }),
-          info.runtime === "docker" || !info.runtime ? /* @__PURE__ */ jsxs(Text, { color: info.dockerState === "building" ? "yellow" : "gray", children: [
-            " ",
-            "(",
-            info.dockerState ?? "initializing",
-            ")"
-          ] }) : info.runtimeVersion && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-            " ",
-            "(",
-            info.runtime === "local" ? `v${info.runtimeVersion}` : info.runtimeVersion,
-            ")"
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Expert: " }),
-          /* @__PURE__ */ jsx(Text, { color: "white", children: displayExpertName }),
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Skills: " }),
-          /* @__PURE__ */ jsx(Text, { color: "green", children: skills })
-        ] }),
-        /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Status: " }),
-          /* @__PURE__ */ jsx(
-            Text,
-            {
-              color: info.status === "running" ? "green" : info.status === "completed" ? "cyan" : "yellow",
-              children: info.status
-            }
-          ),
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Step: " }),
-          /* @__PURE__ */ jsx(Text, { color: "white", children: step }),
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Events: " }),
-          /* @__PURE__ */ jsx(Text, { color: "white", children: eventCount }),
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Usage: " }),
-          /* @__PURE__ */ jsxs(Text, { color: "white", children: [
-            usagePercent,
-            "%"
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs(Text, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Model: " }),
-          /* @__PURE__ */ jsx(Text, { color: "white", children: info.model })
-        ] }),
-        /* @__PURE__ */ jsxs(Box, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Query: " }),
-          isEditing ? /* @__PURE__ */ jsxs(Fragment, { children: [
-            /* @__PURE__ */ jsx(Text, { color: "white", children: input }),
-            /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
-          ] }) : /* @__PURE__ */ jsx(Text, { color: "white", children: info.query })
-        ] })
-      ]
-    }
-  );
-};
-var QueryRow = ({ text }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-  /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: INDICATOR.CHEVRON_RIGHT }) }),
-  /* @__PURE__ */ jsx(Text, { color: "cyan", children: text })
-] });
-var CompletionRow = ({ text }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
-    /* @__PURE__ */ jsx(Text, { color: "white", children: INDICATOR.BULLET }),
-    /* @__PURE__ */ jsx(Text, { color: "white", children: "Run Results" })
-  ] }),
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: INDICATOR.TREE }) }),
-    /* @__PURE__ */ jsx(Text, { color: "white", children: text })
-  ] })
-] });
-var ErrorRow = ({ errorName, message, statusCode }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
-    /* @__PURE__ */ jsx(Text, { color: "red", children: INDICATOR.BULLET }),
-    /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
-      "Error: ",
-      errorName,
-      statusCode ? ` (${statusCode})` : ""
-    ] })
-  ] }),
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: INDICATOR.TREE }) }),
-    /* @__PURE__ */ jsx(Text, { color: "red", children: message })
-  ] })
-] });
-var ActionRowSimple = ({
-  indicatorColor,
-  text,
-  textDimColor = false
-}) => /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-  /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { color: indicatorColor, children: INDICATOR.BULLET }) }),
-  /* @__PURE__ */ jsx(Text, { color: "white", dimColor: textDimColor, children: text })
-] }) });
-var ActionRow = ({ indicatorColor, label, summary, children }) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
-    /* @__PURE__ */ jsx(Text, { color: indicatorColor, children: INDICATOR.BULLET }),
-    /* @__PURE__ */ jsx(Text, { color: "white", children: label }),
-    summary && /* @__PURE__ */ jsx(Text, { color: "white", dimColor: true, children: summary })
-  ] }),
-  /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
-    /* @__PURE__ */ jsx(Box, { paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: INDICATOR.TREE }) }),
-    children
-  ] })
-] });
-var getResultText = (result) => {
-  if (!result) return "";
-  return result.find((r) => r.type === "textPart")?.text ?? "";
-};
-var getString = (args, key) => {
-  const value = args[key];
-  return typeof value === "string" ? value : "";
-};
-var getStringArray = (args, key) => {
-  const value = args[key];
-  return Array.isArray(value) ? value : [];
-};
-var getNumberArray = (args, key) => {
-  const value = args[key];
-  return Array.isArray(value) ? value : [];
-};
-var renderThink = (args) => {
-  const thought = getString(args, "thought");
-  return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: "white", text: thought, textDimColor: true });
-};
-var renderCompleteReasoning = (text) => {
-  const label = "Reasoning";
+  ] });
+}
+function renderReasoning(text) {
   const lines = text.split("\n");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "white", label, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: line }, `reasoning-${idx}`)) }) });
-};
-var renderAttemptCompletion = () => null;
-var getTodosFromResult = (result) => {
-  if (!result) return [];
-  const text = result.find((r) => r.type === "textPart")?.text;
-  if (!text) return [];
-  try {
-    const parsed = JSON.parse(text);
-    return parsed.todos ?? [];
-  } catch {
-    return [];
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "white", label: "Reasoning", children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: line }, `reasoning-${idx}`)) }) });
+}
+function renderAction(action) {
+  const color = action.type === "error" || "error" in action && action.error ? "red" : "green";
+  switch (action.type) {
+    case "query":
+      return renderQuery(action.text, action.runId);
+    case "retry":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label: "Retry", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: action.message || action.error }) });
+    case "complete":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "green", label: "Run Results", children: /* @__PURE__ */ jsx(Text, { children: action.text }) });
+    case "attemptCompletion": {
+      if (action.error) {
+        return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "red", label: "Completion Failed", children: /* @__PURE__ */ jsx(Text, { color: "red", children: action.error }) });
+      }
+      const remaining = action.remainingTodos?.filter((t) => !t.completed) ?? [];
+      if (remaining.length > 0) {
+        return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label: "Completion Blocked", children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          remaining.length,
+          " remaining task",
+          remaining.length > 1 ? "s" : ""
+        ] }) });
+      }
+      return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: "green", text: "Completion Accepted" });
+    }
+    case "todo":
+      return renderTodo(action, color);
+    case "clearTodo":
+      return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: color, text: "Todo Cleared" });
+    case "readTextFile":
+      return renderReadTextFile(action, color);
+    case "writeTextFile":
+      return renderWriteTextFile(action, color);
+    case "editTextFile":
+      return renderEditTextFile(action, color);
+    case "appendTextFile":
+      return renderAppendTextFile(action, color);
+    case "deleteFile":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Delete", summary: shortenPath(action.path), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Removed" }) });
+    case "deleteDirectory":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Delete Dir", summary: shortenPath(action.path), children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Removed",
+        action.recursive ? " (recursive)" : ""
+      ] }) });
+    case "moveFile":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Move", summary: shortenPath(action.source), children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "\u2192 ",
+        shortenPath(action.destination, 30)
+      ] }) });
+    case "createDirectory":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Mkdir", summary: shortenPath(action.path), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Created" }) });
+    case "listDirectory":
+      return renderListDirectory(action, color);
+    case "getFileInfo":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Info", summary: shortenPath(action.path), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Fetched" }) });
+    case "readPdfFile":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "PDF", summary: shortenPath(action.path), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Read" }) });
+    case "readImageFile":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Image", summary: shortenPath(action.path), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Read" }) });
+    case "exec":
+      return renderExec(action, color);
+    case "delegate":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label: action.delegateExpertKey, children: /* @__PURE__ */ jsx(
+        Text,
+        {
+          dimColor: true,
+          children: `{"query":"${truncateText(action.query, UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM)}"}`
+        }
+      ) });
+    case "delegationComplete":
+      return /* @__PURE__ */ jsx(
+        ActionRowSimple,
+        {
+          indicatorColor: "green",
+          text: `Delegation Complete (${action.count} delegate${action.count > 1 ? "s" : ""} returned)`
+        }
+      );
+    case "interactiveTool":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label: `Interactive: ${action.toolName}`, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(JSON.stringify(action.args), UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM) }) });
+    case "generalTool":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: action.toolName, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(JSON.stringify(action.args), UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM) }) });
+    case "error":
+      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "red", label: action.errorName ?? "Error", children: /* @__PURE__ */ jsx(Text, { color: "red", children: action.error ?? "Unknown error" }) });
+    default: {
+      return null;
+    }
   }
-};
-var renderTodo = (args, result) => {
-  const newTodos = getStringArray(args, "newTodos");
-  const completedTodoIds = getNumberArray(args, "completedTodos");
-  if (newTodos.length === 0 && completedTodoIds.length === 0) return null;
-  if (newTodos.length > 0) {
-    const label2 = `Todo Added ${newTodos.length} task${newTodos.length > 1 ? "s" : ""}`;
-    const preview2 = newTodos.slice(0, RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW);
-    const remaining2 = newTodos.length - preview2.length;
-    return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "white", label: label2, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      preview2.map((todo, idx) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "\u25CB ",
-        todo
-      ] }, `todo-${idx}`)),
-      remaining2 > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "... +",
-        remaining2,
-        " more"
-      ] })
-    ] }) });
-  }
-  const todos = getTodosFromResult(result);
-  const completedTitles = completedTodoIds.map((id) => todos.find((t) => t.id === id)?.title).filter((t) => t !== void 0);
-  const label = `Todo Completed ${completedTodoIds.length} task${completedTodoIds.length > 1 ? "s" : ""}`;
-  if (completedTitles.length === 0) {
-    return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: "white", text: label });
-  }
-  const preview = completedTitles.slice(0, RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW);
-  const remaining = completedTitles.length - preview.length;
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "white", label, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    preview.map((title, idx) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+}
+function renderTodo(action, color) {
+  const { newTodos, completedTodos, todos } = action;
+  const hasNewTodos = newTodos && newTodos.length > 0;
+  const hasCompletedTodos = completedTodos && completedTodos.length > 0;
+  if (!hasNewTodos && !hasCompletedTodos) {
+    return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: color, text: "Todo No changes" });
+  }
+  const labelParts = [];
+  if (hasNewTodos) {
+    labelParts.push(`Added ${newTodos.length} task${newTodos.length > 1 ? "s" : ""}`);
+  }
+  if (hasCompletedTodos) {
+    labelParts.push(
+      `Completed ${completedTodos.length} task${completedTodos.length > 1 ? "s" : ""}`
+    );
+  }
+  const label = `Todo ${labelParts.join(", ")}`;
+  const completedTitles = hasCompletedTodos ? completedTodos.map((id) => todos.find((t) => t.id === id)?.title).filter((t) => t !== void 0) : [];
+  if (!hasNewTodos && completedTitles.length === 0) {
+    return /* @__PURE__ */ jsx(ActionRowSimple, { indicatorColor: color, text: label });
+  }
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    hasNewTodos && newTodos.slice(0, RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW).map((todo, idx) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "\u25CB ",
+      todo
+    ] }, `todo-${idx}`)),
+    hasNewTodos && newTodos.length > RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "... +",
+      newTodos.length - RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW,
+      " more"
+    ] }),
+    completedTitles.slice(0, RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW).map((title, idx) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
       "\u2713 ",
       title
     ] }, `completed-${idx}`)),
-    remaining > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-      "... +",
-      remaining,
-      " more"
-    ] })
-  ] }) });
-};
-var renderExec = (args, result, color) => {
-  const command = getString(args, "command");
-  const cmdArgs = getStringArray(args, "args");
-  const cwd = getString(args, "cwd");
-  const cwdPart = cwd ? ` ${shortenPath(cwd, 40)}` : "";
-  const cmdLine = truncateText(
-    `${command} ${cmdArgs.join(" ")}${cwdPart}`,
-    UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT
-  );
-  const text = getResultText(result);
-  const { visible, remaining } = summarizeOutput(
-    text.split("\n"),
-    RENDER_CONSTANTS.EXEC_OUTPUT_MAX_LINES
-  );
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: `Bash ${cmdLine}`, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    visible.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(line, UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT) }, `out-${idx}`)),
-    remaining > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    completedTitles.length > RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
       "... +",
-      remaining,
+      completedTitles.length - RENDER_CONSTANTS.NEW_TODO_MAX_PREVIEW,
       " more"
     ] })
   ] }) });
-};
-var parseReadTextFileResult = (result) => {
-  const text = getResultText(result);
-  if (!text) return { content: "" };
-  try {
-    return JSON.parse(text);
-  } catch {
-    return { content: "" };
-  }
-};
-var renderReadTextFile = (args, result, color) => {
-  const path11 = getString(args, "path");
-  const { content, from, to } = parseReadTextFileResult(result);
+}
+function renderReadTextFile(action, color) {
+  const { path: path11, content, from, to } = action;
   const lineRange = from !== void 0 && to !== void 0 ? `#${from}-${to}` : "";
   const lines = content?.split("\n") ?? [];
   return /* @__PURE__ */ jsx(
@@ -2972,20 +2149,17 @@ var renderReadTextFile = (args, result, color) => {
       children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Box, { flexDirection: "row", gap: 1, children: /* @__PURE__ */ jsx(Text, { color: "white", dimColor: true, children: line }) }, `read-${idx}`)) })
     }
   );
-};
-var renderWriteTextFile = (args, color) => {
-  const path11 = getString(args, "path");
-  const text = getString(args, "text");
+}
+function renderWriteTextFile(action, color) {
+  const { path: path11, text } = action;
   const lines = text.split("\n");
   return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Write Text File", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
     /* @__PURE__ */ jsx(Text, { color: "green", dimColor: true, children: "+" }),
     /* @__PURE__ */ jsx(Text, { color: "white", dimColor: true, children: line })
   ] }, `write-${idx}`)) }) });
-};
-var renderEditTextFile = (args, color) => {
-  const path11 = getString(args, "path");
-  const oldText = getString(args, "oldText");
-  const newText = getString(args, "newText");
+}
+function renderEditTextFile(action, color) {
+  const { path: path11, oldText, newText } = action;
   const oldLines = oldText.split("\n");
   const newLines = newText.split("\n");
   return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Edit Text File", summary: shortenPath(path11), children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
@@ -2998,23 +2172,19 @@ var renderEditTextFile = (args, color) => {
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: line })
     ] }, `new-${idx}`))
   ] }) });
-};
-var renderAppendTextFile = (args, color) => {
-  const path11 = getString(args, "path");
-  const text = getString(args, "text");
+}
+function renderAppendTextFile(action, color) {
+  const { path: path11, text } = action;
   const lines = text.split("\n");
   return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Append Text File", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
     /* @__PURE__ */ jsx(Text, { color: "green", dimColor: true, children: "+" }),
     /* @__PURE__ */ jsx(Text, { color: "white", dimColor: true, children: line })
   ] }, `append-${idx}`)) }) });
-};
-var renderListDirectory = (args, result, color) => {
-  const path11 = getString(args, "path");
-  const text = getResultText(result);
-  const { visible, remaining } = summarizeOutput(
-    text.split("\n"),
-    RENDER_CONSTANTS.LIST_DIR_MAX_ITEMS
-  );
+}
+function renderListDirectory(action, color) {
+  const { path: path11, items } = action;
+  const itemLines = items?.map((item) => `${item.type === "directory" ? "\u{1F4C1}" : "\u{1F4C4}"} ${item.name}`) ?? [];
+  const { visible, remaining } = summarizeOutput(itemLines, RENDER_CONSTANTS.LIST_DIR_MAX_ITEMS);
   return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "List", summary: shortenPath(path11), children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     visible.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(line, UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT) }, `dir-${idx}`)),
     remaining > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
@@ -3023,159 +2193,160 @@ var renderListDirectory = (args, result, color) => {
       " more"
     ] })
   ] }) });
-};
-var renderDeleteFile = (args, color) => {
-  const path11 = getString(args, "path");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Delete", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Removed" }) });
-};
-var renderMoveFile = (args, color) => {
-  const sourcePath = getString(args, "sourcePath");
-  const destinationPath = getString(args, "destinationPath");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Move", summary: shortenPath(sourcePath), children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-    "\u2192 ",
-    shortenPath(destinationPath, 30)
-  ] }) });
-};
-var renderCreateDirectory = (args, color) => {
-  const path11 = getString(args, "path");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Mkdir", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Created" }) });
-};
-var renderGetFileInfo = (args, color) => {
-  const path11 = getString(args, "path");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Info", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Fetched" }) });
-};
-var renderReadPdfFile = (args, color) => {
-  const path11 = getString(args, "path");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "PDF", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Read" }) });
-};
-var renderReadImageFile = (args, color) => {
-  const path11 = getString(args, "path");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Image", summary: shortenPath(path11), children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Read" }) });
-};
-var renderTestUrl = (args, color) => {
-  const urls = getStringArray(args, "urls");
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "TestURL", children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-    urls.length,
-    " URL(s)"
-  ] }) });
-};
-var renderDefault = (toolName, args, color) => /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: toolName, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(JSON.stringify(args), UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM) }) });
-var renderDelegationStarted = (expertName, runtime, version, query) => {
-  const label = `Delegation Started (${expertName}, ${runtime}, v${version})`;
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label, children: query && /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(query, UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM) }) });
-};
-var renderDelegationCompleted = (expertName, runtime, version, result) => {
-  const label = `Delegation Completed (${expertName}, ${runtime}, v${version})`;
-  const trimmedResult = result?.trim();
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "green", label, children: trimmedResult && /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(trimmedResult, UI_CONSTANTS.TRUNCATE_TEXT_MEDIUM) }) });
-};
-var renderDockerBuild = (stage, service, message) => {
-  const stageColors = {
-    pulling: "yellow",
-    building: "yellow",
-    complete: "green",
-    error: "red"
-  };
-  const color = stageColors[stage] ?? "yellow";
-  const stageLabel = stage.charAt(0).toUpperCase() + stage.slice(1);
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: `Docker Build [${service}] ${stageLabel}`, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(message, UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT) }) });
-};
-var renderDockerContainer = (status, service, message) => {
-  const statusColors = {
-    starting: "yellow",
-    running: "green",
-    healthy: "green",
-    unhealthy: "red",
-    stopped: "white",
-    error: "red"
-  };
-  const color = statusColors[status] ?? "white";
-  const statusLabel = status.charAt(0).toUpperCase() + status.slice(1);
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: `Docker [${service}] ${statusLabel}`, children: message && /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(message, UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT) }) });
-};
-var renderProxyAccess = (action, domain, port, reason) => {
-  const isAllowed = action === "allowed";
-  const color = isAllowed ? "green" : "red";
-  const icon = isAllowed ? "\u2713" : "\u2717";
-  const detail = reason ? `${domain}:${port} (${reason})` : `${domain}:${port}`;
-  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: "Proxy", children: /* @__PURE__ */ jsxs(Text, { color, children: [
-    icon,
-    " ",
-    detail
+}
+function renderExec(action, color) {
+  const { command, args, cwd, output } = action;
+  const cwdPart = cwd ? ` ${shortenPath(cwd, 40)}` : "";
+  const cmdLine = truncateText(
+    `${command} ${args.join(" ")}${cwdPart}`,
+    UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT
+  );
+  const outputLines = output?.split("\n") ?? [];
+  const { visible, remaining } = summarizeOutput(
+    outputLines,
+    RENDER_CONSTANTS.EXEC_OUTPUT_MAX_LINES
+  );
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: color, label: `Bash ${cmdLine}`, children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    visible.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: truncateText(line, UI_CONSTANTS.TRUNCATE_TEXT_DEFAULT) }, `out-${idx}`)),
+    remaining > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "... +",
+      remaining,
+      " more"
+    ] })
   ] }) });
+}
+function renderQuery(text, runId) {
+  const lines = text.split("\n");
+  const shortRunId = runId.slice(0, 8);
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "cyan", label: "Query", summary: `(${shortRunId})`, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: line }, `query-${idx}`)) }) });
+}
+function ErrorStep({ message, onBack }) {
+  useInput(() => onBack());
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "Error: ",
+      message
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press any key to go back" }) })
+  ] });
+}
+var RunSetting = ({
+  info,
+  eventCount,
+  isEditing,
+  expertName,
+  onQuerySubmit
+}) => {
+  const { input, handleInput } = useTextInput({
+    onSubmit: onQuerySubmit ?? (() => {
+    })
+  });
+  useInput(handleInput, { isActive: isEditing });
+  const displayExpertName = expertName ?? info.expertName;
+  const skills = info.activeSkills.length > 0 ? info.activeSkills.join(", ") : "";
+  const step = info.currentStep !== void 0 ? String(info.currentStep) : "";
+  const usagePercent = (info.contextWindowUsage * 100).toFixed(1);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "gray",
+      borderTop: true,
+      borderBottom: false,
+      borderLeft: false,
+      borderRight: false,
+      children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: info.runtime === "local" ? "Local" : info.runtime === "claude-code" ? "Claude Code" : (info.runtime ?? "docker").charAt(0).toUpperCase() + (info.runtime ?? "docker").slice(1) }),
+          info.runtime === "docker" || !info.runtime ? /* @__PURE__ */ jsxs(Text, { color: info.dockerState === "building" ? "yellow" : "gray", children: [
+            " ",
+            "(",
+            info.dockerState ?? "initializing",
+            ")"
+          ] }) : info.runtimeVersion && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            " ",
+            "(",
+            info.runtime === "local" ? `v${info.runtimeVersion}` : info.runtimeVersion,
+            ")"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Expert: " }),
+          /* @__PURE__ */ jsx(Text, { color: "white", children: displayExpertName }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Skills: " }),
+          /* @__PURE__ */ jsx(Text, { color: "green", children: skills })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Status: " }),
+          /* @__PURE__ */ jsx(
+            Text,
+            {
+              color: info.status === "running" ? "green" : info.status === "completed" ? "cyan" : "yellow",
+              children: info.status
+            }
+          ),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Step: " }),
+          /* @__PURE__ */ jsx(Text, { color: "white", children: step }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Events: " }),
+          /* @__PURE__ */ jsx(Text, { color: "white", children: eventCount }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " / Usage: " }),
+          /* @__PURE__ */ jsxs(Text, { color: "white", children: [
+            usagePercent,
+            "%"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Model: " }),
+          /* @__PURE__ */ jsx(Text, { color: "white", children: info.model })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "Query: " }),
+          isEditing ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { color: "white", children: input }),
+            /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+          ] }) : /* @__PURE__ */ jsx(Text, { color: "white", children: info.query })
+        ] })
+      ]
+    }
+  );
 };
-var renderToolFromLog = (toolName, args, result, isSuccess) => {
-  const color = isSuccess === void 0 ? "yellow" : isSuccess ? "green" : "red";
-  switch (toolName) {
-    case "think":
-      return renderThink(args);
-    case "attemptCompletion":
-      return renderAttemptCompletion();
-    case "todo":
-      return renderTodo(args, result);
-    case "exec":
-      return renderExec(args, result, color);
-    case "readTextFile":
-      return renderReadTextFile(args, result, color);
-    case "writeTextFile":
-      return renderWriteTextFile(args, color);
-    case "editTextFile":
-      return renderEditTextFile(args, color);
-    case "appendTextFile":
-      return renderAppendTextFile(args, color);
-    case "listDirectory":
-      return renderListDirectory(args, result, color);
-    case "deleteFile":
-      return renderDeleteFile(args, color);
-    case "moveFile":
-      return renderMoveFile(args, color);
-    case "createDirectory":
-      return renderCreateDirectory(args, color);
-    case "getFileInfo":
-      return renderGetFileInfo(args, color);
-    case "readPdfFile":
-      return renderReadPdfFile(args, color);
-    case "readImageFile":
-      return renderReadImageFile(args, color);
-    case "testUrl":
-      return renderTestUrl(args, color);
-    default:
-      return renderDefault(toolName, args, color);
-  }
+var StreamingDisplay = ({ streaming }) => {
+  const activeRuns = Object.entries(streaming.runs).filter(
+    ([, run]) => run.isReasoningActive || run.isRunResultActive
+  );
+  if (activeRuns.length === 0) return null;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginY: 1, children: activeRuns.map(([runId, run]) => /* @__PURE__ */ jsx(StreamingRunSection, { run }, runId)) });
 };
-var LogEntryRow = ({ entry }) => {
-  switch (entry.type) {
-    case "query":
-      return /* @__PURE__ */ jsx(QueryRow, { text: entry.text });
-    case "tool":
-      return /* @__PURE__ */ jsx(Box, { children: renderToolFromLog(entry.toolName, entry.args, entry.result, entry.isSuccess) });
-    case "delegation-started":
-      return /* @__PURE__ */ jsx(Box, { children: renderDelegationStarted(entry.expertName, entry.runtime, entry.version, entry.query) });
-    case "delegation-completed":
-      return /* @__PURE__ */ jsx(Box, { children: renderDelegationCompleted(entry.expertName, entry.runtime, entry.version, entry.result) });
-    case "completion":
-      return /* @__PURE__ */ jsx(CompletionRow, { text: entry.text });
-    case "docker-build":
-      return /* @__PURE__ */ jsx(Box, { children: renderDockerBuild(entry.stage, entry.service, entry.message) });
-    case "docker-container":
-      return /* @__PURE__ */ jsx(Box, { children: renderDockerContainer(entry.status, entry.service, entry.message) });
-    case "proxy-access":
-      return /* @__PURE__ */ jsx(Box, { children: renderProxyAccess(entry.action, entry.domain, entry.port, entry.reason) });
-    case "error":
-      return /* @__PURE__ */ jsx(
-        ErrorRow,
-        {
-          errorName: entry.errorName,
-          message: entry.message,
-          statusCode: entry.statusCode
-        }
-      );
-    case "completeReasoning":
-      return /* @__PURE__ */ jsx(Box, { children: renderCompleteReasoning(entry.text) });
-    case "retry":
-      return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "yellow", label: "Retry", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.reason }) });
+function StreamingRunSection({ run }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    run.isReasoningActive && run.reasoning !== void 0 && /* @__PURE__ */ jsx(StreamingReasoning, { expertKey: run.expertKey, text: run.reasoning }),
+    run.isRunResultActive && run.runResult !== void 0 && /* @__PURE__ */ jsx(StreamingRunResult, { expertKey: run.expertKey, text: run.runResult })
+  ] });
+}
+function StreamingReasoning({
+  expertKey,
+  text
+}) {
+  const lines = text.split("\n");
+  const label = `[${formatExpertKey(expertKey)}] Reasoning...`;
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "cyan", label, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: line }, `streaming-reasoning-${idx}`)) }) });
+}
+function StreamingRunResult({
+  expertKey,
+  text
+}) {
+  const lines = text.split("\n");
+  const label = `[${formatExpertKey(expertKey)}] Generating...`;
+  return /* @__PURE__ */ jsx(ActionRow, { indicatorColor: "green", label, children: /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, idx) => /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: line }, `streaming-run-result-${idx}`)) }) });
+}
+function formatExpertKey(expertKey) {
+  const atIndex = expertKey.lastIndexOf("@");
+  if (atIndex > 0) {
+    return expertKey.substring(0, atIndex);
   }
-};
+  return expertKey;
+}
 
 // src/tui/utils/status-color.ts
 var getStatusColor = (status) => {
@@ -3236,6 +2407,10 @@ function VersionSelector({
 function WizardExpertSelector({ title, experts, onSelect }) {
   const { exit } = useApp();
   const [selectedIndex, setSelectedIndex] = useState(0);
+  const expertItems = experts.map((expert) => ({
+    key: expert.name,
+    expert
+  }));
   useInput((input, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => prev > 0 ? prev - 1 : experts.length - 1);
@@ -3252,17 +2427,291 @@ function WizardExpertSelector({ title, experts, onSelect }) {
   });
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
-    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: experts.map((expert, index) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: index === selectedIndex ? "cyan" : void 0, children: [
-      index === selectedIndex ? "\u276F " : "  ",
-      expert.name,
-      expert.description && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        " - ",
-        expert.description
-      ] })
-    ] }) }, expert.name)) }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: /* @__PURE__ */ jsx(
+      SelectableList,
+      {
+        items: expertItems,
+        selectedIndex,
+        renderItem: (item, isSelected) => /* @__PURE__ */ jsxs(Text, { color: isSelected ? "cyan" : void 0, children: [
+          isSelected ? "\u276F " : "  ",
+          item.expert.name,
+          item.expert.description && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            " - ",
+            item.expert.description
+          ] })
+        ] })
+      }
+    ) }),
     /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \xB7 enter select \xB7 q quit" }) })
   ] });
 }
+function getActivityKey(activityOrGroup, index) {
+  return activityOrGroup.id || `activity-${index}`;
+}
+var RunBox = ({ node, isRoot }) => {
+  if (isRoot) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      node.activities.map((activity, index) => /* @__PURE__ */ jsx(CheckpointActionRow, { action: activity }, getActivityKey(activity, index))),
+      node.children.map((child) => /* @__PURE__ */ jsx(RunBox, { node: child, isRoot: false }, child.runId))
+    ] });
+  }
+  const shortRunId = node.runId.slice(0, 8);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", marginLeft: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, bold: true, children: [
+      "[",
+      node.expertKey,
+      "] ",
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "(",
+        shortRunId,
+        ")"
+      ] })
+    ] }),
+    node.activities.map((activity, index) => /* @__PURE__ */ jsx(CheckpointActionRow, { action: activity }, getActivityKey(activity, index))),
+    node.children.map((child) => /* @__PURE__ */ jsx(RunBox, { node: child, isRoot: false }, child.runId))
+  ] });
+};
+function getActivityProps(activityOrGroup) {
+  if (activityOrGroup.type === "parallelGroup") {
+    const group = activityOrGroup;
+    const firstActivity = group.activities[0];
+    return {
+      runId: group.runId,
+      expertKey: group.expertKey,
+      delegatedBy: firstActivity?.delegatedBy
+    };
+  }
+  return activityOrGroup;
+}
+var ActivityLogPanel = ({ activities }) => {
+  const rootNodes = useMemo(() => {
+    const nodeMap = /* @__PURE__ */ new Map();
+    const roots = [];
+    const orphanChildren = /* @__PURE__ */ new Map();
+    for (const activityOrGroup of activities) {
+      const { runId, expertKey, delegatedBy } = getActivityProps(activityOrGroup);
+      let node = nodeMap.get(runId);
+      if (!node) {
+        node = {
+          runId,
+          expertKey,
+          activities: [],
+          children: []
+        };
+        nodeMap.set(runId, node);
+        const waitingChildren = orphanChildren.get(runId);
+        if (waitingChildren) {
+          for (const child of waitingChildren) {
+            node.children.push(child);
+            const rootIndex = roots.indexOf(child);
+            if (rootIndex !== -1) {
+              roots.splice(rootIndex, 1);
+            }
+          }
+          orphanChildren.delete(runId);
+        }
+        if (delegatedBy) {
+          const parentNode = nodeMap.get(delegatedBy.runId);
+          if (parentNode) {
+            parentNode.children.push(node);
+          } else {
+            const orphans = orphanChildren.get(delegatedBy.runId) ?? [];
+            orphans.push(node);
+            orphanChildren.set(delegatedBy.runId, orphans);
+            roots.push(node);
+          }
+        } else {
+          roots.push(node);
+        }
+      }
+      node.activities.push(activityOrGroup);
+    }
+    return roots;
+  }, [activities]);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rootNodes.map((node) => /* @__PURE__ */ jsx(RunBox, { node, isRoot: true }, node.runId)) });
+};
+var ContinueInputPanel = ({
+  isActive,
+  runStatus,
+  onSubmit
+}) => {
+  const { input, handleInput } = useTextInput({
+    onSubmit: (newQuery) => {
+      if (isActive && newQuery.trim()) {
+        onSubmit(newQuery.trim());
+      }
+    }
+  });
+  useInput(handleInput, { isActive });
+  if (runStatus === "running") {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: runStatus === "completed" ? "green" : "yellow", bold: true, children: runStatus === "completed" ? "Completed" : "Stopped" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: " - Enter a follow-up query or wait to exit" })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Continue: " }),
+      /* @__PURE__ */ jsx(Text, { children: input }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+    ] })
+  ] });
+};
+var StatusPanel = ({
+  runtimeInfo,
+  eventCount,
+  runStatus
+}) => {
+  if (runStatus !== "running") {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(RunSetting, { info: runtimeInfo, eventCount, isEditing: false });
+};
+var useExecutionState = (options) => {
+  const { expertKey, query, config, continueTimeoutMs, historicalEvents, onReady, onComplete } = options;
+  const { exit } = useApp();
+  const runState = useRun();
+  const { runtimeInfo, handleEvent, setQuery } = useRuntimeInfo({
+    initialExpertName: expertKey,
+    initialConfig: config
+  });
+  const [runStatus, setRunStatus] = useState("running");
+  const [isAcceptingContinue, setIsAcceptingContinue] = useState(false);
+  const timeoutRef = useRef(null);
+  const clearTimeoutIfExists = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const startExitTimeout = useCallback(() => {
+    clearTimeoutIfExists();
+    timeoutRef.current = setTimeout(() => {
+      onComplete({ nextQuery: null });
+      exit();
+    }, continueTimeoutMs);
+  }, [clearTimeoutIfExists, continueTimeoutMs, onComplete, exit]);
+  useEffect(() => {
+    setQuery(query);
+  }, [query, setQuery]);
+  useEffect(() => {
+    if (historicalEvents && historicalEvents.length > 0) {
+      runState.appendHistoricalEvents(historicalEvents);
+    }
+  }, [historicalEvents, runState.appendHistoricalEvents]);
+  useEffect(() => {
+    onReady((event) => {
+      runState.addEvent(event);
+      const result = handleEvent(event);
+      if (result?.completed) {
+        setRunStatus("completed");
+        setIsAcceptingContinue(true);
+        startExitTimeout();
+      } else if (result?.stopped) {
+        setRunStatus("stopped");
+        setIsAcceptingContinue(true);
+        startExitTimeout();
+      }
+    });
+  }, [onReady, runState.addEvent, handleEvent, startExitTimeout]);
+  useEffect(() => {
+    return () => {
+      clearTimeoutIfExists();
+    };
+  }, [clearTimeoutIfExists]);
+  const handleContinueSubmit = useCallback(
+    (newQuery) => {
+      if (isAcceptingContinue && newQuery.trim()) {
+        clearTimeoutIfExists();
+        onComplete({ nextQuery: newQuery.trim() });
+        exit();
+      }
+    },
+    [isAcceptingContinue, clearTimeoutIfExists, onComplete, exit]
+  );
+  return {
+    activities: runState.activities,
+    streaming: runState.streaming,
+    eventCount: runState.eventCount,
+    runtimeInfo,
+    runStatus,
+    isAcceptingContinue,
+    handleContinueSubmit,
+    clearTimeout: clearTimeoutIfExists
+  };
+};
+var ExecutionApp = (props) => {
+  const { expertKey, query, config, continueTimeoutMs, historicalEvents, onReady, onComplete } = props;
+  const { exit } = useApp();
+  const state = useExecutionState({
+    expertKey,
+    query,
+    config,
+    continueTimeoutMs,
+    historicalEvents,
+    onReady,
+    onComplete
+  });
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      state.clearTimeout();
+      exit();
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(ActivityLogPanel, { activities: state.activities }),
+    /* @__PURE__ */ jsx(StreamingDisplay, { streaming: state.streaming }),
+    /* @__PURE__ */ jsx(
+      StatusPanel,
+      {
+        runtimeInfo: state.runtimeInfo,
+        eventCount: state.eventCount,
+        runStatus: state.runStatus
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      ContinueInputPanel,
+      {
+        isActive: state.isAcceptingContinue,
+        runStatus: state.runStatus,
+        onSubmit: state.handleContinueSubmit
+      }
+    )
+  ] });
+};
+function renderExecution(params) {
+  const eventQueue = new EventQueue();
+  const result = new Promise((resolve2, reject) => {
+    let resolved = false;
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx(
+        ExecutionApp,
+        {
+          ...params,
+          onReady: (handler) => {
+            eventQueue.setHandler(handler);
+          },
+          onComplete: (result2) => {
+            resolved = true;
+            resolve2(result2);
+          }
+        }
+      )
+    );
+    waitUntilExit().then(() => {
+      if (!resolved) {
+        reject(new Error("Execution cancelled"));
+      }
+    }).catch(reject);
+  });
+  return {
+    result,
+    eventListener: (event) => {
+      eventQueue.emit(event);
+    }
+  };
+}
 function PublishApp({ experts, onSelect }) {
   const { exit } = useApp();
   const handleSelect = (name) => {
@@ -3297,93 +2746,210 @@ async function renderPublish(options) {
     });
   });
 }
-var App = (props) => {
-  const { eventStore, runtimeInfo, inputState, inputAreaContextValue } = useAppState(props);
-  const isBrowsing = inputState.type === "browsingHistory" || inputState.type === "browsingExperts" || inputState.type === "browsingCheckpoints" || inputState.type === "browsingEvents";
-  const isEditing = inputState.type === "enteringQuery";
-  const showRunSetting = isEditing || inputState.type === "running";
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Static, { items: eventStore.logs, style: { flexDirection: "column", gap: 1, paddingBottom: 1 }, children: (entry) => /* @__PURE__ */ jsx(LogEntryRow, { entry }, entry.id) }),
-    eventStore.streamingReasoning && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u25CF Reasoning" }),
-      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "\u2514 ",
-        eventStore.streamingReasoning
-      ] })
-    ] }),
-    eventStore.streamingText && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Text, { color: "green", children: "\u25CF Run Results" }),
-      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "\u2514 ",
-        eventStore.streamingText
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx(InputAreaProvider, { value: inputAreaContextValue, children: isBrowsing && /* @__PURE__ */ jsx(
+var selectionReducer = (_state, action) => {
+  switch (action.type) {
+    case "BROWSE_HISTORY":
+      return { type: "browsingHistory", jobs: action.jobs };
+    case "BROWSE_EXPERTS":
+      return { type: "browsingExperts", experts: action.experts };
+    case "SELECT_EXPERT":
+      return { type: "enteringQuery", expertKey: action.expertKey };
+    case "SELECT_JOB":
+      return { type: "browsingCheckpoints", job: action.job, checkpoints: action.checkpoints };
+    case "GO_BACK_FROM_CHECKPOINTS":
+      return { type: "browsingHistory", jobs: action.jobs };
+    default:
+      return assertNever(action);
+  }
+};
+var SelectionApp = (props) => {
+  const {
+    showHistory,
+    initialExpertKey,
+    initialQuery,
+    initialCheckpoint,
+    configuredExperts,
+    recentExperts,
+    historyJobs,
+    onLoadCheckpoints,
+    onComplete
+  } = props;
+  const { exit } = useApp();
+  const allExperts = useMemo(() => {
+    const configured = configuredExperts.map((e) => ({ ...e, source: "configured" }));
+    const recent = recentExperts.filter((e) => !configured.some((c) => c.key === e.key)).map((e) => ({ ...e, source: "recent" }));
+    return [...configured, ...recent];
+  }, [configuredExperts, recentExperts]);
+  const getInitialState = () => {
+    if (initialExpertKey && !initialQuery) {
+      return { type: "enteringQuery", expertKey: initialExpertKey };
+    }
+    if (showHistory && historyJobs.length > 0) {
+      return { type: "browsingHistory", jobs: historyJobs };
+    }
+    return { type: "browsingExperts", experts: allExperts };
+  };
+  const [state, dispatch] = useReducer(selectionReducer, void 0, getInitialState);
+  const [selectedCheckpoint, setSelectedCheckpoint] = useState(
+    initialCheckpoint
+  );
+  useEffect(() => {
+    if (initialExpertKey && initialQuery) {
+      onComplete({
+        expertKey: initialExpertKey,
+        query: initialQuery,
+        checkpoint: initialCheckpoint
+      });
+      exit();
+    }
+  }, [initialExpertKey, initialQuery, initialCheckpoint, onComplete, exit]);
+  const { input: queryInput, handleInput: handleQueryInput } = useTextInput({
+    onSubmit: (query) => {
+      if (state.type === "enteringQuery" && query.trim()) {
+        onComplete({
+          expertKey: state.expertKey,
+          query: query.trim(),
+          checkpoint: selectedCheckpoint
+        });
+        exit();
+      }
+    }
+  });
+  useInput(handleQueryInput, { isActive: state.type === "enteringQuery" });
+  const handleExpertSelect = useCallback((expertKey) => {
+    dispatch({ type: "SELECT_EXPERT", expertKey });
+  }, []);
+  const handleJobSelect = useCallback(
+    async (job) => {
+      try {
+        const checkpoints = await onLoadCheckpoints(job);
+        dispatch({ type: "SELECT_JOB", job, checkpoints });
+      } catch {
+        dispatch({ type: "SELECT_JOB", job, checkpoints: [] });
+      }
+    },
+    [onLoadCheckpoints]
+  );
+  const handleJobResume = useCallback(
+    async (job) => {
+      try {
+        const checkpoints = await onLoadCheckpoints(job);
+        const latestCheckpoint = checkpoints[0];
+        if (latestCheckpoint) {
+          setSelectedCheckpoint(latestCheckpoint);
+        }
+        dispatch({ type: "SELECT_EXPERT", expertKey: job.expertKey });
+      } catch {
+        dispatch({ type: "SELECT_EXPERT", expertKey: job.expertKey });
+      }
+    },
+    [onLoadCheckpoints]
+  );
+  const handleCheckpointResume = useCallback(
+    (checkpoint) => {
+      setSelectedCheckpoint(checkpoint);
+      if (state.type === "browsingCheckpoints") {
+        dispatch({ type: "SELECT_EXPERT", expertKey: state.job.expertKey });
+      }
+    },
+    [state]
+  );
+  const handleBack = useCallback(() => {
+    if (state.type === "browsingCheckpoints") {
+      dispatch({ type: "GO_BACK_FROM_CHECKPOINTS", jobs: historyJobs });
+    }
+  }, [state, historyJobs]);
+  const handleSwitchToExperts = useCallback(() => {
+    dispatch({ type: "BROWSE_EXPERTS", experts: allExperts });
+  }, [allExperts]);
+  const handleSwitchToHistory = useCallback(() => {
+    dispatch({ type: "BROWSE_HISTORY", jobs: historyJobs });
+  }, [historyJobs]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      exit();
+    }
+  });
+  const contextValue = useMemo(
+    () => ({
+      onExpertSelect: handleExpertSelect,
+      onQuerySubmit: () => {
+      },
+      // Not used in browser
+      onJobSelect: handleJobSelect,
+      onJobResume: handleJobResume,
+      onCheckpointSelect: () => {
+      },
+      // Not used in selection (no event browsing)
+      onCheckpointResume: handleCheckpointResume,
+      onEventSelect: () => {
+      },
+      // Not used in selection
+      onBack: handleBack,
+      onSwitchToExperts: handleSwitchToExperts,
+      onSwitchToHistory: handleSwitchToHistory
+    }),
+    [
+      handleExpertSelect,
+      handleJobSelect,
+      handleJobResume,
+      handleCheckpointResume,
+      handleBack,
+      handleSwitchToExperts,
+      handleSwitchToHistory
+    ]
+  );
+  if (initialExpertKey && initialQuery) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(InputAreaProvider, { value: contextValue, children: (state.type === "browsingHistory" || state.type === "browsingExperts" || state.type === "browsingCheckpoints") && /* @__PURE__ */ jsx(
       BrowserRouter,
       {
-        inputState
+        inputState: state,
+        showEventsHint: false
       }
     ) }),
-    showRunSetting && /* @__PURE__ */ jsx(
-      RunSetting,
-      {
-        info: runtimeInfo,
-        eventCount: eventStore.eventCount,
-        isEditing,
-        expertName: isEditing ? inputState.expertName : void 0,
-        onQuerySubmit: isEditing ? inputAreaContextValue.onQuerySubmit : void 0
-      }
-    )
+    state.type === "enteringQuery" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "Expert:" }),
+        " ",
+        /* @__PURE__ */ jsx(Text, { children: state.expertKey }),
+        selectedCheckpoint && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " (resuming from step ",
+          selectedCheckpoint.stepNumber,
+          ")"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "gray", children: "Query: " }),
+        /* @__PURE__ */ jsx(Text, { children: queryInput }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "_" })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press Enter to start" })
+    ] })
   ] });
 };
-var createEventEmitter = () => {
-  const eventQueue = new EventQueue();
-  return {
-    setHandler: (fn) => eventQueue.setHandler(fn),
-    emit: (event) => eventQueue.emit(event)
-  };
-};
-async function renderStart(options) {
+async function renderSelection(params) {
   return new Promise((resolve2, reject) => {
-    const emitter = createEventEmitter();
     let resolved = false;
     const { waitUntilExit } = render(
       /* @__PURE__ */ jsx(
-        App,
+        SelectionApp,
         {
-          needsQueryInput: options.needsQueryInput,
-          showHistory: options.showHistory,
-          initialExpertName: options.initialExpertName,
-          initialQuery: options.initialQuery,
-          initialConfig: options.initialConfig,
-          configuredExperts: options.configuredExperts,
-          recentExperts: options.recentExperts,
-          historyJobs: options.historyJobs,
-          onComplete: (expertKey, query) => {
+          ...params,
+          onComplete: (result) => {
             resolved = true;
-            resolve2({
-              expertKey,
-              query,
-              eventListener: emitter.emit
-            });
-          },
-          onContinue: options.onContinue,
-          onResumeFromCheckpoint: options.onResumeFromCheckpoint,
-          onLoadCheckpoints: options.onLoadCheckpoints,
-          onLoadEvents: options.onLoadEvents,
-          onLoadHistoricalEvents: options.onLoadHistoricalEvents,
-          onReady: emitter.setHandler
+            resolve2(result);
+          }
         }
       )
     );
     waitUntilExit().then(() => {
       if (!resolved) {
-        reject(new Error("TUI exited without completing selection"));
+        reject(new Error("Selection cancelled"));
       }
-    }).catch((error) => {
-      options.onError?.(error);
-      reject(error);
-    });
+    }).catch(reject);
   });
 }
 function getAvailableStatusTransitions(currentStatus) {
@@ -3509,30 +3075,15 @@ function ConfirmStep({
 }
 function StatusApp({ experts, onFetchVersions, onComplete, onCancel }) {
   const { exit } = useApp();
-  const [step, setStep] = useState({ type: "selectExpert" });
-  const handleExpertSelect = async (expertName) => {
-    setStep({ type: "loadingVersions", expertName });
-    try {
-      const versions = await onFetchVersions(expertName);
-      if (versions.length === 0) {
-        setStep({ type: "error", message: `No versions found for ${expertName}` });
-        return;
-      }
-      setStep({ type: "selectVersion", expertName, versions });
-    } catch (error) {
-      setStep({
-        type: "error",
-        message: error instanceof Error ? error.message : "Failed to fetch versions"
-      });
-    }
-  };
-  const handleVersionSelect = (version) => {
-    setStep({
+  const { step, setStep, handlers, renderBaseStep, isBaseStep: isBaseStep2 } = useExpertVersionWizard({
+    experts,
+    onFetchVersions,
+    customStepFromVersion: (version) => ({
       type: "selectStatus",
       expertKey: version.key,
       currentStatus: version.status
-    });
-  };
+    })
+  });
   const handleStatusSelect = (status) => {
     if (step.type === "selectStatus") {
       setStep({
@@ -3552,81 +3103,54 @@ function StatusApp({ experts, onFetchVersions, onComplete, onCancel }) {
       exit();
     }
   };
-  const handleBack = () => {
-    switch (step.type) {
-      case "selectVersion":
-        setStep({ type: "selectExpert" });
-        break;
+  const handleCustomBack = (currentStep) => {
+    switch (currentStep.type) {
       case "selectStatus":
         setStep({ type: "selectExpert" });
         break;
       case "confirm":
         setStep({
           type: "selectStatus",
-          expertKey: step.expertKey,
-          currentStatus: step.currentStatus
+          expertKey: currentStep.expertKey,
+          currentStatus: currentStep.currentStatus
         });
         break;
-      case "error":
-        setStep({ type: "selectExpert" });
-        break;
       default:
         onCancel();
         exit();
     }
   };
-  switch (step.type) {
-    case "selectExpert":
-      return /* @__PURE__ */ jsx(
-        WizardExpertSelector,
-        {
-          title: "Select an Expert to change status:",
-          experts,
-          onSelect: handleExpertSelect
-        }
-      );
-    case "loadingVersions":
-      return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
-        "Loading versions for ",
-        step.expertName,
-        "..."
-      ] }) });
-    case "selectVersion":
-      return /* @__PURE__ */ jsx(
-        VersionSelector,
-        {
-          expertName: step.expertName,
-          versions: step.versions,
-          onSelect: handleVersionSelect,
-          onBack: handleBack
-        }
-      );
-    case "selectStatus":
-      return /* @__PURE__ */ jsx(
-        StatusSelector,
-        {
-          expertKey: step.expertKey,
-          currentStatus: step.currentStatus,
-          onSelect: handleStatusSelect,
-          onBack: handleBack
-        }
-      );
-    case "confirm":
-      return /* @__PURE__ */ jsx(
-        ConfirmStep,
-        {
-          expertKey: step.expertKey,
-          status: step.status,
-          currentStatus: step.currentStatus,
-          onConfirm: handleConfirm,
-          onBack: handleBack
-        }
-      );
-    case "error":
-      return /* @__PURE__ */ jsx(ErrorStep, { message: step.message, onBack: handleBack });
-    default:
-      return null;
+  const baseStepRender = renderBaseStep({ title: "Select an Expert to change status:" });
+  if (baseStepRender) {
+    return baseStepRender;
+  }
+  if (!isBaseStep2) {
+    const customStep = step;
+    switch (customStep.type) {
+      case "selectStatus":
+        return /* @__PURE__ */ jsx(
+          StatusSelector,
+          {
+            expertKey: customStep.expertKey,
+            currentStatus: customStep.currentStatus,
+            onSelect: handleStatusSelect,
+            onBack: () => handlers.handleBack(handleCustomBack)
+          }
+        );
+      case "confirm":
+        return /* @__PURE__ */ jsx(
+          ConfirmStep,
+          {
+            expertKey: customStep.expertKey,
+            status: customStep.status,
+            currentStatus: customStep.currentStatus,
+            onConfirm: handleConfirm,
+            onBack: () => handlers.handleBack(handleCustomBack)
+          }
+        );
+    }
   }
+  return null;
 }
 async function renderStatus(options) {
   return new Promise((resolve2) => {
@@ -3776,30 +3300,15 @@ function ConfirmStep2({
 }
 function TagApp({ experts, onFetchVersions, onComplete, onCancel }) {
   const { exit } = useApp();
-  const [step, setStep] = useState({ type: "selectExpert" });
-  const handleExpertSelect = async (expertName) => {
-    setStep({ type: "loadingVersions", expertName });
-    try {
-      const versions = await onFetchVersions(expertName);
-      if (versions.length === 0) {
-        setStep({ type: "error", message: `No versions found for ${expertName}` });
-        return;
-      }
-      setStep({ type: "selectVersion", expertName, versions });
-    } catch (error) {
-      setStep({
-        type: "error",
-        message: error instanceof Error ? error.message : "Failed to fetch versions"
-      });
-    }
-  };
-  const handleVersionSelect = (version) => {
-    setStep({
+  const { step, setStep, handlers, renderBaseStep, isBaseStep: isBaseStep2 } = useExpertVersionWizard({
+    experts,
+    onFetchVersions,
+    customStepFromVersion: (version) => ({
       type: "inputTags",
       expertKey: version.key,
       currentTags: version.tags
-    });
-  };
+    })
+  });
   const handleTagsSubmit = (tags) => {
     if (step.type === "inputTags") {
       setStep({
@@ -3819,81 +3328,54 @@ function TagApp({ experts, onFetchVersions, onComplete, onCancel }) {
       exit();
     }
   };
-  const handleBack = () => {
-    switch (step.type) {
-      case "selectVersion":
-        setStep({ type: "selectExpert" });
-        break;
+  const handleCustomBack = (currentStep) => {
+    switch (currentStep.type) {
       case "inputTags":
         setStep({ type: "selectExpert" });
         break;
       case "confirm":
         setStep({
           type: "inputTags",
-          expertKey: step.expertKey,
-          currentTags: step.currentTags
+          expertKey: currentStep.expertKey,
+          currentTags: currentStep.currentTags
         });
         break;
-      case "error":
-        setStep({ type: "selectExpert" });
-        break;
       default:
         onCancel();
         exit();
     }
   };
-  switch (step.type) {
-    case "selectExpert":
-      return /* @__PURE__ */ jsx(
-        WizardExpertSelector,
-        {
-          title: "Select an Expert to tag:",
-          experts,
-          onSelect: handleExpertSelect
-        }
-      );
-    case "loadingVersions":
-      return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
-        "Loading versions for ",
-        step.expertName,
-        "..."
-      ] }) });
-    case "selectVersion":
-      return /* @__PURE__ */ jsx(
-        VersionSelector,
-        {
-          expertName: step.expertName,
-          versions: step.versions,
-          onSelect: handleVersionSelect,
-          onBack: handleBack
-        }
-      );
-    case "inputTags":
-      return /* @__PURE__ */ jsx(
-        TagInput,
-        {
-          expertKey: step.expertKey,
-          currentTags: step.currentTags,
-          onSubmit: handleTagsSubmit,
-          onBack: handleBack
-        }
-      );
-    case "confirm":
-      return /* @__PURE__ */ jsx(
-        ConfirmStep2,
-        {
-          expertKey: step.expertKey,
-          tags: step.tags,
-          currentTags: step.currentTags,
-          onConfirm: handleConfirm,
-          onBack: handleBack
-        }
-      );
-    case "error":
-      return /* @__PURE__ */ jsx(ErrorStep, { message: step.message, onBack: handleBack });
-    default:
-      return null;
+  const baseStepRender = renderBaseStep({ title: "Select an Expert to tag:" });
+  if (baseStepRender) {
+    return baseStepRender;
+  }
+  if (!isBaseStep2) {
+    const customStep = step;
+    switch (customStep.type) {
+      case "inputTags":
+        return /* @__PURE__ */ jsx(
+          TagInput,
+          {
+            expertKey: customStep.expertKey,
+            currentTags: customStep.currentTags,
+            onSubmit: handleTagsSubmit,
+            onBack: () => handlers.handleBack(handleCustomBack)
+          }
+        );
+      case "confirm":
+        return /* @__PURE__ */ jsx(
+          ConfirmStep2,
+          {
+            expertKey: customStep.expertKey,
+            tags: customStep.tags,
+            currentTags: customStep.currentTags,
+            onConfirm: handleConfirm,
+            onBack: () => handlers.handleBack(handleCustomBack)
+          }
+        );
+    }
   }
+  return null;
 }
 async function renderTag(options) {
   return new Promise((resolve2) => {
@@ -3984,94 +3466,50 @@ function UnpublishApp({
   onCancel
 }) {
   const { exit } = useApp();
-  const [step, setStep] = useState({ type: "selectExpert" });
-  const handleExpertSelect = async (expertName) => {
-    setStep({ type: "loadingVersions", expertName });
-    try {
-      const versions = await onFetchVersions(expertName);
-      if (versions.length === 0) {
-        setStep({ type: "error", message: `No versions found for ${expertName}` });
-        return;
-      }
-      setStep({ type: "selectVersion", expertName, versions });
-    } catch (error) {
-      setStep({
-        type: "error",
-        message: error instanceof Error ? error.message : "Failed to fetch versions"
-      });
-    }
-  };
-  const handleVersionSelect = (version) => {
-    setStep({
+  const { step, setStep, handlers, renderBaseStep, isBaseStep: isBaseStep2 } = useExpertVersionWizard({
+    experts,
+    onFetchVersions,
+    customStepFromVersion: (version) => ({
       type: "confirm",
       expertKey: version.key,
       version: version.version
-    });
-  };
+    })
+  });
   const handleConfirm = () => {
     if (step.type === "confirm") {
       onComplete({ expertKey: step.expertKey });
       exit();
     }
   };
-  const handleBack = () => {
-    switch (step.type) {
-      case "selectVersion":
-        setStep({ type: "selectExpert" });
-        break;
+  const handleCustomBack = (currentStep) => {
+    switch (currentStep.type) {
       case "confirm":
         setStep({ type: "selectExpert" });
         break;
-      case "error":
-        setStep({ type: "selectExpert" });
-        break;
       default:
         onCancel();
         exit();
     }
   };
-  switch (step.type) {
-    case "selectExpert":
-      return /* @__PURE__ */ jsx(
-        WizardExpertSelector,
-        {
-          title: "Select an Expert to unpublish:",
-          experts,
-          onSelect: handleExpertSelect
-        }
-      );
-    case "loadingVersions":
-      return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
-        "Loading versions for ",
-        step.expertName,
-        "..."
-      ] }) });
-    case "selectVersion":
-      return /* @__PURE__ */ jsx(
-        VersionSelector,
-        {
-          expertName: step.expertName,
-          versions: step.versions,
-          onSelect: handleVersionSelect,
-          onBack: handleBack,
-          title: `Select a version of ${step.expertName} to unpublish:`
-        }
-      );
-    case "confirm":
-      return /* @__PURE__ */ jsx(
-        ConfirmStep3,
-        {
-          expertKey: step.expertKey,
-          version: step.version,
-          onConfirm: handleConfirm,
-          onBack: handleBack
-        }
-      );
-    case "error":
-      return /* @__PURE__ */ jsx(ErrorStep, { message: step.message, onBack: handleBack });
-    default:
-      return null;
+  const baseStepRender = renderBaseStep({
+    title: "Select an Expert to unpublish:",
+    versionSelectorTitle: `Select a version to unpublish:`
+  });
+  if (baseStepRender) {
+    return baseStepRender;
+  }
+  if (!isBaseStep2 && step.type === "confirm") {
+    return /* @__PURE__ */ jsx(
+      ConfirmStep3,
+      {
+        expertKey: step.expertKey,
+        version: step.version,
+        onConfirm: handleConfirm,
+        onBack: () => handlers.handleBack(handleCustomBack)
+      }
+    );
   }
+  return null;
 }
 async function renderUnpublish(options) {
   return new Promise((resolve2) => {
@@ -4337,6 +3775,9 @@ function getMostRecentRun() {
   }
   return runs[0];
 }
+function getRunsByJobId(jobId) {
+  return getAllRuns2().filter((r) => r.jobId === jobId);
+}
 function getCheckpointsByJobId2(jobId) {
   return getCheckpointsByJobId(jobId);
 }
@@ -4379,18 +3820,18 @@ function getCheckpointsWithDetails(jobId) {
     contextWindowUsage: cp.contextWindowUsage ?? 0
   })).sort((a, b) => b.stepNumber - a.stepNumber);
 }
-function getEventsWithDetails(jobId, runId, stepNumber) {
-  return getEventsByRun(jobId, runId).map((e) => ({
-    id: `${e.timestamp}-${e.stepNumber}-${e.type}`,
-    runId,
-    stepNumber: e.stepNumber,
-    type: e.type,
-    timestamp: e.timestamp
-  })).filter((event) => stepNumber === void 0 || event.stepNumber === stepNumber).sort((a, b) => a.timestamp - b.timestamp);
-}
 function getEventContents2(jobId, runId, maxStepNumber) {
   return getEventContents(jobId, runId, maxStepNumber);
 }
+function getAllEventContentsForJob(jobId, maxStepNumber) {
+  const runs = getRunsByJobId(jobId);
+  const allEvents = [];
+  for (const run of runs) {
+    const events = getEventContents(jobId, run.runId, maxStepNumber);
+    allEvents.push(...events);
+  }
+  return allEvents.sort((a, b) => a.timestamp - b.timestamp);
+}
 
 // src/lib/context.ts
 var defaultProvider = "anthropic";
@@ -4402,11 +3843,11 @@ async function resolveRunContext(input) {
     if (!input.continueJob) {
       throw new Error("--resume-from requires --continue-job");
     }
-    checkpoint = await getCheckpointById(input.continueJob, input.resumeFrom);
+    checkpoint = getCheckpointById(input.continueJob, input.resumeFrom);
   } else if (input.continueJob) {
-    checkpoint = await getMostRecentCheckpoint(input.continueJob);
+    checkpoint = getMostRecentCheckpoint(input.continueJob);
   } else if (input.continue) {
-    checkpoint = await getMostRecentCheckpoint();
+    checkpoint = getMostRecentCheckpoint();
   }
   if ((input.continue || input.continueJob || input.resumeFrom) && !checkpoint) {
     throw new Error("No checkpoint found");
@@ -6357,9 +5798,6 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
             const text = content.text?.trim();
             if (text && text !== state.lastStreamingText) {
               state.lastStreamingText = text;
-              const event = createStreamingTextEvent(jobId, runId, text);
-              state.events.push(event);
-              eventListener?.(event);
             }
           } else if (content.type === "tool_use") {
             const toolCall = {
@@ -6433,11 +5871,7 @@ var ClaudeCodeAdapter = class extends BaseAdapter {
     } else if (parsed.type === "content_block_delta" && parsed.delta) {
       const delta = parsed.delta;
       const text = delta.text?.trim();
-      if (delta.type === "text_delta" && text) {
-        const event = createStreamingTextEvent(jobId, runId, text);
-        state.events.push(event);
-        eventListener?.(event);
-      }
+      if (delta.type === "text_delta" && text) ;
     }
   }
 };
@@ -6646,9 +6080,6 @@ ${query}`;
           const text = content.text?.trim();
           if (content.type === "text" && text && text !== state.lastStreamingText) {
             state.lastStreamingText = text;
-            const event = createStreamingTextEvent(jobId, runId, text);
-            state.events.push(event);
-            eventListener?.(event);
           }
         }
       }
@@ -7040,10 +6471,16 @@ function validateWorkspacePath(path11) {
   }
 }
 function generateComposeFile(options) {
-  const { proxyEnabled, networkName, envKeys, workspacePath } = options;
+  const { proxyEnabled, networkName, envKeys, workspacePath, additionalVolumes } = options;
   if (workspacePath) {
     validateWorkspacePath(workspacePath);
   }
+  for (const volume of additionalVolumes ?? []) {
+    const hostPath = volume.split(":")[0];
+    if (hostPath) {
+      validateWorkspacePath(hostPath);
+    }
+  }
   const internalNetworkName = `${networkName}-internal`;
   const lines = [];
   lines.push("services:");
@@ -7066,9 +6503,15 @@ function generateComposeFile(options) {
       lines.push(`      - ${key}`);
     }
   }
-  if (workspacePath) {
+  const hasVolumes = workspacePath || additionalVolumes && additionalVolumes.length > 0;
+  if (hasVolumes) {
     lines.push("    volumes:");
-    lines.push(`      - ${workspacePath}:/workspace:rw`);
+    if (workspacePath) {
+      lines.push(`      - ${workspacePath}:/workspace:rw`);
+    }
+    for (const volume of additionalVolumes ?? []) {
+      lines.push(`      - ${volume}`);
+    }
   }
   lines.push("    stdin_open: true");
   lines.push("    tty: true");
@@ -7119,7 +6562,12 @@ function generateComposeFile(options) {
   return lines.join("\n");
 }
 function generateBuildContext(config, expertKey, options) {
-  const { workspacePath, verbose, additionalEnvKeys } = typeof options === "string" || options === void 0 ? { workspacePath: options, verbose: false, additionalEnvKeys: [] } : { additionalEnvKeys: [], ...options };
+  const { workspacePath, verbose, additionalEnvKeys, additionalVolumes } = typeof options === "string" || options === void 0 ? {
+    workspacePath: options,
+    verbose: false,
+    additionalEnvKeys: [],
+    additionalVolumes: []
+  } : { additionalEnvKeys: [], additionalVolumes: [], ...options };
   const allowedDomains = collectAllowedDomains(config, expertKey);
   const hasAllowlist = allowedDomains.length > 0;
   const dockerfile = generateDockerfile(config, expertKey, { proxyEnabled: hasAllowlist });
@@ -7143,7 +6591,8 @@ function generateBuildContext(config, expertKey, options) {
     proxyEnabled: hasAllowlist,
     networkName: "perstack-net",
     envKeys: allEnvKeys,
-    workspacePath: resolvedWorkspacePath
+    workspacePath: resolvedWorkspacePath,
+    additionalVolumes
   });
   return {
     dockerfile,
@@ -7437,7 +6886,7 @@ var DockerAdapter = class extends BaseAdapter {
     return { instruction: expert.instruction };
   }
   async run(params) {
-    const { setting, config, eventListener, workspace, additionalEnvKeys } = params;
+    const { setting, config, eventListener, workspace, additionalEnvKeys, additionalVolumes } = params;
     if (!config) {
       throw new Error("DockerAdapter requires config in AdapterRunParams");
     }
@@ -7452,7 +6901,8 @@ var DockerAdapter = class extends BaseAdapter {
       expertKey,
       resolvedWorkspace,
       setting.verbose,
-      additionalEnvKeys
+      additionalEnvKeys,
+      additionalVolumes
     );
     let signalReceived = false;
     const signalHandler = async (signal) => {
@@ -7538,12 +6988,13 @@ var DockerAdapter = class extends BaseAdapter {
     }
     return resolved;
   }
-  async prepareBuildContext(config, expertKey, workspace, verbose, additionalEnvKeys) {
+  async prepareBuildContext(config, expertKey, workspace, verbose, additionalEnvKeys, additionalVolumes) {
     const buildDir = fs.mkdtempSync(path10.join(os.tmpdir(), "perstack-docker-"));
     const context = generateBuildContext(config, expertKey, {
       workspacePath: workspace,
       verbose,
-      additionalEnvKeys
+      additionalEnvKeys,
+      additionalVolumes
     });
     fs.writeFileSync(path10.join(buildDir, "Dockerfile"), context.dockerfile);
     fs.writeFileSync(path10.join(buildDir, "perstack.toml"), context.configToml);
@@ -7910,9 +7361,6 @@ ${query}`;
         state.finalOutput = state.accumulatedText;
         if (content !== state.lastStreamingText) {
           state.lastStreamingText = content;
-          const event = createStreamingTextEvent(jobId, runId, state.accumulatedText);
-          state.events.push(event);
-          eventListener?.(event);
         }
       }
     } else if (parsed.type === "tool_use") {
@@ -8004,12 +7452,14 @@ async function dispatchToRuntime(params) {
     storeEvent,
     retrieveCheckpoint,
     workspace,
-    additionalEnvKeys
+    additionalEnvKeys,
+    additionalVolumes
   } = params;
   const setting = {
     ...params.setting,
     jobId: params.setting.jobId ?? createId(),
-    runId: params.setting.runId ?? createId()
+    runId: createId()
+    // runId is always generated internally, never from external input
   };
   if (!isAdapterAvailable(runtime)) {
     const available = getRegisteredRuntimes().join(", ");
@@ -8035,7 +7485,8 @@ See: ${error.helpUrl}`;
     storeEvent: storeEvent ?? defaultStoreEvent,
     retrieveCheckpoint: retrieveCheckpoint ?? defaultRetrieveCheckpoint,
     workspace,
-    additionalEnvKeys
+    additionalEnvKeys,
+    additionalVolumes
   });
   return { checkpoint: result.checkpoint };
 }
@@ -8068,7 +7519,7 @@ var runCommand = new Command().command("run").description("Run Perstack with JSO
 ).option("--max-retries <maxRetries>", "Maximum number of generation retries, default is 5").option(
   "--timeout <timeout>",
   "Timeout for each generation in milliseconds, default is 60000 (1 minute)"
-).option("--job-id <jobId>", "Job ID for identifying the job").option("--run-id <runId>", "Run ID for identifying the run").option(
+).option("--job-id <jobId>", "Job ID for identifying the job").option(
   "--env-path <path>",
   "Path to the environment file (can be specified multiple times), default is .env and .env.local",
   (value, previous) => previous.concat(value),
@@ -8081,8 +7532,31 @@ var runCommand = new Command().command("run").description("Run Perstack with JSO
 ).option("--verbose", "Enable verbose logging").option("--continue", "Continue the most recent job with new query").option("--continue-job <jobId>", "Continue the specified job with new query").option(
   "--resume-from <checkpointId>",
   "Resume from a specific checkpoint (requires --continue or --continue-job)"
-).option("-i, --interactive-tool-call-result", "Query is interactive tool call result").option("--runtime <runtime>", "Execution runtime (docker, local, cursor, claude-code, gemini)").option("--workspace <workspace>", "Workspace directory for Docker runtime").action(async (expertKey, query, options) => {
+).option("-i, --interactive-tool-call-result", "Query is interactive tool call result").option("--runtime <runtime>", "Execution runtime (docker, local, cursor, claude-code, gemini)").option("--workspace <workspace>", "Workspace directory for Docker runtime").option(
+  "--volume <volume>",
+  "Additional volume mount for Docker runtime (format: hostPath:containerPath:mode, can be specified multiple times)",
+  (value, previous) => previous.concat(value),
+  []
+).option(
+  "--filter <types>",
+  "Filter events by type (comma-separated, e.g., completeRun,stopRunByError)"
+).action(async (expertKey, query, options) => {
   const input = parseWithFriendlyError(runCommandInputSchema, { expertKey, query, options });
+  let eventListener = defaultEventListener;
+  if (input.options.filter && input.options.filter.length > 0) {
+    try {
+      const validatedTypes = validateEventFilter(input.options.filter);
+      const allowedTypes = new Set(validatedTypes);
+      eventListener = createFilteredEventListener(defaultEventListener, allowedTypes);
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(error.message);
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  }
   try {
     const { perstackConfig, checkpoint, env, providerConfig, model, experts } = await resolveRunContext({
       configPath: input.options.config,
@@ -8098,7 +7572,6 @@ var runCommand = new Command().command("run").description("Run Perstack with JSO
     await dispatchToRuntime({
       setting: {
         jobId: checkpoint?.jobId ?? input.options.jobId,
-        runId: checkpoint?.runId ?? input.options.runId,
         expertKey: input.expertKey,
         input: input.options.interactiveToolCallResult ? parseInteractiveToolCallResultJson(input.query) ?? (checkpoint ? parseInteractiveToolCallResult(input.query, checkpoint) : { text: input.query }) : { text: input.query },
         experts,
@@ -8118,9 +7591,10 @@ var runCommand = new Command().command("run").description("Run Perstack with JSO
       checkpoint,
       runtime,
       config: perstackConfig,
-      eventListener: defaultEventListener,
+      eventListener,
       workspace: input.options.workspace,
-      additionalEnvKeys: input.options.env
+      additionalEnvKeys: input.options.env,
+      additionalVolumes: input.options.volume
     });
   } catch (error) {
     if (error instanceof Error) {
@@ -8141,7 +7615,7 @@ var startCommand = new Command().command("start").description("Start Perstack wi
 ).option("--max-retries <maxRetries>", "Maximum number of generation retries, default is 5").option(
   "--timeout <timeout>",
   "Timeout for each generation in milliseconds, default is 60000 (1 minute)"
-).option("--job-id <jobId>", "Job ID for identifying the job").option("--run-id <runId>", "Run ID for identifying the run").option(
+).option("--job-id <jobId>", "Job ID for identifying the job").option(
   "--env-path <path>",
   "Path to the environment file (can be specified multiple times), default is .env and .env.local",
   (value, previous) => previous.concat(value),
@@ -8168,14 +7642,16 @@ var startCommand = new Command().command("start").description("Start Perstack wi
       expertKey: input.expertKey
     });
     const runtime = input.options.runtime ?? perstackConfig.runtime ?? "docker";
-    const showHistory = !input.expertKey && !input.query && !checkpoint;
-    const needsQueryInput = !input.query && !checkpoint;
+    const maxSteps = input.options.maxSteps ?? perstackConfig.maxSteps;
+    const maxRetries = input.options.maxRetries ?? perstackConfig.maxRetries ?? defaultMaxRetries;
+    const timeout = input.options.timeout ?? perstackConfig.timeout ?? defaultTimeout;
     const configuredExperts = Object.keys(perstackConfig.experts ?? {}).map((key) => ({
       key,
       name: key
     }));
-    const recentExperts = await getRecentExperts(10);
-    const historyJobs = showHistory ? (await getAllJobs2()).map((j) => ({
+    const recentExperts = getRecentExperts(10);
+    const showHistory = !input.expertKey && !input.query && !checkpoint;
+    const historyJobs = showHistory ? getAllJobs2().map((j) => ({
       jobId: j.id,
       status: j.status,
       expertKey: j.coordinatorExpertKey,
@@ -8183,75 +7659,65 @@ var startCommand = new Command().command("start").description("Start Perstack wi
       startedAt: j.startedAt,
       finishedAt: j.finishedAt
     })) : [];
-    const resumeState = { checkpoint: null };
-    let resolveContinueQuery = null;
-    const maxSteps = input.options.maxSteps ?? perstackConfig.maxSteps;
-    const maxRetries = input.options.maxRetries ?? perstackConfig.maxRetries ?? defaultMaxRetries;
-    const timeout = input.options.timeout ?? perstackConfig.timeout ?? defaultTimeout;
-    const result = await renderStart({
+    const selection = await renderSelection({
       showHistory,
-      needsQueryInput,
-      initialExpertName: input.expertKey,
+      initialExpertKey: input.expertKey,
       initialQuery: input.query,
-      initialConfig: {
-        runtimeVersion: getRuntimeVersion(),
-        model,
-        maxSteps,
-        maxRetries,
-        timeout,
-        contextWindowUsage: checkpoint?.contextWindowUsage ?? 0,
-        runtime
-      },
+      initialCheckpoint: checkpoint ? {
+        id: checkpoint.id,
+        jobId: checkpoint.jobId,
+        runId: checkpoint.runId,
+        stepNumber: checkpoint.stepNumber,
+        contextWindowUsage: checkpoint.contextWindowUsage ?? 0
+      } : void 0,
       configuredExperts,
       recentExperts,
       historyJobs,
-      onContinue: (query2) => {
-        if (resolveContinueQuery) {
-          resolveContinueQuery(query2);
-          resolveContinueQuery = null;
-        }
-      },
-      onResumeFromCheckpoint: (cp) => {
-        resumeState.checkpoint = cp;
-      },
       onLoadCheckpoints: async (j) => {
-        const checkpoints = await getCheckpointsWithDetails(j.jobId);
+        const checkpoints = getCheckpointsWithDetails(j.jobId);
         return checkpoints.map((cp) => ({ ...cp, jobId: j.jobId }));
-      },
-      onLoadEvents: async (j, cp) => {
-        const events = await getEventsWithDetails(j.jobId, cp.runId, cp.stepNumber);
-        return events.map((e) => ({ ...e, jobId: j.jobId }));
-      },
-      onLoadHistoricalEvents: async (cp) => {
-        return await getEventContents2(cp.jobId, cp.runId, cp.stepNumber);
       }
     });
-    const finalExpertKey = result.expertKey || input.expertKey;
-    let finalQuery = result.query || input.query;
-    if (!finalExpertKey) {
+    if (!selection.expertKey) {
       console.error("Expert key is required");
       return;
     }
-    let currentCheckpoint = resumeState.checkpoint !== null ? await getCheckpointById(resumeState.checkpoint.jobId, resumeState.checkpoint.id) : checkpoint;
-    if (currentCheckpoint && currentCheckpoint.expert.key !== finalExpertKey) {
-      console.error(
-        `Checkpoint expert key ${currentCheckpoint.expert.key} does not match input expert key ${finalExpertKey}`
-      );
+    if (!selection.query && !selection.checkpoint) {
+      console.error("Query is required");
       return;
     }
-    if (!finalQuery && !currentCheckpoint) {
-      console.error("Query is required");
+    let currentCheckpoint = selection.checkpoint ? getCheckpointById(selection.checkpoint.jobId, selection.checkpoint.id) : checkpoint;
+    if (currentCheckpoint && currentCheckpoint.expert.key !== selection.expertKey) {
+      console.error(
+        `Checkpoint expert key ${currentCheckpoint.expert.key} does not match input expert key ${selection.expertKey}`
+      );
       return;
     }
+    let currentQuery = selection.query;
     let currentJobId = currentCheckpoint?.jobId ?? input.options.jobId;
-    let currentRunId = currentCheckpoint?.runId ?? input.options.runId;
-    while (true) {
+    let accumulatedEvents = currentCheckpoint ? getAllEventContentsForJob(currentCheckpoint.jobId, currentCheckpoint.stepNumber) : void 0;
+    while (currentQuery !== null) {
+      const historicalEvents = accumulatedEvents;
+      const { result: executionResult, eventListener } = renderExecution({
+        expertKey: selection.expertKey,
+        query: currentQuery,
+        config: {
+          runtimeVersion: getRuntimeVersion(),
+          model,
+          maxSteps,
+          maxRetries,
+          timeout,
+          contextWindowUsage: currentCheckpoint?.contextWindowUsage ?? 0,
+          runtime
+        },
+        continueTimeoutMs: CONTINUE_TIMEOUT_MS,
+        historicalEvents
+      });
       const { checkpoint: runResult } = await dispatchToRuntime({
         setting: {
           jobId: currentJobId,
-          runId: currentRunId,
-          expertKey: finalExpertKey,
-          input: input.options.interactiveToolCallResult && currentCheckpoint ? parseInteractiveToolCallResult(finalQuery || "", currentCheckpoint) : { text: finalQuery },
+          expertKey: selection.expertKey,
+          input: input.options.interactiveToolCallResult && currentCheckpoint ? parseInteractiveToolCallResult(currentQuery, currentCheckpoint) : { text: currentQuery },
           experts,
           model,
           providerConfig,
@@ -8268,30 +7734,23 @@ var startCommand = new Command().command("start").description("Start Perstack wi
         checkpoint: currentCheckpoint,
         runtime,
         config: perstackConfig,
-        eventListener: result.eventListener,
+        eventListener,
         workspace: input.options.workspace,
         additionalEnvKeys: input.options.env
       });
-      if (runResult.status === "completed" || runResult.status === "stoppedByExceededMaxSteps" || runResult.status === "stoppedByError") {
-        const nextQuery = await new Promise((resolve2) => {
-          resolveContinueQuery = resolve2;
-          setTimeout(() => {
-            if (resolveContinueQuery === resolve2) {
-              resolveContinueQuery = null;
-              resolve2(null);
-            }
-          }, CONTINUE_TIMEOUT_MS);
-        });
-        if (nextQuery) {
-          finalQuery = nextQuery;
-          currentCheckpoint = runResult;
-          currentJobId = runResult.jobId;
-          currentRunId = runResult.runId;
+      const result = await executionResult;
+      if (result.nextQuery && (runResult.status === "completed" || runResult.status === "stoppedByExceededMaxSteps" || runResult.status === "stoppedByError")) {
+        currentQuery = result.nextQuery;
+        currentCheckpoint = runResult;
+        currentJobId = runResult.jobId;
+        const newRunEvents = getEventContents2(runResult.jobId, runResult.runId);
+        if (accumulatedEvents) {
+          accumulatedEvents = [...accumulatedEvents, ...newRunEvents];
         } else {
-          break;
+          accumulatedEvents = newRunEvents;
         }
       } else {
-        break;
+        currentQuery = null;
       }
     }
   } catch (error) {