Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

110 KB
Raw Blame
import Combine
import Foundation
import os
import SwiftUI

@MainActor
final class ChatViewModel: ObservableObject {
    private struct ModelReadyKey: Equatable {
        let id: String
        let requestedContextLength: Int?
    }

    private struct StreamingBuffer {
        var text = ""
        var tokenCount = 0
        var lastUiUpdate = Date.distantPast
        var updateTask: Task<Void, Never>?
    }

    private static let defaultTemperature: Float = 0.5
    private static let systemPromptDateFormatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        return formatter
    }()
    private static let systemPromptDatePlaceholder = ConfigDefaults.shared
        .systemPromptDatePlaceholder
    private static let overflowSafetyTokens = 256
    private static let imageTokenEstimate = 768
    private nonisolated static let sessionTitleMaxLength = 40
    private static let sessionSummaryMaxWords = 7
    private static let sessionSummaryStoreKey = "ensu.session_summaries"
    private static let sessionSummarySystemPrompt = ConfigDefaults.shared.sessionSummarySystemPrompt

    private func systemPrompt() -> String {
        let date = Self.systemPromptDateFormatter.string(from: Date())
        let promptBody = ModelSettingsStore.currentSystemPromptBody()
        return promptBody.replacingOccurrences(of: Self.systemPromptDatePlaceholder, with: date)
    }

    private let logger = EnsuLogging.shared.logger("ChatViewModel")

    @Published var sessions: [ChatSession]
    @Published var currentSessionId: UUID?
    @Published var messages: [RenderedChatMessage]
    @Published var streamingResponse: String = ""
    @Published var streamingParentId: UUID? = nil
    @Published var overflowAlert: OverflowAlertState? = nil
    @Published var conversationStatus: String?

    var displayedStreamingResponse: String {
        guard let activeSession = activeGenerationSessionId,
            activeSession == currentSessionId,
            activeGenerationId != nil
        else {
            return ""
        }
        return streamingResponse
    }

    var displayedStreamingParentId: UUID? {
        guard let activeSession = activeGenerationSessionId,
            activeSession == currentSessionId,
            activeGenerationId != nil
        else {
            return nil
        }
        return streamingParentId
    }
    @Published var isGenerating: Bool = false
    @Published private(set) var isSendPending: Bool = false
    @Published var isDownloading: Bool = false
    @Published var isProcessingAttachments: Bool = false
    @Published var draftText: String = "" {
        didSet {
            if draftText != oldValue {
                composerRevision += 1
                voiceInsertionCaret = nil
            }
        }
    }
    @Published var draftAttachments: [ChatAttachment] = []
    private var draftImageAttachmentCount: Int {
        draftAttachments.filter { $0.kind == .image }.count
    }

    @Published var editingMessageId: UUID?
    @Published var downloadToast: DownloadToastState?
    @Published var isModelDownloaded: Bool = false
    @Published var modelDownloadSizeBytes: Int64?
    @Published var hasRequestedModelDownload: Bool = false
    @Published var deviceCapability: ChatDeviceCapability = .unknown
    @Published var showUnsupportedDeviceDialog: Bool = false
    @Published var generationErrorMessage: String?
    @Published var draftCursorMoveToken = UUID()
    let knowledgeStore: KnowledgeStore
    let notesStore: NotesStore
    private var chatActive = false
    private var appForeground = false
    private var warmupSuppressed = false
    private var warmupTask: Task<Void, Never>?
    private var warmupAttempt: (owner: UUID, selection: ModelReadyKey)?

    private let provider: LlmProvider
    private let knowledgeEmbedding: KnowledgeEmbeddingConfig
    private let knowledgeProvider: KnowledgeProvider
    let voiceTranscriber: VoiceTranscriptionService
    private var composerRevision: UInt64 = 0
    private var emptyComposerId = UUID()
    var composerSelection = NSRange(location: 0, length: 0)
    var composerIsComposing = false
    @Published var voiceInsertionCaret: Int?
    private var chatDb: EnsuDb
    private let attachmentsDir: URL
    private let chatDbPath: String
    private let chatDbKey: Data
    private let modelSettings: ModelSettingsStore

    private var messageStore: [UUID: [MessageNode]] = [:]
    private var branchSelections: [UUID: [String: UUID]] = [:]
    private var childrenByParentCache: [UUID: [UUID: [MessageNode]]] = [:]
    private var sessionSummaries: [String: String] = [:]
    private var sessionSummaryTask: Task<Void, Never>?
    private var reloadTask: Task<Void, Never>?
    private let rootId = UUID(uuid: (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
    private var generationTask: Task<Void, Never>?
    private var pendingSendTask: Task<Void, Never>?
    private var pendingSendId: UUID?
    private var modelDownloadTask: Task<Void, Never>?
    private var sharedModelReadyTask: Task<Void, Error>?
    private var sharedModelReadyTaskId: UUID?
    private var sharedModelReadyKey: ModelReadyKey?
    private var stopRequested = false
    private var activeGenerationId: UUID?
    private var activeGenerationSessionId: UUID?
    private var modelDownloadLoggedStart = false
    private let downloadProgressTracker = DownloadProgressTracker()
    private var pendingOverflow: PendingOverflow?
    private var overflowBypassMessageId: UUID?

    init(assetStore: AssetStore) async {
        logger.info("Initializing")
        let summaries = Self.loadSessionSummaries().reduce(into: [String: String]()) {
            result, item in
            result[item.key.lowercased()] = item.value
        }
        let baseDir =
            FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
            ?? FileManager.default.temporaryDirectory

        let config = ConfigDefaults.shared
        // Must initialize after the asset store migrates the persisted selection.
        self.modelSettings = ModelSettingsStore.shared
        let transcription = transcriptionModelAsset()
        var info = utsname()
        uname(&info)
        let machine = withUnsafeBytes(of: &info.machine) { bytes in
            String(decoding: bytes.prefix { $0 != 0 }, as: UTF8.self)
        }
        let transcriber = Transcriber.withCache(
            modelDir: assetStore.assetDir(transcription).path,
            vadModelPath: assetStore.voiceActivityModelPath().path,
            cacheDirectory: (FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
                .first
                ?? FileManager.default.temporaryDirectory).path,
            deviceIdentity: "\(machine)|\(ProcessInfo.processInfo.operatingSystemVersionString)"
        )
        let provider = LlmProvider(
            assetStore: assetStore, transcriber: transcriber,
            knowledgeEmbedding: config.knowledgeEmbedding)
        let notesStore = NotesStore(provider: provider)
        provider.modelMaintenance = notesStore
        let voiceTranscriber = VoiceTranscriptionService(
            provider: provider, assetStore: assetStore)
        let knowledgeProvider = KnowledgeProvider(assetStore: assetStore)
        let knowledgeStore = KnowledgeStore(
            datasets: config.knowledgeDatasets, provider: knowledgeProvider)

        let dbDir = baseDir.appendingPathComponent("llmchat", isDirectory: true)
        try? FileManager.default.createDirectory(
            at: dbDir, withIntermediateDirectories: true, attributes: nil)
        let attachmentsDir = dbDir.appendingPathComponent("chat_attachments", isDirectory: true)
        try? FileManager.default.createDirectory(
            at: attachmentsDir, withIntermediateDirectories: true, attributes: nil)

        let chatDbPath = dbDir.appendingPathComponent("llmchat.db").path
        let hasChatData =
            FileManager.default.fileExists(atPath: chatDbPath)
            || (try? FileManager.default.contentsOfDirectory(atPath: attachmentsDir.path).isEmpty)
                != true
        let chatDbKey: Data
        do {
            chatDbKey = try await CredentialStore.shared.getOrCreateChatDbKey(
                hasChatData: hasChatData)
        } catch {
            fatalError("Failed to load chat DB key: \(error)")
        }

        let chatDb: EnsuDb
        do {
            chatDb = try EnsuDb.open(mainDbPath: chatDbPath, key: chatDbKey)
        } catch {
            fatalError("Failed to open chat DB: \(error)")
        }

        let loadedResult = try? chatDb.listSessions()
        if let loadedResult {
            Self.pruneOrphanedAttachments(
                sessions: loadedResult,
                chatDb: chatDb,
                attachmentsDir: attachmentsDir
            )
        }
        let loaded = loadedResult ?? []
        let sessions = Self.buildSessions(from: loaded, chatDb: chatDb, summaries: summaries)

        self.provider = provider
        self.knowledgeEmbedding = config.knowledgeEmbedding
        self.knowledgeProvider = knowledgeProvider
        self.knowledgeStore = knowledgeStore
        self.notesStore = notesStore
        self.voiceTranscriber = voiceTranscriber
        self.chatDb = chatDb
        self.attachmentsDir = attachmentsDir
        self.chatDbPath = chatDbPath
        self.chatDbKey = chatDbKey
        self.sessionSummaries = summaries

        self.sessions = sessions
        self.currentSessionId = nil
        self.messages = []

        for session in sessions {
            self.messageStore[session.id] = []
            self.branchSelections[session.id] = [:]
        }

        if let current = self.currentSessionId {
            loadMessagesFromDb(for: current)
        }

        voiceTranscriber.onActivityChanged = { [weak self] in self?.refreshChatWarmup() }
        refreshDeviceCapability()
        refreshModelDownloadInfo()
        Task {
            async let knowledge: Void = knowledgeStore.bootstrap()
            async let notes: Void = notesStore.bootstrap()
            _ = await (knowledge, notes)
        }
    }

    func setChatActive(_ active: Bool) {
        guard chatActive != active else { return }
        chatActive = active
        if !active {
            sessionSummaryTask?.cancel()
            cancelChatWarmup(releaseLoadedModel: false)
        }
        Task { await provider.setChatForeground(active) }
        if active {
            warmupSuppressed = false
            if warmupTask == nil { warmupAttempt = nil }
        }
        refreshChatWarmup()
    }

    func setAppForeground(_ active: Bool) {
        guard appForeground != active else { return }
        appForeground = active
        if !active { cancelChatWarmup(releaseLoadedModel: false) }
        Task { await provider.setAppForeground(active) }
    }

    func handleMemoryPressure() {
        voiceTranscriber.interrupt(reason: .memoryUnavailable)
        sessionSummaryTask?.cancel()
        warmupSuppressed = true
        cancelChatWarmup()
        Task { await provider.handleMemoryPressure() }
    }

    private func cancelChatWarmup(releaseLoadedModel: Bool = true) {
        warmupTask?.cancel()
        warmupTask = nil
        let owner = warmupAttempt?.owner
        warmupAttempt = nil
        if let owner, releaseLoadedModel {
            Task { await provider.releaseChatWarmup(owner: owner) }
        }
    }

    private func refreshChatWarmup() {
        let selection = modelSettings.currentSelection()
        let key = modelReadyKey(for: selection)
        let eligible =
            appForeground && chatActive && !warmupSuppressed && !isChatUnsupported
            && !voiceTranscriber.active && !voiceTranscriber.hasActiveTasks
        if let attempt = warmupAttempt, attempt.selection != key { cancelChatWarmup() }
        guard eligible, warmupAttempt == nil, !isGenerating, !isDownloading,
            provider.isChatModelReady(selection)
        else { return }
        let owner = UUID()
        warmupAttempt = (owner, key)
        warmupTask = Task { [weak self] in
            guard let self else { return }
            var ready = false
            defer {
                if warmupAttempt?.owner == owner {
                    warmupTask = nil
                    if !ready { warmupAttempt = nil }
                }
            }
            do {
                try await Task.sleep(nanoseconds: 350_000_000)
                await knowledgeStore.bootstrap()
                await notesStore.bootstrap()
                ready = try await retryChatWarmup(
                    isEligible: {
                        warmupAttempt?.owner == owner
                            && modelReadyKey(for: modelSettings.currentSelection()) == key
                            && appForeground && chatActive && !warmupSuppressed
                            && !isChatUnsupported && !isGenerating && !isDownloading
                            && !voiceTranscriber.active && !voiceTranscriber.hasActiveTasks
                    },
                    operation: {
                        try await provider.prewarmChatModelIfDownloaded(selection, owner: owner)
                    })
            } catch {
                guard !Task.isCancelled, !isCancellation(error), warmupAttempt?.owner == owner,
                    modelReadyKey(for: modelSettings.currentSelection()) == key,
                    !isGenerating, !isDownloading
                else { return }
                logger.info("Chat warmup skipped", details: error.localizedDescription)
            }
        }
    }

    var isChatUnsupported: Bool {
        !deviceCapability.isChatSupported
    }

    var supportsImageAttachments: Bool {
        provider.supportsImages(modelSettings.currentSelection())
    }

    var unsupportedDeviceMessage: String {
        Self.unsupportedDeviceMessage
    }

    func refreshDeviceCapability() {
        let capability = currentChatDeviceCapability()
        deviceCapability = capability
        knowledgeStore.downloadsAllowed = capability.isChatSupported
        logger.info("Chat device capability evaluated", details: "\(capability)")
        guard !capability.isChatSupported else { return }
        cancelPendingSend()
        showUnsupportedDeviceDialog = true
        isDownloading = false
        downloadToast = nil
        modelDownloadSizeBytes = nil
        hasRequestedModelDownload = false
        modelDownloadTask?.cancel()
        sharedModelReadyTask?.cancel()
        clearSharedModelReadyTask()
        discardUnstoredAttachments(draftAttachments)
        editingMessageId = nil
        draftText = ""
        draftAttachments = []
    }

    func dismissUnsupportedDeviceDialog() {
        showUnsupportedDeviceDialog = false
    }

    static let unsupportedDeviceMessage =
        "This device doesn't have enough memory to run Ensu's AI model. "
        + "You can view existing chats, but can't send new messages."

    private func reopenChatStoreIfNeeded(force: Bool = false) {
        let hasChatDb = FileManager.default.fileExists(atPath: chatDbPath)
        if !force && hasChatDb {
            return
        }

        resetGenerationState()
        do {
            try? FileManager.default.createDirectory(
                at: attachmentsDir,
                withIntermediateDirectories: true,
                attributes: nil
            )

            chatDb = try EnsuDb.open(
                mainDbPath: chatDbPath,
                key: chatDbKey
            )
        } catch {
            logger.error("Failed to reopen chat store: \(error)")
        }
    }

    var currentSession: ChatSession? {
        guard let currentSessionId else { return nil }
        return sessions.first { $0.id == currentSessionId }
    }

    private func currentSourceSelection() -> ChatSourceSelection? {
        guard knowledgeStore.inventoryReady && notesStore.inventoryReady else { return nil }
        return ChatSourceSelection(
            selectedPackIDs: Set(
                knowledgeStore.packs.filter {
                    $0.activeIdentity != nil && !knowledgeStore.disabledIDs.contains($0.id)
                }.map(\.id)),
            selectedCollectionIDs: Set(
                notesStore.collections
                    .filter { !notesStore.disabledIDs.contains($0.id) }
                    .map(\.id)))
    }

    var modelDownloadSizeText: String {
        guard let bytes = modelDownloadSizeBytes else { return "Approx. size varies by model" }
        return "Approx. \(bytes.formattedFileSize)"
    }

    private func resetGenerationState(stopRequested: Bool = false) {
        cancelPendingSend()
        conversationStatus = nil
        generationTask?.cancel()
        provider.stopGeneration(invalidatePreparation: true)
        self.stopRequested = stopRequested
        activeGenerationId = nil
        activeGenerationSessionId = nil
        isGenerating = false
        isDownloading = false
        streamingResponse = ""
        streamingParentId = nil
        downloadToast = nil
    }

    func sessionTitle(for sessionId: UUID) -> String {
        guard let title = sessions.first(where: { $0.id == sessionId })?.title else {
            return "Chat"
        }
        return Self.sessionTitle(from: title, fallback: "Chat")
    }

    func startNewSession() {
        guard !isDownloading else { return }

        resetGenerationState()
        cancelVoiceInput()
        discardUnstoredAttachments(draftAttachments)
        draftText = ""
        draftAttachments = []
        editingMessageId = nil

        currentSessionId = nil
        messages = []
    }

    func selectSession(_ session: ChatSession) {
        resetGenerationState()
        cancelVoiceInput()
        currentSessionId = session.id
        messages = []
        loadMessagesFromDb(for: session.id)
    }

    func deleteSession(_ session: ChatSession) {
        if currentSessionId == session.id {
            resetGenerationState()
        }

        if let nodes = messageStore[session.id] {
            for node in nodes {
                logger.info(
                    "Message deleted",
                    details:
                        "id=\(node.id.uuidString) session=\(session.id.uuidString) role=\(node.role.rawValue)"
                )
            }
        }
        logger.info("Session deleted", details: "id=\(session.id.uuidString)")
        guard let attachmentIds = try? chatDb.deleteSession(uuid: session.id.uuidString) else {
            return
        }
        if currentSessionId == session.id {
            cancelVoiceInput()
            discardUnstoredAttachments(draftAttachments)
        }
        for id in attachmentIds {
            try? FileManager.default.removeItem(at: attachmentsDir.appendingPathComponent(id))
        }
        sessionSummaries.removeValue(forKey: sessionSummaryKey(session.id))
        persistSessionSummaries()

        sessions.removeAll { $0.id == session.id }
        messageStore[session.id] = nil
        branchSelections[session.id] = nil
        childrenByParentCache[session.id] = nil
        if currentSessionId == session.id {
            currentSessionId = sessions.first?.id
            if let next = currentSessionId {
                messages = []
                loadMessagesFromDb(for: next)
            } else {
                messages = []
            }
        }
    }

    func beginEditing(message: RenderedChatMessage) {
        guard !isChatUnsupported else {
            showUnsupportedDeviceDialog = true
            return
        }
        guard message.role == .user else { return }
        cancelVoiceInput()
        resetGenerationState()
        editingMessageId = message.id
        draftText = message.text
        draftAttachments = message.attachments
    }

    func cancelEditing() {
        cancelPendingSend()
        discardUnstoredAttachments(draftAttachments)
        editingMessageId = nil
        draftText = ""
        draftAttachments = []
    }

    func toggleVoiceInput() {
        guard !isGenerating, !isDownloading, !isSendPending, editingMessageId == nil,
            !composerIsComposing, !voiceTranscriber.active, !voiceTranscriber.hasActiveTasks
        else { return }
        sessionSummaryTask?.cancel()
        cancelChatWarmup(releaseLoadedModel: false)
        let destination = (currentSessionId ?? emptyComposerId).uuidString
        voiceTranscriber.onInsert = { [weak self] insertion, text in
            guard let self, self.appForeground else { return false }
            do {
                let result = try insertion.apply(
                    destination: (self.currentSessionId ?? self.emptyComposerId).uuidString,
                    revision: self.composerRevision, text: self.draftText, voiceText: text,
                    foreground: self.appForeground, keyboardComposing: self.composerIsComposing)
                self.draftText = result.text
                self.composerRevision = result.revision
                self.voiceInsertionCaret = Int(result.caretUtf16)
                self.draftCursorMoveToken = UUID()
                return true
            } catch { return false }
        }
        voiceTranscriber.open { [weak self] in
            guard let self, self.appForeground, self.chatActive,
                !self.isGenerating, !self.isDownloading, !self.isSendPending,
                self.editingMessageId == nil, !self.composerIsComposing,
                (self.currentSessionId ?? self.emptyComposerId).uuidString == destination
            else { return nil }
            let range = self.composerSelection
            let text = self.draftText as NSString
            guard range.location >= 0, range.length >= 0, range.location <= text.length,
                range.length <= text.length - range.location,
                [range.location, NSMaxRange(range)].allSatisfy({
                    $0 == text.length
                        || text.rangeOfComposedCharacterSequence(at: $0).location == $0
                })
            else { return nil }
            return DictationInsertion(
                destination: destination, revision: self.composerRevision,
                startUtf16: UInt32(range.location), endUtf16: UInt32(NSMaxRange(range)))
        }
    }

    func cancelVoiceInput() {
        voiceTranscriber.releaseComposer()
        emptyComposerId = UUID()
        voiceInsertionCaret = nil
    }

    func addImageAttachment(data: Data, fileName: String?) {
        guard supportsImageAttachments, !isGenerating,
            !isDownloading,
            draftImageAttachmentCount < ChatAttachmentLimits.maxImagesPerMessage
        else { return }
        isProcessingAttachments = true

        Task.detached { [weak self] in
            guard let self else { return }
            do {
                let id = UUID()
                let compressed = try compressAttachmentImage(data: data)
                let url = try self.writeAttachment(data: compressed, attachmentId: id)
                let attachment = ChatAttachment(
                    id: id,
                    name: self.normalizedJpegAttachmentName(fileName),
                    size: Int64(compressed.count),
                    kind: .image,
                    url: url,
                    isUploading: false
                )
                await MainActor.run {
                    if !self.supportsImageAttachments
                        || self.draftImageAttachmentCount
                            >= ChatAttachmentLimits.maxImagesPerMessage
                    {
                        try? FileManager.default.removeItem(at: url)
                        self.isProcessingAttachments = false
                        return
                    }
                    self.draftAttachments.append(attachment)
                    self.isProcessingAttachments = false
                }
            } catch {
                await MainActor.run { self.isProcessingAttachments = false }
            }
        }
    }

    private nonisolated func normalizedJpegAttachmentName(_ fileName: String?) -> String {
        let raw =
            fileName?
            .replacingOccurrences(of: "\0", with: "")
            .replacingOccurrences(of: "\\", with: "/")
            .split(separator: "/")
            .last
            .map(String.init)?
            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
        let base = (raw as NSString).deletingPathExtension
        return "\(base.isEmpty ? "photo" : base).jpg"
    }

    func addDocumentAttachment(url: URL) {
        guard !isGenerating && !isDownloading else { return }
        isProcessingAttachments = true

        Task.detached { [weak self] in
            guard let self else { return }
            do {
                let id = UUID()
                let storedUrl = try self.copyAttachment(from: url, attachmentId: id)
                let size =
                    (try? FileManager.default.attributesOfItem(atPath: storedUrl.path)[.size]
                    as? NSNumber)?.int64Value ?? 0
                let attachment = ChatAttachment(
                    id: id,
                    name: url.lastPathComponent,
                    size: size,
                    kind: .document,
                    url: storedUrl,
                    isUploading: false
                )
                await MainActor.run {
                    self.draftAttachments.append(attachment)
                    self.isProcessingAttachments = false
                }
            } catch {
                await MainActor.run { self.isProcessingAttachments = false }
            }
        }
    }

    func removeAttachment(_ attachment: ChatAttachment) {
        draftAttachments.removeAll { $0.id == attachment.id }
        discardUnstoredAttachments([attachment])
    }

    private func discardUnstoredAttachments(_ attachments: [ChatAttachment]) {
        let storedIds = Set(
            messageStore.values.flatMap { messages in
                messages.flatMap { $0.attachments.map(\.id) }
            })
        for attachment in attachments where !storedIds.contains(attachment.id) {
            if let url = attachment.url {
                try? FileManager.default.removeItem(at: url)
            }
        }
    }

    private static func pruneOrphanedAttachments(
        sessions: [DbSession],
        chatDb: EnsuDb,
        attachmentsDir: URL
    ) {
        let referenced: Set<String>
        do {
            referenced = Set(
                try sessions.flatMap { session in
                    try chatDb.getMessages(sessionUuid: session.uuid)
                        .flatMap { $0.attachments.map(\.id) }
                })
        } catch {
            return
        }
        guard
            let files = try? FileManager.default.contentsOfDirectory(
                at: attachmentsDir,
                includingPropertiesForKeys: nil
            )
        else { return }
        for file in files where !referenced.contains(file.lastPathComponent) {
            try? FileManager.default.removeItem(at: file)
        }
    }

    private func cancelPendingSend() {
        guard isSendPending else { return }
        pendingSendTask?.cancel()
        clearPendingSend()
    }

    private func clearPendingSend() {
        pendingSendTask = nil
        pendingSendId = nil
        isSendPending = false
        isDownloading = false
        if downloadToast?.phase == .loading || downloadToast?.phase == .downloading {
            downloadToast = nil
            clearDownloadProgressMemory()
        }
    }

    func sendDraft() {
        guard !voiceTranscriber.blocksComposer else { return }
        guard !isGenerating && !isDownloading && !isSendPending else { return }
        guard !isChatUnsupported else {
            showUnsupportedDeviceDialog = true
            return
        }

        let text = draftText
        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
        let attachments = draftAttachments
        guard !trimmed.isEmpty || !attachments.isEmpty else { return }

        let sessionId = currentSessionId
        let editingId = editingMessageId
        let selection = modelSettings.currentSelection()
        if attachments.contains(where: { $0.kind == .image }), !provider.supportsImages(selection) {
            generationErrorMessage = ModelImagesUnsupported().localizedDescription
            return
        }
        voiceTranscriber.releaseComposer()
        let sourceSnapshot = currentSourceSelection()
        let sendId = UUID()
        pendingSendId = sendId
        isSendPending = true
        pendingSendTask = Task { @MainActor in
            defer {
                if self.pendingSendId == sendId {
                    self.clearPendingSend()
                }
            }
            guard !Task.isCancelled, self.pendingSendId == sendId else { return }
            self.hasRequestedModelDownload = true

            await knowledgeStore.bootstrap()
            await notesStore.bootstrap()
            guard !Task.isCancelled, self.pendingSendId == sendId,
                currentSessionId == sessionId
            else { return }
            guard let sources = sourceSnapshot ?? currentSourceSelection() else {
                generationErrorMessage = "Couldn’t load sources. Try sending again."
                return
            }

            do {
                try await self.ensureChatModelReady(
                    selection, pendingSendId: sendId, loadContext: false)
            } catch {
                guard !Task.isCancelled, self.pendingSendId == sendId,
                    !self.isCancellation(error)
                else { return }
                self.isDownloading = false
                self.downloadToast = DownloadToastState(
                    phase: .errorDownload,
                    percent: nil,
                    status: self.userFacingModelReadyError(error, wasDownloaded: false),
                    offerRetryDownload: true
                )
                self.refreshModelDownloadInfo()
                self.logger.error("Model readiness check failed before send", error)
                return
            }

            guard !Task.isCancelled, self.pendingSendId == sendId,
                self.currentSessionId == sessionId, self.editingMessageId == editingId,
                self.draftText == text, self.draftAttachments == attachments,
                self.modelSettings.currentSelection() == selection
            else { return }
            let destination = sessionId ?? self.createSessionForDraft()
            self.sendDraftMessage(
                trimmed: trimmed, attachments: attachments, sessionId: destination,
                sources: sources)
        }
    }

    private func sendDraftMessage(
        trimmed: String, attachments: [ChatAttachment], sessionId: UUID,
        sources: ChatSourceSelection
    ) {
        let parentId: UUID? = {
            if let editingId = editingMessageId {
                let existing = messageStore[sessionId]?.first { $0.id == editingId }
                return existing?.parentId
            }
            let childrenMap = childrenByParent(sessionId: sessionId)
            return buildSelectedPath(for: sessionId, childrenMap: childrenMap).last?.id
        }()

        let meta: [DbAttachmentMeta] = attachments.map { attachment in
            DbAttachmentMeta(
                id: attachment.id.uuidString.lowercased(),
                kind: attachment.kind == .image ? .image : .document,
                size: attachment.size,
                name: attachment.name
            )
        }

        guard
            let inserted = try? chatDb.insertMessage(
                sessionUuid: sessionId.uuidString,
                sender: .selfUser,
                text: trimmed,
                parentMessageUuid: parentId?.uuidString,
                attachments: meta
            ), let messageId = UUID(uuidString: inserted.uuid)
        else {
            return
        }

        logger.info(
            "Sent message",
            details:
                "id=\(messageId.uuidString) session=\(sessionId.uuidString) len=\(trimmed.count) attachments=\(attachments.count) edited=\(editingMessageId != nil)"
        )

        let timestamp = Date(timeIntervalSince1970: Double(inserted.createdAtUs) / 1_000_000.0)

        let userNode = MessageNode(
            id: messageId,
            sessionId: sessionId,
            parentId: parentId,
            role: .user,
            text: trimmed,
            timestamp: timestamp,
            attachments: attachments,
            isInterrupted: false,
            tokensPerSecond: nil
        )

        messageStore[sessionId, default: []].append(userNode)
        invalidateChildrenCache(for: sessionId)
        updateSelection(for: sessionId, parentId: parentId, childId: userNode.id)

        draftText = ""
        draftAttachments = []
        editingMessageId = nil

        updateSessionPreview(sessionId: sessionId, preview: trimmed, date: timestamp)
        rebuildMessages(for: sessionId)
        startGeneration(for: userNode, sources: sources)
    }

    func stopGenerating() {
        stopRequested = true
        provider.stopGeneration()
        generationTask?.cancel()
    }

    func modelSelectionChanged() {
        resetGenerationState()
        if let currentSessionId { rebuildMessages(for: currentSessionId) }
        refreshModelDownloadInfo()
    }

    func confirmOverflowTrim() {
        guard let pendingOverflow else { return }
        guard
            let node = messageStore[pendingOverflow.sessionId]?.first(where: {
                $0.id == pendingOverflow.messageId
            })
        else {
            cancelOverflowDialog()
            return
        }
        overflowBypassMessageId = pendingOverflow.messageId
        self.pendingOverflow = nil
        overflowAlert = nil
        startGeneration(for: node, sources: pendingOverflow.sources)
    }

    func cancelOverflowDialog() {
        pendingOverflow = nil
        overflowBypassMessageId = nil
        overflowAlert = nil
    }

    func refreshModelDownloadInfo() {
        defer { refreshChatWarmup() }
        notesStore.modelReadinessChanged()
        guard !isChatUnsupported else {
            isDownloading = false
            downloadToast = nil
            modelDownloadSizeBytes = nil
            hasRequestedModelDownload = false
            isModelDownloaded = false
            return
        }
        let selection = modelSettings.currentSelection()
        isModelDownloaded = provider.isModelDownloaded(selection)
        if isModelDownloaded {
            clearDownloadProgressMemory()
            modelDownloadSizeBytes = nil
            return
        }

        Task { [weak self] in
            guard let self else { return }
            let size = await provider.missingModelDownloadSize(selection)
            await MainActor.run {
                guard
                    self.modelReadyKey(for: self.modelSettings.currentSelection())
                        == self.modelReadyKey(for: selection)
                else {
                    return
                }
                if self.sharedModelReadyTask == nil
                    && (self.downloadToast?.phase == .downloading
                        || self.downloadToast?.phase == .loading)
                {
                    self.downloadToast = nil
                    self.isDownloading = false
                    self.clearDownloadProgressMemory()
                }
                self.modelDownloadSizeBytes = size ?? self.modelDownloadSizeBytes
            }
        }
    }

    private func clearSharedModelReadyTask() {
        sharedModelReadyTask = nil
        sharedModelReadyTaskId = nil
        sharedModelReadyKey = nil
    }

    private func modelReadyKey(for selection: LlmModelSelection) -> ModelReadyKey {
        ModelReadyKey(id: selection.id, requestedContextLength: selection.contextLength)
    }

    private func ensureChatModelReady(
        _ selection: LlmModelSelection, pendingSendId: UUID? = nil,
        loadContext: Bool = true
    ) async throws {
        if isChatUnsupported {
            throw UnsupportedDeviceMemoryError(capability: deviceCapability)
        }
        var retryCount = 0
        while true {
            do {
                try Task.checkCancellation()
                let onProgress: @Sendable (DownloadProgress) -> Void = { progress in
                    Task { @MainActor in
                        if let pendingSendId, self.pendingSendId != pendingSendId { return }
                        self.handleProgress(progress)
                    }
                }
                if loadContext {
                    try await provider.ensureModelReady(selection, onProgress: onProgress)
                } else {
                    try await provider.ensureChatModelAssetsReady(selection, onProgress: onProgress)
                }
                try Task.checkCancellation()
                return
            } catch {
                if isCancellation(error) || !shouldRetryModelDownload(error, retryCount: retryCount)
                {
                    throw error
                }
                retryCount += 1
                try await Task.sleep(nanoseconds: retryDelayNanoseconds(for: retryCount))
            }
        }
    }

    private func ensureRequiredModelsReadyShared(
        _ selection: LlmModelSelection, recoverDownloadedModel: Bool
    ) async throws {
        if isChatUnsupported {
            throw UnsupportedDeviceMemoryError(capability: deviceCapability)
        }
        let modelKey = modelReadyKey(for: selection)
        if let existingTask = sharedModelReadyTask, sharedModelReadyKey == modelKey {
            try await existingTask.value
            return
        }

        if let existingTask = sharedModelReadyTask, sharedModelReadyKey != modelKey {
            existingTask.cancel()
            clearSharedModelReadyTask()
        }

        let taskId = UUID()
        let task = Task {
            if recoverDownloadedModel {
                try await self.ensureChatModelReady(selection)
                return
            }
            var retryCount = 0
            while true {
                do {
                    try await provider.ensureRequiredModelsReady(selection) { progress in
                        Task { @MainActor in
                            self.handleProgress(progress)
                        }
                    }
                    return
                } catch {
                    if self.isCancellation(error) {
                        throw error
                    }
                    if !self.shouldRetryModelDownload(error, retryCount: retryCount) {
                        throw error
                    }
                    retryCount += 1
                    try await Task.sleep(nanoseconds: self.retryDelayNanoseconds(for: retryCount))
                }
            }
        }

        sharedModelReadyTask = task
        sharedModelReadyTaskId = taskId
        sharedModelReadyKey = modelKey

        do {
            try await task.value
        } catch {
            if sharedModelReadyTaskId == taskId {
                clearSharedModelReadyTask()
            }
            throw error
        }

        if sharedModelReadyTaskId == taskId {
            clearSharedModelReadyTask()
        }
    }

    func startModelDownload(userInitiated: Bool = true) {
        guard !isDownloading && !isGenerating else { return }
        guard !isChatUnsupported else {
            showUnsupportedDeviceDialog = true
            return
        }
        if userInitiated {
            hasRequestedModelDownload = true
        }

        let selection = modelSettings.currentSelection()
        let wasDownloaded = provider.isModelDownloaded(selection)
        if wasDownloaded && isModelDownloaded {
            modelDownloadSizeBytes = nil
            return
        }

        cancelChatWarmup()
        isDownloading = true
        seedDownloadProgressMemory()
        modelDownloadLoggedStart = !wasDownloaded
        if modelDownloadLoggedStart {
            logger.info("Model download started", details: "model=\(selection.id)")
        }

        modelDownloadTask?.cancel()
        modelDownloadTask = Task {
            do {
                try await self.ensureRequiredModelsReadyShared(
                    selection, recoverDownloadedModel: wasDownloaded)
                self.handleProgress(DownloadProgress(percent: 100, status: "Ready", phase: .ready))
                self.refreshChatWarmup()
            } catch {
                if isCancellation(error) {
                    return
                }
                if self.modelDownloadLoggedStart {
                    self.logger.error("Model download failed", error)
                    self.modelDownloadLoggedStart = false
                } else {
                    self.logger.error("Model load failed", error)
                }
                await MainActor.run {
                    self.downloadToast = DownloadToastState(
                        phase: wasDownloaded ? .errorLoad : .errorDownload,
                        percent: nil,
                        status: self.userFacingModelReadyError(error, wasDownloaded: wasDownloaded),
                        offerRetryDownload: true
                    )
                    self.isDownloading = false
                    self.isModelDownloaded = false
                }
            }
        }
    }

    func cancelDownload() {
        resetGenerationState(stopRequested: true)
        modelDownloadTask?.cancel()
        modelDownloadTask = nil
        sharedModelReadyTask?.cancel()
        clearSharedModelReadyTask()
        if modelDownloadLoggedStart {
            logger.info("Model download cancelled")
            modelDownloadLoggedStart = false
        }
        hasRequestedModelDownload = false
        clearDownloadProgressMemory()
        refreshModelDownloadInfo()
    }

    func retryDownload() {
        startModelDownload(userInitiated: true)
    }

    func retryAssistantResponse(_ message: RenderedChatMessage) {
        let priorGeneration = generationTask
        let priorSummary = sessionSummaryTask
        guard message.role == .assistant else { return }
        if isGenerating {
            stopGenerating()
        }
        guard !isChatUnsupported else {
            showUnsupportedDeviceDialog = true
            return
        }
        guard let sessionId = currentSessionId else { return }

        let userNode: MessageNode?
        if message.isSynthetic {
            guard let syntheticIndex = messages.firstIndex(where: { $0.id == message.id }),
                syntheticIndex > 0
            else { return }
            let parentMessage = messages[syntheticIndex - 1]
            guard parentMessage.role == .user else { return }
            userNode = messageStore[sessionId]?.first(where: { $0.id == parentMessage.id })
        } else {
            guard
                let parentId = messageStore[sessionId]?.first(where: { $0.id == message.id })?
                    .parentId
            else { return }
            userNode = messageStore[sessionId]?.first(where: { $0.id == parentId })
        }
        guard let userNode else { return }
        voiceTranscriber.interrupt()
        let sourceSnapshot = currentSourceSelection()
        cancelPendingSend()
        priorGeneration?.cancel()
        priorSummary?.cancel()
        provider.stopGeneration()
        Task { [weak self] in
            _ = await priorGeneration?.result
            _ = await priorSummary?.result
            guard let self else { return }
            if !userNode.attachments.contains(where: { $0.kind == .image })
                || provider.supportsImages(modelSettings.currentSelection())
            {
                await provider.resetContext()
            }
            startGeneration(for: userNode, sources: sourceSnapshot)
        }
    }

    func changeBranch(for message: RenderedChatMessage, delta: Int) {
        cancelPendingSend()
        if isGenerating {
            stopGenerating()
        }
        guard let sessionId = currentSessionId else { return }
        guard let node = messageStore[sessionId]?.first(where: { $0.id == message.id }) else {
            return
        }
        let parentKey = node.parentId?.uuidString ?? "__root__"
        let parentId = node.parentId ?? rootId
        let siblings = dedupeSiblings(childrenFor(sessionId: sessionId, parentId: parentId))
        guard !siblings.isEmpty else { return }
        let selectionMap = branchSelections[sessionId] ?? [:]
        let currentId = selectionMap[parentKey] ?? siblings.last?.id
        let currentIndex = siblings.firstIndex { $0.id == currentId } ?? (siblings.count - 1)
        let nextIndex = max(0, min(siblings.count - 1, currentIndex + delta))
        branchSelections[sessionId, default: [:]][parentKey] = siblings[nextIndex].id
        rebuildMessages(for: sessionId)
    }

    private func createSessionForDraft() -> UUID {
        let created = (try? chatDb.createSession(title: "New chat"))
        let sessionId = created.flatMap { UUID(uuidString: $0.uuid) } ?? UUID()
        let updatedAt =
            created.map { Date(timeIntervalSince1970: Double($0.updatedAtUs) / 1_000_000.0) }
            ?? Date()

        logger.info("Session created", details: "id=\(sessionId.uuidString)")
        let session = ChatSession(
            id: sessionId, title: created?.title ?? "New chat", lastMessage: "",
            updatedAt: updatedAt)
        sessions.insert(session, at: 0)
        currentSessionId = session.id
        messageStore[session.id] = []
        branchSelections[session.id] = [:]
        invalidateChildrenCache(for: session.id)
        return session.id
    }

    private func startGeneration(
        for userNode: MessageNode, sources sourceSnapshot: ChatSourceSelection?
    ) {
        guard !isChatUnsupported else {
            showUnsupportedDeviceDialog = true
            return
        }
        cancelChatWarmup(releaseLoadedModel: false)
        let selection = modelSettings.currentSelection()
        let priorGeneration = generationTask
        let priorSummary = sessionSummaryTask
        priorGeneration?.cancel()
        priorSummary?.cancel()
        provider.stopGeneration(invalidatePreparation: true)
        conversationStatus = nil
        stopRequested = false

        if userNode.attachments.contains(where: { $0.kind == .image }),
            !provider.supportsImages(selection)
        {
            resetGenerationState()
            generationErrorMessage = ModelImagesUnsupported().localizedDescription
            rebuildMessages(for: userNode.sessionId)
            return
        }
        let prompt = buildPrompt(text: userNode.text, attachments: userNode.attachments)

        let generationId = UUID()
        activeGenerationId = generationId
        activeGenerationSessionId = userNode.sessionId
        isGenerating = true
        isDownloading = false
        hasRequestedModelDownload = true
        streamingResponse = ""
        streamingParentId = userNode.id
        downloadToast = nil
        seedDownloadProgressMemory()
        rebuildMessages(for: userNode.sessionId)

        let notesScope = notesStore.suspendMaintenance()
        generationTask = Task { [self] in
            defer {
                notesScope.close()
                settleGenerationIfActive(generationId: generationId, sessionId: userNode.sessionId)
                refreshChatWarmup()
            }
            await notesStore.awaitMaintenance()
            _ = await priorGeneration?.result
            _ = await priorSummary?.result
            guard !Task.isCancelled, activeGenerationId == generationId else { return }
            await knowledgeStore.bootstrap()
            await notesStore.bootstrap()
            guard !Task.isCancelled, activeGenerationId == generationId else { return }
            guard let sources = sourceSnapshot ?? currentSourceSelection() else {
                generationErrorMessage = "Couldn’t load sources. Try again."
                return
            }
            var embeddingAssetInvalid = false
            var knowledgeHits: [GroundedExcerpt] = []
            let enabledDatasets = knowledgeStore.readyDatasets.filter {
                sources.includesPack($0.stableId)
            }
            let enabledCollectionIDs = Set(
                notesStore.collections.filter {
                    $0.eligible && sources.includesCollection($0.id)
                }.map(\.id))
            var followup: ConversationFollowup?
            var reloaded: [GroundedExcerpt] = []
            defer { followup?.cancel() }
            do {
                if prompt.imageFiles.isEmpty {
                    let path = buildConversationPath(for: userNode)
                    let pathIds = Set(path)
                    let assistantTexts = (messageStore[userNode.sessionId] ?? [])
                        .filter { pathIds.contains($0.id.uuidString) && $0.role == .assistant }
                        .map { $0.text }
                    followup = try await Task.detached {
                        [chatDb] () throws -> ConversationFollowup? in
                        guard
                            assistantTexts.contains(where: {
                                !parseGroundedAssistantText(storedText: $0).sources.isEmpty
                            })
                        else { return nil }
                        return try chatDb.startConversationFollowup(
                            sessionUuid: userNode.sessionId.uuidString, path: path,
                            question: userNode.text
                        )
                    }.value
                    try Task.checkCancellation()
                    guard activeGenerationId == generationId else { return }
                    if followup != nil { conversationStatus = "Finding sources" }
                }
            } catch {
                guard !isCancellation(error), activeGenerationId == generationId else { return }
                if case ConversationError.Stale = error {
                    generationErrorMessage = "Conversation changed. Retry the message."
                    return
                }
                logger.warning("Source search preparation failed", details: "\(error)")
            }
            let queryText = userNode.text.trimmingCharacters(in: .whitespacesAndNewlines)
            if !queryText.isEmpty,
                (!enabledDatasets.isEmpty
                    || !enabledCollectionIDs.isEmpty)
            {
                do {
                    let hits = try await provider.withRetrievalContext(
                        queryBytes: queryText.utf8.count
                    ) { embed in
                        try Task.checkCancellation()
                        let query = try embed(queryText)
                        try Task.checkCancellation()
                        let packs = await knowledgeProvider.search(
                            datasets: enabledDatasets, query: query,
                            maxHits: knowledgeEmbedding.maxHits
                        )
                        let notes = try await notesStore.retrieve(
                            query: query, collectionIDs: enabledCollectionIDs)
                        let candidates = try selectMixedGroundingCandidates(
                            packHits: packs.map {
                                KnowledgePromptHit(datasetId: $0.dataset.stableId, hit: $0.hit)
                            },
                            notesHits: notes, notesLimit: UInt32(notes.count)
                        )
                        return try await notesStore.verify(candidates)
                    }
                    try Task.checkCancellation()
                    knowledgeHits = hits
                } catch {
                    if isCancellation(error) {
                        return
                    }
                    if error is ModelMemoryUnavailable {
                        guard !Task.isCancelled, activeGenerationId == generationId else { return }
                        generationErrorMessage = error.localizedDescription
                        return
                    }
                    embeddingAssetInvalid = error is EmbeddingAssetInvalidError
                }
            }

            do {
                if let turn = followup {
                    let locators = try await Task.detached { [searched = knowledgeHits] in
                        try turn.searchWithHistory(searched: searched)
                    }.value
                    try Task.checkCancellation()
                    guard activeGenerationId == generationId else { return }
                    for locator in locators {
                        if let hit = try await reloadPassage(
                            locator, datasets: enabledDatasets,
                            collectionIDs: enabledCollectionIDs)
                        {
                            reloaded.append(hit)
                        }
                    }
                }
            } catch {
                guard !isCancellation(error), activeGenerationId == generationId else { return }
                if case ConversationError.Stale = error {
                    generationErrorMessage = "Conversation changed. Retry the message."
                    return
                }
                logger.warning("Source history search failed", details: "\(error)")
                followup?.cancel()
                followup = nil
            }

            do {
                try await self.ensureChatModelReady(selection, loadContext: false)
            } catch {
                if isCancellation(error) {
                    self.sharedModelReadyTask?.cancel()
                    self.clearSharedModelReadyTask()
                    if self.activeGenerationId == generationId {
                        isGenerating = false
                        isDownloading = false
                        streamingParentId = nil
                        downloadToast = nil
                        activeGenerationId = nil
                        activeGenerationSessionId = nil
                    }
                    return
                }
                if self.activeGenerationId == generationId {
                    isGenerating = false
                    isDownloading = false
                    streamingParentId = nil
                    downloadToast = DownloadToastState(
                        phase: .errorDownload,
                        percent: nil,
                        status: self.userFacingModelReadyError(
                            error, wasDownloaded: self.provider.isChatModelReady(selection)),
                        offerRetryDownload: true
                    )
                    activeGenerationId = nil
                    activeGenerationSessionId = nil
                }
                refreshModelDownloadInfo()
                return
            }

            let normalSystemPrompt = systemPrompt()
            var activeCitations: [GroundedSource] = []
            var conversationPrepared = false

            let buffer = OSAllocatedUnfairLock(initialState: StreamingBuffer())
            let uiUpdateInterval: TimeInterval = 0.05

            let onToken: @Sendable (String) -> Void = { token in
                let snapshot = buffer.withLock { state -> String? in
                    state.text.append(token)
                    state.tokenCount += max(1, token.count / 4)
                    let now = Date()
                    if now.timeIntervalSince(state.lastUiUpdate) >= uiUpdateInterval {
                        state.lastUiUpdate = now
                        state.updateTask?.cancel()
                        state.updateTask = nil
                        return state.text
                    }
                    if state.updateTask == nil {
                        state.updateTask = Task { @MainActor [weak self] in
                            do {
                                try await Task.sleep(for: .seconds(uiUpdateInterval))
                            } catch {
                                return
                            }
                            let snapshot = buffer.withLock { state -> String? in
                                guard !Task.isCancelled else { return nil }
                                state.updateTask = nil
                                state.lastUiUpdate = Date()
                                return state.text
                            }
                            guard let self, let snapshot,
                                self.activeGenerationId == generationId
                            else { return }
                            self.streamingResponse = snapshot
                        }
                    }
                    return nil
                }
                if let snapshot {
                    Task { @MainActor in
                        guard self.activeGenerationId == generationId else { return }
                        self.streamingResponse = snapshot
                    }
                }
            }
            let finish:
                @MainActor (
                    Result<GenerationSummary, Error>, ConversationPreparation?, [GroundedSource]
                ) -> Void = {
                    [self]
                    result, preparation, citations in
                    let snapshot = buffer.withLock { $0 }
                    let interrupted: Bool
                    let totalTimeMs: Int64?
                    switch result {
                    case let .success(summary):
                        interrupted = false
                        totalTimeMs = summary.totalTimeMs
                    case let .failure(error):
                        interrupted = true
                        totalTimeMs = nil
                        let wasCancelled = stopRequested || isCancellation(error)
                        if activeGenerationId == generationId && !wasCancelled {
                            let details =
                                "session=\(userNode.sessionId.uuidString) promptLen=\(prompt.text.count) responseLen=\(snapshot.text.count) tokens=\(snapshot.tokenCount)"
                            logger.error("Generation failed", error, details: details)
                            if case ConversationError.CurrentInputTooLarge = error {
                                generationErrorMessage =
                                    "This message is too long for the model, even without earlier messages. Shorten it or split it into smaller messages. Your full text is still available to edit or copy."
                            } else if case let ConversationError.Other(detail) = error {
                                generationErrorMessage = detail
                            } else if case ConversationError.Stale = error {
                                generationErrorMessage = "Conversation changed. Retry the message."
                            } else if error is ModelMemoryUnavailable
                                || error is ModelImagesUnsupported
                            {
                                generationErrorMessage = error.localizedDescription
                            } else {
                                generationErrorMessage = "Response failed. Try again."
                            }
                        }
                    }
                    finishGeneration(
                        parent: userNode, response: snapshot.text, tokenCount: snapshot.tokenCount,
                        totalTimeMs: totalTimeMs, interrupted: interrupted,
                        generationId: generationId, citations: citations,
                        preparation: preparation)
                }
            do {
                if prompt.imageFiles.isEmpty {
                    try await self.generatePreparedChat(
                        selection,
                        request: ConversationRequest(
                            sessionUuid: userNode.sessionId.uuidString,
                            path: self.buildConversationPath(for: userNode),
                            system: normalSystemPrompt,
                            current: prompt.text,
                            expectedUserText: userNode.text,
                            historyQuery: userNode.text,
                            maxTokens: nil,
                            searched: knowledgeHits,
                            followup: followup,
                            reloaded: reloaded
                        ),
                        temperature: self.resolveTemperature(),
                        onProgress: {
                            guard self.activeGenerationId == generationId,
                                !conversationPrepared
                            else { return }
                            self.conversationStatus = "Remembering earlier messages"
                        },
                        onPrepared: { prepared in
                            guard self.activeGenerationId == generationId else {
                                prepared.cancel()
                                return
                            }
                            conversationPrepared = true
                            self.conversationStatus = nil
                        },
                        onFinished: { result, preparation in finish(result, preparation, []) },
                        onToken: onToken
                    )
                } else {
                    let result = try await generateImageChat(
                        selection, parent: userNode, prompt: prompt,
                        knowledgeHits: knowledgeHits, systemPrompt: normalSystemPrompt,
                        onCitations: { activeCitations = $0 },
                        hasOutput: { buffer.withLock { !$0.text.isEmpty } }, onToken: onToken
                    )
                    switch result {
                    case let .generated(summary):
                        finish(.success(summary), nil, activeCitations)
                    case let .overflow(inputTokens, inputBudget, limits):
                        overflowBypassMessageId = nil
                        pendingOverflow = PendingOverflow(
                            sessionId: userNode.sessionId, messageId: userNode.id,
                            sources: sources)
                        activeGenerationId = nil
                        activeGenerationSessionId = nil
                        isGenerating = false
                        isDownloading = false
                        streamingResponse = ""
                        streamingParentId = nil
                        overflowAlert = OverflowAlertState(
                            inputTokens: inputTokens, inputBudget: inputBudget,
                            contextLength: limits.contextLength, maxOutput: limits.maxOutput)
                        rebuildMessages(for: userNode.sessionId)
                        if embeddingAssetInvalid { refreshModelDownloadInfo() }
                        return
                    }
                }
            } catch {
                if activeGenerationId == generationId { refreshModelDownloadInfo() }
                finish(.failure(error), nil, activeCitations)
            }
            if embeddingAssetInvalid {
                refreshModelDownloadInfo()
            }
        }
    }

    private enum ImageChatResult {
        case generated(GenerationSummary)
        case overflow(inputTokens: Int, inputBudget: Int, GenerationLimits)
    }

    private func generateImageChat(
        _ selection: LlmModelSelection,
        parent: MessageNode,
        prompt: PromptResult,
        knowledgeHits: [GroundedExcerpt],
        systemPrompt: String,
        onCitations: @escaping @MainActor ([GroundedSource]) -> Void,
        hasOutput: @escaping @Sendable () -> Bool,
        onToken: @escaping @Sendable (String) -> Void
    ) async throws -> ImageChatResult {
        guard provider.supportsImages(selection) else { throw ModelImagesUnsupported() }
        return try await provider.withConversationContext(
            selection,
            onProgress: { progress in
                Task { @MainActor in self.handleProgress(progress) }
            }
        ) { context, control in
            let contextLength = Int(context.contextSize())
            let limits = GenerationLimits(
                contextLength: contextLength,
                maxOutput: resolveMaxOutputTokens(contextLength: contextLength))
            let normalHistory = buildHistorySelection(
                sessionId: parent.sessionId, promptText: prompt.text,
                promptImageCount: prompt.imageFiles.count, currentMessageId: parent.id,
                limits: limits, systemPrompt: systemPrompt)
            if normalHistory.wasTrimmed && overflowBypassMessageId != parent.id {
                return .overflow(
                    inputTokens: normalHistory.inputTokens,
                    inputBudget: normalHistory.inputBudget, limits)
            }
            overflowBypassMessageId = nil
            pendingOverflow = nil
            overflowAlert = nil

            let remainingKnowledgeBytes = max(
                0, (normalHistory.inputBudget - normalHistory.inputTokens) * 4 - 2)
            let knowledgeContext = try? buildGroundedPromptContext(
                excerpts: knowledgeHits,
                maxUtf8Bytes: UInt32(
                    min(Int(knowledgeEmbedding.maxContextUtf8Bytes), remainingKnowledgeBytes)))
            let candidateSystem = knowledgeContext.map { "\(systemPrompt)\n\n\($0.text)" }
            let knowledgeHistory = candidateSystem.map {
                buildHistorySelection(
                    sessionId: parent.sessionId, promptText: prompt.text,
                    promptImageCount: prompt.imageFiles.count, currentMessageId: parent.id,
                    limits: limits, systemPrompt: $0)
            }
            let useKnowledge = knowledgeHistory?.wasTrimmed == false
            let history = useKnowledge ? (knowledgeHistory ?? normalHistory) : normalHistory
            let citations = useKnowledge ? (knowledgeContext?.sources ?? []) : []
            onCitations(citations)
            let user = LlmMessage(
                text: prompt.text, role: .user, hasAttachments: !parent.attachments.isEmpty)
            let effectiveSystem = useKnowledge ? (candidateSystem ?? systemPrompt) : systemPrompt
            let messages =
                [LlmMessage(text: effectiveSystem, role: .system, hasAttachments: false)]
                + history.messages + [user]

            let generate: @MainActor ([LlmMessage]) async throws -> GenerationSummary = {
                messages in
                try control.checkCancellation()
                return try await self.provider.generatePreparedChat(
                    selection,
                    messages: messages.map {
                        LlmChatMessage(role: $0.role.roleString, content: $0.text)
                    },
                    imageFiles: prompt.imageFiles, temperature: self.resolveTemperature(),
                    maxTokens: UInt32(limits.maxOutput), control: control, onToken: onToken)
            }
            do {
                return .generated(try await generate(messages))
            } catch {
                guard case LlmError.PromptTooLong = error, !hasOutput(), !citations.isEmpty else {
                    throw error
                }
                let fallback =
                    [LlmMessage(text: systemPrompt, role: .system, hasAttachments: false)]
                    + normalHistory.messages + [user]
                onCitations([])
                return .generated(try await generate(fallback))
            }
        }
    }

    private func generatePreparedChat(
        _ selection: LlmModelSelection,
        request: ConversationRequest,
        temperature: Float,
        onProgress: @escaping @MainActor () -> Void,
        onPrepared: @escaping @MainActor (ConversationPreparation) -> Void,
        onFinished:
            @escaping @MainActor (Result<GenerationSummary, Error>, ConversationPreparation) ->
            Void,
        onToken: @escaping @Sendable (String) -> Void
    ) async throws {
        let db = chatDb
        try await provider.withConversationContext(
            selection,
            onProgress: { progress in
                Task { @MainActor in self.handleProgress(progress) }
            }
        ) { context, control in
            let preparation = try await Task.detached {
                try control.checkCancellation()
                return try db.prepareConversation(context: context, input: request)
            }.value
            control.setPreparationCancellation { preparation.cancel() }
            try control.checkCancellation()
            let sink = ConversationProgressSink {
                Task { @MainActor in onProgress() }
            }
            let result = try await Task.detached {
                try control.checkCancellation()
                return try preparation.run(callback: sink)
            }.value
            try control.beginAnswer()
            onPrepared(preparation)
            do {
                try await Task.detached { try preparation.validate() }.value
                try control.checkCancellation()
                let summary = try await self.provider.generatePreparedChat(
                    selection,
                    messages: result.messages,
                    temperature: temperature,
                    maxTokens: result.maxTokens,
                    control: control,
                    onToken: onToken
                )
                onFinished(.success(summary), preparation)
            } catch {
                onFinished(.failure(error), preparation)
            }
        }
    }

    private func reloadPassage(
        _ locator: PassageLocator, datasets: [KnowledgeDatasetConfig],
        collectionIDs: Set<String>
    ) async throws -> GroundedExcerpt? {
        do {
            switch locator {
            case .ensuPack:
                return try await knowledgeProvider.reload(
                    locator, datasets: datasets)
            case .localNote(let note):
                return try await notesStore.reload(note, collectionIDs: collectionIDs)
            }
        } catch {
            if isCancellation(error) { throw error }
            logger.warning("Source reload failed", details: "\(error)")
            return nil
        }
    }

    private func finishGeneration(
        parent: MessageNode, response: String, tokenCount: Int, totalTimeMs: Int64?,
        interrupted: Bool, generationId: UUID, citations: [GroundedSource] = [],
        preparation: ConversationPreparation? = nil
    ) {
        let rawText = response.trimmingCharacters(in: .whitespacesAndNewlines)
        let trimmed: String
        if rawText.isEmpty || preparation != nil {
            trimmed = rawText
        } else {
            do {
                trimmed = try finalizeGroundedAssistantText(
                    rawAssistantText: rawText,
                    sources: citations
                )
            } catch {
                logger.error("Assistant source finalization failed", error)
                trimmed =
                    (try? finalizeGroundedAssistantText(
                        rawAssistantText: rawText,
                        sources: []
                    )) ?? ""
            }
        }
        let isActiveGeneration = activeGenerationId == generationId
        if trimmed.isEmpty {
            if isActiveGeneration && !interrupted && generationErrorMessage == nil {
                let details =
                    "session=\(parent.sessionId.uuidString) promptLen=\(parent.text.count)"
                logger.warning("Generation returned empty response", details: details)
                generationErrorMessage = "No response from model. Try again."
            }
        } else {
            let tokensPerSecond: Double? = {
                guard let totalTimeMs, totalTimeMs > 0 else { return nil }
                return Double(tokenCount) / (Double(totalTimeMs) / 1000.0)
            }()

            if isActiveGeneration {
                let meta: [DbAttachmentMeta] = []
                do {
                    let inserted: DbMessage
                    if let preparation {
                        inserted = try preparation.addAnswer(text: trimmed, attachments: meta)
                    } else {
                        inserted = try chatDb.insertMessage(
                            sessionUuid: parent.sessionId.uuidString,
                            sender: .other,
                            text: trimmed,
                            parentMessageUuid: parent.id.uuidString,
                            attachments: meta
                        )
                    }

                    if let assistantId = UUID(uuidString: inserted.uuid) {
                        logger.info(
                            "Message created",
                            details:
                                "id=\(assistantId.uuidString) session=\(parent.sessionId.uuidString) role=assistant"
                        )
                        let timestamp = Date(
                            timeIntervalSince1970: Double(inserted.createdAtUs) / 1_000_000.0)
                        let assistant = MessageNode(
                            id: assistantId,
                            sessionId: parent.sessionId,
                            parentId: parent.id,
                            role: .assistant,
                            text: inserted.text,
                            timestamp: timestamp,
                            attachments: [],
                            isInterrupted: interrupted,
                            tokensPerSecond: tokensPerSecond
                        )

                        messageStore[parent.sessionId, default: []].append(assistant)
                        invalidateChildrenCache(for: parent.sessionId)
                        updateSelection(
                            for: parent.sessionId, parentId: parent.id, childId: assistant.id)
                        updateSessionPreview(
                            sessionId: parent.sessionId,
                            preview: cleanAssistantText(storedText: inserted.text),
                            date: assistant.timestamp)
                    } else {
                        logger.warning(
                            "Skipping assistant message persistence",
                            details:
                                "session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted) reason=invalid_uuid"
                        )
                    }
                } catch {
                    if preparation != nil {
                        generationErrorMessage =
                            "The response could not be saved. Retry the message."
                    }
                    logger.warning(
                        "Skipping assistant message persistence",
                        details:
                            "session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted) error=\(error)"
                    )
                }
            } else {
                logger.info(
                    "Dropped stale generation response",
                    details:
                        "session=\(parent.sessionId.uuidString) parent=\(parent.id.uuidString) interrupted=\(interrupted)"
                )
            }
        }

        if isActiveGeneration {
            conversationStatus = nil
            isGenerating = false
            isDownloading = false
            streamingResponse = ""
            streamingParentId = nil
            downloadToast = nil
            activeGenerationId = nil
            activeGenerationSessionId = nil
        }

        if currentSessionId == parent.sessionId {
            rebuildMessages(for: parent.sessionId)
        }
        if isActiveGeneration {
            scheduleSessionSummary(for: parent.sessionId)
        }
    }

    private func settleGenerationIfActive(generationId: UUID, sessionId: UUID) {
        guard activeGenerationId == generationId, isGenerating else { return }
        conversationStatus = nil
        isGenerating = false
        isDownloading = false
        streamingResponse = ""
        streamingParentId = nil
        downloadToast = nil
        activeGenerationId = nil
        activeGenerationSessionId = nil
        rebuildMessages(for: sessionId)
    }

    private func handleProgress(_ progress: DownloadProgress) {
        let resolvedProgress = downloadProgressTracker.resolve(progress)

        if resolvedProgress.isLoading {
            downloadToast = DownloadToastState(
                phase: .loading,
                percent: resolvedProgress.percent ?? progress.percent,
                status: resolvedProgress.status,
                offerRetryDownload: false
            )
            isDownloading = true
            return
        }

        if resolvedProgress.isReady {
            if modelDownloadLoggedStart {
                logger.info("Model download complete", details: progress.status)
                modelDownloadLoggedStart = false
            }
            downloadToast = DownloadToastState(
                phase: .ready, percent: 100, status: progress.status, offerRetryDownload: false)
            isDownloading = false
            isModelDownloaded = provider.isModelDownloaded(modelSettings.currentSelection())
            modelDownloadSizeBytes = nil
            clearDownloadProgressMemory()
            Task { @MainActor in
                try? await Task.sleep(nanoseconds: 1_500_000_000)
                if self.downloadToast?.phase == .ready {
                    self.downloadToast = nil
                }
            }
            return
        }

        downloadToast = DownloadToastState(
            phase: .downloading,
            percent: resolvedProgress.percent ?? 0,
            status: resolvedProgress.status,
            offerRetryDownload: false
        )
        isDownloading = true
    }

    private nonisolated static func buildSessions(
        from loaded: [DbSession],
        chatDb: EnsuDb,
        summaries: [String: String]
    ) -> [ChatSession] {
        let sessions: [ChatSession] = loaded.compactMap { session in
            guard let id = UUID(uuidString: session.uuid) else { return nil }
            let messages = (try? chatDb.getMessages(sessionUuid: session.uuid)) ?? []
            let sortedMessages = messages.sorted { $0.createdAtUs < $1.createdAtUs }
            let firstUserMessage =
                sortedMessages.first(where: { $0.sender == .selfUser })?.text ?? ""
            let lastMessageNode = sortedMessages.last
            let lastMessage =
                lastMessageNode.map { message in
                    message.sender == .other
                        ? cleanAssistantText(storedText: message.text) : message.text
                } ?? ""
            let summary = summaries[session.uuid.lowercased()]
            let isPlaceholderTitle =
                session.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
                || session.title.caseInsensitiveCompare("New chat") == .orderedSame
            let seedTitle = summary ?? (isPlaceholderTitle ? firstUserMessage : session.title)
            let title = Self.sessionTitle(from: seedTitle, fallback: session.title)
            let updatedAtUs = lastMessageNode?.createdAtUs ?? session.updatedAtUs
            return ChatSession(
                id: id,
                title: title,
                lastMessage: lastMessage,
                updatedAt: Date(timeIntervalSince1970: Double(updatedAtUs) / 1_000_000.0)
            )
        }
        return sessions.sorted { $0.updatedAt > $1.updatedAt }
    }

    private func reloadFromDb() {
        reloadTask?.cancel()
        reopenChatStoreIfNeeded()
        let chatDb = chatDb
        let summaries = sessionSummaries
        let selected = currentSessionId

        reloadTask = Task.detached { [weak self, chatDb, summaries, selected] in
            let loaded = (try? chatDb.listSessions()) ?? []
            let refreshed = Self.buildSessions(from: loaded, chatDb: chatDb, summaries: summaries)

            let resolved =
                selected.flatMap { id in
                    refreshed.first(where: { $0.id == id })?.id
                } ?? (selected == nil ? nil : refreshed.first?.id)

            if Task.isCancelled { return }

            await MainActor.run {
                guard let self else { return }
                if Task.isCancelled { return }

                let previousSessionId = self.currentSessionId
                let shouldPreserveMessages = resolved == previousSessionId && !self.messages.isEmpty
                let preservedMessages = self.messages
                let preservedMessageStore = self.messageStore
                let preservedBranchSelections = self.branchSelections

                self.sessions = refreshed
                self.currentSessionId = resolved
                self.messageStore = [:]
                self.branchSelections = [:]
                self.childrenByParentCache = [:]

                for session in refreshed {
                    if shouldPreserveMessages, session.id == resolved,
                        let nodes = preservedMessageStore[session.id]
                    {
                        self.messageStore[session.id] = nodes
                        self.branchSelections[session.id] =
                            preservedBranchSelections[session.id] ?? [:]
                    } else {
                        self.messageStore[session.id] = []
                        self.branchSelections[session.id] = [:]
                    }
                }

                if shouldPreserveMessages {
                    self.messages = preservedMessages
                } else {
                    self.messages = []
                }

                if let current = resolved {
                    self.loadMessagesFromDb(for: current)
                }
            }
        }
    }

    private func loadMessagesFromDb(for sessionId: UUID) {
        reopenChatStoreIfNeeded()
        if messageStore[sessionId] == nil {
            messageStore[sessionId] = []
            branchSelections[sessionId] = [:]
        }

        let chatDb = chatDb
        let attachmentsDir = attachmentsDir

        Task.detached { [weak self, chatDb, attachmentsDir] in
            guard let self else { return }

            let rawMessages = (try? chatDb.getMessages(sessionUuid: sessionId.uuidString)) ?? []

            let nodes: [MessageNode] = rawMessages.compactMap { msg in
                guard let messageId = UUID(uuidString: msg.uuid) else { return nil }
                let parentId = msg.parentMessageUuid.flatMap { UUID(uuidString: $0) }
                let role: RenderedChatMessage.Role = (msg.sender == .selfUser) ? .user : .assistant
                let timestamp = Date(timeIntervalSince1970: Double(msg.createdAtUs) / 1_000_000.0)

                let attachments: [ChatAttachment] = msg.attachments.compactMap { meta in
                    guard let attachmentId = UUID(uuidString: meta.id) else { return nil }
                    let kind: ChatAttachment.Kind = (meta.kind == .image) ? .image : .document
                    let file = attachmentsDir.appendingPathComponent(meta.id)
                    return ChatAttachment(
                        id: attachmentId,
                        name: meta.name,
                        size: meta.size,
                        kind: kind,
                        url: FileManager.default.fileExists(atPath: file.path) ? file : nil,
                        isUploading: false
                    )
                }

                return MessageNode(
                    id: messageId,
                    sessionId: sessionId,
                    parentId: parentId,
                    role: role,
                    text: msg.text,
                    timestamp: timestamp,
                    attachments: attachments,
                    isInterrupted: false,
                    tokensPerSecond: nil
                )
            }

            await MainActor.run {
                guard self.messageStore[sessionId] != nil else { return }
                self.messageStore[sessionId] = nodes
                // Branch selection is computed in-memory.
                self.branchSelections[sessionId] = [:]
                self.invalidateChildrenCache(for: sessionId)
                if self.currentSessionId == sessionId {
                    self.rebuildMessages(for: sessionId)
                }
            }
        }
    }

    private func rebuildMessages(for sessionId: UUID) {
        let childrenMap = childrenByParent(sessionId: sessionId)
        let path = buildSelectedPath(for: sessionId, childrenMap: childrenMap)
        let selectionMap = branchSelections[sessionId, default: [:]]

        messages = path.map { node in
            let parentKey = node.parentId?.uuidString ?? "__root__"
            let parentId = node.parentId ?? rootId
            let siblings = dedupeSiblings(childrenMap[parentId] ?? [])
            let selectedId = selectionMap[parentKey]
            let index = siblings.firstIndex { $0.id == selectedId } ?? (siblings.count - 1)

            return RenderedChatMessage(
                id: node.id,
                role: node.role,
                text: node.text,
                timestamp: node.timestamp,
                attachments: node.attachments,
                isInterrupted: node.isInterrupted,
                isSynthetic: false,
                tokensPerSecond: node.tokensPerSecond,
                branchIndex: max(1, index + 1),
                branchCount: max(1, siblings.count)
            )
        }

        var augmented: [RenderedChatMessage] = []
        for (i, msg) in messages.enumerated() {
            augmented.append(msg)
            if msg.role == .user {
                let next = i + 1 < messages.count ? messages[i + 1] : nil
                let isLastAndGenerating = i == messages.count - 1 && isGenerating
                if next?.role != .assistant && !isLastAndGenerating {
                    augmented.append(
                        RenderedChatMessage(
                            id: deterministicSyntheticMessageId(parentId: msg.id),
                            role: .assistant,
                            text: "Response was interrupted",
                            timestamp: msg.timestamp,
                            isInterrupted: true,
                            isSynthetic: true
                        ))
                }
            }
        }
        messages = augmented
    }

    private func deterministicSyntheticMessageId(parentId: UUID) -> UUID {
        var uuid = parentId.uuid
        uuid.0 ^= 0xA5
        uuid.15 ^= 0x5A
        return UUID(uuid: uuid)
    }

    private func buildConversationPath(for target: MessageNode) -> [String] {
        let byId = Dictionary(
            uniqueKeysWithValues: (messageStore[target.sessionId] ?? []).map { ($0.id, $0) })
        var path: [String] = []
        var visited = Set<UUID>()
        var current: MessageNode? = target
        while let node = current, visited.insert(node.id).inserted {
            path.append(node.id.uuidString)
            current = node.parentId.flatMap { byId[$0] }
        }
        return path.reversed()
    }

    private func buildSelectedPath(for sessionId: UUID, childrenMap: [UUID: [MessageNode]])
        -> [MessageNode]
    {
        guard let nodes = messageStore[sessionId], !nodes.isEmpty else { return [] }
        let byId = Dictionary(uniqueKeysWithValues: nodes.map { ($0.id, $0) })
        let roots = dedupeSiblings(
            nodes.filter { node in
                guard let parentId = node.parentId else { return true }
                return byId[parentId] == nil
            })
        guard !roots.isEmpty else { return [] }

        let selectionMap = branchSelections[sessionId, default: [:]]
        var current = selectChild(
            selectionMap: selectionMap, selectionKey: "__root__", candidates: roots)
        var path: [MessageNode] = []
        var visited = Set<UUID>()

        while let node = current, visited.insert(node.id).inserted {
            path.append(node)
            if node.id == streamingParentId { break }
            let children = dedupeSiblings(childrenMap[node.id] ?? [])
            if children.isEmpty { break }
            current = selectChild(
                selectionMap: selectionMap, selectionKey: node.id.uuidString, candidates: children)
        }
        return path
    }

    private func selectChild(
        selectionMap: [String: UUID], selectionKey: String, candidates: [MessageNode]
    ) -> MessageNode? {
        guard !candidates.isEmpty else { return nil }
        if let selectedId = selectionMap[selectionKey],
            let selected = candidates.first(where: { $0.id == selectedId })
        {
            return selected
        }
        return candidates.last
    }

    private func invalidateChildrenCache(for sessionId: UUID) {
        childrenByParentCache[sessionId] = nil
    }

    private func childrenByParent(sessionId: UUID) -> [UUID: [MessageNode]] {
        if let cached = childrenByParentCache[sessionId] {
            return cached
        }
        var map: [UUID: [MessageNode]] = [:]
        guard let nodes = messageStore[sessionId] else { return map }
        let byId = Dictionary(uniqueKeysWithValues: nodes.map { ($0.id, $0) })
        for node in nodes {
            let parent = node.parentId.flatMap { byId[$0] != nil ? $0 : nil } ?? rootId
            map[parent, default: []].append(node)
        }
        childrenByParentCache[sessionId] = map
        return map
    }

    private func childrenFor(sessionId: UUID, parentId: UUID) -> [MessageNode] {
        let map = childrenByParent(sessionId: sessionId)
        return map[parentId] ?? []
    }

    private func dedupeSiblings(_ nodes: [MessageNode]) -> [MessageNode] {
        guard nodes.count > 1 else { return nodes.sorted(by: { $0.timestamp < $1.timestamp }) }
        let sorted = nodes.sorted(by: { $0.timestamp < $1.timestamp })
        var result: [MessageNode] = []
        for node in sorted {
            if let last = result.last, isDuplicate(last, node) {
                continue
            }
            result.append(node)
        }
        return result
    }

    private func isDuplicate(_ lhs: MessageNode, _ rhs: MessageNode) -> Bool {
        guard lhs.role == rhs.role else { return false }
        guard lhs.text == rhs.text else { return false }
        guard attachmentSignature(lhs.attachments) == attachmentSignature(rhs.attachments) else {
            return false
        }
        return abs(lhs.timestamp.timeIntervalSince(rhs.timestamp)) <= 2
    }

    private func attachmentSignature(_ attachments: [ChatAttachment]) -> [String] {
        attachments.map { "\($0.kind)-\($0.name)" }
    }

    private func updateSelection(for sessionId: UUID, parentId: UUID?, childId: UUID) {
        let key = parentId?.uuidString ?? "__root__"
        branchSelections[sessionId, default: [:]][key] = childId
    }

    private func updateSessionPreview(sessionId: UUID, preview: String, date: Date) {
        sessions = sessions.map { session in
            guard session.id == sessionId else { return session }
            var updated = session
            let isPlaceholderTitle =
                session.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
                || session.title.caseInsensitiveCompare("New chat") == .orderedSame
            if isPlaceholderTitle {
                let updatedTitle = Self.sessionTitle(from: preview, fallback: session.title)
                if updatedTitle != session.title {
                    _ = try? chatDb.updateSessionTitle(
                        uuid: sessionId.uuidString, title: updatedTitle)
                }
                updated.title = updatedTitle
            }
            updated.lastMessage = preview
            updated.updatedAt = date
            return updated
        }
    }

    private func scheduleSessionSummary(for sessionId: UUID) {
        guard !isChatUnsupported else { return }
        sessionSummaryTask?.cancel()
        let summaryKey = sessionSummaryKey(sessionId)
        guard sessionSummaries[summaryKey] == nil else { return }
        guard let summaryInput = buildSessionSummaryInput(sessionId: sessionId) else { return }
        let existingSummary = sessionSummaries[summaryKey]
        let selection = modelSettings.currentSelection()
        let provider = provider

        let notes = notesStore
        let notesScope = notes.suspendMaintenance()
        sessionSummaryTask = Task.detached(priority: .utility) { [weak self] in
            defer { notesScope.close() }
            await notes.awaitMaintenance()
            guard let self else { return }
            do {
                try await Task.sleep(nanoseconds: 200_000_000)
            } catch {
                return
            }
            guard !Task.isCancelled else { return }

            let summary = await Self.generateSessionSummary(
                input: summaryInput.text,
                fallback: summaryInput.fallback,
                existingSummary: existingSummary,
                provider: provider,
                selection: selection
            )
            guard !Task.isCancelled, let summary else { return }

            await MainActor.run {
                self.applySessionSummary(sessionId: sessionId, summary: summary)
            }
        }
    }

    private func buildSessionSummaryInput(sessionId: UUID) -> (text: String, fallback: String)? {
        guard let nodes = messageStore[sessionId], !nodes.isEmpty else { return nil }
        let sorted = nodes.sorted(by: { $0.timestamp < $1.timestamp })
        guard let firstUser = sorted.first(where: { $0.role == .user }) else { return nil }
        let input = "User: \(firstUser.text)"
        let fallback = Self.summarizeQuestion(firstUser.text)
        return (text: input, fallback: fallback)
    }

    private func applySessionSummary(sessionId: UUID, summary: String) {
        let sanitized = Self.sessionTitle(from: summary, fallback: "New chat")
        guard !sanitized.isEmpty else { return }
        let summaryKey = sessionSummaryKey(sessionId)
        if sessionSummaries[summaryKey] == sanitized { return }
        sessionSummaries[summaryKey] = sanitized
        persistSessionSummaries()
        _ = try? chatDb.updateSessionTitle(uuid: sessionId.uuidString, title: sanitized)
        sessions = sessions.map { session in
            guard session.id == sessionId else { return session }
            var updated = session
            updated.title = sanitized
            return updated
        }
    }

    private func persistSessionSummaries() {
        guard let data = try? JSONEncoder().encode(sessionSummaries) else { return }
        UserDefaults.standard.set(data, forKey: Self.sessionSummaryStoreKey)
    }

    private func sessionSummaryKey(_ id: UUID) -> String {
        id.uuidString.lowercased()
    }

    private func sessionSummaryKey(_ id: String) -> String {
        id.lowercased()
    }

    private static func loadSessionSummaries() -> [String: String] {
        guard let data = UserDefaults.standard.data(forKey: Self.sessionSummaryStoreKey) else {
            return [:]
        }
        return (try? JSONDecoder().decode([String: String].self, from: data)) ?? [:]
    }

    private static func summarizeQuestion(_ text: String) -> String {
        let cleaned = sanitizeTitleText(text)
        guard !cleaned.isEmpty else { return "" }
        let words = cleaned.split(separator: " ").map {
            String($0).trimmingCharacters(in: .punctuationCharacters)
        }.filter { !$0.isEmpty }
        guard !words.isEmpty else { return "" }
        let summaryWords = words.prefix(Self.sessionSummaryMaxWords)
        return summaryWords.joined(separator: " ")
    }

    private nonisolated static func sanitizeTitleText(_ text: String) -> String {
        text
            .replacingOccurrences(of: "[\\r\\n\\t]+", with: " ", options: .regularExpression)
            .replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression)
            .trimmingCharacters(in: .whitespacesAndNewlines)
    }

    nonisolated static func sessionTitle(from text: String, fallback: String = "New chat") -> String
    {
        let trimmed = sanitizeTitleText(text)
        guard !trimmed.isEmpty else { return fallback }
        if trimmed.count <= Self.sessionTitleMaxLength {
            return trimmed
        }
        let prefix = trimmed.prefix(Self.sessionTitleMaxLength)
        return String(prefix).trimmingCharacters(in: .whitespacesAndNewlines) + "…"
    }

    private static func generateSessionSummary(
        input: String,
        fallback: String,
        existingSummary: String?,
        provider: LlmProvider,
        selection: LlmModelSelection
    ) async -> String? {
        if let existingSummary, !existingSummary.isEmpty { return nil }
        let cleanedInput = sanitizeTitleText(input)
        guard !cleanedInput.isEmpty else { return sessionTitle(from: fallback, fallback: fallback) }

        let messages = [
            LlmMessage(text: sessionSummarySystemPrompt, role: .system, hasAttachments: false),
            LlmMessage(text: cleanedInput, role: .user, hasAttachments: false),
        ]

        let buffer = OSAllocatedUnfairLock(initialState: "")

        do {
            try await provider.generateTitle(
                selection,
                messages: messages
            ) { token in
                buffer.withLock { $0.append(token) }
            }
        } catch {
            let fallbackSummary = summarizeQuestion(fallback)
            return fallbackSummary.isEmpty
                ? nil : sessionTitle(from: fallbackSummary, fallback: fallback)
        }

        let raw = sanitizeTitleText(buffer.withLock { $0 })
        guard !raw.isEmpty else { return sessionTitle(from: fallback, fallback: fallback) }
        let words = raw.split(separator: " ").map { String($0) }.filter { !$0.isEmpty }
        guard !words.isEmpty else { return nil }
        let summaryWords = words.prefix(Self.sessionSummaryMaxWords)
        let summary = summaryWords.joined(separator: " ")
        return sessionTitle(from: summary, fallback: fallback)
    }

    private func isCancellation(_ error: Error) -> Bool {
        if error is CancellationError { return true }
        if case LlmError.Cancelled = error { return true }
        if case ConversationError.Cancelled = error { return true }
        if case AssetDownloadError.Cancelled = error { return true }
        return (error as? URLError)?.code == .cancelled
    }

    private func seedDownloadProgressMemory() {
        downloadProgressTracker.seed(from: downloadToast)
    }

    private func clearDownloadProgressMemory() {
        downloadProgressTracker.clear()
    }

    private func shouldRetryModelDownload(_ error: Error, retryCount: Int) -> Bool {
        if retryCount >= 5 { return false }
        if isCancellation(error) { return false }
        if isOutOfStorageError(error) { return false }
        if error is RequiredModelValidationError {
            return false
        }

        switch error {
        case AssetDownloadError.Validation:
            return false
        case let AssetDownloadError.Http(_, retryable):
            return retryable
        default:
            break
        }

        return true
    }

    private func retryDelayNanoseconds(for retryCount: Int) -> UInt64 {
        let shift = max(0, retryCount - 1)
        let multiplier = UInt64(1 << shift)
        let delayMs = min(12_000, 1_500 * Int(multiplier))
        return UInt64(delayMs) * 1_000_000
    }

    private func userFacingModelReadyError(_ error: Error, wasDownloaded: Bool) -> String {
        if error is UnsupportedDeviceMemoryError {
            return Self.unsupportedDeviceMessage
        }
        if isOutOfStorageError(error) {
            return
                "Not enough storage space to download the model. Please free up space and try again."
        }
        return wasDownloaded ? "Model load failed" : "Download failed. Please try again."
    }

    private func isOutOfStorageError(_ error: Error) -> Bool {
        if case AssetDownloadError.StorageFull = error { return true }
        return error.isOutOfDiskSpace
    }

    private nonisolated func attachmentsDirectory() throws -> URL {
        let base =
            FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
            ?? FileManager.default.temporaryDirectory
        let dir = base.appendingPathComponent("llmchat", isDirectory: true)
            .appendingPathComponent("chat_attachments", isDirectory: true)
        try FileManager.default.createDirectory(
            at: dir, withIntermediateDirectories: true, attributes: nil)
        return dir
    }

    private nonisolated func writeAttachment(data: Data, attachmentId: UUID) throws -> URL {
        let dir = try attachmentsDirectory()
        let destination = dir.appendingPathComponent(attachmentId.uuidString.lowercased())
        try data.write(to: destination, options: .atomic)
        return destination
    }

    private nonisolated func copyAttachment(from url: URL, attachmentId: UUID) throws -> URL {
        let dir = try attachmentsDirectory()
        let destination = dir.appendingPathComponent(attachmentId.uuidString.lowercased())

        let needsSecurity = url.startAccessingSecurityScopedResource()
        defer {
            if needsSecurity {
                url.stopAccessingSecurityScopedResource()
            }
        }

        if FileManager.default.fileExists(atPath: destination.path) {
            try FileManager.default.removeItem(at: destination)
        }
        try FileManager.default.copyItem(at: url, to: destination)
        return destination
    }

    private struct HistorySelection {
        let messages: [LlmMessage]
        let inputTokens: Int
        let inputBudget: Int
        let wasTrimmed: Bool
    }

    private struct GenerationLimits {
        let contextLength: Int
        let maxOutput: Int
    }

    private struct PendingOverflow {
        let sessionId: UUID
        let messageId: UUID
        let sources: ChatSourceSelection
    }

    private func buildPrompt(text: String, attachments: [ChatAttachment]) -> PromptResult {
        var prompt = text
        let documents = attachments.filter { $0.kind == .document }
        let images = attachments.filter { $0.kind == .image }
        let imageFiles = images.compactMap { $0.url }

        if !imageFiles.isEmpty && text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
            prompt = "Describe the attached images."
        }

        for (index, attachment) in documents.enumerated() {
            prompt += "\n\n----- BEGIN DOCUMENT: Document \(index + 1) -----\n"
            prompt += "Attached document: \(attachment.name)\n"
            prompt += "----- END DOCUMENT: Document \(index + 1) -----"
        }

        if !imageFiles.isEmpty {
            let mediaMarker = "<__media__>"
            prompt += "\n\n[\(imageFiles.count) image attachment"
            if imageFiles.count > 1 { prompt += "s" }
            prompt += " provided]"
            for _ in imageFiles {
                prompt += "\n\(mediaMarker)"
            }
        }

        return PromptResult(text: prompt, imageFiles: imageFiles)
    }

    private func buildHistorySelection(
        sessionId: UUID,
        promptText: String,
        promptImageCount: Int,
        currentMessageId: UUID,
        limits: GenerationLimits,
        systemPrompt: String
    ) -> HistorySelection {
        let childrenMap = childrenByParent(sessionId: sessionId)
        let path = buildSelectedPath(for: sessionId, childrenMap: childrenMap)
        let historyMessages = path.prefix { $0.id != currentMessageId }

        let inputBudget = max(
            0, limits.contextLength - limits.maxOutput - Self.overflowSafetyTokens)
        let systemTokens = estimateTokens(systemPrompt)
        let promptTokens = estimatePromptTokens(
            promptText: promptText, imageCount: promptImageCount)
        let historyTokens = historyMessages.reduce(0) { total, node in
            total + estimateTokens(historyText(node))
        }
        let inputTokens = systemTokens + promptTokens + historyTokens
        let remaining = inputBudget - systemTokens - promptTokens

        if remaining <= 0 || historyMessages.isEmpty {
            return HistorySelection(
                messages: [], inputTokens: inputTokens, inputBudget: inputBudget,
                wasTrimmed: inputTokens > inputBudget)
        }

        let quantum = max(1, inputBudget / 4)
        let overflow = max(0, historyTokens - remaining)
        let quantaToDiscard = (overflow + quantum - 1) / quantum
        let discardTarget = quantaToDiscard * quantum
        var discarded = 0
        var startIndex = historyMessages.startIndex
        while startIndex < historyMessages.endIndex && discarded < discardTarget {
            discarded += estimateTokens(historyText(historyMessages[startIndex]))
            startIndex = historyMessages.index(after: startIndex)
        }

        var retained = historyMessages[startIndex...]
        if retained.isEmpty, let last = historyMessages.last,
            estimateTokens(historyText(last)) <= remaining
        {
            retained = historyMessages.suffix(1)
        }

        let selected = retained.map { node in
            let text = historyText(node)
            return LlmMessage(
                text: text, role: node.role == .user ? .user : .assistant,
                hasAttachments: !node.attachments.isEmpty)
        }

        return HistorySelection(
            messages: selected, inputTokens: inputTokens, inputBudget: inputBudget,
            wasTrimmed: inputTokens > inputBudget)
    }

    private func resolveMaxOutputTokens(contextLength: Int) -> Int {
        let maxAllowed = max(1, contextLength - Self.overflowSafetyTokens)
        let implicitMax = automaticMaxOutputTokens(contextLength: contextLength)
        return min(maxAllowed, implicitMax)
    }

    private func historyText(_ node: MessageNode) -> String {
        var text = node.text
        if node.role == .assistant {
            text = cleanAssistantText(storedText: text)
            if let regex = ChatMessageTagRegex.think {
                let range = NSRange(text.startIndex..., in: text)
                text = regex.stringByReplacingMatches(
                    in: text, options: [], range: range, withTemplate: "")
            } else {
                text = text.replacingOccurrences(
                    of: "<think>[\\s\\S]*?</think>", with: "", options: .regularExpression)
            }
            if let regex = ChatMessageTagRegex.todoList {
                let range = NSRange(text.startIndex..., in: text)
                text = regex.stringByReplacingMatches(
                    in: text, options: [], range: range, withTemplate: "")
            } else {
                text = text.replacingOccurrences(
                    of: "<todo_list>[\\s\\S]*?</todo_list>", with: "", options: .regularExpression)
            }
        } else if !node.attachments.isEmpty {
            text += "\n\n[\(node.attachments.count) attachments attached]"
        }
        return text.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
    }

    private func trimToBudget(_ text: String, budget: Int) -> String {
        guard budget > 0 else { return "" }
        let maxChars = budget * 4
        if text.count <= maxChars { return text }
        return String(text.suffix(maxChars))
    }

    private func estimateTokens(_ text: String) -> Int {
        max(1, text.count / 4)
    }

    private func estimateImageTokens(_ imageCount: Int) -> Int {
        imageCount * Self.imageTokenEstimate
    }

    private func estimatePromptTokens(promptText: String, imageCount: Int) -> Int {
        estimateTokens(promptText) + estimateImageTokens(imageCount)
    }

    private func resolveTemperature() -> Float {
        let value = Float(
            modelSettings.temperature.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines))
        let resolved = value.map { max(0, $0) } ?? Self.defaultTemperature
        return min(max(resolved, 0.35), 0.7)
    }

    private struct MessageNode: Identifiable {
        let id: UUID
        let sessionId: UUID
        let parentId: UUID?
        let role: RenderedChatMessage.Role
        let text: String
        let timestamp: Date
        let attachments: [ChatAttachment]
        let isInterrupted: Bool
        let tokensPerSecond: Double?
    }

    private struct PromptResult {
        let text: String
        let imageFiles: [URL]
    }
}

