feat: add MiniMax M3 as a cloud AI provider (v2.0.3 base)

Ports the MiniMax integration from #320 onto the v2.0.3 base, which
refactored the provider system into LLMProviderID with separate cases for
chatGPT, claude, openAICompatible, and local.

What's included

- New LLMProviderID.minimax case with analytics + display label
- MiniMaxProvider + 4 extension files (Networking, Reasoning, Summaries,
  Transcription) following the OllamaProvider pattern but using Bearer
  auth against https://api.minimax.io/v1 with M3's 1M-token context
- MiniMaxModelPreference, MiniMaxPromptPreferences, MiniMaxAPIHelper
- LLMService.makeMiniMaxProvider() wired into makeBatchProvider and
  makeTextProvider; providerModelId(for:) helper stamps cards with the
  active model
- Storage layer: provider_id + model_id columns on timeline_cards with
  ALTER TABLE migration, TimelineCard/TimelineCardShell fields, and
  fetchAllTimelineCards() for the dashboard
- Onboarding: 6th provider card (sparkles icon) + dedicated 4-step setup
  flow (get-key, enter-key, test, complete)
- Settings: MiniMax section in providers tab with model picker, keychain
  field, test-connection button, and prompt-override plumbing
- ModelCatalog + ProviderStatsCalculator + ProviderStatsView (dashboard
  data + GitHub-style heatmap + daily/weekly/monthly breakdowns)

Build verified: xcodebuild Release succeeds, no new errors vs v2.0.3 base

Author: M3NT1

Dayflow/Dayflow/Core/AI/DailyRecapModels.swift

@@ -56,6 +56,8 @@ enum DailyRecapProvider: String, Codable, CaseIterable, Sendable {
       return .local
     case .openAICompatible:
       return .none
+    case .minimax:
+      return .none
     }
   }
 

Dayflow/Dayflow/Core/AI/LLMService.swift

@@ -183,11 +183,21 @@ final class LLMService: LLMServicing {
     return OllamaProvider(openAICompatible: runtimeConfiguration)
   }
 
+  private func makeMiniMaxProvider() -> MiniMaxProvider? {
+    guard let key = KeychainManager.shared.retrieve(for: MiniMaxProvider.keychainKey),
+      !key.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    else {
+      print("❌ [LLMService] MiniMax provider unavailable: missing API key")
+      return nil
+    }
+    return MiniMaxProvider()
+  }
+
   private func providerLabel(for providerID: LLMProviderID) -> String {
     providerID.providerLabel
   }
 
-  /// Returns the model id the provider should be stamped with on
+/// Returns the model id the provider should be stamped with on
   /// generated cards. Mirrors how `providerLabel` is sourced from the
   /// `LLMProviderID`, but goes one level deeper to read the actual model
   /// the user has configured (Gemini primary preference, Ollama model id
@@ -223,6 +233,8 @@ final class LLMService: LLMServicing {
       // Settings → Providers tab writes this). The CLI accepts
       // these aliases natively — `sonnet` → latest Sonnet release.
       return ClaudeModelPreference.load().primary.rawValue
+    case .minimax:
+      return MiniMaxModelPreference.load().modelId
     case .dayflow:
       return nil
     }
@@ -331,6 +343,20 @@ final class LLMService: LLMServicing {
           generateActivityCards: provider.generateActivityCards
         ), fallbackState: nil
       )
+    case .minimax:
+      guard let provider = makeMiniMaxProvider() else { throw noProviderError() }
+      return (
+        actions: BatchProviderActions(
+          transcribeScreenshots: { [provider] screenshots, batchStartTime, batchId in
+            try await provider.transcribeScreenshots(
+              screenshots, batchStartTime: batchStartTime, batchId: batchId)
+          },
+          generateActivityCards: { [provider] observations, context, batchId in
+            try await provider.generateActivityCards(
+              observations: observations, context: context, batchId: batchId)
+          }
+        ), fallbackState: nil
+      )
     }
   }
 
