Add indexed history search across iOS and web

ios/Packages/Sybil/Sources/Sybil/SybilAPIClient.swift

@@ -49,6 +49,15 @@ actor SybilAPIClient: SybilAPIClienting {
         return response.items
     }
 
+    func searchWorkspaceItems(query: String) async throws -> WorkspaceSearchResponse {
+        try await request(
+            "/v1/workspace-items",
+            method: "GET",
+            queryItems: [URLQueryItem(name: "q", value: query)],
+            responseType: WorkspaceSearchResponse.self
+        )
+    }
+
     func listChats() async throws -> [ChatSummary] {
         let response = try await request("/v1/chats", method: "GET", responseType: ChatListResponse.self)
         return response.chats
@@ -290,9 +299,10 @@ actor SybilAPIClient: SybilAPIClienting {
         _ path: String,
         method: String,
         body: AnyEncodable? = nil,
+        queryItems: [URLQueryItem] = [],
         responseType: Response.Type
     ) async throws -> Response {
-        let request = try makeRequest(path: path, method: method, body: body, acceptsSSE: false)
+        let request = try makeRequest(path: path, method: method, body: body, acceptsSSE: false, queryItems: queryItems)
 
         SybilLog.debug(
             SybilLog.network,
@@ -344,9 +354,10 @@ actor SybilAPIClient: SybilAPIClienting {
         path: String,
         method: String,
         body: AnyEncodable?,
-        acceptsSSE: Bool
+        acceptsSSE: Bool,
+        queryItems: [URLQueryItem] = []
     ) throws -> URLRequest {
-        let url = try buildURL(path: path)
+        let url = try buildURL(path: path, queryItems: queryItems)
         var request = URLRequest(url: url)
         request.httpMethod = method
         request.timeoutInterval = 120
@@ -369,7 +380,7 @@ actor SybilAPIClient: SybilAPIClienting {
         return request
     }
 
-    private func buildURL(path: String) throws -> URL {
+    private func buildURL(path: String, queryItems: [URLQueryItem]) throws -> URL {
         guard var components = URLComponents(url: configuration.baseURL, resolvingAgainstBaseURL: false) else {
             throw APIError.invalidBaseURL
         }
@@ -380,6 +391,9 @@ actor SybilAPIClient: SybilAPIClienting {
             basePath.removeLast()
         }
         components.path = "\(basePath)/\(trimmedPath)"
+        if !queryItems.isEmpty {
+            components.queryItems = (components.queryItems ?? []) + queryItems
+        }
 
         guard let url = components.url else {
             throw APIError.invalidBaseURL

ios/Packages/Sybil/Sources/Sybil/SybilAPIClienting.swift

@@ -3,6 +3,7 @@ import Foundation
 protocol SybilAPIClienting: Sendable {
     func verifySession() async throws -> AuthSession
     func listWorkspaceItems() async throws -> [WorkspaceItem]
+    func searchWorkspaceItems(query: String) async throws -> WorkspaceSearchResponse
     func listChats() async throws -> [ChatSummary]
     func createChat(
         title: String?,

ios/Packages/Sybil/Sources/Sybil/SybilModels.swift

@@ -219,6 +219,7 @@ public struct WorkspaceItem: Codable, Identifiable, Hashable, Sendable {
     public var id: String
     public var title: String?
     public var query: String?
+    public var searchSnippet: String? = nil
     public var parentChatId: String? = nil
     public var titleGenerationPending = false
     public var createdAt: Date
@@ -302,6 +303,7 @@ extension WorkspaceItem {
         case id
         case title
         case query
+        case searchSnippet
         case parentChatId
         case titleGenerationPending
         case createdAt
@@ -320,6 +322,7 @@ extension WorkspaceItem {
         id = try container.decode(String.self, forKey: .id)
         title = try container.decodeIfPresent(String.self, forKey: .title)
         query = try container.decodeIfPresent(String.self, forKey: .query)
+        searchSnippet = try container.decodeIfPresent(String.self, forKey: .searchSnippet)
         parentChatId = try container.decodeIfPresent(String.self, forKey: .parentChatId)
         titleGenerationPending = try container.decodeIfPresent(Bool.self, forKey: .titleGenerationPending) ?? false
         createdAt = try container.decode(Date.self, forKey: .createdAt)
@@ -730,6 +733,11 @@ struct SearchListResponse: Codable {
     var searches: [SearchSummary]
 }
 
+struct WorkspaceSearchResponse: Codable, Sendable {
+    var items: [WorkspaceItem]
+    var hasMore: Bool
+}
+
 struct WorkspaceListResponse: Codable {
     var items: [WorkspaceItem]
 }

ios/Packages/Sybil/Sources/Sybil/SybilPhoneShellView.swift

@@ -242,6 +242,7 @@ struct SybilPhoneShellView: View {
     }
 
     private func showRoute(_ nextRoute: PhoneRoute) {
+        dismissSidebarKeyboard()
         let update = {
             route = nextRoute
         }
@@ -271,12 +272,19 @@ struct SybilPhoneShellView: View {
     }
 
     private func hideSidebarOverlay() {
+        dismissSidebarKeyboard()
         withAnimation(.easeOut(duration: 0.18)) {
             isSidebarOverlayPresented = false
         }
         resetSidebarSwipe(animated: false)
     }
 
+    private func dismissSidebarKeyboard() {
+        if isSidebarOverlayPresented {
+            UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)
+        }
+    }
+
     private func openSidebarSelection(_ selection: SidebarSelection) {
         if openingSelectionRequestID != nil, sidebarHighlightSelection == selection {
             return

ios/Packages/Sybil/Sources/Sybil/SybilSidebarView.swift

@@ -115,6 +115,7 @@ struct SybilSidebarItemList: View {
     var onOpenForkedChat: ((String) -> Void)? = nil
     @State private var renameTarget: SidebarItem?
     @State private var renameTitle = ""
+    @FocusState private var isSearchFocused: Bool
 
     private var isRenameAlertPresented: Binding<Bool> {
         Binding {
@@ -128,37 +129,98 @@ struct SybilSidebarItemList: View {
     }
 
     var body: some View {
+        VStack(spacing: 0) {
+            HStack(spacing: 10) {
+                Image(systemName: "magnifyingglass")
+                    .foregroundStyle(SybilTheme.textMuted)
+                TextField("Search chats and web searches", text: Binding(
+                    get: { viewModel.sidebarSearchQuery },
+                    set: { viewModel.setSidebarSearchQuery($0) }
+                ))
+                .font(.sybil(.subheadline))
+                .foregroundStyle(SybilTheme.text)
+                .textInputAutocapitalization(.never)
+                .autocorrectionDisabled()
+                .submitLabel(.search)
+                .focused($isSearchFocused)
+                .accessibilityLabel("Search conversation history and saved web searches")
+                .onSubmit {
+                    isSearchFocused = false
+                    Task { await viewModel.refreshSidebarSearch() }
+                }
+
+                if !viewModel.sidebarSearchQuery.isEmpty {
+                    Button {
+                        viewModel.setSidebarSearchQuery("")
+                    } label: {
+                        Image(systemName: "xmark.circle.fill")
+                            .foregroundStyle(SybilTheme.textMuted)
+                    }
+                    .buttonStyle(.plain)
+                    .accessibilityLabel("Clear history search")
+                }
+            }
+            .padding(12)
+            .background(SybilTheme.surface, in: RoundedRectangle(cornerRadius: 12))
+            .overlay(RoundedRectangle(cornerRadius: 12).stroke(SybilTheme.border, lineWidth: 1))
+            .padding(10)
+
+            itemList
+        }
+    }
+
+    private var itemList: some View {
         Group {
-            if viewModel.isLoadingCollections && viewModel.sidebarItems.isEmpty {
+            if viewModel.isSearchingSidebar ||
+                (!viewModel.isSidebarSearchActive && viewModel.isLoadingCollections && viewModel.sidebarItems.isEmpty) {
                 VStack(alignment: .leading, spacing: 8) {
                     ProgressView()
                         .tint(SybilTheme.primary)
-                    Text("Loading conversations…")
+                    Text(viewModel.isSidebarSearchActive ? "Searching history…" : "Loading conversations…")
                         .font(.sybil(.footnote))
                         .foregroundStyle(SybilTheme.textMuted)
                 }
                 .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
                 .padding(16)
-            } else if viewModel.sidebarItems.isEmpty {
+            } else if let error = viewModel.sidebarSearchError, viewModel.isSidebarSearchActive {
+                VStack(spacing: 12) {
+                    Text(error)
+                        .font(.sybil(.footnote))
+                        .foregroundStyle(SybilTheme.danger)
+                        .multilineTextAlignment(.center)
+                    Button("Try again") {
+                        Task { await viewModel.refreshSidebarSearch() }
+                    }
+                }
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .padding(16)
+            } else if viewModel.visibleSidebarItems.isEmpty {
                 VStack(spacing: 10) {
-                    Image(systemName: "message.badge")
+                    Image(systemName: viewModel.isSidebarSearchActive ? "magnifyingglass" : "message.badge")
                         .font(.system(size: 20, weight: .medium))
                         .foregroundStyle(SybilTheme.textMuted)
-                    Text("Start a chat or run your first search.")
+                    Text(viewModel.isSidebarSearchActive ? "No matching chats or web searches." : "Start a chat or run your first search.")
                         .font(.sybil(.footnote))
                         .multilineTextAlignment(.center)
                         .foregroundStyle(SybilTheme.textMuted)
+                    if viewModel.isSidebarSearchActive {
+                        Text("Try a title, a query, or words from a conversation.")
+                            .font(.sybil(.caption))
+                            .multilineTextAlignment(.center)
+                            .foregroundStyle(SybilTheme.textMuted)
+                    }
                 }
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
                 .padding(16)
             } else {
                 ScrollView {
                     LazyVStack(alignment: .leading, spacing: 8) {
-                        ForEach(viewModel.sidebarItems) { item in
+                        ForEach(viewModel.visibleSidebarItems) { item in
                             Button {
+                                isSearchFocused = false
                                 onSelect(item)
                             } label: {
-                                SybilSidebarRow(item: item, isSelected: isSelected(item))
+                                SybilSidebarRow(item: item, isSelected: isSelected(item), searchQuery: viewModel.sidebarSearchQuery)
                             }
                             .buttonStyle(.plain)
                             .contextMenu {
@@ -201,9 +263,16 @@ struct SybilSidebarItemList: View {
                                 }
                             }
                         }
+                        if viewModel.isSidebarSearchActive && viewModel.sidebarSearchHasMore {
+                            Text("Showing the 100 most recent matches. Refine your search to find more.")
+                                .font(.sybil(.caption))
+                                .foregroundStyle(SybilTheme.textMuted)
+                                .padding(12)
+                        }
                     }
                     .padding(10)
                 }
+                .scrollDismissesKeyboard(.interactively)
                 .refreshable {
                     await viewModel.refreshSidebarCollectionsFromPullToRefresh()
                 }
@@ -257,6 +326,25 @@ struct SybilSidebarItemList: View {
 struct SybilSidebarRow: View {
     var item: SidebarItem
     var isSelected: Bool
+    var searchQuery = ""
+
+    private func highlightedSnippet(_ snippet: String) -> AttributedString {
+        var highlighted = AttributedString(snippet)
+        guard let words = try? NSRegularExpression(pattern: #"[\p{L}\p{N}\p{M}\p{Co}]+"#) else { return highlighted }
+        let terms = words.matches(in: searchQuery, range: NSRange(searchQuery.startIndex..., in: searchQuery)).compactMap { match -> String? in
+            guard let range = Range(match.range, in: searchQuery) else { return nil }
+            return String(searchQuery[range]).folding(options: [.diacriticInsensitive, .caseInsensitive], locale: Locale(identifier: "en_US_POSIX"))
+        }.filter { !$0.isEmpty }
+        for word in words.matches(in: snippet, range: NSRange(snippet.startIndex..., in: snippet)) {
+            guard let range = Range(word.range, in: snippet) else { continue }
+            let normalized = String(snippet[range]).folding(options: [.diacriticInsensitive, .caseInsensitive], locale: Locale(identifier: "en_US_POSIX"))
+            guard terms.contains(where: { normalized.hasPrefix($0) }),
+                  let start = AttributedString.Index(range.lowerBound, within: highlighted),
+                  let end = AttributedString.Index(range.upperBound, within: highlighted) else { continue }
+            highlighted[start..<end].font = .sybil(.caption, weight: .semibold)
+        }
+        return highlighted
+    }
 
     private var isHighlighted: Bool {
         isSelected
@@ -318,6 +406,15 @@ struct SybilSidebarRow: View {
                         .frame(maxWidth: .infinity, alignment: .trailing)
                 }
             }
+
+            if let snippet = item.searchSnippet, !snippet.isEmpty {
+                Text(highlightedSnippet(snippet.replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)))
+                    .font(.sybil(.caption))
+                    .foregroundStyle(SybilTheme.textMuted)
+                    .lineLimit(1)
+                    .truncationMode(.middle)
+                    .multilineTextAlignment(.leading)
+            }
         }
         .foregroundStyle(SybilTheme.text)
         .padding(.horizontal, 12)

ios/Packages/Sybil/Sources/Sybil/SybilViewModel.swift

@@ -38,6 +38,7 @@ struct SidebarItem: Identifiable, Hashable {
     var starredAt: Date?
     var initiatedLabel: String?
     var isRunning: Bool
+    var searchSnippet: String? = nil
 }
 
 enum StreamingAssistantContentUpdate: Equatable, Sendable {
@@ -161,6 +162,15 @@ final class SybilViewModel {
     var chats: [ChatSummary] = []
     var searches: [SearchSummary] = []
     var workspaceItems: [WorkspaceItem] = []
+    private(set) var sidebarSearchQuery = ""
+    private(set) var sidebarSearchResults: [WorkspaceItem] = []
+    private(set) var isSearchingSidebar = false
+    private(set) var sidebarSearchError: String?
+    private(set) var sidebarSearchHasMore = false
+    @ObservationIgnored
+    private var sidebarSearchTask: Task<Void, Never>?
+    @ObservationIgnored
+    private var sidebarSearchRequestID = UUID()
 
     var selectedItem: SidebarSelection?
     var selectedChat: ChatDetail?
@@ -482,7 +492,19 @@ final class SybilViewModel {
     }
 
     var sidebarItems: [SidebarItem] {
-        workspaceItems.map { item in
+        makeSidebarItems(workspaceItems)
+    }
+
+    var isSidebarSearchActive: Bool {
+        !sidebarSearchQuery.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    }
+
+    var visibleSidebarItems: [SidebarItem] {
+        isSidebarSearchActive ? makeSidebarItems(sidebarSearchResults) : sidebarItems
+    }
+
+    private func makeSidebarItems(_ items: [WorkspaceItem]) -> [SidebarItem] {
+        items.map { item in
             switch item.type {
             case .chat:
                 let initiatedLabel: String?
@@ -496,7 +518,8 @@ final class SybilViewModel {
                     initiatedLabel = nil
                 }
                 let starOwner = item.parentChatId.flatMap { parentChatID in
-                    workspaceItems.first(where: { $0.type == .chat && $0.id == parentChatID })
+                    workspaceItems.first(where: { $0.type == .chat && $0.id == parentChatID }) ??
+                        sidebarSearchResults.first(where: { $0.type == .chat && $0.id == parentChatID })
                 } ?? item
 
                 return SidebarItem(
@@ -507,7 +530,8 @@ final class SybilViewModel {
                     starred: starOwner.starred,
                     starredAt: starOwner.starredAt,
                     initiatedLabel: initiatedLabel,
-                    isRunning: isChatRowRunning(item.id)
+                    isRunning: isChatRowRunning(item.id),
+                    searchSnippet: item.searchSnippet
                 )
 
             case .search:
@@ -519,20 +543,70 @@ final class SybilViewModel {
                     starred: item.starred,
                     starredAt: item.starredAt,
                     initiatedLabel: "exa",
-                    isRunning: isSearchRowRunning(item.id)
+                    isRunning: isSearchRowRunning(item.id),
+                    searchSnippet: item.searchSnippet
                 )
             }
         }
     }
 
+    func setSidebarSearchQuery(_ query: String) {
+        let previous = sidebarSearchQuery.trimmingCharacters(in: .whitespacesAndNewlines)
+        sidebarSearchQuery = query
+        guard query.trimmingCharacters(in: .whitespacesAndNewlines) != previous else { return }
+        scheduleSidebarSearch()
+    }
+
+    func refreshSidebarSearch() async {
+        guard isSidebarSearchActive else { return }
+        scheduleSidebarSearch(debounce: false)
+        await sidebarSearchTask?.value
+    }
+
+    private func scheduleSidebarSearch(debounce: Bool = true) {
+        sidebarSearchTask?.cancel()
+        let requestID = UUID()
+        sidebarSearchRequestID = requestID
+        sidebarSearchResults = []
+        sidebarSearchError = nil
+        sidebarSearchHasMore = false
+        isSearchingSidebar = false
+        let query = sidebarSearchQuery.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !query.isEmpty, isAuthenticated else { return }
+        guard query.utf16.count <= 200 else {
+            sidebarSearchError = "Use 200 characters or fewer."
+            return
+        }
+        isSearchingSidebar = true
+        sidebarSearchTask = Task { [weak self] in
+            do {
+                if debounce { try await Task.sleep(for: .milliseconds(300)) }
+                guard let self, !Task.isCancelled else { return }
+                let response = try await self.client().searchWorkspaceItems(query: query)
+                guard !Task.isCancelled, self.sidebarSearchRequestID == requestID else { return }
+                self.sidebarSearchResults = response.items
+                self.sidebarSearchHasMore = response.hasMore
+                self.isSearchingSidebar = false
+            } catch {
+                guard let self, !Task.isCancelled, self.sidebarSearchRequestID == requestID else { return }
+                self.isSearchingSidebar = false
+                if !self.isCancellation(error) {
+                    self.sidebarSearchError = self.normalizeAPIError(error)
+                }
+            }
+        }
+    }
+
     var selectedChatSummary: ChatSummary? {
         guard case let .chat(chatID) = selectedItem else { return nil }
-        return chats.first(where: { $0.id == chatID })
+        return chats.first(where: { $0.id == chatID }) ??
+            sidebarSearchResults.first(where: { $0.type == .chat && $0.id == chatID })?.chatSummary
     }
 
     var selectedSearchSummary: SearchSummary? {
         guard case let .search(searchID) = selectedItem else { return nil }
-        return searches.first(where: { $0.id == searchID })
+        return searches.first(where: { $0.id == searchID }) ??
+            sidebarSearchResults.first(where: { $0.type == .search && $0.id == searchID })?.searchSummary
     }
 
     var hasRefreshableSelection: Bool {
@@ -559,6 +633,7 @@ final class SybilViewModel {
     }
 
     func reconnect() async {
+        setSidebarSearchQuery("")
         isCheckingSession = true
         authError = nil
         errorMessage = nil
@@ -865,6 +940,15 @@ final class SybilViewModel {
     private func beginSelecting(_ selection: SidebarSelection) -> Task<Void, Never>? {
         SybilLog.debug(SybilLog.ui, "Selecting \(selection.id)")
 
+        // Search can open history outside the recent collection. Retain its
+        // summary for provider settings, starring, and subsequent refreshes.
+        if let item = sidebarSearchResults.first(where: {
+            ($0.type == .chat ? SidebarSelection.chat($0.id) : .search($0.id)) == selection
+        }) {
+            if let chat = item.chatSummary { applyChatSummary(chat, moveToFront: false) }
+            if let search = item.searchSummary { applySearchSummary(search, moveToFront: false) }
+        }
+
         if draftKind == nil, selectedItem == selection {
             errorMessage = nil
             if case .search = selection {
@@ -915,7 +999,7 @@ final class SybilViewModel {
     }
 
     private func selectAdjacentSidebarItem(offset: Int) {
-        let items = sidebarItems
+        let items = visibleSidebarItems
         guard !items.isEmpty else {
             return
         }
@@ -951,6 +1035,7 @@ final class SybilViewModel {
                     break
                 }
                 await refreshCollections(preferredSelection: nil)
+                await refreshSidebarSearch()
             } catch {
                 errorMessage = normalizeAPIError(error)
                 SybilLog.error(SybilLog.ui, "Delete failed", error: error)
@@ -1006,6 +1091,7 @@ final class SybilViewModel {
         do {
             let updated = try await client().updateChatTitle(chatID: chatID, title: trimmedTitle)
             applyChatSummary(updated, moveToFront: true)
+            await refreshSidebarSearch()
         } catch {
             errorMessage = normalizeAPIError(error)
             SybilLog.error(SybilLog.ui, "Rename failed", error: error)
@@ -1105,6 +1191,10 @@ final class SybilViewModel {
     }
 
     func refreshSidebarCollectionsFromPullToRefresh() async {
+        if isSidebarSearchActive {
+            await refreshSidebarSearch()
+            return
+        }
         guard isAuthenticated, !isCheckingSession else {
             return
         }
@@ -1445,7 +1535,15 @@ final class SybilViewModel {
             async let activeRunsValue = client.getActiveRuns()
             let (nextWorkspaceItems, nextActiveRuns) = try await (workspaceItemsValue, activeRunsValue)
 
-            applyWorkspaceItems(nextWorkspaceItems)
+            var items = nextWorkspaceItems
+            // A selected historical search result may be outside the latest 100.
+            if let preferredSelection,
+               let selectedSummary = workspaceItems.first(where: {
+                   ($0.type == .chat ? SidebarSelection.chat($0.id) : .search($0.id)) == preferredSelection
+               }), !items.contains(where: { $0.type == selectedSummary.type && $0.id == selectedSummary.id }) {
+                items.append(selectedSummary)
+            }
+            applyWorkspaceItems(items)
             applyActiveRuns(nextActiveRuns)
 
             SybilLog.info(
@@ -1623,6 +1721,11 @@ final class SybilViewModel {
     }
 
     private func upsertWorkspaceItem(_ item: WorkspaceItem, moveToFront: Bool) {
+        if let index = sidebarSearchResults.firstIndex(where: { $0.type == item.type && $0.id == item.id }) {
+            var updated = item
+            updated.searchSnippet = sidebarSearchResults[index].searchSnippet
+            sidebarSearchResults[index] = updated
+        }
         if let existingIndex = workspaceItems.firstIndex(where: { $0.type == item.type && $0.id == item.id }) {
             workspaceItems.remove(at: existingIndex)
             if moveToFront {
@@ -1646,6 +1749,9 @@ final class SybilViewModel {
         if let parentChatID = workspaceItems.first(where: { $0.type == .chat && $0.id == chatID })?.parentChatId {
             return parentChatID
         }
+        if let parentChatID = sidebarSearchResults.first(where: { $0.type == .chat && $0.id == chatID })?.parentChatId {
+            return parentChatID
+        }
         return chatID
     }
 

ios/Packages/Sybil/Tests/SybilTests/SybilTests.swift

@@ -9,6 +9,7 @@ import UIKit
 
 private struct MockClientCallSnapshot: Sendable {
     var listWorkspaceItems = 0
+    var workspaceSearchQueries: [String] = []
     var listChats = 0
     var listSearches = 0
     var createChat = 0
@@ -43,6 +44,7 @@ private actor MockSybilClient: SybilAPIClienting {
     private let chatsResponse: [ChatSummary]
     private let searchesResponse: [SearchSummary]
     private let workspaceItemsResponse: [WorkspaceItem]
+    private let workspaceSearchHandler: @Sendable (String) async throws -> WorkspaceSearchResponse
     private let chatDetails: [String: ChatDetail]
     private let searchDetails: [String: SearchDetail]
     private let createChatResponse: ChatSummary?
@@ -86,11 +88,15 @@ private actor MockSybilClient: SybilAPIClienting {
         updateSearchStarResponses: [String: SearchSummary] = [:],
         activeRunsResponse: ActiveRunsResponse = ActiveRunsResponse(),
         workspaceItemsResponse: [WorkspaceItem]? = nil,
+        workspaceSearchHandler: @escaping @Sendable (String) async throws -> WorkspaceSearchResponse = { _ in
+            WorkspaceSearchResponse(items: [], hasMore: false)
+        },
         modelCatalogResponse: ModelCatalogResponse = ModelCatalogResponse(providers: [:])
     ) {
         self.chatsResponse = chatsResponse
         self.searchesResponse = searchesResponse
         self.workspaceItemsResponse = workspaceItemsResponse ?? Self.makeWorkspaceItems(chats: chatsResponse, searches: searchesResponse)
+        self.workspaceSearchHandler = workspaceSearchHandler
         self.chatDetails = chatDetails
         self.searchDetails = searchDetails
         self.createChatResponse = createChatResponse
@@ -186,6 +192,11 @@ private actor MockSybilClient: SybilAPIClienting {
         return workspaceItemsResponse
     }
 
+    func searchWorkspaceItems(query: String) async throws -> WorkspaceSearchResponse {
+        snapshot.workspaceSearchQueries.append(query)
+        return try await workspaceSearchHandler(query)
+    }
+
     func listChats() async throws -> [ChatSummary] {
         snapshot.listChats += 1
         if listChatsDelayNanoseconds > 0 {
@@ -1998,3 +2009,173 @@ private final class MockQuickQuestionLifecycle {
     controller.stop()
 }
 #endif
+
+// Deliberately ignores cancellation so stale-response protection is exercised.
+private actor WorkspaceSearchGate {
+    private var pending: [String: CheckedContinuation<WorkspaceSearchResponse, any Error>] = [:]
+    private var observers: [String: CheckedContinuation<Void, Never>] = [:]
+
+    func response(for query: String) async throws -> WorkspaceSearchResponse {
+        try await withCheckedThrowingContinuation { continuation in
+            pending[query] = continuation
+            observers.removeValue(forKey: query)?.resume()
+        }
+    }
+
+    func waitUntilRequested(_ query: String) async {
+        if pending[query] != nil { return }
+        await withCheckedContinuation { observers[query] = $0 }
+    }
+
+    func complete(_ query: String, with response: WorkspaceSearchResponse) {
+        pending.removeValue(forKey: query)?.resume(returning: response)
+    }
+
+    func fail(_ query: String) {
+        pending.removeValue(forKey: query)?.resume(throwing: APIError.networkError(message: "Offline"))
+    }
+}
+
+@MainActor
+@Test func historySearchKeepsRecentItemsAndOpensOlderChat() async throws {
+    let date = Date(timeIntervalSince1970: 1_700_000_000)
+    let recent = makeChatSummary(id: "recent", date: date)
+    let old = makeChatSummary(id: "old", date: date.addingTimeInterval(-100))
+    var match = WorkspaceItem(chat: old)
+    match.searchSnippet = "The nebula we discussed"
+    let response = WorkspaceSearchResponse(items: [match, WorkspaceItem(search: makeSearchSummary(id: "web", date: date))], hasMore: true)
+    let client = MockSybilClient(
+        chatsResponse: [recent],
+        chatDetails: ["old": makeChatDetail(id: "old", date: date, body: "The nebula we discussed")],
+        workspaceSearchHandler: { _ in response }
+    )
+    let viewModel = SybilViewModel(settings: testSettings(named: #function)) { _ in client }
+    viewModel.isAuthenticated = true
+    viewModel.isCheckingSession = false
+    viewModel.workspaceItems = [WorkspaceItem(chat: recent)]
+    viewModel.chats = [recent]
+    viewModel.selectedItem = .chat("recent")
+    viewModel.setSidebarSearchQuery("  nebula  ")
+    await viewModel.refreshSidebarSearch()
+    #expect(viewModel.selectedItem == .chat("recent"))
+    #expect(viewModel.workspaceItems == [WorkspaceItem(chat: recent)])
+    #expect(viewModel.visibleSidebarItems.map(\.selection) == [.chat("old"), .search("web")])
+    #expect(viewModel.visibleSidebarItems.first?.searchSnippet == "The nebula we discussed")
+    #expect(viewModel.sidebarSearchHasMore)
+    #expect(await client.currentSnapshot().workspaceSearchQueries == ["nebula"])
+    await viewModel.selectForNavigation(.chat("old"))
+    #expect(viewModel.selectedChat?.id == "old")
+    viewModel.setSidebarSearchQuery("")
+    await viewModel.refreshVisibleContent(refreshCollections: true, refreshSelection: false)
+    #expect(viewModel.selectedItem == .chat("old"))
+    #expect(viewModel.selectedChat?.id == "old")
+    #expect(viewModel.sidebarItems.contains(where: { $0.selection == .chat("old") }))
+}
+
+@MainActor
+@Test func historySearchDebouncesAndClearingRestoresRecentItems() async throws {
+    let client = MockSybilClient()
+    let viewModel = SybilViewModel(settings: testSettings(named: #function)) { _ in client }
+    viewModel.isAuthenticated = true
+    let recent = WorkspaceItem(chat: makeChatSummary(id: "recent", date: Date()))
+    viewModel.workspaceItems = [recent]
+    viewModel.setSidebarSearchQuery("n")
+    viewModel.setSidebarSearchQuery("ne")
+    viewModel.setSidebarSearchQuery("nebula")
+    #expect(viewModel.isSearchingSidebar)
+    #expect(await client.currentSnapshot().workspaceSearchQueries.isEmpty)
+    try await Task.sleep(for: .milliseconds(600))
+    #expect(await client.currentSnapshot().workspaceSearchQueries == ["nebula"])
+    #expect(viewModel.visibleSidebarItems.isEmpty)
+    #expect(!viewModel.isSearchingSidebar)
+    viewModel.setSidebarSearchQuery("   ")
+    #expect(viewModel.visibleSidebarItems.map(\.selection) == [.chat("recent")])
+    #expect(!viewModel.isSidebarSearchActive)
+    #expect(viewModel.sidebarSearchError == nil)
+}
+
+@MainActor
+@Test func historySearchDiscardsOutOfOrderAndClearedResponses() async throws {
+    let gate = WorkspaceSearchGate()
+    let client = MockSybilClient(workspaceSearchHandler: { try await gate.response(for: $0) })
+    let viewModel = SybilViewModel(settings: testSettings(named: #function)) { _ in client }
+    viewModel.isAuthenticated = true
+    viewModel.setSidebarSearchQuery("first")
+    let first = Task { await viewModel.refreshSidebarSearch() }
+    await gate.waitUntilRequested("first")
+    viewModel.setSidebarSearchQuery("second")
+    let second = Task { await viewModel.refreshSidebarSearch() }
+    await gate.waitUntilRequested("second")
+    let match = WorkspaceItem(chat: makeChatSummary(id: "second", date: Date()))
+    await gate.complete("second", with: WorkspaceSearchResponse(items: [match], hasMore: false))
+    await second.value
+    await gate.fail("first")
+    await first.value
+    #expect(viewModel.sidebarSearchResults == [match])
+    #expect(viewModel.sidebarSearchError == nil)
+    #expect(!viewModel.isSearchingSidebar)
+
+    viewModel.setSidebarSearchQuery("third")
+    let third = Task { await viewModel.refreshSidebarSearch() }
+    await gate.waitUntilRequested("third")
+    viewModel.setSidebarSearchQuery("")
+    await gate.complete("third", with: WorkspaceSearchResponse(items: [match], hasMore: true))
+    await third.value
+    #expect(viewModel.sidebarSearchResults.isEmpty)
+    #expect(!viewModel.sidebarSearchHasMore)
+    #expect(!viewModel.isSearchingSidebar)
+}
+
+@MainActor
+@Test func historySearchFailureCanRetryWithoutChangingSelection() async throws {
+    let gate = WorkspaceSearchGate()
+    let client = MockSybilClient(workspaceSearchHandler: { try await gate.response(for: $0) })
+    let viewModel = SybilViewModel(settings: testSettings(named: #function)) { _ in client }
+    viewModel.isAuthenticated = true
+    viewModel.selectedItem = .chat("current")
+    viewModel.setSidebarSearchQuery("nebula")
+    let failed = Task { await viewModel.refreshSidebarSearch() }
+    await gate.waitUntilRequested("nebula")
+    await gate.fail("nebula")
+    await failed.value
+    #expect(viewModel.sidebarSearchError != nil)
+    #expect(viewModel.selectedItem == .chat("current"))
+    let retry = Task { await viewModel.refreshSidebarSearch() }
+    await gate.waitUntilRequested("nebula")
+    await gate.complete("nebula", with: WorkspaceSearchResponse(items: [], hasMore: false))
+    await retry.value
+    #expect(viewModel.sidebarSearchError == nil)
+    #expect(!viewModel.isSearchingSidebar)
+    #expect(viewModel.selectedItem == .chat("current"))
+    viewModel.setSidebarSearchQuery(String(repeating: "a", count: 201))
+    #expect(viewModel.sidebarSearchError == "Use 200 characters or fewer.")
+    #expect(await client.currentSnapshot().workspaceSearchQueries == ["nebula", "nebula"])
+}
+
+private final class HistorySearchURLProtocol: URLProtocol, @unchecked Sendable {
+    override class func canInit(with request: URLRequest) -> Bool { true }
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
+    override func startLoading() {
+        let url = request.url!
+        #expect(url.path == "/api/v1/workspace-items")
+        #expect(request.httpMethod == "GET")
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer test-token")
+        #expect(URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems == [URLQueryItem(name: "q", value: "café + AI & #ideas?")])
+        let json = #"{"items":[{"type":"chat","id":"old","title":"Notes","createdAt":"2026-01-01T00:00:00.000Z","updatedAt":"2026-01-01T00:00:00.000Z","searchSnippet":"Some café ideas"}],"hasMore":false}"#
+        client?.urlProtocol(self, didReceive: HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: ["Content-Type": "application/json"])!, cacheStoragePolicy: .notAllowed)
+        client?.urlProtocol(self, didLoad: Data(json.utf8))
+        client?.urlProtocolDidFinishLoading(self)
+    }
+    override func stopLoading() {}
+}
+
+@Test func historySearchEncodesQueryAndDecodesSnippet() async throws {
+    let configuration = URLSessionConfiguration.ephemeral
+    configuration.protocolClasses = [HistorySearchURLProtocol.self]
+    let session = URLSession(configuration: configuration)
+    defer { session.invalidateAndCancel() }
+    let client = SybilAPIClient(configuration: APIConfiguration(baseURL: URL(string: "https://example.com/api")!, authToken: "test-token"), session: session)
+    let response = try await client.searchWorkspaceItems(query: "café + AI & #ideas?")
+    #expect(response.items.first?.searchSnippet == "Some café ideas")
+    #expect(!response.hasMore)
+}

ios/README.md

@@ -5,6 +5,14 @@ Run `just run` for the iPhone simulator, or `just run-mac` for Mac Catalyst.
 project from `project.yml`. The Mac recipes use ad-hoc signing for local development;
 release/archive signing settings are unchanged.
 
+The conversation sidebar includes **Search chats and web searches** on iPhone,
+iPad, and Mac. It searches all saved history by title, conversation text, and saved
+web-search query/answer, with single-line excerpts that bold matching words and
+truncate in the middle. Search waits briefly while typing,
+cancels superseded requests, and leaves the current conversation open. Clear the
+field to return to recent items. Searches use word prefixes (for example, `plan`
+finds `planning`); if more than 100 items match, refine the query.
+
 ## Quick Question on macOS
 
 While the Catalyst app is running, **Option+Space** toggles a floating Quick