@hasna/recordings 0.3.13 → 0.4.0

package/src/native/Recordings/RecordingsLib/RecordingGlassBackground.swift

@@ -0,0 +1,34 @@
+import SwiftUI
+import AppKit
+
+/// One live macOS material per surface. No opaque tint below the blur and no
+/// per-meter-tick Liquid Glass surfaces; content remains legible in accessibility mode.
+public struct RecordingGlassBackground: View {
+    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency
+    public var radius: CGFloat
+    public init(radius: CGFloat = 16) { self.radius = radius }
+    public var body: some View {
+        ZStack {
+            if ChromeSurface.forReducedTransparency(reduceTransparency) == .opaque {
+                Color(NSColor.windowBackgroundColor)
+            } else {
+                NativeRecordingGlass()
+                LinearGradient(colors: [.white.opacity(0.18), .clear, .white.opacity(0.06)], startPoint: .topLeading, endPoint: .bottomTrailing)
+            }
+        }
+        .clipShape(RoundedRectangle(cornerRadius: radius))
+        .overlay(RoundedRectangle(cornerRadius: radius).strokeBorder(.white.opacity(0.45), lineWidth: 0.5))
+    }
+}
+
+private struct NativeRecordingGlass: NSViewRepresentable {
+    func makeNSView(context: Context) -> NSVisualEffectView {
+        let view = NSVisualEffectView()
+        view.material = .hudWindow
+        view.alphaValue = 0.9
+        view.blendingMode = .behindWindow
+        view.state = .active
+        return view
+    }
+    func updateNSView(_ view: NSVisualEffectView, context: Context) {}
+}

package/src/native/Recordings/RecordingsLib/RecordingProvider.swift

@@ -0,0 +1,102 @@
+import Foundation
+
+/// A separate application must opt into its own filesystem and preferences roots.
+/// This configuration never installs shortcuts or uses the legacy provider, Keychain,
+/// environment variables, helper CLI, or service connection. Providers own their credentials.
+public struct RecordingEngineConfiguration: Sendable {
+    public let isolatedHomePath: String
+    public let preferencesSuiteName: String
+
+    public init(isolatedHomePath: String, preferencesSuiteName: String) throws {
+        let path = URL(fileURLWithPath: isolatedHomePath).standardizedFileURL.resolvingSymlinksInPath()
+        let liveHome = FileManager.default.homeDirectoryForCurrentUser.resolvingSymlinksInPath()
+        let state = path.appendingPathComponent(".hasna/recordings").resolvingSymlinksInPath()
+        let liveState = liveHome.appendingPathComponent(".hasna/recordings").resolvingSymlinksInPath()
+        guard isolatedHomePath.hasPrefix("/"), path != liveHome,
+              state != liveState,
+              !preferencesSuiteName.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+              preferencesSuiteName != "com.hasna.recordings",
+              preferencesSuiteName != "NSGlobalDomain",
+              preferencesSuiteName != "NSArgumentDomain" else {
+            throw RecordingProviderError.invalidIsolation
+        }
+        self.isolatedHomePath = path.path
+        self.preferencesSuiteName = preferencesSuiteName
+    }
+}
+
+/// The native capture format is fixed so providers can forward PCM without conversion.
+public struct RecordingProviderSessionConfiguration: Sendable {
+    public let captureID: String
+    public let language: String
+    public let sampleRate: Int = 24_000
+    public let channels: Int = 1
+    public let bitsPerSample: Int = 16
+
+    public init(captureID: String, language: String) {
+        self.captureID = captureID
+        self.language = language
+    }
+}
+
+public struct RecordingTranscriptionRequest: Sendable {
+    public let captureID: String
+    /// A complete 24 kHz, mono, signed little-endian PCM16 WAV, excluding paused audio.
+    public let audioURL: URL
+    public let duration: TimeInterval
+    public let language: String
+
+    public init(captureID: String, audioURL: URL, duration: TimeInterval, language: String) {
+        self.captureID = captureID
+        self.audioURL = audioURL
+        self.duration = duration
+        self.language = language
+    }
+}
+
+public struct RecordingProviderResult: Sendable, Equatable {
+    public let rawText: String
+    public let processedText: String?
+
+    public init(rawText: String, processedText: String? = nil) {
+        self.rawText = rawText
+        self.processedText = processedText
+    }
+}
+
+public protocol RecordingTranscriptionProvider: Sendable {
+    /// Construct promptly; start network/recognition work asynchronously inside the session.
+    /// Freeze mutable provider settings here so they cannot switch beneath a capture.
+    /// Each partial callback replaces the complete current transcript, rather than appending.
+    func makeSession(
+        configuration: RecordingProviderSessionConfiguration,
+        onPartialTranscript: @escaping @Sendable (String) -> Void
+    ) throws -> any RecordingTranscriptionSession
+}
+
+public protocol RecordingTranscriptionSession: Sendable {
+    /// Called in capture order, in roughly 100 ms chunks, off the audio callback.
+    /// Return promptly. Providers must bound any queue while connecting or sending.
+    /// The final short chunk is delivered before finish. An in-flight append may race cancel;
+    /// a cancelled session must ignore it.
+    func appendPCM(_ data: Data)
+    /// Called once after capture drains and the fallback WAV is safely written.
+    /// File-based providers may ignore appendPCM and recognize this file locally.
+    func finish(_ request: RecordingTranscriptionRequest) async throws -> RecordingProviderResult
+    /// Must be thread-safe and idempotent, including cancellation during finish.
+    func cancel()
+}
+
+public enum RecordingProviderError: Error, LocalizedError, Sendable {
+    case invalidIsolation
+    case noAudio
+    case emptyTranscript
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidIsolation: "Provide a separate absolute state home and preferences suite for this app."
+        case .noAudio: "No audio was captured."
+        case .emptyTranscript: "No speech was recognized."
+        }
+    }
+}

