Fix SessionStart triggering in-progress and add streaming history search

rogeriochaves · rogeriochaves · commit a64ff2e7509d · 2026-03-04T08:25:02.000+01:00
SessionStart was treated the same as UserPromptSubmit, causing cards to
stay in-progress for 5 minutes after resuming even when Claude is idle
at the prompt. Now SessionStart returns .idleWaiting instead.

Also adds non-blocking history search: scans JSONL file directly via
TranscriptReader.scanForMatches() stream, loads turns on-demand around
matches with loadAroundTurn(), and shows scanning progress in search bar.
diff --git a/Sources/KanbanCode/CardDetailView.swift b/Sources/KanbanCode/CardDetailView.swift
@@ -337,7 +337,8 @@ struct CardDetailView: View {
                         showCheckpointConfirm = true
                     },
                     onLoadMore: { Task { await loadMoreHistory() } },
-                    onLoadAll: { Task { await loadAllHistory() } }
+                    onLoadAroundTurn: { turnIndex in Task { await loadAroundTurn(turnIndex) } },
+                    sessionPath: card.link.sessionLink?.sessionPath ?? card.session?.jsonlPath
                 )
             case .issue:
                 issueTabView
@@ -1183,18 +1184,24 @@ struct CardDetailView: View {
         isLoadingMore = false
     }
 
-    /// Load the entire conversation history (for search).
-    private func loadAllHistory() async {
-        guard hasMoreTurns, !isLoadingMore else { return }
+    /// Load turns around a specific turn index (for search match navigation).
+    /// Loads a page-sized chunk around the target, merging with existing turns.
+    private func loadAroundTurn(_ targetIndex: Int) async {
         guard let path = card.link.sessionLink?.sessionPath ?? card.session?.jsonlPath else { return }
         isLoadingMore = true
+
+        let halfPage = Self.pageSize / 2
+        let rangeStart = max(0, targetIndex - halfPage)
+        let rangeEnd = targetIndex + halfPage
+
         do {
-            let all = try await TranscriptReader.readTurns(from: path)
-            turns = all
-            hasMoreTurns = false
-        } catch {
-            // Silently fail
-        }
+            let chunk = try await TranscriptReader.readRange(from: path, turnRange: rangeStart..<rangeEnd)
+            var byIndex: [Int: ConversationTurn] = [:]
+            for t in turns { byIndex[t.index] = t }
+            for t in chunk { byIndex[t.index] = t }
+            turns = byIndex.values.sorted { $0.index < $1.index }
+            hasMoreTurns = (turns.first?.index ?? 0) > 0
+        } catch { }
         isLoadingMore = false
     }
 
