@pheem49/mint 1.16.0 → 1.17.0

package/src/renderer/shared/conversation/lifecycle.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { createConversationLifecycle, type ConversationTransport, type ConversationEffects, type PendingApproval } from './lifecycle'
+import { createConversationLifecycle, conversationPollIntervalsMs, type ConversationTransport, type ConversationEffects, type PendingApproval } from './lifecycle'
 import type { AgentProgress, ChatResponse, ConversationChanges, ConversationSnapshot, InteractionMemory, ChatSession } from '../types'
 
 function deferred<T>() {
@@ -66,6 +66,32 @@ describe('Conversation lifecycle through the renderer interface', () => {
     results[1].resolve(reply); await retried
   })
 
+  it('fingerprints attachments for retry deduplication without calling JSON.stringify on attachment payloads', async () => {
+    const received: any[] = []
+    const results = [deferred<ChatResponse>(), deferred<ChatResponse>(), deferred<ChatResponse>()]
+    const { lifecycle } = setup({ streamChatMessage: (...args) => {
+      received.push(args[15])
+      return results[received.length - 1].promise
+    } })
+    const stringifySpy = vi.spyOn(JSON, 'stringify')
+    const img1 = { name: 'photo.png', dataUri: 'data:image/png;base64,AAAA1111' }
+    const img2 = { name: 'photo.png', dataUri: 'data:image/png;base64,BBBB2222' }
+
+    const attempt1 = lifecycle.sendPrompt('Analyze', { imageAttachments: [img1] })
+    results[0].reject(new Error('Network error')); await attempt1
+
+    const attempt2 = lifecycle.sendPrompt('Analyze', { imageAttachments: [img1] })
+    results[1].reject(new Error('Network error')); await attempt2
+
+    const attempt3 = lifecycle.sendPrompt('Analyze', { imageAttachments: [img2] })
+    results[2].resolve(reply); await attempt3
+
+    expect(stringifySpy).not.toHaveBeenCalled()
+    expect(received[0]?.requestId).toBeTruthy()
+    expect(received[1]?.requestId).toBe(received[0]?.requestId)
+    expect(received[2]?.requestId).not.toBe(received[0]?.requestId)
+  })
+
   it('rejects old A snapshots after A → B → A, including an old failure', async () => {
     const reads = [deferred<ConversationSnapshot>(), deferred<ConversationSnapshot>(), deferred<ConversationSnapshot>()]
     let next = 0
@@ -360,3 +386,139 @@ it('can submit from a LAN HTTP browser without crypto.randomUUID', async()=>{
  expect(lifecycle.getSnapshot().sending).toBe(false)
  vi.unstubAllGlobals()
 })
+
+it('exports adaptive conversation polling intervals for active and idle runs', () => {
+  expect(conversationPollIntervalsMs(true)).toEqual({ historyMs: 1500, sessionsMs: 5000 })
+  expect(conversationPollIntervalsMs(false)).toEqual({ historyMs: 5000, sessionsMs: 15000 })
+})
+
+it('adapts polling intervals between idle and active runs in watch', async () => {
+  vi.useFakeTimers()
+  let historySyncCount = 0
+  let sessionRefreshCount = 0
+  const { lifecycle, streams } = setup({
+    getConversationChanges: async () => { historySyncCount++; return { changes: [], cursor: 0, hasMore: false } },
+    listChatSessions: async () => { sessionRefreshCount++; return [] },
+  })
+  await lifecycle.refreshHistory()
+
+  const browser = {
+    window: { addEventListener: vi.fn(), removeEventListener: vi.fn(), setInterval, clearInterval },
+    document: { addEventListener: vi.fn(), removeEventListener: vi.fn(), visibilityState: 'visible' },
+  } as unknown as import('./lifecycle').ConversationBrowser
+
+  const stop = lifecycle.watch(browser, true)
+  // Initial synchronous invocation at attach
+  expect(historySyncCount).toBe(1)
+  expect(sessionRefreshCount).toBe(0)
+
+  // Idle state: history syncs every 5s, sessions every 15s
+  await vi.advanceTimersByTimeAsync(4900)
+  expect(historySyncCount).toBe(1)
+  await vi.advanceTimersByTimeAsync(200)
+  expect(historySyncCount).toBe(2)
+
+  await vi.advanceTimersByTimeAsync(9700)
+  expect(sessionRefreshCount).toBe(0)
+  await vi.advanceTimersByTimeAsync(300)
+  expect(sessionRefreshCount).toBe(1)
+
+  // Start an active prompt -> switches to active polling (1.5s history, 5s sessions)
+  const run = lifecycle.sendPrompt('test active run')
+  const initialHistory = historySyncCount
+  await vi.advanceTimersByTimeAsync(1500)
+  expect(historySyncCount).toBe(initialHistory + 1)
+
+  // Finish run -> returns to idle polling
+  streams[0].result.resolve(reply)
+  await run
+  const afterRunHistory = historySyncCount
+  await vi.advanceTimersByTimeAsync(1500)
+  // Since it returned to idle (5000ms), 1500ms shouldn't trigger another sync
+  expect(historySyncCount).toBe(afterRunHistory)
+
+  stop()
+  expect(vi.getTimerCount()).toBe(0)
+})
+
+describe('Queued messages lifecycle and steering', () => {
+  it('enqueues, edits, and removes queued prompts', () => {
+    const { lifecycle } = setup()
+    expect(lifecycle.getSnapshot().queuedPrompts).toEqual([])
+
+    lifecycle.queuePrompt({ text: 'Hello from queue' })
+    const snapshot1 = lifecycle.getSnapshot()
+    expect(snapshot1.queuedPrompts).toHaveLength(1)
+    expect(snapshot1.queuedPrompts[0].text).toBe('Hello from queue')
+    const promptId = snapshot1.queuedPrompts[0].id
+
+    // Edit restores text to composer and removes from queue
+    lifecycle.editQueuedPrompt(promptId)
+    const snapshot2 = lifecycle.getSnapshot()
+    expect(snapshot2.queuedPrompts).toHaveLength(0)
+    expect(snapshot2.message).toBe('Hello from queue')
+
+    // Re-queue and remove
+    lifecycle.queuePrompt({ text: 'To be removed' })
+    const promptId2 = lifecycle.getSnapshot().queuedPrompts[0].id
+    lifecycle.removeQueuedPrompt(promptId2)
+    expect(lifecycle.getSnapshot().queuedPrompts).toHaveLength(0)
+  })
+
+  it('automatically dispatches the next queued prompt on natural turn completion', async () => {
+    const { lifecycle, streams } = setup()
+    const run1 = lifecycle.sendPrompt('Turn 1')
+    expect(lifecycle.getSnapshot().sending).toBe(true)
+
+    // Queue Turn 2 while Turn 1 is running
+    lifecycle.queuePrompt({ text: 'Turn 2' })
+    expect(lifecycle.getSnapshot().queuedPrompts).toHaveLength(1)
+
+    // Turn 1 completes
+    streams[0].result.resolve(reply)
+    await run1
+
+    // Turn 2 should be automatically popped and dispatched
+    expect(lifecycle.getSnapshot().queuedPrompts).toHaveLength(0)
+    expect(streams).toHaveLength(2)
+    expect(lifecycle.getSnapshot().sending).toBe(true)
+    expect(lifecycle.getSnapshot().sendingMessage).toBe('Turn 2')
+
+    // Turn 2 completes
+    streams[1].result.resolve(reply)
+    await new Promise(r => setTimeout(r, 10))
+    expect(lifecycle.getSnapshot().sending).toBe(false)
+  })
+
+  it('pauses the queue on user cancellation and does not auto-dispatch', async () => {
+    const { lifecycle, streams } = setup()
+    lifecycle.sendPrompt('Turn 1')
+    lifecycle.queuePrompt({ text: 'Turn 2' })
+    expect(lifecycle.getSnapshot().queuePaused).toBe(false)
+
+    // User cancels Turn 1
+    await lifecycle.cancel()
+    expect(lifecycle.getSnapshot().sending).toBe(false)
+    expect(lifecycle.getSnapshot().queuePaused).toBe(true)
+    // The queued prompt must remain preserved in queue
+    expect(lifecycle.getSnapshot().queuedPrompts).toHaveLength(1)
+    expect(lifecycle.getSnapshot().queuedPrompts[0].text).toBe('Turn 2')
+    // No second stream should have been dispatched
+    expect(streams).toHaveLength(1)
+  })
+
+  it('interrupts running turn and steers directly to the selected queued prompt', async () => {
+    const { lifecycle, streams } = setup()
+    lifecycle.sendPrompt('Turn 1')
+    lifecycle.queuePrompt({ text: 'Important Urgent Turn' })
+    const queuedId = lifecycle.getSnapshot().queuedPrompts[0].id
+
+    // Steer queued prompt
+    await lifecycle.steerQueuedPrompt(queuedId)
+    // Turn 1 cancelled, Turn 2 steered immediately
+    expect(lifecycle.getSnapshot().queuedPrompts).toHaveLength(0)
+    expect(lifecycle.getSnapshot().sending).toBe(true)
+    expect(lifecycle.getSnapshot().sendingMessage).toBe('Important Urgent Turn')
+    expect(streams).toHaveLength(2)
+  })
+})

package/src/renderer/shared/conversation/lifecycle.ts

@@ -3,7 +3,7 @@ import { compactAgentProgressForPersistence, mergeActivitySnapshots } from '../a
 import { requiresExplicitApproval } from '../utils/approval'
 import { navigateToProject } from './projectNavigation'
 import type { MintPlatformApi } from '../platform'
-import type { AgentProgress, ChatResponse, ChatSession, InteractionMemory } from '../types'
+import type { AgentProgress, ChatResponse, ChatSession, InteractionMemory, QueuedPrompt } from '../types'
 
 export type ConversationTransport = Pick<MintPlatformApi,
   | 'getConversationSnapshot' | 'getConversationChanges' | 'listChatSessions'
@@ -60,6 +60,12 @@ export interface ConversationBrowser {
   document: Pick<Document, 'visibilityState' | 'addEventListener' | 'removeEventListener'>
 }
 
+export function conversationPollIntervalsMs(activeRun: boolean): { historyMs: number; sessionsMs: number } {
+  return activeRun
+    ? { historyMs: 1500, sessionsMs: 5000 }
+    : { historyMs: 5000, sessionsMs: 15000 }
+}
+
 /** Owns ordering and lifecycle; callers never handle generations or cursors. */
 export function createConversationLifecycle(
   conversationId: string,
@@ -82,6 +88,8 @@ export function createConversationLifecycle(
   const pendingSubmissions = new Map<string, { signature: string; requestId: string }>()
   const runs = new Map<string, Run>()
   const subscribers = new Set<() => void>()
+  const conversationQueuedPrompts = new Map<string, QueuedPrompt[]>()
+  const conversationQueuePaused = new Map<string, boolean>()
   const update = (patch: Partial<ConversationView>) => {
     state = { ...state, ...patch }
     subscribers.forEach(notify => notify())
@@ -121,8 +129,11 @@ export function createConversationLifecycle(
     session = { chatId: id }
     cursor = null
     projectSerial++
+    const activePrompts = conversationQueuedPrompts.get(id) || []
+    const activePaused = conversationQueuePaused.get(id) || false
     update({
       ...transitionConversation(state, { type: 'session_switched', draft }), conversationId: id,
+      queuedPrompts: activePrompts, queuePaused: activePaused,
       interactions: [], hasOlderInteractions: false, agentActivitySnapshots: {},
       streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false,
     })
@@ -252,8 +263,10 @@ export function createConversationLifecycle(
       if (origin === session) effects.onError?.(error)
     } finally {
       if (approvalToken) removeApproval(origin.chatId, approvalToken)
+      conversationQueuePaused.set(origin.chatId, true)
       if (origin === session && !runs.has(origin.chatId)) {
         update({ ...transitionConversation(state, { type: 'run_cancelled' }),
+          queuePaused: true,
           streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
       }
     }
@@ -271,7 +284,15 @@ export function createConversationLifecycle(
     update({ ...transitionConversation(state, { type: 'run_started', message: prompt, imageCount: images.length, videoCount: videos.length }),
       streamingConversationId: origin.chatId, activeTurnId: null, sessionAutoApproved: false })
     const draft = { message: state.message, images: state.imageAttachments, videos: state.videoAttachments, document: state.documentAttachment }
-    const signature = JSON.stringify([prompt, images, videos, options.documentAttachment])
+    const uriFingerprint = (name: string, dataUri: string) =>
+      `${name}:${dataUri.length}:${dataUri.slice(0, 64)}:${dataUri.slice(-32)}`
+    const doc = options.documentAttachment
+    const signature = [
+      prompt,
+      images.map(i => uriFingerprint(i.name, i.dataUri)).join('|'),
+      videos.map(v => uriFingerprint(v.name, v.dataUri)).join('|'),
+      doc ? uriFingerprint(doc.filename, doc.dataUri) : '',
+    ].join('\u0000')
     let submission = pendingSubmissions.get(origin.chatId)
     if (submission?.signature !== signature) {
       submission = { signature, requestId: globalThis.crypto?.randomUUID?.() ?? `submission-${Date.now().toString(36)}-${Array.from(globalThis.crypto.getRandomValues(new Uint8Array(16)), byte => byte.toString(16).padStart(2, '0')).join('')}` }
@@ -329,10 +350,31 @@ export function createConversationLifecycle(
     } finally {
       flushProgress(run)
       if (runs.get(origin.chatId) === run) {
+        const isCurrent = currentRun(run)
         removeApproval(origin.chatId)
-        if (currentRun(run)) update({ ...transitionConversation(state, { type: 'run_finished' }),
-          streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
         runs.delete(origin.chatId)
+        if (isCurrent) {
+          update({ ...transitionConversation(state, { type: 'run_finished' }),
+            streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
+        } else {
+          subscribers.forEach(notify => notify())
+        }
+        const isPaused = conversationQueuePaused.get(origin.chatId) || false
+        const chatQueue = conversationQueuedPrompts.get(origin.chatId) || []
+        if (!isPaused && chatQueue.length > 0) {
+          const next = chatQueue.shift()!
+          conversationQueuedPrompts.set(origin.chatId, chatQueue)
+          if (origin === session) {
+            dispatch({ type: 'queued_prompt_dequeued', id: next.id })
+          }
+          void sendPrompt(next.text, {
+            imageAttachments: next.imageAttachments,
+            videoAttachments: next.videoAttachments,
+            documentAttachment: next.documentAttachment,
+            agentMode: options.agentMode,
+            planMode: options.planMode,
+          })
+        }
       }
     }
   }
@@ -381,29 +423,144 @@ export function createConversationLifecycle(
 
   function watch(browser: ConversationBrowser, historyVisible: boolean) {
     let active = true
+    let activeRun = state.sending || runs.size > 0
+    let historyTimer: number | undefined
+    let sessionsTimer: number | undefined
+
     const visible = () => active && browser.document.visibilityState === 'visible'
     const sync = () => { if (historyVisible && visible()) void syncHistory(visible) }
     const refresh = () => { if (visible()) void refreshSessions().catch(() => {}) }
     const focus = () => { sync(); refresh() }
+
+    const scheduleTimers = () => {
+      if (historyTimer !== undefined) browser.window.clearInterval(historyTimer)
+      if (sessionsTimer !== undefined) browser.window.clearInterval(sessionsTimer)
+      if (!active) return
+
+      const intervals = conversationPollIntervalsMs(activeRun)
+      historyTimer = historyVisible ? browser.window.setInterval(sync, intervals.historyMs) : undefined
+      sessionsTimer = browser.window.setInterval(refresh, intervals.sessionsMs)
+    }
+
+    const checkActiveRunTransition = () => {
+      const currentActive = state.sending || runs.size > 0
+      if (currentActive !== activeRun) {
+        activeRun = currentActive
+        scheduleTimers()
+        if (activeRun) {
+          sync()
+          refresh()
+        }
+      }
+    }
+
+    subscribers.add(checkActiveRunTransition)
     sync()
-    const historyTimer = historyVisible ? browser.window.setInterval(sync, 1500) : undefined
-    const sessionsTimer = browser.window.setInterval(refresh, 5000)
+    scheduleTimers()
+
     browser.window.addEventListener('focus', focus)
     browser.document.addEventListener('visibilitychange', focus)
     return () => {
       active = false
+      subscribers.delete(checkActiveRunTransition)
       if (historyTimer !== undefined) browser.window.clearInterval(historyTimer)
-      browser.window.clearInterval(sessionsTimer)
+      if (sessionsTimer !== undefined) browser.window.clearInterval(sessionsTimer)
       browser.window.removeEventListener('focus', focus)
       browser.document.removeEventListener('visibilitychange', focus)
     }
   }
 
+  function queuePrompt(data: {
+    text: string
+    imageAttachments?: ConversationState['imageAttachments']
+    videoAttachments?: ConversationState['videoAttachments']
+    documentAttachment?: ConversationState['documentAttachment']
+  }) {
+    const id = `q-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`
+    const prompt: QueuedPrompt = {
+      id,
+      chatId: session.chatId,
+      text: data.text,
+      imageAttachments: data.imageAttachments && data.imageAttachments.length > 0 ? [...data.imageAttachments] : undefined,
+      videoAttachments: data.videoAttachments && data.videoAttachments.length > 0 ? [...data.videoAttachments] : undefined,
+      documentAttachment: data.documentAttachment || null,
+      createdAt: Date.now(),
+    }
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    conversationQueuedPrompts.set(session.chatId, [...current, prompt])
+    conversationQueuePaused.set(session.chatId, false)
+    dispatch({ type: 'prompt_queued', prompt })
+  }
+
+  function removeQueuedPrompt(id: string) {
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    conversationQueuedPrompts.set(session.chatId, current.filter(p => p.id !== id))
+    dispatch({ type: 'queued_prompt_removed', id })
+  }
+
+  function editQueuedPrompt(id: string) {
+    const current = conversationQueuedPrompts.get(session.chatId) || []
+    const found = current.find(p => p.id === id)
+    if (!found) return
+    conversationQueuedPrompts.set(session.chatId, current.filter(p => p.id !== id))
+    dispatch({ type: 'queued_prompt_restored_to_composer', prompt: found })
+  }
+
+  function clearQueuedPrompts() {
+    conversationQueuedPrompts.delete(session.chatId)
+    conversationQueuePaused.set(session.chatId, false)
+    dispatch({ type: 'queued_prompts_cleared' })
+  }
+
+  function setQueuePaused(paused: boolean) {
+    conversationQueuePaused.set(session.chatId, paused)
+    dispatch({ type: 'queue_paused_set', paused })
+  }
+
+  function resumeQueue() {
+    setQueuePaused(false)
+    if (!state.sending) {
+      const current = conversationQueuedPrompts.get(session.chatId) || []
+      const next = current[0]
+      if (next) {
+        conversationQueuedPrompts.set(session.chatId, current.slice(1))
+        dispatch({ type: 'queued_prompt_dequeued', id: next.id })
+        void sendPrompt(next.text, {
+          imageAttachments: next.imageAttachments,
+          videoAttachments: next.videoAttachments,
+          documentAttachment: next.documentAttachment,
+        })
+      }
+    }
+  }
+
+  async function steerQueuedPrompt(id: string) {
+    const origin = session
+    const current = conversationQueuedPrompts.get(origin.chatId) || []
+    const found = current.find(p => p.id === id)
+    if (!found) return
+    conversationQueuedPrompts.set(origin.chatId, current.filter(p => p.id !== id))
+    conversationQueuePaused.set(origin.chatId, false)
+    if (origin === session) {
+      dispatch({ type: 'queued_prompt_dequeued', id })
+      dispatch({ type: 'queue_paused_set', paused: false })
+    }
+    if (state.sending && runs.has(origin.chatId)) {
+      await cancel()
+    }
+    void sendPrompt(found.text, {
+      imageAttachments: found.imageAttachments,
+      videoAttachments: found.videoAttachments,
+      documentAttachment: found.documentAttachment,
+    })
+  }
+
   return {
     getSnapshot: () => state,
     subscribe: (notify: () => void) => { subscribers.add(notify); return () => { subscribers.delete(notify) } },
     activate, refreshHistory, refreshSessions, syncHistory, loadOlder, sendPrompt, cancel,
     receiveApproval, resolveApproval, clearHistory, selectProject, watch,
+    queuePrompt, removeQueuedPrompt, editQueuedPrompt, clearQueuedPrompts, setQueuePaused, resumeQueue, steerQueuedPrompt,
     appendInteraction: (row: Omit<InteractionMemory, 'chatId' | 'status'> & Partial<Pick<InteractionMemory, 'chatId' | 'status'>>) =>
       update({ interactions: [...state.interactions, { chatId: session.chatId, status: 'completed', ...row }] }),
     compose: (message: string) => dispatch({ type: 'compose', message }),

package/src/renderer/shared/conversation/projectNavigation.test.ts

@@ -103,3 +103,21 @@ describe('project selection', () => {
   })
 
 })
+
+it('handoff opens the exact saved conversation with its own workspace', async () => {
+  const { navigateToSavedConversation } = await import('./projectNavigation')
+  const target = session('cli::saved', '/projects/target', '2026-10-18T00:00:00Z', 'cli')
+  const { state, ports } = fixture([target])
+  expect(await navigateToSavedConversation(target.id, ports)).toBe(true)
+  expect(state.activeId).toBe('cli::saved')
+  expect(state.workspace).toBe('/projects/target')
+  expect(state.view).toBe('chat')
+})
+it('a missing or superseded handoff never opens a different conversation', async () => {
+  const { navigateToSavedConversation } = await import('./projectNavigation')
+  const { state, ports } = fixture([session('other', null, '2026-10-18T00:00:00Z')])
+  expect(await navigateToSavedConversation('deleted', ports)).toBe(false)
+  expect(state.activeId).toBe('conversation-origin')
+  expect(await navigateToSavedConversation('other', { ...ports, isCurrent: () => false })).toBe(false)
+  expect(state.activeId).toBe('conversation-origin')
+})

package/src/renderer/shared/conversation/projectNavigation.ts

@@ -37,3 +37,14 @@ export async function navigateToProject(path: string, navigation: ProjectNavigat
     await navigation.newChat(targetPath, view)
   }
 }
+
+/** Open a persisted ID without substituting another session or its workspace. */
+export async function navigateToSavedConversation(id: string, navigation: Pick<ProjectNavigation, 'listSessions' | 'openSession' | 'isCurrent'>): Promise<boolean> {
+  if (navigation.isCurrent?.() === false) return false
+  const sessions = await navigation.listSessions()
+  if (navigation.isCurrent?.() === false) return false
+  const session = sessions.find(session => session.id === id)
+  if (!session) return false
+  await navigation.openSession(session, 'chat')
+  return true
+}

package/src/renderer/shared/conversation/transport.test.ts

@@ -160,4 +160,24 @@ describe.each([['Desktop', desktop], ['Web', web]] as const)('%s Conversation tr
       'chat-1', undefined, true)).resolves.toEqual(response)
     expect(captured).toMatchObject({ ownerToken: 'owner-token', request: { chatId: 'chat-1', planMode: true } })
   })
+
+  it('validates the 32 MiB request limit without TextEncoder allocations or double JSON.stringify on native IPC', async () => {
+    const encodeSpy = vi.spyOn(TextEncoder.prototype, 'encode')
+    const stringifySpy = vi.spyOn(JSON, 'stringify')
+    ;(window as any).__TAURI_INTERNALS__ = {}
+    native.invoke.mockResolvedValue(response)
+
+    await expect(adapter.streamChatMessage('hello', () => {}, 'data:image/png;base64,AAAA')).resolves.toEqual(response)
+    expect(encodeSpy).not.toHaveBeenCalled()
+    expect(stringifySpy).not.toHaveBeenCalled()
+
+    const oversized = 'A'.repeat(32 * 1024 * 1024 + 64)
+    await expect(adapter.streamChatMessage('hello', () => {}, oversized)).rejects.toThrow(
+      'Attachments exceed the 32 MiB request limit. Send fewer files at once.',
+    )
+    delete (window as any).__TAURI_INTERNALS__
+    await expect(adapter.streamChatMessage('hello', () => {}, oversized)).rejects.toThrow(
+      'Attachments exceed the 32 MiB request limit. Send fewer files at once.',
+    )
+  })
 })

package/src/renderer/shared/conversation/transport.ts

@@ -84,6 +84,29 @@ function withMediaPlaceholders(message: string, imageDataUri?: string | null, vi
   return message
 }
 
+const MAX_REQUEST_BYTES = 32 * 1024 * 1024
+const REQUEST_LIMIT_ERROR = 'Attachments exceed the 32 MiB request limit. Send fewer files at once.'
+
+function utf8ByteLength(value?: string | null): number {
+  if (!value) return 0
+  if (value.length > MAX_REQUEST_BYTES) return value.length
+  if (value.startsWith('data:') && value.includes(';base64,')) return value.length
+  let bytes = value.length
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code >= 0x80) {
+      if (code <= 0x7ff) bytes += 1
+      else if (code >= 0xd800 && code <= 0xdbff) {
+        bytes += 2
+        i++
+      } else {
+        bytes += 2
+      }
+    }
+  }
+  return bytes
+}
+
 /** Shared wire contract; adapters supply runtime detection, address and authentication. */
 export function createConversationTransport(environment: TransportEnvironment): ConversationOperations {
   const requestBody = (message: string, imageDataUri?: string | null, audioDataUri?: string | null,
@@ -95,14 +118,33 @@ export function createConversationTransport(environment: TransportEnvironment):
     imageDataUri, audioDataUri, videoDataUri, documentAttachment, workspacePath, chatId, agentId, planMode, pinnedMcpServer,
   })
 
-  const validate = (request: ReturnType<typeof requestBody>) => {
-    const body = JSON.stringify(request)
-    if (new TextEncoder().encode(body).byteLength > 32 * 1024 * 1024) throw new Error('Attachments exceed the 32 MiB request limit. Send fewer files at once.')
-    return body
+  const assertWithinLimit = (request: ReturnType<typeof requestBody>) => {
+    const metadataBytes = request.attachmentMetadata
+      ? utf8ByteLength(request.attachmentMetadata.requestId)
+        + (request.attachmentMetadata.imageNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+        + (request.attachmentMetadata.videoNames?.reduce((sum, name) => sum + utf8ByteLength(name) + 4, 0) ?? 0)
+      : 0
+    const totalBytes = 256
+      + metadataBytes
+      + utf8ByteLength(request.message)
+      + utf8ByteLength(request.systemInstruction)
+      + utf8ByteLength(request.imageDataUri)
+      + utf8ByteLength(request.audioDataUri)
+      + utf8ByteLength(request.videoDataUri)
+      + utf8ByteLength(request.documentAttachment?.filename)
+      + utf8ByteLength(request.documentAttachment?.dataUri)
+      + utf8ByteLength(request.workspacePath)
+      + utf8ByteLength(request.chatId)
+      + utf8ByteLength(request.agentId)
+      + utf8ByteLength(request.pinnedMcpServer)
+    if (totalBytes > MAX_REQUEST_BYTES) throw new Error(REQUEST_LIMIT_ERROR)
+  }
+  const post = (route: string, request: ReturnType<typeof requestBody>) => {
+    assertWithinLimit(request)
+    return environment.fetch(`${environment.apiBase()}/${route}`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(request),
+    })
   }
-  const post = (route: string, request: ReturnType<typeof requestBody>) => environment.fetch(`${environment.apiBase()}/${route}`, {
-    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: validate(request),
-  })
 
 
   return {
@@ -125,7 +167,7 @@ export function createConversationTransport(environment: TransportEnvironment):
           return { provider: 'error', model: 'error', text: `Failed to connect to Local API Server: ${error}` }
         }
       }
-      validate(request)
+      assertWithinLimit(request)
       const { invoke } = await import('@tauri-apps/api/core')
       const response = await invoke<ChatResponse>('send_chat_message', { ownerToken: environment.ownerToken(), request, ...(attachmentMetadata ? { attachmentMetadata } : {}) })
       return response
@@ -145,7 +187,7 @@ export function createConversationTransport(environment: TransportEnvironment):
         }
         return readStream(response, callbacks)
       }
-      validate(request)
+      assertWithinLimit(request)
       const { invoke, Channel } = await import('@tauri-apps/api/core')
       const onEvent = new Channel<StreamEvent>()
       onEvent.onmessage = event => { deliverEvent(event, callbacks) }

package/src/renderer/shared/conversation/useConversationCoordinator.ts

@@ -33,23 +33,53 @@ export function useConversationCoordinator(
       else window.localStorage.removeItem(key)
     },
   }))
-  const conversation = useSyncExternalStore(actions.subscribe, actions.getSnapshot, actions.getSnapshot)
+  const dashboardSnapshotRef = useRef<ReturnType<typeof actions.getSnapshot> | null>(null)
+  const getDashboardSnapshot = () => {
+    const next = actions.getSnapshot()
+    const prev = dashboardSnapshotRef.current
+    if (prev && prev !== next) {
+      let onlyMessageChanged = prev.message !== next.message
+      if (onlyMessageChanged) {
+        for (const key of Object.keys(next) as Array<keyof typeof next>) {
+          if (key !== 'message' && prev[key] !== next[key]) {
+            onlyMessageChanged = false
+            break
+          }
+        }
+      }
+      if (onlyMessageChanged) {
+        return prev
+      }
+    }
+    dashboardSnapshotRef.current = next
+    return next
+  }
+
+  const conversation = useSyncExternalStore(actions.subscribe, getDashboardSnapshot, getDashboardSnapshot)
 
   useEffect(() => actions.watch({ window, document }, options.historyVisible),
     [actions, options.historyVisible, conversation.conversationId])
 
   useEffect(() => {
-    const timer = window.setTimeout(() => {
-      try {
-        const key = `${options.draftKeyPrefix}${conversation.conversationId}`
-        if (conversation.message) window.localStorage.setItem(key, conversation.message)
-        else window.localStorage.removeItem(key)
-      } catch {
-        // Draft persistence is best-effort in private browsing modes.
-      }
-    }, 300)
-    return () => window.clearTimeout(timer)
-  }, [conversation.message, conversation.conversationId, options.draftKeyPrefix])
+    let timer: number | undefined
+    const unsubscribe = actions.subscribe(() => {
+      const snap = actions.getSnapshot()
+      if (timer !== undefined) window.clearTimeout(timer)
+      timer = window.setTimeout(() => {
+        try {
+          const key = `${latest.current.draftKeyPrefix}${snap.conversationId}`
+          if (snap.message) window.localStorage.setItem(key, snap.message)
+          else window.localStorage.removeItem(key)
+        } catch {
+          // Draft persistence is best-effort in private browsing modes.
+        }
+      }, 300)
+    })
+    return () => {
+      unsubscribe()
+      if (timer !== undefined) window.clearTimeout(timer)
+    }
+  }, [actions])
 
   useEffect(() => {
     try {