wave-code 0.5.0 → 0.6.1

package/src/contexts/useChat.tsx

@@ -12,6 +12,7 @@ import type {
   Message,
   McpServerStatus,
   BackgroundTask,
+  Task,
   SlashCommand,
   PermissionDecision,
   PermissionMode,
@@ -30,9 +31,10 @@ export interface ChatContextType {
   isLoading: boolean;
   isCommandRunning: boolean;
   isCompressing: boolean;
-  userInputHistory: string[];
   // Message display state
   isExpanded: boolean;
+  isTaskListVisible: boolean;
+  setIsTaskListVisible: (visible: boolean) => void;
   // AI functionality
   sessionId: string;
   sendMessage: (
@@ -41,14 +43,14 @@ export interface ChatContextType {
   ) => Promise<void>;
   abortMessage: () => void;
   latestTotalTokens: number;
-  // Memory functionality
-  saveMemory: (message: string, type: "project" | "user") => Promise<void>;
   // MCP functionality
   mcpServers: McpServerStatus[];
   connectMcpServer: (serverName: string) => Promise<boolean>;
   disconnectMcpServer: (serverName: string) => Promise<boolean>;
   // Background tasks
   backgroundTasks: BackgroundTask[];
+  // Session tasks
+  sessionTasks: Task[];
   getBackgroundTaskOutput: (
     taskId: string,
   ) => { stdout: string; stderr: string; status: string } | null;
@@ -58,6 +60,7 @@ export interface ChatContextType {
   hasSlashCommand: (commandId: string) => boolean;
   // Subagent messages
   subagentMessages: Record<string, Message[]>;
+  subagentLatestTokens: Record<string, number>;
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
@@ -83,6 +86,12 @@ export interface ChatContextType {
   // Rewind functionality
   rewindId: number;
   handleRewindSelect: (index: number) => Promise<void>;
+  getFullMessageThread: () => Promise<{
+    messages: Message[];
+    sessionIds: string[];
+  }>;
+  wasLastDetailsTooTall: number;
+  setWasLastDetailsTooTall: React.Dispatch<React.SetStateAction<number>>;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -110,6 +119,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   // Message Display State
   const [isExpanded, setIsExpanded] = useState(false);
+  const [isTaskListVisible, setIsTaskListVisible] = useState(true);
 
   // AI State
   const [messages, setMessages] = useState<Message[]>([]);
@@ -118,13 +128,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [sessionId, setSessionId] = useState("");
   const [isCommandRunning, setIsCommandRunning] = useState(false);
   const [isCompressing, setIsCompressing] = useState(false);
-  const [userInputHistory, setUserInputHistory] = useState<string[]>([]);
 
   // MCP State
   const [mcpServers, setMcpServers] = useState<McpServerStatus[]>([]);
 
   // Background tasks state
   const [backgroundTasks, setBackgroundTasks] = useState<BackgroundTask[]>([]);
+  // Session tasks state
+  const [sessionTasks, setSessionTasks] = useState<Task[]>([]);
 
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
@@ -133,6 +144,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [subagentMessages, setSubagentMessages] = useState<
     Record<string, Message[]>
   >({});
+  const [subagentLatestTokens, setSubagentLatestTokens] = useState<
+    Record<string, number>
+  >({});
 
   // Permission state
   const [permissionMode, setPermissionModeState] =
@@ -171,6 +185,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Rewind state
   const [rewindId, setRewindId] = useState(0);
 
+  // Confirmation too tall state
+  const [wasLastDetailsTooTall, setWasLastDetailsTooTall] = useState(0);
+
   const agentRef = useRef<Agent | null>(null);
 
   // Permission confirmation methods with queue support
@@ -209,29 +226,36 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           setMcpServers([...servers]);
         },
         onSessionIdChange: (sessionId) => {
-          process.stdout.write("\x1Bc", () => {
-            setSessionId(sessionId);
-          });
+          setSessionId(sessionId);
         },
         onLatestTotalTokensChange: (tokens) => {
           setlatestTotalTokens(tokens);
         },
-        onUserInputHistoryChange: (history) => {
-          setUserInputHistory([...history]);
-        },
         onCompressionStateChange: (isCompressingState) => {
           setIsCompressing(isCompressingState);
         },
         onTasksChange: (tasks) => {
           setBackgroundTasks([...tasks]);
         },
-        onSubagentMessagesChange: (subagentId, messages) => {
+        onSessionTasksChange: (tasks) => {
+          setSessionTasks([...tasks]);
+        },
+        onSubagentMessagesChange: (subagentId: string, messages: Message[]) => {
           logger.debug("onSubagentMessagesChange", subagentId, messages.length);
           setSubagentMessages((prev) => ({
             ...prev,
             [subagentId]: [...messages],
           }));
         },
+        onSubagentLatestTotalTokensChange: (
+          subagentId: string,
+          tokens: number,
+        ) => {
+          setSubagentLatestTokens((prev) => ({
+            ...prev,
+            [subagentId]: tokens,
+          }));
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
         },
@@ -283,7 +307,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setlatestTotalTokens(agent.latestTotalTokens);
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompressing(agent.isCompressing);
-        setUserInputHistory(agent.userInputHistory);
         setPermissionModeState(agent.getPermissionMode());
 
         // Get initial MCP servers state
@@ -338,16 +361,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       if (!hasTextContent && !hasImageAttachments) return;
 
       try {
-        // Handle memory mode - check if it's a memory message (starts with # and only one line)
-        if (content.startsWith("#") && !content.includes("\n")) {
-          const memoryText = content.substring(1).trim();
-          if (!memoryText) return;
-
-          // In memory mode, don't add user message, only wait for user to choose memory type then add assistant message
-          // Don't auto-save, wait for user to choose memory type
-          return;
-        }
-
         // Handle bash mode - check if it's a bash command (starts with ! and only one line)
         if (content.startsWith("!") && !content.includes("\n")) {
           const command = content.substring(1).trim();
@@ -394,14 +407,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     agentRef.current?.abortMessage();
   }, []);
 
-  // Memory save function - delegate to Agent
-  const saveMemory = useCallback(
-    async (message: string, type: "project" | "user") => {
-      await agentRef.current?.saveMemory(message, type);
-    },
-    [],
-  );
-
   // Permission management methods
   const setPermissionMode = useCallback((mode: PermissionMode) => {
     setPermissionModeState((prev) => {
@@ -492,27 +497,34 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         await agentRef.current.truncateHistory(index);
 
         // Clear terminal screen after rewind
-        process.stdout.write("\x1Bc", () => {
-          setRewindId((prev) => prev + 1);
-        });
+        setRewindId((prev) => prev + 1);
       } catch (error) {
         logger.error("Failed to rewind:", error);
       }
     }
   }, []);
 
+  const getFullMessageThread = useCallback(async () => {
+    if (agentRef.current) {
+      return await agentRef.current.getFullMessageThread();
+    }
+    return { messages: [], sessionIds: [] };
+  }, []);
+
   // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
   useInput((input, key) => {
     if (key.ctrl && input === "o") {
       // Clear terminal screen when expanded state changes
-      process.stdout.write("\x1Bc", () => {
-        setIsExpanded((prev) => {
-          const newExpanded = !prev;
-          return newExpanded;
-        });
+      setIsExpanded((prev) => {
+        const newExpanded = !prev;
+        return newExpanded;
       });
     }
 
+    if (key.ctrl && input === "t") {
+      setIsTaskListVisible((prev) => !prev);
+    }
+
     // Handle ESC key to cancel confirmation
     if (key.escape && isConfirmationVisible) {
       handleConfirmationCancel();
@@ -523,23 +535,25 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     messages,
     isLoading,
     isCommandRunning,
-    userInputHistory,
     isExpanded,
+    isTaskListVisible,
+    setIsTaskListVisible,
     sessionId,
     sendMessage,
     abortMessage,
     latestTotalTokens,
     isCompressing,
-    saveMemory,
     mcpServers,
     connectMcpServer,
     disconnectMcpServer,
     backgroundTasks,
+    sessionTasks,
     getBackgroundTaskOutput,
     stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
     subagentMessages,
+    subagentLatestTokens,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,
@@ -551,6 +565,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     backgroundCurrentTask,
     rewindId,
     handleRewindSelect,
+    getFullMessageThread,
+    wasLastDetailsTooTall,
+    setWasLastDetailsTooTall,
   };
 
   return (

package/src/hooks/useInputManager.ts

@@ -33,11 +33,8 @@ export const useInputManager = (
     show: false,
     query: "",
   });
-  const [memoryTypeSelectorState, setMemoryTypeSelectorState] = useState({
-    show: false,
-    message: "",
-  });
-  const [showTaskManager, setShowTaskManager] = useState(false);
+  const [showBackgroundTaskManager, setShowBackgroundTaskManager] =
+    useState(false);
   const [showMcpManager, setShowMcpManager] = useState(false);
   const [showRewindManager, setShowRewindManager] = useState(false);
   const [permissionMode, setPermissionModeState] =
@@ -61,11 +58,8 @@ export const useInputManager = (
         onHistorySearchStateChange: (show, query) => {
           setHistorySearchState({ show, query });
         },
-        onMemoryTypeSelectorStateChange: (show, message) => {
-          setMemoryTypeSelectorState({ show, message });
-        },
-        onTaskManagerStateChange: (show) => {
-          setShowTaskManager(show);
+        onBackgroundTaskManagerStateChange: (show) => {
+          setShowBackgroundTaskManager(show);
         },
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
@@ -78,9 +72,6 @@ export const useInputManager = (
           callbacks.onPermissionModeChange?.(mode);
         },
         onImagesStateChange: setAttachedImages,
-        onShowTaskManager: () => setShowTaskManager(true),
-        onShowMcpManager: () => setShowMcpManager(true),
-        onShowRewindManager: () => setShowRewindManager(true),
         ...callbacks,
       });
 
@@ -101,11 +92,8 @@ export const useInputManager = (
         onHistorySearchStateChange: (show, query) => {
           setHistorySearchState({ show, query });
         },
-        onMemoryTypeSelectorStateChange: (show, message) => {
-          setMemoryTypeSelectorState({ show, message });
-        },
-        onTaskManagerStateChange: (show) => {
-          setShowTaskManager(show);
+        onBackgroundTaskManagerStateChange: (show) => {
+          setShowBackgroundTaskManager(show);
         },
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
@@ -118,9 +106,6 @@ export const useInputManager = (
           callbacks.onPermissionModeChange?.(mode);
         },
         onImagesStateChange: setAttachedImages,
-        onShowTaskManager: () => setShowTaskManager(true),
-        onShowMcpManager: () => setShowMcpManager(true),
-        onShowRewindManager: () => setShowRewindManager(true),
         ...callbacks,
       });
     }
@@ -252,43 +237,6 @@ export const useInputManager = (
     managerRef.current?.handleCancelHistorySearch();
   }, []);
 
-  // Memory type selector methods
-  const activateMemoryTypeSelector = useCallback((message: string) => {
-    managerRef.current?.activateMemoryTypeSelector(message);
-  }, []);
-
-  const handleMemoryTypeSelect = useCallback(
-    async (type: "project" | "user") => {
-      await managerRef.current?.handleMemoryTypeSelect(type);
-    },
-    [],
-  );
-
-  const handleCancelMemoryTypeSelect = useCallback(() => {
-    managerRef.current?.handleCancelMemoryTypeSelect();
-  }, []);
-
-  // Input history methods
-  const setUserInputHistory = useCallback((history: string[]) => {
-    managerRef.current?.setUserInputHistory(history);
-  }, []);
-
-  const navigateHistory = useCallback(
-    (direction: "up" | "down", currentInput: string) => {
-      return (
-        managerRef.current?.navigateHistory(direction, currentInput) || {
-          newInput: currentInput,
-          newCursorPosition: currentInput.length,
-        }
-      );
-    },
-    [],
-  );
-
-  const resetHistoryNavigation = useCallback(() => {
-    managerRef.current?.resetHistoryNavigation();
-  }, []);
-
   // Special character handling
   const handleSpecialCharInput = useCallback((char: string) => {
     managerRef.current?.handleSpecialCharInput(char);
@@ -317,9 +265,7 @@ export const useInputManager = (
     slashPosition: commandSelectorState.position,
     showHistorySearch: historySearchState.show,
     historySearchQuery: historySearchState.query,
-    showMemoryTypeSelector: memoryTypeSelectorState.show,
-    memoryMessage: memoryTypeSelectorState.message,
-    showTaskManager,
+    showBackgroundTaskManager,
     showMcpManager,
     showRewindManager,
     permissionMode,
@@ -354,22 +300,12 @@ export const useInputManager = (
     handleHistorySearchSelect,
     handleCancelHistorySearch,
 
-    // Memory type selector
-    activateMemoryTypeSelector,
-    handleMemoryTypeSelect,
-    handleCancelMemoryTypeSelect,
-
-    // Input history
-    setUserInputHistory,
-    navigateHistory,
-    resetHistoryNavigation,
-
     // Special handling
     handleSpecialCharInput,
 
     // Bash/MCP Manager
-    setShowTaskManager: useCallback((show: boolean) => {
-      managerRef.current?.setShowTaskManager(show);
+    setShowBackgroundTaskManager: useCallback((show: boolean) => {
+      managerRef.current?.setShowBackgroundTaskManager(show);
     }, []),
     setShowMcpManager: useCallback((show: boolean) => {
       managerRef.current?.setShowMcpManager(show);

package/src/hooks/useTasks.ts

@@ -0,0 +1,6 @@
+import { useChat } from "../contexts/useChat.js";
+
+export const useTasks = () => {
+  const { sessionTasks } = useChat();
+  return sessionTasks;
+};

package/src/managers/InputManager.ts

@@ -29,12 +29,8 @@ export interface InputManagerCallbacks {
     position: number,
   ) => void;
   onHistorySearchStateChange?: (show: boolean, query: string) => void;
-  onMemoryTypeSelectorStateChange?: (show: boolean, message: string) => void;
-  onShowTaskManager?: () => void;
-  onTaskManagerStateChange?: (show: boolean) => void;
-  onShowMcpManager?: () => void;
+  onBackgroundTaskManagerStateChange?: (show: boolean) => void;
   onMcpManagerStateChange?: (show: boolean) => void;
-  onShowRewindManager?: () => void;
   onRewindManagerStateChange?: (show: boolean) => void;
   onImagesStateChange?: (images: AttachedImage[]) => void;
   onSendMessage?: (
@@ -42,7 +38,6 @@ export interface InputManagerCallbacks {
     images?: Array<{ path: string; mimeType: string }>,
   ) => void | Promise<void>;
   onHasSlashCommand?: (commandId: string) => boolean;
-  onSaveMemory?: (message: string, type: "project" | "user") => Promise<void>;
   onAbortMessage?: () => void;
   onBackgroundCurrentTask?: () => void;
   onResetHistoryNavigation?: () => void;
@@ -71,15 +66,6 @@ export class InputManager {
   private showHistorySearch: boolean = false;
   private historySearchQuery: string = "";
 
-  // Memory type selector state
-  private showMemoryTypeSelector: boolean = false;
-  private memoryMessage: string = "";
-
-  // Input history state
-  private userInputHistory: string[] = [];
-  private historyIndex: number = -1;
-  private historyBuffer: string = "";
-
   // Paste debounce state
   private pasteDebounceTimer: NodeJS.Timeout | null = null;
   private pasteBuffer: string = "";
@@ -95,7 +81,7 @@ export class InputManager {
   private imageIdCounter: number = 1;
 
   // Additional UI state
-  private showTaskManager: boolean = false;
+  private showBackgroundTaskManager: boolean = false;
   private showMcpManager: boolean = false;
   private showRewindManager: boolean = false;
 
@@ -362,17 +348,14 @@ export class InputManager {
 
         // If not an agent command or execution failed, check local commands
         if (!commandExecuted) {
-          if (command === "tasks" && this.callbacks.onShowTaskManager) {
-            this.callbacks.onShowTaskManager();
+          if (command === "tasks") {
+            this.setShowBackgroundTaskManager(true);
             commandExecuted = true;
-          } else if (command === "mcp" && this.callbacks.onShowMcpManager) {
-            this.callbacks.onShowMcpManager();
+          } else if (command === "mcp") {
+            this.setShowMcpManager(true);
             commandExecuted = true;
-          } else if (
-            command === "rewind" &&
-            this.callbacks.onShowRewindManager
-          ) {
-            this.callbacks.onShowRewindManager();
+          } else if (command === "rewind") {
+            this.setShowRewindManager(true);
             commandExecuted = true;
           }
         }
@@ -439,95 +422,6 @@ export class InputManager {
     return false;
   }
 
-  // Memory type selector methods
-  activateMemoryTypeSelector(message: string): void {
-    this.showMemoryTypeSelector = true;
-    this.memoryMessage = message;
-
-    this.callbacks.onMemoryTypeSelectorStateChange?.(true, message);
-  }
-
-  async handleMemoryTypeSelect(type: "project" | "user"): Promise<void> {
-    const currentMessage = this.inputText.trim();
-    if (currentMessage.startsWith("#")) {
-      await this.callbacks.onSaveMemory?.(currentMessage, type);
-    }
-    // Close the selector
-    this.showMemoryTypeSelector = false;
-    this.memoryMessage = "";
-    this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
-
-    // Clear input box
-    this.clearInput();
-  }
-
-  handleCancelMemoryTypeSelect(): void {
-    this.showMemoryTypeSelector = false;
-    this.memoryMessage = "";
-
-    this.callbacks.onMemoryTypeSelectorStateChange?.(false, "");
-  }
-
-  // Input history methods
-  setUserInputHistory(history: string[]): void {
-    this.userInputHistory = history;
-  }
-
-  navigateHistory(
-    direction: "up" | "down",
-    currentInput: string,
-  ): { newInput: string; newCursorPosition: number } {
-    if (this.historyIndex === -1) {
-      this.historyBuffer = currentInput;
-    }
-
-    if (direction === "up") {
-      if (this.historyIndex < this.userInputHistory.length - 1) {
-        this.historyIndex++;
-      }
-    } else {
-      // Down direction
-      if (this.historyIndex > 0) {
-        this.historyIndex--;
-      } else if (this.historyIndex === 0) {
-        // Go from first history item to draft
-        this.historyIndex = -1;
-      } else if (this.historyIndex === -1) {
-        // Go from draft to empty (beyond history bottom)
-        this.historyIndex = -2;
-      }
-    }
-
-    let newInput: string;
-    if (this.historyIndex === -1) {
-      newInput = this.historyBuffer;
-    } else if (this.historyIndex === -2) {
-      // Beyond history bottom, clear input
-      newInput = "";
-    } else {
-      const historyItem =
-        this.userInputHistory[
-          this.userInputHistory.length - 1 - this.historyIndex
-        ];
-      newInput = historyItem || "";
-    }
-
-    const newCursorPosition = newInput.length;
-
-    this.inputText = newInput;
-    this.cursorPosition = newCursorPosition;
-
-    this.callbacks.onInputTextChange?.(newInput);
-    this.callbacks.onCursorPositionChange?.(newCursorPosition);
-
-    return { newInput, newCursorPosition };
-  }
-
-  resetHistoryNavigation(): void {
-    this.historyIndex = -1;
-    this.historyBuffer = "";
-  }
-
   // Getter methods for state
   isFileSelectorActive(): boolean {
     return this.showFileSelector;
@@ -537,10 +431,6 @@ export class InputManager {
     return this.showCommandSelector;
   }
 
-  isMemoryTypeSelectorActive(): boolean {
-    return this.showMemoryTypeSelector;
-  }
-
   getFileSelectorState() {
     return {
       show: this.showFileSelector,
@@ -558,13 +448,6 @@ export class InputManager {
     };
   }
 
-  getMemoryTypeSelectorState() {
-    return {
-      show: this.showMemoryTypeSelector,
-      message: this.memoryMessage,
-    };
-  }
-
   // Update search queries for active selectors
   private updateSearchQueriesForActiveSelectors(
     inputText: string,
@@ -595,8 +478,6 @@ export class InputManager {
       // Don't activate command selector when file selector is active
       // Only activate command selector if '/' is at the start of input
       this.activateCommandSelector(this.cursorPosition - 1);
-    } else if (char === "#" && this.cursorPosition === 1) {
-      // Memory message detection will be handled in submit
     } else {
       // Update search queries for active selectors
       this.updateSearchQueriesForActiveSelectors(
@@ -753,13 +634,13 @@ export class InputManager {
   }
 
   // Task manager state methods
-  getShowTaskManager(): boolean {
-    return this.showTaskManager;
+  getShowBackgroundTaskManager(): boolean {
+    return this.showBackgroundTaskManager;
   }
 
-  setShowTaskManager(show: boolean): void {
-    this.showTaskManager = show;
-    this.callbacks.onTaskManagerStateChange?.(show);
+  setShowBackgroundTaskManager(show: boolean): void {
+    this.showBackgroundTaskManager = show;
+    this.callbacks.onBackgroundTaskManagerStateChange?.(show);
   }
 
   getShowMcpManager(): boolean {
@@ -815,15 +696,6 @@ export class InputManager {
     }
 
     if (this.inputText.trim()) {
-      const trimmedInput = this.inputText.trim();
-
-      // Check if it's a memory message (starts with # and only one line)
-      if (trimmedInput.startsWith("#") && !trimmedInput.includes("\n")) {
-        // Activate memory type selector
-        this.activateMemoryTypeSelector(trimmedInput);
-        return;
-      }
-
       // Extract image information
       const imageRegex = /\[Image #(\d+)\]/g;
       const matches = [...this.inputText.matchAll(imageRegex)];
@@ -1012,17 +884,6 @@ export class InputManager {
       return true;
     }
 
-    // Handle up/down keys for history navigation (only when no selector is active)
-    if (key.upArrow && !this.showFileSelector && !this.showCommandSelector) {
-      this.navigateHistory("up", this.inputText);
-      return true;
-    }
-
-    if (key.downArrow && !this.showFileSelector && !this.showCommandSelector) {
-      this.navigateHistory("down", this.inputText);
-      return true;
-    }
-
     // Handle typing input
     if (
       input &&
@@ -1060,7 +921,13 @@ export class InputManager {
     }
 
     // Handle interrupt request - use Esc key to interrupt AI request or command
-    if (key.escape && (isLoading || isCommandRunning)) {
+    if (
+      key.escape &&
+      (isLoading || isCommandRunning) &&
+      !this.showBackgroundTaskManager &&
+      !this.showMcpManager &&
+      !this.showRewindManager
+    ) {
       // Unified interrupt for AI message generation and command execution
       this.callbacks.onAbortMessage?.();
       return true;
@@ -1078,19 +945,18 @@ export class InputManager {
       this.showFileSelector ||
       this.showCommandSelector ||
       this.showHistorySearch ||
-      this.showMemoryTypeSelector ||
-      this.showTaskManager ||
+      this.showBackgroundTaskManager ||
       this.showMcpManager ||
       this.showRewindManager
     ) {
       if (
-        this.showMemoryTypeSelector ||
-        this.showTaskManager ||
+        this.showBackgroundTaskManager ||
         this.showMcpManager ||
         this.showRewindManager
       ) {
-        // Memory type selector, task manager, MCP manager and Rewind don't need to handle input, handled by component itself
-        return false;
+        // Task manager, MCP manager and Rewind don't need to handle input, handled by component itself
+        // Return true to indicate we've "handled" it (by ignoring it) so it doesn't leak to normal input
+        return true;
       }
 
       if (this.showHistorySearch) {