private struct ResolvedDownloadProgress {
    let percent: Int?
    let status: String
    let isLoading: Bool
    let isReady: Bool
}

private final class DownloadProgressTracker {
    private var lastVisiblePercent: Int?
    private var lastVisibleStatus: String?

    func seed(from toast: DownloadToastState?) {
        if let toast, let percent = toast.percent {
            lastVisiblePercent = percent
            lastVisibleStatus = toast.status
        } else {
            lastVisiblePercent = 0
            lastVisibleStatus = "Starting download..."
        }
    }

    func clear() {
        lastVisiblePercent = nil
        lastVisibleStatus = nil
    }

    func resolve(_ progress: DownloadProgress) -> ResolvedDownloadProgress {
        let isLoading = progress.phase == .loading
        let isReady = progress.phase == .ready
        let rawPercent = progress.percent
        let previousPercent = lastVisiblePercent
        let previousStatus = lastVisibleStatus

        let resolvedPercent: Int? = {
            if isReady { return 100 }
            if let rawPercent {
                if let previousPercent {
                    return max(rawPercent, previousPercent)
                }
                return rawPercent
            }
            return previousPercent
        }()
        let regressed = {
            guard let rawPercent, let previousPercent else { return false }
            return rawPercent < previousPercent
        }()
        let resolvedStatus: String = {
            if isReady || isLoading {
                return progress.status
            }
            if regressed {
                return previousStatus ?? progress.status
            }
            return progress.status
        }()

        if !isReady {
            lastVisiblePercent = resolvedPercent
            lastVisibleStatus = resolvedStatus
        }

        return ResolvedDownloadProgress(
            percent: resolvedPercent,
            status: resolvedStatus,
            isLoading: isLoading,
            isReady: isReady
        )
    }
}

private final class ConversationProgressSink: ConversationProgressCallback {
    private let handler: @Sendable () -> Void

    init(handler: @escaping @Sendable () -> Void) {
        self.handler = handler
    }

    func onProgress() {
        handler()
    }
}