@within-7/minto 0.4.0 → 0.4.2

package/dist/screens/REPL.js

@@ -9,8 +9,11 @@ import { Logo } from "../components/Logo.js";
 import { Message } from "../components/Message.js";
 import { MessageResponse } from "../components/MessageResponse.js";
 import { BashStreamingProgress } from "../components/BashStreamingProgress.js";
+import { StreamingTextPreview } from "../components/StreamingTextPreview.js";
 import { MessageSelector } from "../components/MessageSelector.js";
-import { MessageBatchBuffer } from "../utils/MessageBatchBuffer.js";
+import {
+  RewindPanel
+} from "../components/RewindPanel.js";
 import {
   PermissionRequest
 } from "../components/permissions/PermissionRequest.js";
@@ -27,6 +30,7 @@ import { overwriteLog } from "../utils/log.js";
 import { PermissionProvider } from "../context/PermissionContext.js";
 import { useFullscreenExitCallback } from "../hooks/useTerminalSize.js";
 import { TodoPanel } from "../components/TodoPanel.js";
+import { ThinkingSelector } from "../components/ThinkingSelector.js";
 import { TurnCompletionIndicator } from "../components/TurnCompletionIndicator.js";
 import { getTodos, initTodoSession } from "../utils/todoStorage.js";
 import {
@@ -35,24 +39,11 @@ import {
   setModelConfigChangeHandler,
   setLanguageChangeHandler
 } from "../messages.js";
-import {
-  query
-} from "../query.js";
-import {
-  getGlobalConfig,
-  saveGlobalConfig,
-  getVerboseLabel
-} from "../utils/config.js";
-import { loadMessagesFromLog } from "../utils/conversationRecovery.js";
+import { getGlobalConfig, saveGlobalConfig } from "../utils/config.js";
 import { useBackgroundShells } from "../hooks/useBackgroundShells.js";
 import { useDeferredLoading } from "../hooks/useDeferredLoading.js";
 import { useSessionTracking } from "../hooks/useSessionTracking.js";
-import { emitReminderEvent } from "../services/systemReminder.js";
-import {
-  getNextAvailableLogForkNumber,
-  loadLogList,
-  CACHE_PATHS
-} from "../utils/log.js";
+import { getNextAvailableLogForkNumber } from "../utils/log.js";
 import {
   getErroredToolUseMessages,
   getInProgressToolUseIDs,
@@ -64,22 +55,26 @@ import {
   normalizeMessages,
   normalizeMessagesForAPI,
   processUserInput,
-  reorderMessages,
-  createAssistantAPIErrorMessage
+  reorderMessages
 } from "../utils/messages.js";
 import { logError } from "../utils/log.js";
-import { ModelManager } from "../utils/model.js";
-import { clearTerminal } from "../utils/terminal.js";
+import {
+  clearTerminal,
+  clearScreen
+} from "../utils/terminal.js";
 import { BinaryFeedback } from "../components/binary-feedback/BinaryFeedback.js";
 import { getMaxThinkingTokens } from "../utils/thinking.js";
 import { getOriginalCwd } from "../utils/state.js";
+import { animationManager } from "../utils/animationManager.js";
 import { handleHashCommand } from "../commands/terminalSetup.js";
-import { randomUUID } from "crypto";
 import { getMessagesPath } from "../utils/log.js";
-import {
-  BackgroundShellManager
-} from "../utils/BackgroundShellManager.js";
+import { BackgroundShellManager } from "../utils/BackgroundShellManager.js";
 import { BackgroundTasksPanel } from "../components/BackgroundTasksPanel.js";
+import { TeamMemberPanel } from "../components/TeamMemberPanel.js";
+import { AgentViewBanner } from "../components/AgentViewBanner.js";
+import { TitledDivider } from "../components/TitledDivider.js";
+import { t } from "../i18n/index.js";
+import { IdleNotificationBar } from "../components/IdleNotificationBar.js";
 import { AskUserQuestionDialog } from "../components/AskUserQuestionDialog/AskUserQuestionDialog.js";
 import {
   getToolUseIdByAgentId,
@@ -90,13 +85,24 @@ import { useMessageGroups } from "../hooks/useMessageGroups.js";
 import { useAgentTranscripts } from "../hooks/useAgentTranscripts.js";
 import { GroupRenderer } from "../components/messages/GroupRenderer.js";
 import { SEMANTIC_COLORS } from "../constants/colors.js";
+import { useIdleNotifications } from "../hooks/useIdleNotifications.js";
+import { useTeamMembers } from "../hooks/useTeamMembers.js";
 import {
   recordFirstPrompt,
   incrementMessageCount,
-  incrementToolCallCount,
   flushSessionStats
 } from "../utils/sessionTracker.js";
+import {
+  getActiveTeams,
+  disbandTeam,
+  formatUserGuidanceForInjection,
+  teamEvents
+} from "../services/agentTeams/index.js";
+import { AgentEngine } from "../engine/AgentEngine.js";
+import { EngineRegistry, setGlobalRegistry } from "../engine/EngineRegistry.js";
+import { useAgentEngine } from "../hooks/useAgentEngine.js";
 const RESUME_VISIBLE_MESSAGE_COUNT = Infinity;
+const TRANSCRIPT_VISIBLE_COUNT = 10;
 function REPL({
   commands,
   safeMode,
@@ -115,36 +121,83 @@ function REPL({
   initialUpdateCommands,
   fallbackMode = false,
   isResumedConversation = false,
-  enableArchitect,
-  autoResume = false
+  enableArchitect
 }) {
-  const [verbose, setVerbose] = useState(
-    verboseFromCLI === true ? true : false
+  const [screen, setScreen] = useState(
+    verboseFromCLI === true ? "transcript" : "prompt"
   );
+  const [showAllInTranscript, setShowAllInTranscript] = useState(false);
+  const verbose = screen === "transcript";
   const [forkNumber, setForkNumber] = useState(
     getNextAvailableLogForkNumber(messageLogName, initialForkNumber, 0)
   );
   const [isResizeClearing, setIsResizeClearing] = useState(false);
-  const { exit: unmountREPL } = useApp();
-  useFullscreenExitCallback(async () => {
+  const safeRefork = useCallback(async (beforeRefork) => {
     setIsResizeClearing(true);
     await new Promise((resolve) => setTimeout(resolve, 50));
     await clearTerminal();
+    beforeRefork?.();
     setForkNumber((prev) => prev + 1);
     setIsResizeClearing(false);
-  });
+  }, []);
+  const { exit: unmountREPL } = useApp();
+  useFullscreenExitCallback(() => safeRefork());
+  useEffect(() => {
+    const unsubscribe = animationManager.onResume(() => safeRefork());
+    return unsubscribe;
+  }, [safeRefork]);
+  useEffect(() => {
+    const handler = () => safeRefork();
+    process.on("SIGCONT", handler);
+    return () => {
+      process.off("SIGCONT", handler);
+    };
+  }, [safeRefork]);
   const [
     forkConvoWithMessagesOnTheNextRender,
     setForkConvoWithMessagesOnTheNextRender
   ] = useState(null);
-  const [abortController, setAbortController] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
+  const defaultEngine = useMemo(() => {
+    const engine = new AgentEngine({
+      agentId: "default",
+      name: "default",
+      role: "default",
+      systemPrompt: () => getSystemPrompt(),
+      context: () => getContext(),
+      tools,
+      commands,
+      initialMessages: initialMessages ?? [],
+      verbose: verboseFromCLI === true,
+      safeMode,
+      safetyMode,
+      messageLogName,
+      forkNumber: getNextAvailableLogForkNumber(
+        messageLogName,
+        initialForkNumber,
+        0
+      )
+    });
+    return engine;
+  }, []);
+  const registry = useMemo(() => {
+    const r = new EngineRegistry();
+    r.register("default", defaultEngine);
+    setGlobalRegistry(r);
+    return r;
+  }, [defaultEngine]);
+  const {
+    messages,
+    isLoading,
+    lastTurnDurationMs,
+    submitPrompt: engineSubmitPrompt,
+    abort: engineAbort,
+    setMessages: engineSetMessages,
+    appendMessages: engineAppendMessages
+  } = useAgentEngine(registry.focused ?? null);
   const [toolJSX, setToolJSX] = useState(null);
   const [toolUseConfirm, setToolUseConfirm] = useState(
     null
   );
-  const [messages, setMessages] = useState(initialMessages ?? []);
-  const messagesRef = useRef(initialMessages ?? []);
   const [messageHistory, setMessageHistory] = useState([]);
   const [inputValue, setInputValue] = useState("");
   const [inputMode, setInputMode] = useState(
@@ -152,6 +205,7 @@ function REPL({
   );
   const [submitCount, setSubmitCount] = useState(0);
   const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
+  const [isRewindPanelVisible, setIsRewindPanelVisible] = useState(false);
   const [showCostDialog, setShowCostDialog] = useState(false);
   const [haveShownCostDialog, setHaveShownCostDialog] = useState(
     getGlobalConfig().hasAcknowledgedCostThreshold
@@ -174,54 +228,51 @@ function REPL({
     enableArchitect
   });
   const [isTodoPanelVisible, setIsTodoPanelVisible] = useState(true);
-  const [verboseToggleMessage, setVerboseToggleMessage] = useState(null);
-  const turnStartTimeRef = useRef(null);
-  const [lastTurnDurationMs, setLastTurnDurationMs] = useState(
-    null
-  );
-  const [queuedPrompts, setQueuedPrompts] = useState([]);
-  const queuedPromptsRef = useRef([]);
-  useEffect(() => {
-    queuedPromptsRef.current = queuedPrompts;
-  }, [queuedPrompts]);
-  useEffect(() => {
-    if (isLoading) {
-      turnStartTimeRef.current = Date.now();
-      setLastTurnDurationMs(null);
-    } else if (turnStartTimeRef.current !== null) {
-      const duration = Date.now() - turnStartTimeRef.current;
-      setLastTurnDurationMs(duration);
-      turnStartTimeRef.current = null;
-    }
-  }, [isLoading]);
+  const [showThinkingSelector, setShowThinkingSelector] = useState(false);
   const {
     shells: backgroundShells,
     isPanelVisible: showBackgroundPanel,
     setIsPanelVisible: setShowBackgroundPanel,
     runningCount: backgroundShellRunningCount
   } = useBackgroundShells();
-  const prevUnresolvedRef = useRef(/* @__PURE__ */ new Set());
-  const messageBatchBufferRef = useRef(null);
-  if (messageBatchBufferRef.current === null) {
-    messageBatchBufferRef.current = new MessageBatchBuffer(
-      (batchedMessages) => {
-        setMessages((prev) => [...prev, ...batchedMessages]);
-      },
-      {
-        flushInterval: 100,
-        // Batch messages for 100ms
-        maxBatchSize: 50,
-        // Force flush if 50+ messages buffered
-        debug: false
-        // Set to true for debugging
+  const [showTeamPanel, setShowTeamPanel] = useState(false);
+  const [currentViewAgent, setCurrentViewAgent] = useState(null);
+  const { notifications: idleNotifications } = useIdleNotifications();
+  const { members: teamMembers, teamName, hasActiveTeam } = useTeamMembers();
+  useEffect(() => {
+    if (!hasActiveTeam) {
+      setShowTeamPanel(false);
+      setToolJSX(null);
+      setToolUseConfirm(null);
+      if (currentViewAgent) {
+        setIsResizeClearing(true);
+        clearScreen();
+        registry.setFocus("default");
+        setCurrentViewAgent(null);
+        setForkNumber((prev) => prev + 1);
+        setImmediate(() => setIsResizeClearing(false));
       }
-    );
-  }
+      defaultEngine.updateConfig({
+        systemPrompt: () => getSystemPrompt()
+      });
+      defaultEngine.demoteFromTeamLead();
+    }
+  }, [hasActiveTeam]);
   useEffect(() => {
-    return () => {
-      messageBatchBufferRef.current?.dispose();
-    };
-  }, []);
+    const unsub = registry.onChange(() => {
+      if (isSwitchingViewRef.current) return;
+      if (registry.focusedId === "default" && currentViewAgent) {
+        setIsResizeClearing(true);
+        clearScreen();
+        setCurrentViewAgent(null);
+        setForkNumber((prev) => prev + 1);
+        setImmediate(() => setIsResizeClearing(false));
+      }
+    });
+    return unsub;
+  }, [registry, currentViewAgent]);
+  const prevUnresolvedRef = useRef(/* @__PURE__ */ new Set());
+  const isSwitchingViewRef = useRef(false);
   const getBinaryFeedbackResponse = useCallback(
     (m1, m2) => {
       return new Promise((resolvePromise) => {
@@ -236,13 +287,15 @@ function REPL({
   );
   const readFileTimestamps = useRef({});
   const { status: apiKeyStatus, reverify } = useApiKeyVerification();
-  function onInterrupt() {
+  const onInterrupt = useCallback(() => {
     if (!isLoading) {
       return;
     }
-    const currentMessages = messagesRef.current;
-    if (currentMessages.length > 0) {
-      const serializedMessages = currentMessages.map(serializeMessageForLog);
+    const currentMessages = registry.focused?.messages;
+    if (currentMessages && currentMessages.length > 0) {
+      const serializedMessages = [...currentMessages].map(
+        serializeMessageForLog
+      );
       overwriteLog(
         getMessagesPath(messageLogName, forkNumber, 0),
         serializedMessages
@@ -251,23 +304,29 @@ function REPL({
     setToolJSX(null);
     setToolUseConfirm(null);
     setBinaryFeedbackContext(null);
-    setIsLoading(false);
     if (toolUseConfirm) {
       toolUseConfirm.onAbort();
-    } else if (abortController && !abortController.signal.aborted) {
-      abortController.abort();
+    } else {
+      engineAbort();
     }
-  }
-  function onCancel() {
+  }, [
+    isLoading,
+    registry.focused?.messages,
+    messageLogName,
+    forkNumber,
+    toolUseConfirm,
+    engineAbort
+  ]);
+  const onCancel = useCallback(() => {
     onInterrupt();
-  }
+  }, [onInterrupt]);
   useEffect(() => {
     if (forkConvoWithMessagesOnTheNextRender) {
       setForkNumber((_) => _ + 1);
       setForkConvoWithMessagesOnTheNextRender(null);
-      setMessages(forkConvoWithMessagesOnTheNextRender);
+      engineSetMessages(forkConvoWithMessagesOnTheNextRender);
     }
-  }, [forkConvoWithMessagesOnTheNextRender]);
+  }, [forkConvoWithMessagesOnTheNextRender, engineSetMessages]);
   useEffect(() => {
     const totalCost = getTotalCost();
     if (totalCost >= 5 && !showCostDialog && !haveShownCostDialog) {
@@ -281,17 +340,14 @@ function REPL({
     if (!initialPrompt) {
       return;
     }
-    setIsLoading(true);
-    const newAbortController = new AbortController();
-    setAbortController(newAbortController);
     try {
-      const model = new ModelManager(getGlobalConfig()).getModelName("main");
+      const tempAbortController = new AbortController();
       const newMessages = await processUserInput(
         initialPrompt,
         "prompt",
         setToolJSX,
         {
-          abortController: newAbortController,
+          abortController: tempAbortController,
           options: {
             commands: currentCommands,
             forkNumber,
@@ -312,44 +368,7 @@ function REPL({
             addToHistory(initialPrompt);
           }
         }
-        setMessages((_) => [..._, ...newMessages]);
-        const lastMessage = newMessages[newMessages.length - 1];
-        if (lastMessage.type === "assistant") {
-          return;
-        }
-        const [systemPrompt, context, model2, maxThinkingTokens] = await Promise.all([
-          getSystemPrompt(),
-          getContext(),
-          new ModelManager(getGlobalConfig()).getModelName("main"),
-          getMaxThinkingTokens([...messages, ...newMessages])
-        ]);
-        for await (const message of query(
-          [...messages, ...newMessages],
-          systemPrompt,
-          context,
-          canUseTool,
-          {
-            options: {
-              commands: currentCommands,
-              forkNumber,
-              messageLogName,
-              tools: currentTools,
-              verbose,
-              safeMode,
-              safetyMode,
-              maxThinkingTokens
-            },
-            messageId: getLastAssistantMessageId([...messages, ...newMessages]),
-            readFileTimestamps: readFileTimestamps.current,
-            abortController: newAbortController,
-            setToolJSX,
-            askUser
-          },
-          getBinaryFeedbackResponse
-        )) {
-          messageBatchBufferRef.current?.add(message);
-        }
-        messageBatchBufferRef.current?.flush();
+        await onQuery(newMessages);
       } else {
         addToHistory(initialPrompt);
       }
@@ -358,103 +377,51 @@ function REPL({
       );
     } catch (error) {
       logError(error);
-      setMessages((oldMessages) => [
-        ...oldMessages,
-        createAssistantAPIErrorMessage(
-          `Request failed: ${error instanceof Error ? error.message : String(error)}`
-        )
-      ]);
-    } finally {
-      setIsLoading(false);
-      setAbortController(null);
     }
   }
-  function rollbackConversation() {
+  const rollbackConversation = useCallback(() => {
     if (messageHistory.length === 0) {
       return false;
     }
     const previousMessages = messageHistory[messageHistory.length - 1];
-    setMessages(previousMessages);
+    if (!previousMessages) return false;
+    engineSetMessages(previousMessages);
     setMessageHistory((history) => history.slice(0, -1));
     return true;
-  }
-  const processNextQueuedPromptRef = useRef(null);
-  async function onQuery(newMessages, passedAbortController) {
-    const controllerToUse = passedAbortController || new AbortController();
-    if (!passedAbortController) {
-      setAbortController(controllerToUse);
-    }
-    setIsLoading(true);
-    setVerbose(false);
-    const isKodingRequest = newMessages.length > 0 && newMessages[0].type === "user" && "options" in newMessages[0] && newMessages[0].options?.isKodingRequest === true;
-    setMessages((oldMessages) => {
-      setMessageHistory((history) => [...history, oldMessages].slice(-10));
-      return [...oldMessages, ...newMessages];
-    });
+  }, [messageHistory, engineSetMessages]);
+  async function onQuery(newMessages, _passedAbortController) {
+    setScreen("prompt");
+    setShowAllInTranscript(false);
+    const firstMessage = newMessages[0];
+    const isKodingRequest = newMessages.length > 0 && firstMessage !== void 0 && firstMessage.type === "user" && "options" in firstMessage && firstMessage.options?.isKodingRequest === true;
+    setMessageHistory((history) => [...history, [...messages]].slice(-10));
     markProjectOnboardingComplete();
     const lastMessage = newMessages[newMessages.length - 1];
-    if (lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
+    if (lastMessage && lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
       recordFirstPrompt(lastMessage.message.content);
       incrementMessageCount(1);
     }
-    if (lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
-    }
-    if (lastMessage.type === "assistant") {
-      setAbortController(null);
-      setIsLoading(false);
+    if (lastMessage && lastMessage.type === "assistant") {
+      engineAppendMessages(newMessages);
       return;
     }
-    try {
-      const [systemPrompt, context, model, maxThinkingTokens] = await Promise.all([
-        getSystemPrompt(),
-        getContext(),
-        new ModelManager(getGlobalConfig()).getModelName("main"),
-        getMaxThinkingTokens([...messages, lastMessage])
-      ]);
-      let lastAssistantMessage = null;
-      for await (const message of query(
-        [...messages, lastMessage],
-        systemPrompt,
-        context,
-        canUseTool,
-        {
-          options: {
-            commands: currentCommands,
-            forkNumber,
-            messageLogName,
-            tools: currentTools,
-            verbose,
-            safeMode,
-            safetyMode,
-            maxThinkingTokens,
-            // If this came from Koding mode, pass that along
-            isKodingRequest: isKodingRequest || void 0
-          },
-          messageId: getLastAssistantMessageId([...messages, lastMessage]),
-          readFileTimestamps: readFileTimestamps.current,
-          abortController: controllerToUse,
-          setToolJSX,
-          askUser
-        },
-        getBinaryFeedbackResponse
-      )) {
-        messageBatchBufferRef.current?.add(message);
-        if (message.type === "assistant") {
-          lastAssistantMessage = message;
-          incrementMessageCount(1);
-          if (Array.isArray(message.message.content)) {
-            const toolUseCount = message.message.content.filter(
-              (block) => typeof block === "object" && block.type === "tool_use"
-            ).length;
-            if (toolUseCount > 0) {
-              incrementToolCallCount(toolUseCount);
-            }
-          }
-        }
-      }
-      if (isKodingRequest && lastAssistantMessage && lastAssistantMessage.type === "assistant") {
+    const maxThinkingTokens = await getMaxThinkingTokens([
+      ...messages,
+      ...newMessages
+    ]);
+    const targetEngine = registry.focused ?? defaultEngine;
+    targetEngine.updateConfig({ maxThinkingTokens });
+    if (isKodingRequest) {
+      targetEngine.updateConfig({ isKodingRequest: true });
+    }
+    await engineSubmitPrompt(newMessages);
+    flushSessionStats();
+    if (isKodingRequest) {
+      const engineMsgs = registry.focused?.messages ?? [];
+      const lastAssistantMsg = [...engineMsgs].reverse().find((m) => m.type === "assistant");
+      if (lastAssistantMsg && lastAssistantMsg.type === "assistant") {
         try {
-          const content = typeof lastAssistantMessage.message.content === "string" ? lastAssistantMessage.message.content : lastAssistantMessage.message.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("\n");
+          const content = typeof lastAssistantMsg.message.content === "string" ? lastAssistantMsg.message.content : lastAssistantMsg.message.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("\n");
           if (content && content.trim().length > 0) {
             handleHashCommand(content);
           }
@@ -462,35 +429,15 @@ function REPL({
           console.error("Error saving response to project docs:", error);
         }
       }
-      messageBatchBufferRef.current?.flush();
-    } catch (error) {
-      logError(error);
-      messageBatchBufferRef.current?.flush();
-      setMessages((oldMessages) => [
-        ...oldMessages,
-        createAssistantAPIErrorMessage(
-          `Request failed: ${error instanceof Error ? error.message : String(error)}`
-        )
-      ]);
-    } finally {
-      setIsLoading(false);
-      setAbortController(null);
-      flushSessionStats();
-      if (queuedPromptsRef.current.length > 0) {
-        setTimeout(() => {
-          if (processNextQueuedPromptRef.current) {
-            processNextQueuedPromptRef.current();
-          }
-        }, 100);
-      }
+      targetEngine.updateConfig({ isKodingRequest: void 0 });
     }
   }
   useCostSummary();
   useEffect(() => {
     const getMessages = () => messages;
     setMessagesGetter(getMessages);
-    setMessagesSetter(setMessages);
-  }, [messages]);
+    setMessagesSetter(engineSetMessages);
+  }, [messages, engineSetMessages]);
   useEffect(() => {
     const todoSessionId = `${messageLogName}-${forkNumber}`;
     initTodoSession(todoSessionId);
@@ -499,51 +446,27 @@ function REPL({
     }
   }, [messageLogName, forkNumber, initialMessages]);
   useEffect(() => {
-    setModelConfigChangeHandler(() => {
-      setForkNumber((prev) => prev + 1);
-    });
-  }, []);
-  useEffect(() => {
-    setLanguageChangeHandler(async () => {
-      setIsResizeClearing(true);
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      await clearTerminal();
-      setForkNumber((prev) => prev + 1);
-      setIsResizeClearing(false);
-    });
-  }, []);
+    setModelConfigChangeHandler(() => safeRefork());
+  }, [safeRefork]);
   useEffect(() => {
-    messagesRef.current = messages;
-  }, [messages]);
+    setLanguageChangeHandler(() => safeRefork());
+  }, [safeRefork]);
   useLogMessages(messages, messageLogName, forkNumber);
   useLogStartupTime();
-  useEffect(() => {
-    if (!autoResume) return;
-    loadLogList(CACHE_PATHS.messages()).then(async (logs) => {
-      for (const log of logs) {
-        try {
-          const loaded = await loadMessagesFromLog(log.fullPath, tools);
-          if (loaded && loaded.length > 0) {
-            setMessages(loaded);
-            emitReminderEvent("session:continuation", {
-              messageCount: loaded.length
-            });
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
-    }).catch(() => {
-    });
-  }, []);
   useEffect(() => {
     onInit();
   }, []);
   useSessionTracking(messageLogName, forkNumber);
+  const activeMessages = useMemo(() => {
+    const engine = registry.focused;
+    if (engine && engine !== defaultEngine && engine.ownMessagesStartIndex > 0) {
+      return messages.slice(engine.ownMessagesStartIndex);
+    }
+    return messages;
+  }, [messages, currentViewAgent, registry, defaultEngine]);
   const normalizedMessages = useMemo(
-    () => normalizeMessages(messages).filter(isNotEmptyMessage),
-    [messages]
+    () => normalizeMessages(activeMessages).filter(isNotEmptyMessage),
+    [activeMessages]
   );
   const unresolvedToolUseIDs = useMemo(
     () => getUnresolvedToolUseIDs(normalizedMessages),
@@ -592,26 +515,68 @@ function REPL({
   }, [normalizedMessages]);
   const messagesJSX = useMemo(() => {
     const reorderedMessages = reorderMessages(normalizedMessages);
-    const hiddenMessageCount = isResumedConversation && reorderedMessages.length > RESUME_VISIBLE_MESSAGE_COUNT ? reorderedMessages.length - RESUME_VISIBLE_MESSAGE_COUNT : 0;
-    const visibleMessages = hiddenMessageCount > 0 ? reorderedMessages.slice(-RESUME_VISIBLE_MESSAGE_COUNT) : reorderedMessages;
-    const result = [
-      {
+    const isTranscript = screen === "transcript";
+    const shouldTruncateTranscript = isTranscript && !showAllInTranscript;
+    const totalMessageCount = reorderedMessages.length;
+    const transcriptTruncatedCount = shouldTruncateTranscript && totalMessageCount > TRANSCRIPT_VISIBLE_COUNT ? totalMessageCount - TRANSCRIPT_VISIBLE_COUNT : 0;
+    const resumeHiddenCount = !isTranscript && isResumedConversation && reorderedMessages.length > RESUME_VISIBLE_MESSAGE_COUNT ? reorderedMessages.length - RESUME_VISIBLE_MESSAGE_COUNT : 0;
+    const visibleMessages = transcriptTruncatedCount > 0 ? reorderedMessages.slice(-TRANSCRIPT_VISIBLE_COUNT) : resumeHiddenCount > 0 ? reorderedMessages.slice(-RESUME_VISIBLE_MESSAGE_COUNT) : reorderedMessages;
+    const result = [];
+    result.push({
+      type: "static",
+      jsx: /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%", key: "logo" }, /* @__PURE__ */ React.createElement(
+        Logo,
+        {
+          mcpClients: currentMcpClients,
+          isDefaultModel,
+          updateBannerVersion: updateAvailableVersion,
+          updateBannerCommands: updateCommands
+        }
+      ), /* @__PURE__ */ React.createElement(ProjectOnboarding, { workspaceDir: getOriginalCwd() }), currentViewAgent && (() => {
+        const focusedEngine = registry.get(registry.focusedId);
+        const engineName = focusedEngine?.engineConfig?.name ?? "unknown";
+        const engineState = focusedEngine?.state ?? "pending";
+        return /* @__PURE__ */ React.createElement(
+          AgentViewBanner,
+          {
+            displayName: currentViewAgent.includes("@") ? currentViewAgent.split("@")[0] : currentViewAgent,
+            agentType: engineName,
+            status: engineState
+          }
+        );
+      })())
+    });
+    if (transcriptTruncatedCount > 0) {
+      result.push({
         type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%", key: "logo" }, /* @__PURE__ */ React.createElement(
-          Logo,
+        jsx: /* @__PURE__ */ React.createElement(Box, { key: `transcript-truncation-${forkNumber}`, width: "100%" }, /* @__PURE__ */ React.createElement(
+          TitledDivider,
           {
-            mcpClients: currentMcpClients,
-            isDefaultModel,
-            updateBannerVersion: updateAvailableVersion,
-            updateBannerCommands: updateCommands
+            title: t("ui.transcript.showPrevious").replace(
+              "{count}",
+              String(transcriptTruncatedCount)
+            )
           }
-        ), /* @__PURE__ */ React.createElement(ProjectOnboarding, { workspaceDir: getOriginalCwd() }))
-      }
-    ];
-    if (hiddenMessageCount > 0) {
+        ))
+      });
+    } else if (isTranscript && showAllInTranscript && totalMessageCount > TRANSCRIPT_VISIBLE_COUNT) {
       result.push({
         type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { key: "collapsed-history", paddingLeft: 2, marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, "\xB7\xB7\xB7 ", hiddenMessageCount, " earlier messages hidden \xB7\xB7\xB7"))
+        jsx: /* @__PURE__ */ React.createElement(Box, { key: `transcript-hide-${forkNumber}`, width: "100%" }, /* @__PURE__ */ React.createElement(
+          TitledDivider,
+          {
+            title: t("ui.transcript.hidePrevious").replace(
+              "{count}",
+              String(totalMessageCount - TRANSCRIPT_VISIBLE_COUNT)
+            )
+          }
+        ))
+      });
+    }
+    if (resumeHiddenCount > 0) {
+      result.push({
+        type: "static",
+        jsx: /* @__PURE__ */ React.createElement(Box, { key: "collapsed-history", paddingLeft: 2, marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, "\xB7\xB7\xB7 ", resumeHiddenCount, " earlier messages hidden \xB7\xB7\xB7"))
       });
     }
     const renderedGroupIds = /* @__PURE__ */ new Set();
@@ -641,7 +606,7 @@ function REPL({
         }
         const isGroupStatic = shouldGroupBeStatic(group);
         const groupType = isGroupStatic ? "static" : "transient";
-        const shouldAnimate = !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isGroupStatic;
+        const shouldAnimate = !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !isGroupStatic;
         result.push({
           type: groupType,
           jsx: /* @__PURE__ */ React.createElement(Box, { key: `group-${group.id}`, width: "100%" }, /* @__PURE__ */ React.createElement(
@@ -695,6 +660,9 @@ function REPL({
       if (_.type === "progress" && !unresolvedToolUseIDs.has(_.toolUseID)) {
         continue;
       }
+      if (!isNotEmptyMessage(_)) {
+        continue;
+      }
       const message = _.type === "progress" ? (
         // Check if this is a streaming progress content (e.g., from BashTool)
         "type" in _.content && _.content.type === "streaming" ? /* @__PURE__ */ React.createElement(
@@ -755,7 +723,7 @@ function REPL({
           debug,
           erroredToolUseIDs,
           inProgressToolUseIDs,
-          shouldAnimate: !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && (!toolUseID || inProgressToolUseIDs.has(toolUseID)),
+          shouldAnimate: !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && (!toolUseID || inProgressToolUseIDs.has(toolUseID)),
           shouldShowDot: true,
           unresolvedToolUseIDs
         }
@@ -798,10 +766,14 @@ function REPL({
     toolJSX,
     toolUseConfirm,
     isMessageSelectorVisible,
+    isRewindPanelVisible,
     unresolvedToolUseIDs,
     currentMcpClients,
     isDefaultModel,
     isResumedConversation,
+    // Transcript mode dependencies
+    screen,
+    showAllInTranscript,
     // V1+ dependencies
     messageGroups,
     getGroupForMessage,
@@ -809,7 +781,9 @@ function REPL({
     shouldGroupBeStatic,
     displayConfig,
     agentTranscripts,
-    toolOutputs
+    toolOutputs,
+    // Agent view dependencies
+    currentViewAgent
   ]);
   const showingCostDialog = !isLoading && showCostDialog;
   const { staticItems, dynamicItems } = useMemo(() => {
@@ -825,79 +799,198 @@ function REPL({
     }
     return { staticItems: staticItems2, dynamicItems: dynamicItems2 };
   }, [messagesJSX]);
+  const noopSetBool = useCallback((_) => {
+  }, []);
+  const noopSetAbort = useCallback((_) => {
+  }, []);
   const handleShowMessageSelector = useCallback(() => {
     setIsMessageSelectorVisible((prev) => !prev);
   }, []);
+  const handleShowRewindPanel = useCallback(() => {
+    if (messages.length === 0) return;
+    setIsRewindPanelVisible(true);
+  }, [messages.length]);
+  const handleRewindAction = useCallback(
+    (action, point) => {
+      setIsRewindPanelVisible(false);
+      if (action === "never_mind") return;
+      if (action === "restore_code_and_conversation" || action === "restore_conversation") {
+        onCancel();
+        setImmediate(async () => {
+          await clearTerminal();
+          const truncatedMessages = messages.slice(0, point.messageIndex);
+          engineSetMessages([]);
+          setForkConvoWithMessagesOnTheNextRender(truncatedMessages);
+          if (point.userText) {
+            setInputValue(point.userText);
+          }
+        });
+        return;
+      }
+      if (action === "restore_code") {
+        return;
+      }
+      if (action === "summarize_from_here") {
+        onCancel();
+        setImmediate(async () => {
+          await clearTerminal();
+          const preserved = messages.slice(0, point.messageIndex);
+          engineSetMessages([]);
+          setForkConvoWithMessagesOnTheNextRender(preserved);
+          if (point.userText) {
+            setInputValue(point.userText);
+          }
+        });
+      }
+    },
+    [
+      messages,
+      onCancel,
+      engineSetMessages,
+      setForkConvoWithMessagesOnTheNextRender
+    ]
+  );
   const handleToggleTodoPanel = useCallback(() => {
     setIsTodoPanelVisible((prev) => !prev);
   }, []);
+  const handleToggleThinkingSelector = useCallback(() => {
+    setShowThinkingSelector((prev) => !prev);
+  }, []);
   const handleToggleBackgroundPanel = useCallback(() => {
     setShowBackgroundPanel((prev) => !prev);
   }, []);
-  const handleModelChange = useCallback(async () => {
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
+  const handleToggleTeamPanel = useCallback(() => {
+    setShowTeamPanel((prev) => !prev);
   }, []);
-  const handleToggleVerbose = useCallback(async (newVerbose) => {
-    const message = `${getVerboseLabel(newVerbose)} (Ctrl+O)`;
-    setVerboseToggleMessage(message);
-    setTimeout(() => setVerboseToggleMessage(null), 2e3);
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    setVerbose(newVerbose);
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
+  const handleKillAllAgents = useCallback(() => {
+    const teams = getActiveTeams();
+    for (const team of teams) {
+      disbandTeam(team.name);
+    }
   }, []);
-  const handleQueueAwareQuery = useCallback(
-    async (newMessages, abortController2) => {
-      if (!isLoading) {
-        return onQuery(newMessages, abortController2);
+  const handleSwitchView = useCallback(
+    async (agentId) => {
+      isSwitchingViewRef.current = true;
+      setShowTeamPanel(false);
+      const isTeamLead = agentId === null || agentId.startsWith("team-lead") || agentId === "team-lead";
+      const oldFocused = registry.focused;
+      if (oldFocused && oldFocused !== defaultEngine) {
+        oldFocused.setIdlePaused(false);
       }
-      const userMessage = newMessages.find((m) => m.type === "user");
-      if (userMessage && userMessage.type === "user") {
-        const promptText = typeof userMessage.message.content === "string" ? userMessage.message.content : "";
-        if (promptText) {
-          setQueuedPrompts((prev) => [...prev, promptText]);
+      await safeRefork(() => {
+        setCurrentViewAgent(isTeamLead ? null : agentId);
+        const targetId = isTeamLead ? "default" : agentId;
+        if (registry.get(targetId)) {
+          registry.setFocus(targetId);
+          const newFocused = registry.get(targetId);
+          if (newFocused && newFocused !== defaultEngine) {
+            newFocused.setIdlePaused(true);
+          }
+        } else {
+          registry.setFocus("default");
         }
+      });
+      isSwitchingViewRef.current = false;
+    },
+    [registry, defaultEngine]
+  );
+  const handleBackFromAgent = useCallback(async () => {
+    await handleSwitchView(null);
+  }, [handleSwitchView]);
+  const handleCycleTeammate = useCallback(
+    (direction) => {
+      const activeMembers = teamMembers.filter((m) => m.status !== "stopped");
+      if (activeMembers.length === 0) return;
+      const memberIds = [
+        null,
+        ...activeMembers.map((m) => m.name)
+      ];
+      const currentIdx = currentViewAgent === null ? 0 : memberIds.findIndex(
+        (id) => id !== null && (currentViewAgent.includes(id) || id.includes(currentViewAgent?.split("@")[0] || ""))
+      );
+      let nextIdx;
+      if (direction === "next") {
+        nextIdx = currentIdx < 0 ? 0 : (currentIdx + 1) % memberIds.length;
+      } else {
+        nextIdx = currentIdx < 0 ? memberIds.length - 1 : (currentIdx - 1 + memberIds.length) % memberIds.length;
       }
+      const nextId = memberIds[nextIdx];
+      if (nextId) handleSwitchView(nextId);
     },
-    [isLoading]
+    [teamMembers, currentViewAgent, handleSwitchView]
   );
+  const handleToggleAgentView = useCallback(() => {
+    if (currentViewAgent) {
+      handleBackFromAgent();
+    } else {
+      const activeMembers = teamMembers.filter((m) => m.status !== "stopped");
+      const firstActive = activeMembers[0];
+      if (firstActive) {
+        handleSwitchView(firstActive.name);
+      }
+    }
+  }, [currentViewAgent, teamMembers, handleBackFromAgent, handleSwitchView]);
+  const handleModelChange = useCallback(() => safeRefork(), [safeRefork]);
+  const handleToggleScreen = useCallback(async () => {
+    setShowAllInTranscript(false);
+    await safeRefork(
+      () => setScreen((prev) => prev === "transcript" ? "prompt" : "transcript")
+    );
+  }, [safeRefork]);
+  const handleToggleShowAll = useCallback(async () => {
+    await safeRefork(() => setShowAllInTranscript((prev) => !prev));
+  }, [safeRefork]);
   useEffect(() => {
-    processNextQueuedPromptRef.current = async () => {
-      if (queuedPrompts.length === 0) return;
-      const nextPrompt = queuedPrompts[0];
-      setQueuedPrompts((prev) => prev.slice(1));
-      if (!nextPrompt) return;
-      const userMessage = {
-        type: "user",
-        uuid: randomUUID(),
-        message: {
-          role: "user",
-          content: nextPrompt
+    const unsubscribe = teamEvents.onTeamChange(
+      (data) => {
+        if (data.event === "created") {
+          defaultEngine.promoteToTeamLead(data.teamName);
+          defaultEngine.updateConfig({
+            systemPrompt: () => getSystemPrompt("team-lead")
+          });
+        } else if (data.event === "disbanded") {
+          defaultEngine.updateConfig({
+            systemPrompt: () => getSystemPrompt()
+          });
         }
-      };
-      setIsLoading(true);
-      const newAbortController = new AbortController();
-      setAbortController(newAbortController);
-      await onQuery([userMessage], newAbortController);
+      }
+    );
+    return unsubscribe;
+  }, [defaultEngine]);
+  useEffect(() => {
+    const engine = registry.focused;
+    if (!engine) return;
+    engine.setCanUseTool(canUseTool);
+    engine.setAskUser(askUser);
+    engine.setToolJSX(setToolJSX);
+    engine.setBinaryFeedbackResponse(getBinaryFeedbackResponse);
+  }, [registry.focusedId, canUseTool, askUser, getBinaryFeedbackResponse]);
+  useEffect(() => {
+    defaultEngine.start();
+    return () => {
+      defaultEngine.stop();
     };
-  }, [queuedPrompts]);
+  }, [defaultEngine]);
+  useEffect(() => {
+    defaultEngine.updateConfig({
+      tools: currentTools,
+      commands: currentCommands
+    });
+  }, [currentTools, currentCommands, defaultEngine]);
+  useEffect(() => {
+    defaultEngine.updateConfig({ verbose, safeMode, safetyMode });
+  }, [verbose, safeMode, safetyMode, defaultEngine]);
   return /* @__PURE__ */ React.createElement(
     PermissionProvider,
     {
       isBypassPermissionsModeAvailable: !safeMode,
-      children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(React.Fragment, { key: `static-wrapper-${forkNumber}` }, /* @__PURE__ */ React.createElement(
+      children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(React.Fragment, { key: `static-wrapper-${forkNumber}` }, /* @__PURE__ */ React.createElement(
         Static,
         {
           items: staticItems,
           children: (item) => /* @__PURE__ */ React.createElement(React.Fragment, { key: item.id }, item.jsx)
         }
-      )), /* @__PURE__ */ React.createElement(React.Fragment, { key: `dynamic-messages-${forkNumber}` }, dynamicItems.map((item) => item.jsx)), /* @__PURE__ */ React.createElement(
+      )), /* @__PURE__ */ React.createElement(React.Fragment, { key: `dynamic-messages-${forkNumber}` }, dynamicItems.map((item) => item.jsx)), isLoading && !isResizeClearing && /* @__PURE__ */ React.createElement(StreamingTextPreview, null), /* @__PURE__ */ React.createElement(
         Box,
         {
           key: `transient-ui-${forkNumber}`,
@@ -912,10 +1005,11 @@ function REPL({
             todos: getTodos(),
             isVisible: isTodoPanelVisible,
             isLoading,
-            showTodoList: isTodoPanelVisible
+            showTodoList: isTodoPanelVisible,
+            focusedAgentId: currentViewAgent
           }
         ),
-        !isResizeClearing && !isLoading && !toolJSX && !toolUseConfirm && !binaryFeedbackContext && queuedPrompts.length === 0 && /* @__PURE__ */ React.createElement(
+        !isResizeClearing && !isLoading && !toolJSX && !toolUseConfirm && !binaryFeedbackContext && !defaultEngine.injectionChannel.hasMessages() && /* @__PURE__ */ React.createElement(
           TurnCompletionIndicator,
           {
             durationMs: lastTurnDurationMs,
@@ -923,7 +1017,7 @@ function REPL({
           }
         ),
         toolJSX?.shouldHidePromptInput ? toolJSX.jsx : null,
-        !toolJSX && binaryFeedbackContext && !isMessageSelectorVisible && /* @__PURE__ */ React.createElement(
+        !toolJSX && binaryFeedbackContext && !isMessageSelectorVisible && !isRewindPanelVisible && /* @__PURE__ */ React.createElement(
           BinaryFeedback,
           {
             m1: binaryFeedbackContext.m1,
@@ -941,7 +1035,7 @@ function REPL({
             unresolvedToolUseIDs
           }
         ),
-        !toolJSX && toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && /* @__PURE__ */ React.createElement(
+        !toolJSX && toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !binaryFeedbackContext && !askUserQuestionContext && /* @__PURE__ */ React.createElement(
           PermissionRequest,
           {
             toolUseConfirm,
@@ -949,14 +1043,14 @@ function REPL({
             verbose
           }
         ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && askUserQuestionContext && /* @__PURE__ */ React.createElement(
+        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !binaryFeedbackContext && askUserQuestionContext && /* @__PURE__ */ React.createElement(
           AskUserQuestionDialog,
           {
             context: askUserQuestionContext,
             onDone: () => setAskUserQuestionContext(null)
           }
         ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && showingCostDialog && /* @__PURE__ */ React.createElement(
+        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !binaryFeedbackContext && !askUserQuestionContext && showingCostDialog && /* @__PURE__ */ React.createElement(
           CostThresholdDialog,
           {
             onDone: () => {
@@ -970,7 +1064,7 @@ function REPL({
             }
           }
         ),
-        !toolUseConfirm && !toolJSX?.shouldHidePromptInput && shouldShowPromptInput && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && !showingCostDialog && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+        !toolUseConfirm && !toolJSX?.shouldHidePromptInput && shouldShowPromptInput && !isMessageSelectorVisible && !isRewindPanelVisible && !showThinkingSelector && !binaryFeedbackContext && !askUserQuestionContext && !showingCostDialog && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
           BackgroundTasksPanel,
           {
             shells: backgroundShells,
@@ -983,11 +1077,12 @@ function REPL({
             },
             onClose: () => setShowBackgroundPanel(false)
           }
-        ), /* @__PURE__ */ React.createElement(
+        ), !isResizeClearing && /* @__PURE__ */ React.createElement(IdleNotificationBar, { notifications: idleNotifications }), /* @__PURE__ */ React.createElement(
           PromptInput,
           {
             commands: currentCommands,
             forkNumber,
+            focusedAgentName: currentViewAgent ? teamMembers.find((m) => m.id === currentViewAgent)?.name ?? currentViewAgent.split("@")[0] : hasActiveTeam ? "team-lead" : null,
             messageLogName,
             tools: currentTools,
             isDisabled: apiKeyStatus === "invalid",
@@ -995,7 +1090,6 @@ function REPL({
             onQuery,
             debug,
             verbose,
-            verboseToggleMessage,
             messages,
             setToolJSX,
             input: inputValue,
@@ -1004,34 +1098,71 @@ function REPL({
             onModeChange: setInputMode,
             submitCount,
             onSubmitCountChange: setSubmitCount,
-            setIsLoading,
-            setAbortController,
+            setIsLoading: noopSetBool,
+            setAbortController: noopSetAbort,
             onShowMessageSelector: handleShowMessageSelector,
             setForkConvoWithMessagesOnTheNextRender,
             readFileTimestamps: readFileTimestamps.current,
-            abortController,
+            abortController: null,
             onModelChange: handleModelChange,
-            onRollbackConversation: rollbackConversation,
+            onShowRewindPanel: handleShowRewindPanel,
             onToggleTodoPanel: handleToggleTodoPanel,
-            onToggleVerbose: handleToggleVerbose,
+            onToggleThinkingSelector: handleToggleThinkingSelector,
+            onToggleScreen: handleToggleScreen,
+            onToggleShowAllInTranscript: handleToggleShowAll,
+            screen,
             onToggleBackgroundPanel: handleToggleBackgroundPanel,
+            onToggleTeamPanel: handleToggleTeamPanel,
+            onCycleTeammate: handleCycleTeammate,
+            onToggleAgentView: handleToggleAgentView,
+            onKillAllAgents: handleKillAllAgents,
             backgroundShellCount: backgroundShells.filter((s) => s.status === "running").length,
             isBackgroundPanelOpen: showBackgroundPanel,
             fallbackMode,
-            queuedPrompts,
-            onQueuePrompt: (prompt) => setQueuedPrompts((prev) => [...prev, prompt]),
-            onPopQueuedPrompt: () => {
-              if (queuedPrompts.length === 0) return void 0;
-              const lastPrompt = queuedPrompts[queuedPrompts.length - 1];
-              setQueuedPrompts((prev) => prev.slice(0, -1));
-              return lastPrompt;
+            onInjectMessage: (input) => {
+              const formatted = formatUserGuidanceForInjection(input);
+              const focusedEng = registry.focused ?? defaultEngine;
+              focusedEng.injectionChannel.push(
+                formatted,
+                "user",
+                input
+              );
             },
+            onRemoveQueuedMessage: () => {
+              const focusedEng = registry.focused ?? defaultEngine;
+              return focusedEng.injectionChannel.removeLastUserMessage();
+            },
+            injectionPending: (registry.focused ?? defaultEngine).injectionChannel.size > 0,
+            getQueuedUserMessages: () => (registry.focused ?? defaultEngine).injectionChannel.peekUserDisplayTexts(),
             onInterrupt,
-            isOverlayActive: !!(toolJSX && !toolJSX.shouldHidePromptInput),
+            isOverlayActive: showTeamPanel || !!(toolJSX && !toolJSX.shouldHidePromptInput),
             unmount: unmountREPL,
-            startupItems
+            startupItems,
+            teamMembers,
+            hasActiveTeam
+          }
+        ), toolJSX && !toolJSX.shouldHidePromptInput && toolJSX.jsx, /* @__PURE__ */ React.createElement(
+          TeamMemberPanel,
+          {
+            isVisible: showTeamPanel,
+            onClose: () => setShowTeamPanel(false),
+            onFocusAgent: handleSwitchView
           }
-        ), toolJSX && !toolJSX.shouldHidePromptInput && toolJSX.jsx)
+        ), screen === "transcript" && /* @__PURE__ */ React.createElement(
+          Box,
+          {
+            width: "100%",
+            paddingLeft: 2,
+            marginTop: 1,
+            borderStyle: "single",
+            borderTop: true,
+            borderBottom: false,
+            borderLeft: false,
+            borderRight: false,
+            borderColor: SEMANTIC_COLORS.dim
+          },
+          /* @__PURE__ */ React.createElement(Text, { dimColor: true }, t("ui.transcript.showing"))
+        ))
       ), isMessageSelectorVisible && /* @__PURE__ */ React.createElement(React.Fragment, { key: `message-selector-wrapper-${forkNumber}` }, /* @__PURE__ */ React.createElement(
         MessageSelector,
         {
@@ -1046,7 +1177,7 @@ function REPL({
             onCancel();
             setImmediate(async () => {
               await clearTerminal();
-              setMessages([]);
+              engineSetMessages([]);
               setForkConvoWithMessagesOnTheNextRender(
                 messages.slice(0, messages.indexOf(message))
               );
@@ -1058,7 +1189,19 @@ function REPL({
           onEscape: () => setIsMessageSelectorVisible(false),
           tools: currentTools
         }
-      )), /* @__PURE__ */ React.createElement(Newline, null))
+      )), isRewindPanelVisible && /* @__PURE__ */ React.createElement(
+        RewindPanel,
+        {
+          messages,
+          onAction: handleRewindAction,
+          onEscape: () => setIsRewindPanelVisible(false)
+        }
+      ), showThinkingSelector && /* @__PURE__ */ React.createElement(
+        ThinkingSelector,
+        {
+          onClose: () => setShowThinkingSelector(false)
+        }
+      ), /* @__PURE__ */ React.createElement(Newline, null)))
     }
   );
 }