Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
Add reusable What’s New release highlights (#1005)
ALTIC46c945aac4d7
diff --git a/.github/workflows/build.yml b/.github/workflows/build.ymlindex 2e00627d..cb60fb62 100644--- a/.github/workflows/build.yml+++ b/.github/workflows/build.yml@@ -91,6 +91,9 @@ jobs:- name: Run standalone onboarding regressionsrun: sh Tests/run_onboarding_tests.sh+ - name: Run release highlights regressions+ run: sh Tests/run_release_highlights_tests.sh+# Tiny Whisper GGUF output is nondeterministic on hosted macOS runners.# Keep this E2E assertion in the suite for local validation, but skip it in CI.- name: Build and test (excluding flaky Tiny Whisper E2E)diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swiftindex 70aa9b70..76b26df8 100644--- a/Sources/Fluid/ContentView.swift+++ b/Sources/Fluid/ContentView.swift@@ -319,6 +319,7 @@ struct ContentView: View {@FocusState private var isSettingsSearchFocused: Bool@State private var playgroundUsed: Bool = SettingsStore.shared.playgroundUsed@State private var showsFluidIntelligenceDemo = false+ @State private var showsReleaseHighlights = false@State private var recordingAppInfo: (name: String, bundleId: String, windowTitle: String)? = nil@State private var recordingPrecedingText: String = ""@State private var recordingFocusTarget: TypingService.CapturedFocusTarget? = nil@@ -460,6 +461,13 @@ struct ContentView: View {self.handleSpokenSendPartialTranscription(text)}.overlay(alignment: .center) {}+ .modifier(ReleaseHighlightsPresenter(+ requested: self.$showsReleaseHighlights,+ isEligible: !self.settings.shouldShowOnboarding && !self.showsFluidIntelligenceDemo &&+ !self.asr.isRunningOrStarting && self.asr.activeExclusiveActivity == nil &&+ !self.asr.showError && !self.showRestartPrompt,+ onExplore: self.navigateToApp+ )).sheet(isPresented: self.$showsFluidIntelligenceDemo) {FluidIntelligenceDemoView(asr: self.asr,@@ -1635,6 +1643,8 @@ struct ContentView: View {private var helpEntryButton: some View {Menu {Button("Documentation", systemImage: "book") { self.openHelpDocumentation() }+ Button("What’s new", systemImage: "gift") { self.showsReleaseHighlights = true }+ .disabled(self.asr.isRunningOrStarting || self.asr.activeExclusiveActivity != nil || NotchContentState.shared.isProcessing)if PrivateAIProviderFeature.shared.isAvailable {Button("Try Fluid Intelligence", systemImage: "sparkles") { self.showsFluidIntelligenceDemo = true }.disabled(self.asr.isRunningOrStarting || NotchContentState.shared.isProcessing || DictationPromptTestCoordinator.shared.isActive)@@ -1674,7 +1684,7 @@ struct ContentView: View {.onHover { self.isHelpEntryHovered = $0 }.help("Open FluidVoice Help").accessibilityLabel("Help")- .accessibilityHint("Documentation, Fluid Intelligence demo, and replay onboarding")+ .accessibilityHint("What’s new, documentation, Fluid Intelligence demo, and replay onboarding")}private var modeTransitionAnimation: Animation {diff --git a/Sources/Fluid/Services/Meeting/MeetingSummaryController.swift b/Sources/Fluid/Services/Meeting/MeetingSummaryController.swiftindex b9384521..50f8fc2d 100644--- a/Sources/Fluid/Services/Meeting/MeetingSummaryController.swift+++ b/Sources/Fluid/Services/Meeting/MeetingSummaryController.swift@@ -53,6 +53,7 @@ nonisolated enum MeetingSummaryInput {final class MeetingSummaryActivityCoordinator: ObservableObject {static let shared = MeetingSummaryActivityCoordinator()private var processing: Set<UUID> = []+ @Published private(set) var isProcessing = falseprivate var summary: UUID?@Published private(set) var selectionLock: UUID?@@ -73,10 +74,14 @@ final class MeetingSummaryActivityCoordinator: ObservableObject {guard self.summary == nil else { return nil }let token = UUID()self.processing.insert(token)+ self.isProcessing = truereturn token}- func endProcessing(_ token: UUID) { self.processing.remove(token) }+ func endProcessing(_ token: UUID) {+ self.processing.remove(token)+ self.isProcessing = !self.processing.isEmpty+ }static func presentBusyError() {let asr = AppServices.shared.asrdiff --git a/Sources/Fluid/UI/ReleaseFeaturePreview.swift b/Sources/Fluid/UI/ReleaseFeaturePreview.swiftnew file mode 100644index 00000000..dbfe2e84--- /dev/null+++ b/Sources/Fluid/UI/ReleaseFeaturePreview.swift@@ -0,0 +1,115 @@+import SwiftUI++/// Static product illustrations: no live user data, model loading, or recording work.+struct ReleaseFeaturePreview: View {+ let kind: ReleaseHighlightsContent.Preview+ @Environment(\.theme) private var theme++ var body: some View {+ Group {+ switch self.kind {+ case .meeting: self.meeting+ case .dashboard: self.dashboard+ case .models: self.models+ }+ }+ .padding(16)+ .frame(maxWidth: .infinity, maxHeight: .infinity)+ .background(self.theme.palette.elevatedCardBackground)+ .overlay {+ RoundedRectangle(cornerRadius: 12)+ .strokeBorder(self.theme.palette.cardBorder, lineWidth: 1)+ }+ .foregroundStyle(self.theme.palette.primaryText)+ .allowsHitTesting(false)+ .accessibilityHidden(true)+ }++ private var meeting: some View {+ VStack(alignment: .leading, spacing: 12) {+ HStack(spacing: 7) {+ Image(systemName: "waveform").foregroundStyle(FluidBrandColors.blue)+ Text("Product catch-up").font(.system(size: 11, weight: .semibold))+ Spacer(minLength: 0)+ Text("12:48").font(.system(size: 9, design: .monospaced))+ .foregroundStyle(self.theme.palette.secondaryText)+ }+ HStack(alignment: .top, spacing: 8) {+ Circle().fill(FluidBrandColors.blue.opacity(0.18))+ .frame(width: 19, height: 19)+ .overlay(Text("A").font(.system(size: 9, weight: .medium)).foregroundStyle(FluidBrandColors.blue))+ VStack(alignment: .leading, spacing: 4) {+ Text("Let’s get the next release ready.")+ .font(.system(size: 10))+ Text("We’ll start with the new features.")+ .font(.system(size: 9)).foregroundStyle(self.theme.palette.secondaryText)+ }+ }+ VStack(alignment: .leading, spacing: 5) {+ Label("Summary", systemImage: "sparkles")+ .font(.system(size: 9, weight: .semibold))+ .foregroundStyle(FluidBrandColors.blue)+ Text("Review features. Prepare the release.")+ .font(.system(size: 9)).foregroundStyle(self.theme.palette.secondaryText)+ }+ .padding(9)+ .frame(maxWidth: .infinity, alignment: .leading)+ .background(self.theme.palette.cardBackground, in: RoundedRectangle(cornerRadius: 7))+ }+ }++ private var dashboard: some View {+ VStack(alignment: .leading, spacing: 11) {+ Text("Good morning.").font(.system(size: 16, weight: .semibold))+ HStack(spacing: 8) {+ self.stat("1,240", label: "WORDS DICTATED", symbol: "waveform")+ self.stat("24 min", label: "TIME SAVED", symbol: "clock")+ }+ HStack(spacing: 6) {+ Image(systemName: "magnifyingglass")+ Text("Search across FluidVoice")+ Spacer(minLength: 0)+ }+ .font(.system(size: 9))+ .foregroundStyle(self.theme.palette.secondaryText)+ .padding(8)+ .background(self.theme.palette.cardBackground, in: RoundedRectangle(cornerRadius: 7))+ }+ }++ private func stat(_ value: String, label: String, symbol: String) -> some View {+ VStack(alignment: .leading, spacing: 5) {+ Image(systemName: symbol).font(.system(size: 10)).foregroundStyle(FluidBrandColors.blue)+ Text(value).font(.system(size: 16, weight: .semibold, design: .rounded))+ Text(label).font(.system(size: 6, weight: .medium)).foregroundStyle(self.theme.palette.secondaryText)+ }+ .frame(maxWidth: .infinity, alignment: .leading)+ }++ private var models: some View {+ VStack(alignment: .leading, spacing: 10) {+ Label(PrivateAIProviderFeature.shared.isAvailable ? "Fluid Intelligence" : "AI Providers", systemImage: "sparkles")+ .font(.system(size: 11, weight: .semibold))+ if PrivateAIProviderFeature.shared.isAvailable {+ self.model("Fluid-1 Pico", detail: "Light & quick", symbol: "bolt")+ self.model("Fluid-1 Mini", detail: "Everyday writing", symbol: "text.alignleft")+ self.model("Fluid-1 Quad", detail: "More capable", symbol: "cpu")+ } else {+ self.model("Your provider", detail: "Your choice", symbol: "sparkles")+ self.model("Your model", detail: "Your workflow", symbol: "cpu")+ }+ }+ }++ private func model(_ name: String, detail: String, symbol: String) -> some View {+ HStack(spacing: 8) {+ Image(systemName: symbol)+ .font(.system(size: 11)).foregroundStyle(FluidBrandColors.blue)+ .frame(width: 23, height: 23)+ .background(FluidBrandColors.blue.opacity(0.1), in: RoundedRectangle(cornerRadius: 6))+ Text(name).font(.system(size: 10, weight: .medium))+ Spacer(minLength: 0)+ Text(detail).font(.system(size: 8)).foregroundStyle(self.theme.palette.secondaryText)+ }+ }+}diff --git a/Sources/Fluid/UI/ReleaseHighlightsContent.swift b/Sources/Fluid/UI/ReleaseHighlightsContent.swiftnew file mode 100644index 00000000..f1d531a5--- /dev/null+++ b/Sources/Fluid/UI/ReleaseHighlightsContent.swift@@ -0,0 +1,61 @@+import Foundation++/// Edit this definition for each release. The renderer and acknowledgement logic stay unchanged.+struct ReleaseHighlightsContent {+ enum Destination { case meetings, dashboard, aiProviders }+ enum Preview { case meeting, dashboard, models }++ struct Feature: Identifiable {+ let id: String+ let preview: Preview+ let eyebrow: String+ let title: String+ let detail: String+ let action: String+ let destination: Destination+ }++ let release: String+ let title: String+ let subtitle: String+ let features: [Feature]++ static func current(hasPrivateAI: Bool) -> Self {+ Self(+ release: "1.6.10",+ title: "Say hello to what’s new.",+ subtitle: "Three new ways to make FluidVoice yours.",+ features: [+ Feature(+ id: "fluidmeet",+ preview: .meeting,+ eyebrow: "MEETINGS, MEET FLUID",+ title: "Introducing FluidMeet",+ detail: "Stay in the conversation. Local recording, live captions, and AI summaries.",+ action: "Open FluidMeet",+ destination: .meetings+ ),+ Feature(+ id: "redesign",+ preview: .dashboard,+ eyebrow: "A FRESH PERSPECTIVE",+ title: "Beautifully redesigned",+ detail: "Your own dashboard. Search across the app. Everything feels right at home.",+ action: "See the new look",+ destination: .dashboard+ ),+ Feature(+ id: "models",+ preview: .models,+ eyebrow: hasPrivateAI ? "ON YOUR MAC. FOR YOU." : "YOUR AI, YOUR WAY",+ title: hasPrivateAI ? "Meet the Fluid models" : "Find your AI",+ detail: hasPrivateAI+ ? "Fast cleanup to thoughtful rewrites. Explore local AI built for your words."+ : "Choose your AI provider and make every dictation sound more like you.",+ action: hasPrivateAI ? "Explore the models" : "Explore AI providers",+ destination: .aiProviders+ ),+ ]+ )+ }+}diff --git a/Sources/Fluid/UI/ReleaseHighlightsPolicy.swift b/Sources/Fluid/UI/ReleaseHighlightsPolicy.swiftnew file mode 100644index 00000000..31f1233b--- /dev/null+++ b/Sources/Fluid/UI/ReleaseHighlightsPolicy.swift@@ -0,0 +1,84 @@+import Foundation++/// Main-thread callers serialize requests; tokens reject delayed callbacks from old sheets.+struct ReleaseHighlightsPolicy {+ static let seenKey = "FluidVoiceSeenReleaseHighlightVersions"+ static let historyLimit = 32++ struct Session: Equatable, Identifiable {+ let id = UUID()+ let owner: UUID+ let version: String+ let manual: Bool+ var dismissing = false+ var acknowledge = false+ }++ private(set) var seenVersions: [String]+ private(set) var session: Session?+ private var manualRequests: Set<UUID> = []++ init(seenVersions: [String] = []) {+ var unique: [String] = []+ for version in seenVersions where !version.isEmpty {+ unique.removeAll { $0 == version }+ unique.append(version)+ }+ self.seenVersions = Array(unique.suffix(Self.historyLimit))+ }++ static func matches(version: String, release: String) -> Bool {+ !release.isEmpty && (version == release || version.hasPrefix(release + "-"))+ }++ mutating func requestManual(owner: UUID) {+ // Repeated requests for an already-open sheet must not queue a second popup.+ guard self.session?.owner != owner else { return }+ self.manualRequests.insert(owner)+ }++ mutating func request(owner: UUID, version: String, release: String, eligible: Bool, manual: Bool = false) -> Session? {+ if manual { self.requestManual(owner: owner) }+ guard eligible, self.session == nil, Self.matches(version: version, release: release),+ self.manualRequests.contains(owner) || !self.seenVersions.contains(version) else { return nil }+ let session = Session(owner: owner, version: version, manual: self.manualRequests.contains(owner))+ self.manualRequests.remove(owner)+ self.session = session+ return session+ }++ mutating func beginDismiss(id: UUID, acknowledge: Bool) -> Bool {+ guard var session = self.session, session.id == id, !session.dismissing else { return false }+ session.dismissing = true+ session.acknowledge = acknowledge+ self.session = session+ return true+ }++ mutating func interrupt(id: UUID) {+ guard var session = self.session, session.id == id else { return }+ session.dismissing = true+ session.acknowledge = false+ self.session = session+ }++ /// Returns nil for stale callbacks. A system dismissal counts as a close only if still eligible.+ mutating func finishDismiss(id: UUID, eligible: Bool) -> Bool? {+ guard let session = self.session, session.id == id else { return nil }+ self.session = nil+ let acknowledged = eligible && (!session.dismissing || session.acknowledge)+ if !acknowledged, session.manual { self.manualRequests.insert(session.owner) }+ if acknowledged {+ self.seenVersions.removeAll { $0 == session.version }+ self.seenVersions.append(session.version)+ self.seenVersions = Array(self.seenVersions.suffix(Self.historyLimit))+ }+ return acknowledged+ }++ mutating func abandon(owner: UUID) {+ self.manualRequests.remove(owner)+ guard self.session?.owner == owner else { return }+ self.session = nil+ }+}diff --git a/Sources/Fluid/UI/ReleaseHighlightsPresenter.swift b/Sources/Fluid/UI/ReleaseHighlightsPresenter.swiftnew file mode 100644index 00000000..a57fabb2--- /dev/null+++ b/Sources/Fluid/UI/ReleaseHighlightsPresenter.swift@@ -0,0 +1,160 @@+import AppKit+import Combine+import SwiftUI++@MainActor+private final class ReleaseHighlightsCoordinator {+ static let shared = ReleaseHighlightsCoordinator()+ private var policy = ReleaseHighlightsPolicy(seenVersions: UserDefaults.standard.stringArray(forKey: ReleaseHighlightsPolicy.seenKey) ?? [])++ func request(owner: UUID, version: String, release: String, eligible: Bool, manual: Bool) -> ReleaseHighlightsPolicy.Session? {+ self.policy.request(owner: owner, version: version, release: release, eligible: eligible, manual: manual)+ }++ func requestManual(owner: UUID) { self.policy.requestManual(owner: owner) }++ func beginDismiss(id: UUID) -> Bool { self.policy.beginDismiss(id: id, acknowledge: true) }+ func interrupt(id: UUID) { self.policy.interrupt(id: id) }+ func abandon(owner: UUID) { self.policy.abandon(owner: owner) }++ func finishDismiss(id: UUID, eligible: Bool) -> Bool? {+ let result = self.policy.finishDismiss(id: id, eligible: eligible)+ if result == true {+ UserDefaults.standard.set(self.policy.seenVersions, forKey: ReleaseHighlightsPolicy.seenKey)+ }+ return result+ }+}++struct ReleaseHighlightsPresenter: ViewModifier {+ @Binding var requested: Bool+ let isEligible: Bool+ let onExplore: (SidebarItem) -> Void+ @Environment(\.scenePhase) private var scenePhase+ @State private var owner = UUID()+ @State private var host = WindowReference()+ @State private var visible = false+ @State private var processing = false+ @State private var refining = false+ @State private var isPresented = false+ @State private var session: ReleaseHighlightsPolicy.Session?+ @State private var pendingDestination: ReleaseHighlightsContent.Destination?+ private let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? ""+ private let highlights = ReleaseHighlightsContent.current(hasPrivateAI: PrivateAIProviderFeature.shared.isAvailable)+ private let coordinator = ReleaseHighlightsCoordinator.shared++ private final class WindowReference { weak var window: NSWindow? }++ private var canExplore: Bool { self.isEligible && !self.processing && !self.refining }++ func body(content: Content) -> some View {+ content+ .background(ReleaseHighlightsWindowReader { window in+ self.host.window = window+ self.presentIfNeeded()+ })+ .sheet(isPresented: self.$isPresented, onDismiss: self.didDismiss) {+ ReleaseHighlightsView(canExplore: self.canExplore, content: self.highlights, onClose: self.close)+ }+ .onAppear { self.visible = true; self.presentIfNeeded() }+ .onDisappear {+ self.visible = false+ self.pendingDestination = nil+ self.session = nil+ self.isPresented = false+ self.coordinator.abandon(owner: self.owner)+ }+ .onChange(of: self.isEligible) { _, _ in self.eligibilityChanged() }+ .onReceive(NotchContentState.shared.$isProcessing.removeDuplicates()) { processing in+ self.processing = processing+ self.eligibilityChanged()+ }+ .onReceive(MeetingSummaryActivityCoordinator.shared.$isProcessing.removeDuplicates()) { refining in+ self.refining = refining+ self.eligibilityChanged()+ }+ .onChange(of: self.scenePhase) { _, phase in+ if phase == .active { self.presentIfNeeded() }+ }+ .onReceive(NotificationCenter.default.publisher(for: NSWindow.didBecomeKeyNotification)) { _ in self.presentIfNeeded() }+ .onReceive(NotificationCenter.default.publisher(for: NSWindow.didEndSheetNotification)) { _ in self.presentIfNeeded() }+ .onChange(of: self.requested) { _, requested in+ guard requested else { return }+ self.coordinator.requestManual(owner: self.owner)+ self.requested = false+ self.presentIfNeeded()+ }+ }++ private func presentIfNeeded(manual: Bool = false) {+ guard self.visible, self.session == nil, let window = self.host.window,+ window.isKeyWindow, window.attachedSheet == nil, NSApp.isActive else { return }+ guard let session = self.coordinator.request(+ owner: self.owner,+ version: self.version,+ release: self.highlights.release,+ eligible: self.canExplore,+ manual: manual+ ) else { return }+ self.session = session+ self.pendingDestination = nil+ self.isPresented = true+ }++ private func eligibilityChanged() {+ if self.canExplore {+ self.presentIfNeeded()+ } else if let session = self.session {+ self.coordinator.interrupt(id: session.id)+ self.pendingDestination = nil+ self.isPresented = false+ }+ }++ private func close(_ destination: ReleaseHighlightsContent.Destination?) {+ guard let session = self.session, self.coordinator.beginDismiss(id: session.id) else { return }+ self.pendingDestination = self.canExplore ? destination : nil+ self.isPresented = false+ }++ private func didDismiss() {+ guard let session = self.session else { return }+ let result = self.coordinator.finishDismiss(id: session.id, eligible: self.canExplore)+ let destination = self.pendingDestination+ self.session = nil+ self.pendingDestination = nil+ if result == true, self.canExplore, self.visible, let destination {+ switch destination {+ case .meetings: self.onExplore(.meetingTranscription)+ case .dashboard: self.onExplore(.welcome)+ case .aiProviders: self.onExplore(.aiEnhancements)+ }+ } else if result == false {+ self.presentIfNeeded()+ }+ }+}++/// Reports only attachment changes. Never inspects hardware or polls windows.+private struct ReleaseHighlightsWindowReader: NSViewRepresentable {+ let onWindow: (NSWindow?) -> Void++ func makeNSView(context _: Context) -> WindowView {+ let view = WindowView()+ view.onWindow = self.onWindow+ return view+ }++ func updateNSView(_ view: WindowView, context _: Context) { view.onWindow = self.onWindow }++ final class WindowView: NSView {+ var onWindow: ((NSWindow?) -> Void)?+ override func viewDidMoveToWindow() {+ super.viewDidMoveToWindow()+ Task { @MainActor [weak self] in+ guard let self else { return }+ self.onWindow?(self.window)+ }+ }+ }+}diff --git a/Sources/Fluid/UI/ReleaseHighlightsView.swift b/Sources/Fluid/UI/ReleaseHighlightsView.swiftnew file mode 100644index 00000000..60701ace--- /dev/null+++ b/Sources/Fluid/UI/ReleaseHighlightsView.swift@@ -0,0 +1,83 @@+import SwiftUI++struct ReleaseHighlightsView: View {+ let canExplore: Bool+ let content: ReleaseHighlightsContent+ let onClose: (ReleaseHighlightsContent.Destination?) -> Void+ @Environment(\.theme) private var theme++ var body: some View {+ VStack(alignment: .leading, spacing: 28) {+ HStack(alignment: .top) {+ VStack(alignment: .leading, spacing: 10) {+ Text("FLUIDVOICE \(self.content.release)")+ .font(self.theme.typography.captionStrong)+ .tracking(2)+ .foregroundStyle(self.theme.palette.secondaryText)+ Text(self.content.title)+ .font(.system(size: 30, weight: .semibold))+ .foregroundStyle(self.theme.palette.primaryText)+ .accessibilityAddTraits(.isHeader)+ Text(self.content.subtitle)+ .font(self.theme.typography.body)+ .foregroundStyle(self.theme.palette.secondaryText)+ }+ Spacer()+ Button { self.onClose(nil) } label: {+ Image(systemName: "xmark")+ }+ .fluidGlassAction(circular: true, quiet: true)+ .accessibilityLabel("Close what’s new")+ .help("Close (Esc)")+ }+ HStack(alignment: .top, spacing: 18) {+ ForEach(self.content.features) { feature in+ self.feature(feature)+ }+ }+ Text("Always here in Help → What’s new.")+ .font(self.theme.typography.caption)+ .foregroundStyle(self.theme.palette.tertiaryText)+ .frame(maxWidth: .infinity)+ }+ .padding(30)+ .frame(width: 800)+ .background(self.theme.palette.contentBackground)+ .onExitCommand { self.onClose(nil) }+ }++ private func feature(_ feature: ReleaseHighlightsContent.Feature) -> some View {+ VStack(alignment: .leading, spacing: 0) {+ ReleaseFeaturePreview(kind: feature.preview)+ .frame(height: 156)+ .clipped()+ .clipShape(RoundedRectangle(cornerRadius: 12))+ .accessibilityHidden(true)+ .padding(.bottom, 20)+ Text(feature.eyebrow)+ .font(.system(size: 9, weight: .semibold))+ .tracking(1)+ .foregroundStyle(self.theme.palette.secondaryText)+ .padding(.bottom, 8)+ Text(feature.title)+ .font(.system(size: 17, weight: .semibold))+ .foregroundStyle(self.theme.palette.primaryText)+ .accessibilityAddTraits(.isHeader)+ .padding(.bottom, 10)+ Text(feature.detail)+ .font(self.theme.typography.bodySmall)+ .foregroundStyle(self.theme.palette.secondaryText)+ .lineSpacing(3)+ .fixedSize(horizontal: false, vertical: true)+ .frame(minHeight: 68, alignment: .topLeading)+ FluidGlassControlGroup {+ Button(feature.action, systemImage: "arrow.up.right") { self.onClose(feature.destination) }+ .fluidGlassAction()+ .disabled(!self.canExplore)+ }+ .padding(.top, 18)+ }+ .frame(maxWidth: .infinity, alignment: .leading)+ .accessibilityElement(children: .contain)+ }+}diff --git a/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swift b/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swiftindex a75bca32..c0b157bf 100644--- a/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swift+++ b/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swift@@ -1,3 +1,4 @@+import Combine@testable import FluidVoice_Debugimport Foundationimport XCTest@@ -134,10 +135,17 @@ final class MeetingSummaryActivityTests: XCTestCase {func testProcessingBlocksSummaryWithoutTouchingAudioAndStaleReleaseCannotUnlock() async throws {let gate = MeetingSummaryActivityCoordinator()let activity = Activity()+ var published: [Bool] = []+ let observation = gate.$isProcessing.removeDuplicates().sink { published.append($0) }+ defer { observation.cancel() }+ XCTAssertFalse(gate.isProcessing)let first = try XCTUnwrap(gate.beginProcessing())+ XCTAssertTrue(gate.isProcessing)let second = try XCTUnwrap(gate.beginProcessing())gate.endProcessing(first)+ XCTAssertTrue(gate.isProcessing)gate.endProcessing(first)+ XCTAssertTrue(gate.isProcessing)do {try await gate.withSummary(activity: activity) { XCTFail("Must not begin") }XCTFail("Second processing token must still block")@@ -145,6 +153,8 @@ final class MeetingSummaryActivityTests: XCTestCase {XCTAssertEqual(activity.handoffs, 0)XCTAssertNil(activity.active)gate.endProcessing(second)+ XCTAssertFalse(gate.isProcessing)+ XCTAssertEqual(published, [false, true, false])try await gate.withSummary(activity: activity) {}XCTAssertEqual(activity.handbacks, 1)}diff --git a/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift b/Tests/FluidDictationIntegrationTests/SearchIndexTests.swiftindex 17a4afeb..b7bff1cb 100644--- a/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift+++ b/Tests/FluidDictationIntegrationTests/SearchIndexTests.swift@@ -225,10 +225,14 @@ final class SearchIndexCoordinatorTests: XCTestCase {}private func indexedIDs(_ index: SearchIndex) async throws -> Set<UUID> {- // Check emptiness directly before exercising lexical lookup.- let recordCount = try await index.namespace(.history).count().count- guard recordCount > 0 else { return [] }- return try Set(await index.query(.history, text: "startup", limit: 50).map(\.id))+ // Inspect membership directly: reconciliation can delete the last record+ // between a separate count and lexical query, which rejects an empty index.+ let store = try await index.namespace(.history)+ var ids = Set<UUID>()+ for try await document in store.documents(fields: []) {+ ids.insert(document.id.uuid)+ }+ return ids}private func waitForIndexedIDs(_ expected: Set<UUID>, in index: SearchIndex) async throws {diff --git a/Tests/ReleaseHighlightsPolicyTests.swift b/Tests/ReleaseHighlightsPolicyTests.swiftnew file mode 100644index 00000000..e13b88ae--- /dev/null+++ b/Tests/ReleaseHighlightsPolicyTests.swift@@ -0,0 +1,103 @@+import Foundation++@main+struct ReleaseHighlightsPolicyTests {+ static func main() throws {+ let owner = UUID()+ let other = UUID()+ var policy = ReleaseHighlightsPolicy()+ for version in ["1.6.9", "1.6.11", "1.6.100", "", "unknown"] {+ precondition(policy.request(owner: owner, version: version, release: "1.6.10", eligible: true) == nil)+ }+ precondition(policy.request(owner: owner, version: "1.6.10-beta.7", release: "1.6.10", eligible: false) == nil)+ let first = try require(policy.request(owner: owner, version: "1.6.10-beta.7", release: "1.6.10", eligible: true))+ precondition(policy.seenVersions.isEmpty, "Opening alone must not acknowledge an interrupted popup")+ precondition(policy.request(owner: other, version: first.version, release: "1.6.10", eligible: true) == nil, "One presentation across windows")+ precondition(policy.beginDismiss(id: first.id, acknowledge: true))+ precondition(!policy.beginDismiss(id: first.id, acknowledge: true), "A double click cannot replace the first destination")+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true, manual: true) == nil, "Dismissal keeps ownership until completion")+ precondition(policy.finishDismiss(id: UUID(), eligible: true) == nil)+ precondition(policy.session?.id == first.id, "Stale callbacks cannot release another sheet")+ precondition(policy.finishDismiss(id: first.id, eligible: true) == true)+ precondition(policy.seenVersions == [first.version])+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true) == nil)++ // A Help click during refinement survives ineligibility and replays an acknowledged version.+ policy.requestManual(owner: owner)+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: false) == nil)+ let deferred = try require(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true))+ policy.requestManual(owner: owner)+ precondition(policy.finishDismiss(id: deferred.id, eligible: true) == true)+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true) == nil, "An open-sheet request must not reopen after dismissal")+ policy.requestManual(owner: owner)+ policy.abandon(owner: owner)+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true) == nil, "Closing the host cancels deferred manual intent")++ // Manual replay, interruption during dismissal, and safe deferred retry.+ let replay = try require(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true, manual: true))+ precondition(policy.beginDismiss(id: replay.id, acknowledge: true))+ policy.interrupt(id: replay.id)+ precondition(policy.finishDismiss(id: replay.id, eligible: false) == false)+ precondition(policy.seenVersions == [first.version])+ let resumedReplay = try require(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true))+ precondition(policy.finishDismiss(id: resumedReplay.id, eligible: true) == true)+ let next = try require(policy.request(owner: other, version: "1.6.10-beta.8", release: "1.6.10", eligible: true))+ policy.interrupt(id: next.id)+ precondition(policy.finishDismiss(id: next.id, eligible: true) == false, "Recovery before onDismiss must not acknowledge an interruption")+ let retry = try require(policy.request(owner: other, version: next.version, release: "1.6.10", eligible: true))+ policy.abandon(owner: owner)+ precondition(policy.session?.id == retry.id, "Another window cannot cancel this owner")+ policy.abandon(owner: other)+ precondition(policy.session == nil)+ precondition(policy.finishDismiss(id: retry.id, eligible: true) == nil)+ precondition(!policy.seenVersions.contains(next.version), "Closing the host must not lose unseen updates")++ // Every shipped version is independent; rebuilds of the same version do not repeat.+ for version in ["1.6.10-beta.8", "1.6.10", "1.6.11"] {+ let release = version == "1.6.11" ? "1.6.11" : "1.6.10"+ let session = try require(policy.request(owner: owner, version: version, release: release, eligible: true))+ precondition(policy.finishDismiss(id: session.id, eligible: true) == true)+ precondition(policy.request(owner: owner, version: version, release: release, eligible: true) == nil)+ }+ precondition(policy.request(owner: owner, version: first.version, release: "1.6.10", eligible: true) == nil, "Downgrades do not repeat an acknowledged update")+ var bounded = ReleaseHighlightsPolicy(seenVersions: [""] + (0..<80).map { "1.0.\($0)" } + ["1.0.79"])+ precondition(bounded.seenVersions.count == ReleaseHighlightsPolicy.historyLimit)+ let boundedSession = try require(bounded.request(owner: owner, version: "2.0.0", release: "2.0.0", eligible: true))+ precondition(bounded.finishDismiss(id: boundedSession.id, eligible: true) == true)+ precondition(bounded.seenVersions.count == ReleaseHighlightsPolicy.historyLimit)+ precondition(bounded.seenVersions.last == "2.0.0")++ // Durable round-trip uses the same standard UserDefaults array representation as production.+ let suite = "ReleaseHighlightsTests.\(UUID().uuidString)"+ let defaults = try require(UserDefaults(suiteName: suite))+ defer { defaults.removePersistentDomain(forName: suite) }+ defaults.set(policy.seenVersions, forKey: ReleaseHighlightsPolicy.seenKey)+ let restored = ReleaseHighlightsPolicy(seenVersions: defaults.stringArray(forKey: ReleaseHighlightsPolicy.seenKey) ?? [])+ precondition(restored.seenVersions == policy.seenVersions)++ let plist = try Data(contentsOf: URL(fileURLWithPath: "Info.plist"))+ let info = try require(PropertyListSerialization.propertyList(from: plist, format: nil) as? [String: Any])+ let version = try require(info["CFBundleShortVersionString"] as? String)+ for privateAI in [false, true] {+ let content = ReleaseHighlightsContent.current(hasPrivateAI: privateAI)+ precondition(ReleaseHighlightsPolicy.matches(version: version, release: content.release), "Update release highlights when bumping the app version")+ precondition((1...3).contains(content.features.count))+ precondition(Set(content.features.map(\.id)).count == content.features.count)+ for feature in content.features {+ precondition(!feature.title.isEmpty && !feature.detail.isEmpty && !feature.action.isEmpty)+ }+ if !privateAI {+ let last = try require(content.features.last)+ precondition(!last.title.contains("Fluid models"))+ }+ }+ print("PASS: version ledger, persistence, multiple owners, rapid dismissal, interruption/retry, stale callbacks, bounded history, and release content")+ }++ private static func require<T>(_ value: T?) throws -> T {+ guard let value else { throw TestFailure.missingValue }+ return value+ }++ private enum TestFailure: Error { case missingValue }+}diff --git a/Tests/run_release_highlights_tests.sh b/Tests/run_release_highlights_tests.shnew file mode 100644index 00000000..20cebc0b--- /dev/null+++ b/Tests/run_release_highlights_tests.sh@@ -0,0 +1,10 @@+#!/bin/sh+set -eu+cd "$(dirname "$0")/.."+task_developer_dir="${DEVELOPER_DIR:-$(xcode-select -p)}"+test -d "$task_developer_dir/Platforms/MacOSX.platform"+export DEVELOPER_DIR="$task_developer_dir"+task_test_dir=$(mktemp -d /tmp/fluidvoice-highlights.XXXXXX)+trap 'rm -rf "$task_test_dir"' EXIT+xcrun swiftc -parse-as-library Sources/Fluid/UI/ReleaseHighlightsPolicy.swift Sources/Fluid/UI/ReleaseHighlightsContent.swift Tests/ReleaseHighlightsPolicyTests.swift -o "$task_test_dir/tests"+"$task_test_dir/tests"diff --git a/docs/whats-new.md b/docs/whats-new.mdnew file mode 100644index 00000000..f492eac2--- /dev/null+++ b/docs/whats-new.md@@ -0,0 +1,22 @@+# What’s New release maintenance++`Sources/Fluid/UI/ReleaseHighlightsContent.swift` is the release definition. Keep the shared presenter, layout, and controls unchanged when updating copy.++For each release:++1. Set `release` to the stable version family (for example `1.6.11`). Its beta versions use the same content.+2. Replace the title, subtitle, and one to three feature entries. Each entry has a stable ID, preview, short copy, action label, and typed destination. Keep private-only features conditional.+3. Reuse a preview kind or add a small static product illustration in `ReleaseFeaturePreview.swift`. Do not load models, user documents, hardware state, or network data for a preview.+4. Run `sh Tests/run_release_highlights_tests.sh` with a full Xcode selected. CI runs this too and rejects content that does not match `Info.plist`.+5. Check the installed popup in both appearances, its X/Escape close actions, and each destination. Keep the separate release notes updated.++## Presentation contract++- Automatically appears in the active main window when onboarding and blocking work have finished. It waits for other sheets to close.+- A main-thread coordinator grants one presentation at a time across windows. Session tokens reject stale dismissal callbacks.+- Acknowledge the full marketing version only after dismissal, including beta suffixes. Beta 7, beta 8, and stable are separate updates; rebuilding the same version does not repeat the popup.+- Store the last 32 acknowledged versions in the local `FluidVoiceSeenReleaseHighlightVersions` preference. No telemetry is sent. Recent downgrades do not repeat acknowledged highlights.+- If recording/processing starts, close without acknowledging or navigating. Retry when eligible. Closing the host window also releases ownership without acknowledging.+- Feature buttons dismiss first, then navigate only if the app is still eligible. Double clicks cannot queue multiple destinations. Closing with X/Escape never navigates.+- Help → What’s new reopens the current release manually, even after acknowledgement.+- Copy edits within an already-acknowledged app version do not reopen the popup. Bump the app version when shipping a new update. Unknown version families never display stale highlights.