Skip to content

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.yml
index 2e00627d..cb60fb62 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -91,6 +91,9 @@ jobs:
- name: Run standalone onboarding regressions
run: 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.swift
index 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.swift
index 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 = false
private 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 = true
return 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.asr
diff --git a/Sources/Fluid/UI/ReleaseFeaturePreview.swift b/Sources/Fluid/UI/ReleaseFeaturePreview.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
index a75bca32..c0b157bf 100644
--- a/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swift
+++ b/Tests/FluidDictationIntegrationTests/MeetingSummaryInputTests.swift
@@ -1,3 +1,4 @@
+import Combine
@testable import FluidVoice_Debug
import Foundation
import 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.swift
index 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.swift
new file mode 100644
index 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.sh
new file mode 100644
index 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.md
new file mode 100644
index 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.