@pheem49/mint 1.16.0 → 1.18.0

package/src/renderer/shared/platform.test.ts

@@ -88,3 +88,146 @@ describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as con
     expect(body).toEqual({ workspacePath: '/project', chatId: 'chat-a', action: 'action', id: 'checklist', instanceId: 'revision-instance', command: 'add', value: 'Test' })
   })
 })
+
+describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as const)('%s openExternal', (_name, adapter) => {
+  it('exports openExternal function and invokes window.open in browser fallback', async () => {
+    const openMock = vi.fn()
+    vi.stubGlobal('window', { open: openMock })
+    expect(adapter.openExternal).toBeTypeOf('function')
+    await adapter.openExternal('https://example.com/test')
+    expect(openMock).toHaveBeenCalledWith('https://example.com/test', '_blank', 'noopener,noreferrer')
+  })
+})
+
+describe('desktop external link interceptor', () => {
+  it('identifies external and internal URLs correctly', async () => {
+    const { isExternalHref } = await import('./utils/externalLinks')
+    expect(isExternalHref('https://example.com')).toBe(true)
+    expect(isExternalHref('http://example.com/page')).toBe(true)
+    expect(isExternalHref('//cdn.example.com/asset.js')).toBe(true)
+    expect(isExternalHref('#/settings')).toBe(false)
+    expect(isExternalHref('/library?item=123')).toBe(false)
+    expect(isExternalHref('./relative')).toBe(false)
+    expect(isExternalHref('../parent')).toBe(false)
+    expect(isExternalHref('javascript:void(0)')).toBe(false)
+    expect(isExternalHref('data:image/png;base64,...')).toBe(false)
+    expect(isExternalHref('blob:http://localhost/123')).toBe(false)
+  })
+
+  it('intercepts clicks on external http/https links and prevents default', async () => {
+    const openMock = vi.fn()
+    vi.stubGlobal('window', { open: openMock })
+
+    let clickHandler: ((e: any) => void) | null = null
+    const mockDocument: any = {
+      addEventListener: vi.fn((event: string, handler: any) => {
+        if (event === 'click') clickHandler = handler
+      }),
+      removeEventListener: vi.fn((event: string, handler: any) => {
+        if (event === 'click' && clickHandler === handler) clickHandler = null
+      }),
+    }
+
+    const cleanup = desktopAdapter.installExternalLinkInterceptor(mockDocument)
+    expect(mockDocument.addEventListener).toHaveBeenCalledWith('click', expect.any(Function), true)
+    expect(clickHandler).toBeTypeOf('function')
+
+    const externalAnchor: any = {
+      getAttribute: (attr: string) => (attr === 'href' ? 'https://example.com/search-result' : null),
+      hasAttribute: (attr: string) => false,
+      href: 'https://example.com/search-result',
+      target: '_blank',
+    }
+    const imgInsideAnchor: any = {
+      closest: (selector: string) => (selector === 'a' ? externalAnchor : null),
+    }
+
+    const clickEvent: any = {
+      defaultPrevented: false,
+      button: 0,
+      target: imgInsideAnchor,
+      preventDefault: vi.fn(() => { clickEvent.defaultPrevented = true }),
+      stopPropagation: vi.fn(),
+    }
+
+    clickHandler!(clickEvent)
+
+    expect(clickEvent.preventDefault).toHaveBeenCalledOnce()
+    // Does NOT suppress propagation so React/child event listeners can still run
+    expect(clickEvent.stopPropagation).not.toHaveBeenCalled()
+    expect(openMock).toHaveBeenCalledWith('https://example.com/search-result', '_blank', 'noopener,noreferrer')
+
+    // Internal relative route (/library?item=lib-123) should NOT be intercepted even if anchor.href resolves to document origin
+    openMock.mockClear()
+    const relativeAnchor: any = {
+      getAttribute: (attr: string) => (attr === 'href' ? '/library?item=lib-123' : null),
+      hasAttribute: (attr: string) => false,
+      href: 'http://localhost:9000/library?item=lib-123',
+      target: '',
+    }
+    const relativeClickEvent: any = {
+      defaultPrevented: false,
+      button: 0,
+      target: {
+        closest: (selector: string) => (selector === 'a' ? relativeAnchor : null),
+      },
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    }
+
+    clickHandler!(relativeClickEvent)
+
+    expect(relativeClickEvent.preventDefault).not.toHaveBeenCalled()
+    expect(openMock).not.toHaveBeenCalled()
+
+    // Download link should not be intercepted
+    openMock.mockClear()
+    const downloadAnchor: any = {
+      getAttribute: (attr: string) => (attr === 'href' ? 'https://example.com/file.png' : null),
+      hasAttribute: (attr: string) => attr === 'download',
+      href: 'https://example.com/file.png',
+      target: '',
+    }
+    const downloadClickEvent: any = {
+      defaultPrevented: false,
+      button: 0,
+      target: {
+        closest: (selector: string) => (selector === 'a' ? downloadAnchor : null),
+      },
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    }
+
+    clickHandler!(downloadClickEvent)
+
+    expect(downloadClickEvent.preventDefault).not.toHaveBeenCalled()
+    expect(openMock).not.toHaveBeenCalled()
+
+    // Internal hash link should not be intercepted
+    openMock.mockClear()
+    const internalAnchor: any = {
+      getAttribute: (attr: string) => (attr === 'href' ? '#/settings' : null),
+      hasAttribute: (attr: string) => false,
+      href: '#/settings',
+      target: '',
+    }
+    const internalClickEvent: any = {
+      defaultPrevented: false,
+      button: 0,
+      target: {
+        closest: (selector: string) => (selector === 'a' ? internalAnchor : null),
+      },
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    }
+
+    clickHandler!(internalClickEvent)
+
+    expect(internalClickEvent.preventDefault).not.toHaveBeenCalled()
+    expect(internalClickEvent.stopPropagation).not.toHaveBeenCalled()
+    expect(openMock).not.toHaveBeenCalled()
+
+    cleanup()
+    expect(mockDocument.removeEventListener).toHaveBeenCalledWith('click', expect.any(Function), true)
+  })
+})

