@pheem49/mint 1.14.0 → 1.16.0

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

@@ -0,0 +1,418 @@
+import { initialConversationState, transitionConversation, type ConversationEvent, type ConversationState } from './coordinator'
+import { compactAgentProgressForPersistence, mergeActivitySnapshots } from '../agentProgress'
+import { requiresExplicitApproval } from '../utils/approval'
+import { navigateToProject } from './projectNavigation'
+import type { MintPlatformApi } from '../platform'
+import type { AgentProgress, ChatResponse, ChatSession, InteractionMemory } from '../types'
+
+export type ConversationTransport = Pick<MintPlatformApi,
+  | 'getConversationSnapshot' | 'getConversationChanges' | 'listChatSessions'
+  | 'streamChatMessage' | 'cancelChatMessage' | 'submitToolApproval'
+  | 'saveInteractionAgentActivity' | 'clearChatHistory'>
+
+export interface PendingApproval { token: string; approval: Record<string, unknown> }
+export interface ConversationView extends ConversationState {
+  conversationId: string
+  interactions: InteractionMemory[]
+  hasOlderInteractions: boolean
+  agentActivitySnapshots: Record<string, AgentProgress[]>
+  chatSessions: ChatSession[]
+  streamingConversationId: string | null
+  activeTurnId: number | null
+  pendingApprovals: Record<string, PendingApproval>
+  sessionAutoApproved: boolean
+}
+export interface ConversationEffects {
+  onError?(error: unknown): void
+  onApproval?(approval: PendingApproval, chatId: string): void
+  onReply?(response: ChatResponse, chatId: string): void | Promise<void>
+  onActivityPersisted?(turnId: number): void
+  onRunCompleted?(): void | Promise<void>
+  onVisibleRunCompleted?(chatId: string): void
+}
+export interface PromptOptions {
+  imageAttachments?: ConversationState['imageAttachments']
+  videoAttachments?: ConversationState['videoAttachments']
+  documentAttachment?: ConversationState['documentAttachment']
+  audioDataUri?: string | null
+  systemInstruction?: string
+  clearComposer?: boolean
+  pinnedMcpServer?: string
+  agentMode?: boolean
+  forceAgentMode?: boolean
+  planMode?: boolean
+}
+export interface ConversationDrafts {
+  read(id: string): string
+  write(id: string, text: string): void
+}
+interface Session { chatId: string }
+interface Run {
+  session: Session
+  turnId: number | null
+  autoApprove: boolean
+  progress: AgentProgress[]
+  queuedProgress: AgentProgress[]
+  timer?: ReturnType<typeof setTimeout>
+}
+export interface ConversationBrowser {
+  window: Pick<Window, 'addEventListener' | 'removeEventListener' | 'setInterval' | 'clearInterval'>
+  document: Pick<Document, 'visibilityState' | 'addEventListener' | 'removeEventListener'>
+}
+
+/** Owns ordering and lifecycle; callers never handle generations or cursors. */
+export function createConversationLifecycle(
+  conversationId: string,
+  initial: Partial<ConversationState>,
+  transport: ConversationTransport,
+  effects: ConversationEffects = {},
+  drafts?: ConversationDrafts,
+) {
+  let state: ConversationView = {
+    ...initialConversationState(initial), conversationId, interactions: [], hasOlderInteractions: false,
+    agentActivitySnapshots: {}, chatSessions: [], streamingConversationId: null, activeTurnId: null,
+    pendingApprovals: {}, sessionAutoApproved: false,
+  }
+  let session: Session = { chatId: conversationId }
+  let cursor: number | null = null
+  let historySerial = 0
+  let sessionsSerial = 0
+  let projectSerial = 0
+  let poll: Session | null = null
+  const pendingSubmissions = new Map<string, { signature: string; requestId: string }>()
+  const runs = new Map<string, Run>()
+  const subscribers = new Set<() => void>()
+  const update = (patch: Partial<ConversationView>) => {
+    state = { ...state, ...patch }
+    subscribers.forEach(notify => notify())
+  }
+  const dispatch = (event: ConversationEvent) => update(transitionConversation(state, event))
+  const currentRun = (run: Run) => run.session === session && runs.get(session.chatId) === run
+  const clearProgressTimer = (run: Run) => {
+    if (run.timer !== undefined) clearTimeout(run.timer)
+    run.timer = undefined
+  }
+  const flushProgress = (run: Run) => {
+    clearProgressTimer(run)
+    const batch = run.queuedProgress
+    run.queuedProgress = []
+    if (currentRun(run) && batch.length) dispatch({ type: 'progress_received', progress: batch })
+  }
+  const removeApproval = (chatId: string, token?: string) => {
+    if (!state.pendingApprovals[chatId] || (token && state.pendingApprovals[chatId].token !== token)) return
+    const pendingApprovals = { ...state.pendingApprovals }
+    delete pendingApprovals[chatId]
+    update({ pendingApprovals })
+  }
+
+  function activate(id: string, draft?: string) {
+    if (session.chatId === id) return
+    // Flush the outgoing draft before the debounce is cancelled by navigation.
+    try { drafts?.write(session.chatId, state.message) } catch { /* Storage is best-effort. */ }
+    if (draft === undefined) {
+      try { draft = drafts?.read(id) ?? '' } catch { draft = '' }
+    }
+    const oldRun = runs.get(session.chatId)
+    if (oldRun) {
+      clearProgressTimer(oldRun)
+      oldRun.queuedProgress = []
+      oldRun.autoApprove = false
+    }
+    session = { chatId: id }
+    cursor = null
+    projectSerial++
+    update({
+      ...transitionConversation(state, { type: 'session_switched', draft }), conversationId: id,
+      interactions: [], hasOlderInteractions: false, agentActivitySnapshots: {},
+      streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false,
+    })
+  }
+
+  async function refreshHistory(): Promise<void> {
+    const origin = session
+    const serial = ++historySerial
+    try {
+      const snapshot = await transport.getConversationSnapshot(origin.chatId, null, 50)
+      if (origin !== session || serial !== historySerial || (cursor !== null && cursor > snapshot.cursor)) return
+      cursor = snapshot.cursor
+      update({ interactions: snapshot.interactions, hasOlderInteractions: snapshot.interactions.length > 0 && snapshot.hasOlder,
+        agentActivitySnapshots: mergeActivitySnapshots(state.agentActivitySnapshots, snapshot.interactions) })
+    } catch (error) {
+      if (origin === session && serial === historySerial) throw error
+    }
+  }
+
+  async function refreshSessions(): Promise<ChatSession[]> {
+    const serial = ++sessionsSerial
+    const sessions = await transport.listChatSessions()
+    if (serial === sessionsSerial) {
+      const unchanged = state.chatSessions.length === sessions.length && state.chatSessions.every((s, i) =>
+        s.id === sessions[i]?.id && s.updatedAt === sessions[i]?.updatedAt && s.title === sessions[i]?.title
+        && s.workspacePath === sessions[i]?.workspacePath && s.messageCount === sessions[i]?.messageCount
+        && s.totalBytes === sessions[i]?.totalBytes)
+      if (!unchanged) update({ chatSessions: sessions })
+    }
+    return sessions
+  }
+
+  async function syncHistory(isActive: () => boolean = () => true) {
+    const origin = session
+    if (poll === origin || !isActive()) return
+    poll = origin
+    try {
+      if (cursor === null) { await refreshHistory(); return }
+      let changed = false
+      for (let page = 0; page < 10; page++) {
+        const batch = await transport.getConversationChanges(origin.chatId, cursor!, 100)
+        if (origin !== session || !isActive() || (cursor !== null && cursor > batch.cursor)) return
+        cursor = batch.cursor
+        if (batch.changes.length) {
+          changed = true
+          const byId = new Map(state.interactions.map(row => [row.id, row]))
+          const snapshots = { ...state.agentActivitySnapshots }
+          for (const change of batch.changes) {
+            if (change.interaction) {
+              byId.set(change.interactionId, change.interaction)
+              if (Array.isArray(change.interaction.agentActivity)) snapshots[String(change.interactionId)] = change.interaction.agentActivity
+            } else {
+              byId.delete(change.interactionId)
+              delete snapshots[String(change.interactionId)]
+            }
+          }
+          const interactions = Array.from(byId.values()).sort((a, b) => a.id - b.id)
+          update({ interactions, agentActivitySnapshots: snapshots,
+            hasOlderInteractions: interactions.length > 0 && state.hasOlderInteractions })
+        }
+        if (!batch.hasMore) break
+      }
+      if (changed && origin === session && isActive()) await refreshSessions()
+    } catch {
+      // Cross-process SQLite synchronization retries on the next visible tick.
+    } finally {
+      if (poll === origin) poll = null
+    }
+  }
+
+  async function loadOlder() {
+    const origin = session
+    const before = state.interactions[0]?.id
+    if (before == null) return
+    const revision = cursor
+    let page
+    try { page = await transport.getConversationSnapshot(origin.chatId, before, 50) }
+    catch (error) { if (origin === session) throw error; return }
+    if (origin !== session || revision !== cursor) return
+    const rows = new Map([...page.interactions, ...state.interactions].map(row => [row.id, row]))
+    update({ interactions: Array.from(rows.values()).sort((a, b) => a.id - b.id), hasOlderInteractions: page.hasOlder })
+  }
+
+  function receiveApproval(chatId: string, approval: PendingApproval) {
+    const run = runs.get(chatId)
+    if (run?.autoApprove && !requiresExplicitApproval(approval.approval)) {
+      void transport.submitToolApproval(approval.token, true).catch(error => effects.onError?.(error))
+    } else {
+      update({ pendingApprovals: { ...state.pendingApprovals, [chatId]: approval } })
+      effects.onApproval?.(approval, chatId)
+    }
+  }
+
+  async function resolveApproval(approved: boolean, autoApprove = false, answer?: string) {
+    const origin = session
+    const approval = state.pendingApprovals[origin.chatId]
+    if (!approval) return
+    const run = runs.get(origin.chatId)
+    const previousAllowance = run?.autoApprove ?? false
+    const allow = autoApprove && run && !requiresExplicitApproval(approval.approval)
+    if (allow) {
+      run.autoApprove = true
+      update({ sessionAutoApproved: true })
+    }
+    try {
+      await transport.submitToolApproval(approval.token, approved, answer)
+      removeApproval(origin.chatId, approval.token)
+    } catch (error) {
+      if (allow && runs.get(origin.chatId) === run) {
+        run.autoApprove = previousAllowance
+        if (origin === session) update({ sessionAutoApproved: previousAllowance })
+      }
+      if (origin === session) effects.onError?.(error)
+    }
+  }
+
+  async function cancel() {
+    const origin = session
+    const run = runs.get(origin.chatId)
+    if (!state.sending || !run || !currentRun(run)) return
+    runs.delete(origin.chatId)
+    clearProgressTimer(run)
+    const approvalToken = state.pendingApprovals[origin.chatId]?.token
+    try {
+      await transport.cancelChatMessage(origin.chatId)
+    } catch (error) {
+      if (origin === session) effects.onError?.(error)
+    } finally {
+      if (approvalToken) removeApproval(origin.chatId, approvalToken)
+      if (origin === session && !runs.has(origin.chatId)) {
+        update({ ...transitionConversation(state, { type: 'run_cancelled' }),
+          streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
+      }
+    }
+  }
+
+  async function sendPrompt(prompt: string, options: PromptOptions = {}) {
+    if (state.sending) return
+    const origin = session
+    const run: Run = { session: origin, turnId: null, autoApprove: false, progress: [], queuedProgress: [] }
+    runs.set(origin.chatId, run)
+    const images = options.imageAttachments ?? []
+    const videos = options.videoAttachments ?? []
+    const agent = options.agentMode || options.forceAgentMode || prompt.toLowerCase().startsWith('search web:')
+    const workspace = state.workspacePath || null
+    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])
+    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('')}` }
+      pendingSubmissions.set(origin.chatId, submission)
+    }
+    const metadata = { requestId: submission.requestId, imageNames: images.map(i => i.name), videoNames: videos.map(v => v.name) }
+    const accepted = () => {
+      if (pendingSubmissions.get(origin.chatId)?.requestId === metadata.requestId) pendingSubmissions.delete(origin.chatId)
+      if (options.clearComposer && currentRun(run) && state.message === draft.message && state.imageAttachments === draft.images && state.videoAttachments === draft.videos && state.documentAttachment === draft.document) dispatch({ type: 'composer_cleared' })
+    }
+    try {
+      const response = await transport.streamChatMessage(
+        agent ? prompt : `/chat ${prompt}`, () => {}, images.map(img => img.dataUri).join(' '),
+        options.audioDataUri ?? null, videos.map(video => video.dataUri).join(' '), options.systemInstruction ?? '',
+        progress => {
+          if (runs.get(origin.chatId) !== run) return
+          run.progress.push(progress)
+          if (!currentRun(run)) return
+          run.queuedProgress.push(progress)
+          if (progress.type !== 'ThinkingDelta') flushProgress(run)
+          else if (run.timer === undefined) run.timer = setTimeout(() => flushProgress(run), 75)
+        }, options.documentAttachment ?? null, workspace, origin.chatId, undefined,
+        agent ? options.planMode : false, options.pinnedMcpServer ?? null,
+        approval => { if (runs.get(origin.chatId) === run) receiveApproval(origin.chatId, approval) },
+        id => {
+          run.turnId = id
+          accepted()
+          if (currentRun(run)) update({ activeTurnId: id })
+        }, metadata,
+      )
+      if (response.provider !== 'error') accepted()
+      flushProgress(run)
+      // Reveal only the authoritative completed reply, as on CLI/TUI.
+      if (currentRun(run)) update({ streamedReply: response.text, streamedResponse: response })
+      await effects.onReply?.(response, origin.chatId)
+      const persisted = compactAgentProgressForPersistence(run.progress)
+      if (persisted.length && run.turnId !== null) {
+        await transport.saveInteractionAgentActivity(run.turnId, persisted)
+        if (currentRun(run)) {
+          update({ agentActivitySnapshots: { ...state.agentActivitySnapshots, [String(run.turnId)]: persisted.slice() } })
+          effects.onActivityPersisted?.(run.turnId)
+        }
+      }
+      if (currentRun(run)) {
+        try { await refreshHistory() } catch (error) { effects.onError?.(error) }
+      }
+      await refreshSessions()
+      await effects.onRunCompleted?.()
+      if (currentRun(run)) {
+        effects.onVisibleRunCompleted?.(origin.chatId)
+        dispatch({ type: 'stream_cleared' })
+      }
+    } catch (error) {
+      if (currentRun(run)) effects.onError?.(error)
+    } finally {
+      flushProgress(run)
+      if (runs.get(origin.chatId) === run) {
+        removeApproval(origin.chatId)
+        if (currentRun(run)) update({ ...transitionConversation(state, { type: 'run_finished' }),
+          streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
+        runs.delete(origin.chatId)
+      }
+    }
+  }
+
+  async function clearHistory() {
+    const origin = session
+    try {
+      await transport.clearChatHistory(origin.chatId)
+      if (origin !== session) return
+      // Invalidate in-flight snapshots, polls and runs even when the id stays the same.
+      const run = runs.get(origin.chatId)
+      if (run) clearProgressTimer(run)
+      runs.delete(origin.chatId)
+      session = { chatId: origin.chatId }
+      cursor = null
+      removeApproval(origin.chatId)
+      update({ ...transitionConversation(state, { type: 'session_switched', draft: '' }),
+        interactions: [], hasOlderInteractions: false, agentActivitySnapshots: {},
+        streamingConversationId: null, activeTurnId: null, sessionAutoApproved: false })
+    } catch (error) {
+      if (origin === session) throw error
+    }
+  }
+
+  async function selectProject(
+    choosePath: () => Promise<string | null>,
+    navigation: {
+      openSession(session: ChatSession, view: 'chat' | 'workspace'): Promise<void>
+      newChat(path: string, view: 'chat' | 'workspace'): Promise<void>
+      showCurrentView(view: 'chat' | 'workspace'): void
+    },
+    view: 'chat' | 'workspace',
+  ) {
+    const origin = session
+    const selection = ++projectSerial
+    const isCurrent = () => origin === session && selection === projectSerial
+    try {
+      const path = await choosePath()
+      if (path && isCurrent()) await navigateToProject(path, {
+        ...navigation, listSessions: refreshSessions, currentSessionId: () => session.chatId, isCurrent,
+      }, view)
+    } catch (error) {
+      if (isCurrent()) effects.onError?.(error)
+    }
+  }
+
+  function watch(browser: ConversationBrowser, historyVisible: boolean) {
+    let active = true
+    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() }
+    sync()
+    const historyTimer = historyVisible ? browser.window.setInterval(sync, 1500) : undefined
+    const sessionsTimer = browser.window.setInterval(refresh, 5000)
+    browser.window.addEventListener('focus', focus)
+    browser.document.addEventListener('visibilitychange', focus)
+    return () => {
+      active = false
+      if (historyTimer !== undefined) browser.window.clearInterval(historyTimer)
+      browser.window.clearInterval(sessionsTimer)
+      browser.window.removeEventListener('focus', focus)
+      browser.document.removeEventListener('visibilitychange', focus)
+    }
+  }
+
+  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,
+    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 }),
+    selectWorkspace: (path: string) => dispatch({ type: 'workspace_selected', path }),
+    attachImage: (image: ConversationState['imageAttachments'][number]) => dispatch({ type: 'image_attached', image }),
+    removeImage: (index: number) => dispatch({ type: 'image_removed', index }),
+    attachVideo: (video: ConversationState['videoAttachments'][number]) => dispatch({ type: 'video_attached', video }),
+    removeVideo: (index: number) => dispatch({ type: 'video_removed', index }),
+    attachDocument: (document: ConversationState['documentAttachment']) => dispatch({ type: 'document_attached', document }),
+    clearComposer: () => dispatch({ type: 'composer_cleared' }),
+  }
+}

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

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest'
+import type { ChatSession } from '../types'
+import { isPersistedConversation, navigateToProject } from './projectNavigation'
+
+function session(id: string, workspacePath: string | null, updatedAt: string, kind = 'conversation'): ChatSession {
+  return { id, workspacePath, updatedAt, kind, title: id, createdAt: '2026-10-01T00:00:00Z', messageCount: 2, totalBytes: 20 }
+}
+
+function fixture(sessions: ChatSession[]) {
+  const state = { activeId: 'conversation-origin', workspace: '/projects/old', draft: 'unfinished text', view: 'chat' };
+  const ports = {
+    listSessions: async () => sessions,
+    currentSessionId: () => state.activeId,
+    openSession: async (target: ChatSession, view = 'chat') => { state.activeId = target.id; state.workspace = target.workspacePath || ''; state.draft = ''; state.view = view },
+    newChat: async (path: string, view = 'chat') => { state.activeId = 'conversation-new'; state.workspace = path; state.draft = ''; state.view = view },
+    showCurrentView: (view: string) => { state.view = view },
+  }
+  return { state, ports }
+}
+
+describe('project selection', () => {
+  it('does not persist workspace context for an unsent New chat', () => {
+    const sessions = [session('conversation-saved', '/projects/new', '2026-10-09T00:00:00Z')]
+    expect(isPersistedConversation('conversation-unsent', sessions)).toBe(false)
+    expect(isPersistedConversation('conversation-saved', sessions)).toBe(true)
+  })
+
+  it('opens the Workspace file tree when the folder action selects an existing project', async () => {
+    const { state, ports } = fixture([session('conversation-target', '/projects/new', '2026-10-09T00:00:00Z')])
+    await navigateToProject('/projects/new', ports, 'workspace')
+    expect(state).toMatchObject({ activeId: 'conversation-target', workspace: '/projects/new', view: 'workspace' })
+  })
+  it('keeps Workspace visible when the selected project starts a new chat', async () => {
+    const { state, ports } = fixture([])
+    await navigateToProject('/projects/new', ports, 'workspace')
+    expect(state).toMatchObject({ activeId: 'conversation-new', workspace: '/projects/new', view: 'workspace' })
+  })
+  it('shows Workspace without clearing the draft when its latest conversation is already open', async () => {
+    const { state, ports } = fixture([session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z')])
+    await navigateToProject('/projects/old', ports, 'workspace')
+    expect(state).toMatchObject({ activeId: 'conversation-origin', draft: 'unfinished text', view: 'workspace' })
+  })
+  it('opens the latest conversation in the selected project without moving the current conversation', async () => {
+    const rows = [session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z'), session('conversation-older', '/projects/new', '2026-10-07T00:00:00Z'), session('conversation-latest', '/projects/new', '2026-10-08T00:00:00Z')]
+    const { state, ports } = fixture(rows)
+    await navigateToProject('/projects/new', ports)
+    expect(rows[0].workspacePath).toBe('/projects/old')
+    expect(state).toMatchObject({ activeId: 'conversation-latest', workspace: '/projects/new', view: 'chat' })
+  })
+
+  it('opens a new chat for a project with no conversations and leaves an unassigned old chat unassigned', async () => {
+    const rows = [session('conversation-origin', null, '2026-10-09T00:00:00Z')]
+    const { state, ports } = fixture(rows)
+    await navigateToProject('/projects/empty', ports)
+    expect(rows[0].workspacePath).toBeNull()
+    expect(state).toMatchObject({ activeId: 'conversation-new', workspace: '/projects/empty', view: 'chat', draft: '' })
+  })
+  it('matches normalized project paths and ignores newer CLI and nested subagent sessions', async () => {
+    const rows = [
+      session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z'),
+      session('cli-latest', '/projects/new', '2026-10-10T00:00:00Z', 'cli'),
+      session('conversation-parent::subagent::worker', '/projects/new', '2026-10-10T00:00:00Z'),
+      session('conversation-target', '/projects/new/', '2026-10-08T00:00:00Z'),
+    ]
+    const { state, ports } = fixture(rows)
+    await navigateToProject(' /projects/new/ ', ports)
+    expect(state.activeId).toBe('conversation-target')
+    expect(rows[0].workspacePath).toBe('/projects/old')
+  })
+
+  it('opens a new chat when only CLI or internal sessions exist for the project', async () => {
+    const { state, ports } = fixture([
+      session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z'),
+      session('cli', '/projects/new', '2026-10-10T00:00:00Z', 'cli'),
+    ])
+    await navigateToProject('/projects/new/', ports)
+    expect(state).toMatchObject({ activeId: 'conversation-new', workspace: '/projects/new', view: 'chat' })
+  })
+
+  it('keeps the current draft when the latest target session is already open', async () => {
+    const { state, ports } = fixture([session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z')])
+    await navigateToProject('/projects/old', ports)
+    expect(state).toMatchObject({ activeId: 'conversation-origin', draft: 'unfinished text', view: 'chat' })
+  })
+
+  it('ignores a slow earlier selection after the user chooses another project', async () => {
+    const { state, ports } = fixture([session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z')])
+    let finish!: (rows: ChatSession[]) => void
+    const slow = new Promise<ChatSession[]>(resolve => { finish = resolve })
+    let selection = 1
+    const earlier = navigateToProject('/projects/first', { ...ports, listSessions: () => slow, isCurrent: () => selection === 1 })
+    selection = 2
+    await navigateToProject('/projects/last', ports)
+    finish([session('conversation-first', '/projects/first', '2026-10-09T00:00:00Z')])
+    await earlier
+    expect(state).toMatchObject({ activeId: 'conversation-new', workspace: '/projects/last' })
+  })
+
+  it('leaves the current conversation intact when session discovery fails', async () => {
+    const { state, ports } = fixture([session('conversation-origin', '/projects/old', '2026-10-09T00:00:00Z')])
+    await expect(navigateToProject('/projects/new', { ...ports, listSessions: async () => { throw new Error('offline') } })).rejects.toThrow('offline')
+    expect(state).toMatchObject({ activeId: 'conversation-origin', workspace: '/projects/old', draft: 'unfinished text' })
+  })
+
+})

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

@@ -0,0 +1,39 @@
+import type { ChatSession } from '../types'
+import { normalizeWorkspacePath } from '../utils/workspaces'
+
+interface ProjectNavigation {
+  listSessions(): Promise<ChatSession[]>
+  currentSessionId(): string
+  openSession(session: ChatSession, view: 'chat' | 'workspace'): Promise<void>
+  newChat(path: string, view: 'chat' | 'workspace'): Promise<void>
+  showCurrentView?(view: 'chat' | 'workspace'): void
+  isCurrent?(): boolean
+}
+
+/** A local New chat is not a saved session until its first message is sent. */
+export function isPersistedConversation(sessionId: string, sessions: ChatSession[]): boolean {
+  return sessions.some(session => session.id === sessionId)
+}
+
+function sessionTime(session: ChatSession): number {
+  return Date.parse(session.updatedAt) || Date.parse(session.createdAt) || 0
+}
+
+/** Navigate using persisted project ownership; selecting a project never moves a chat. */
+export async function navigateToProject(path: string, navigation: ProjectNavigation, view: 'chat' | 'workspace' = 'chat'): Promise<void> {
+  const targetPath = normalizeWorkspacePath(path)
+  if (!targetPath || navigation.isCurrent?.() === false) return
+  const sessions = await navigation.listSessions()
+  if (navigation.isCurrent?.() === false) return
+  const latest = sessions
+    .filter(session => session.kind !== 'cli' && !session.id.startsWith('cli')
+      && session.id !== 'conversation-default' && !session.id.includes('::subagent::')
+      && normalizeWorkspacePath(session.workspacePath) === targetPath)
+    .sort((a, b) => sessionTime(b) - sessionTime(a) || Date.parse(b.createdAt) - Date.parse(a.createdAt))[0]
+  if (latest) {
+    if (latest.id !== navigation.currentSessionId()) await navigation.openSession(latest, view)
+    else navigation.showCurrentView?.(view)
+  } else {
+    await navigation.newChat(targetPath, view)
+  }
+}

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

@@ -0,0 +1,27 @@
+import type { ConversationSources, SourceAttachment } from '../types'
+
+export function createSourcesTransport(environment: {
+  isNative(): boolean; apiBase(): string; fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}) {
+  return {
+    async getConversationSources(chatId: string): Promise<ConversationSources> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core')
+        return invoke('get_conversation_sources', { chatId })
+      }
+      const response = await environment.fetch(`${environment.apiBase()}/conversation-sources?${new URLSearchParams({ chatId })}`)
+      if (!response.ok) throw new Error(`Session sources unavailable (${response.status})`)
+      return response.json()
+    },
+    async saveSourceAttachments(chatId: string, interactionId: number, attachments: SourceAttachment[]): Promise<void> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core')
+        return invoke('save_source_attachments', { chatId, interactionId, attachments })
+      }
+      const response = await environment.fetch(`${environment.apiBase()}/conversation-sources`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ chatId, interactionId, attachments }),
+      })
+      if (!response.ok) throw new Error(`Could not save session sources (${response.status})`)
+    },
+  }
+}

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

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest'
+import { visibleInteractionsDuringRun } from './syncView'
+
+describe('shared conversation view reconciliation', () => {
+  it('hides only the initiating turn, never a matching remote prompt', () => {
+    const turns = [
+      { id: 10, userText: 'same prompt' },
+      { id: 11, userText: 'same prompt' },
+    ]
+    expect(visibleInteractionsDuringRun(turns, true, null)).toBe(turns)
+    expect(visibleInteractionsDuringRun(turns, true, 11)).toEqual([turns[0]])
+  })
+})

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

@@ -0,0 +1,6 @@
+export function visibleInteractionsDuringRun<T extends { id: number }>(
+  interactions: T[], sending: boolean, sendingTurnId: number | null | undefined,
+): T[] {
+  if (!sending || sendingTurnId == null) return interactions
+  return interactions.filter((interaction) => interaction.id !== sendingTurnId)
+}