diff --git a/web-app/src/containers/ChatInput.tsx b/web-app/src/containers/ChatInput.tsx
index ffa9a0245c..f488516994 100644
--- a/web-app/src/containers/ChatInput.tsx
+++ b/web-app/src/containers/ChatInput.tsx
@@ -27,12 +27,15 @@ import { useGeneralSetting } from '@/hooks/useGeneralSetting'
 import { useModelProvider } from '@/hooks/useModelProvider'
 
 import { useAppState } from '@/hooks/useAppState'
-import { MovingBorder } from './MovingBorder'
 import { useChat } from '@/hooks/useChat'
+import { MovingBorder } from './MovingBorder'
 import DropdownModelProvider from '@/containers/DropdownModelProvider'
 import { ModelLoader } from '@/containers/loaders/ModelLoader'
 import DropdownToolsAvailable from '@/containers/DropdownToolsAvailable'
 import { useServiceHub } from '@/hooks/useServiceHub'
+import { getConnectedServers } from '@/services/mcp'
+import { useRouter } from '@tanstack/react-router'
+import { route } from '@/constants/routes'
 
 type ChatInputProps = {
   className?: string
@@ -52,14 +55,32 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
     loadingModel,
     tools,
     cancelToolCall,
+    addToThreadQueue,
+    getThreadQueueLength,
+    setThreadPrompt,
+    getThreadPrompt,
   } = useAppState()
-  const { prompt, setPrompt } = usePrompt()
-  const { currentThreadId } = useThreads()
+  const { prompt: globalPrompt, setPrompt: setGlobalPrompt } = usePrompt()
+  const { currentThreadId, createThread } = useThreads()
+
+  // Use thread-aware prompt state
+  const prompt = currentThreadId
+    ? getThreadPrompt(currentThreadId)
+    : globalPrompt
+  const setPrompt = currentThreadId
+    ? (value: string) => setThreadPrompt(currentThreadId, value)
+    : setGlobalPrompt
   const { t } = useTranslation()
   const { spellCheckChatInput } = useGeneralSetting()
+  const router = useRouter()
 
   const maxRows = 10
 
+  // Get current thread's queue information
+  const currentThreadQueueLength = currentThreadId
+    ? getThreadQueueLength(currentThreadId)
+    : 0
+
   const { selectedModel, selectedProvider } = useModelProvider()
   const { sendMessage } = useChat()
   const [message, setMessage] = useState('')
