refactor: streamline conversation management and UI layout

- Remove unused stop_session command and related backend functionality
- Simplify ChatView component by removing complex tab management logic
- Clean up ConversationTabs to focus on sessions and favorites only
- Remove SessionManager component and session list visibility controls
- Add SearchInput component for consistent search UI across tabs
- Improve conversation selection and session handling in chat interface
- Remove sessionLoader dependency and consolidate session management
- Update NotesView to remove notes list sidebar
- Fix minor layout issues in NoteList component

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: milisp

src-tauri/src/commands.rs

@@ -52,10 +52,6 @@ pub async fn approve_patch(
     codex::approve_patch(state, session_id, approval_id, approved).await
 }
 
-#[tauri::command]
-pub async fn stop_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
-    codex::stop_session(state, session_id).await
-}
 
 #[tauri::command]
 pub async fn pause_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {

src-tauri/src/lib.rs

@@ -12,7 +12,7 @@ use commands::{
     approve_execution, approve_patch, check_codex_version, close_session, delete_session_file,
     get_latest_session_id, get_running_sessions, get_session_files, load_sessions_from_disk,
     pause_session, read_history_file, read_session_file, send_message,
-    start_codex_session, stop_session,
+    start_codex_session,
 };
 use config::{
     add_or_update_model_provider, add_or_update_profile, delete_profile, get_profile_config,
@@ -57,7 +57,6 @@ pub fn run() {
             send_message,
             approve_execution,
             approve_patch,
-            stop_session,
             pause_session,
             close_session,
             get_running_sessions,

src-tauri/src/services/codex.rs

@@ -92,25 +92,6 @@ pub async fn approve_patch(
     }
 }
 
-pub async fn stop_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
-    let sessions = state.sessions.lock().await;
-    let stored_sessions: Vec<String> = sessions.keys().cloned().collect();
-
-    log::debug!("Attempting to interrupt session: {}", session_id);
-    log::debug!("Currently stored sessions: {:?}", stored_sessions);
-
-    if let Some(client) = sessions.get(&session_id) {
-        log::debug!("Found session, sending interrupt: {}", session_id);
-        client
-            .interrupt()
-            .await
-            .map_err(|e| format!("Failed to interrupt session: {}", e))?;
-        Ok(())
-    } else {
-        log::debug!("Session not found: {}", session_id);
-        Err("Session not found".to_string())
-    }
-}
 
 pub async fn pause_session(state: State<'_, CodexState>, session_id: String) -> Result<(), String> {
     let sessions = state.sessions.lock().await;

src/components/ChatView.tsx

@@ -1,106 +1,45 @@
-import React, { useState, useEffect } from "react";
+import React, { useState, useEffect, useMemo } from "react";
 import { ChatInterface } from "./chat/ChatInterface";
-import { ConversationTabs } from "./chat/ConversationTabs";
+import { ConversationTabs } from "@/components/chat/ConversationTabs";
 import { useConversationStore } from "@/stores/ConversationStore";
-import { useLayoutStore } from "@/stores/layoutStore";
-import { sessionManager } from "@/services/sessionManager";
-import { sessionLoader } from "@/services/sessionLoader";
 import type { Conversation } from "@/types/chat";
-import { invoke } from "@tauri-apps/api/core";
-import { DebugInfo } from "./common/DebugInfo";
 
-export const ChatView: React.FC = () => {
-  const [selectedConversation, setSelectedConversation] =
-    useState<Conversation | null>(null);
-  const [searchQueries, setSearchQueries] = useState({
-    all: "",
-    favorites: "",
-    sessions: ""
-  });
-  const [historyConversations, setHistoryConversations] = useState<
-    Conversation[]
-  >([]);
-  const [favoriteStatuses, setFavoriteStatuses] = useState<
-    Record<string, boolean>
-  >({});
+interface ChatViewProps {
+  selectedConversation?: Conversation | null;
+  showChatTabs?: boolean;
+}
 
+export const ChatView: React.FC<ChatViewProps> = ({ selectedConversation, showChatTabs = false }) => {
   const {
     currentConversationId,
     conversations: activeConversations,
-    createConversationWithLatestSession,
-    selectHistoryConversation,
     deleteConversation,
     setCurrentConversation,
+    selectHistoryConversation,
     pendingNewConversation,
+    toggleFavorite,
   } = useConversationStore();
-  const { showSessionList, conversationListTab } = useLayoutStore();
 
-  // Don't auto-switch tabs to prevent unwanted tab changes when favoriting/deleting conversations
-  // Users can manually switch tabs as needed
+  const [searchQuery, setSearchQuery] = useState("");
+  const [internalSelectedConversation, setInternalSelectedConversation] = useState<Conversation | null>(null);
 
-  // Clear selected conversation when starting a new conversation
-  useEffect(() => {
-    if (pendingNewConversation) {
-      setSelectedConversation(null);
-    }
-  }, [pendingNewConversation]);
+  // Generate favorite statuses from the persisted store data
+  const favoriteStatuses = useMemo(() => {
+    const statuses: Record<string, boolean> = {};
+    activeConversations.forEach(conv => {
+      statuses[conv.id] = conv.isFavorite || false;
+    });
+    return statuses;
+  }, [activeConversations]);
 
-  // Also clear when currentConversationId changes to a new codex-event format (from toolbar button)
-  useEffect(() => {
-    if (currentConversationId && currentConversationId.startsWith('codex-event-')) {
-      // Check if this is a new conversation (no messages)
-      const currentConv = activeConversations.find(conv => conv.id === currentConversationId);
-      if (currentConv && currentConv.messages.length === 0) {
-        setSelectedConversation(null);
-      }
-    }
-  }, [currentConversationId, activeConversations]);
-
-  const loadHistory = async () => {
-    try {
-      const history = await sessionLoader.loadSessionsFromDisk();
-      setHistoryConversations(history);
-
-      const statuses: Record<string, boolean> = {};
-      for (const conv of history) {
-        statuses[conv.id] = await sessionLoader.isConversationFavorited(
-          conv.id,
-        );
-      }
-      setFavoriteStatuses(statuses);
-    } catch (error) {
-      console.error("Failed to load history conversations:", error);
-    }
-  };
-
-  useEffect(() => {
-    loadHistory();
-  }, []);
-
-  // Handle creating new conversation with latest session
-  const handleCreateNewConversation = async () => {
-    try {
-      await createConversationWithLatestSession();
-    } catch (error) {
-      console.error("Failed to create new conversation:", error);
-    }
-  };
-
-  // Handle conversation selection from history
   const handleConversationSelect = (conversation: Conversation) => {
-    // Always create a new object to force re-render even if same conversation
     const conversationCopy = { ...conversation };
-    
-    // Store the selected conversation data
-    setSelectedConversation(conversationCopy);
-
-    // Use the new method to select history conversation with full data
+    setInternalSelectedConversation(conversationCopy);
     console.log("🔄 ChatView: Calling selectHistoryConversation", conversation.id);
     selectHistoryConversation(conversationCopy);
   };
 
   const handleSelectSession = (sessionId: string) => {
-    // Set the current session ID for communication
     setCurrentConversation(sessionId);
   };
 
@@ -110,23 +49,7 @@ export const ChatView: React.FC = () => {
   ) => {
     e.stopPropagation();
     try {
-      const conversation = historyConversations.find(
-        (c) => c.id === conversationId,
-      );
-      if (conversation && conversation.filePath) {
-        await invoke("delete_session_file", {
-          filePath: conversation.filePath,
-        });
-      }
       deleteConversation(conversationId);
-      setHistoryConversations((prev) =>
-        prev.filter((c) => c.id !== conversationId),
-      );
-      setFavoriteStatuses((prev) => {
-        const newStatus = { ...prev };
-        delete newStatus[conversationId];
-        return newStatus;
-      });
     } catch (error) {
       console.error("Failed to delete conversation and session file:", error);
     }
@@ -138,89 +61,57 @@ export const ChatView: React.FC = () => {
   ) => {
     e.stopPropagation();
     try {
-      await sessionLoader.toggleFavorite(conversationId);
-
-      // Update local favorite status
-      setFavoriteStatuses((prev) => ({
-        ...prev,
-        [conversationId]: !prev[conversationId],
-      }));
+      // Use the store's toggleFavorite method directly for persistence
+      toggleFavorite(conversationId);
     } catch (error) {
       console.error("Failed to toggle favorite:", error);
     }
   };
 
-  const handleKillSession = async (sessionId: string) => {
-    console.log(`💀 ChatView: Killing session ${sessionId}`);
-    try {
-      // First check if it's a timestamp format session
-      const isTimestampFormat = sessionId.startsWith('codex-event-') && sessionId.includes('-') && 
-        /\d{13}-[a-z0-9]+$/.test(sessionId.replace('codex-event-', ''));
-      
-      if (!isTimestampFormat) {
-        console.log(`💀 Ignoring UUID session kill: ${sessionId}`);
-        return;
-      }
-
-      // Extract the raw session ID for backend process management
-      const rawSessionId = sessionId.replace('codex-event-', '');
-      console.log(`🔄 Extracting raw session ID: ${rawSessionId}`);
+  // Clear selected conversation when starting a new conversation
+  useEffect(() => {
+    if (pendingNewConversation) {
+      setInternalSelectedConversation(null);
+    }
+  }, [pendingNewConversation]);
 
-      await sessionManager.stopSession(rawSessionId);
-      console.log(`✅ Session stopped: ${sessionId}`);
-      
-      // Remove the conversation from the store to update UI
-      deleteConversation(sessionId);
-    } catch (error) {
-      console.warn('Failed to kill session (session may have already been cleaned up):', error);
-      // Don't throw error - session might have been cleaned up by hot reload or other reasons
+  // Also clear when currentConversationId changes to a new codex-event format (from toolbar button)
+  useEffect(() => {
+    if (currentConversationId && currentConversationId.startsWith('codex-event-')) {
+      // Check if this is a new conversation (no messages)
+      const currentConv = activeConversations.find(conv => conv.id === currentConversationId);
+      if (currentConv && currentConv.messages.length === 0) {
+        setInternalSelectedConversation(null);
+      }
     }
-  };
+  }, [currentConversationId, activeConversations]);
 
+  // Use either the passed selectedConversation or internal one
+  const displayedConversation = selectedConversation || internalSelectedConversation;
+
+  if (showChatTabs) {
+    return (
+      <ConversationTabs
+        favoriteStatuses={favoriteStatuses}
+        activeConversations={activeConversations}
+        currentConversationId={currentConversationId}
+        activeSessionId={currentConversationId || ''}
+        searchQuery={searchQuery}
+        onSearchChange={setSearchQuery}
+        onSelectConversation={handleConversationSelect}
+        onToggleFavorite={handleToggleFavorite}
+        onDeleteConversation={handleDeleteConversation}
+        onSelectSession={handleSelectSession}
+      />
+    );
+  }
 
   return (
-    <div className="flex h-full min-h-0">
-      {showSessionList && (
-        <div className="w-64 border-r h-full overflow-y-auto flex-shrink-0">
-          <div className="flex flex-col h-full bg-background">
-            
-            <DebugInfo
-              conversationListTab={conversationListTab}
-              currentConversationId={currentConversationId}
-              historyConversationsCount={historyConversations.length}
-              activeConversationsCount={activeConversations.length}
-              searchQueries={searchQueries}
-            />
-
-            <ConversationTabs
-              historyConversations={historyConversations}
-              favoriteStatuses={favoriteStatuses}
-              activeConversations={activeConversations}
-              currentConversationId={currentConversationId}
-              activeSessionId={currentConversationId || ''}
-              searchQueries={searchQueries}
-              onSearchChange={setSearchQueries}
-              onSelectConversation={handleConversationSelect}
-              onToggleFavorite={handleToggleFavorite}
-              onDeleteConversation={handleDeleteConversation}
-              onSelectSession={handleSelectSession}
-              onKillSession={handleKillSession}
-              onRefreshConversations={loadHistory}
-            />
-          </div>
-        </div>
-      )}
-      <div className="flex-1 min-h-0 h-full min-w-0">
-        <ChatInterface
-          sessionId={currentConversationId || ''}
-          activeSessionId={currentConversationId || ''}
-          onCreateSession={handleCreateNewConversation}
-          onSelectSession={handleSelectSession}
-          onCloseSession={deleteConversation}
-          isSessionListVisible={false}
-          selectedConversation={selectedConversation}
-        />
-      </div>
+    <div className="flex-1 min-h-0 h-full min-w-0">
+      <ChatInterface
+        sessionId={currentConversationId || ''}
+        selectedConversation={displayedConversation}
+      />
     </div>
   );
 };

src/components/NotesView.tsx

@@ -1,17 +1,10 @@
 import React from "react";
-import { NoteList, NoteEditor } from "./notes";
-import { useLayoutStore } from "@/stores/layoutStore";
+import { NoteEditor } from "./notes/NoteEditor";
 
 export const NotesView: React.FC = () => {
-  const { showNotesList } = useLayoutStore();
 
   return (
     <div className="flex h-full min-h-0">
-      {showNotesList && (
-        <div className="w-64 border-r h-full flex-shrink-0 dark:border-gray-700">
-          <NoteList />
-        </div>
-      )}
       <div className="flex-1 min-h-0 h-full min-w-0">
         <NoteEditor />
       </div>