package/src/renderer/shared/platform.ts

@@ -68,7 +68,7 @@ export type SlashResponse =
 
 export interface MintPlatformApi {
   modsOperation(operation: import("./mods").ModOperation): Promise<import("./mods").ModResponse>
-  readMcpArtifact(id: string): Promise<string>
+  readMcpArtifact(id: string, chatId?: string): Promise<string>
   listBackgroundJobs(workspace?: string): Promise<import("./types").BackgroundJob[]>
   getBackgroundJob(id: string): Promise<import("./types").BackgroundJobOutput>
   stopBackgroundJob(id: string): Promise<import("./types").BackgroundJob>
@@ -112,6 +112,7 @@ export interface MintPlatformApi {
     onTurnStarted?: (interactionId: number) => void,
     attachmentMetadata?: import('./types').AttachmentMetadata,
   ): Promise<ChatResponse>
+  speechRequest(request: import('./speech/types').SpeechRequest): Promise<import('./speech/types').SpeechReply>
   getTtsUrls(text: string): Promise<TtsUrl[]>
   cancelChatMessage(chatId: string): Promise<void>
   getRecentInteractions(limit?: number, chatId?: string | null, workspacePath?: string | null): Promise<InteractionMemory[]>
@@ -128,6 +129,7 @@ export interface MintPlatformApi {
   ): Promise<any>
 
   saveInteractionAgentActivity(interactionId: number, progress: any[]): Promise<void>
+  pendingCompanionChat(acknowledgedId?: string): Promise<string | null>
   listChatSessions(): Promise<ChatSession[]>
   updateChatSessionWorkspace(chatId: string, workspacePath: string | null): Promise<void>
   deleteChatSession(chatId: string): Promise<number>
@@ -141,6 +143,7 @@ export interface MintPlatformApi {
   saveSubagent(draft: SubagentDraft, workspacePath?: string): Promise<SubagentDefinition>
   deleteSubagent(sourcePath: string): Promise<void>
   clearChatHistory(chatId?: string | null): Promise<number>
+  truncateInteractionsFrom(chatId: string | null | undefined, fromId: number): Promise<number>
   listLibrary(query: import('./types').LibraryQuery): Promise<import('./types').LibraryPage>
   getLibraryItem(id: string): Promise<import('./types').LibraryItem>
   removeLibraryItem(id: string): Promise<void>
@@ -176,6 +179,9 @@ export interface MintPlatformApi {
   rollbackGitCheckpoint(chatId: string, step: number, workspacePath?: string): Promise<{ status: string; message: string }>
   undoGitCheckpoint(workspacePath?: string): Promise<{ status: string; message: string }>
   readWorkspaceFile(path: string, workspacePath?: string): Promise<string>
+  readWorkspaceImage(path: string, workspacePath: string): Promise<string>
+  readWorkspaceMedia(path: string, workspacePath: string): Promise<import('./types').WorkspaceMediaSource>
+  openExternal(url: string): Promise<any>
   testMcpConnection(
     url: string,
     headers?: Record<string, string>,
@@ -264,14 +270,14 @@ export const authPlatform = {
 /** Conversation transport, persistence, live voice, and checkpoint seam. */
 export const conversationPlatform = {
   getConversationSources: operation('getConversationSources'), saveSourceAttachments: operation('saveSourceAttachments'),
-  clearChatHistory: operation('clearChatHistory'), deleteChatSession: operation('deleteChatSession'),
+  clearChatHistory: operation('clearChatHistory'), truncateInteractionsFrom: operation('truncateInteractionsFrom'), deleteChatSession: operation('deleteChatSession'),
   renameChatSession: operation('renameChatSession'), getRecentInteractions: operation('getRecentInteractions'),
   getConversationSnapshot: operation('getConversationSnapshot'), getConversationChanges: operation('getConversationChanges'),
-  saveSystemInteraction: operation('saveSystemInteraction'), listChatSessions: operation('listChatSessions'),
+  saveSystemInteraction: operation('saveSystemInteraction'), listChatSessions: operation('listChatSessions'), pendingCompanionChat: operation('pendingCompanionChat'),
   updateChatSessionWorkspace: operation('updateChatSessionWorkspace'),
   saveInteractionAgentActivity: operation('saveInteractionAgentActivity'), streamChatMessage: operation('streamChatMessage'),
   cancelChatMessage: operation('cancelChatMessage'), submitToolApproval: operation('submitToolApproval'),
-  listen: operation('listen'), readClipboardImage: operation('readClipboardImage'), getTtsUrls: operation('getTtsUrls'),
+  listen: operation('listen'), readClipboardImage: operation('readClipboardImage'), getTtsUrls: operation('getTtsUrls'), speechRequest: operation('speechRequest'),
   startGeminiLiveSession: operation('startGeminiLiveSession'), sendGeminiLiveAudioChunk: operation('sendGeminiLiveAudioChunk'),
   stopGeminiLiveSession: operation('stopGeminiLiveSession'), listGitCheckpoints: operation('listGitCheckpoints'),
   rollbackGitCheckpoint: operation('rollbackGitCheckpoint'), undoGitCheckpoint: operation('undoGitCheckpoint'),
@@ -316,7 +322,8 @@ export const runtimePlatform = {
   appIconPath: () => String(requireRendererPlatform().APP_ICON_PATH ?? './assets/icon.png'),
   getRuntimeStatus: operation('getRuntimeStatus'), setActiveModel: operation('setActiveModel'),
   selectWorkspaceDirectory: operation('selectWorkspaceDirectory'), selectLinkedFolderPath: operation('selectLinkedFolderPath'),
-  isTauriRuntime: operation('isTauriRuntime'), readWorkspaceFile: operation('readWorkspaceFile'),
+  isTauriRuntime: operation('isTauriRuntime'), readWorkspaceFile: operation('readWorkspaceFile'), readWorkspaceImage: operation('readWorkspaceImage'), readWorkspaceMedia: operation('readWorkspaceMedia'),
+  openExternal: operation('openExternal'),
 }
 
 /** Install the Desktop or Web adapter before rendering the application. */

package/src/renderer/shared/speech/player.ts

@@ -0,0 +1,160 @@
+import type { SpeechReply, SpeechTransport } from './types'
+
+type Prepared = Extract<SpeechReply, { kind: 'prepared' }>
+type Input = { chatId: string; turnId?: number; text?: string; automatic?: boolean; audioOnly?: boolean }
+export type SpeechState = 'idle' | 'preparing' | 'speaking'
+
+/** One cancellable playback run, shared by Desktop, Web and Companion. */
+export class SpeechPlayer {
+  private generation = 0
+  private owner: string | null = null
+  private context: AudioContext | null = null
+  private source: AudioBufferSourceNode | null = null
+  private gain: GainNode | null = null
+  private timer: ReturnType<typeof setInterval> | undefined
+  private frame = 0
+  private settle: (() => void) | null = null
+  private renewing = false
+  private localVolume = 1
+  private hostVolume = 1
+  private speaking = false
+  constructor(private transport: SpeechTransport, private changed: (state: SpeechState) => void, private failed: (message: string) => void, private samples?: (samples: Float32Array | null) => void) {}
+
+  unlock(): Promise<void> {
+    try {
+      this.context ??= new AudioContext()
+      const context = this.context
+      return new Promise<void>((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Use the Read button to allow audio playback.')), 1500)
+        context.resume().then(() => { clearTimeout(timer); resolve() }, error => { clearTimeout(timer); reject(error) })
+      })
+    }
+    catch (error) { return Promise.reject(error) }
+  }
+  volume(value: number) {
+    this.localVolume = Math.min(1, Math.max(0, value))
+    if (this.gain) this.gain.gain.value = this.localVolume * this.hostVolume
+  }
+  stop(): Promise<void> {
+    this.generation += 1
+    const owner = this.owner
+    this.owner = null
+    clearInterval(this.timer); this.timer = undefined
+    cancelAnimationFrame(this.frame)
+    const wasSpeaking = this.speaking; this.speaking = false
+    try { this.source?.stop() } catch {}
+    this.source?.disconnect(); this.source = null
+    this.gain?.disconnect(); this.gain = null
+    this.settle?.(); this.settle = null
+    if (wasSpeaking && typeof speechSynthesis !== 'undefined') speechSynthesis.cancel()
+    this.samples?.(null); this.changed('idle')
+    return owner ? this.transport({ operation: 'release', owner }).then(() => {}, () => {}) : Promise.resolve()
+  }
+  async dispose() { const context = this.context; this.context = null; await this.stop(); await context?.close() }
+  private async renew(owner: string): Promise<boolean> {
+    const reply = await this.transport({ operation: 'renew', owner })
+    return reply.kind === 'lease' && reply.active
+  }
+  async play(input: Input): Promise<void> {
+    const previous = this.stop()
+    const generation = this.generation
+    const owner = crypto.randomUUID()
+    this.owner = owner
+    this.changed('preparing')
+    // Resume synchronously from the Read/Enable button's user gesture.
+    const unlocked = this.unlock().then(() => null, error => error)
+    try {
+      await previous; const unlockError = await unlocked; if (unlockError) throw unlockError
+      if (generation !== this.generation) return
+      let prepared: SpeechReply | undefined
+      for (let attempt = 0; attempt < 40; attempt++) {
+        if (generation !== this.generation) return
+        try { prepared = await this.transport({ operation: 'prepare', owner, ...input }); break }
+        catch (error) {
+          if (!input.automatic || !/Another Mint surface/.test(String(error)) || attempt === 39) throw error
+          // Wait for the revoked player to acknowledge stopping; never overlap its final audio segment.
+          await new Promise(resolve => setTimeout(resolve, 300))
+        }
+      }
+      if (generation !== this.generation) return
+      if (!prepared || prepared.kind !== 'prepared') throw new Error('Mint returned no speech plan')
+      this.hostVolume = prepared.volume
+      this.timer = setInterval(() => {
+        if (this.renewing) return
+        this.renewing = true
+        this.renew(owner).then(active => { if (!active && this.owner === owner) void this.stop() })
+          .catch(() => { if (this.owner === owner) void this.stop() }).finally(() => { this.renewing = false })
+      }, 1000)
+      if (prepared.provider === 'native') {
+        if (input.audioOnly) throw new Error('This voice cannot stream audio to Companion')
+        await this.playNative(prepared, generation)
+      } else {
+        for (let index = 0; index < prepared.chunks && generation === this.generation; index++) {
+          const audio = await this.transport({ operation: 'audio', owner, index })
+          if (generation !== this.generation) return
+          if (audio.kind !== 'audio') throw new Error('Mint returned no speech audio')
+          const bytes = Uint8Array.from(atob(audio.data), character => character.charCodeAt(0))
+          const buffer = await this.context!.decodeAudioData(bytes.buffer)
+          if (generation !== this.generation) return
+          await this.playBuffer(buffer, prepared, owner, generation)
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      if (generation === this.generation && !(input.automatic && /already been read automatically|Another Mint surface|A newer message|Automatic replies are routed/.test(message))) this.failed(message)
+    } finally {
+      if (generation === this.generation) await this.stop()
+      // Covers cancellation racing with preparation on another socket/process.
+      else await this.transport({ operation: 'release', owner }).catch(() => {})
+    }
+  }
+  private async playBuffer(buffer: AudioBuffer, plan: Prepared, owner: string, generation: number) {
+    const context = this.context!
+    const gain = context.createGain(); this.gain = gain
+    gain.gain.value = plan.volume * this.localVolume
+    const analyser = context.createAnalyser(); analyser.fftSize = 256
+    gain.connect(analyser); analyser.connect(context.destination)
+    const samples = new Float32Array(analyser.fftSize)
+    let frame = 0
+    const sample = () => {
+      if (generation !== this.generation) return
+      analyser.getFloatTimeDomainData(samples); this.samples?.(samples)
+      frame = requestAnimationFrame(sample); this.frame = frame
+    }
+    this.changed('speaking'); this.speaking = true; sample()
+    try {
+      // Short independently leased segments cannot continue for minutes after a frozen tab loses ownership.
+      let offset = 0
+      while (offset < buffer.duration && generation === this.generation) {
+        if (!await this.renew(owner) || generation !== this.generation) return
+        const length = Math.min(4 * plan.speed, buffer.duration - offset)
+        await new Promise<void>(resolve => {
+          const source = context.createBufferSource(); this.source = source
+          source.buffer = buffer; source.playbackRate.value = plan.speed
+          source.connect(gain); this.settle = resolve
+          source.onended = () => { source.disconnect(); if (this.source === source) { this.source = null; this.settle = null } resolve() }
+          source.start(0, offset, length)
+        })
+        offset += length
+      }
+    } finally {
+      cancelAnimationFrame(frame); if (generation === this.generation) this.samples?.(null)
+      analyser.disconnect(); gain.disconnect(); if (this.gain === gain) this.gain = null
+    }
+  }
+  private async playNative(plan: Prepared, generation: number) {
+    if (typeof speechSynthesis === 'undefined') throw new Error('System speech is unavailable')
+    this.changed('speaking'); this.speaking = true
+    await new Promise<void>((resolve, reject) => {
+      const utterance = new SpeechSynthesisUtterance(plan.text)
+      utterance.lang = /[\u0e00-\u0e7f]/.test(plan.text) ? 'th-TH' : 'en-US'
+      utterance.volume = plan.volume * this.localVolume; utterance.rate = plan.speed; utterance.pitch = plan.pitch
+      const voice = speechSynthesis.getVoices().find(voice => voice.lang.toLowerCase().startsWith(utterance.lang.slice(0, 2)))
+      if (voice) utterance.voice = voice
+      this.settle = resolve
+      utterance.onend = () => { if (this.settle === resolve) this.settle = null; resolve() }
+      utterance.onerror = event => { if (this.settle === resolve) this.settle = null; if (generation !== this.generation) resolve(); else reject(new Error(event.error)) }
+      speechSynthesis.speak(utterance)
+    })
+  }
+}

package/src/renderer/shared/speech/types.ts

@@ -0,0 +1,11 @@
+export type SpeechRequest =
+  | { operation: 'prefer'; owner: string; chatId: string; enabled: boolean }
+  | { operation: 'prepare'; owner: string; chatId: string; turnId?: number; text?: string; automatic?: boolean; audioOnly?: boolean; routeOwner?: string }
+  | { operation: 'audio'; owner: string; index: number }
+  | { operation: 'renew' | 'release'; owner: string }
+export type SpeechReply =
+  | { kind: 'prepared'; text: string; provider: string; volume: number; speed: number; pitch: number; chunks: number }
+  | { kind: 'audio'; data: string }
+  | { kind: 'lease'; active: boolean }
+  | { kind: 'released' }
+export type SpeechTransport = (request: SpeechRequest) => Promise<SpeechReply>

package/src/renderer/shared/theme/themeManager.test.ts

@@ -40,4 +40,41 @@ describe('theme surface settings', () => {
     expect(attributes.get('data-surface')).toBe('opaque')
     expect(properties.get('--glass-blur')).toBe('none')
   })
+
+  it('sets data-accent-mode to monochrome for pure white accent', () => {
+    applyTheme({ theme: 'dark', accentColor: '#ffffff' })
+    expect(attributes.get('data-accent-mode')).toBe('monochrome')
+  })
+
+  it('sets data-accent-mode to gray for neutral gray accents', () => {
+    applyTheme({ theme: 'dark', accentColor: '#52525b' })
+    expect(attributes.get('data-accent-mode')).toBe('gray')
+  })
+
+  it('sets data-accent-mode to color for standard color accents', () => {
+    applyTheme({ theme: 'dark', accentColor: '#10b981' })
+    expect(attributes.get('data-accent-mode')).toBe('color')
+  })
+
+  it('correctly sets data-theme to studio when studio theme is selected', () => {
+    applyTheme({ theme: 'studio' })
+    expect(attributes.get('data-theme')).toBe('studio')
+  })
+
+  it('sets centralized text color and derived tokens when textColor is provided', () => {
+    applyTheme({ theme: 'dark', textColor: '#f8fafc' })
+    expect(properties.get('--text-main')).toBe('#f8fafc')
+    expect(properties.get('--text-chat')).toBe('#f8fafc')
+    expect(properties.get('--text-primary')).toBe('#f8fafc')
+    expect(properties.get('--text-soft')).toBe('color-mix(in srgb, #f8fafc 82%, transparent)')
+    expect(properties.get('--text-secondary')).toBe('color-mix(in srgb, #f8fafc 82%, transparent)')
+    expect(properties.get('--text-muted')).toBe('color-mix(in srgb, #f8fafc 58%, transparent)')
+  })
+
+  it('sets custom text color when another color is chosen', () => {
+    applyTheme({ theme: 'dark', textColor: '#f5f5f4' })
+    expect(properties.get('--text-main')).toBe('#f5f5f4')
+    expect(properties.get('--text-chat')).toBe('#f5f5f4')
+    expect(properties.get('--text-primary')).toBe('#f5f5f4')
+  })
 })

package/src/renderer/shared/theme/themeManager.ts

@@ -83,9 +83,11 @@ export const applyTheme = (cfg: any): void => {
   document.documentElement.setAttribute('data-theme', effectiveTheme)
   document.documentElement.setAttribute('data-surface', surfaceStyle)
   const normalizedAccent = accentColor.trim().toLowerCase()
+  const isMonochrome = normalizedAccent === '#ffffff' || normalizedAccent === '#fff'
+  const isGray = normalizedAccent === '#52525b' || normalizedAccent === '#475569' || normalizedAccent === '#3f3f46' || normalizedAccent === '#64748b'
   document.documentElement.setAttribute(
     'data-accent-mode',
-    normalizedAccent === '#ffffff' || normalizedAccent === '#fff' ? 'monochrome' : 'color'
+    isMonochrome ? 'monochrome' : (isGray ? 'gray' : 'color')
   )
 
   // Set Accent variables
@@ -98,6 +100,26 @@ export const applyTheme = (cfg: any): void => {
   document.documentElement.style.setProperty('--text-on-accent', contrastText)
   document.documentElement.style.setProperty('--accent-contrast', contrastText)
 
+  // Centralized Text Color Tokens
+  const textColor = cfg.textColor || cfg.systemTextColor || cfg.chatTextColor
+  if (textColor) {
+    document.documentElement.style.setProperty('--text-main', textColor)
+    document.documentElement.style.setProperty('--text-chat', textColor)
+    document.documentElement.style.setProperty('--text-primary', textColor)
+    document.documentElement.style.setProperty('--text-soft', `color-mix(in srgb, ${textColor} 82%, transparent)`)
+    document.documentElement.style.setProperty('--text-secondary', `color-mix(in srgb, ${textColor} 82%, transparent)`)
+    document.documentElement.style.setProperty('--text-muted', `color-mix(in srgb, ${textColor} 58%, transparent)`)
+  } else {
+    ;[
+      '--text-main',
+      '--text-chat',
+      '--text-primary',
+      '--text-soft',
+      '--text-secondary',
+      '--text-muted',
+    ].forEach((prop) => document.documentElement.style.removeProperty(prop))
+  }
+
   // Surface and Blur
   if (surfaceStyle === 'opaque') {
     document.documentElement.style.setProperty('--glass-blur', 'none')
@@ -138,7 +160,7 @@ export const applyTheme = (cfg: any): void => {
     return
   }
 
-  // Clean up inline background and text overrides for standard themes
+  // Clean up inline background overrides for standard themes
   ;[
     '--bg-canvas',
     '--bg-color',
@@ -150,8 +172,5 @@ export const applyTheme = (cfg: any): void => {
     '--surface-bg',
     '--surface-strong',
     '--input-bg',
-    '--text-main',
-    '--text-chat',
-    '--text-soft',
   ].forEach((prop) => document.documentElement.style.removeProperty(prop))
 }

package/src/renderer/shared/theme/themes.ts

@@ -3,7 +3,7 @@
  * TypeScript constants and types for the Mint GUI Theme System.
  */
 
-export type ColorMode = 'system' | 'dark' | 'light' | 'midnight'
+export type ColorMode = 'system' | 'dark' | 'light' | 'midnight' | 'studio'
 export type SurfaceStyle = 'opaque' | 'glass'
 
 export interface AccentFlavor {
@@ -59,12 +59,66 @@ export const ACCENT_FLAVORS: AccentFlavor[] = [
   },
 ]
 
+export interface TextColorFlavor {
+  id: string
+  name: string
+  color: string
+  contrastText: string
+  description: string
+}
+
+export const TEXT_COLOR_FLAVORS: TextColorFlavor[] = [
+  {
+    id: 'white',
+    name: 'Pure White',
+    color: '#ffffff',
+    contrastText: '#09090b',
+    description: 'Crisp classic bright white',
+  },
+  {
+    id: 'green',
+    name: 'Cyber Green',
+    color: '#86efac',
+    contrastText: '#09090b',
+    description: 'Phosphor terminal matrix green',
+  },
+  {
+    id: 'cyan',
+    name: 'Electric Cyan',
+    color: '#67e8f9',
+    contrastText: '#09090b',
+    description: 'Sci-fi holographic ice cyan',
+  },
+  {
+    id: 'amber',
+    name: 'Retro Amber',
+    color: '#fde047',
+    contrastText: '#09090b',
+    description: 'Warm CRT phosphor amber gold',
+  },
+  {
+    id: 'lavender',
+    name: 'Pastel Lilac',
+    color: '#d8b4fe',
+    contrastText: '#09090b',
+    description: 'Soft dreamy violet lavender',
+  },
+  {
+    id: 'coral',
+    name: 'Soft Coral',
+    color: '#fda4af',
+    contrastText: '#09090b',
+    description: 'Warm energetic pastel rose coral',
+  },
+]
+
 export interface ThemePreset {
   id: string
   name: string
   description: string
-  theme: 'dark' | 'light' | 'midnight'
+  theme: 'dark' | 'light' | 'midnight' | 'studio'
   accentColor: string
+  textColor?: string
   systemTextColor: string
   chatTextColor: string
   bgPreview: string
@@ -77,7 +131,7 @@ export const THEME_PRESETS: ThemePreset[] = [
   {
     id: 'preset-dark-mint',
     name: 'Dark Mint',
-    description: 'Black background · Green elements · White text',
+    description: 'Black background · Mint green & slate gray elements',
     theme: 'dark',
     accentColor: '#10b981',
     systemTextColor: '#f8fafc',
@@ -100,10 +154,23 @@ export const THEME_PRESETS: ThemePreset[] = [
     accentPreview: '#10b981',
     textPreview: '#0f172a',
   },
+  {
+    id: 'preset-studio-dark',
+    name: 'Studio Dark',
+    description: '#101010 canvas · #1c1c1c surfaces · #323232 active',
+    theme: 'studio',
+    accentColor: '#10b981',
+    systemTextColor: '#e1e1e1',
+    chatTextColor: '#e1e1e1',
+    bgPreview: '#101010',
+    panelPreview: '#161616',
+    accentPreview: '#10b981',
+    textPreview: '#e1e1e1',
+  },
   {
     id: 'preset-dark-mono',
     name: 'Dark Monochrome',
-    description: 'Black background · White elements · White text',
+    description: 'Black background · Slate gray surfaces · White text',
     theme: 'dark',
     accentColor: '#ffffff',
     systemTextColor: '#f8fafc',