package/src/native/Recordings/RecordingsLib/RecordingsCLI.swift

@@ -33,25 +33,32 @@ public enum RecordingsCLI {
               command.argumentsPrefix.isEmpty else {
             throw Failure(message: "Packaged companion resolver did not select the embedded helper")
         }
-        let versionOutput = CLIRunner.run(["--version"], home: home)
+        // The resolver smoke checks a throwaway local store, never the owner's API.
+        let probeEnvironment = [
+            "HOME": home,
+            "PATH": "/usr/bin:/bin:/usr/sbin:/sbin",
+            "HASNA_RECORDINGS_CLIENT_STORE": "sqlite",
+            "HASNA_RECORDINGS_DB_PATH": "\(home)/recordings.db",
+        ]
+        let versionOutput = CLIRunner.run(["--version"], home: home, environment: probeEnvironment)
             .trimmingCharacters(in: .whitespacesAndNewlines)
         if let error = CLIRunner.parseError(versionOutput) { throw Failure(message: error) }
         let expectedVersion = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
         guard !versionOutput.isEmpty, versionOutput == expectedVersion else {
             throw Failure(message: "Packaged companion version does not match the app")
         }
-        let project = try registerProject(
-            name: "Activated Helper Contract",
-            path: "recordings-app://install/activated-helper-contract",
-            description: "Installed app resolver verification",
-            home: home
-        )
+        let project = try decode(CanonicalProject.self, from: CLIRunner.run([
+            "--json", "project", "register", "--name", "Activated Helper Contract",
+            "--path", "recordings-app://install/activated-helper-contract",
+            "--description", "Installed app resolver verification",
+        ], home: home, environment: probeEnvironment))
         guard project.name == "Activated Helper Contract" else {
             throw Failure(message: "Packaged companion project capability failed")
         }
         let saved = CLIRunner.run(
             ["--json", "save-text", "Activated helper contract", "--source", "native_install_contract", "--post-processing", "off"],
-            home: home
+            home: home,
+            environment: probeEnvironment
         )
         struct SavedRecording: Decodable { let raw_text: String }
         let recording = try decode(SavedRecording.self, from: saved)
@@ -115,7 +122,7 @@ public enum RecordingsCLI {
 
     public static func delete(id: String, home: String = defaultHome) throws {
         let output = CLIRunner.run(["delete", id], home: home)
-        if let err = CLIRunner.parseError(output) { throw Failure(message: err) }
+        if let err = CLIRunner.parseError(output, serviceAPI: true) { throw Failure(message: err) }
     }
 
     public struct CanonicalProject: Codable, Sendable {
@@ -141,7 +148,7 @@ public enum RecordingsCLI {
 
     private static func runDecoding<T: Decodable>(_ type: T.Type, _ args: [String], home: String) throws -> T {
         let output = CLIRunner.run(args, home: home)
-        if let err = CLIRunner.parseError(output) { throw Failure(message: err) }
+        if let err = CLIRunner.parseError(output, serviceAPI: true) { throw Failure(message: err) }
         return try decode(type, from: output)
     }
 

package/src/native/Recordings/RecordingsLib/ServiceAPIConfiguration.swift

@@ -0,0 +1,107 @@
+import Foundation
+import Security
+
+/// Bridges Finder/menu-bar launches to the same environment contract as the CLI.
+/// The endpoint is user configuration; credentials live in Keychain, scoped to that URL.
+public enum ServiceAPIConfiguration {
+    public static let defaultsKey = "recordingsServiceAPIURL"
+    public static let didChangeNotification = Notification.Name("recordingsServiceAPIConfigurationDidChange")
+    private static let keychainService = "com.hasna.recordings.service-api"
+
+    enum Failure: Error, LocalizedError {
+        case invalidURL
+        case keychain(OSStatus)
+
+        var errorDescription: String? {
+            switch self {
+            case .invalidURL:
+                "Enter an HTTPS API URL without credentials, query parameters, or a fragment. Localhost may use HTTP."
+            case .keychain(let status):
+                "Could not access the Recordings API credential in Keychain (\(status))."
+            }
+        }
+    }
+
+    public static func normalizedURL(_ value: String) throws -> String {
+        guard var url = URLComponents(string: value.trimmingCharacters(in: .whitespacesAndNewlines)),
+              let host = url.host, !host.isEmpty,
+              url.user == nil, url.password == nil, url.query == nil, url.fragment == nil,
+              url.scheme == "https" || (url.scheme == "http" && ["localhost", "127.0.0.1", "[::1]", "::1"].contains(host)) else {
+            throw Failure.invalidURL
+        }
+        var path = url.path
+        while path.hasSuffix("/") { path.removeLast() }
+        if !path.hasSuffix("/v1") { path += "/v1" }
+        url.path = path
+        guard let result = url.url?.absoluteString else { throw Failure.invalidURL }
+        return result
+    }
+
+    public static func configuredURL(
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        defaults: UserDefaults = .standard
+    ) -> String {
+        environment["HASNA_RECORDINGS_API_URL"] ?? defaults.string(forKey: defaultsKey) ?? ""
+    }
+
+    public static func save(url: String, apiKey: String, defaults: UserDefaults = .standard) throws {
+        let endpoint = try normalizedURL(url)
+        let key = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !key.isEmpty {
+            let query: [String: Any] = [
+                kSecClass as String: kSecClassGenericPassword,
+                kSecAttrService as String: keychainService,
+                kSecAttrAccount as String: endpoint,
+            ]
+            let value = [kSecValueData as String: Data(key.utf8)]
+            var status = SecItemUpdate(query as CFDictionary, value as CFDictionary)
+            if status == errSecItemNotFound {
+                var item = query.merging(value) { _, new in new }
+                item[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+                status = SecItemAdd(item as CFDictionary, nil)
+            }
+            guard status == errSecSuccess else { throw Failure.keychain(status) }
+        }
+        defaults.set(endpoint, forKey: defaultsKey)
+        NotificationCenter.default.post(name: didChangeNotification, object: nil)
+    }
+
+    static func loadKey(for endpoint: String) throws -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: keychainService,
+            kSecAttrAccount as String: endpoint,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne,
+            kSecUseAuthenticationUI as String: kSecUseAuthenticationUIFail,
+        ]
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecItemNotFound { return nil }
+        guard status == errSecSuccess else { throw Failure.keychain(status) }
+        return (result as? Data).flatMap { String(data: $0, encoding: .utf8) }
+    }
+
+    static func childEnvironment(
+        base: [String: String],
+        defaults: UserDefaults = .standard,
+        keyLoader: (String) throws -> String? = loadKey
+    ) throws -> [String: String] {
+        // Explicit environment routing wins. Never attach a saved credential to an
+        // unrelated environment endpoint, or silently turn a local override into HTTP.
+        if base["HASNA_RECORDINGS_LOCAL"] == "1" || base["RECORDINGS_LOCAL"] == "1" { return base }
+        if ["HASNA_RECORDINGS_API_URL"]
+            .contains(where: { !(base[$0] ?? "").trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) {
+            return base
+        }
+        guard let saved = defaults.string(forKey: defaultsKey), !saved.isEmpty else { return base }
+        let endpoint = try normalizedURL(saved)
+        var result = base
+        result["HASNA_RECORDINGS_API_URL"] = endpoint
+        if ["HASNA_RECORDINGS_API_KEY_OVERRIDE", "HASNA_RECORDINGS_API_KEY"]
+            .allSatisfy({ (base[$0] ?? "").isEmpty }), let key = try keyLoader(endpoint), !key.isEmpty {
+            result["HASNA_RECORDINGS_API_KEY_OVERRIDE"] = key
+        }
+        return result
+    }
+}

package/src/native/Recordings/RecordingsLib/ServiceConnectionView.swift

@@ -0,0 +1,76 @@
+import SwiftUI
+
+struct ServiceConnectionView: View {
+    let home: String
+    @State private var apiURL = ServiceAPIConfiguration.configuredURL()
+    @State private var apiKey = ""
+    @State private var status: String?
+    @State private var checking = false
+
+    private var environmentManaged: Bool {
+        ["HASNA_RECORDINGS_API_URL", "HASNA_RECORDINGS_CLIENT_STORE", "RECORDINGS_CLIENT_STORE"]
+            .contains { !(ProcessInfo.processInfo.environment[$0] ?? "").isEmpty }
+    }
+
+    var body: some View {
+        Section("Recordings API") {
+            TextField("API URL", text: $apiURL)
+                .textFieldStyle(.roundedBorder)
+                .disabled(environmentManaged)
+            SecureField("API key", text: $apiKey)
+                .textFieldStyle(.roundedBorder)
+                .disabled(environmentManaged)
+            Text(environmentManaged
+                 ? "Connection managed by the launch environment."
+                 : "The URL is configurable. Saved API keys stay in Keychain and are used only for this endpoint.")
+                .font(.caption).foregroundStyle(.secondary)
+            HStack {
+                if !environmentManaged {
+                    Button("Save Connection", action: save)
+                        .disabled(checking || apiURL.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                }
+                Button("Test Connection", action: testConnection)
+                    .disabled(checking)
+                if checking { ProgressView().controlSize(.small) }
+            }
+            if let status { Text(status).font(.caption).foregroundStyle(.secondary) }
+        }
+    }
+
+    private func save() {
+        do {
+            try ServiceAPIConfiguration.save(url: apiURL, apiKey: apiKey)
+            apiURL = ServiceAPIConfiguration.configuredURL()
+            apiKey = ""
+            status = "Connection saved."
+        } catch {
+            status = error.localizedDescription
+        }
+    }
+
+    private func testConnection() {
+        if !environmentManaged {
+            do {
+                try ServiceAPIConfiguration.save(url: apiURL, apiKey: apiKey)
+                apiKey = ""
+            } catch {
+                status = error.localizedDescription
+                return
+            }
+        }
+        checking = true
+        status = nil
+        Task {
+            let result = await Task.detached {
+                do {
+                    _ = try RecordingsCLI.list(limit: 1, home: home)
+                    return "Connected. Recordings are available."
+                } catch {
+                    return (error as? RecordingsCLI.Failure)?.message ?? error.localizedDescription
+                }
+            }.value
+            status = result
+            checking = false
+        }
+    }
+}

package/src/native/Recordings/RecordingsLib/SettingsView.swift

@@ -4,29 +4,31 @@ import SwiftUI
 public struct SettingsView: View {
     @ObservedObject public var engine: RecordingEngine
     @ObservedObject public var shortcuts: VoiceShortcuts
-    @ObservedObject public var projectStore: ProjectStore
-    @AppStorage("openAIAPIKey") private var openAIAPIKey = ""
+    @ObservedObject public var preferences: ProjectStore
+    @State private var openAIAPIKey = ""
+    @State private var providerStatus = ""
 
-    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, projectStore: ProjectStore) {
+    public init(engine: RecordingEngine, shortcuts: VoiceShortcuts, preferences: ProjectStore) {
         self.engine = engine
         self.shortcuts = shortcuts
-        self.projectStore = projectStore
+        self.preferences = preferences
     }
 
     public var body: some View {
         TabView {
             generalTab.tabItem { Label("General", systemImage: "gear") }
-            projectsTab.tabItem { Label("Projects", systemImage: "folder") }
             shortcutsTab.tabItem { Label("Voice Shortcuts", systemImage: "text.badge.star") }
         }
-        .frame(width: 520, height: 500)
-        .alert("Project Settings Error", isPresented: Binding(
-            get: { projectStore.persistenceError != nil },
-            set: { if !$0 { projectStore.clearPersistenceError() } }
+        .font(.system(size: 13))
+        .controlSize(.small)
+        .frame(width: 520, height: 460)
+        .alert("Settings Error", isPresented: Binding(
+            get: { preferences.persistenceError != nil },
+            set: { if !$0 { preferences.clearPersistenceError() } }
         )) {
             Button("OK", role: .cancel) {}
         } message: {
-            Text(projectStore.persistenceError ?? "The project settings could not be saved.")
+            Text(preferences.persistenceError ?? "The settings could not be saved.")
         }
     }
 
@@ -34,18 +36,38 @@ public struct SettingsView: View {
 
     private var generalTab: some View {
         Form {
+            ServiceConnectionView(home: engine.home)
             Section("OpenAI") {
                 SecureField("API key", text: $openAIAPIKey)
                     .textFieldStyle(.roundedBorder)
-                    .onChange(of: openAIAPIKey) {
-                        // Keep the CLI config in sync — final transcription shells out to it.
-                        try? OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
+                Button("Save OpenAI Key") {
+                    do {
+                        try OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
+                        openAIAPIKey = ""
+                        providerStatus = "OpenAI key saved in Keychain."
+                    } catch {
+                        providerStatus = error.localizedDescription
+                    }
+                }
+                .disabled(openAIAPIKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                Button("Connect Saved Key") {
+                    do {
+                        providerStatus = (try OpenAIAPIKeyStore.loadKeychain(allowInteraction: true))?.isEmpty == false
+                            ? "OpenAI key available from Keychain."
+                            : "No saved OpenAI key found in Keychain."
+                    } catch { providerStatus = error.localizedDescription }
+                }
+                Text(providerStatus).foregroundStyle(.secondary)
+                    .onAppear {
+                        providerStatus = OpenAIAPIKeyStore.load(homePath: engine.home).isEmpty
+                            ? "Add an OpenAI key for transcription."
+                            : "OpenAI key available for transcription."
                     }
                 Picker("Language", selection: $engine.transcriptionLanguage) {
                     Text("English").tag("en")
                     Text("Auto Detect").tag("auto")
                 }
-                Text("Used for live transcription and the final paste. Stored in ~/.hasna/recordings/config.json.")
+                Text("Used for live transcription and the final paste. New keys are stored in macOS Keychain.")
                     .foregroundStyle(.secondary)
             }
 
@@ -143,82 +165,26 @@ public struct SettingsView: View {
             }
 
             Section("Transcription Cleanup") {
-                Picker("Mode", selection: $projectStore.settings.postProcessingMode) {
+                Picker("Mode", selection: $preferences.settings.postProcessingMode) {
                     ForEach(PostProcessingMode.allCases) { mode in
                         Text(mode.label).tag(mode.rawValue)
                     }
                 }
                 .pickerStyle(.segmented)
-                .onChange(of: projectStore.settings.postProcessingMode) {
-                    try? projectStore.save()
+                .onChange(of: preferences.settings.postProcessingMode) {
+                    try? preferences.save()
                 }
-                TextEditor(text: $projectStore.settings.globalSystemPrompt)
-                    .frame(height: 80)
-                    .onChange(of: projectStore.settings.globalSystemPrompt) {
-                        try? projectStore.save()
+                TextEditor(text: $preferences.settings.globalSystemPrompt)
+                    .frame(height: 80).scrollContentBackground(.hidden)
+                    .onChange(of: preferences.settings.globalSystemPrompt) {
+                        try? preferences.save()
                     }
                 Text("Instructions for post-transcription cleanup and formatting.")
                     .foregroundStyle(.secondary)
             }
-            .disabled(!projectStore.canMutateProjects)
-        }
-        .formStyle(.grouped).padding()
-    }
-
-    // MARK: - Projects
-
-    @State private var newProjectName = ""
-    @State private var editingProject: RecProject?
-
-    private var projectsTab: some View {
-        VStack(spacing: 0) {
-            HStack(spacing: 8) {
-                TextField("New project name", text: $newProjectName)
-                    .textFieldStyle(.roundedBorder)
-                Button("Add") {
-                    guard !newProjectName.isEmpty else { return }
-                    let name = newProjectName
-                    Task {
-                        do {
-                            try await projectStore.addProject(name: name)
-                            newProjectName = ""
-                        } catch {}
-                    }
-                }
-                .disabled(newProjectName.isEmpty)
-            }
-            .padding()
-
-            Divider()
-
-            if projectStore.settings.projects.isEmpty {
-                Spacer()
-                VStack(spacing: 8) {
-                    Image(systemName: "folder").font(.largeTitle).foregroundStyle(.quaternary)
-                    Text("No projects yet").foregroundStyle(.secondary)
-                }
-                Spacer()
-            } else {
-                List {
-                    ForEach(projectStore.settings.projects) { project in
-                        ProjectRow(project: project) {
-                            editingProject = project
-                        }
-                    }
-                    .onDelete { indexSet in
-                        for i in indexSet {
-                            try? projectStore.removeProject(id: projectStore.settings.projects[i].id)
-                        }
-                    }
-                }
-            }
-        }
-        .disabled(!projectStore.canMutateProjects)
-        .sheet(item: $editingProject) { project in
-            ProjectEditView(project: project, store: projectStore) {
-                editingProject = nil
-            }
+            .disabled(!preferences.canMutateProjects)
         }
+        .formStyle(.grouped).scrollContentBackground(.hidden).padding(8)
     }
 
     // MARK: - Voice Shortcuts
@@ -263,73 +229,3 @@ public struct SettingsView: View {
         }
     }
 }
-
-// MARK: - Project Row
-
-struct ProjectRow: View {
-    let project: RecProject
-    let onEdit: () -> Void
-
-    var body: some View {
-        HStack {
-            VStack(alignment: .leading, spacing: 2) {
-                Text(project.name)
-                if let path = project.path, !path.isEmpty {
-                    Text(path).foregroundStyle(.secondary).lineLimit(1)
-                }
-            }
-            Spacer()
-            Button("Edit") { onEdit() }
-                .controlSize(.small)
-        }
-    }
-}
-
-// MARK: - Project Edit
-
-struct ProjectEditView: View {
-    @State var project: RecProject
-    let store: ProjectStore
-    let onDismiss: () -> Void
-
-    var body: some View {
-        VStack(spacing: 0) {
-            Form {
-                Section("Project") {
-                    TextField("Name", text: $project.name)
-                    TextField("Path", text: Binding(
-                        get: { project.path ?? "" },
-                        set: { project.path = $0.isEmpty ? nil : $0 }
-                    ))
-                    .textFieldStyle(.roundedBorder)
-                }
-
-                Section("Transcriber Instructions") {
-                    TextEditor(text: Binding(
-                        get: { project.systemPrompt ?? "" },
-                        set: { project.systemPrompt = $0.isEmpty ? nil : $0 }
-                    ))
-                    .frame(height: 100)
-                    Text("Project-specific cleanup and formatting instructions.")
-                        .foregroundStyle(.secondary)
-                }
-            }
-            .formStyle(.grouped)
-            .disabled(!store.canMutateProjects)
-
-            HStack {
-                Spacer()
-                Button("Cancel") { onDismiss() }
-                Button("Save") {
-                    do {
-                        try store.updateProject(project)
-                        onDismiss()
-                    } catch {}
-                }
-                .disabled(!store.canMutateProjects)
-            }
-            .padding()
-        }
-        .frame(width: 420, height: 340)
-    }
-}

package/src/native/Recordings/RecordingsLib/SettingsWindowController.swift

@@ -0,0 +1,48 @@
+import AppKit
+import SwiftUI
+
+/// Settings must also open from an accessory app with no SwiftUI workspace scene.
+/// Retain the window so repeated menu actions and closing/reopening preserve its state.
+@MainActor
+public final class SettingsWindowController {
+    private var window: NSWindow?
+    private let makeContent: @MainActor () -> NSView
+
+    public init(content: @escaping @MainActor () -> NSView) {
+        makeContent = content
+    }
+
+    @discardableResult
+    public func show() -> NSWindow {
+        let settings: NSWindow
+        if let window {
+            settings = window
+        } else {
+            settings = NSWindow(
+                contentRect: NSRect(x: 0, y: 0, width: 520, height: 500),
+                styleMask: [.titled, .closable],
+                backing: .buffered,
+                defer: false
+            )
+            settings.title = "Hasna Recordings Settings"
+            settings.isReleasedWhenClosed = false
+            settings.isOpaque = false
+            settings.backgroundColor = .clear
+            settings.titlebarAppearsTransparent = true
+            let content = makeContent()
+            let backdrop = NSHostingView(rootView: RecordingGlassBackground())
+            backdrop.frame = content.bounds
+            backdrop.autoresizingMask = [.width, .height]
+            content.addSubview(backdrop, positioned: .below, relativeTo: nil)
+            settings.contentView = content
+            settings.center()
+            window = settings
+        }
+        // Activation is needed when invoked from a menu-bar popover. Preserve the
+        // activation policy so a bar-only app stays out of the Dock and app switcher.
+        NSApplication.shared.activate()
+        NSRunningApplication.current.activate(options: [.activateAllWindows])
+        settings.makeKeyAndOrderFront(nil)
+        return settings
+    }
+}