@@ -625,6 +651,14 @@ final class LLMService: LLMServicing {
         },
         generateTextStreaming: provider.generateTextStreaming
       )
+    case .minimax:
+      guard let provider = makeMiniMaxProvider() else { throw noProviderError() }
+      return TextProviderActions(
+        generateText: { prompt in
+          try await provider.generateText(prompt: prompt)
+        },
+        generateTextStreaming: nil
+      )
     }
   }
 
@@ -998,7 +1032,7 @@ final class LLMService: LLMServicing {
                 distractions: card.distractions,
                 appSites: card.appSites,
                 isBackupGenerated: isBackupGenerated ? true : nil,
-                providerId: activeProviderId,
+providerId: activeProviderId,
                 modelId: activeModelId
               )
             },

Dayflow/Dayflow/Core/AI/LLMTypes.swift

@@ -88,6 +88,7 @@ enum LLMProviderID: String, Codable, CaseIterable {
   case claude
   case openAICompatible = "openai_compatible"
   case local
+  case minimax
 
   var analyticsName: String {
     switch self {
@@ -101,6 +102,8 @@ enum LLMProviderID: String, Codable, CaseIterable {
       return "openai_compatible"
     case .local:
       return "ollama"
+    case .minimax:
+      return "minimax"
     }
   }
 
@@ -113,6 +116,8 @@ enum LLMProviderID: String, Codable, CaseIterable {
     case .openAICompatible: return "openai_compatible"
     case .local:
       return "local"
+    case .minimax:
+      return "minimax"
     }
   }
 }

Dayflow/Dayflow/Core/AI/MiniMaxModelPreference.swift

@@ -0,0 +1,49 @@
+//
+//  MiniMaxModelPreference.swift
+//  Dayflow
+//
+//  Persisted preference for the active MiniMax model. Mirrors the shape of
+//  `GeminiModelPreference` so the settings UI can drop the same component in.
+//
+
+import Foundation
+
+struct MiniMaxModelPreference: Codable, Equatable {
+  /// Wire-format model id sent in chat completion requests.
+  var modelId: String
+
+  /// Whether the user has selected a non-default model.
+  var hasUserOverride: Bool
+
+  static let `default` = MiniMaxModelPreference(
+    modelId: MiniMaxProvider.defaultModelId,
+    hasUserOverride: false
+  )
+
+  static let storageKey = "minimaxModelPreference"
+
+  static func load(from defaults: UserDefaults = .standard) -> MiniMaxModelPreference {
+    guard let data = defaults.data(forKey: storageKey),
+      let decoded = try? JSONDecoder().decode(MiniMaxModelPreference.self, from: data)
+    else {
+      return .default
+    }
+    return decoded
+  }
+
+  func persist(to defaults: UserDefaults = .standard) {
+    guard let data = try? JSONEncoder().encode(self) else { return }
+    defaults.set(data, forKey: Self.storageKey)
+  }
+
+  mutating func setModelId(_ newValue: String) {
+    let trimmed = newValue.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !trimmed.isEmpty else { return }
+    self.modelId = trimmed
+    self.hasUserOverride = (trimmed != MiniMaxProvider.defaultModelId)
+  }
+
+  mutating func reset() {
+    self = .default
+  }
+}

Dayflow/Dayflow/Core/AI/MiniMaxPromptPreferences.swift