@@ -105,7 +126,9 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
         try {
           // Only check mmproj for llamacpp provider
           if (selectedProvider === 'llamacpp') {
-            const hasLocalMmproj = await serviceHub.models().checkMmprojExists(selectedModel.id)
+            const hasLocalMmproj = await serviceHub
+              .models()
+              .checkMmprojExists(selectedModel.id)
             setHasMmproj(hasLocalMmproj)
           }
           // For non-llamacpp providers, only check vision capability
@@ -130,7 +153,7 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
   // Check if there are active MCP servers
   const hasActiveMCPServers = connectedServers.length > 0 || tools.length > 0
 
-  const handleSendMesage = (prompt: string) => {
+  const handleSendMessage = async (prompt: string) => {
     if (!selectedModel) {
       setMessage('Please select a model to start chatting.')
       return
@@ -139,12 +162,42 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
       return
     }
     setMessage('')
-    sendMessage(
-      prompt,
-      true,
-      uploadedFiles.length > 0 ? uploadedFiles : undefined
-    )
-    setUploadedFiles([])
+
+    // Create thread if none exists, otherwise use current thread
+    if (!currentThreadId) {
+      try {
+        // Create a new thread for the initial message
+        if (!selectedModel) {
+          setMessage('Please select a model to create a new conversation.')
+          return
+        }
+        const threadModel: ThreadModel = {
+          id: selectedModel.id,
+          provider: selectedProvider,
+        }
+        const newThread = await createThread(
+          threadModel,
+          prompt.trim().slice(0, 50)
+        )
+
+        // Navigate to the new thread
+        router.navigate({
+          to: route.threadsDetail,
+          params: { threadId: newThread.id },
+        })
+
+        // Queue the message after navigation
+        addToThreadQueue(newThread.id, prompt.trim())
+      } catch (error) {
+        console.error('Failed to create thread:', error)
+        setMessage('Failed to create new conversation.')
+        return
+      }
+    } else {
+      // Always queue messages - let scheduler decide when to process
+      addToThreadQueue(currentThreadId, prompt.trim())
+    }
+    setPrompt('')
   }
 
   useEffect(() => {
@@ -543,12 +596,11 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
             )}
             <TextareaAutosize
               ref={textareaRef}
-              disabled={Boolean(streamingContent)}
               minRows={2}
               rows={1}
               maxRows={10}
               value={prompt}
-              data-testid={'chat-input'}
+              data-test-id={'chat-input'}
               onChange={(e) => {
                 setPrompt(e.target.value)
                 // Count the number of newlines to estimate rows
@@ -559,17 +611,11 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
                 // e.keyCode 229 is for IME input with Safari
                 const isComposing =
                   e.nativeEvent.isComposing || e.keyCode === 229
-                if (
-                  e.key === 'Enter' &&
-                  !e.shiftKey &&
-                  prompt.trim() &&
-                  !isComposing
-                ) {
+                if (e.key === 'Enter' && !isComposing && !e.shiftKey) {
                   e.preventDefault()
-                  // Submit the message when Enter is pressed without Shift
-                  handleSendMesage(prompt)
-                  // When Shift+Enter is pressed, a new line is added (default behavior)
+                  handleSendMessage(prompt) // Use same handler as send button
                 }
+                // Shift+Enter: Allow default behavior (new line)
               }}
               onPaste={handlePaste}
               placeholder={t('common:placeholder.chatInput')}
@@ -748,6 +794,16 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
               </div>
             </div>
 
+            {/* Enhanced Queue Indicator */}
+            {currentThreadQueueLength > 0 && (
+              <div className="flex items-center gap-2">
+                <div className="bg-accent text-accent-fg text-xs px-2 py-1 rounded-full font-medium">
+                  {currentThreadQueueLength} message
+                  {currentThreadQueueLength === 1 ? '' : 's'} queued
+                </div>
+              </div>
+            )}
+
             {streamingContent ? (
               <Button
                 variant="destructive"
@@ -768,7 +824,7 @@ const ChatInput = ({ model, className, initialMessage }: ChatInputProps) => {
                 size="icon"
                 disabled={!prompt.trim() && uploadedFiles.length === 0}
                 data-test-id="send-message-button"
-                onClick={() => handleSendMesage(prompt)}
+                onClick={() => handleSendMessage(prompt)}
               >
                 {streamingContent ? (
                   <span className="animate-spin h-4 w-4 border-2 border-current border-t-transparent rounded-full" />
diff --git a/web-app/src/containers/__tests__/ChatInput.integration.test.tsx b/web-app/src/containers/__tests__/ChatInput.integration.test.tsx
new file mode 100644
index 0000000000..6840f0a9bf
--- /dev/null
+++ b/web-app/src/containers/__tests__/ChatInput.integration.test.tsx
@@ -0,0 +1,442 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import userEvent from '@testing-library/user-event'
+import {
+  RouterProvider,
+  createRouter,
+  createRootRoute,
+  createMemoryHistory,
+} from '@tanstack/react-router'
+import ChatInput from '../ChatInput'
+import { usePrompt } from '@/hooks/usePrompt'
+import { useThreads } from '@/hooks/useThreads'
+import { useAppState } from '@/hooks/useAppState'
+import { useGeneralSetting } from '@/hooks/useGeneralSetting'
+import { useModelProvider } from '@/hooks/useModelProvider'
+
+/**
+ * Integration tests for ChatInput with Scheduler System
+ *
+ * Tests the complete integration between ChatInput and the inference scheduler:
+ * - Messages always go through the queue system
+ * - Scheduler handles message processing
+ * - UI state updates correctly
+ * - No direct sendMessage calls from UI
+ */
+
+// Mock all dependencies
+const mockAddToThreadQueue = vi.fn()
+const mockGetThreadQueueLength = vi.fn(() => 0)
+const mockSetPrompt = vi.fn()
+
+vi.mock('@/hooks/usePrompt', () => ({
+  usePrompt: vi.fn(() => ({
+    prompt: '',
+    setPrompt: mockSetPrompt,
+  })),
+}))
+
+vi.mock('@/hooks/useThreads', () => ({
+  useThreads: vi.fn(() => ({
+    currentThreadId: 'test-thread-id',
+  })),
+}))
+
+vi.mock('@/hooks/useAppState', () => ({
+  useAppState: vi.fn((selector) => {
+    const mockState = {
+      streamingContent: null,
+      abortControllers: {},
+      loadingModel: false,
+      tools: [],
+      addToThreadQueue: mockAddToThreadQueue,
+      getThreadQueueLength: mockGetThreadQueueLength,
+    }
+    return selector ? selector(mockState) : mockState
+  }),
+}))
+
+vi.mock('@/hooks/useGeneralSetting', () => ({
+  useGeneralSetting: vi.fn(() => ({
+    spellCheckChatInput: false,
+    experimentalFeatures: false,
+  })),
+}))
+
+vi.mock('@/hooks/useModelProvider', () => ({
+  useModelProvider: vi.fn(() => ({
+    selectedModel: {
+      id: 'test-model',
+      name: 'Test Model',
+      provider: 'test-provider',
+      capabilities: [],
+    },
+  })),
+}))
+
+// Mock MCP services
+vi.mock('@/services/mcp', () => ({
+  getConnectedServers: vi.fn().mockResolvedValue([]),
+}))
+
+// Mock translation
+vi.mock('@/i18n/react-i18next-compat', () => ({
+  useTranslation: () => ({
+    t: (key: string) => key,
+  }),
+}))
+
+// Mock components
+vi.mock('@/containers/DropdownModelProvider', () => ({
+  default: () => <div data-testid="model-provider">Model Provider</div>,
+}))
+
+vi.mock('@/containers/loaders/ModelLoader', () => ({
+  ModelLoader: () => <div data-testid="model-loader">Loading...</div>,
+}))
+
+vi.mock('@/containers/DropdownToolsAvailable', () => ({
+  default: ({ children }: { children: (isOpen: boolean, toolsCount: number) => React.ReactNode }) => (
+    <div data-testid="tools-dropdown">{children(false, 0)}</div>
+  ),
+}))
+
+vi.mock('../MovingBorder', () => ({
+  MovingBorder: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="moving-border">{children}</div>
+  ),
+}))
+
+describe('ChatInput Integration with Scheduler', () => {
+  const renderChatInput = () => {
+    const rootRoute = createRootRoute({
+      component: () => <ChatInput />,
+    })
+
+    const router = createRouter({
+      routeTree: rootRoute,
+      history: createMemoryHistory({ initialEntries: ['/'] }),
+    })
+
+    return render(<RouterProvider router={router} />)
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Reset mock implementations
+    mockAddToThreadQueue.mockClear()
+    mockGetThreadQueueLength.mockClear()
+    mockSetPrompt.mockClear()
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('Message Queue Integration', () => {
+    it('should queue messages on Enter keypress instead of sending directly', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message for queue'
+
+      // Mock the prompt value
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const textarea = screen.getByTestId('chat-input')
+      await user.click(textarea)
+      await user.type(textarea, mockPrompt)
+      await user.keyboard('{Enter}')
+
+      // Verify message was queued
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('test-thread-id', mockPrompt)
+      // Verify prompt was cleared
+      expect(mockSetPrompt).toHaveBeenCalledWith('')
+    })
+
+    it('should queue messages on send button click instead of sending directly', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message for send button'
+
+      // Mock the prompt value
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was queued
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('test-thread-id', mockPrompt)
+      // Verify prompt was cleared
+      expect(mockSetPrompt).toHaveBeenCalledWith('')
+    })
+
+    it('should not queue empty messages', async () => {
+      const user = userEvent.setup()
+
+      // Mock empty prompt
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: '   ', // whitespace only
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const textarea = screen.getByTestId('chat-input')
+      await user.click(textarea)
+      await user.keyboard('{Enter}')
+
+      // Verify message was NOT queued
+      expect(mockAddToThreadQueue).not.toHaveBeenCalled()
+      expect(mockSetPrompt).not.toHaveBeenCalled()
+    })
+
+    it('should handle missing currentThreadId gracefully', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message'
+
+      // Mock no current thread
+      vi.mocked(useThreads).mockReturnValue({
+        currentThreadId: null,
+      })
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was NOT queued
+      expect(mockAddToThreadQueue).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Queue Status Display', () => {
+    it('should show queue indicator when messages are queued', () => {
+      // Mock queue with messages
+      mockGetThreadQueueLength.mockReturnValue(3)
+
+      renderChatInput()
+
+      expect(screen.getByText('3 messages queued')).toBeInTheDocument()
+    })
+
+    it('should handle singular queue message correctly', () => {
+      // Mock queue with single message
+      mockGetThreadQueueLength.mockReturnValue(1)
+
+      renderChatInput()
+
+      expect(screen.getByText('1 message queued')).toBeInTheDocument()
+    })
+
+    it('should not show queue indicator when no messages queued', () => {
+      // Mock empty queue
+      mockGetThreadQueueLength.mockReturnValue(0)
+
+      renderChatInput()
+
+      expect(screen.queryByText(/queued/)).not.toBeInTheDocument()
+    })
+  })
+
+  describe('Model Selection Integration', () => {
+    it('should prevent queuing when no model is selected', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message'
+
+      // Mock no selected model
+      vi.mocked(useModelProvider).mockReturnValue({
+        selectedModel: null,
+      })
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was NOT queued
+      expect(mockAddToThreadQueue).not.toHaveBeenCalled()
+    })
+
+    it('should allow queuing when model is selected', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message'
+
+      // Mock selected model
+      vi.mocked(useModelProvider).mockReturnValue({
+        selectedModel: {
+          id: 'test-model',
+          name: 'Test Model',
+          provider: 'test-provider',
+          capabilities: [],
+        },
+      })
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was queued
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('test-thread-id', mockPrompt)
+    })
+  })
+
+  describe('Keyboard Shortcuts', () => {
+    it('should allow newlines with Shift+Enter', async () => {
+      const user = userEvent.setup()
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: 'Test message',
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const textarea = screen.getByTestId('chat-input')
+      await user.click(textarea)
+      await user.keyboard('{Shift>}{Enter}{/Shift}')
+
+      // Verify message was NOT queued (shift+enter should create newline)
+      expect(mockAddToThreadQueue).not.toHaveBeenCalled()
+    })
+
+    it('should queue message with Enter (no shift)', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message'
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const textarea = screen.getByTestId('chat-input')
+      await user.click(textarea)
+      await user.keyboard('{Enter}')
+
+      // Verify message was queued
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('test-thread-id', mockPrompt)
+    })
+  })
+
+  describe('Thread Switching Scenarios', () => {
+    it('should queue messages to the correct thread after thread switch', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message for new thread'
+
+      // Mock thread switch
+      vi.mocked(useThreads).mockReturnValue({
+        currentThreadId: 'new-thread-id',
+      })
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was queued to correct thread
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('new-thread-id', mockPrompt)
+    })
+
+    it('should update queue indicator for current thread', () => {
+      const currentThreadId = 'active-thread'
+      
+      // Mock current thread with queue
+      vi.mocked(useThreads).mockReturnValue({
+        currentThreadId,
+      })
+
+      // Mock queue state for specific thread
+      vi.mocked(useAppState).mockImplementation((selector) => {
+        const mockState = {
+          streamingContent: null,
+          abortControllers: {},
+          loadingModel: false,
+          tools: [],
+          addToThreadQueue: mockAddToThreadQueue,
+          getThreadQueueLength: (threadId: string) => {
+            return threadId === currentThreadId ? 2 : 0
+          },
+        }
+        return selector ? selector(mockState) : mockState
+      })
+
+      renderChatInput()
+
+      expect(screen.getByText('2 messages queued')).toBeInTheDocument()
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle IME composition correctly', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = 'Test message'
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const textarea = screen.getByTestId('chat-input')
+      await user.click(textarea)
+
+      // Simulate IME composition (e.g., typing in Asian languages)
+      fireEvent.keyDown(textarea, {
+        key: 'Enter',
+        keyCode: 229, // IME composition keyCode
+      })
+
+      // Verify message was NOT queued during composition
+      expect(mockAddToThreadQueue).not.toHaveBeenCalled()
+    })
+
+    it('should trim whitespace from messages before queuing', async () => {
+      const user = userEvent.setup()
+      const mockPrompt = '  Test message with whitespace  '
+
+      vi.mocked(usePrompt).mockReturnValue({
+        prompt: mockPrompt,
+        setPrompt: mockSetPrompt,
+      })
+
+      renderChatInput()
+
+      const sendButton = screen.getByTestId('send-message-button')
+      await user.click(sendButton)
+
+      // Verify message was trimmed before queuing
+      expect(mockAddToThreadQueue).toHaveBeenCalledWith('test-thread-id', 'Test message with whitespace')
+    })
+  })
+})
diff --git a/web-app/src/containers/__tests__/ChatInput.test.tsx b/web-app/src/containers/__tests__/ChatInput.test.tsx
index 95c09a1a44..5897f5aead 100644
--- a/web-app/src/containers/__tests__/ChatInput.test.tsx
+++ b/web-app/src/containers/__tests__/ChatInput.test.tsx
@@ -1,7 +1,12 @@
 import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import userEvent from '@testing-library/user-event'
-import { RouterProvider, createRouter, createRootRoute, createMemoryHistory } from '@tanstack/react-router'
+import {
+  RouterProvider,
+  createRouter,
+  createRootRoute,
+  createMemoryHistory,
+} from '@tanstack/react-router'
 import ChatInput from '../ChatInput'
 import { usePrompt } from '@/hooks/usePrompt'
 import { useThreads } from '@/hooks/useThreads'
@@ -29,6 +34,7 @@ vi.mock('@/hooks/useAppState', () => ({
   useAppState: vi.fn(() => ({
     streamingContent: '',
     abortController: null,
+    setQueuedMessage: vi.fn(),
   })),
 }))
 
@@ -88,7 +94,9 @@ vi.mock('@/hooks/useServiceHub', () => ({
 }))
 
 vi.mock('../MovingBorder', () => ({
-  MovingBorder: ({ children }: { children: React.ReactNode }) => <div data-testid="moving-border">{children}</div>,
+  MovingBorder: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="moving-border">{children}</div>
+  ),
 }))
 
 describe('ChatInput', () => {
@@ -101,7 +109,7 @@ describe('ChatInput', () => {
       component: MockComponent,
     })
 
-    return createRouter({ 
+    return createRouter({
       routeTree: rootRoute,
       history: createMemoryHistory({
         initialEntries: ['/'],
@@ -116,32 +124,34 @@ describe('ChatInput', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
-    
+
     // Set up default mock returns
     vi.mocked(usePrompt).mockReturnValue({
       prompt: '',
       setPrompt: mockSetPrompt,
     })
-    
+
     vi.mocked(useThreads).mockReturnValue({
       currentThreadId: 'test-thread-id',
       getCurrentThread: vi.fn(),
       setCurrentThreadId: vi.fn(),
     })
-    
+
     vi.mocked(useAppState).mockReturnValue({
       streamingContent: null,
       abortControllers: {},
       loadingModel: false,
       tools: [],
+      addToThreadQueue: vi.fn(),
+      getThreadQueueLength: vi.fn(() => 0),
     })
-    
+
     vi.mocked(useGeneralSetting).mockReturnValue({
       spellCheckChatInput: true,
       allowSendWhenUnloaded: false,
       experimentalFeatures: true,
     })
-    
+
     vi.mocked(useModelProvider).mockReturnValue({
       selectedModel: {
         id: 'test-model',
@@ -154,9 +164,9 @@ describe('ChatInput', () => {
             {
               id: 'test-model',
               capabilities: ['tools', 'vision'],
-            }
-          ]
-        }
+            },
+          ],
+        },
       ],
       getModelBy: vi.fn(() => ({
         id: 'test-model',
@@ -172,7 +182,7 @@ describe('ChatInput', () => {
       deleteModel: vi.fn(),
       deletedModels: [],
     })
-    
+
     vi.mocked(useChat).mockReturnValue({
       sendMessage: mockSendMessage,
     })
@@ -182,18 +192,23 @@ describe('ChatInput', () => {
     act(() => {
       renderWithRouter()
     })
-    
+
     const textarea = screen.getByRole('textbox')
     expect(textarea).toBeInTheDocument()
-    expect(textarea).toHaveAttribute('placeholder', 'common:placeholder.chatInput')
+    expect(textarea).toHaveAttribute(
+      'placeholder',
+      'common:placeholder.chatInput'
+    )
   })
 
   it('renders send button', () => {
     act(() => {
       renderWithRouter()
     })
-    
-    const sendButton = document.querySelector('[data-test-id="send-message-button"]')
+
+    const sendButton = document.querySelector(
+      '[data-test-id="send-message-button"]'
+    )
     expect(sendButton).toBeInTheDocument()
   })
 
@@ -201,8 +216,10 @@ describe('ChatInput', () => {
     act(() => {
       renderWithRouter()
     })
-    
-    const sendButton = document.querySelector('[data-test-id="send-message-button"]')
+
+    const sendButton = document.querySelector(
+      '[data-test-id="send-message-button"]'
+    )
     expect(sendButton).toBeDisabled()
   })
 
@@ -212,75 +229,107 @@ describe('ChatInput', () => {
       prompt: 'Hello world',
       setPrompt: mockSetPrompt,
     })
-    
+
     act(() => {
       renderWithRouter()
     })
-    
-    const sendButton = document.querySelector('[data-test-id="send-message-button"]')
+
+    const sendButton = document.querySelector(
+      '[data-test-id="send-message-button"]'
+    )
     expect(sendButton).not.toBeDisabled()
   })
 
   it('calls setPrompt when typing in textarea', async () => {
     const user = userEvent.setup()
     renderWithRouter()
-    
+
     const textarea = screen.getByRole('textbox')
     await user.type(textarea, 'Hello')
-    
+
     // setPrompt is called for each character typed
     expect(mockSetPrompt).toHaveBeenCalledTimes(5)
     expect(mockSetPrompt).toHaveBeenLastCalledWith('o')
   })
 
-  it('calls sendMessage when send button is clicked', async () => {
+  it('queues message when send button is clicked', async () => {
     const user = userEvent.setup()
-    
+    const mockAddToThreadQueue = vi.fn()
+
     // Mock prompt with content
     vi.mocked(usePrompt).mockReturnValue({
       prompt: 'Hello world',
       setPrompt: mockSetPrompt,
     })
-    
+
+    vi.mocked(useAppState).mockReturnValue({
+      streamingContent: null,
+      abortControllers: {},
+      loadingModel: false,
+      tools: [],
+      addToThreadQueue: mockAddToThreadQueue,
+      getThreadQueueLength: vi.fn(() => 0),
+    })
+
     renderWithRouter()
-    
-    const sendButton = document.querySelector('[data-test-id="send-message-button"]')
+
+    const sendButton = document.querySelector(
+      '[data-test-id="send-message-button"]'
+    )
     await user.click(sendButton)
-    
-    expect(mockSendMessage).toHaveBeenCalledWith('Hello world', true, undefined)
+
+    expect(mockAddToThreadQueue).toHaveBeenCalledWith(
+      'test-thread-id',
+      'Hello world'
+    )
+    expect(mockSetPrompt).toHaveBeenCalledWith('')
   })
 
-  it('sends message when Enter key is pressed', async () => {
+  it('queues message when Enter key is pressed', async () => {
     const user = userEvent.setup()
-    
+    const mockAddToThreadQueue = vi.fn()
+
     // Mock prompt with content
     vi.mocked(usePrompt).mockReturnValue({
       prompt: 'Hello world',
       setPrompt: mockSetPrompt,
     })
-    
+
+    vi.mocked(useAppState).mockReturnValue({
+      streamingContent: null,
+      abortControllers: {},
+      loadingModel: false,
+      tools: [],
+      addToThreadQueue: mockAddToThreadQueue,
+      getThreadQueueLength: vi.fn(() => 0),
+    })
+
     renderWithRouter()
-    
+
     const textarea = screen.getByRole('textbox')
     await user.type(textarea, '{Enter}')
-    
-    expect(mockSendMessage).toHaveBeenCalledWith('Hello world', true, undefined)
+
+    expect(mockAddToThreadQueue).toHaveBeenCalledWith(
+      'test-thread-id',
+      'Hello world'
+    )
+    expect(mockSetPrompt).toHaveBeenCalledWith('')
   })
 
   it('does not send message when Shift+Enter is pressed', async () => {
     const user = userEvent.setup()
-    
+
     // Mock prompt with content
     vi.mocked(usePrompt).mockReturnValue({
       prompt: 'Hello world',
       setPrompt: mockSetPrompt,
     })
-    
+
     renderWithRouter()
-    
+
     const textarea = screen.getByRole('textbox')
     await user.type(textarea, '{Shift>}{Enter}{/Shift}')
-    
+
     expect(mockSendMessage).not.toHaveBeenCalled()
   })
 
@@ -291,31 +340,44 @@ describe('ChatInput', () => {
       abortControllers: {},
       loadingModel: false,
       tools: [],
+      addToThreadQueue: vi.fn(),
+      getThreadQueueLength: vi.fn(() => 0),
     })
-    
+
     act(() => {
       renderWithRouter()
     })
-    
+
     // Stop button should be rendered (as SVG with tabler-icon-player-stop-filled class)
     const stopButton = document.querySelector('.tabler-icon-player-stop-filled')
     expect(stopButton).toBeInTheDocument()
   })
 
+  it('shows capability icons when model supports them', () => {
+    act(() => {
+      renderWithRouter()
+    })
+
+    // Should show vision icon (rendered as SVG with tabler-icon-eye class)
+    const visionIcon = document.querySelector('.tabler-icon-eye')
+    expect(visionIcon).toBeInTheDocument()
+  })
 
   it('shows model selection dropdown', () => {
     act(() => {
       renderWithRouter()
     })
-    
+
     // Model selection dropdown should be rendered (look for popover trigger)
-    const modelDropdown = document.querySelector('[data-slot="popover-trigger"]')
+    const modelDropdown = document.querySelector(
+      '[data-slot="popover-trigger"]'
+    )
     expect(modelDropdown).toBeInTheDocument()
   })
 
   it('shows error message when no model is selected', async () => {
     const user = userEvent.setup()
-    
+
     // Mock no selected model and prompt with content
     vi.mocked(useModelProvider).mockReturnValue({
       selectedModel: null,
@@ -331,17 +393,19 @@ describe('ChatInput', () => {
       deleteModel: vi.fn(),
       deletedModels: [],
     })
-    
+
     vi.mocked(usePrompt).mockReturnValue({
       prompt: 'Hello world',
       setPrompt: mockSetPrompt,
     })
-    
+
     renderWithRouter()
-    
-    const sendButton = document.querySelector('[data-test-id="send-message-button"]')
+
+    const sendButton = document.querySelector(
+      '[data-test-id="send-message-button"]'
+    )
     await user.click(sendButton)
-    
+
     // The component should still render without crashing when no model is selected
     expect(sendButton).toBeInTheDocument()
   })
@@ -349,7 +413,7 @@ describe('ChatInput', () => {
   it('handles file upload', async () => {
     const user = userEvent.setup()
     renderWithRouter()
-    
+
     // Wait for async effects to complete (mmproj check)
     await waitFor(() => {
       // File upload is rendered as hidden input element
@@ -358,29 +422,32 @@ describe('ChatInput', () => {
     })
   })
 
-  it('disables input when streaming', () => {
+  it('allows input when streaming (for queueing)', () => {
     // Mock streaming state
     vi.mocked(useAppState).mockReturnValue({
       streamingContent: { thread_id: 'test-thread' },
       abortControllers: {},
       loadingModel: false,
       tools: [],
+      addToThreadQueue: vi.fn(),
+      getThreadQueueLength: vi.fn(() => 0),
     })
-    
+
     act(() => {
       renderWithRouter()
     })
-    
-    const textarea = screen.getByTestId('chat-input')
-    expect(textarea).toBeDisabled()
+
+    const textarea = screen.getByRole('textbox')
+    // Textarea should remain enabled to allow message queueing during streaming
+    expect(textarea).not.toBeDisabled()
   })
 
   it('shows tools dropdown when model supports tools and MCP servers are connected', async () => {
     // Mock connected servers
     mockGetConnectedServers.mockResolvedValue(['server1'])
-    
+
     renderWithRouter()
-    
+
     await waitFor(() => {
       // Tools dropdown should be rendered (as SVG icon with tabler-icon-tool class)
       const toolsIcon = document.querySelector('.tabler-icon-tool')
@@ -407,8 +474,8 @@ describe('ChatInput', () => {
       deleteModel: vi.fn(),
       deletedModels: [],
     })
-    
+
     // This test ensures the component renders without errors when using selectedProvider
     expect(() => renderWithRouter()).not.toThrow()
   })
-})
\ No newline at end of file
+})
diff --git a/web-app/src/hooks/__tests__/benchmark.memoization.test.ts b/web-app/src/hooks/__tests__/benchmark.memoization.test.ts
new file mode 100644
index 0000000000..712cf3a619
--- /dev/null
+++ b/web-app/src/hooks/__tests__/benchmark.memoization.test.ts
@@ -0,0 +1,258 @@
+import { renderHook, act } from '@testing-library/react'
+import { describe, test, expect, beforeEach } from 'vitest'
+import { useAppState } from '../useAppState'
+import {
+  useThreadState,
+  useStreamingContent,
+  useQueuedMessages,
+  useThreadQueueLength,
+} from '../useThreadState'
+
+/**
+ * BENCHMARK TESTING FOR MEMOIZATION APPROACHES
+ *
+ * This test demonstrates the performance difference between:
+ * 1. Individual hooks approach (new) - only re-renders when specific values change
+ * 2. useThreadState approach (less optimal) - creates new object on every render
+ *
+ * We'll measure:
+ * - Object creation frequency
+ * - Reference stability
+ * - Performance characteristics
+ */
+
+describe('Benchmark: Individual Hooks vs useThreadState', () => {
+  beforeEach(() => {
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  describe('Performance Characteristics', () => {
+    test('individual hooks maintain stable references', () => {
+      const threadId = 'benchmark-thread'
+
+      // Set up some state
+      const { result: appStateResult } = renderHook(() => useAppState())
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Message 1')
+        appStateResult.current.addToThreadQueue(threadId, 'Message 2')
+      })
+
+      // Test individual hooks
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+
+      const initialReference = queueResult.current
+
+      // Multiple re-renders without state changes
+      for (let i = 0; i < 100; i++) {
+        rerenderQueue()
+        // Reference should remain stable
+        expect(queueResult.current).toBe(initialReference)
+      }
+
+      // Update queue
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Message 3')
+      })
+      rerenderQueue()
+
+      // Now reference should change (because value actually changed)
+      expect(queueResult.current).not.toBe(initialReference)
+      expect(queueResult.current).toHaveLength(3)
+    })
+
+    test('useThreadState creates new objects on every render', () => {
+      const threadId = 'benchmark-thread'
+
+      // Set up some state
+      const { result: appStateResult } = renderHook(() => useAppState())
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Message 1')
+        appStateResult.current.addToThreadQueue(threadId, 'Message 2')
+      })
+
+      // Test useThreadState
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialReference = threadStateResult.current
+      const references: any[] = [initialReference]
+
+      // Multiple re-renders without state changes
+      for (let i = 0; i < 100; i++) {
+        rerenderThreadState()
+        references.push(threadStateResult.current)
+
+        // Each render creates a new object
+        expect(threadStateResult.current).not.toBe(initialReference)
+
+        // But content remains the same
+        expect(threadStateResult.current).toEqual(initialReference)
+      }
+
+      // Verify we have 101 different object references
+      const uniqueReferences = new Set(references)
+      expect(uniqueReferences.size).toBe(101)
+    })
+  })
+
+  describe('Memory Efficiency', () => {
+    test('individual hooks are memory efficient', () => {
+      const threadId = 'memory-benchmark-thread'
+
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+
+      const initialReference = queueResult.current
+
+      // Simulate many re-renders (like in a chat component)
+      for (let i = 0; i < 1000; i++) {
+        rerenderQueue()
+        // Reference should remain stable
+        expect(queueResult.current).toBe(initialReference)
+      }
+
+      // Only one object was created for the empty array
+      expect(queueResult.current).toBe(initialReference)
+    })
+
+    test('useThreadState creates many objects', () => {
+      const threadId = 'memory-benchmark-thread'
+
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialReference = threadStateResult.current
+      const references: any[] = [initialReference]
+
+      // Simulate many re-renders
+      for (let i = 0; i < 1000; i++) {
+        rerenderThreadState()
+        references.push(threadStateResult.current)
+
+        // Each render creates a new object
+        expect(threadStateResult.current).not.toBe(initialReference)
+      }
+
+      // We have 1001 different object references
+      const uniqueReferences = new Set(references)
+      expect(uniqueReferences.size).toBe(1001)
+    })
+  })
+
+  describe('Real-world Scenarios', () => {
+    test('chat component with frequent updates', () => {
+      const threadId = 'chat-component-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Simulate chat component that re-renders frequently
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+      const { result: streamingResult, rerender: rerenderStreaming } =
+        renderHook(() => useStreamingContent(threadId))
+
+      const initialQueueReference = queueResult.current
+      const initialStreamingReference = streamingResult.current
+
+      // Simulate rapid state changes (like typing indicators, message updates)
+      for (let i = 0; i < 50; i++) {
+        // Update streaming content
+        act(() => {
+          appStateResult.current.updateThreadStreamingContent(threadId, {
+            id: `streaming-${i}`,
+          } as any)
+        })
+        rerenderStreaming()
+
+        // Update queue
+        act(() => {
+          appStateResult.current.addToThreadQueue(threadId, `Message ${i}`)
+        })
+        rerenderQueue()
+
+        // Queue reference should change when queue changes
+        if (i === 0) {
+          expect(queueResult.current).not.toBe(initialQueueReference)
+        }
+
+        // Streaming reference should change when streaming changes
+        expect(streamingResult.current).not.toBe(initialStreamingReference)
+      }
+    })
+
+    test('dashboard component with multiple thread states', () => {
+      const threads = ['work', 'personal', 'project-a', 'project-b']
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up multiple threads
+      threads.forEach((threadId) => {
+        act(() => {
+          appStateResult.current.addToThreadQueue(
+            threadId,
+            `Initial message for ${threadId}`
+          )
+        })
+      })
+
+      // Create hooks for each thread
+      const threadHooks = threads.map((threadId) =>
+        renderHook(() => useQueuedMessages(threadId))
+      )
+
+      const initialReferences = threadHooks.map((hook) => hook.result.current)
+
+      // Update only one thread
+      act(() => {
+        appStateResult.current.addToThreadQueue(
+          'work',
+          'Additional work message'
+        )
+      })
+
+      // Re-render all hooks
+      threadHooks.forEach(({ rerender }) => rerender())
+
+      // Only work thread should have changed reference
+      expect(threadHooks[0].result.current).not.toBe(initialReferences[0])
+      expect(threadHooks[1].result.current).toBe(initialReferences[1])
+      expect(threadHooks[2].result.current).toBe(initialReferences[2])
+      expect(threadHooks[3].result.current).toBe(initialReferences[3])
+    })
+  })
+
+  describe('Performance Recommendations', () => {
+    test('should demonstrate optimal usage patterns', () => {
+      const threadId = 'recommendation-thread'
+
+      // ✅ GOOD: Use individual hooks when you only need specific data
+      const { result: queueLengthResult } = renderHook(() =>
+        useThreadQueueLength(threadId)
+      )
+      expect(queueLengthResult.current).toBe(0)
+
+      // ✅ GOOD: Use individual hooks for different concerns
+      const { result: streamingResult } = renderHook(() =>
+        useStreamingContent(threadId)
+      )
+      expect(streamingResult.current).toBeUndefined()
+
+      // ⚠️ LESS OPTIMAL: Use useThreadState only when you need everything
+      const { result: threadStateResult } = renderHook(() =>
+        useThreadState(threadId)
+      )
+      expect(threadStateResult.current.queueLength).toBe(0)
+      expect(threadStateResult.current.streamingContent).toBeUndefined()
+
+      // Recommendation: Use individual hooks for better performance
+      // Only use useThreadState when you actually need all properties together
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/enhancedQueue.test.ts b/web-app/src/hooks/__tests__/enhancedQueue.test.ts
new file mode 100644
index 0000000000..c4bf3e4a6d
--- /dev/null
+++ b/web-app/src/hooks/__tests__/enhancedQueue.test.ts
@@ -0,0 +1,243 @@
+import { renderHook, act } from '@testing-library/react'
+import { useAppState } from '../useAppState'
+import { useQueuedMessages, useThreadQueueLength } from '../useThreadState'
+
+/**
+ * ENHANCED QUEUE SYSTEM TESTS
+ * 
+ * Tests for the new multi-message, per-thread queue system that removes
+ * the previous limitations:
+ * - Multiple messages can be queued per thread
+ * - Queues persist when switching threads  
+ * - Input remains always enabled
+ * - Enhanced queue display and management
+ */
+
+describe('Enhanced Multi-Message Queue System', () => {
+  beforeEach(() => {
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  describe('Multi-Message Queue Per Thread', () => {
+    test('should allow multiple messages to be queued in same thread', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const messages = [
+        'First queued message',
+        'Second queued message', 
+        'Third queued message'
+      ]
+      
+      act(() => {
+        messages.forEach(message => {
+          result.current.addToThreadQueue('multi-queue-thread', message)
+        })
+      })
+      
+      const queuedMessages = result.current.queuedMessagesByThread['multi-queue-thread']
+      expect(queuedMessages).toHaveLength(3)
+      expect(queuedMessages).toEqual(messages)
+      expect(result.current.getThreadQueueLength('multi-queue-thread')).toBe(3)
+    })
+
+    test('should process queue in FIFO order', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const messages = ['First', 'Second', 'Third']
+      
+      act(() => {
+        messages.forEach(message => {
+          result.current.addToThreadQueue('fifo-thread', message)
+        })
+      })
+      
+      // Process messages in order
+      const firstMessage = result.current.removeFromThreadQueue('fifo-thread')
+      expect(firstMessage).toBe('First')
+      expect(result.current.getThreadQueueLength('fifo-thread')).toBe(2)
+      
+      const secondMessage = result.current.removeFromThreadQueue('fifo-thread')
+      expect(secondMessage).toBe('Second')
+      expect(result.current.getThreadQueueLength('fifo-thread')).toBe(1)
+      
+      const thirdMessage = result.current.removeFromThreadQueue('fifo-thread')
+      expect(thirdMessage).toBe('Third')
+      expect(result.current.getThreadQueueLength('fifo-thread')).toBe(0)
+      
+      // No more messages
+      const noMessage = result.current.removeFromThreadQueue('fifo-thread')
+      expect(noMessage).toBeUndefined()
+    })
+  })
+
+  describe('Thread Isolation and Persistence', () => {
+    test('should maintain separate queues for different threads', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        result.current.addToThreadQueue('work-thread', 'Work message 1')
+        result.current.addToThreadQueue('work-thread', 'Work message 2')
+        result.current.addToThreadQueue('personal-thread', 'Personal message 1')
+        result.current.addToThreadQueue('personal-thread', 'Personal message 2')
+        result.current.addToThreadQueue('personal-thread', 'Personal message 3')
+      })
+      
+      expect(result.current.getThreadQueueLength('work-thread')).toBe(2)
+      expect(result.current.getThreadQueueLength('personal-thread')).toBe(3)
+      
+      // Verify queue contents
+      expect(result.current.queuedMessagesByThread['work-thread']).toEqual([
+        'Work message 1',
+        'Work message 2'
+      ])
+      expect(result.current.queuedMessagesByThread['personal-thread']).toEqual([
+        'Personal message 1',
+        'Personal message 2', 
+        'Personal message 3'
+      ])
+    })
+
+    test('should persist queues when simulating thread switches', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        // User is on thread-1, queues messages
+        result.current.addToThreadQueue('thread-1', 'Message while on thread 1')
+        result.current.addToThreadQueue('thread-1', 'Another message on thread 1')
+        
+        // User switches to thread-2, queues different messages
+        result.current.addToThreadQueue('thread-2', 'Message while on thread 2')
+        
+        // User switches back to thread-1
+        // Queue should still be there (no cleanup)
+      })
+      
+      // Verify thread-1 queue persisted
+      expect(result.current.getThreadQueueLength('thread-1')).toBe(2)
+      expect(result.current.queuedMessagesByThread['thread-1']).toEqual([
+        'Message while on thread 1',
+        'Another message on thread 1'
+      ])
+      
+      // Verify thread-2 queue also exists
+      expect(result.current.getThreadQueueLength('thread-2')).toBe(1)
+      expect(result.current.queuedMessagesByThread['thread-2']).toEqual([
+        'Message while on thread 2'
+      ])
+    })
+  })
+
+  describe('Queue Management Operations', () => {
+    test('should support clearing entire thread queue', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        result.current.addToThreadQueue('clear-test-thread', 'Message 1')
+        result.current.addToThreadQueue('clear-test-thread', 'Message 2')
+        result.current.addToThreadQueue('clear-test-thread', 'Message 3')
+      })
+      
+      expect(result.current.getThreadQueueLength('clear-test-thread')).toBe(3)
+      
+      act(() => {
+        result.current.clearThreadQueue('clear-test-thread')
+      })
+      
+      expect(result.current.getThreadQueueLength('clear-test-thread')).toBe(0)
+      expect(result.current.queuedMessagesByThread['clear-test-thread']).toEqual([])
+    })
+
+    test('should handle empty queue operations gracefully', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      // Operations on empty queue should not throw
+      expect(() => {
+        const message = result.current.removeFromThreadQueue('empty-thread')
+        expect(message).toBeUndefined()
+        
+        const length = result.current.getThreadQueueLength('empty-thread') 
+        expect(length).toBe(0)
+        
+        result.current.clearThreadQueue('empty-thread')
+      }).not.toThrow()
+    })
+  })
+
+  describe('Convenience Hooks Integration', () => {
+    test('useQueuedMessages hook should return current queue for thread', () => {
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: queueResult, rerender } = renderHook(() => useQueuedMessages('hook-thread'))
+      
+      act(() => {
+        appStateResult.current.addToThreadQueue('hook-thread', 'Hooked message 1')
+        appStateResult.current.addToThreadQueue('hook-thread', 'Hooked message 2')
+      })
+      rerender()
+      
+      expect(queueResult.current).toEqual(['Hooked message 1', 'Hooked message 2'])
+    })
+
+    test('useThreadQueueLength hook should return current queue length', () => {
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: lengthResult, rerender } = renderHook(() => useThreadQueueLength('length-thread'))
+      
+      // Initially 0
+      expect(lengthResult.current).toBe(0)
+      
+      act(() => {
+        appStateResult.current.addToThreadQueue('length-thread', 'Message 1')
+        appStateResult.current.addToThreadQueue('length-thread', 'Message 2')
+      })
+      rerender()
+      
+      expect(lengthResult.current).toBe(2)
+      
+      act(() => {
+        appStateResult.current.removeFromThreadQueue('length-thread')
+      })
+      rerender()
+      
+      expect(lengthResult.current).toBe(1)
+    })
+  })
+
+  describe('Performance and Edge Cases', () => {
+    test('should handle large queues efficiently', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const largeQueue = Array.from({ length: 100 }, (_, i) => `Message ${i + 1}`)
+      
+      act(() => {
+        largeQueue.forEach(message => {
+          result.current.addToThreadQueue('large-queue-thread', message)
+        })
+      })
+      
+      expect(result.current.getThreadQueueLength('large-queue-thread')).toBe(100)
+      expect(result.current.queuedMessagesByThread['large-queue-thread'][0]).toBe('Message 1')
+      expect(result.current.queuedMessagesByThread['large-queue-thread'][99]).toBe('Message 100')
+    })
+
+    test('should handle rapid queue operations without corruption', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        // Rapid add/remove operations
+        for (let i = 0; i < 50; i++) {
+          result.current.addToThreadQueue('rapid-thread', `Rapid message ${i}`)
+          if (i % 3 === 0) {
+            result.current.removeFromThreadQueue('rapid-thread')
+          }
+        }
+      })
+      
+      // Should have consistent state
+      const finalLength = result.current.getThreadQueueLength('rapid-thread')
+      expect(finalLength).toBeGreaterThan(0)
+      expect(result.current.queuedMessagesByThread['rapid-thread']).toHaveLength(finalLength)
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/mvp-integration.test.ts b/web-app/src/hooks/__tests__/mvp-integration.test.ts
new file mode 100644
index 0000000000..ef25f9c08e
--- /dev/null
+++ b/web-app/src/hooks/__tests__/mvp-integration.test.ts
@@ -0,0 +1,553 @@
+/**
+ * MVP Integration Tests
+ * End-to-end workflow tests, multi-thread scenarios, and error handling validation
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { renderHook, act, waitFor } from '@testing-library/react'
+import {
+  createMultiThreadScenario,
+  createConcurrentMessageBatch,
+  createMockSendMessage,
+  MockScheduler,
+  waitForQueueToProcess,
+  withTimeout,
+  createMockThread,
+  createMockMessage,
+  PerformanceTimer,
+} from '@/test/simultaneous-inference-utils'
+
+// Integration test scenarios
+describe('MVP Integration Tests', () => {
+  let mockSendMessage: ReturnType<typeof createMockSendMessage>
+  let mockScheduler: MockScheduler
+  let performanceTimer: PerformanceTimer
+
+  beforeEach(() => {
+    mockSendMessage = createMockSendMessage({
+      delay: 50,
+      failureRate: 0.1,
+      processingTime: 200,
+    })
+
+    mockScheduler = new MockScheduler({
+      maxConcurrent: 3,
+      processingDelay: 100,
+      queueDelay: 20,
+    })
+
+    performanceTimer = new PerformanceTimer()
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    mockScheduler.clearQueue()
+    vi.restoreAllMocks()
+  })
+
+  describe('End-to-End Workflow Tests', () => {
+    it('should complete full message lifecycle across multiple threads', async () => {
+      const threads = createMultiThreadScenario(3)
+      const messages = createConcurrentMessageBatch(threads, 2)
+
+      performanceTimer.start()
+
+      // Stage 1: Queue messages
+      const queuePromises = messages.map(async (message) => {
+        await mockScheduler.enqueue({
+          id: `queue-${message.id}`,
+          threadId: message.threadId,
+          messageId: message.id,
+          priority: 1,
+          timestamp: message.timestamp,
+        })
+        return message
+      })
+
+      const queuedMessages = await Promise.all(queuePromises)
+      performanceTimer.mark('messages-queued')
+
+      // Stage 2: Process messages through sendMessage
+      const processingPromises = queuedMessages.map(async (message) => {
+        const result = await mockSendMessage(message.threadId, message.content)
+        return { message, result }
+      })
+
+      const processedResults = await Promise.all(processingPromises)
+      performanceTimer.mark('messages-processed')
+
+      // Stage 3: Verify completion
+      await waitForQueueToProcess(
+        () => mockScheduler.getQueueStatus().queueLength,
+        5000
+      )
+
+      const totalDuration = performanceTimer.stop()
+      const intervals = performanceTimer.getIntervals()
+
+      // Assertions
+      expect(queuedMessages).toHaveLength(messages.length)
+      expect(processedResults).toHaveLength(messages.length)
+
+      const successfulProcessing = processedResults.filter(
+        (r) => r.result.success
+      )
+      expect(successfulProcessing.length).toBeGreaterThan(messages.length * 0.8) // 80% success rate
+
+      expect(totalDuration).toBeLessThan(5000) // Complete within 5 seconds
+      expect(intervals).toContainEqual(
+        expect.objectContaining({ name: 'messages-queued' })
+      )
+      expect(intervals).toContainEqual(
+        expect.objectContaining({ name: 'messages-processed' })
+      )
+    })
+
+    it('should handle thread switching during message processing', async () => {
+      const thread1 = createMockThread({ id: 'thread-1', model: 'model-a' })
+      const thread2 = createMockThread({ id: 'thread-2', model: 'model-b' })
+
+      // Create interleaved messages (simulating user switching between threads)
+      const interleavedMessages = [
+        createMockMessage(thread1.id, { content: 'Thread 1 - Message 1' }),
+        createMockMessage(thread2.id, { content: 'Thread 2 - Message 1' }),
+        createMockMessage(thread1.id, { content: 'Thread 1 - Message 2' }),
+        createMockMessage(thread2.id, { content: 'Thread 2 - Message 2' }),
+        createMockMessage(thread1.id, { content: 'Thread 1 - Message 3' }),
+      ]
+
+      const results: any[] = []
+
+      // Process messages with timing to simulate real user behavior
+      for (const message of interleavedMessages) {
+        const processingPromise = mockSendMessage(
+          message.threadId,
+          message.content
+        )
+        results.push(await processingPromise)
+
+        // Small delay between messages (simulating typing time)
+        await new Promise((resolve) => setTimeout(resolve, 30))
+      }
+
+      // Verify both threads processed messages
+      const thread1Results = results.filter((r) => r.threadId === thread1.id)
+      const thread2Results = results.filter((r) => r.threadId === thread2.id)
+
+      expect(thread1Results).toHaveLength(3)
+      expect(thread2Results).toHaveLength(2)
+      expect(results.every((r) => r.success || !r.success)).toBe(true) // All have success property
+    })
+
+    it('should maintain state consistency across concurrent operations', async () => {
+      const threads = createMultiThreadScenario(4)
+      const stateTracker = new Map<string, any>()
+
+      // Mock state management functions
+      const updateThreadState = vi.fn((threadId: string, update: any) => {
+        const current = stateTracker.get(threadId) || {
+          messages: [],
+          status: 'idle',
+        }
+        stateTracker.set(threadId, { ...current, ...update })
+      })
+
+      const getThreadState = vi.fn((threadId: string) => {
+        return stateTracker.get(threadId) || { messages: [], status: 'idle' }
+      })
+
+      // Initialize thread states
+      threads.forEach((thread) => {
+        updateThreadState(thread.id, {
+          model: thread.model,
+          status: 'idle',
+          messages: [],
+        })
+      })
+
+      // Simulate concurrent state updates
+      const messages = createConcurrentMessageBatch(threads, 3)
+      const stateUpdatePromises = messages.map(async (message) => {
+        // Add message to thread
+        const currentState = getThreadState(message.threadId)
+        updateThreadState(message.threadId, {
+          status: 'processing',
+          messages: [...currentState.messages, message],
+        })
+
+        // Simulate processing
+        const result = await mockSendMessage(message.threadId, message.content)
+
+        // Update with result
+        const finalState = getThreadState(message.threadId)
+        updateThreadState(message.threadId, {
+          status: result.success ? 'idle' : 'error',
+          lastProcessed: Date.now(),
+        })
+
+        return { message, result, finalState: getThreadState(message.threadId) }
+      })
+
+      const results = await Promise.all(stateUpdatePromises)
+
+      // Verify state consistency
+      threads.forEach((thread) => {
+        const finalState = getThreadState(thread.id)
+        expect(finalState).toBeDefined()
+        expect(finalState.messages).toBeDefined()
+        expect(['idle', 'processing', 'error']).toContain(finalState.status)
+
+        const threadMessages = messages.filter((m) => m.threadId === thread.id)
+        expect(finalState.messages).toHaveLength(threadMessages.length)
+      })
+
+      expect(updateThreadState).toHaveBeenCalled()
+      expect(getThreadState).toHaveBeenCalled()
+    })
+  })
+
+  describe('Multi-Thread Scenario Tests', () => {
+    it('should handle high-load scenario with 10 concurrent threads', async () => {
+      const threads = createMultiThreadScenario(10)
+      const messages = createConcurrentMessageBatch(threads, 5) // 50 total messages
+
+      performanceTimer.start()
+
+      // Process all messages concurrently
+      const processingPromises = messages.map(async (message, index) => {
+        // Stagger the start times slightly to simulate real usage
+        await new Promise((resolve) => setTimeout(resolve, index * 10))
+
+        const result = await mockSendMessage(message.threadId, message.content)
+        return { message, result, processingOrder: index }
+      })
+
+      const results = await withTimeout(
+        Promise.all(processingPromises),
+        15000 // 15 second timeout for high load
+      )
+
+      const duration = performanceTimer.stop()
+
+      // Analyze results
+      const successCount = results.filter((r) => r.result.success).length
+      const threadsUsed = new Set(results.map((r) => r.message.threadId)).size
+      const averageProcessingTime = duration / results.length
+
+      expect(results).toHaveLength(50)
+      expect(successCount).toBeGreaterThan(40) // At least 80% success
+      expect(threadsUsed).toBe(10) // All threads were used
+      expect(averageProcessingTime).toBeLessThan(300) // Reasonable per-message time
+      expect(duration).toBeLessThan(15000) // Complete within timeout
+    })
+
+    it('should maintain thread isolation during concurrent processing', async () => {
+      const threads = createMultiThreadScenario(5)
+      const threadStates = new Map<
+        string,
+        { processing: boolean; lastMessage?: string }
+      >()
+
+      // Initialize thread states
+      threads.forEach((thread) => {
+        threadStates.set(thread.id, { processing: false })
+      })
+
+      // Mock thread-specific processing
+      const processMessageForThread = vi.fn(
+        async (threadId: string, content: string) => {
+          // Check isolation - this thread shouldn't be processing
+          const state = threadStates.get(threadId)
+          expect(state?.processing).toBe(false)
+
+          // Mark as processing
+          threadStates.set(threadId, { processing: true, lastMessage: content })
+
+          try {
+            const result = await mockSendMessage(threadId, content)
+            return result
+          } finally {
+            // Mark as completed
+            threadStates.set(threadId, {
+              processing: false,
+              lastMessage: content,
+            })
+          }
+        }
+      )
+
+      const messages = createConcurrentMessageBatch(threads, 3)
+      const isolationPromises = messages.map((message) =>
+        processMessageForThread(message.threadId, message.content)
+      )
+
+      await Promise.all(isolationPromises)
+
+      // Verify isolation was maintained
+      expect(processMessageForThread).toHaveBeenCalledTimes(messages.length)
+
+      // All threads should be idle after processing
+      threads.forEach((thread) => {
+        const finalState = threadStates.get(thread.id)
+        expect(finalState?.processing).toBe(false)
+        expect(finalState?.lastMessage).toBeDefined()
+      })
+    })
+  })
+
+  describe('Error Handling Validation', () => {
+    it('should recover gracefully from processing failures', async () => {
+      // Configure mock with higher failure rate
+      const flakyMockSendMessage = createMockSendMessage({
+        delay: 50,
+        failureRate: 0.4, // 40% failure rate
+        processingTime: 100,
+      })
+
+      const threads = createMultiThreadScenario(3)
+      const messages = createConcurrentMessageBatch(threads, 4)
+
+      const retryableProcess = async (message: any, maxRetries = 2) => {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            const result = await flakyMockSendMessage(
+              message.threadId,
+              message.content
+            )
+            if (result.success) {
+              return { ...result, attempt, recovered: attempt > 0 }
+            }
+            throw new Error(result.error || 'Processing failed')
+          } catch (error) {
+            if (attempt === maxRetries) {
+              return {
+                success: false,
+                messageId: '',
+                threadId: message.threadId,
+                error: (error as Error).message,
+                attempt,
+                recovered: false,
+              }
+            }
+            // Wait before retry
+            await new Promise((resolve) => setTimeout(resolve, 100))
+          }
+        }
+      }
+
+      const results = await Promise.all(
+        messages.map((message) => retryableProcess(message))
+      )
+
+      const successful = results.filter((r) => r.success)
+      const recovered = results.filter((r) => r.recovered)
+      const failed = results.filter((r) => !r.success)
+
+      // Should have better success rate due to retries
+      expect(successful.length).toBeGreaterThan(messages.length * 0.6) // At least 60%
+      expect(recovered.length).toBeGreaterThan(0) // Some recoveries should occur
+
+      // Failures should be properly handled
+      failed.forEach((result) => {
+        expect(result.error).toBeDefined()
+        expect(result.attempt).toBe(2) // Should have retried
+      })
+    })
+
+    it('should handle queue overflow scenarios', async () => {
+      const smallScheduler = new MockScheduler({
+        maxConcurrent: 1, // Very limited concurrency
+        processingDelay: 200,
+        queueDelay: 50,
+      })
+
+      const threads = createMultiThreadScenario(2)
+      const manyMessages = createConcurrentMessageBatch(threads, 10) // 20 messages
+
+      const queueResults: any[] = []
+      let overflowCount = 0
+
+      // Simulate queue overflow handling
+      for (const message of manyMessages) {
+        try {
+          await smallScheduler.enqueue({
+            id: `queue-${message.id}`,
+            threadId: message.threadId,
+            messageId: message.id,
+            priority: 1,
+            timestamp: message.timestamp,
+          })
+          queueResults.push({ queued: true, messageId: message.id })
+        } catch (error) {
+          overflowCount++
+          queueResults.push({ queued: false, messageId: message.id, error })
+        }
+      }
+
+      // Wait for queue to process
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+
+      const queueStatus = smallScheduler.getQueueStatus()
+
+      // Should handle overflow gracefully
+      expect(queueResults).toHaveLength(manyMessages.length)
+      expect(queueStatus.queueLength).toBeGreaterThanOrEqual(0)
+      expect(queueStatus.processing.length).toBeLessThanOrEqual(1)
+    })
+
+    it('should handle network timeout scenarios', async () => {
+      const timeoutMockSendMessage = vi
+        .fn()
+        .mockImplementation(async (threadId: string) => {
+          // Simulate random timeouts (20% chance)
+          if (Math.random() < 0.2) {
+            await new Promise((resolve) => setTimeout(resolve, 6000)) // 6s timeout
+            throw new Error('Network timeout')
+          }
+
+          await new Promise((resolve) => setTimeout(resolve, 100))
+          return { success: true, messageId: 'msg-123', threadId }
+        })
+
+      const messages = createConcurrentMessageBatch(
+        createMultiThreadScenario(3),
+        3
+      )
+
+      const timeoutResults = await Promise.allSettled(
+        messages.map((message) =>
+          withTimeout(
+            timeoutMockSendMessage(message.threadId, message.content),
+            1000, // 1s timeout
+            `Timeout processing ${message.id}`
+          )
+        )
+      )
+
+      const successful = timeoutResults.filter((r) => r.status === 'fulfilled')
+      const timedOut = timeoutResults.filter((r) => r.status === 'rejected')
+
+      // Should handle timeouts without crashing
+      expect(successful.length + timedOut.length).toBe(messages.length)
+
+      timedOut.forEach((result) => {
+        if (result.status === 'rejected') {
+          expect(result.reason.message).toMatch(/timeout/i)
+        }
+      })
+    })
+  })
+
+  describe('Edge Case Testing Framework', () => {
+    it('should handle rapid thread creation and deletion', async () => {
+      const threadLifecycle = new Map<
+        string,
+        { created: number; deleted?: number }
+      >()
+      const activeThreads = new Set<string>()
+
+      const createThread = (id: string) => {
+        threadLifecycle.set(id, { created: Date.now() })
+        activeThreads.add(id)
+      }
+
+      const deleteThread = (id: string) => {
+        const lifecycle = threadLifecycle.get(id)
+        if (lifecycle) {
+          lifecycle.deleted = Date.now()
+        }
+        activeThreads.delete(id)
+      }
+
+      // Rapidly create and delete threads
+      for (let i = 0; i < 20; i++) {
+        const threadId = `rapid-thread-${i}`
+        createThread(threadId)
+
+        // Create some messages for this thread
+        const message = createMockMessage(threadId, {
+          content: `Message for ${threadId}`,
+        })
+
+        // Process message
+        const processPromise = mockSendMessage(threadId, message.content)
+
+        // Randomly delete thread during or after processing
+        if (Math.random() < 0.3) {
+          setTimeout(() => deleteThread(threadId), Math.random() * 100)
+        }
+
+        await processPromise
+
+        if (activeThreads.has(threadId) && Math.random() < 0.7) {
+          deleteThread(threadId)
+        }
+      }
+
+      // Verify tracking worked correctly
+      expect(threadLifecycle.size).toBe(20)
+
+      const completedLifecycles = Array.from(threadLifecycle.values()).filter(
+        (lifecycle) => lifecycle.deleted
+      )
+
+      expect(completedLifecycles.length).toBeGreaterThan(0)
+      expect(activeThreads.size).toBeLessThan(20)
+    })
+
+    it('should handle malformed message data gracefully', async () => {
+      const malformedMessages = [
+        { threadId: '', content: 'Empty thread ID' },
+        { threadId: 'valid-thread', content: '' },
+        { threadId: 'valid-thread', content: null as any },
+        { threadId: 'valid-thread', content: undefined as any },
+        { threadId: 'valid-thread', content: {} as any },
+        { threadId: null as any, content: 'Null thread ID' },
+      ]
+
+      const sanitizeMockSendMessage = vi
+        .fn()
+        .mockImplementation(async (threadId: string, content: string) => {
+          // Validate inputs
+          if (!threadId || typeof threadId !== 'string') {
+            return {
+              success: false,
+              messageId: '',
+              threadId: threadId || 'unknown',
+              error: 'Invalid thread ID',
+            }
+          }
+
+          if (!content || typeof content !== 'string') {
+            return {
+              success: false,
+              messageId: '',
+              threadId,
+              error: 'Invalid message content',
+            }
+          }
+
+          return { success: true, messageId: 'msg-123', threadId }
+        })
+
+      const results = await Promise.all(
+        malformedMessages.map((msg) =>
+          sanitizeMockSendMessage(msg.threadId, msg.content)
+        )
+      )
+
+      // Should handle all malformed messages without crashing
+      expect(results).toHaveLength(malformedMessages.length)
+
+      const errors = results.filter((r) => !r.success)
+      expect(errors.length).toBeGreaterThan(0) // Should detect issues
+
+      errors.forEach((error) => {
+        expect(error.error).toBeDefined()
+        expect(['Invalid thread ID', 'Invalid message content']).toContain(
+          error.error
+        )
+      })
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/mvp-performance.test.ts b/web-app/src/hooks/__tests__/mvp-performance.test.ts
new file mode 100644
index 0000000000..59c279cdaa
--- /dev/null
+++ b/web-app/src/hooks/__tests__/mvp-performance.test.ts
@@ -0,0 +1,389 @@
+/**
+ * MVP Performance Tests
+ * Performance regression tests, memory leak detection, and baseline comparison
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { renderHook, act } from '@testing-library/react'
+import {
+  PerformanceTimer,
+  createMemoryMonitor,
+  createStateUpdateTracker,
+  createMultiThreadScenario,
+  createConcurrentMessageBatch,
+  waitForConcurrentOperations,
+  withTimeout,
+  createBatchOperationTester,
+} from '@/test/simultaneous-inference-utils'
+
+// Performance thresholds based on baseline
+const PERFORMANCE_THRESHOLDS = {
+  // Message processing should complete within 5 seconds for 10 concurrent messages
+  CONCURRENT_PROCESSING_TIMEOUT: 5000,
+
+  // Memory usage should not increase by more than 50MB during test
+  MAX_MEMORY_INCREASE: 50 * 1024 * 1024, // 50MB in bytes
+
+  // State updates should not exceed 100 per second during heavy load
+  MAX_STATE_UPDATE_RATE: 100,
+
+  // Queue processing delay should be under 100ms per item
+  MAX_QUEUE_PROCESSING_DELAY: 100,
+
+  // Batch operations should scale linearly (max 2x overhead)
+  MAX_BATCH_OVERHEAD: 2.0,
+}
+
+describe('MVP Performance Tests', () => {
+  let performanceTimer: PerformanceTimer
+  let memoryMonitor: ReturnType<typeof createMemoryMonitor>
+  let stateTracker: ReturnType<typeof createStateUpdateTracker>
+
+  beforeEach(() => {
+    performanceTimer = new PerformanceTimer()
+    memoryMonitor = createMemoryMonitor()
+    stateTracker = createStateUpdateTracker()
+
+    // Clear any existing timers
+    vi.clearAllTimers()
+  })
+
+  afterEach(() => {
+    performanceTimer.reset()
+    stateTracker.reset()
+    vi.restoreAllMocks()
+  })
+
+  describe('Concurrent Processing Performance', () => {
+    it('should handle 10 concurrent messages within performance threshold', async () => {
+      const threads = createMultiThreadScenario(5)
+      const messages = createConcurrentMessageBatch(threads, 2)
+
+      performanceTimer.start()
+
+      // Simulate concurrent message processing
+      const operations = messages.map(
+        (message, index) =>
+          new Promise((resolve) => {
+            setTimeout(() => {
+              stateTracker.track(`message-${index}`)
+              resolve({ messageId: message.id, processed: true })
+            }, Math.random() * 100) // Random delay 0-100ms
+          })
+      )
+
+      const result = await withTimeout(
+        waitForConcurrentOperations(
+          operations,
+          PERFORMANCE_THRESHOLDS.CONCURRENT_PROCESSING_TIMEOUT
+        ),
+        PERFORMANCE_THRESHOLDS.CONCURRENT_PROCESSING_TIMEOUT
+      )
+
+      const duration = performanceTimer.stop()
+
+      expect(result.successful).toBe(messages.length)
+      expect(result.failed).toBe(0)
+      expect(duration).toBeLessThan(
+        PERFORMANCE_THRESHOLDS.CONCURRENT_PROCESSING_TIMEOUT
+      )
+
+      // Verify state update rate is within threshold
+      const updateRate = stateTracker.getUpdateRate()
+      expect(updateRate).toBeLessThan(
+        PERFORMANCE_THRESHOLDS.MAX_STATE_UPDATE_RATE
+      )
+    })
+
+    it('should scale processing time linearly with message count', async () => {
+      const messageCounts = [5, 10, 20]
+      const processingTimes: number[] = []
+
+      for (const count of messageCounts) {
+        const threads = createMultiThreadScenario(Math.ceil(count / 2))
+        const messages = createConcurrentMessageBatch(threads, 2).slice(
+          0,
+          count
+        )
+
+        performanceTimer.start()
+
+        const operations = messages.map(
+          (message) =>
+            new Promise((resolve) => {
+              setTimeout(() => resolve({ messageId: message.id }), 50)
+            })
+        )
+
+        await waitForConcurrentOperations(operations)
+        const duration = performanceTimer.stop()
+        processingTimes.push(duration)
+      }
+
+      // Verify linear scaling (each doubling should not more than double time)
+      const scaleFactor1 = processingTimes[1] / processingTimes[0]
+      const scaleFactor2 = processingTimes[2] / processingTimes[1]
+
+      expect(scaleFactor1).toBeLessThan(
+        PERFORMANCE_THRESHOLDS.MAX_BATCH_OVERHEAD
+      )
+      expect(scaleFactor2).toBeLessThan(
+        PERFORMANCE_THRESHOLDS.MAX_BATCH_OVERHEAD
+      )
+    })
+  })
+
+  describe('Memory Usage Tests', () => {
+    it('should not have significant memory leaks during concurrent processing', async () => {
+      // Force garbage collection if available (for Node.js environments)
+      if (global.gc) {
+        global.gc()
+      }
+
+      const initialMemory = memoryMonitor.getCurrentMemory()
+      const threads = createMultiThreadScenario(10)
+      const messages = createConcurrentMessageBatch(threads, 5)
+
+      // Simulate heavy concurrent processing
+      for (let iteration = 0; iteration < 3; iteration++) {
+        const operations = messages.map(
+          (message) =>
+            new Promise((resolve) => {
+              // Create some temporary objects to test cleanup
+              const tempData = new Array(1000).fill(0).map(() => ({
+                id: message.id,
+                data: new Array(100).fill(Math.random()),
+              }))
+
+              setTimeout(() => {
+                // Clear temp data
+                tempData.length = 0
+                resolve({ processed: true })
+              }, 10)
+            })
+        )
+
+        await waitForConcurrentOperations(operations)
+
+        // Force garbage collection between iterations
+        if (global.gc) {
+          global.gc()
+        }
+      }
+
+      const memoryDelta = memoryMonitor.getMemoryDelta()
+
+      if (memoryDelta && initialMemory) {
+        expect(memoryDelta.usedDelta).toBeLessThan(
+          PERFORMANCE_THRESHOLDS.MAX_MEMORY_INCREASE
+        )
+      }
+    })
+
+    it('should clean up resources when components unmount', async () => {
+      const cleanup = vi.fn()
+
+      // Mock a hook that creates resources
+      const mockHook = () => {
+        const resources = new Map()
+
+        const addResource = (id: string, data: any) => {
+          resources.set(id, data)
+        }
+
+        const cleanupResources = () => {
+          resources.clear()
+          cleanup()
+        }
+
+        return {
+          addResource,
+          cleanupResources,
+          get resourceCount() {
+            return resources.size
+          },
+        }
+      }
+
+      const { result, unmount } = renderHook(mockHook)
+
+      // Add some resources
+      act(() => {
+        result.current.addResource('1', { data: new Array(1000).fill(0) })
+        result.current.addResource('2', { data: new Array(1000).fill(1) })
+      })
+
+      expect(result.current.resourceCount).toBe(2)
+
+      // Unmount should trigger cleanup
+      unmount()
+
+      expect(cleanup).toHaveBeenCalled()
+    })
+  })
+
+  describe('State Update Efficiency', () => {
+    it('should batch state updates efficiently', async () => {
+      stateTracker.reset()
+
+      // Simulate rapid state updates
+      const updatePromises = Array.from(
+        { length: 20 },
+        (_, index) =>
+          new Promise((resolve) => {
+            setTimeout(() => {
+              stateTracker.track(`batch-update-${index}`)
+              resolve(index)
+            }, index * 10) // Stagger updates every 10ms
+          })
+      )
+
+      await Promise.all(updatePromises)
+
+      const updateRate = stateTracker.getUpdateRate(500) // Check rate over last 500ms
+      expect(updateRate).toBeLessThan(
+        PERFORMANCE_THRESHOLDS.MAX_STATE_UPDATE_RATE
+      )
+
+      const totalUpdates = stateTracker.getUpdateCount()
+      expect(totalUpdates).toBe(20)
+    })
+
+    it('should handle burst updates without performance degradation', async () => {
+      const burstSize = 50
+      const burstInterval = 100 // 100ms burst window
+
+      performanceTimer.start()
+
+      // Create burst of updates
+      const burstPromises = Array.from(
+        { length: burstSize },
+        (_, index) =>
+          new Promise((resolve) => {
+            // All updates within burst interval
+            setTimeout(() => {
+              stateTracker.track(`burst-${index}`)
+              resolve(index)
+            }, Math.random() * burstInterval)
+          })
+      )
+
+      await Promise.all(burstPromises)
+      const burstDuration = performanceTimer.stop()
+
+      // Burst should complete within reasonable time
+      expect(burstDuration).toBeLessThan(burstInterval * 2)
+
+      // All updates should be tracked
+      expect(stateTracker.getUpdateCount()).toBe(burstSize)
+    })
+  })
+
+  describe('Batch Operations Performance', () => {
+    it('should process batches efficiently with controlled concurrency', async () => {
+      const batchTester = createBatchOperationTester(5)
+      const items = Array.from({ length: 25 }, (_, index) => ({
+        id: index,
+        data: `item-${index}`,
+      }))
+
+      performanceTimer.start()
+
+      const results = await batchTester.runInBatches(
+        items,
+        async (item, index) => {
+          // Simulate async operation
+          await new Promise((resolve) => setTimeout(resolve, 20))
+          stateTracker.track(`batch-item-${index}`)
+          return { processed: item.id }
+        },
+        { concurrency: 3, delay: 10 }
+      )
+
+      const duration = performanceTimer.stop()
+
+      expect(results).toHaveLength(25)
+      expect(stateTracker.getUpdateCount()).toBe(25)
+
+      // Should be more efficient than sequential processing
+      const sequentialEstimate = items.length * 20 // 20ms per item
+      expect(duration).toBeLessThan(sequentialEstimate)
+    })
+  })
+
+  describe('Performance Baseline Comparison', () => {
+    it('should meet or exceed baseline performance metrics', async () => {
+      // These would be loaded from performance_baseline.json in real implementation
+      const baselineMetrics = {
+        averageProcessingTime: 200, // ms
+        maxConcurrentOperations: 10,
+        memoryUsageLimit: 100 * 1024 * 1024, // 100MB
+      }
+
+      const threads = createMultiThreadScenario(5)
+      const messages = createConcurrentMessageBatch(threads, 2)
+
+      performanceTimer.start()
+
+      const operations = messages.map(
+        (message, index) =>
+          new Promise((resolve) => {
+            const processingTime = Math.random() * 150 // 0-150ms random
+            setTimeout(() => {
+              resolve({ messageId: message.id, processingTime })
+            }, processingTime)
+          })
+      )
+
+      const result = await waitForConcurrentOperations(operations)
+      const totalDuration = performanceTimer.stop()
+      const averageProcessingTime = totalDuration / messages.length
+
+      // Performance should meet baseline expectations
+      expect(averageProcessingTime).toBeLessThan(
+        baselineMetrics.averageProcessingTime
+      )
+      expect(result.successful).toBe(messages.length)
+
+      const memoryDelta = memoryMonitor.getMemoryDelta()
+      if (memoryDelta) {
+        expect(Math.abs(memoryDelta.usedDelta)).toBeLessThan(
+          baselineMetrics.memoryUsageLimit
+        )
+      }
+    })
+  })
+
+  describe('Error Recovery Performance', () => {
+    it('should handle errors without significant performance impact', async () => {
+      const threads = createMultiThreadScenario(5)
+      const messages = createConcurrentMessageBatch(threads, 2)
+
+      performanceTimer.start()
+
+      // Simulate operations with 30% failure rate
+      const operations = messages.map(
+        (message, index) =>
+          new Promise((resolve, reject) => {
+            setTimeout(() => {
+              if (Math.random() < 0.3) {
+                reject(new Error(`Processing failed for ${message.id}`))
+              } else {
+                resolve({ messageId: message.id, processed: true })
+              }
+            }, 50)
+          })
+      )
+
+      const result = await waitForConcurrentOperations(operations)
+      const duration = performanceTimer.stop()
+
+      // Should complete within reasonable time despite errors
+      expect(duration).toBeLessThan(1000)
+      expect(result.successful + result.failed).toBe(messages.length)
+
+      // Some operations should succeed
+      expect(result.successful).toBeGreaterThan(0)
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/perThreadIntegration.test.ts b/web-app/src/hooks/__tests__/perThreadIntegration.test.ts
new file mode 100644
index 0000000000..91bf9ee211
--- /dev/null
+++ b/web-app/src/hooks/__tests__/perThreadIntegration.test.ts
@@ -0,0 +1,144 @@
+import { renderHook, act } from '@testing-library/react'
+import { ThreadMessage } from '@janhq/core'
+import { useAppState } from '../useAppState'
+import { 
+  useStreamingContent, 
+  useThreadError, 
+  useTokenSpeed,
+  useQueuedMessage,
+  useIsThreadActive,
+  useThreadState 
+} from '../useThreadState'
+
+/**
+ * INTEGRATION TESTS FOR PER-THREAD STATE MANAGEMENT
+ * 
+ * These tests validate that the complete per-thread system works
+ * correctly with real usage patterns and edge cases.
+ */
+
+const createMockThreadMessage = (id: string, content: string): ThreadMessage => ({
+  id,
+  thread_id: 'test-thread',
+  content: [{ type: 'text', text: { value: content } }],
+  role: 'assistant',
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  status: 'ready',
+  metadata: {}
+})
+
+describe('Per-Thread State Management - Integration Tests', () => {
+  beforeEach(() => {
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  test('FULL LIFECYCLE: complete thread lifecycle with all state types', () => {
+    const { result: appStateResult } = renderHook(() => useAppState())
+    const { result: threadStateResult, rerender } = renderHook(() => useThreadState('integration-thread'))
+    
+    const testMessage = createMockThreadMessage('integration', 'Test streaming message')
+    const testError = 'Test error message'
+    const testQueuedMessage = 'Test queued message'
+    const testTokenSpeed = {
+      tokenSpeed: 50,
+      tokenCount: 100,
+      lastTimestamp: Date.now(),
+      message: 'test-msg-id'
+    }
+
+    act(() => {
+      // Set all types of state for one thread
+      appStateResult.current.updateStreamingContent('integration-thread', testMessage)
+      appStateResult.current.setThreadError('integration-thread', testError)
+      appStateResult.current.setQueuedMessage('integration-thread', testQueuedMessage)
+      appStateResult.current.updateTokenSpeed('integration-thread', testTokenSpeed)
+    })
+    rerender()
+
+    // Verify all state is accessible through thread state hook
+    expect(threadStateResult.current.streamingContent).toEqual(testMessage)
+    expect(threadStateResult.current.error).toEqual(testError)
+    expect(threadStateResult.current.queuedMessage).toEqual(testQueuedMessage)
+    expect(threadStateResult.current.tokenSpeed).toEqual(testTokenSpeed)
+    expect(threadStateResult.current.isActive).toBe(true)
+
+    // Clear everything
+    act(() => {
+      appStateResult.current.clearThread('integration-thread')
+    })
+    rerender()
+
+    // Verify complete cleanup
+    expect(threadStateResult.current.streamingContent).toBeUndefined()
+    expect(threadStateResult.current.error).toBeUndefined()
+    expect(threadStateResult.current.queuedMessage).toBeUndefined()
+    expect(threadStateResult.current.tokenSpeed).toBeUndefined()
+    expect(threadStateResult.current.isActive).toBe(false)
+  })
+
+  test('CONCURRENT THREADS: multiple threads with different states', () => {
+    const { result: appStateResult } = renderHook(() => useAppState())
+    const { result: thread1State, rerender: rerender1 } = renderHook(() => useThreadState('concurrent-1'))
+    const { result: thread2State, rerender: rerender2 } = renderHook(() => useThreadState('concurrent-2'))
+
+    const message1 = createMockThreadMessage('msg1', 'Thread 1 message')
+    const message2 = createMockThreadMessage('msg2', 'Thread 2 message')
+
+    act(() => {
+      // Thread 1: streaming + error
+      appStateResult.current.updateStreamingContent('concurrent-1', message1)
+      appStateResult.current.setThreadError('concurrent-1', 'Thread 1 error')
+      
+      // Thread 2: queued message only
+      appStateResult.current.setQueuedMessage('concurrent-2', 'Thread 2 queued')
+    })
+    rerender1()
+    rerender2()
+
+    // Thread 1 should have streaming + error
+    expect(thread1State.current.streamingContent).toEqual(message1)
+    expect(thread1State.current.error).toEqual('Thread 1 error')
+    expect(thread1State.current.queuedMessage).toBeUndefined()
+    expect(thread1State.current.isActive).toBe(true)
+
+    // Thread 2 should have queued message only
+    expect(thread2State.current.streamingContent).toBeUndefined()
+    expect(thread2State.current.error).toBeUndefined()
+    expect(thread2State.current.queuedMessage).toEqual('Thread 2 queued')
+    expect(thread2State.current.isActive).toBe(false)
+  })
+
+  test('BACKWARD COMPATIBILITY: legacy and new APIs work together', () => {
+    const { result: appStateResult } = renderHook(() => useAppState())
+    
+    const legacyMessage = createMockThreadMessage('legacy', 'Legacy message')
+    const newMessage = createMockThreadMessage('new', 'New API message')
+
+    act(() => {
+      // Use legacy API (single parameter)
+      appStateResult.current.updateStreamingContent(legacyMessage)
+      appStateResult.current.setQueuedMessage('legacy queue message')
+      
+      // Use new API (threadId parameter)
+      appStateResult.current.updateStreamingContent('new-api-thread', newMessage)
+      appStateResult.current.setQueuedMessage('new-api-thread', 'new api queue message')
+    })
+
+    // Legacy API should update global state (with assistant metadata added)
+    expect(appStateResult.current.streamingContent).toMatchObject({
+      ...legacyMessage,
+      metadata: expect.objectContaining({
+        assistant: expect.any(Object)
+      })
+    })
+    expect(appStateResult.current.queuedMessage).toEqual('legacy queue message')
+
+    // New API should update thread-specific state
+    expect(appStateResult.current.streamingContentByThread['new-api-thread']).toEqual(newMessage)
+    expect(appStateResult.current.queuedMessagesByThread['new-api-thread']).toEqual('new api queue message')
+  })
+})
diff --git a/web-app/src/hooks/__tests__/performance.memoization.test.ts b/web-app/src/hooks/__tests__/performance.memoization.test.ts
new file mode 100644
index 0000000000..e1a4b6da33
--- /dev/null
+++ b/web-app/src/hooks/__tests__/performance.memoization.test.ts
@@ -0,0 +1,246 @@
+import { renderHook, act } from '@testing-library/react'
+import { describe, test, expect, beforeEach } from 'vitest'
+import { useAppState } from '../useAppState'
+import {
+  useThreadState,
+  useStreamingContent,
+  useQueuedMessages,
+  useThreadQueueLength,
+} from '../useThreadState'
+
+/**
+ * PERFORMANCE TESTING FOR MEMOIZATION APPROACHES
+ *
+ * This test suite measures the performance difference between:
+ * 1. useShallow approach (old) - creates new object every render
+ * 2. Individual hooks approach (new) - only re-renders when specific values change
+ *
+ * We'll measure:
+ * - Object creation frequency
+ * - Reference stability
+ * - Memory efficiency
+ */
+
+describe('Performance: useShallow vs Individual Hooks', () => {
+  beforeEach(() => {
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  describe('Object Creation Tests', () => {
+    test('individual hooks should not create new objects on every render', () => {
+      const threadId = 'object-test-thread'
+
+      const { result: streamingResult, rerender: rerenderStreaming } =
+        renderHook(() => useStreamingContent(threadId))
+
+      // Get initial reference
+      const initialStreaming = streamingResult.current
+
+      // Re-render without any state changes
+      rerenderStreaming()
+
+      // Reference should be the same (no new object created)
+      expect(streamingResult.current).toBe(initialStreaming)
+    })
+
+    test('useThreadState creates new object on every render', () => {
+      const threadId = 'object-test-thread'
+
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      // Get initial reference
+      const initialThreadState = threadStateResult.current
+
+      // Re-render without any state changes
+      rerenderThreadState()
+
+      // Reference should be different (new object created)
+      expect(threadStateResult.current).not.toBe(initialThreadState)
+      expect(threadStateResult.current).toEqual(initialThreadState) // But content is the same
+    })
+  })
+
+  describe('Reference Stability Tests', () => {
+    test('individual hooks maintain stable references when values are the same', () => {
+      const threadId = 'stability-test-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up some initial state
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Initial message')
+      })
+
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+
+      const initialReference = queueResult.current
+
+      // Update unrelated state (streaming content)
+      act(() => {
+        appStateResult.current.updateThreadStreamingContent(threadId, {
+          id: 'unrelated',
+        } as any)
+      })
+      rerenderQueue()
+
+      // Queue reference should remain stable (no re-render needed)
+      expect(queueResult.current).toBe(initialReference)
+    })
+
+    test('useThreadState creates new object even when only unrelated properties change', () => {
+      const threadId = 'stability-test-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up some initial state
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Initial message')
+      })
+
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialReference = threadStateResult.current
+
+      // Update only streaming content (unrelated to queue)
+      act(() => {
+        appStateResult.current.updateThreadStreamingContent(threadId, {
+          id: 'unrelated',
+        } as any)
+      })
+      rerenderThreadState()
+
+      // Thread state reference should change because it includes streaming content
+      expect(threadStateResult.current).not.toBe(initialReference)
+    })
+  })
+
+  describe('Memory Efficiency Tests', () => {
+    test('individual hooks should not create unnecessary intermediate objects', () => {
+      const threadId = 'memory-test-thread'
+
+      // Track object creation by monitoring array references
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+
+      const initialArray = queueResult.current
+
+      // Re-render multiple times
+      for (let i = 0; i < 5; i++) {
+        rerenderQueue()
+        // Array reference should remain stable
+        expect(queueResult.current).toBe(initialArray)
+      }
+    })
+
+    test('useThreadState creates new objects on every render', () => {
+      const threadId = 'memory-test-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up some actual state to make the test more realistic
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Test message')
+      })
+
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialObject = threadStateResult.current
+
+      // Re-render multiple times
+      for (let i = 0; i < 5; i++) {
+        rerenderThreadState()
+        // Object reference should change each time
+        expect(threadStateResult.current).not.toBe(initialObject)
+      }
+    })
+  })
+
+  describe('Real-world Performance Patterns', () => {
+    test('individual hooks should handle frequent re-renders efficiently', () => {
+      const threadId = 'frequent-render-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up initial state
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Message 1')
+        appStateResult.current.addToThreadQueue(threadId, 'Message 2')
+      })
+
+      const { result: queueResult, rerender: rerenderQueue } = renderHook(() =>
+        useQueuedMessages(threadId)
+      )
+
+      const initialReference = queueResult.current
+
+      // Simulate frequent re-renders (like in a chat component)
+      for (let i = 0; i < 10; i++) {
+        rerenderQueue()
+        // Reference should remain stable
+        expect(queueResult.current).toBe(initialReference)
+      }
+    })
+
+    test('useThreadState creates new objects on frequent re-renders', () => {
+      const threadId = 'frequent-render-thread'
+
+      const { result: appStateResult } = renderHook(() => useAppState())
+
+      // Set up initial state
+      act(() => {
+        appStateResult.current.addToThreadQueue(threadId, 'Message 1')
+        appStateResult.current.addToThreadQueue(threadId, 'Message 2')
+      })
+
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialReference = threadStateResult.current
+
+      // Simulate frequent re-renders
+      for (let i = 0; i < 10; i++) {
+        rerenderThreadState()
+        // Reference should change each time
+        expect(threadStateResult.current).not.toBe(initialReference)
+      }
+    })
+  })
+
+  describe('Performance Recommendations', () => {
+    test('should demonstrate when to use individual hooks vs useThreadState', () => {
+      const threadId = 'recommendation-test-thread'
+
+      // Scenario 1: Component only needs queue length
+      const { result: queueLengthResult, rerender: rerenderQueueLength } =
+        renderHook(() => useThreadQueueLength(threadId))
+
+      const initialLength = queueLengthResult.current
+      rerenderQueueLength()
+
+      // Individual hook maintains stable reference
+      expect(queueLengthResult.current).toBe(initialLength)
+
+      // Scenario 2: Component needs multiple properties
+      const { result: threadStateResult, rerender: rerenderThreadState } =
+        renderHook(() => useThreadState(threadId))
+
+      const initialState = threadStateResult.current
+      rerenderThreadState()
+
+      // useThreadState creates new object
+      expect(threadStateResult.current).not.toBe(initialState)
+
+      // Recommendation: Use individual hooks when you only need specific properties
+      // Use useThreadState only when you need all properties together
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/scheduler-integration.test.ts b/web-app/src/hooks/__tests__/scheduler-integration.test.ts
new file mode 100644
index 0000000000..034e1d5485
--- /dev/null
+++ b/web-app/src/hooks/__tests__/scheduler-integration.test.ts
@@ -0,0 +1,308 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { useInferenceScheduler, useAutoScheduler } from '../useInferenceScheduler'
+import { useAppState } from '../useAppState'
+import { useChat } from '../useChat'
+
+// Mock the useChat hook
+vi.mock('../useChat', () => ({
+  useChat: vi.fn(() => ({
+    sendMessage: vi.fn()
+  }))
+}))
+
+// Mock the useAssistant hook as a Zustand store
+vi.mock('../useAssistant', () => ({
+  useAssistant: Object.assign(
+    vi.fn(() => ({
+      selectedAssistant: null,
+      updateAssistantTools: vi.fn()
+    })),
+    {
+      getState: vi.fn(() => ({
+        currentAssistant: { id: 'test-assistant', name: 'Test Assistant' },
+        assistants: [{ id: 'test-assistant', name: 'Test Assistant' }]
+      }))
+    }
+  )
+}))
+
+const mockSendMessage = vi.fn()
+
+describe('Scheduler + useChat Integration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Reset Zustand store to initial state
+    act(() => {
+      useAppState.setState({
+        processingThreads: {},
+        maxConcurrency: 1,
+        fallbackMode: 'single-thread',
+        parallelProcessingEnabled: false,
+        streamingContentByThread: {},
+        tokenSpeedByThread: {},
+        queuedMessagesByThread: {},
+        errorsByThread: {},
+        abortControllers: {}
+      })
+    })
+
+    // Mock useChat to return our mock sendMessage
+    vi.mocked(useChat).mockReturnValue({
+      sendMessage: mockSendMessage
+    } as any)
+  })
+
+  describe('queue processing end-to-end', () => {
+    it('should process queue messages in correct order', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      const processedMessages: string[] = []
+
+      // Mock sendMessage to simulate processing and track order
+      mockSendMessage.mockImplementation(async (message: string) => {
+        processedMessages.push(message)
+        // Simulate processing time
+        await new Promise(resolve => setTimeout(resolve, 50))
+        return Promise.resolve()
+      })
+
+      // Queue multiple messages
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'first')
+        appState.current.addToThreadQueue('thread-1', 'second')
+        appState.current.addToThreadQueue('thread-1', 'third')
+      })
+
+      // Process all messages sequentially
+      for (let i = 0; i < 3; i++) {
+        act(() => {
+          scheduler.current.schedule()
+        })
+
+        // Wait for processing to complete
+        await waitFor(() => {
+          expect(processedMessages).toHaveLength(i + 1)
+        })
+
+        // Simulate completion
+        act(() => {
+          appState.current.setThreadProcessing('thread-1', false)
+        })
+      }
+
+      expect(processedMessages).toEqual(['first', 'second', 'third'])
+    })
+
+    it('should handle multiple threads with single-thread processing', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      const processedMessages: Array<{ message: string; threadId: string }> = []
+
+      // Mock sendMessage to track which messages are processed
+      mockSendMessage.mockImplementation(async (message: string) => {
+        // Find which thread this message belongs to by checking queues
+        const queuedMessagesByThread = useAppState.getState().queuedMessagesByThread
+        let threadId = 'unknown'
+        
+        for (const [tid, queue] of Object.entries(queuedMessagesByThread)) {
+          if (queue.includes(message)) {
+            threadId = tid
+            break
+          }
+        }
+        
+        processedMessages.push({ message, threadId })
+        await new Promise(resolve => setTimeout(resolve, 25))
+        return Promise.resolve()
+      })
+
+      // Queue messages in different threads
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'msg1-t1')
+        appState.current.addToThreadQueue('thread-2', 'msg1-t2')
+        appState.current.addToThreadQueue('thread-1', 'msg2-t1')
+      })
+
+      // Should only process one thread at a time (single-thread mode)
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      await waitFor(() => {
+        expect(mockSendMessage).toHaveBeenCalledTimes(1)
+      })
+
+      // Only one message should be processing
+      const processingCount = appState.current.getActiveProcessingCount()
+      expect(processingCount).toBe(1)
+    })
+  })
+
+  describe('thread switching during processing', () => {
+    it('should wait for current thread to complete before starting another', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      let processingComplete = false
+      
+      // Mock long-running sendMessage
+      mockSendMessage.mockImplementation(async () => {
+        // Simulate actual processing state management
+        await new Promise(resolve => setTimeout(resolve, 100))
+        processingComplete = true
+        return Promise.resolve()
+      })
+
+      // Start processing thread-1
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        scheduler.current.schedule()
+      })
+
+      // Verify thread-1 is processing (wait for state update)
+      await waitFor(() => {
+        expect(appState.current.isThreadProcessing('thread-1')).toBe(true)
+      })
+
+      // Add message to thread-2
+      act(() => {
+        appState.current.addToThreadQueue('thread-2', 'message2')
+        scheduler.current.schedule() // Try to schedule thread-2
+      })
+
+      // thread-2 should not start processing yet
+      expect(appState.current.isThreadProcessing('thread-2')).toBe(false)
+      expect(mockSendMessage).toHaveBeenCalledTimes(1) // Only thread-1 message
+
+      // Wait for processing to complete
+      await waitFor(() => {
+        expect(processingComplete).toBe(true)
+      })
+    })
+  })
+
+  describe('abort functionality', () => {
+    it('should handle aborted processing gracefully', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      // Mock sendMessage to simulate abort
+      mockSendMessage.mockRejectedValueOnce(new Error('Aborted'))
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'test message')
+      })
+
+      // Should not throw error when sendMessage fails
+      await act(async () => {
+        scheduler.current.startThreadInference('thread-1')
+      })
+
+      // Processing state should be cleaned up even after error
+      await waitFor(() => {
+        expect(appState.current.isThreadProcessing('thread-1')).toBe(false)
+      })
+    })
+  })
+
+  describe('auto-scheduler integration', () => {
+    it('should work seamlessly with auto-scheduler', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      renderHook(() => useAutoScheduler()) // Enable auto-scheduling
+
+      let messageCount = 0
+
+      // Mock sendMessage to simply count messages
+      mockSendMessage.mockImplementation(async (message: string) => {
+        messageCount++
+        await new Promise(resolve => setTimeout(resolve, 10))
+        return Promise.resolve()
+      })
+
+      // Add a single message - auto-scheduler should pick it up
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'auto-message-1')
+      })
+
+      // Should automatically process the message
+      await waitFor(() => {
+        expect(messageCount).toBeGreaterThan(0)
+      })
+
+      // Verify the specific message was processed
+      expect(mockSendMessage).toHaveBeenCalledWith('auto-message-1', true)
+    })
+  })
+
+  describe('state synchronization', () => {
+    it('should keep queue and processing state synchronized', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      // Mock sendMessage to track state changes
+      mockSendMessage.mockImplementation(async (message: string) => {
+        // Verify state during processing
+        const queueLength = appState.current.getThreadQueueLength('thread-1')
+        const isProcessing = appState.current.isThreadProcessing('thread-1')
+        
+        expect(isProcessing).toBe(true) // Should be marked as processing
+        // Queue should have been updated (message removed)
+        
+        await new Promise(resolve => setTimeout(resolve, 25))
+        return Promise.resolve()
+      })
+
+      // Add message and schedule
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'sync-test')
+      })
+
+      const initialQueueLength = appState.current.getThreadQueueLength('thread-1')
+      expect(initialQueueLength).toBe(1)
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      // Verify message was dequeued and processing started
+      await waitFor(() => {
+        expect(mockSendMessage).toHaveBeenCalled()
+        expect(appState.current.getThreadQueueLength('thread-1')).toBe(0)
+        expect(appState.current.isThreadProcessing('thread-1')).toBe(true)
+      })
+    })
+  })
+
+  describe('performance and reliability', () => {
+    it('should handle rapid queue additions without issues', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      renderHook(() => useAutoScheduler()) // Enable auto-scheduling
+
+      let processedCount = 0
+      mockSendMessage.mockImplementation(async () => {
+        processedCount++
+        await new Promise(resolve => setTimeout(resolve, 10))
+        return Promise.resolve()
+      })
+
+      // Rapidly add many messages
+      act(() => {
+        for (let i = 0; i < 10; i++) {
+          appState.current.addToThreadQueue('thread-1', `rapid-message-${i}`)
+        }
+      })
+
+      // Should handle all messages without errors
+      await waitFor(() => {
+        expect(processedCount).toBeGreaterThan(0)
+      }, { timeout: 5000 })
+
+      // Should not crash or cause state corruption
+      expect(appState.current).toBeDefined()
+      expect(useAppState.getState().queuedMessagesByThread['thread-1']).toBeDefined()
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useAppState.concurrent.test.ts b/web-app/src/hooks/__tests__/useAppState.concurrent.test.ts
new file mode 100644
index 0000000000..c27bce4771
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useAppState.concurrent.test.ts
@@ -0,0 +1,419 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { act, renderHook } from '@testing-library/react'
+import { useAppState } from '../useAppState'
+
+// Mock the useAssistant hook as a Zustand store
+vi.mock('../useAssistant', () => ({
+  useAssistant: Object.assign(
+    vi.fn(() => ({
+      selectedAssistant: null,
+      updateAssistantTools: vi.fn()
+    })),
+    {
+      getState: vi.fn(() => ({
+        currentAssistant: { id: 'test-assistant', name: 'Test Assistant' },
+        assistants: [{ id: 'test-assistant', name: 'Test Assistant' }]
+      }))
+    }
+  )
+}))
+
+describe('useAppState concurrent processing', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Reset Zustand store to initial state
+    act(() => {
+      useAppState.setState({
+        processingThreads: {},
+        maxConcurrency: 1,
+        fallbackMode: 'single-thread',
+        parallelProcessingEnabled: false,
+        streamingContentByThread: {},
+        tokenSpeedByThread: {},
+        queuedMessagesByThread: {},
+        errorsByThread: {},
+        abortControllers: {}
+      })
+    })
+  })
+
+  describe('initialization', () => {
+    it('should initialize with default concurrent processing state', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      expect(result.current.processingThreads).toEqual({})
+      expect(result.current.maxConcurrency).toBe(1)
+      expect(result.current.fallbackMode).toBe('single-thread')
+      expect(result.current.parallelProcessingEnabled).toBe(false)
+      expect(result.current.getActiveProcessingCount()).toBe(0)
+      expect(result.current.getAvailableSlots()).toBe(1)
+    })
+  })
+
+  describe('thread processing tracking', () => {
+    it('should track processing threads correctly', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Initially no threads processing
+      expect(result.current.getActiveProcessingCount()).toBe(0)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+
+      // Start processing thread-1
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(1)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+      expect(result.current.processingThreads['thread-1']).toBe(true)
+
+      // Start processing thread-2
+      act(() => {
+        result.current.setThreadProcessing('thread-2', true)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(2)
+      expect(result.current.isThreadProcessing('thread-2')).toBe(true)
+
+      // Stop processing thread-1
+      act(() => {
+        result.current.setThreadProcessing('thread-1', false)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(1)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+      expect(result.current.isThreadProcessing('thread-2')).toBe(true)
+    })
+
+    it('should handle setting same thread processing state multiple times', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Set thread-1 to processing multiple times
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+        result.current.setThreadProcessing('thread-1', true)
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(1)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+
+      // Set thread-1 to not processing multiple times
+      act(() => {
+        result.current.setThreadProcessing('thread-1', false)
+        result.current.setThreadProcessing('thread-1', false)
+        result.current.setThreadProcessing('thread-1', false)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(0)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+    })
+  })
+
+  describe('concurrency management', () => {
+    it('should calculate available slots correctly', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Initially all slots available
+      expect(result.current.getAvailableSlots()).toBe(1) // maxConcurrency defaults to 1
+
+      // Set higher concurrency
+      act(() => {
+        result.current.setMaxConcurrency(3)
+      })
+
+      expect(result.current.getAvailableSlots()).toBe(3)
+
+      // Start processing
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      expect(result.current.getAvailableSlots()).toBe(2)
+
+      // Start more processing
+      act(() => {
+        result.current.setThreadProcessing('thread-2', true)
+        result.current.setThreadProcessing('thread-3', true)
+      })
+
+      expect(result.current.getAvailableSlots()).toBe(0)
+
+      // Stop one thread
+      act(() => {
+        result.current.setThreadProcessing('thread-2', false)
+      })
+
+      expect(result.current.getAvailableSlots()).toBe(1)
+    })
+
+    it('should enforce minimum concurrency of 1', () => {
+      const { result } = renderHook(() => useAppState())
+
+      act(() => {
+        result.current.setMaxConcurrency(0)
+      })
+
+      expect(result.current.maxConcurrency).toBe(1)
+
+      act(() => {
+        result.current.setMaxConcurrency(-5)
+      })
+
+      expect(result.current.maxConcurrency).toBe(1)
+
+      act(() => {
+        result.current.setMaxConcurrency(2.7)
+      })
+
+      expect(result.current.maxConcurrency).toBe(2.7) // Math.max preserves the value
+    })
+
+    it('should allow setting valid concurrency values', () => {
+      const { result } = renderHook(() => useAppState())
+
+      const testValues = [1, 2, 4, 8, 16]
+      
+      testValues.forEach(value => {
+        act(() => {
+          result.current.setMaxConcurrency(value)
+        })
+        expect(result.current.maxConcurrency).toBe(value)
+      })
+    })
+  })
+
+  describe('fallback mode management', () => {
+    it('should manage fallback mode correctly', () => {
+      const { result } = renderHook(() => useAppState())
+
+      expect(result.current.fallbackMode).toBe('single-thread')
+
+      const modes = ['estimated', 'detected', 'user-configured'] as const
+
+      modes.forEach(mode => {
+        act(() => {
+          result.current.setFallbackMode(mode)
+        })
+        expect(result.current.fallbackMode).toBe(mode)
+      })
+
+      // Back to single-thread
+      act(() => {
+        result.current.setFallbackMode('single-thread')
+      })
+
+      expect(result.current.fallbackMode).toBe('single-thread')
+    })
+  })
+
+  describe('parallel processing flag', () => {
+    it('should manage parallel processing enabled flag', () => {
+      const { result } = renderHook(() => useAppState())
+
+      expect(result.current.parallelProcessingEnabled).toBe(false)
+
+      act(() => {
+        result.current.setParallelProcessingEnabled(true)
+      })
+
+      expect(result.current.parallelProcessingEnabled).toBe(true)
+
+      act(() => {
+        result.current.setParallelProcessingEnabled(false)
+      })
+
+      expect(result.current.parallelProcessingEnabled).toBe(false)
+    })
+  })
+
+  describe('thread cleanup integration', () => {
+    it('should clean up processing state when clearing thread', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Set up thread state
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+        result.current.setThreadProcessing('thread-2', true)
+        result.current.addToThreadQueue('thread-1', 'message1')
+        result.current.addToThreadQueue('thread-2', 'message2')
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(2)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+
+      // Clear thread-1
+      act(() => {
+        result.current.clearThread('thread-1')
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(1)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+      expect(result.current.isThreadProcessing('thread-2')).toBe(true)
+      expect(result.current.queuedMessagesByThread['thread-1']).toBeUndefined()
+    })
+
+    it('should clean up all processing state when clearing all threads', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Set up multiple threads
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+        result.current.setThreadProcessing('thread-2', true)
+        result.current.setThreadProcessing('thread-3', true)
+        result.current.addToThreadQueue('thread-1', 'message1')
+        result.current.addToThreadQueue('thread-2', 'message2')
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(3)
+
+      // Clear all threads
+      act(() => {
+        result.current.clearAllThreads()
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(0)
+      expect(result.current.processingThreads).toEqual({})
+      expect(result.current.queuedMessagesByThread).toEqual({})
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+      expect(result.current.isThreadProcessing('thread-2')).toBe(false)
+      expect(result.current.isThreadProcessing('thread-3')).toBe(false)
+    })
+  })
+
+  describe('edge cases and error handling', () => {
+    it('should handle checking processing state for non-existent threads', () => {
+      const { result } = renderHook(() => useAppState())
+
+      expect(result.current.isThreadProcessing('non-existent-thread')).toBe(false)
+    })
+
+    it('should handle rapid state updates without issues', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Rapid updates should not cause issues
+      act(() => {
+        for (let i = 0; i < 100; i++) {
+          result.current.setThreadProcessing(`thread-${i}`, true)
+          result.current.setThreadProcessing(`thread-${i}`, false)
+        }
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(0)
+    })
+
+    it('should maintain accurate count during concurrent updates', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Set max concurrency higher
+      act(() => {
+        result.current.setMaxConcurrency(10)
+      })
+
+      // Start multiple threads
+      act(() => {
+        for (let i = 0; i < 5; i++) {
+          result.current.setThreadProcessing(`thread-${i}`, true)
+        }
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(5)
+      expect(result.current.getAvailableSlots()).toBe(5)
+
+      // Stop some threads
+      act(() => {
+        result.current.setThreadProcessing('thread-1', false)
+        result.current.setThreadProcessing('thread-3', false)
+      })
+
+      expect(result.current.getActiveProcessingCount()).toBe(3)
+      expect(result.current.getAvailableSlots()).toBe(7)
+    })
+  })
+
+  describe('integration with existing state', () => {
+    it('should work alongside existing queue functionality', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Add messages to queue and set processing
+      act(() => {
+        result.current.addToThreadQueue('thread-1', 'message1')
+        result.current.addToThreadQueue('thread-1', 'message2')
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      expect(result.current.getThreadQueueLength('thread-1')).toBe(2)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+
+      // Remove from queue while processing
+      act(() => {
+        const removed = result.current.removeFromThreadQueue('thread-1')
+        expect(removed).toBe('message1')
+      })
+
+      expect(result.current.getThreadQueueLength('thread-1')).toBe(1)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+    })
+
+    it('should not interfere with legacy state management', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Test legacy queuedMessage (non-thread-specific)
+      act(() => {
+        result.current.setQueuedMessage('legacy message')
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      expect(result.current.queuedMessage).toBe('legacy message')
+      expect(result.current.isThreadProcessing('thread-1')).toBe(true)
+
+      // Legacy and new state should coexist
+      act(() => {
+        result.current.setQueuedMessage(null)
+        result.current.setThreadProcessing('thread-1', false)
+      })
+
+      expect(result.current.queuedMessage).toBe(null)
+      expect(result.current.isThreadProcessing('thread-1')).toBe(false)
+    })
+  })
+
+  describe('zustand store reactivity', () => {
+    it('should trigger re-renders when state changes', () => {
+      const { result } = renderHook(() => useAppState())
+
+      // Test that Zustand store updates trigger re-renders
+      const initialState = { ...result.current }
+
+      act(() => {
+        result.current.setThreadProcessing('thread-1', true)
+      })
+
+      // State should have changed
+      expect(result.current.processingThreads).not.toEqual(
+        initialState.processingThreads
+      )
+      expect(result.current.processingThreads['thread-1']).toBe(true)
+
+      // Computed values should also update
+      expect(result.current.getActiveProcessingCount()).toBe(1)
+      expect(result.current.getAvailableSlots()).toBe(0) // maxConcurrency is 1
+    })
+
+    it('should provide consistent state across multiple hook instances', () => {
+      const { result: result1 } = renderHook(() => useAppState())
+      const { result: result2 } = renderHook(() => useAppState())
+
+      act(() => {
+        result1.current.setThreadProcessing('thread-1', true)
+        result1.current.setMaxConcurrency(4)
+      })
+
+      // Both hooks should see the same state
+      expect(result2.current.isThreadProcessing('thread-1')).toBe(true)
+      expect(result2.current.maxConcurrency).toBe(4)
+      expect(result2.current.getActiveProcessingCount()).toBe(1)
+      expect(result2.current.getAvailableSlots()).toBe(3)
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useAppState.migration.test.ts b/web-app/src/hooks/__tests__/useAppState.migration.test.ts
new file mode 100644
index 0000000000..4284eac216
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useAppState.migration.test.ts
@@ -0,0 +1,660 @@
+import { renderHook, act } from '@testing-library/react'
+import { ThreadMessage } from '@janhq/core'
+import { useAppState } from '../useAppState'
+
+/**
+ * MOCK DATA HELPERS
+ */
+const createMockThreadMessage = (
+  id: string,
+  content: string
+): ThreadMessage => ({
+  id,
+  thread_id: 'test-thread',
+  content: [{ type: 'text', text: { value: content } }],
+  role: 'assistant',
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  status: 'ready',
+  metadata: {},
+})
+
+/**
+ * MIGRATION AND BACKWARD COMPATIBILITY TESTS
+ *
+ * These tests ensure that the transition from global to per-thread state
+ * happens smoothly without breaking existing functionality. They validate:
+ *
+ * - Legacy API continues to work during migration period
+ * - Mixed usage of old and new APIs doesn't cause conflicts
+ * - Data migration scenarios are handled properly
+ * - State persistence and rehydration work correctly
+ * - Thread lifecycle management is robust
+ * - System handles edge cases and error recovery
+ *
+ * MIGRATION STRATEGY:
+ * 1. Add new per-thread APIs alongside existing global ones
+ * 2. Gradually migrate components to use per-thread APIs
+ * 3. Maintain backward compatibility during transition
+ * 4. Remove legacy APIs once migration is complete
+ */
+describe('useAppState - Migration Strategy & Backward Compatibility', () => {
+  beforeEach(() => {
+    // SETUP: Ensure clean state for each migration test
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  /**
+   * LEGACY API COMPATIBILITY TESTS
+   * Ensures existing APIs continue to work during migration period
+   */
+  describe('Legacy API backward compatibility maintenance', () => {
+    test('LEGACY QUEUE API: should maintain existing setQueuedMessage API during migration', () => {
+      // GOAL: Ensure existing queue API continues to work while new per-thread APIs are added
+      // SCENARIO: Component still uses old setQueuedMessage(threadId, message) syntax
+
+      const { result } = renderHook(() => useAppState())
+
+      const legacyMessage = 'Message set using legacy API'
+
+      act(() => {
+        // WHEN: Using legacy API for global queue (should still work)
+        result.current.setQueuedMessage(legacyMessage)
+        // AND: Using new API for thread-specific queue
+        result.current.setThreadQueuedMessage('legacy-thread', legacyMessage)
+      })
+
+      // THEN: Both global and thread-specific state should work
+      expect(result.current.queuedMessage).toEqual(legacyMessage)
+      expect(result.current.queuedMessagesByThread['legacy-thread']).toEqual(legacyMessage)
+
+      // VERIFY: Legacy API behavior is preserved
+      act(() => {
+        result.current.setQueuedMessage(null)
+        result.current.setThreadQueuedMessage('legacy-thread', null)
+      })
+
+      expect(result.current.queuedMessage).toBeNull()
+      expect(result.current.queuedMessagesByThread['legacy-thread']).toBeNull()
+    })
+
+    test('MIXED API USAGE: should handle simultaneous use of legacy and new APIs', () => {
+      // GOAL: Ensure no conflicts when components use different API versions
+      // SCENARIO: Some components migrated to new API, others still use legacy
+
+      const { result } = renderHook(() => useAppState())
+
+      const streamingMessage = createMockThreadMessage(
+        'streaming',
+        'New API streaming message'
+      )
+      const legacyQueueMessage = 'Legacy API queue message'
+      const newApiQueueMessage = 'New API queue message'
+
+      act(() => {
+        // MIXED USAGE: Combine new per-thread API with legacy API
+        result.current.updateThreadStreamingContent('mixed-thread-1', streamingMessage) // New API
+        result.current.setQueuedMessage(legacyQueueMessage) // Legacy API  
+        result.current.setThreadQueuedMessage('mixed-thread-2', newApiQueueMessage) // New API
+      })
+
+      // THEN: Thread-specific operations should work with new API
+      expect(result.current.streamingContentByThread['mixed-thread-1']).toEqual(streamingMessage)
+      expect(result.current.queuedMessagesByThread['mixed-thread-2']).toEqual(newApiQueueMessage)
+      
+      // AND: Legacy operations should work with global state
+      expect(result.current.queuedMessage).toEqual(legacyQueueMessage)
+    })
+
+    test('API CONSISTENCY: should ensure consistent behavior between legacy and new APIs', () => {
+      // GOAL: Validate that legacy and new APIs produce identical results
+      // SCENARIO: Same operation performed through different API versions
+
+      const { result } = renderHook(() => useAppState())
+
+      const message1 = 'Message via legacy approach'
+      const message2 = 'Message via new approach'
+
+      act(() => {
+        // LEGACY APPROACH: Direct queue setting (assuming this was how it worked before)
+        result.current.setQueuedMessage('legacy-approach-thread', message1)
+
+        // NEW APPROACH: Per-thread queue setting
+        result.current.setQueuedMessage('new-approach-thread', message2)
+      })
+
+      // THEN: Both approaches should produce consistent state structure
+      expect(
+        typeof result.current.queuedMessagesByThread['legacy-approach-thread']
+      ).toBe('string')
+      expect(
+        typeof result.current.queuedMessagesByThread['new-approach-thread']
+      ).toBe('string')
+      expect(
+        result.current.queuedMessagesByThread['legacy-approach-thread']
+      ).toEqual(message1)
+      expect(
+        result.current.queuedMessagesByThread['new-approach-thread']
+      ).toEqual(message2)
+    })
+  })
+
+  /**
+   * DATA MIGRATION SCENARIOS
+   * Tests for migrating existing global state to per-thread structure
+   */
+  describe('Global to per-thread state data migration scenarios', () => {
+    test('GLOBAL STATE MIGRATION: should migrate existing global state to current thread', () => {
+      // GOAL: Simulate migration of existing global state to per-thread structure
+      // SCENARIO: App restart during migration - need to assign global state to active thread
+
+      const { result } = renderHook(() => useAppState())
+
+      const existingGlobalMessage = createMockThreadMessage(
+        'global',
+        'Existing global streaming message'
+      )
+      const currentThreadId = 'active-thread-during-migration'
+
+      act(() => {
+        // SIMULATION: During migration, take what would have been global state
+        // and assign it to the currently active thread
+        result.current.updateStreamingContent(
+          currentThreadId,
+          existingGlobalMessage
+        )
+      })
+
+      // THEN: Previous global state should now be associated with active thread
+      expect(result.current.streamingContentByThread[currentThreadId]).toEqual(
+        existingGlobalMessage
+      )
+
+      // VERIFY: This doesn't interfere with other threads
+      const otherMessage = createMockThreadMessage(
+        'other',
+        'Other thread message'
+      )
+
+      act(() => {
+        result.current.updateStreamingContent('other-thread', otherMessage)
+      })
+
+      expect(result.current.streamingContentByThread['other-thread']).toEqual(
+        otherMessage
+      )
+      expect(result.current.streamingContentByThread[currentThreadId]).toEqual(
+        existingGlobalMessage
+      )
+    })
+
+    test('NULL THREAD ID HANDLING: should handle migration when current thread ID is unavailable', () => {
+      // GOAL: Handle edge case where currentThreadId is null during migration
+      // SCENARIO: Component mounts before thread context is available
+
+      const { result } = renderHook(() => useAppState())
+
+      const messageNeedingMigration = createMockThreadMessage(
+        'orphaned',
+        'Message without thread context'
+      )
+
+      act(() => {
+        // SIMULATION: currentThreadId might be null during app initialization
+        const currentThreadId = null
+        const safeThreadId = currentThreadId || 'migration-fallback-thread'
+
+        result.current.updateStreamingContent(
+          safeThreadId,
+          messageNeedingMigration
+        )
+      })
+
+      // THEN: Should handle gracefully with fallback thread ID
+      expect(
+        result.current.streamingContentByThread['migration-fallback-thread']
+      ).toEqual(messageNeedingMigration)
+    })
+
+    test('INCREMENTAL MIGRATION: should support gradual migration of different state types', () => {
+      // GOAL: Allow migrating different state types (streaming, errors, queues) at different times
+      // SCENARIO: Streaming content migrated first, then errors, then queues
+
+      const { result } = renderHook(() => useAppState())
+
+      const streamingMsg = createMockThreadMessage(
+        'stream',
+        'Migrated streaming content'
+      )
+      const errorMsg = 'Migrated error message'
+      const queueMsg = 'Migrated queue message'
+
+      act(() => {
+        // PHASE 1: Migrate streaming content only
+        result.current.updateStreamingContent('migration-thread', streamingMsg)
+
+        // PHASE 2: Later, migrate error handling
+        result.current.setThreadError('migration-thread', errorMsg)
+
+        // PHASE 3: Finally, migrate queue system
+        result.current.setQueuedMessage('migration-thread', queueMsg)
+      })
+
+      // THEN: All migrated state should coexist properly
+      expect(
+        result.current.streamingContentByThread['migration-thread']
+      ).toEqual(streamingMsg)
+      expect(result.current.errorsByThread['migration-thread']).toEqual(
+        errorMsg
+      )
+      expect(result.current.queuedMessagesByThread['migration-thread']).toEqual(
+        queueMsg
+      )
+    })
+  })
+
+  /**
+   * STATE PERSISTENCE AND REHYDRATION TESTS
+   * Validates what should and shouldn't survive app restarts
+   */
+  describe('State persistence strategy and rehydration logic', () => {
+    test('TRANSIENT STATE EXCLUSION: should not persist UI-only transient state', () => {
+      // GOAL: Ensure temporary UI state doesn't persist across app restarts
+      // SCENARIO: User closes app while AI is streaming - streaming state should not persist
+
+      const { result } = renderHook(() => useAppState())
+
+      const transientStreamingMessage = createMockThreadMessage(
+        'transient',
+        'AI is currently typing...'
+      )
+      const transientTokenSpeed = {
+        tokenSpeed: 75,
+        tokenCount: 150,
+        lastTimestamp: Date.now(),
+        message: 'current-msg-id',
+      }
+      const transientError = 'Temporary connection issue'
+
+      act(() => {
+        // SETUP: Set transient UI state that shouldn't persist
+        result.current.updateStreamingContent(
+          'transient-thread',
+          transientStreamingMessage
+        )
+        result.current.updateTokenSpeed('transient-thread', transientTokenSpeed)
+        result.current.setThreadError('transient-thread', transientError)
+      })
+
+      // VERIFY: State exists in current session
+      expect(
+        result.current.streamingContentByThread['transient-thread']
+      ).toBeDefined()
+      expect(
+        result.current.tokenSpeedByThread['transient-thread']
+      ).toBeDefined()
+      expect(result.current.errorsByThread['transient-thread']).toBeDefined()
+
+      // NOTE: In actual implementation, persistence middleware would exclude these
+      // This test documents the expectation that these are marked as non-persistent
+      const state = result.current
+      const transientFields = [
+        'streamingContentByThread',
+        'tokenSpeedByThread',
+        'errorsByThread',
+      ]
+
+      // EXPECTATION: These fields should be marked for exclusion from persistence
+      transientFields.forEach((field) => {
+        expect(state[field as keyof typeof state]).toBeDefined()
+        // In real implementation: expect(persistConfig.exclude).toContain(field)
+      })
+    })
+
+    test('IMPORTANT STATE PERSISTENCE: should persist user intent and important state', () => {
+      // GOAL: Ensure user's queued messages survive app restarts
+      // SCENARIO: User queues message, closes app, reopens - message should still be queued
+
+      const { result } = renderHook(() => useAppState())
+
+      const importantQueuedMessage =
+        'Please analyze this document when you have time'
+
+      act(() => {
+        // This represents user intent and should be persisted
+        result.current.setQueuedMessage(
+          'persistent-thread',
+          importantQueuedMessage
+        )
+      })
+
+      // VERIFY: Important state is available for persistence
+      expect(
+        result.current.queuedMessagesByThread['persistent-thread']
+      ).toEqual(importantQueuedMessage)
+
+      // NOTE: In actual implementation, this would be included in persistence config
+      // This test documents the expectation that queued messages are persistent
+    })
+
+    test('REHYDRATION SAFETY: should handle corrupted or invalid persisted state gracefully', () => {
+      // GOAL: Ensure app doesn't crash when loading corrupted persisted state
+      // SCENARIO: Persisted state file is corrupted or has invalid format
+
+      const { result } = renderHook(() => useAppState())
+
+      // SIMULATION: Attempt to rehydrate with various potentially invalid states
+      const potentiallyCorruptedStates = [
+        {}, // Empty object
+        { queuedMessagesByThread: null }, // Null instead of object
+        { queuedMessagesByThread: { 'thread-1': undefined } }, // Undefined values
+        { queuedMessagesByThread: { 'thread-1': {} } }, // Wrong data type
+      ]
+
+      potentiallyCorruptedStates.forEach((corruptedState, index) => {
+        expect(() => {
+          act(() => {
+            // SIMULATION: This would be handled by Zustand persist middleware
+            // For now, test that our state handlers are robust
+            if (corruptedState.queuedMessagesByThread) {
+              const threadId = `corruption-test-${index}`
+              const message = corruptedState.queuedMessagesByThread['thread-1']
+
+              // Should handle gracefully even with unexpected data
+              result.current.setQueuedMessage(threadId, message)
+            }
+          })
+        }).not.toThrow()
+      })
+    })
+  })
+
+  /**
+   * THREAD LIFECYCLE MANAGEMENT TESTS
+   * Tests for robust thread creation, switching, and cleanup
+   */
+  describe('Thread lifecycle management during migration', () => {
+    test('DYNAMIC THREAD CREATION: should handle new threads being created dynamically', () => {
+      // GOAL: Ensure new threads work properly with per-thread state system
+      // SCENARIO: User creates new chat while migration is ongoing
+
+      const { result } = renderHook(() => useAppState())
+
+      const newThreadIds = [
+        'new-work-chat',
+        'new-personal-chat',
+        'new-research-chat',
+      ]
+      const messages = newThreadIds.map((id, index) =>
+        createMockThreadMessage(`new-msg-${index}`, `Message for ${id}`)
+      )
+
+      act(() => {
+        // WHEN: Creating multiple new threads with state
+        newThreadIds.forEach((threadId, index) => {
+          result.current.updateStreamingContent(threadId, messages[index])
+          result.current.setQueuedMessage(threadId, `Queued for ${threadId}`)
+        })
+      })
+
+      // THEN: All new threads should have proper isolated state
+      newThreadIds.forEach((threadId, index) => {
+        expect(result.current.streamingContentByThread[threadId]).toEqual(
+          messages[index]
+        )
+        expect(result.current.queuedMessagesByThread[threadId]).toEqual(
+          `Queued for ${threadId}`
+        )
+      })
+
+      // VERIFY: Proper state isolation
+      expect(Object.keys(result.current.streamingContentByThread)).toHaveLength(
+        newThreadIds.length
+      )
+      expect(Object.keys(result.current.queuedMessagesByThread)).toHaveLength(
+        newThreadIds.length
+      )
+    })
+
+    test('THREAD DELETION CLEANUP: should properly clean up when threads are deleted', () => {
+      // GOAL: Ensure thread deletion doesn't leave orphaned state
+      // SCENARIO: User deletes a chat thread
+
+      const { result } = renderHook(() => useAppState())
+
+      const threadsToDelete = ['temp-thread-1', 'temp-thread-2']
+      const permanentThread = 'permanent-thread'
+      const messages = [
+        createMockThreadMessage('temp1', 'Temporary message 1'),
+        createMockThreadMessage('temp2', 'Temporary message 2'),
+        createMockThreadMessage('perm', 'Permanent message'),
+      ]
+
+      act(() => {
+        // SETUP: Create threads with comprehensive state
+        result.current.updateStreamingContent('temp-thread-1', messages[0])
+        result.current.updateStreamingContent('temp-thread-2', messages[1])
+        result.current.updateStreamingContent(permanentThread, messages[2])
+
+        result.current.setQueuedMessage('temp-thread-1', 'Temp queue 1')
+        result.current.setQueuedMessage('temp-thread-2', 'Temp queue 2')
+        result.current.setQueuedMessage(permanentThread, 'Permanent queue')
+
+        result.current.setThreadError('temp-thread-1', 'Temp error 1')
+        result.current.setThreadError(permanentThread, 'Permanent error')
+      })
+
+      // VERIFY: Initial state setup
+      expect(Object.keys(result.current.streamingContentByThread)).toHaveLength(
+        3
+      )
+
+      act(() => {
+        // WHEN: Delete temporary threads
+        threadsToDelete.forEach((threadId) => {
+          result.current.clearThread(threadId)
+        })
+      })
+
+      // THEN: Deleted threads should be completely cleaned up
+      threadsToDelete.forEach((threadId) => {
+        expect(
+          result.current.streamingContentByThread[threadId]
+        ).toBeUndefined()
+        expect(result.current.queuedMessagesByThread[threadId]).toBeUndefined()
+        expect(result.current.errorsByThread[threadId]).toBeUndefined()
+      })
+
+      // AND: Permanent thread should remain intact
+      expect(result.current.streamingContentByThread[permanentThread]).toEqual(
+        messages[2]
+      )
+      expect(result.current.queuedMessagesByThread[permanentThread]).toEqual(
+        'Permanent queue'
+      )
+      expect(result.current.errorsByThread[permanentThread]).toEqual(
+        'Permanent error'
+      )
+    })
+
+    test('RAPID THREAD SWITCHING: should handle rapid thread switching without state corruption', () => {
+      // GOAL: Ensure thread switching doesn't cause race conditions or state corruption
+      // SCENARIO: User rapidly switches between multiple active threads
+
+      const { result } = renderHook(() => useAppState())
+
+      const threads = ['rapid-1', 'rapid-2', 'rapid-3', 'rapid-4']
+      const messages = threads.map((id, i) =>
+        createMockThreadMessage(`rapid-msg-${i}`, `Rapid message for ${id}`)
+      )
+
+      act(() => {
+        // SIMULATION: Rapid thread switching with state updates
+        threads.forEach((threadId, i) => {
+          // Each thread gets comprehensive state
+          result.current.updateStreamingContent(threadId, messages[i])
+          result.current.setQueuedMessage(threadId, `Rapid queue ${i}`)
+          result.current.setThreadError(threadId, `Rapid error ${i}`)
+        })
+      })
+
+      // THEN: All threads should maintain their separate, correct state
+      threads.forEach((threadId, i) => {
+        expect(result.current.streamingContentByThread[threadId]).toEqual(
+          messages[i]
+        )
+        expect(result.current.queuedMessagesByThread[threadId]).toEqual(
+          `Rapid queue ${i}`
+        )
+        expect(result.current.errorsByThread[threadId]).toEqual(
+          `Rapid error ${i}`
+        )
+      })
+
+      // VERIFY: No cross-contamination between threads
+      expect(result.current.streamingContentByThread['rapid-1']).not.toEqual(
+        result.current.streamingContentByThread['rapid-2']
+      )
+    })
+  })
+
+  /**
+   * ERROR RECOVERY AND EDGE CASES
+   * Tests for system resilience during migration scenarios
+   */
+  describe('Error recovery and edge case handling during migration', () => {
+    test('STATE CORRUPTION RECOVERY: should recover gracefully from corrupted thread state', () => {
+      // GOAL: Ensure system can recover from corrupted state without crashing
+      // SCENARIO: Thread state becomes corrupted due to unexpected error
+
+      const { result } = renderHook(() => useAppState())
+
+      const validMessage = createMockThreadMessage('valid', 'Valid message')
+
+      act(() => {
+        // SETUP: Valid state
+        result.current.updateStreamingContent('recovery-thread', validMessage)
+
+        // SIMULATION: Corruption occurs (in real scenario, this might be due to
+        // memory corruption, network issues, etc.)
+
+        // RECOVERY: Clear and reinitialize
+        result.current.clearThread('recovery-thread')
+        result.current.updateStreamingContent(
+          'recovery-thread',
+          createMockThreadMessage('recovered', 'Recovered message')
+        )
+      })
+
+      // THEN: System should recover successfully
+      expect(
+        result.current.streamingContentByThread['recovery-thread']
+      ).toMatchObject({
+        id: 'recovered',
+        content: [{ type: 'text', value: 'Recovered message' }],
+      })
+    })
+
+    test('MEMORY PRESSURE HANDLING: should handle cleanup when memory pressure is high', () => {
+      // GOAL: Validate system can clean up inactive threads to manage memory usage
+      // SCENARIO: App running with many threads - need to clean up inactive ones
+
+      const { result } = renderHook(() => useAppState())
+
+      // SIMULATION: Create many threads (simulate memory pressure scenario)
+      const manyThreads = Array.from(
+        { length: 100 },
+        (_, i) => `memory-pressure-thread-${i}`
+      )
+
+      act(() => {
+        manyThreads.forEach((threadId) => {
+          result.current.updateStreamingContent(
+            threadId,
+            createMockThreadMessage(
+              `msg-${threadId}`,
+              `Content for ${threadId}`
+            )
+          )
+        })
+      })
+
+      // VERIFY: All threads created
+      expect(Object.keys(result.current.streamingContentByThread)).toHaveLength(
+        100
+      )
+
+      act(() => {
+        // SIMULATION: Memory pressure cleanup - keep only most recent threads
+        const activeThreads = manyThreads.slice(-5) // Keep last 5 threads active
+        const threadsToCleanup = manyThreads.filter(
+          (id) => !activeThreads.includes(id)
+        )
+
+        // Cleanup inactive threads
+        threadsToCleanup.forEach((threadId) => {
+          result.current.clearThread(threadId)
+        })
+      })
+
+      // THEN: Memory should be freed while keeping active threads
+      expect(Object.keys(result.current.streamingContentByThread)).toHaveLength(
+        5
+      )
+      expect(
+        result.current.streamingContentByThread['memory-pressure-thread-95']
+      ).toBeDefined()
+      expect(
+        result.current.streamingContentByThread['memory-pressure-thread-99']
+      ).toBeDefined()
+      expect(
+        result.current.streamingContentByThread['memory-pressure-thread-0']
+      ).toBeUndefined()
+    })
+
+    test('CONCURRENT MODIFICATION SAFETY: should handle concurrent modifications safely', () => {
+      // GOAL: Ensure thread-safe operations during concurrent modifications
+      // SCENARIO: Multiple parts of app modifying thread state simultaneously
+
+      const { result } = renderHook(() => useAppState())
+
+      const concurrentThreadId = 'concurrent-modifications'
+      const messages = Array.from({ length: 10 }, (_, i) =>
+        createMockThreadMessage(`concurrent-${i}`, `Concurrent message ${i}`)
+      )
+
+      act(() => {
+        // SIMULATION: Rapid concurrent modifications
+        messages.forEach((message, i) => {
+          // Simulate different parts of app making changes
+          result.current.updateStreamingContent(concurrentThreadId, message)
+          result.current.setThreadError(concurrentThreadId, `Error ${i}`)
+          result.current.setQueuedMessage(concurrentThreadId, `Queue ${i}`)
+
+          // Sometimes clear and reset
+          if (i % 3 === 0) {
+            result.current.setThreadError(concurrentThreadId, undefined)
+          }
+        })
+      })
+
+      // THEN: Final state should be consistent (not corrupted)
+      const finalState = result.current
+      expect(
+        finalState.streamingContentByThread[concurrentThreadId]
+      ).toBeDefined()
+      expect(
+        finalState.queuedMessagesByThread[concurrentThreadId]
+      ).toBeDefined()
+
+      // VERIFY: No undefined or null state corruption
+      const streamingContent =
+        finalState.streamingContentByThread[concurrentThreadId]
+      expect(streamingContent?.id).toBeDefined()
+      expect(streamingContent?.content).toBeDefined()
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useAppState.perThread.test.ts b/web-app/src/hooks/__tests__/useAppState.perThread.test.ts
new file mode 100644
index 0000000000..6f3f2fe74f
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useAppState.perThread.test.ts
@@ -0,0 +1,483 @@
+import { renderHook, act } from '@testing-library/react'
+import { ThreadMessage } from '@janhq/core'
+import { useAppState } from '../useAppState'
+
+/**
+ * MOCK DATA HELPERS
+ * These helpers create consistent test data for different scenarios
+ */
+const createMockThreadMessage = (id: string, content: string): ThreadMessage => ({
+  id,
+  thread_id: 'test-thread',
+  content: [{ type: 'text', text: { value: content } }],
+  role: 'assistant',
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  status: 'ready',
+  metadata: {}
+})
+
+const createMockTokenSpeed = (speed: number) => ({
+  tokenSpeed: speed,
+  tokenCount: 10,
+  lastTimestamp: Date.now(),
+  message: 'test-msg-id'
+})
+
+/**
+ * PER-THREAD STATE MANAGEMENT TESTS
+ * 
+ * These tests validate that the app state can manage multiple threads independently,
+ * where each thread maintains its own streaming content, token speed, errors, and queued messages.
+ * 
+ * Key requirements being validated:
+ * - Thread isolation (changes to one thread don't affect others)
+ * - State consistency during concurrent operations
+ * - Proper cleanup and memory management
+ * - Backward compatibility during migration
+ */
+describe('useAppState - Per-Thread State Management', () => {
+  beforeEach(() => {
+    // SETUP: Reset store to clean state before each test
+    // This ensures no test interference and predictable initial conditions
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  /**
+   * STREAMING CONTENT TESTS
+   * Validates that AI response streaming can happen independently per thread
+   */
+  describe('Thread-isolated streaming content management', () => {
+    test('CORE: should maintain separate streaming content for multiple threads simultaneously', () => {
+      // GOAL: Prove that thread-1 and thread-2 can have different streaming messages
+      // without interfering with each other
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const thread1Message = createMockThreadMessage('msg1', 'AI response for work chat')
+      const thread2Message = createMockThreadMessage('msg2', 'AI response for personal chat')
+      
+      act(() => {
+        // WHEN: Setting streaming content for two different threads
+        result.current.updateStreamingContent('work-thread', thread1Message)
+        result.current.updateStreamingContent('personal-thread', thread2Message)
+      })
+      
+      // THEN: Each thread should maintain its own content independently
+      expect(result.current.streamingContentByThread['work-thread']).toEqual(thread1Message)
+      expect(result.current.streamingContentByThread['personal-thread']).toEqual(thread2Message)
+      
+      // VERIFY: Threads are truly isolated
+      expect(result.current.streamingContentByThread['work-thread']).not.toEqual(thread2Message)
+    })
+
+    test('EDGE CASE: should handle clearing streaming content without affecting other threads', () => {
+      // GOAL: Ensure clearing streaming content is thread-specific
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const thread1Message = createMockThreadMessage('msg1', 'Thread 1 streaming')
+      const thread2Message = createMockThreadMessage('msg2', 'Thread 2 streaming')
+      
+      act(() => {
+        // SETUP: Both threads have streaming content
+        result.current.updateStreamingContent('thread-1', thread1Message)
+        result.current.updateStreamingContent('thread-2', thread2Message)
+        
+        // WHEN: Clear only thread-1's streaming content
+        result.current.updateStreamingContent('thread-1', undefined)
+      })
+      
+      // THEN: Only thread-1 should be cleared, thread-2 should remain unchanged
+      expect(result.current.streamingContentByThread['thread-1']).toBeUndefined()
+      expect(result.current.streamingContentByThread['thread-2']).toEqual(thread2Message)
+    })
+
+    test('UPDATE SCENARIO: should handle streaming content updates without cross-thread contamination', () => {
+      // GOAL: Validate that rapid updates to one thread don't corrupt another thread's state
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const initialMessage1 = createMockThreadMessage('initial1', 'Initial content thread 1')
+      const initialMessage2 = createMockThreadMessage('initial2', 'Initial content thread 2')
+      const updatedMessage1 = createMockThreadMessage('updated1', 'Updated content thread 1')
+      
+      act(() => {
+        // SETUP: Both threads have initial streaming content
+        result.current.updateStreamingContent('thread-1', initialMessage1)
+        result.current.updateStreamingContent('thread-2', initialMessage2)
+        
+        // WHEN: Update only thread-1 multiple times
+        result.current.updateStreamingContent('thread-1', updatedMessage1)
+      })
+      
+      // THEN: Thread-1 should have updated content, thread-2 should be unchanged
+      expect(result.current.streamingContentByThread['thread-1']).toEqual(updatedMessage1)
+      expect(result.current.streamingContentByThread['thread-2']).toEqual(initialMessage2)
+    })
+  })
+
+  /**
+   * TOKEN SPEED TESTS
+   * Validates that token generation speed tracking works independently per thread
+   */
+  describe('Thread-specific token speed tracking', () => {
+    test('CORE: should track different token speeds for different threads independently', () => {
+      // GOAL: Verify each thread can have its own token speed without interference
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const fastSpeed = createMockTokenSpeed(100) // Fast AI model
+      const slowSpeed = createMockTokenSpeed(25)  // Slower AI model
+      
+      act(() => {
+        // WHEN: Setting different speeds for different threads
+        result.current.updateTokenSpeed('fast-thread', fastSpeed)
+        result.current.updateTokenSpeed('slow-thread', slowSpeed)
+      })
+      
+      // THEN: Each thread should maintain its own speed independently
+      expect(result.current.tokenSpeedByThread['fast-thread']).toEqual(fastSpeed)
+      expect(result.current.tokenSpeedByThread['slow-thread']).toEqual(slowSpeed)
+    })
+
+    test('LIFECYCLE: should handle token speed lifecycle (set -> update -> clear)', () => {
+      // GOAL: Test complete token speed lifecycle for a single thread
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const initialSpeed = createMockTokenSpeed(50)
+      const updatedSpeed = createMockTokenSpeed(75)
+      
+      act(() => {
+        // Phase 1: Set initial speed
+        result.current.updateTokenSpeed('test-thread', initialSpeed)
+      })
+      
+      expect(result.current.tokenSpeedByThread['test-thread']).toEqual(initialSpeed)
+      
+      act(() => {
+        // Phase 2: Update speed
+        result.current.updateTokenSpeed('test-thread', updatedSpeed)
+      })
+      
+      expect(result.current.tokenSpeedByThread['test-thread']).toEqual(updatedSpeed)
+      
+      act(() => {
+        // Phase 3: Clear speed
+        result.current.updateTokenSpeed('test-thread', undefined)
+      })
+      
+      expect(result.current.tokenSpeedByThread['test-thread']).toBeUndefined()
+    })
+  })
+
+  /**
+   * ERROR HANDLING TESTS
+   * Validates that errors are properly isolated per thread
+   */
+  describe('Thread-isolated error management', () => {
+    test('CORE: should store and retrieve errors independently for each thread', () => {
+      // GOAL: Prove that errors in one thread don't affect other threads
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const connectionError = 'Connection failed to AI service'
+      const modelError = { message: 'Model loading failed', code: 500, details: 'GPU memory insufficient' }
+      
+      act(() => {
+        // WHEN: Setting different error types for different threads
+        result.current.setThreadError('connection-thread', connectionError)
+        result.current.setThreadError('model-thread', modelError)
+      })
+      
+      // THEN: Each thread should have its specific error
+      expect(result.current.errorsByThread['connection-thread']).toEqual(connectionError)
+      expect(result.current.errorsByThread['model-thread']).toEqual(modelError)
+    })
+
+    test('ERROR RECOVERY: should allow clearing errors without affecting other thread errors', () => {
+      // GOAL: Validate error recovery doesn't clear other thread errors
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const error1 = 'Thread 1 error'
+      const error2 = 'Thread 2 error'
+      
+      act(() => {
+        // SETUP: Both threads have errors
+        result.current.setThreadError('thread-1', error1)
+        result.current.setThreadError('thread-2', error2)
+        
+        // WHEN: Clear error from thread-1 only
+        result.current.setThreadError('thread-1', undefined)
+      })
+      
+      // THEN: Only thread-1 error should be cleared
+      expect(result.current.errorsByThread['thread-1']).toBeUndefined()
+      expect(result.current.errorsByThread['thread-2']).toEqual(error2)
+    })
+
+    test('ERROR TYPES: should handle both string and object error formats per thread', () => {
+      // GOAL: Ensure error system supports different error data structures
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const stringError = 'Simple error message'
+      const objectError = { 
+        message: 'Complex error', 
+        code: 'AUTH_FAILED', 
+        timestamp: Date.now(),
+        retryable: true 
+      }
+      
+      act(() => {
+        result.current.setThreadError('string-error-thread', stringError)
+        result.current.setThreadError('object-error-thread', objectError)
+      })
+      
+      expect(result.current.errorsByThread['string-error-thread']).toEqual(stringError)
+      expect(result.current.errorsByThread['object-error-thread']).toEqual(objectError)
+    })
+  })
+
+  /**
+   * QUEUED MESSAGES TESTS
+   * Validates that message queuing works independently per thread
+   */
+  describe('Thread-specific message queue management', () => {
+    test('CORE: should maintain separate message queues for each thread', () => {
+      // GOAL: Verify that queued messages don't cross between threads
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const workMessage = 'Please review the quarterly report'
+      const personalMessage = 'What\'s the weather like today?'
+      
+      act(() => {
+        // WHEN: Queuing messages in different threads
+        result.current.setQueuedMessage('work-thread', workMessage)
+        result.current.setQueuedMessage('personal-thread', personalMessage)
+      })
+      
+      // THEN: Each thread should have its specific queued message
+      expect(result.current.queuedMessagesByThread['work-thread']).toEqual(workMessage)
+      expect(result.current.queuedMessagesByThread['personal-thread']).toEqual(personalMessage)
+    })
+
+    test('QUEUE LIFECYCLE: should support queue operations (set -> clear -> reset)', () => {
+      // GOAL: Test complete queue lifecycle management
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const queuedMessage = 'Message waiting to be sent'
+      
+      act(() => {
+        // Phase 1: Queue a message
+        result.current.setQueuedMessage('test-thread', queuedMessage)
+      })
+      
+      expect(result.current.queuedMessagesByThread['test-thread']).toEqual(queuedMessage)
+      
+      act(() => {
+        // Phase 2: Clear the queue (message sent)
+        result.current.setQueuedMessage('test-thread', null)
+      })
+      
+      expect(result.current.queuedMessagesByThread['test-thread']).toBeNull()
+    })
+  })
+
+  /**
+   * THREAD CLEANUP TESTS
+   * Validates proper memory management and thread lifecycle
+   */
+  describe('Thread lifecycle and cleanup management', () => {
+    test('CLEANUP SINGLE: should clear all state for a specific thread without affecting others', () => {
+      // GOAL: Validate complete thread cleanup doesn't affect other threads
+      
+      const { result } = renderHook(() => useAppState())
+      
+      // SETUP: Create comprehensive state for multiple threads
+      const thread1Message = createMockThreadMessage('msg1', 'Thread 1 content')
+      const thread2Message = createMockThreadMessage('msg2', 'Thread 2 content')
+      const thread1Speed = createMockTokenSpeed(50)
+      const thread2Speed = createMockTokenSpeed(75)
+      
+      act(() => {
+        // Set up full state for both threads
+        result.current.updateStreamingContent('thread-1', thread1Message)
+        result.current.updateStreamingContent('thread-2', thread2Message)
+        result.current.updateTokenSpeed('thread-1', thread1Speed)
+        result.current.updateTokenSpeed('thread-2', thread2Speed)
+        result.current.setThreadError('thread-1', 'Thread 1 error')
+        result.current.setThreadError('thread-2', 'Thread 2 error')
+        result.current.setQueuedMessage('thread-1', 'Thread 1 queue')
+        result.current.setQueuedMessage('thread-2', 'Thread 2 queue')
+        
+        // WHEN: Clear only thread-1
+        result.current.clearThread('thread-1')
+      })
+      
+      // THEN: Thread-1 should be completely cleared
+      expect(result.current.streamingContentByThread['thread-1']).toBeUndefined()
+      expect(result.current.tokenSpeedByThread['thread-1']).toBeUndefined()
+      expect(result.current.errorsByThread['thread-1']).toBeUndefined()
+      expect(result.current.queuedMessagesByThread['thread-1']).toBeUndefined()
+      
+      // AND: Thread-2 should remain completely intact
+      expect(result.current.streamingContentByThread['thread-2']).toEqual(thread2Message)
+      expect(result.current.tokenSpeedByThread['thread-2']).toEqual(thread2Speed)
+      expect(result.current.errorsByThread['thread-2']).toEqual('Thread 2 error')
+      expect(result.current.queuedMessagesByThread['thread-2']).toEqual('Thread 2 queue')
+    })
+
+    test('CLEANUP ALL: should clear all threads when global cleanup is triggered', () => {
+      // GOAL: Validate global cleanup clears everything
+      
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        // SETUP: Create state for multiple threads
+        result.current.updateStreamingContent('thread-1', createMockThreadMessage('msg1', 'Test 1'))
+        result.current.updateStreamingContent('thread-2', createMockThreadMessage('msg2', 'Test 2'))
+        result.current.setThreadError('thread-1', 'Error 1')
+        result.current.setQueuedMessage('thread-2', 'Queue 2')
+        
+        // WHEN: Global cleanup
+        result.current.clearAllThreads()
+      })
+      
+      // THEN: All thread state should be cleared
+      expect(Object.keys(result.current.streamingContentByThread)).toHaveLength(0)
+      expect(Object.keys(result.current.tokenSpeedByThread)).toHaveLength(0)
+      expect(Object.keys(result.current.errorsByThread)).toHaveLength(0)
+      expect(Object.keys(result.current.queuedMessagesByThread)).toHaveLength(0)
+    })
+
+    test('CLEANUP RESILIENCE: should handle cleanup of non-existent threads gracefully', () => {
+      // GOAL: Ensure cleanup is safe even for threads that don't exist
+      
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        // SETUP: Create state for one thread
+        result.current.updateStreamingContent('existing-thread', createMockThreadMessage('msg1', 'Test'))
+        
+        // WHEN: Try to clear a non-existent thread (should not throw)
+        result.current.clearThread('non-existent-thread')
+      })
+      
+      // THEN: Existing thread should be unaffected, no errors should occur
+      expect(result.current.streamingContentByThread['existing-thread']).toBeDefined()
+      expect(() => result.current.clearThread('another-non-existent-thread')).not.toThrow()
+    })
+  })
+
+  /**
+   * CONCURRENCY AND RACE CONDITION TESTS
+   * Validates that rapid operations don't cause state corruption
+   */
+  describe('Concurrent operations and race condition prevention', () => {
+    test('RAPID UPDATES: should handle rapid state updates across multiple threads without corruption', () => {
+      // GOAL: Simulate high-frequency updates that could cause race conditions
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const messages = Array.from({ length: 20 }, (_, i) => 
+        createMockThreadMessage(`rapid-msg-${i}`, `Rapid message ${i}`)
+      )
+      
+      act(() => {
+        // WHEN: Rapidly updating different threads
+        messages.forEach((message, i) => {
+          const threadId = `thread-${i % 4}` // Distribute across 4 threads
+          result.current.updateStreamingContent(threadId, message)
+          result.current.setQueuedMessage(threadId, `Queue ${i}`)
+        })
+      })
+      
+      // THEN: Each thread should have its latest message (no corruption)
+      expect(result.current.streamingContentByThread['thread-0']).toEqual(messages[16]) // Last message for thread-0 (index 16)
+      expect(result.current.queuedMessagesByThread['thread-0']).toEqual('Queue 16')
+      expect(result.current.streamingContentByThread['thread-1']).toEqual(messages[17]) // Last message for thread-1 (index 17)
+      expect(result.current.queuedMessagesByThread['thread-1']).toEqual('Queue 17')
+    })
+
+    test('MIXED OPERATIONS: should maintain consistency during complex operation sequences', () => {
+      // GOAL: Test realistic sequences of mixed operations
+      
+      const { result } = renderHook(() => useAppState())
+      
+      act(() => {
+        // WHEN: Performing complex sequence of operations
+        result.current.updateStreamingContent('complex-thread', createMockThreadMessage('msg1', 'First'))
+        result.current.setThreadError('complex-thread', 'Initial error')
+        result.current.updateStreamingContent('complex-thread', createMockThreadMessage('msg2', 'Second'))
+        result.current.setQueuedMessage('complex-thread', 'Queued message')
+        result.current.setThreadError('complex-thread', undefined) // Clear error
+        result.current.updateStreamingContent('complex-thread', undefined) // Clear streaming
+      })
+      
+      // THEN: Final state should be consistent with operation sequence
+      expect(result.current.streamingContentByThread['complex-thread']).toBeUndefined()
+      expect(result.current.errorsByThread['complex-thread']).toBeUndefined()
+      expect(result.current.queuedMessagesByThread['complex-thread']).toEqual('Queued message')
+    })
+  })
+
+  /**
+   * EDGE CASES AND ERROR RESILIENCE
+   * Validates system handles unusual inputs and conditions gracefully
+   */
+  describe('Edge cases and system resilience', () => {
+    test('UNUSUAL INPUTS: should handle empty and special character thread IDs', () => {
+      // GOAL: Ensure system works with unusual but valid thread IDs
+      
+      const { result } = renderHook(() => useAppState())
+      
+      const specialThreadIds = [
+        '', // Empty string
+        'thread-with-special-chars!@#$%^&*()',
+        'thread with spaces',
+        '🔥-emoji-thread-🚀',
+        'very-long-thread-id-'.repeat(10) // Long ID
+      ]
+      
+      act(() => {
+        specialThreadIds.forEach((threadId, i) => {
+          const message = createMockThreadMessage(`msg-${i}`, `Message for ${threadId || 'empty'}`)
+          result.current.updateStreamingContent(threadId, message)
+        })
+      })
+      
+      // THEN: All special thread IDs should work correctly
+      specialThreadIds.forEach((threadId) => {
+        expect(result.current.streamingContentByThread[threadId]).toBeDefined()
+      })
+    })
+
+    test('NULL SAFETY: should handle undefined and null values without throwing errors', () => {
+      // GOAL: Ensure system is robust against null/undefined values
+      
+      const { result } = renderHook(() => useAppState())
+      
+      expect(() => {
+        act(() => {
+          // These operations should not throw
+          result.current.updateStreamingContent('test-thread', undefined)
+          result.current.updateTokenSpeed('test-thread', undefined)
+          result.current.setThreadError('test-thread', undefined)
+          result.current.setQueuedMessage('test-thread', null)
+        })
+      }).not.toThrow()
+      
+      // Verify safe handling
+      expect(result.current.streamingContentByThread['test-thread']).toBeUndefined()
+      expect(result.current.queuedMessagesByThread['test-thread']).toBeNull()
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useAppState.separateMethods.test.ts b/web-app/src/hooks/__tests__/useAppState.separateMethods.test.ts
new file mode 100644
index 0000000000..d0bac61a0c
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useAppState.separateMethods.test.ts
@@ -0,0 +1,228 @@
+import { renderHook, act } from '@testing-library/react'
+import { ThreadMessage } from '@janhq/core'
+import { useAppState } from '../useAppState'
+import { 
+  useStreamingContent, 
+  useThreadError, 
+  useTokenSpeed,
+  useQueuedMessage,
+  useIsThreadActive,
+  useThreadState 
+} from '../useThreadState'
+
+/**
+ * SIMPLE CLEAN TESTS FOR SEPARATE METHODS APPROACH
+ * 
+ * These tests validate that:
+ * 1. Legacy methods work exactly as before (backward compatibility)
+ * 2. New thread-aware methods work independently 
+ * 3. Both can be used together without conflicts
+ */
+
+const createMockThreadMessage = (id: string, content: string): ThreadMessage => ({
+  id,
+  thread_id: 'test-thread',
+  content: [{ type: 'text', text: { value: content } }] as any,
+  role: 'assistant' as any,
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  status: 'ready' as any,
+  metadata: {}
+})
+
+describe('useAppState - Separate Methods Approach (Clean)', () => {
+  beforeEach(() => {
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  describe('Legacy API Backward Compatibility', () => {
+    test('legacy updateStreamingContent should work unchanged', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const content = createMockThreadMessage('legacy', 'Legacy streaming content')
+      
+      act(() => {
+        result.current.updateStreamingContent(content)
+      })
+      
+      expect(result.current.streamingContent).toMatchObject({
+        ...content,
+        metadata: expect.objectContaining({
+          assistant: expect.any(Object)
+        })
+      })
+    })
+
+    test('legacy setQueuedMessage should work unchanged', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const message = 'Legacy queued message'
+      
+      act(() => {
+        result.current.setQueuedMessage(message)
+      })
+      
+      expect(result.current.queuedMessage).toEqual(message)
+      
+      act(() => {
+        result.current.setQueuedMessage(null)
+      })
+      
+      expect(result.current.queuedMessage).toBeNull()
+    })
+
+    test('legacy resetTokenSpeed should work unchanged', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const message = createMockThreadMessage('token', 'Token message')
+      
+      act(() => {
+        result.current.updateTokenSpeed(message)
+        result.current.resetTokenSpeed()
+      })
+      
+      expect(result.current.tokenSpeed).toBeUndefined()
+    })
+  })
+
+  describe('New Thread-Aware API', () => {
+    test('updateThreadStreamingContent should work independently per thread', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const content1 = createMockThreadMessage('msg1', 'Thread 1 content')
+      const content2 = createMockThreadMessage('msg2', 'Thread 2 content')
+      
+      act(() => {
+        result.current.updateThreadStreamingContent('thread-1', content1)
+        result.current.updateThreadStreamingContent('thread-2', content2)
+      })
+      
+      expect(result.current.streamingContentByThread['thread-1']).toEqual(content1)
+      expect(result.current.streamingContentByThread['thread-2']).toEqual(content2)
+      
+      // Clear one thread, other should remain
+      act(() => {
+        result.current.updateThreadStreamingContent('thread-1', undefined)
+      })
+      
+      expect(result.current.streamingContentByThread['thread-1']).toBeUndefined()
+      expect(result.current.streamingContentByThread['thread-2']).toEqual(content2)
+    })
+
+    test('addToThreadQueue should work independently per thread', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const message1 = 'Queued for thread 1'
+      const message2 = 'Queued for thread 2'
+      
+      act(() => {
+        result.current.addToThreadQueue('thread-1', message1)
+        result.current.addToThreadQueue('thread-2', message2)
+      })
+      
+      expect(result.current.queuedMessagesByThread['thread-1']).toEqual([message1])
+      expect(result.current.queuedMessagesByThread['thread-2']).toEqual([message2])
+      
+      act(() => {
+        result.current.clearThreadQueue('thread-1')
+      })
+      
+      expect(result.current.queuedMessagesByThread['thread-1']).toEqual([])
+      expect(result.current.queuedMessagesByThread['thread-2']).toEqual([message2])
+    })
+
+    test('setThreadError should work independently per thread', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const error1 = 'Thread 1 error'
+      const error2 = { message: 'Thread 2 complex error', code: 500 }
+      
+      act(() => {
+        result.current.setThreadError('thread-1', error1)
+        result.current.setThreadError('thread-2', error2)
+      })
+      
+      expect(result.current.errorsByThread['thread-1']).toEqual(error1)
+      expect(result.current.errorsByThread['thread-2']).toEqual(error2)
+    })
+
+    test('clearThread should clean up all state for specific thread', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const content = createMockThreadMessage('cleanup', 'Content to cleanup')
+      const error = 'Error to cleanup'
+      const queuedMessage = 'Message to cleanup'
+      
+      act(() => {
+        result.current.updateThreadStreamingContent('cleanup-thread', content)
+        result.current.setThreadError('cleanup-thread', error)
+        result.current.addToThreadQueue('cleanup-thread', queuedMessage)
+        
+        // Other thread should remain
+        result.current.addToThreadQueue('other-thread', 'Other message')
+      })
+      
+      act(() => {
+        result.current.clearThread('cleanup-thread')
+      })
+      
+      // Cleanup thread should be completely cleared
+      expect(result.current.streamingContentByThread['cleanup-thread']).toBeUndefined()
+      expect(result.current.errorsByThread['cleanup-thread']).toBeUndefined()
+      expect(result.current.queuedMessagesByThread['cleanup-thread']).toBeUndefined()
+      
+      // Other thread should remain intact
+      expect(result.current.queuedMessagesByThread['other-thread']).toEqual(['Other message'])
+    })
+  })
+
+  describe('Legacy and New API Coexistence', () => {
+    test('should handle legacy and new APIs being used simultaneously', () => {
+      const { result } = renderHook(() => useAppState())
+      
+      const legacyContent = createMockThreadMessage('legacy', 'Legacy content')
+      const threadContent = createMockThreadMessage('thread', 'Thread content')
+      
+      act(() => {
+        // Use legacy API for global state
+        result.current.updateStreamingContent(legacyContent)
+        result.current.setQueuedMessage('Global queued message')
+        
+        // Use new API for thread-specific state
+        result.current.updateThreadStreamingContent('specific-thread', threadContent)
+        result.current.addToThreadQueue('specific-thread', 'Thread queued message')
+      })
+      
+      // Both should work independently
+      expect(result.current.streamingContent).toMatchObject({
+        ...legacyContent,
+        metadata: expect.objectContaining({
+          assistant: expect.any(Object)
+        })
+      })
+      expect(result.current.queuedMessage).toEqual('Global queued message')
+      
+      expect(result.current.streamingContentByThread['specific-thread']).toEqual(threadContent)
+      expect(result.current.queuedMessagesByThread['specific-thread']).toEqual(['Thread queued message'])
+    })
+  })
+
+  describe('Convenience Hooks Integration', () => {
+    test('convenience hooks should work with new thread-aware methods', () => {
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: streamingResult, rerender } = renderHook(() => useStreamingContent('hook-thread'))
+      
+      const content = createMockThreadMessage('hook', 'Hook test content')
+      
+      act(() => {
+        appStateResult.current.updateThreadStreamingContent('hook-thread', content)
+      })
+      rerender()
+      
+      expect(streamingResult.current).toEqual(content)
+    })
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useInferenceScheduler.test.ts b/web-app/src/hooks/__tests__/useInferenceScheduler.test.ts
new file mode 100644
index 0000000000..d77b577116
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useInferenceScheduler.test.ts
@@ -0,0 +1,347 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { act, renderHook } from '@testing-library/react'
+import { useInferenceScheduler, useAutoScheduler } from '../useInferenceScheduler'
+import { useAppState } from '../useAppState'
+import { useChat } from '../useChat'
+
+// Mock the useChat hook
+vi.mock('../useChat', () => ({
+  useChat: vi.fn(() => ({
+    sendMessage: vi.fn()
+  }))
+}))
+
+// Mock the useAssistant hook as a Zustand store
+vi.mock('../useAssistant', () => ({
+  useAssistant: Object.assign(
+    vi.fn(() => ({
+      selectedAssistant: null,
+      updateAssistantTools: vi.fn()
+    })),
+    {
+      getState: vi.fn(() => ({
+        currentAssistant: { id: 'test-assistant', name: 'Test Assistant' },
+        assistants: [{ id: 'test-assistant', name: 'Test Assistant' }]
+      }))
+    }
+  )
+}))
+
+const mockSendMessage = vi.fn()
+
+describe('useInferenceScheduler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Reset Zustand store to initial state
+    act(() => {
+      useAppState.setState({
+        processingThreads: {},
+        maxConcurrency: 1,
+        fallbackMode: 'single-thread',
+        parallelProcessingEnabled: false,
+        streamingContent: undefined,
+        tokenSpeed: {},
+        queuedMessagesByThread: {},
+        errorsByThread: {},
+        abortControllers: {}
+      })
+    })
+
+    // Mock useChat to return our mock sendMessage
+    vi.mocked(useChat).mockReturnValue({
+      sendMessage: mockSendMessage
+    } as any)
+  })
+
+  describe('basic scheduling logic', () => {
+    it('should not schedule when no messages are queued', () => {
+      const { result } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        result.current.schedule()
+      })
+
+      expect(mockSendMessage).not.toHaveBeenCalled()
+    })
+
+    it('should not schedule when no slots are available', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        // Set max concurrency to 1 and mark one thread as processing
+        appState.current.setMaxConcurrency(1)
+        appState.current.setThreadProcessing('thread-1', true)
+        appState.current.addToThreadQueue('thread-2', 'test message')
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      expect(mockSendMessage).not.toHaveBeenCalled()
+    })
+
+    it('should schedule one thread when slot is available', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'test message')
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('test message', true, { explicitThreadId: 'thread-1' })
+    })
+
+    it('should not schedule thread that is already processing', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'test message')
+        appState.current.setThreadProcessing('thread-1', true)
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      expect(mockSendMessage).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('single-thread mode (MVP behavior)', () => {
+    it('should only process one thread at a time', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        appState.current.addToThreadQueue('thread-2', 'message1')
+        appState.current.addToThreadQueue('thread-3', 'message1')
+        // Keep single-thread mode (maxConcurrency: 1, parallelProcessingEnabled: false)
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      // Should respect current concurrency setting
+      const expectedCallCount = Math.min(
+        appState.current.maxConcurrency, 
+        appState.current.parallelProcessingEnabled ? 3 : 1
+      )
+      expect(mockSendMessage).toHaveBeenCalledTimes(expectedCallCount)
+    })
+
+    it('should maintain FIFO order within each thread', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'first-message')
+        appState.current.addToThreadQueue('thread-1', 'second-message')
+        appState.current.addToThreadQueue('thread-1', 'third-message')
+      })
+
+      // Process first message
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('first-message', true, { explicitThreadId: 'thread-1' })
+      expect(mockSendMessage).toHaveBeenCalledTimes(1)
+
+      // Simulate completion and process next
+      act(() => {
+        appState.current.setThreadProcessing('thread-1', false)
+        scheduler.current.schedule()
+      })
+
+      expect(mockSendMessage).toHaveBeenCalledWith('second-message', true, { explicitThreadId: 'thread-1' })
+      expect(mockSendMessage).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('error handling and cleanup', () => {
+    it('should handle sendMessage errors gracefully', async () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      // Mock sendMessage to throw error
+      mockSendMessage.mockRejectedValueOnce(new Error('Inference failed'))
+
+      act(() => {
+        appState.current.addToThreadQueue('thread-1', 'test message')
+      })
+
+      // Should not throw error
+      await act(async () => {
+        scheduler.current.startThreadInference('thread-1')
+      })
+
+      expect(mockSendMessage).toHaveBeenCalled()
+    })
+
+    it('should prevent recursive scheduling', () => {
+      const { result } = renderHook(() => useInferenceScheduler())
+
+      // Call schedule multiple times rapidly
+      act(() => {
+        for (let i = 0; i < 10; i++) {
+          result.current.schedule()
+        }
+      })
+
+      // Should not cause issues (scheduler uses ref to prevent recursion)
+      expect(result.current).toBeDefined()
+    })
+  })
+
+  describe('scheduling status', () => {
+    it('should provide accurate scheduling status', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.setMaxConcurrency(3)
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        appState.current.addToThreadQueue('thread-2', 'message1')
+        appState.current.setThreadProcessing('thread-3', true)
+      })
+
+      const status = scheduler.current.getSchedulingStatus()
+
+      expect(status).toEqual({
+        availableSlots: 2, // 3 max - 1 processing
+        activeProcessingCount: 1,
+        maxConcurrency: 3,
+        parallelProcessingEnabled: false,
+        fallbackMode: 'single-thread',
+        queuedThreads: ['thread-1', 'thread-2'],
+        processingThreads: ['thread-3'],
+      })
+    })
+  })
+
+  describe('concurrency behavior', () => {
+    it('should respect maxConcurrency setting when parallel processing disabled', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.setMaxConcurrency(3)
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        appState.current.addToThreadQueue('thread-2', 'message2')
+        appState.current.addToThreadQueue('thread-3', 'message3')
+        // Keep parallel processing disabled for MVP behavior
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      // Should only start 1 thread when parallelProcessingEnabled is false
+      const expectedThreads = appState.current.parallelProcessingEnabled ? 
+        Math.min(appState.current.maxConcurrency, 3) : 1
+      expect(mockSendMessage).toHaveBeenCalledTimes(expectedThreads)
+    })
+
+    it('should start multiple threads when parallel processing enabled', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.setMaxConcurrency(2)
+        appState.current.setParallelProcessingEnabled(true)
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        appState.current.addToThreadQueue('thread-2', 'message2')
+        appState.current.addToThreadQueue('thread-3', 'message3')
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      // Should start up to maxConcurrency threads
+      expect(mockSendMessage).toHaveBeenCalledTimes(appState.current.maxConcurrency)
+    })
+
+    it('should not exceed available threads', () => {
+      const { result: appState } = renderHook(() => useAppState())
+      const { result: scheduler } = renderHook(() => useInferenceScheduler())
+
+      act(() => {
+        appState.current.setMaxConcurrency(5)
+        appState.current.setParallelProcessingEnabled(true)
+        // Only queue 2 threads but allow 5 concurrent
+        appState.current.addToThreadQueue('thread-1', 'message1')
+        appState.current.addToThreadQueue('thread-2', 'message2')
+      })
+
+      act(() => {
+        scheduler.current.schedule()
+      })
+
+      // Should only start 2 threads (limited by available queued threads)
+      expect(mockSendMessage).toHaveBeenCalledTimes(2)
+    })
+  })
+})
+
+describe('useAutoScheduler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    // Reset Zustand store to initial state
+    act(() => {
+      useAppState.setState({
+        processingThreads: {},
+        maxConcurrency: 1,
+        fallbackMode: 'single-thread',
+        parallelProcessingEnabled: false,
+        streamingContent: undefined,
+        tokenSpeed: {},
+        queuedMessagesByThread: {},
+        errorsByThread: {},
+        abortControllers: {}
+      })
+    })
+
+    // Mock useChat to return our mock sendMessage
+    vi.mocked(useChat).mockReturnValue({
+      sendMessage: mockSendMessage
+    } as any)
+  })
+
+  it('should automatically schedule when queue changes', () => {
+    const { result: appState } = renderHook(() => useAppState())
+    renderHook(() => useAutoScheduler()) // Auto-scheduler should be active
+
+    act(() => {
+      appState.current.addToThreadQueue('thread-1', 'test message')
+    })
+
+    // Should automatically trigger scheduling due to queue change
+    expect(mockSendMessage).toHaveBeenCalledWith('test message', true, { explicitThreadId: 'thread-1' })
+  })
+
+  it('should automatically schedule when processing state changes', () => {
+    const { result: appState } = renderHook(() => useAppState())
+    renderHook(() => useAutoScheduler()) // Auto-scheduler should be active
+
+    act(() => {
+      appState.current.addToThreadQueue('thread-1', 'message1')
+      appState.current.addToThreadQueue('thread-1', 'message2')
+    })
+
+    // Should process at least the first message (single-thread mode processes one at a time)
+    expect(mockSendMessage).toHaveBeenCalledWith('message1', true, { explicitThreadId: 'thread-1' })
+    
+    // Auto-scheduler is reactive to state changes - may process both or just first depending on timing
+    expect(mockSendMessage.mock.calls.length).toBeGreaterThanOrEqual(1)
+  })
+})
diff --git a/web-app/src/hooks/__tests__/useThreadState.convenience.test.ts b/web-app/src/hooks/__tests__/useThreadState.convenience.test.ts
new file mode 100644
index 0000000000..4de6abc804
--- /dev/null
+++ b/web-app/src/hooks/__tests__/useThreadState.convenience.test.ts
@@ -0,0 +1,542 @@
+import { renderHook, act } from '@testing-library/react'
+import { ThreadMessage } from '@janhq/core'
+import { useAppState } from '../useAppState'
+import { 
+  useStreamingContent, 
+  useThreadError, 
+  useTokenSpeed,
+  useQueuedMessage,
+  useIsThreadActive
+} from '../useThreadState'
+
+/**
+ * MOCK DATA HELPERS
+ * Consistent test data creation for different scenarios
+ */
+const createMockThreadMessage = (id: string, content: string): ThreadMessage => ({
+  id,
+  thread_id: 'test-thread',
+  content: [{ type: 'text', text: { value: content } }],
+  role: 'assistant',
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  status: 'ready',
+  metadata: {}
+})
+
+const createMockTokenSpeed = (speed: number) => ({
+  tokenSpeed: speed,
+  tokenCount: 10,
+  lastTimestamp: Date.now(),
+  message: 'test-msg-id'
+})
+
+/**
+ * CONVENIENCE HOOKS TESTS
+ * 
+ * These tests validate the thread-specific convenience hooks that provide
+ * easy access to per-thread state without prop drilling or complex selectors.
+ * 
+ * Key goals:
+ * - Simplify component access to thread-specific state
+ * - Optimize re-rendering (only update when specific thread state changes)
+ * - Provide clean, readable APIs for common use cases
+ * - Maintain performance with efficient Zustand selectors
+ */
+describe('Thread State Convenience Hooks - API Usability & Performance', () => {
+  beforeEach(() => {
+    // SETUP: Reset store to clean state before each test
+    const { result } = renderHook(() => useAppState())
+    act(() => {
+      result.current.clearAllThreads()
+    })
+  })
+
+  /**
+   * STREAMING CONTENT CONVENIENCE HOOK TESTS
+   * Tests for useStreamingContent(threadId) hook
+   */
+  describe('useStreamingContent - Thread-specific streaming content access', () => {
+    test('BASIC RETRIEVAL: should return streaming content for the specified thread only', () => {
+      // GOAL: Validate that hook returns correct content for requested thread
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: streamingResult } = renderHook(() => useStreamingContent('target-thread'))
+      
+      const targetMessage = createMockThreadMessage('target-msg', 'Content for target thread')
+      const otherMessage = createMockThreadMessage('other-msg', 'Content for other thread')
+      
+      act(() => {
+        // SETUP: Set content for both target and other thread
+        appStateResult.current.updateStreamingContent('target-thread', targetMessage)
+        appStateResult.current.updateStreamingContent('other-thread', otherMessage)
+      })
+      
+      // THEN: Hook should return only the target thread's content
+      expect(streamingResult.current).toEqual(targetMessage)
+      expect(streamingResult.current).not.toEqual(otherMessage)
+    })
+
+    test('EMPTY STATE: should return undefined when thread has no streaming content', () => {
+      // GOAL: Ensure hook handles empty state gracefully
+      
+      const { result } = renderHook(() => useStreamingContent('empty-thread'))
+      
+      // THEN: Should return undefined for thread with no content
+      expect(result.current).toBeUndefined()
+    })
+
+    test('REACTIVITY: should update when streaming content changes for the specific thread', () => {
+      // GOAL: Validate hook reactivity to state changes
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: streamingResult, rerender } = renderHook(() => useStreamingContent('reactive-thread'))
+      
+      const firstMessage = createMockThreadMessage('first', 'First streaming message')
+      const secondMessage = createMockThreadMessage('second', 'Updated streaming message')
+      
+      // PHASE 1: Initial empty state
+      expect(streamingResult.current).toBeUndefined()
+      
+      // PHASE 2: Set streaming content
+      act(() => {
+        appStateResult.current.updateStreamingContent('reactive-thread', firstMessage)
+      })
+      rerender()
+      
+      expect(streamingResult.current).toEqual(firstMessage)
+      
+      // PHASE 3: Update streaming content
+      act(() => {
+        appStateResult.current.updateStreamingContent('reactive-thread', secondMessage)
+      })
+      rerender()
+      
+      expect(streamingResult.current).toEqual(secondMessage)
+      
+      // PHASE 4: Clear streaming content
+      act(() => {
+        appStateResult.current.updateStreamingContent('reactive-thread', undefined)
+      })
+      rerender()
+      
+      expect(streamingResult.current).toBeUndefined()
+    })
+
+    test('ISOLATION: should not be affected by changes to other threads', () => {
+      // GOAL: Ensure thread isolation - changes to other threads don't affect this hook
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: streamingResult, rerender } = renderHook(() => useStreamingContent('isolated-thread'))
+      
+      const isolatedMessage = createMockThreadMessage('isolated', 'Isolated thread message')
+      const noiseMessage1 = createMockThreadMessage('noise1', 'Noise from thread 1')
+      const noiseMessage2 = createMockThreadMessage('noise2', 'Noise from thread 2')
+      
+      act(() => {
+        // SETUP: Set content for target thread
+        appStateResult.current.updateStreamingContent('isolated-thread', isolatedMessage)
+        
+        // NOISE: Update other threads (should not affect our hook)
+        appStateResult.current.updateStreamingContent('noise-thread-1', noiseMessage1)
+        appStateResult.current.updateStreamingContent('noise-thread-2', noiseMessage2)
+      })
+      rerender()
+      
+      // THEN: Our hook should only see the isolated thread's content
+      expect(streamingResult.current).toEqual(isolatedMessage)
+    })
+  })
+
+  /**
+   * THREAD ERROR CONVENIENCE HOOK TESTS
+   * Tests for useThreadError(threadId) hook
+   */
+  describe('useThreadError - Thread-specific error state access', () => {
+    test('STRING ERROR RETRIEVAL: should return string error for the specified thread', () => {
+      // GOAL: Validate string error retrieval functionality
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: errorResult } = renderHook(() => useThreadError('error-thread'))
+      
+      const errorMessage = 'Connection timeout after 30 seconds'
+      
+      act(() => {
+        appStateResult.current.setThreadError('error-thread', errorMessage)
+      })
+      
+      expect(errorResult.current).toEqual(errorMessage)
+    })
+
+    test('OBJECT ERROR RETRIEVAL: should handle complex error objects correctly', () => {
+      // GOAL: Validate complex error object handling
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: errorResult } = renderHook(() => useThreadError('complex-error-thread'))
+      
+      const complexError = { 
+        message: 'AI model inference failed', 
+        code: 'MODEL_ERROR',
+        details: {
+          model: 'llama-7b',
+          timestamp: Date.now(),
+          retryable: true,
+          suggestion: 'Try reducing context length'
+        }
+      }
+      
+      act(() => {
+        appStateResult.current.setThreadError('complex-error-thread', complexError)
+      })
+      
+      expect(errorResult.current).toEqual(complexError)
+      expect(errorResult.current).toHaveProperty('details.retryable', true)
+    })
+
+    test('NO ERROR STATE: should return undefined when thread has no error', () => {
+      // GOAL: Ensure clean state when no errors exist
+      
+      const { result } = renderHook(() => useThreadError('clean-thread'))
+      
+      expect(result.current).toBeUndefined()
+    })
+
+    test('ERROR RECOVERY: should reflect error clearing in real-time', () => {
+      // GOAL: Test error recovery workflow
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: errorResult, rerender } = renderHook(() => useThreadError('recovery-thread'))
+      
+      const temporaryError = 'Temporary network issue'
+      
+      // PHASE 1: Set error
+      act(() => {
+        appStateResult.current.setThreadError('recovery-thread', temporaryError)
+      })
+      rerender()
+      
+      expect(errorResult.current).toEqual(temporaryError)
+      
+      // PHASE 2: Clear error (recovery)
+      act(() => {
+        appStateResult.current.setThreadError('recovery-thread', undefined)
+      })
+      rerender()
+      
+      expect(errorResult.current).toBeUndefined()
+    })
+  })
+
+  /**
+   * TOKEN SPEED CONVENIENCE HOOK TESTS
+   * Tests for useTokenSpeed(threadId) hook
+   */
+  describe('useTokenSpeed - Thread-specific performance metrics access', () => {
+    test('SPEED TRACKING: should return token speed metrics for the specified thread', () => {
+      // GOAL: Validate token speed tracking functionality
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: speedResult } = renderHook(() => useTokenSpeed('speed-thread'))
+      
+      const speedMetrics = createMockTokenSpeed(85) // 85 tokens/sec
+      
+      act(() => {
+        appStateResult.current.updateTokenSpeed('speed-thread', speedMetrics)
+      })
+      
+      expect(speedResult.current).toEqual(speedMetrics)
+      expect(speedResult.current?.tokenSpeed).toBe(85)
+    })
+
+    test('NO METRICS STATE: should return undefined when thread has no speed data', () => {
+      // GOAL: Handle threads without performance metrics
+      
+      const { result } = renderHook(() => useTokenSpeed('no-metrics-thread'))
+      
+      expect(result.current).toBeUndefined()
+    })
+
+    test('METRICS UPDATES: should track speed changes over time', () => {
+      // GOAL: Validate dynamic speed tracking
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: speedResult, rerender } = renderHook(() => useTokenSpeed('dynamic-thread'))
+      
+      const initialSpeed = createMockTokenSpeed(50)
+      const improvedSpeed = createMockTokenSpeed(75)
+      
+      // PHASE 1: Initial speed
+      act(() => {
+        appStateResult.current.updateTokenSpeed('dynamic-thread', initialSpeed)
+      })
+      rerender()
+      
+      expect(speedResult.current?.tokenSpeed).toBe(50)
+      
+      // PHASE 2: Speed improvement
+      act(() => {
+        appStateResult.current.updateTokenSpeed('dynamic-thread', improvedSpeed)
+      })
+      rerender()
+      
+      expect(speedResult.current?.tokenSpeed).toBe(75)
+    })
+  })
+
+  /**
+   * QUEUED MESSAGE CONVENIENCE HOOK TESTS
+   * Tests for useQueuedMessage(threadId) hook
+   */
+  describe('useQueuedMessage - Thread-specific message queue access', () => {
+    test('QUEUE RETRIEVAL: should return queued message for the specified thread', () => {
+      // GOAL: Validate queued message access functionality
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: queueResult } = renderHook(() => useQueuedMessage('queue-thread'))
+      
+      const queuedMessage = 'Please analyze this data when you finish the current task'
+      
+      act(() => {
+        appStateResult.current.setQueuedMessage('queue-thread', queuedMessage)
+      })
+      
+      expect(queueResult.current).toEqual(queuedMessage)
+    })
+
+    test('QUEUE LIFECYCLE: should handle queue set -> clear -> reset workflow', () => {
+      // GOAL: Test complete queue lifecycle
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: queueResult, rerender } = renderHook(() => useQueuedMessage('lifecycle-thread'))
+      
+      const testMessage = 'Test queued message'
+      
+      // PHASE 1: Initially no queue
+      expect(queueResult.current).toBeUndefined()
+      
+      // PHASE 2: Queue a message
+      act(() => {
+        appStateResult.current.setQueuedMessage('lifecycle-thread', testMessage)
+      })
+      rerender()
+      
+      expect(queueResult.current).toEqual(testMessage)
+      
+      // PHASE 3: Clear queue (message processed)
+      act(() => {
+        appStateResult.current.setQueuedMessage('lifecycle-thread', null)
+      })
+      rerender()
+      
+      expect(queueResult.current).toBeNull()
+    })
+
+    test('EMPTY QUEUE STATE: should return appropriate value when no message is queued', () => {
+      // GOAL: Validate empty queue state handling
+      
+      const { result } = renderHook(() => useQueuedMessage('empty-queue-thread'))
+      
+      expect(result.current).toBeUndefined()
+    })
+  })
+
+  /**
+   * THREAD ACTIVITY STATUS HOOK TESTS
+   * Tests for useIsThreadActive(threadId) hook
+   */
+  describe('useIsThreadActive - Thread activity status detection', () => {
+    test('ACTIVE DETECTION: should return true when thread has streaming content', () => {
+      // GOAL: Detect when a thread is actively generating content
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: activeResult, rerender } = renderHook(() => useIsThreadActive('active-thread'))
+      
+      const activeMessage = createMockThreadMessage('active', 'AI is generating response...')
+      
+      act(() => {
+        appStateResult.current.updateStreamingContent('active-thread', activeMessage)
+      })
+      rerender()
+      
+      expect(activeResult.current).toBe(true)
+    })
+
+    test('INACTIVE DETECTION: should return false when thread has no streaming content', () => {
+      // GOAL: Detect inactive/idle threads
+      
+      const { result } = renderHook(() => useIsThreadActive('inactive-thread'))
+      
+      expect(result.current).toBe(false)
+    })
+
+    test('ACTIVITY TRANSITION: should track activity state transitions correctly', () => {
+      // GOAL: Validate activity state changes over time
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: activeResult, rerender } = renderHook(() => useIsThreadActive('transition-thread'))
+      
+      const streamingMessage = createMockThreadMessage('streaming', 'Generating response...')
+      
+      // PHASE 1: Initially inactive
+      expect(activeResult.current).toBe(false)
+      
+      // PHASE 2: Start streaming (becomes active)
+      act(() => {
+        appStateResult.current.updateStreamingContent('transition-thread', streamingMessage)
+      })
+      rerender()
+      
+      expect(activeResult.current).toBe(true)
+      
+      // PHASE 3: Stop streaming (becomes inactive)
+      act(() => {
+        appStateResult.current.updateStreamingContent('transition-thread', undefined)
+      })
+      rerender()
+      
+      expect(activeResult.current).toBe(false)
+    })
+
+    test('MULTI-THREAD ACTIVITY: should track activity independently across multiple threads', () => {
+      // GOAL: Ensure activity detection works independently for different threads
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: active1Result, rerender: rerender1 } = renderHook(() => useIsThreadActive('multi-thread-1'))
+      const { result: active2Result, rerender: rerender2 } = renderHook(() => useIsThreadActive('multi-thread-2'))
+      
+      const message1 = createMockThreadMessage('msg1', 'Thread 1 active')
+      
+      act(() => {
+        // Only thread-1 starts streaming
+        appStateResult.current.updateStreamingContent('multi-thread-1', message1)
+        // thread-2 remains inactive
+      })
+      rerender1()
+      rerender2()
+      
+      expect(active1Result.current).toBe(true)  // Thread 1 is active
+      expect(active2Result.current).toBe(false) // Thread 2 is inactive
+      
+      const message2 = createMockThreadMessage('msg2', 'Thread 2 now active')
+      
+      act(() => {
+        // Both threads now active
+        appStateResult.current.updateStreamingContent('multi-thread-2', message2)
+      })
+      rerender1()
+      rerender2()
+      
+      expect(active1Result.current).toBe(true)  // Thread 1 still active
+      expect(active2Result.current).toBe(true)  // Thread 2 now active
+    })
+  })
+
+  /**
+   * PERFORMANCE AND OPTIMIZATION TESTS
+   * Validates that hooks are optimized and don't cause unnecessary re-renders
+   */
+  describe('Performance optimization and re-rendering efficiency', () => {
+    test('SELECTIVE REACTIVITY: should only re-render when specific thread state changes', () => {
+      // GOAL: Validate that hooks use efficient selectors to minimize re-renders
+      // NOTE: This test validates the concept - actual re-render counting may vary
+      //       based on Zustand's internal optimization
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      
+      let renderCount1 = 0
+      let renderCount2 = 0
+      
+      const { rerender: rerender1 } = renderHook(() => {
+        renderCount1++
+        return useStreamingContent('selective-thread-1')
+      })
+      
+      const { rerender: rerender2 } = renderHook(() => {
+        renderCount2++
+        return useStreamingContent('selective-thread-2')
+      })
+      
+      // BASELINE: Initial renders
+      const initialRender1 = renderCount1
+      const initialRender2 = renderCount2
+      
+      // WHEN: Update only thread-1
+      act(() => {
+        appStateResult.current.updateStreamingContent('selective-thread-1', 
+          createMockThreadMessage('msg1', 'Thread 1 update'))
+      })
+      rerender1()
+      rerender2()
+      
+      // THEN: Both hooks may re-render due to Zustand subscription model
+      // but the important thing is that the values are correctly isolated
+      expect(renderCount1).toBeGreaterThan(initialRender1) // Thread 1 hook updated
+      expect(renderCount2).toBeGreaterThan(initialRender2) // Thread 2 hook may also re-render
+      
+      // VERIFY: Values are still correctly isolated despite re-renders
+      const { result: thread1Result } = renderHook(() => useStreamingContent('selective-thread-1'))
+      const { result: thread2Result } = renderHook(() => useStreamingContent('selective-thread-2'))
+      
+      expect(thread1Result.current).toBeDefined()
+      expect(thread2Result.current).toBeUndefined()
+    })
+
+    test('HOOK STABILITY: should maintain stable references when state doesn\'t change', () => {
+      // GOAL: Ensure hooks don't create new references unnecessarily
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      const { result: streamingResult, rerender } = renderHook(() => useStreamingContent('stable-thread'))
+      
+      const testMessage = createMockThreadMessage('stable', 'Stable message')
+      
+      act(() => {
+        appStateResult.current.updateStreamingContent('stable-thread', testMessage)
+      })
+      rerender()
+      
+      const firstReference = streamingResult.current
+      
+      // Re-render without changing state
+      rerender()
+      
+      const secondReference = streamingResult.current
+      
+      // References should be the same (Zustand's internal optimization)
+      expect(firstReference).toBe(secondReference)
+    })
+
+    test('MEMORY EFFICIENCY: should not leak memory when threads are cleaned up', () => {
+      // GOAL: Validate that cleanup doesn't leave stale references
+      // NOTE: This is more of a conceptual test - actual memory leak detection
+      //       would require more sophisticated tooling
+      
+      const { result: appStateResult } = renderHook(() => useAppState())
+      
+      // SETUP: Create and populate multiple threads
+      const threadIds = Array.from({ length: 10 }, (_, i) => `temp-thread-${i}`)
+      
+      act(() => {
+        threadIds.forEach(threadId => {
+          appStateResult.current.updateStreamingContent(threadId, 
+            createMockThreadMessage(`msg-${threadId}`, `Content for ${threadId}`))
+        })
+      })
+      
+      // VERIFY: All threads exist
+      threadIds.forEach(threadId => {
+        expect(appStateResult.current.streamingContentByThread[threadId]).toBeDefined()
+      })
+      
+      // CLEANUP: Remove all threads
+      act(() => {
+        appStateResult.current.clearAllThreads()
+      })
+      
+      // VERIFY: All threads are properly cleaned up
+      expect(Object.keys(appStateResult.current.streamingContentByThread)).toHaveLength(0)
+      expect(Object.keys(appStateResult.current.tokenSpeedByThread)).toHaveLength(0)
+      expect(Object.keys(appStateResult.current.errorsByThread)).toHaveLength(0)
+      expect(Object.keys(appStateResult.current.queuedMessagesByThread)).toHaveLength(0)
+    })
+  })
+})
diff --git a/web-app/src/hooks/useAppState.ts b/web-app/src/hooks/useAppState.ts
index fe885e0438..2b320bafb2 100644
--- a/web-app/src/hooks/useAppState.ts
+++ b/web-app/src/hooks/useAppState.ts
@@ -4,25 +4,40 @@ import { MCPTool } from '@/types/completion'
 import { useAssistant } from './useAssistant'
 import { ChatCompletionMessageToolCall } from 'openai/resources'
 
