Fix LazyVStack cell hangs: definite scroll heights + cached coloredOutput

clients/macos/vellum-assistant/Features/Chat/AssistantProgressView.swift

@@ -1012,11 +1012,12 @@ private struct StepDetailRow: View {
         copyText: String,
         copyLabel: String
     ) -> some View {
-        let lineCount = copyText.components(separatedBy: "\n").count
+        let lineCount = copyText.utf8.reduce(1) { count, byte in byte == 0x0A ? count + 1 : count }
+        let isLong = lineCount > 500 || copyText.count > 50_000
 
         ZStack(alignment: .topTrailing) {
             VStack(alignment: .leading, spacing: VSpacing.xs) {
-                if lineCount > 500 {
+                if isLong {
                     // Content at 500+ lines always exceeds 400pt, so a fixed
                     // height lets sizeThatFits return without measuring content.
                     ScrollView {

clients/shared/DesignSystem/Modifiers/LazyVStackScrollFrameModifier.swift

@@ -3,21 +3,30 @@ import SwiftUI
 extension View {
     /// Applies an adaptive height constraint to a `ScrollView` inside a `LazyVStack` cell.
     ///
-    /// For content exceeding `lineThreshold` lines, a definite `frame(height:)` is used so
-    /// `LazyVStack` can skip scroll-content measurement during cell sizing. For shorter content
-    /// `frame(maxHeight:)` is used so the view collapses to its natural height instead of
-    /// rendering with blank space.
+    /// For content exceeding `lineThreshold` lines **or** `charThreshold` characters, a definite
+    /// `frame(height:)` is used so `LazyVStack` can skip scroll-content measurement during cell
+    /// sizing. The character threshold catches single-line mega-strings (e.g. base64 data,
+    /// minified JSON) that would otherwise trigger an expensive Core Text width measurement.
+    /// For shorter content `frame(maxHeight:)` is used so the view collapses to its natural
+    /// height instead of rendering with blank space.
     ///
     /// - Parameters:
-    ///   - text: The string whose line count determines which constraint is applied.
+    ///   - text: The string whose size determines which constraint is applied.
     ///   - maxHeight: The height cap applied in both branches.
     ///   - lineThreshold: Line count above which the fixed height is used. Default: 500.
+    ///   - charThreshold: Character count above which the fixed height is used. Default: 50 000.
+    ///   - lineCount: Pre-computed line count. When provided, the modifier skips its
+    ///     internal `countLines` scan. Use this when the caller caches the line count
+    ///     via `@State` to avoid redundant O(n) work on re-render.
     func adaptiveScrollFrame(
         for text: String,
         maxHeight: CGFloat,
-        lineThreshold: Int = 500
+        lineThreshold: Int = 500,
+        charThreshold: Int = 50_000,
+        lineCount: Int? = nil
     ) -> some View {
-        let isLong = countLines(in: text) > lineThreshold
+        let lines = lineCount ?? countLines(in: text)
+        let isLong = lines > lineThreshold || text.count > charThreshold
         return self
             .frame(height: isLong ? maxHeight : nil)
             .frame(maxHeight: isLong ? nil : maxHeight)

clients/shared/Features/Chat/ToolCallChip.swift

@@ -237,7 +237,7 @@ public struct ToolCallChip: View {
                                             .frame(maxWidth: .infinity, alignment: .leading)
                                             .textSelection(.enabled)
                                     }
-                                    .adaptiveScrollFrame(for: result, maxHeight: 400)
+                                    .adaptiveScrollFrame(for: result, maxHeight: 400, lineCount: lineCount)
                                 }
                             }
                         }

clients/shared/Features/Chat/ToolCallProgressBar.swift

@@ -5,6 +5,9 @@ import SwiftUI
 public struct ToolCallProgressBar: View {
     public let toolCalls: [ToolCallData]
     @State private var expandedStepId: UUID?
+    /// Cached line count for the expanded tool call's result text — avoids O(n)
+    /// byte scan on every SwiftUI render pass when a step is expanded.
+    @State private var cachedResultLineCount: Int?
 
     public init(toolCalls: [ToolCallData]) {
         self.toolCalls = toolCalls
@@ -250,12 +253,29 @@ public struct ToolCallProgressBar: View {
                                 .frame(maxWidth: .infinity, alignment: .leading)
                                 .textSelection(.enabled)
                         }
-                        .adaptiveScrollFrame(for: result, maxHeight: 200)
+                        .adaptiveScrollFrame(for: result, maxHeight: 200, lineThreshold: 200, lineCount: cachedResultLineCount)
                     }
                 }
             }
         }
         .padding(VSpacing.md)
+        .onAppear {
+            if cachedResultLineCount == nil,
+               let expandedId = expandedStepId,
+               let expandedCall = toolCalls.first(where: { $0.id == expandedId }),
+               let result = expandedCall.result {
+                cachedResultLineCount = ToolCallChip.countLines(in: result)
+            }
+        }
+        .onChange(of: expandedStepId) {
+            if let expandedId = expandedStepId,
+               let expandedCall = toolCalls.first(where: { $0.id == expandedId }),
+               let result = expandedCall.result {
+                cachedResultLineCount = ToolCallChip.countLines(in: result)
+            } else {
+                cachedResultLineCount = nil
+            }
+        }
         .background(
             RoundedRectangle(cornerRadius: VRadius.md)
                 .fill(VColor.surfaceOverlay)