@@ -0,0 +1,108 @@
+//
+//  MiniMaxPromptPreferences.swift
+//  Dayflow
+//
+//  User-overridable prompt blocks for the MiniMax provider. Defaults are
+//  intentionally aligned with the Ollama prompt defaults so behaviour stays
+//  consistent across providers. Users can customise either block independently.
+//
+
+import Foundation
+
+struct MiniMaxPromptOverrides: Codable, Equatable {
+  var summaryBlock: String?
+  var titleBlock: String?
+
+  var isEmpty: Bool {
+    [summaryBlock, titleBlock].allSatisfy { value in
+      let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+      return trimmed.isEmpty
+    }
+  }
+}
+
+enum MiniMaxPromptPreferences {
+  private static let overridesKey = "minimaxPromptOverrides"
+  private static let store = UserDefaults.standard
+
+  static func load() -> MiniMaxPromptOverrides {
+    guard let data = store.data(forKey: overridesKey) else {
+      return MiniMaxPromptOverrides()
+    }
+    guard let overrides = try? JSONDecoder().decode(MiniMaxPromptOverrides.self, from: data)
+    else {
+      return MiniMaxPromptOverrides()
+    }
+    return overrides
+  }
+
+  static func save(_ overrides: MiniMaxPromptOverrides) {
+    guard let data = try? JSONEncoder().encode(overrides) else { return }
+    store.set(data, forKey: overridesKey)
+  }
+
+  static func reset() {
+    store.removeObject(forKey: overridesKey)
+  }
+}
+
+enum MiniMaxPromptDefaults {
+  static let summaryBlock = """
+      SUMMARY GUIDELINES:
+      - Write in first person without using "I" (like a personal journal entry)
+      - 2-3 sentences maximum
+      - Include specific details (app names, search topics, etc.)
+      - Natural, conversational tone
+
+      GOOD EXAMPLES:
+      "Managed Mac system preferences focusing on software updates and accessibility settings. Browsed Chrome searching for iPhone wireless charging info while
+      checking Twitter and Slack messages."
+
+      "Configured GitHub Actions pipeline for automated testing. Quick Slack check interrupted focus, then back to debugging deployment issues."
+
+      "Researched React performance optimization techniques in Chrome, reading articles about useMemo patterns. Switched between documentation tabs and took notes in
+       Notion about component re-rendering."
+
+      "Updated Xcode project dependencies and resolved build errors in SwiftUI views. Tested app on simulator while responding to client messages about timeline
+      changes."
+
+      "Browsed Instagram and TikTok while listening to Spotify playlist. Responded to personal messages on WhatsApp about weekend plans."
+
+      BAD EXAMPLES:
+      - "The user did various computer activities" (too vague, wrong perspective, never say the user)
+      - "I was working on my computer doing different tasks" (uses "I", not specific)
+      - "Spent time on multiple applications and websites" (generic, no details)
+  """
+
+  static let titleBlock = """
+    Write one activity title for a 15-minute window using ONLY the observations.
+    Rules:
+    - 5-10 words, natural and specific, single line
+    - Choose the dominant activity (most time), not necessarily the first
+    - Ignore brief interruptions (<3 minutes)
+    - Include a second activity only if both take ~5+ minutes
+    - If 3+ unrelated activities appear, output exactly: "Scattered apps and sites"
+    - Prefer proper nouns/topics (Bookface, Claude, League of Legends, Paul Graham, etc.)
+    - Never use: worked on, looked at, handled, various, some, multiple, browsing, browse, multitasking, tabs, brief, quick, short
+    - Do NOT use the word "browsing"; use "scrolling" or "reading" instead
+    - Avoid long lists; no more than one conjunction
+    - Return only the title text (no quotes, no JSON)
+  """
+}
+
+struct MiniMaxPromptSections {
+  let summary: String
+  let title: String
+
+  init(overrides: MiniMaxPromptOverrides) {
+    self.summary = MiniMaxPromptSections.compose(
+      defaultBlock: MiniMaxPromptDefaults.summaryBlock, custom: overrides.summaryBlock)
+    self.title = MiniMaxPromptSections.compose(
+      defaultBlock: MiniMaxPromptDefaults.titleBlock, custom: overrides.titleBlock)
+  }
+
+  private static func compose(defaultBlock: String, custom: String?) -> String {
+    let trimmed = custom?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+    return trimmed.isEmpty ? defaultBlock : trimmed
+  }
+}