-type AppErrorMessage = {
-  message?: string
-  title?: string
-  subtitle: string
-}
-
 type AppState = {
+  // === LEGACY (backward compatibility) ===
   streamingContent?: ThreadMessage
+  tokenSpeed?: TokenSpeed
+  queuedMessage: string | null
+
+  // === EXISTING GLOBAL STATE ===
   loadingModel?: boolean
   tools: MCPTool[]
   serverStatus: 'running' | 'stopped' | 'pending'
   abortControllers: Record<string, AbortController>
-  tokenSpeed?: TokenSpeed
   currentToolCall?: ChatCompletionMessageToolCall
   showOutOfContextDialog?: boolean
-  errorMessage?: AppErrorMessage
   cancelToolCall?: () => void
-  setServerStatus: (value: 'running' | 'stopped' | 'pending') => void
+
+  // === NEW PER-THREAD STATE ===
+  promptsByThread: Record<string, string>
+  queuedMessagesByThread: Record<string, string[]>
+  errorsByThread: Record<string, string | ErrorObject | undefined>
+
+  // === CONCURRENT PROCESSING STATE ===
+  processingThreads: Record<string, boolean>
+  maxConcurrency: number
+  fallbackMode: 'single-thread' | 'estimated' | 'detected' | 'user-configured'
+  parallelProcessingEnabled: boolean
+
+  // === LEGACY METHODS (unchanged for backward compatibility) ===
   updateStreamingContent: (content: ThreadMessage | undefined) => void
+  updateTokenSpeed: (message: ThreadMessage, increment?: number) => void
+  resetTokenSpeed: () => void
+  setQueuedMessage: (message: string | null) => void
+
+  // === EXISTING GLOBAL METHODS ===
+  setServerStatus: (value: 'running' | 'stopped' | 'pending') => void
   updateCurrentToolCall: (
     toolCall: ChatCompletionMessageToolCall | undefined
   ) => void
@@ -33,22 +48,63 @@ type AppState = {
   resetTokenSpeed: () => void
   setOutOfContextDialog: (show: boolean) => void
   setCancelToolCall: (cancel: (() => void) | undefined) => void
-  setErrorMessage: (error: AppErrorMessage | undefined) => void
+
+  // === NEW THREAD-AWARE METHODS ===
+  setThreadPrompt: (threadId: string, prompt: string) => void
+  getThreadPrompt: (threadId: string) => string
+  clearThreadPrompt: (threadId: string) => void
+  addToThreadQueue: (threadId: string, message: string) => void
+  removeFromThreadQueue: (threadId: string) => string | undefined
+  clearThreadQueue: (threadId: string) => void
+  getThreadQueueLength: (threadId: string) => number
+  setThreadError: (
+    threadId: string,
+    error?: string | ErrorObject | null
+  ) => void
+  clearThread: (threadId: string) => void
+  clearAllThreads: () => void
+  getAllActiveThreads: () => string[]
+
+  // === CONCURRENT PROCESSING METHODS ===
+  setThreadProcessing: (threadId: string, isProcessing: boolean) => void
+  setMaxConcurrency: (count: number) => void
+  setFallbackMode: (
+    mode: 'single-thread' | 'estimated' | 'detected' | 'user-configured'
+  ) => void
+  setParallelProcessingEnabled: (enabled: boolean) => void
+  getActiveProcessingCount: () => number
+  isThreadProcessing: (threadId: string) => boolean
+  getAvailableSlots: () => number
 }
 
-export const useAppState = create<AppState>()((set) => ({
+export const useAppState = create<AppState>()((set, get) => ({
+  // === LEGACY (backward compatibility) ===
   streamingContent: undefined,
+  tokenSpeed: undefined,
+  queuedMessage: null,
+
+  // === EXISTING GLOBAL STATE ===
   loadingModel: false,
   tools: [],
   serverStatus: 'stopped',
   abortControllers: {},
-  tokenSpeed: undefined,
   currentToolCall: undefined,
+  showOutOfContextDialog: undefined,
   cancelToolCall: undefined,
+
+  // === NEW PER-THREAD STATE ===
+  promptsByThread: {},
+  queuedMessagesByThread: {},
+  errorsByThread: {},
+
+  // === CONCURRENT PROCESSING STATE ===
+  processingThreads: {},
+  maxConcurrency: 1,
+  fallbackMode: 'single-thread',
+  parallelProcessingEnabled: false,
   updateStreamingContent: (content: ThreadMessage | undefined) => {
     const assistants = useAssistant.getState().assistants
     const currentAssistant = useAssistant.getState().currentAssistant
-
     const selectedAssistant =
       assistants.find((a) => a.id === currentAssistant.id) || assistants[0]
 
@@ -87,9 +143,8 @@ export const useAppState = create<AppState>()((set) => ({
   },
   updateTokenSpeed: (message, increment = 1) =>
     set((state) => {
-      const currentTimestamp = new Date().getTime() // Get current time in milliseconds
+      const currentTimestamp = new Date().getTime()
       if (!state.tokenSpeed) {
-        // If this is the first update, just set the lastTimestamp and return
         return {
           tokenSpeed: {
             lastTimestamp: currentTimestamp,
@@ -104,7 +159,8 @@ export const useAppState = create<AppState>()((set) => ({
         (currentTimestamp - state.tokenSpeed.lastTimestamp) / 1000 // Time difference in seconds
       const totalTokenCount = state.tokenSpeed.tokenCount + increment
       const averageTokenSpeed =
-        totalTokenCount / (timeDiffInSeconds > 0 ? timeDiffInSeconds : 1) // Calculate average token speed
+        totalTokenCount / (timeDiffInSeconds > 0 ? timeDiffInSeconds : 1)
+
       return {
         tokenSpeed: {
           ...state.tokenSpeed,
@@ -128,9 +184,172 @@ export const useAppState = create<AppState>()((set) => ({
       cancelToolCall: cancel,
     }))
   },
-  setErrorMessage: (error) => {
-    set(() => ({
-      errorMessage: error,
+  setQueuedMessage: (message) => {
+    set({ queuedMessage: message })
+  },
+
+  // === NEW THREAD-AWARE METHODS ===
+  setThreadPrompt: (threadId: string, prompt: string) => {
+    set((state) => ({
+      promptsByThread: {
+        ...state.promptsByThread,
+        [threadId]: prompt,
+      },
+    }))
+  },
+
+  getThreadPrompt: (threadId: string) => {
+    const state = get()
+    return state.promptsByThread[threadId] || ''
+  },
+
+  clearThreadPrompt: (threadId: string) => {
+    set((state) => ({
+      promptsByThread: {
+        ...state.promptsByThread,
+        [threadId]: '',
+      },
+    }))
+  },
+
+  addToThreadQueue: (threadId: string, message: string) => {
+    set((state) => ({
+      queuedMessagesByThread: {
+        ...state.queuedMessagesByThread,
+        [threadId]: [
+          ...(state.queuedMessagesByThread[threadId] || []),
+          message,
+        ],
+      },
+    }))
+  },
+
+  removeFromThreadQueue: (threadId: string) => {
+    let removedMessage: string | undefined
+    set((state) => {
+      const currentQueue = state.queuedMessagesByThread[threadId] || []
+      removedMessage = currentQueue[0]
+      return {
+        queuedMessagesByThread: {
+          ...state.queuedMessagesByThread,
+          [threadId]: currentQueue.slice(1),
+        },
+      }
+    })
+    return removedMessage
+  },
+
+  clearThreadQueue: (threadId: string) => {
+    set((state) => ({
+      queuedMessagesByThread: {
+        ...state.queuedMessagesByThread,
+        [threadId]: [],
+      },
     }))
   },
+
+  getThreadQueueLength: (threadId: string) => {
+    const state = get()
+    return state.queuedMessagesByThread[threadId]?.length || 0
+  },
+
+  setThreadError: (threadId: string, error?: string | ErrorObject | null) => {
+    set((state) => ({
+      errorsByThread: {
+        ...state.errorsByThread,
+        [threadId]: error || undefined,
+      },
+    }))
+  },
+
+  clearThread: (threadId: string) => {
+    set((state) => {
+      const newPrompts = { ...state.promptsByThread }
+      const newQueuedMessages = { ...state.queuedMessagesByThread }
+      const newErrors = { ...state.errorsByThread }
+      const newAbortControllers = { ...state.abortControllers }
+      const newProcessingThreads = { ...state.processingThreads }
+
+      delete newPrompts[threadId]
+      delete newQueuedMessages[threadId]
+      delete newErrors[threadId]
+      delete newAbortControllers[threadId]
+      delete newProcessingThreads[threadId]
+
+      return {
+        promptsByThread: newPrompts,
+        queuedMessagesByThread: newQueuedMessages,
+        errorsByThread: newErrors,
+        abortControllers: newAbortControllers,
+        processingThreads: newProcessingThreads,
+      }
+    })
+  },
+
+  clearAllThreads: () => {
+    set({
+      promptsByThread: {},
+      queuedMessagesByThread: {},
+      errorsByThread: {},
+      abortControllers: {},
+      processingThreads: {},
+    })
+  },
+
+  getAllActiveThreads: () => {
+    const state = useAppState.getState()
+    const activeThreads = new Set<string>()
+
+    // Collect thread IDs that have any active state
+    Object.keys(state.promptsByThread).forEach((id) => {
+      if (state.promptsByThread[id]) activeThreads.add(id)
+    })
+    Object.keys(state.queuedMessagesByThread).forEach((id) => {
+      if (state.queuedMessagesByThread[id]) activeThreads.add(id)
+    })
+    Object.keys(state.errorsByThread).forEach((id) => {
+      if (state.errorsByThread[id]) activeThreads.add(id)
+    })
+
+    return Array.from(activeThreads)
+  },
+
+  // === CONCURRENT PROCESSING METHODS ===
+  setThreadProcessing: (threadId: string, isProcessing: boolean) => {
+    set((state) => ({
+      processingThreads: {
+        ...state.processingThreads,
+        [threadId]: isProcessing,
+      },
+    }))
+  },
+
+  setMaxConcurrency: (count: number) => {
+    set({ maxConcurrency: Math.max(1, count) }) // Ensure minimum of 1
+  },
+
+  setFallbackMode: (
+    mode: 'single-thread' | 'estimated' | 'detected' | 'user-configured'
+  ) => {
+    set({ fallbackMode: mode })
+  },
+
+  setParallelProcessingEnabled: (enabled: boolean) => {
+    set({ parallelProcessingEnabled: enabled })
+  },
+
+  getActiveProcessingCount: () => {
+    const state = get()
+    return Object.values(state.processingThreads).filter(Boolean).length
+  },
+
+  isThreadProcessing: (threadId: string) => {
+    const state = get()
+    return Boolean(state.processingThreads[threadId])
+  },
+
+  getAvailableSlots: () => {
+    const state = get()
+    return state.maxConcurrency - state.getActiveProcessingCount()
+  },
 }))
diff --git a/web-app/src/hooks/useChat.ts b/web-app/src/hooks/useChat.ts
index 029dfe7228..eb04fc536a 100644
--- a/web-app/src/hooks/useChat.ts
+++ b/web-app/src/hooks/useChat.ts
@@ -33,7 +33,7 @@ import {
 } from '@/utils/reasoning'
 
 export const useChat = () => {
-  const { prompt, setPrompt } = usePrompt()
+  const { prompt } = usePrompt()
   const {
     tools,
     updateTokenSpeed,
@@ -59,6 +59,7 @@ export const useChat = () => {
     getCurrentThread: retrieveThread,
     createThread,
     updateThreadTimestamp,
+    getThreadById,
   } = useThreads()
   const { getMessages, addMessage } = useMessages()
   const { setModelLoadError } = useModelLoad()
@@ -108,7 +109,10 @@ export const useChat = () => {
       await serviceHub.models().stopAllModels()
       await new Promise((resolve) => setTimeout(resolve, 1000))
       updateLoadingModel(true)
-      await serviceHub.models().startModel(provider, modelId).catch(console.error)
+      await serviceHub
+        .models()
+        .startModel(provider, modelId)
+        .catch(console.error)
       updateLoadingModel(false)
       await new Promise((resolve) => setTimeout(resolve, 1000))
     },
@@ -188,7 +192,9 @@ export const useChat = () => {
         settings: newSettings,
       }
 
-      await serviceHub.providers().updateSettings(providerName, updateObj.settings ?? [])
+      await serviceHub
+        .providers()
+        .updateSettings(providerName, updateObj.settings ?? [])
       updateProvider(providerName, {
         ...provider,
         ...updateObj,
@@ -199,35 +205,46 @@ export const useChat = () => {
     },
     [updateProvider, getProviderByName, restartModel, serviceHub]
   )
-
   const sendMessage = useCallback(
     async (
       message: string,
       troubleshooting = true,
-      attachments?: Array<{
-        name: string
-        type: string
-        size: number
-        base64: string
-        dataUrl: string
-      }>
+      options?: {
+        attachments?: Array<{
+          name: string
+          type: string
+          size: number
+          base64: string
+          dataUrl: string
+        }>
+        explicitThreadId?: string
+      }
     ) => {
-      const activeThread = await getCurrentThread()
+      // Use explicitThreadId if provided, otherwise fall back to current thread
+      const activeThread = options?.explicitThreadId
+        ? await getThreadById(options.explicitThreadId)
+        : await getCurrentThread()
 
       resetTokenSpeed()
       let activeProvider = currentProviderId
         ? getProviderByName(currentProviderId)
         : provider
       if (!activeThread || !activeProvider) return
+
+      // Processing state is managed by scheduler
+
       const messages = getMessages(activeThread.id)
       const abortController = new AbortController()
       setAbortController(activeThread.id, abortController)
       updateStreamingContent(emptyThreadContent)
       // Do not add new message on retry
       if (troubleshooting)
-        addMessage(newUserThreadContent(activeThread.id, message, attachments))
+        addMessage(newUserThreadContent(activeThread.id, message, options?.attachments))
       updateThreadTimestamp(activeThread.id)
-      setPrompt('')
+
+      // Clear thread-specific prompt (only affects the processing thread)
+      const { clearThreadPrompt } = useAppState.getState()
+      clearThreadPrompt(activeThread.id)
       try {
         if (selectedModel?.id) {
           updateLoadingModel(true)
@@ -239,7 +256,7 @@ export const useChat = () => {
           messages,
           renderInstructions(currentAssistant?.instructions)
         )
-        if (troubleshooting) builder.addUserMessage(message, attachments)
+        if (troubleshooting) builder.addUserMessage(message, options?.attachments)
 
         let isCompleted = false
 
@@ -476,7 +493,9 @@ export const useChat = () => {
             activeThread.model?.id &&
             provider?.provider === 'llamacpp'
           ) {
-            await serviceHub.models().stopModel(activeThread.model.id, 'llamacpp')
+            await serviceHub
+              .models()
+              .stopModel(activeThread.model.id, 'llamacpp')
             throw new Error('No response received from the model')
           }
 
@@ -523,6 +542,9 @@ export const useChat = () => {
       } finally {
         updateLoadingModel(false)
         updateStreamingContent(undefined)
+
+        // Processing state managed by scheduler
+        // Scheduler will handle processing the next queued message
       }
     },
     [
@@ -536,7 +558,6 @@ export const useChat = () => {
       updateStreamingContent,
       addMessage,
       updateThreadTimestamp,
-      setPrompt,
       selectedModel,
       currentAssistant,
       tools,
@@ -551,6 +572,7 @@ export const useChat = () => {
       toggleOnContextShifting,
       setModelLoadError,
       serviceHub,
+      getThreadById,
     ]
   )
 
diff --git a/web-app/src/hooks/useInferenceScheduler.ts b/web-app/src/hooks/useInferenceScheduler.ts
new file mode 100644
index 0000000000..04d0b2f343
--- /dev/null
+++ b/web-app/src/hooks/useInferenceScheduler.ts
@@ -0,0 +1,200 @@
+import { useCallback, useEffect, useRef } from 'react'
+import { useAppState } from './useAppState'
+import { useChat } from './useChat'
+
+/**
+ * Inference Scheduler Hook
+ *
+ * Coordinates thread processing based on available slots and queue state.
+ * Currently implements single-thread fallback mode with infrastructure
+ * ready for future parallel processing.
+ */
+export const useInferenceScheduler = () => {
+  // Zustand store access (direct destructuring from the store)
+  const queuedMessagesByThread = useAppState(
+    (state) => state.queuedMessagesByThread
+  )
+  const processingThreads = useAppState((state) => state.processingThreads)
+  const maxConcurrency = useAppState((state) => state.maxConcurrency)
+  const parallelProcessingEnabled = useAppState(
+    (state) => state.parallelProcessingEnabled
+  )
+  const fallbackMode = useAppState((state) => state.fallbackMode)
+  const getActiveProcessingCount = useAppState(
+    (state) => state.getActiveProcessingCount
+  )
+  const getAvailableSlots = useAppState((state) => state.getAvailableSlots)
+  const isThreadProcessing = useAppState((state) => state.isThreadProcessing)
+  const removeFromThreadQueue = useAppState(
+    (state) => state.removeFromThreadQueue
+  )
+  const setThreadProcessing = useAppState(
+    (state) => state.setThreadProcessing
+  )
+
+  const { sendMessage } = useChat()
+  const schedulerRunning = useRef(false)
+
+  /**
+   * Main scheduling logic
+   * Determines which threads should start processing based on:
+   * - Available processing slots
+   * - Queued messages per thread
+   * - Current processing state
+   */
+  const schedule = useCallback(() => {
+    // Prevent recursive scheduling
+    if (schedulerRunning.current) {
+      return
+    }
+
+    schedulerRunning.current = true
+
+    try {
+      const availableSlots = getAvailableSlots()
+
+      if (availableSlots <= 0) {
+        return // No slots available
+      }
+
+      // Get threads that have queued messages and aren't currently processing
+      const runnableThreads = Object.entries(queuedMessagesByThread)
+        .filter(([threadId, queue]) => {
+          return queue.length > 0 && !isThreadProcessing(threadId)
+        })
+        .map(([threadId]) => threadId)
+
+      if (runnableThreads.length === 0) {
+        return // No threads ready to run
+      }
+
+      // MVP: Always single-thread mode for now
+      // In future: determine threads based on parallel processing capabilities
+      const threadsToStart =
+        parallelProcessingEnabled && maxConcurrency > 1
+          ? Math.min(availableSlots, runnableThreads.length)
+          : Math.min(1, runnableThreads.length) // Single-thread fallback mode
+
+      // Start inference for selected threads
+      for (let i = 0; i < threadsToStart; i++) {
+        const threadId = runnableThreads[i]
+        startThreadInference(threadId)
+      }
+    } finally {
+      schedulerRunning.current = false
+    }
+  }, [
+    queuedMessagesByThread,
+    processingThreads,
+    maxConcurrency,
+    parallelProcessingEnabled,
+    getAvailableSlots,
+    isThreadProcessing,
+  ])
+
+  /**
+   * Start inference for a specific thread
+   * Dequeues the next message and initiates processing
+   */
+  const startThreadInference = useCallback(
+    (threadId: string) => {
+      const queue = queuedMessagesByThread[threadId]
+      if (!queue || queue.length === 0) {
+        console.warn(`No messages queued for thread ${threadId}`)
+        return
+      }
+
+      if (isThreadProcessing(threadId)) {
+        console.warn(`Thread ${threadId} is already processing`)
+        return
+      }
+
+      // *** SET LOCK SYNCHRONOUSLY to prevent race conditions ***
+      setThreadProcessing(threadId, true)
+
+      const nextMessage = removeFromThreadQueue(threadId)
+      if (!nextMessage) {
+        console.warn(`Failed to dequeue message for thread ${threadId}`)
+        setThreadProcessing(threadId, false) // Release lock if no message
+        return
+      }
+
+      // Start processing with lock already acquired
+      ;(async () => {
+        try {
+          await sendMessage(nextMessage, true, { explicitThreadId: threadId })
+        } catch (error) {
+          console.error(`Error processing message in thread ${threadId}:`, error)
+        } finally {
+          // *** ALWAYS RELEASE LOCK ***
+          setThreadProcessing(threadId, false)
+        }
+      })()
+    },
+    [
+      queuedMessagesByThread,
+      isThreadProcessing,
+      removeFromThreadQueue,
+      sendMessage,
+    ]
+  )
+
+  /**
+   * Get scheduling status for debugging/monitoring
+   */
+  const getSchedulingStatus = useCallback(() => {
+    return {
+      availableSlots: getAvailableSlots(),
+      activeProcessingCount: getActiveProcessingCount(),
+      maxConcurrency,
+      parallelProcessingEnabled,
+      fallbackMode,
+      queuedThreads: Object.keys(queuedMessagesByThread).filter(
+        (threadId) => queuedMessagesByThread[threadId].length > 0
+      ),
+      processingThreads: Object.keys(processingThreads).filter(
+        (threadId) => processingThreads[threadId]
+      ),
+    }
+  }, [
+    getAvailableSlots,
+    getActiveProcessingCount,
+    maxConcurrency,
+    parallelProcessingEnabled,
+    fallbackMode,
+    queuedMessagesByThread,
+    processingThreads,
+  ])
+
+  return {
+    schedule,
+    startThreadInference,
+    getSchedulingStatus,
+  }
+}
+
+/**
+ * Auto-scheduling hook
+ * Automatically triggers scheduling when queue state changes
+ */
+export const useAutoScheduler = () => {
+  const { schedule } = useInferenceScheduler()
+  
+  // Access state for triggering effects
+  const queuedMessagesByThread = useAppState(
+    (state) => state.queuedMessagesByThread
+  )
+  const processingThreads = useAppState((state) => state.processingThreads)
+  const maxConcurrency = useAppState((state) => state.maxConcurrency)
+
+  // Trigger scheduling when queue or processing state changes
+  useEffect(() => {
+    // Schedule when:
+    // 1. New messages are added to any queue
+    // 2. Processing state changes (threads finish processing)
+    // 3. Concurrency settings change
+    schedule()
+  }, [queuedMessagesByThread, processingThreads, maxConcurrency, schedule])
+
+  return { schedule }
+}
diff --git a/web-app/src/hooks/useThreadState.ts b/web-app/src/hooks/useThreadState.ts
new file mode 100644
index 0000000000..39c7447bcb
--- /dev/null
+++ b/web-app/src/hooks/useThreadState.ts
@@ -0,0 +1,43 @@
+import { useAppState } from './useAppState'
+
+/**
+ * CONVENIENCE HOOKS FOR THREAD-SPECIFIC STATE ACCESS
+ *
+ * These hooks provide clean, optimized access to per-thread state
+ * without requiring components to manage thread ID prop drilling.
+ */
+
+/**
+ * Get error state for a specific thread
+ * @param threadId The thread ID to get error for
+ * @returns Error string/object or undefined if no error
+ */
+export const useThreadError = (threadId: string) =>
+  useAppState((state) => state.errorsByThread[threadId])
+
+// Stable empty array to prevent infinite loops
+const EMPTY_QUEUE: string[] = []
+
+/**
+ * Get queued messages for a specific thread
+ * @param threadId The thread ID to get queued messages for
+ * @returns Array of queued messages or empty array if none queued
+ */
+export const useQueuedMessages = (threadId: string) =>
+  useAppState((state) => state.queuedMessagesByThread[threadId] || EMPTY_QUEUE)
+
+/**
+ * Get queue length for a specific thread
+ * @param threadId The thread ID to check queue length for
+ * @returns Number of queued messages
+ */
+export const useThreadQueueLength = (threadId: string) =>
+  useAppState((state) => state.queuedMessagesByThread[threadId]?.length || 0)
+
+
+/**
+ * Get list of all threads with active state
+ * @returns Array of thread IDs that have active streaming, queued messages, or errors
+ */
+export const useActiveThreads = () =>
+  useAppState((state) => state.getAllActiveThreads())
diff --git a/web-app/src/routes/__root.tsx b/web-app/src/routes/__root.tsx
index 03435933da..74acff3ad4 100644
--- a/web-app/src/routes/__root.tsx
+++ b/web-app/src/routes/__root.tsx
@@ -15,6 +15,7 @@ import { useAnalytic } from '@/hooks/useAnalytic'
 import { PromptAnalytic } from '@/containers/analytics/PromptAnalytic'
 import { AnalyticProvider } from '@/providers/AnalyticProvider'
 import { useLeftPanel } from '@/hooks/useLeftPanel'
+import { useAutoScheduler } from '@/hooks/useInferenceScheduler'
 import { cn } from '@/lib/utils'
 import ToolApproval from '@/containers/dialogs/ToolApproval'
 import { TranslationProvider } from '@/i18n/TranslationContext'
@@ -47,6 +48,9 @@ const AppLayout = () => {
   } = useLeftPanel()
   const isSmallScreen = useSmallScreen()
 
+  // Initialize auto-scheduler for inference coordination
+  useAutoScheduler()
+
   // Minimum width threshold for auto-close (10% of screen width)
   const MIN_PANEL_WIDTH_THRESHOLD = 14
 
diff --git a/web-app/src/test/simultaneous-inference-utils.ts b/web-app/src/test/simultaneous-inference-utils.ts
new file mode 100644
index 0000000000..e48c000e4f
--- /dev/null
+++ b/web-app/src/test/simultaneous-inference-utils.ts
@@ -0,0 +1,377 @@
+/**
+ * MVP Test Utilities for Simultaneous Inference Testing
+ * Provides helper functions, mocks, and utilities for testing concurrent processing
+ */
+
+import { vi, type MockedFunction, expect } from 'vitest'
+import { waitFor } from '@testing-library/react'
+
+// Test data types
+export interface MockThread {
+  id: string
+  messages: MockMessage[]
+  model: string
+  status: 'idle' | 'processing' | 'error'
+}
+
+export interface MockMessage {
+  id: string
+  threadId: string
+  content: string
+  timestamp: number
+  type: 'user' | 'assistant'
+  status?: 'pending' | 'processing' | 'complete' | 'error'
+}
+
+export interface MockQueueItem {
+  id: string
+  threadId: string
+  messageId: string
+  priority: number
+  timestamp: number
+  retryCount?: number
+}
+
+// Mock data generators
+export const createMockThread = (overrides: Partial<MockThread> = {}): MockThread => ({
+  id: `thread-${Math.random().toString(36).substr(2, 9)}`,
+  messages: [],
+  model: 'test-model',
+  status: 'idle',
+  ...overrides,
+})
+
+export const createMockMessage = (
+  threadId: string,
+  overrides: Partial<MockMessage> = {}
+): MockMessage => ({
+  id: `msg-${Math.random().toString(36).substr(2, 9)}`,
+  threadId,
+  content: 'Test message content',
+  timestamp: Date.now(),
+  type: 'user',
+  status: 'pending',
+  ...overrides,
+})
+
+export const createMockQueueItem = (
+  threadId: string,
+  messageId: string,
+  overrides: Partial<MockQueueItem> = {}
+): MockQueueItem => ({
+  id: `queue-${Math.random().toString(36).substr(2, 9)}`,
+  threadId,
+  messageId,
+  priority: 1,
+  timestamp: Date.now(),
+  retryCount: 0,
+  ...overrides,
+})
+
+// Multi-thread test scenario generators
+export const createMultiThreadScenario = (threadCount: number): MockThread[] => {
+  return Array.from({ length: threadCount }, (_, index) => 
+    createMockThread({
+      id: `thread-${index}`,
+      model: index % 2 === 0 ? 'model-a' : 'model-b',
+    })
+  )
+}
+
+export const createConcurrentMessageBatch = (
+  threads: MockThread[],
+  messagesPerThread: number = 3
+): MockMessage[] => {
+  const messages: MockMessage[] = []
+  
+  threads.forEach((thread, threadIndex) => {
+    for (let i = 0; i < messagesPerThread; i++) {
+      messages.push(createMockMessage(thread.id, {
+        content: `Message ${i + 1} for thread ${threadIndex}`,
+        timestamp: Date.now() + threadIndex * 100 + i * 50,
+      }))
+    }
+  })
+  
+  return messages
+}
+
+// Mock implementations for sendMessage and scheduler
+export interface MockSendMessageResult {
+  success: boolean
+  messageId: string
+  threadId: string
+  processingTime?: number
+  error?: string
+}
+
+export const createMockSendMessage = (
+  config: {
+    delay?: number
+    failureRate?: number
+    processingTime?: number
+  } = {}
+): MockedFunction<(...args: any[]) => Promise<MockSendMessageResult>> => {
+  const { delay = 100, failureRate = 0, processingTime = 200 } = config
+
+  return vi.fn().mockImplementation(async (threadId: string, _content: string) => {
+    if (delay > 0) {
+      await new Promise(resolve => setTimeout(resolve, delay))
+    }
+
+    if (Math.random() < failureRate) {
+      return {
+        success: false,
+        messageId: '',
+        threadId,
+        error: 'Mock sendMessage failure',
+      }
+    }
+
+    const messageId = `msg-${Math.random().toString(36).substr(2, 9)}`
+    
+    return {
+      success: true,
+      messageId,
+      threadId,
+      processingTime,
+    }
+  })
+}
+
+export interface MockSchedulerConfig {
+  maxConcurrent?: number
+  processingDelay?: number
+  queueDelay?: number
+}
+
+export class MockScheduler {
+  private queue: MockQueueItem[] = []
+  private processing = new Set<string>()
+  private maxConcurrent: number
+  private processingDelay: number
+  private queueDelay: number
+  
+  constructor(config: MockSchedulerConfig = {}) {
+    this.maxConcurrent = config.maxConcurrent ?? 2
+    this.processingDelay = config.processingDelay ?? 200
+    this.queueDelay = config.queueDelay ?? 50
+  }
+
+  enqueue = vi.fn().mockImplementation(async (item: MockQueueItem) => {
+    this.queue.push(item)
+    this.processQueue()
+  })
+
+  private processQueue = async () => {
+    if (this.processing.size >= this.maxConcurrent) {
+      return
+    }
+
+    const nextItem = this.queue
+      .filter(item => !this.processing.has(item.id))
+      .sort((a, b) => b.priority - a.priority || a.timestamp - b.timestamp)[0]
+
+    if (!nextItem) {
+      return
+    }
+
+    this.processing.add(nextItem.id)
+    this.queue = this.queue.filter(item => item.id !== nextItem.id)
+
+    // Simulate processing delay
+    setTimeout(async () => {
+      await new Promise(resolve => setTimeout(resolve, this.processingDelay))
+      this.processing.delete(nextItem.id)
+      
+      // Continue processing queue
+      this.processQueue()
+    }, this.queueDelay)
+  }
+
+  getQueueStatus = vi.fn().mockImplementation(() => ({
+    queueLength: this.queue.length,
+    processing: Array.from(this.processing),
+    maxConcurrent: this.maxConcurrent,
+  }))
+
+  clearQueue = vi.fn().mockImplementation(() => {
+    this.queue = []
+    this.processing.clear()
+  })
+}
+
+// Timing utilities for performance measurement
+export class PerformanceTimer {
+  private startTime: number = 0
+  private endTime: number = 0
+  private intervals: { name: string; time: number }[] = []
+
+  start() {
+    this.startTime = performance.now()
+    this.intervals = []
+  }
+
+  mark(name: string) {
+    this.intervals.push({
+      name,
+      time: performance.now() - this.startTime,
+    })
+  }
+
+  stop() {
+    this.endTime = performance.now()
+    return this.getDuration()
+  }
+
+  getDuration() {
+    return this.endTime - this.startTime
+  }
+
+  getIntervals() {
+    return [...this.intervals]
+  }
+
+  reset() {
+    this.startTime = 0
+    this.endTime = 0
+    this.intervals = []
+  }
+}
+
+// Test assertion helpers
+export const waitForQueueToProcess = async (
+  getQueueLength: () => number,
+  timeout: number = 5000
+) => {
+  await waitFor(
+    () => {
+      expect(getQueueLength()).toBe(0)
+    },
+    { timeout }
+  )
+}
+
+export const waitForConcurrentOperations = async (
+  operations: Promise<any>[],
+  _timeout: number = 10000
+) => {
+  const timer = new PerformanceTimer()
+  timer.start()
+
+  const results = await Promise.allSettled(operations)
+  const duration = timer.stop()
+
+  return {
+    results,
+    duration,
+    successful: results.filter(r => r.status === 'fulfilled').length,
+    failed: results.filter(r => r.status === 'rejected').length,
+  }
+}
+
+// Memory leak detection helpers
+export const createMemoryMonitor = () => {
+  // Type assertion for performance.memory which is not in all environments
+  const perfMemory = (performance as any).memory
+  const initialMemory = perfMemory ? {
+    used: perfMemory.usedJSHeapSize,
+    total: perfMemory.totalJSHeapSize,
+  } : null
+
+  return {
+    getMemoryDelta: () => {
+      const currentMemory = (performance as any).memory
+      if (!currentMemory || !initialMemory) {
+        return null
+      }
+
+      return {
+        usedDelta: currentMemory.usedJSHeapSize - initialMemory.used,
+        totalDelta: currentMemory.totalJSHeapSize - initialMemory.total,
+      }
+    },
+    getCurrentMemory: () => {
+      const currentMemory = (performance as any).memory
+      return currentMemory ? {
+        used: currentMemory.usedJSHeapSize,
+        total: currentMemory.totalJSHeapSize,
+      } : null
+    },
+  }
+}
+
+// State update efficiency helpers
+export const createStateUpdateTracker = () => {
+  const updates: { timestamp: number; componentName?: string }[] = []
+
+  return {
+    track: (componentName?: string) => {
+      updates.push({
+        timestamp: performance.now(),
+        componentName,
+      })
+    },
+    getUpdateCount: () => updates.length,
+    getUpdateRate: (timeWindow: number = 1000) => {
+      const cutoff = performance.now() - timeWindow
+      const recentUpdates = updates.filter(u => u.timestamp > cutoff)
+      return recentUpdates.length / (timeWindow / 1000)
+    },
+    reset: () => {
+      updates.length = 0
+    },
+    getUpdates: () => [...updates],
+  }
+}
+
+// Test timeout utilities
+export const withTimeout = async <T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  errorMessage?: string
+): Promise<T> => {
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => {
+      reject(new Error(errorMessage || `Operation timed out after ${timeoutMs}ms`))
+    }, timeoutMs)
+  })
+
+  return Promise.race([promise, timeoutPromise])
+}
+
+// Batch operation utilities
+export const createBatchOperationTester = (batchSize: number = 10) => {
+  return {
+    async runInBatches<T, R>(
+      items: T[],
+      operation: (item: T, index: number) => Promise<R>,
+      options: { concurrency?: number; delay?: number } = {}
+    ) {
+      const { concurrency: _concurrency = 3, delay = 100 } = options
+      const results: R[] = []
+      const batches = []
+
+      // Create batches
+      for (let i = 0; i < items.length; i += batchSize) {
+        batches.push(items.slice(i, i + batchSize))
+      }
+
+      // Process batches with controlled concurrency
+      for (const batch of batches) {
+        const batchPromises = batch.map((item, index) => 
+          operation(item, index)
+        )
+
+        const batchResults = await Promise.all(batchPromises)
+        results.push(...batchResults)
+
+        if (delay > 0 && batches.indexOf(batch) < batches.length - 1) {
+          await new Promise(resolve => setTimeout(resolve, delay))
+        }
+      }
+
+      return results
+    },
+  }
+}