diff --git a/Sources/KanbanCode/SessionHistoryView.swift b/Sources/KanbanCode/SessionHistoryView.swift
@@ -25,20 +25,23 @@ struct SessionHistoryView: View {
     var onCancelCheckpoint: (() -> Void)?
     var onSelectTurn: ((ConversationTurn) -> Void)?
     var onLoadMore: (() -> Void)?
-    var onLoadAll: (() -> Void)?
+    var onLoadAroundTurn: ((Int) -> Void)?
+    var sessionPath: String?
 
     @State private var hoveredTurnIndex: Int?
     @State private var isAtBottom = true
     @State private var showSearch = false
     @State private var searchText = ""
     @State private var activeQuery = ""  // debounced, min 2 chars
-    @State private var searchMatchIndices: [Int] = []
-    @State private var currentMatchPosition: Int = 0
+    @State private var searchMatchIndices: [Int] = []  // all found match turn indices (ascending)
+    @State private var currentMatchPosition: Int = 0   // index into searchMatchIndices, 0 = most recent (last)
     @State private var searchDebounceTask: Task<Void, Never>?
+    @State private var searchScanTask: Task<Void, Never>?
+    @State private var isSearchScanning = false
     @State private var didOverscrollTop = false
     @FocusState private var isSearchFieldFocused: Bool
 
-    private static let maxSearchResults = 200
+    private static let maxSearchResults = 500
 
     var body: some View {
         if isLoading {
@@ -121,7 +124,18 @@ struct SessionHistoryView: View {
                     }
                     .onAppear { scrollToBottom(proxy: proxy, force: true) }
                     .onChange(of: turns.count) {
-                        scrollToBottom(proxy: proxy)
+                        if activeQuery.isEmpty {
+                            scrollToBottom(proxy: proxy)
+                        } else if !searchMatchIndices.isEmpty,
+                                  currentMatchPosition < searchMatchIndices.count {
+                            // Turns loaded during search — scroll to current match
+                            let idx = searchMatchIndices[currentMatchPosition]
+                            if turns.contains(where: { $0.index == idx }) {
+                                withAnimation(.easeInOut(duration: 0.2)) {
+                                    proxy.scrollTo(idx, anchor: .center)
+                                }
+                            }
+                        }
                         didOverscrollTop = false
                     }
                     .onChange(of: didOverscrollTop) {
@@ -130,13 +144,26 @@ struct SessionHistoryView: View {
                         }
                     }
                     .onChange(of: currentMatchPosition) {
-                        guard !searchMatchIndices.isEmpty,
+                        guard !isSearchScanning,
+                              !searchMatchIndices.isEmpty,
                               currentMatchPosition < searchMatchIndices.count else { return }
                         let idx = searchMatchIndices[currentMatchPosition]
                         withAnimation(.easeInOut(duration: 0.2)) {
                             proxy.scrollTo(idx, anchor: .center)
                         }
                     }
+                    .onChange(of: isSearchScanning) {
+                        if !isSearchScanning && !searchMatchIndices.isEmpty {
+                            let idx = searchMatchIndices[currentMatchPosition]
+                            if turns.contains(where: { $0.index == idx }) {
+                                withAnimation(.easeInOut(duration: 0.2)) {
+                                    proxy.scrollTo(idx, anchor: .center)
+                                }
+                            } else {
+                                onLoadAroundTurn?(idx)
+                            }
+                        }
+                    }
                 }
 
                 // Search overlay
@@ -149,8 +176,6 @@ struct SessionHistoryView: View {
                 Button("") {
                     showSearch = true
                     isSearchFieldFocused = true
-                    // Load full history for search if not all loaded yet
-                    if hasMoreTurns { onLoadAll?() }
                 }
                 .keyboardShortcut("f", modifiers: .command)
                 .hidden()
@@ -178,17 +203,19 @@ struct SessionHistoryView: View {
                 .onSubmit { navigateSearch(forward: true) }
                 .onChange(of: searchText) { scheduleSearch() }
 
-            if isLoadingMore {
-                ProgressView()
-                    .controlSize(.mini)
-                    .tint(.white.opacity(0.5))
-            } else if !activeQuery.isEmpty {
-                if searchMatchIndices.isEmpty {
+            if !activeQuery.isEmpty {
+                if isSearchScanning {
+                    ProgressView()
+                        .controlSize(.mini)
+                        .tint(.white.opacity(0.5))
+                }
+
+                if searchMatchIndices.isEmpty && !isSearchScanning {
                     Text("0 results")
                         .font(.caption2)
                         .foregroundStyle(.white.opacity(0.4))
-                } else {
-                    Text("\(currentMatchPosition + 1)/\(searchMatchIndices.count)\(searchMatchIndices.count >= Self.maxSearchResults ? "+" : "")")
+                } else if !searchMatchIndices.isEmpty {
+                    Text("\(currentMatchPosition + 1)/\(searchMatchIndices.count)\(isSearchScanning ? "…" : "")")
                         .font(.caption2)
                         .foregroundStyle(.white.opacity(0.6))
 
@@ -232,6 +259,8 @@ struct SessionHistoryView: View {
             activeQuery = ""
             searchMatchIndices = []
             currentMatchPosition = 0
+            searchScanTask?.cancel()
+            isSearchScanning = false
             return
         }
 
@@ -242,27 +271,42 @@ struct SessionHistoryView: View {
             try? await Task.sleep(for: .milliseconds(250))
             guard !Task.isCancelled else { return }
             activeQuery = searchText
-            updateSearchMatches()
+            startScan()
         }
     }
 
-    private func updateSearchMatches() {
-        guard !activeQuery.isEmpty else {
-            searchMatchIndices = []
-            currentMatchPosition = 0
-            return
-        }
-        let query = activeQuery.lowercased()
-        var indices: [Int] = []
-        for turn in turns {
-            if turn.textPreview.lowercased().contains(query)
-                || turn.contentBlocks.contains(where: { $0.text.lowercased().contains(query) }) {
-                indices.append(turn.index)
-                if indices.count >= Self.maxSearchResults { break }
+    private func startScan() {
+        searchScanTask?.cancel()
+        searchMatchIndices = []
+        currentMatchPosition = 0
+
+        guard let path = sessionPath, !activeQuery.isEmpty else { return }
+
+        isSearchScanning = true
+        let query = activeQuery
+        let maxResults = Self.maxSearchResults
+
+        searchScanTask = Task {
+            var matches: [Int] = []
+
+            for await matchIndex in TranscriptReader.scanForMatches(from: path, query: query) {
+                if Task.isCancelled { break }
+                matches.append(matchIndex)
+                if matches.count >= maxResults { break }
+
+                // Batch update UI every 20 matches or on first match
+                if matches.count == 1 || matches.count % 20 == 0 {
+                    searchMatchIndices = matches
+                    currentMatchPosition = max(0, matches.count - 1)
+                }
             }
+
+            guard !Task.isCancelled else { return }
+
+            searchMatchIndices = matches
+            currentMatchPosition = max(0, matches.count - 1)
+            isSearchScanning = false
         }
-        searchMatchIndices = indices
-        currentMatchPosition = max(0, indices.count - 1)
     }
 
     private func navigateSearch(forward: Bool) {
@@ -272,10 +316,17 @@ struct SessionHistoryView: View {
         } else {
             currentMatchPosition = (currentMatchPosition - 1 + searchMatchIndices.count) % searchMatchIndices.count
         }
+        // Ensure the target match turn is loaded
+        let targetIndex = searchMatchIndices[currentMatchPosition]
+        if !turns.contains(where: { $0.index == targetIndex }) {
+            onLoadAroundTurn?(targetIndex)
+        }
     }
 
     private func dismissSearch() {
         searchDebounceTask?.cancel()
+        searchScanTask?.cancel()
+        isSearchScanning = false
         showSearch = false
         isSearchFieldFocused = false
         searchText = ""
diff --git a/Sources/KanbanCodeCore/Adapters/ClaudeCode/ClaudeCodeActivityDetector.swift b/Sources/KanbanCodeCore/Adapters/ClaudeCode/ClaudeCodeActivityDetector.swift
@@ -89,7 +89,7 @@ public actor ClaudeCodeActivityDetector: ActivityDetector {
         }
 
         switch lastEvent.eventName {
-        case "UserPromptSubmit", "SessionStart":
+        case "UserPromptSubmit":
             // After a prompt, Claude is actively working. Stay in this state until:
             // 1. A Stop hook fires (handled by the "Stop" case below)
             // 2. File stale >3s AND last jsonl line is "[Request interrupted by user]"
@@ -121,6 +121,11 @@ public actor ClaudeCodeActivityDetector: ActivityDetector {
 
             return .activelyWorking
 
+        case "SessionStart":
+            // Session opened or resumed — Claude is at the prompt waiting for input.
+            // NOT actively working yet (that requires UserPromptSubmit).
+            return .idleWaiting
+
         case "Stop":
             // Stop is the definitive signal — immediately needs attention
             return .needsAttention
diff --git a/Sources/KanbanCodeCore/Adapters/ClaudeCode/TranscriptReader.swift b/Sources/KanbanCodeCore/Adapters/ClaudeCode/TranscriptReader.swift
@@ -90,6 +90,108 @@ public enum TranscriptReader {
         )
     }
 
+    /// Stream all conversation turns from a .jsonl file, yielding each turn as it's parsed.
+    /// Callers receive turns incrementally without waiting for the full file to load.
+    public static func streamAllTurns(from filePath: String) -> AsyncStream<ConversationTurn> {
+        AsyncStream { continuation in
+            let task = Task.detached {
+                guard FileManager.default.fileExists(atPath: filePath) else {
+                    continuation.finish()
+                    return
+                }
+                do {
+                    let url = URL(fileURLWithPath: filePath)
+                    let handle = try FileHandle(forReadingFrom: url)
+                    defer { try? handle.close() }
+
+                    var lineNumber = 0
+                    var turnIndex = 0
+
+                    for try await line in handle.bytes.lines {
+                        if Task.isCancelled { break }
+                        lineNumber += 1
+                        guard !line.isEmpty, line.contains("\"type\"") else { continue }
+
+                        guard let data = line.data(using: .utf8),
+                              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                              let type = obj["type"] as? String,
+                              type == "user" || type == "assistant" else { continue }
+
+                        let blocks: [ContentBlock]
+                        let textPreview: String
+
+                        if type == "user" {
+                            blocks = extractUserBlocks(from: obj)
+                            textPreview = buildTextPreview(blocks: blocks, role: type)
+                        } else {
+                            blocks = extractAssistantBlocks(from: obj)
+                            textPreview = buildTextPreview(blocks: blocks, role: type)
+                        }
+
+                        let timestamp = obj["timestamp"] as? String
+
+                        continuation.yield(ConversationTurn(
+                            index: turnIndex,
+                            lineNumber: lineNumber,
+                            role: type,
+                            textPreview: textPreview,
+                            timestamp: timestamp,
+                            contentBlocks: blocks
+                        ))
+                        turnIndex += 1
+                    }
+                } catch {
+                    // File read error — just finish the stream
+                }
+                continuation.finish()
+            }
+            continuation.onTermination = { _ in task.cancel() }
+        }
+    }
+
+    /// Lightweight scan for matching turn indices — no JSON parsing for non-matches.
+    /// Yields each matching turn index as found. Scans the full file but only does
+    /// case-insensitive string search on raw line text.
+    public static func scanForMatches(
+        from filePath: String,
+        query: String
+    ) -> AsyncStream<Int> {
+        AsyncStream { continuation in
+            let task = Task.detached {
+                guard FileManager.default.fileExists(atPath: filePath) else {
+                    continuation.finish()
+                    return
+                }
+                do {
+                    let url = URL(fileURLWithPath: filePath)
+                    let handle = try FileHandle(forReadingFrom: url)
+                    defer { try? handle.close() }
+
+                    var turnIndex = 0
+
+                    for try await line in handle.bytes.lines {
+                        if Task.isCancelled { break }
+                        guard !line.isEmpty, line.contains("\"type\"") else { continue }
+
+                        // Minimal JSON parse — just check if it's a user/assistant line
+                        guard let data = line.data(using: .utf8),
+                              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                              let type = obj["type"] as? String,
+                              type == "user" || type == "assistant" else { continue }
+
+                        // Case-insensitive search on the raw line text (covers all content)
+                        if line.range(of: query, options: .caseInsensitive) != nil {
+                            continuation.yield(turnIndex)
+                        }
+                        turnIndex += 1
+                    }
+                } catch { }
+                continuation.finish()
+            }
+            continuation.onTermination = { _ in task.cancel() }
+        }
+    }
+
     /// Load earlier turns before the current set (for "load more" pagination).
     public static func readRange(from filePath: String, turnRange: Range<Int>) async throws -> [ConversationTurn] {
         guard FileManager.default.fileExists(atPath: filePath) else { return [] }
