@pheem49/mint 1.16.0 → 1.17.0

package/src/renderer/shared/utils/sessionSources.test.ts

@@ -3,7 +3,7 @@ import { collectSessionSources } from './sessionSources'
 import type { AgentProgress } from '../types'
 import { createElement } from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
-import SessionSources from '../components/SessionSources'
+import SessionSources from '../components/workspace/SessionSources'
 
 const search = (url: string, title = 'Reference'): AgentProgress => ({ type: 'ToolEnd', data: { action: 'web_search', input: { query: 'example' }, result: `1. ${title}\nURL: ${url}\nA useful reference` } })
 describe('session sources', () => {
@@ -28,4 +28,44 @@ describe('session sources', () => {
     expect(html).toContain('src="https://www.google.com/s2/favicons?sz=32&domain=open.spotify.com"')
     expect(html).toContain('referrerPolicy="no-referrer"')
   })
+  it('maps libraryItemId onto session sources and exposes tool preview for images', () => {
+    const sources = collectSessionSources({
+      attachments: [{
+        id: 10,
+        interactionId: 1,
+        name: 'diagram.png',
+        kind: 'image',
+        mimeType: 'image/png',
+        thumbnailDataUri: 'data:image/png;base64,abc',
+        libraryItemId: 'lib-123',
+      }],
+      webSearchProgress: [],
+    })
+    expect(sources[0]).toMatchObject({
+      id: 'attachment:10',
+      kind: 'image',
+      name: 'diagram.png',
+      libraryItemId: 'lib-123',
+      thumbnailDataUri: 'data:image/png;base64,abc',
+    })
+    const htmlWithPreview = renderToStaticMarkup(createElement(SessionSources, {
+      sources,
+      loading: false,
+      error: '',
+      onRetry: () => {},
+      onOpenLibrary: () => {},
+      onOpenArtifact: () => {},
+    }))
+    expect(htmlWithPreview).toContain('Open image preview in Tools')
+
+    const htmlWithoutPreview = renderToStaticMarkup(createElement(SessionSources, {
+      sources,
+      loading: false,
+      error: '',
+      onRetry: () => {},
+      onOpenLibrary: () => {},
+    }))
+    expect(htmlWithoutPreview).not.toContain('Open image preview in Tools')
+    expect(htmlWithoutPreview).toContain('href="/library?item=lib-123"')
+  })
 })

package/src/renderer/shared/utils/sessionSources.ts

@@ -10,6 +10,7 @@ export interface SessionSource {
   thumbnailDataUri?: string
   faviconUrl?: string
   url?: string
+  libraryItemId?: string
 }
 
 export function collectSessionSources(persisted: ConversationSources, liveProgress: AgentProgress[] = []): SessionSource[] {
@@ -18,6 +19,7 @@ export function collectSessionSources(persisted: ConversationSources, liveProgre
     detail: attachment.trashed ? 'In Trash · Restore in Library' : attachment.availability === 'missing' ? 'Original file missing' : attachment.kind === 'image' ? 'Image' : attachment.kind === 'video' ? 'Video' : (attachment.name.split('.').length > 1 ? attachment.name.split('.').at(-1)!.toUpperCase() : 'File'),
     url: attachment.libraryItemId ? `/library?${new URLSearchParams({ item: attachment.libraryItemId, ...(attachment.trashed ? { trash: '1' } : {}) })}` : undefined,
     interactionId: attachment.interactionId ?? undefined, thumbnailDataUri: attachment.thumbnailDataUri || undefined,
+    libraryItemId: attachment.libraryItemId || undefined,
   }))
   const seen = new Set<string>()
   const web: SessionSource[] = []

package/src/renderer/shared/utils/slashCommandProcessor.ts

@@ -8,7 +8,7 @@
 
 export interface SlashCommandExecutionResult {
   handled: boolean
-  action?: 'open_image_picker' | 'paste_image' | 'generate_veo' | 'system_message' | 'resume_session'
+  action?: 'open_image_picker' | 'paste_image' | 'generate_veo' | 'system_message' | 'resume_session' | 'open_settings'
   payload?: any
   systemText?: string
 }
@@ -42,6 +42,9 @@ export function executeSlashCommand(input: string): SlashCommandExecutionResult
     case '/resume':
       return { handled: true, action: 'resume_session', payload: { query: rest } }
 
+    case '/onboard':
+      return { handled: true, action: 'open_settings' }
+
     case '/veo': {
       if (!rest) {
         return {

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

@@ -1,6 +1,7 @@
 import { useState, useRef, useEffect } from 'react'
 
 export interface SpeechToTextOptions {
+  chatId?: string
   language?: string
   message: string
   sending: boolean
@@ -10,6 +11,7 @@ export interface SpeechToTextOptions {
 }
 
 export function useSpeechToText({
+  chatId,
   language,
   message,
   sending,
@@ -32,6 +34,9 @@ export function useSpeechToText({
   const voiceAwaitingResponseRef = useRef(false)
   const isSpeakingRef = useRef(false)
   const messageRef = useRef(message)
+  const chatIdRef = useRef(chatId)
+  const previousChatIdRef = useRef(chatId)
+  chatIdRef.current = chatId
 
   // Sync state to refs for event handlers
   useEffect(() => {
@@ -97,6 +102,12 @@ export function useSpeechToText({
     setVoiceTranscript('')
   }
 
+  useEffect(() => {
+    if (previousChatIdRef.current === chatId) return
+    previousChatIdRef.current = chatId
+    cancelRecognition()
+  }, [chatId])
+
   const scheduleVoiceListen = (delayMs = 350) => {
     clearRestartTimer()
     if (!voiceModeRef.current || sendingRef.current || voiceAwaitingResponseRef.current || isSpeakingRef.current) return
@@ -111,9 +122,10 @@ export function useSpeechToText({
 
     const SpeechRecognitionApi = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition
     if (!SpeechRecognitionApi) {
-      setVoiceTranscript('Speech recognition is unavailable in this browser. Use Chrome or Edge.')
+      setVoiceTranscript('')
       voiceModeRef.current = false
-      setVoiceMode(true)
+      setVoiceMode(false)
+      window.alert('Speech recognition is unavailable in this browser. Use Chrome or Edge.')
       return Promise.resolve(false)
     }
 
@@ -147,7 +159,9 @@ export function useSpeechToText({
         if (recognitionRef.current !== recognition) return
         let interimText = ''
         let finalText = ''
-        for (let index = event.resultIndex; index < event.results.length; index += 1) {
+        // Each event contains the complete session result list. Rebuild it so
+        // later phrases retain earlier finals and interim revisions do not duplicate text.
+        for (let index = 0; index < event.results.length; index += 1) {
           const transcript = event.results[index]?.[0]?.transcript ?? ''
           if (event.results[index]?.isFinal) {
             finalText += transcript
@@ -175,7 +189,7 @@ export function useSpeechToText({
         clearSilenceTimer()
       }
       recognition.onend = () => {
-        if (recognitionRef.current !== recognition) return
+        if (recognitionRef.current !== recognition || chatIdRef.current !== chatId) return
         resolveStartRef.current?.(false)
         resolveStartRef.current = null
         recognitionRef.current = null

package/src/renderer/shared/utils/useNativeVoiceInput.ts

@@ -2,7 +2,9 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import { createNativeRecordingSession, type NativeRecordingBackend } from './nativeRecordingSession'
 
 export interface NativeVoiceInputOptions extends NativeRecordingBackend {
-  onSendVoiceMessage: (text: string) => Promise<any>
+  chatId?: string
+  message: string
+  onSetMessage: (text: string) => void
 }
 
 /** Explicit push-to-talk, with cancel/stop requests serialized behind device startup. */
@@ -14,6 +16,7 @@ export function useNativeVoiceInput(options: NativeVoiceInputOptions) {
   const voiceAwaitingResponseRef = useRef(false)
   const voiceModeRef = useRef(false)
   const latest = useRef(options)
+  const previousChatId = useRef(options.chatId)
   latest.current = options
   const mounted = useRef(true)
   const epoch = useRef(0)
@@ -30,14 +33,15 @@ export function useNativeVoiceInput(options: NativeVoiceInputOptions) {
   const startRecognition = useCallback(async () => {
     if (stopping.current) return false
     const request = ++epoch.current
+    const chatId = latest.current.chatId
     setVoiceTranscript('')
     try {
       const started = await session.current!.start()
-      if (started && mounted.current && request === epoch.current) {
+      if (started && mounted.current && request === epoch.current && chatId === latest.current.chatId) {
         setIsRecording(true)
         setVoiceMode(true)
       }
-      return started && mounted.current && request === epoch.current
+      return started && mounted.current && request === epoch.current && chatId === latest.current.chatId
     } catch (error) {
       if (mounted.current && request === epoch.current) {
         setVoiceTranscript(error instanceof Error ? error.message : String(error))
@@ -50,16 +54,20 @@ export function useNativeVoiceInput(options: NativeVoiceInputOptions) {
   const stopRecognition = useCallback(() => {
     if (stopping.current) return stopping.current
     const request = epoch.current
+    const chatId = latest.current.chatId
     setIsRecording(false)
     setVoiceAwaitingResponse(true)
     setVoiceTranscript('Transcribing...')
     const finish = async () => {
       try {
         const text = await session.current!.stop()
-        if (!mounted.current || request !== epoch.current || text === null) return
+        if (!mounted.current || request !== epoch.current || chatId !== latest.current.chatId || text === null) return
         const trimmed = text.trim()
         setVoiceTranscript(trimmed || 'No speech detected')
-        if (trimmed) await latest.current.onSendVoiceMessage(trimmed)
+        if (trimmed) {
+          const { message, onSetMessage } = latest.current
+          onSetMessage(message.trim() ? `${message.trimEnd()} ${trimmed}` : trimmed)
+        }
       } catch (error) {
         if (mounted.current && request === epoch.current) {
           setVoiceTranscript(error instanceof Error ? error.message : String(error))
@@ -90,6 +98,12 @@ export function useNativeVoiceInput(options: NativeVoiceInputOptions) {
     }
   }, [])
 
+  useEffect(() => {
+    if (previousChatId.current === options.chatId) return
+    previousChatId.current = options.chatId
+    void cancelRecognition()
+  }, [options.chatId, cancelRecognition])
+
   useEffect(() => {
     mounted.current = true
     return () => {

package/src/renderer/shared/utils/useSessionSources.ts

@@ -3,6 +3,10 @@ import { conversationPlatform } from '../platform'
 import type { AgentProgress, ConversationSources } from '../types'
 import { collectSessionSources } from './sessionSources'
 
+export function shouldPollSessionSources(toolsPanelOpen: boolean, activeSurfaceId: string | null): boolean {
+  return toolsPanelOpen && (activeSurfaceId === null || activeSurfaceId === 'sources')
+}
+
 /** Shared session ownership and polling for the Desktop and Web source panels. */
 export function useSessionSources(chatId: string, liveProgress: AgentProgress[], enabled: boolean) {
   const [state, setState] = useState<{ chatId: string; value: ConversationSources | null; error: string; loading: boolean } | null>(null)

package/src/renderer/shared/utils/viewedImages.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+import { viewedImagesFrom, viewedImageDataUri } from './viewedImages'
+import type { AgentProgress } from '../types'
+
+describe('viewedImagesFrom', () => {
+  it('extracts legacy inline data URI from ToolEnd', () => {
+    const dataUri = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII='
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'view_image',
+          callId: 'call-1',
+          input: { path: '/workspace/photos/photo.png' },
+          result: `${dataUri}\n\n[Hook] Viewed`,
+          status: 'success',
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      id: 'call-1',
+      src: dataUri,
+      path: '/workspace/photos/photo.png',
+      name: 'photo.png',
+    })
+  })
+
+  it('extracts artifact-backed view_image seamlessly', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-view',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-12345',
+              name: 'example-com-shot.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 88239,
+              chatId: 'chat-test',
+              callId: 'call-view',
+              server: 'view_image',
+            },
+          ],
+        },
+      },
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'view_image',
+          callId: 'call-view',
+          input: { path: '.mint-screenshots/example-com-shot.png' },
+          result: 'Image saved: example-com-shot.png (artifactId: art-12345). Original: 1440 × 900.',
+          status: 'success',
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      id: 'call-view',
+      artifactId: 'art-12345',
+      path: '.mint-screenshots/example-com-shot.png',
+      name: 'example-com-shot.png',
+    })
+  })
+
+  it('recovers view_image artifacts even if ToolEnd was compacted or missing', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-compacted',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-recovered',
+              name: 'recovered.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 5000,
+              chatId: 'chat-test',
+              callId: 'call-compacted',
+              server: 'view_image',
+            },
+          ],
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0].artifactId).toBe('art-recovered')
+    expect(items[0].name).toBe('recovered.png')
+  })
+
+  it('ignores non-view_image artifacts so they remain in their respective tool handlers', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-browser',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-browser',
+              name: 'browser.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 5000,
+              chatId: 'chat-test',
+              callId: 'call-browser',
+              server: 'browser',
+            },
+          ],
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(0)
+  })
+})

package/src/renderer/shared/utils/viewedImages.ts

@@ -1,4 +1,4 @@
-import type { AgentProgress } from '../types'
+import type { AgentProgress, McpArtifact } from '../types'
 
 /** view_image returns an inline image, optionally followed by post-tool hook notes. */
 export function viewedImageDataUri(result: string): string | null {
@@ -7,20 +7,91 @@ export function viewedImageDataUri(result: string): string | null {
     ? firstLine : null
 }
 
-export function viewedImagesFrom(progress: AgentProgress[]) {
-  const images = new Map<string, { id: string; src: string; path: string; name: string }>()
+export interface ViewedImageItem {
+  id: string
+  src?: string
+  artifactId?: string
+  path: string
+  name: string
+}
+
+export function viewedImagesFrom(progress: AgentProgress[]): ViewedImageItem[] {
+  const images = new Map<string, ViewedImageItem>()
+  const artifactsByCallId = new Map<string, McpArtifact>()
+  const artifactsById = new Map<string, McpArtifact>()
+  const viewImageArtifacts: McpArtifact[] = []
+
+  progress.forEach(event => {
+    if (event.type === 'ToolArtifacts') {
+      for (const artifact of event.data.artifacts) {
+        if (artifact.kind === 'image') {
+          artifactsById.set(artifact.id, artifact)
+          if (event.data.callId) artifactsByCallId.set(event.data.callId, artifact)
+          if (artifact.callId) artifactsByCallId.set(artifact.callId, artifact)
+          if (artifact.server === 'view_image') {
+            viewImageArtifacts.push(artifact)
+          }
+        }
+      }
+    }
+  })
+
   let anonymousCount = 0
+  const handledCallIds = new Set<string>()
+  const handledArtifactIds = new Set<string>()
+
   progress.forEach(event => {
     if (event.type !== 'ToolEnd' || event.data.action !== 'view_image'
       || (event.data.status && event.data.status !== 'success')) return
-    const src = viewedImageDataUri(event.data.result)
-    if (!src) return
+
+    const callId = event.data.callId
     const path = typeof event.data.input.path === 'string' ? event.data.input.path : ''
-    const name = path.replaceAll('\\', '/').split('/').at(-1) || 'Image'
-    // Legacy/parallel results may omit callId. Count only retained images so
-    // trimming unrelated progress cannot remount an image and close its dialog.
-    const id = event.data.callId || `view-image-${anonymousCount++}`
-    images.set(id, { id, src, path, name })
+    const fallbackName = path.replaceAll('\\', '/').split('/').at(-1) || 'Image'
+    const id = callId || `view-image-${anonymousCount++}`
+
+    // 1. Try inline data URI first (legacy or direct)
+    const src = viewedImageDataUri(event.data.result)
+    if (src) {
+      if (callId) handledCallIds.add(callId)
+      images.set(id, { id, src, path, name: fallbackName })
+      return
+    }
+
+    // 2. Check if there is an artifact associated with this callId or mentioned in result
+    let artifact = (callId ? artifactsByCallId.get(callId) : undefined)
+    if (!artifact) {
+      const match = event.data.result.match(/artifactId:\s*([a-f0-9-]+)/i)
+      if (match) {
+        artifact = artifactsById.get(match[1])
+      }
+    }
+
+    if (artifact) {
+      if (callId) handledCallIds.add(callId)
+      handledArtifactIds.add(artifact.id)
+      images.set(id, {
+        id,
+        artifactId: artifact.id,
+        path: path || artifact.name,
+        name: artifact.name || fallbackName,
+      })
+    }
   })
+
+  // 3. Fallback for ToolArtifacts tagged as view_image when ToolEnd might be compacted or delayed
+  for (const artifact of viewImageArtifacts) {
+    if (handledArtifactIds.has(artifact.id) || (artifact.callId && handledCallIds.has(artifact.callId))) {
+      continue
+    }
+    const id = artifact.callId || artifact.id
+    images.set(id, {
+      id,
+      artifactId: artifact.id,
+      path: artifact.name,
+      name: artifact.name || 'Image',
+    })
+  }
+
   return [...images.values()]
 }
+

package/src/renderer/shared/utils/workspaceDrag.ts

@@ -0,0 +1,30 @@
+import { normalizeWorkspacePath } from './workspaces'
+
+export const WORKSPACE_FILE_MIME = 'application/x-mint-workspace-file'
+export interface WorkspaceFileDrag { root: string; path: string; kind: 'file' }
+
+/** Only explicit Workspace file drags are accepted; text mentions and folders stay separate. */
+export function parseWorkspaceFileDrag(raw: string): WorkspaceFileDrag {
+  let value: Partial<WorkspaceFileDrag>
+  try { value = JSON.parse(raw) } catch { throw Error('Drag a file from Workspace to preview it.') }
+  if (!value || value.kind !== 'file' || typeof value.root !== 'string' || typeof value.path !== 'string') throw Error('Drag a file from Workspace to preview it.')
+  const root = normalizeWorkspacePath(value.root)
+  const path = value.path.replace(/\\/g, '/')
+  if (!root || !/^(\/|[a-z]:\/)/i.test(root) || /\0/.test(root + path) || !path || /^(\/|[a-z]:)/i.test(path) || path.split('/').includes('..')) throw Error('This file is outside its source workspace.')
+  const relative = path.split('/').filter(part => part && part !== '.').join('/')
+  if (!relative) throw Error('Choose a file to preview.')
+  return { root, path: relative, kind: 'file' }
+}
+
+export function workspacePreviewId(root: string, path: string): string {
+  const file = parseWorkspaceFileDrag(JSON.stringify({ root, path, kind: 'file' }))
+  return `preview:${JSON.stringify([file.root, file.path])}`
+}
+
+export function workspaceFileUrl(root: string, path: string): string {
+  const file = parseWorkspaceFileDrag(JSON.stringify({ root, path, kind: 'file' }))
+  const full = `${file.root.replace(/\/$/, '')}/${file.path}`
+  const encoded = full.split('/').map(part => encodeURIComponent(part)).join('/')
+  if (/^[a-z]:\//i.test(full)) return `file:///${full.slice(0, 2)}${encoded.slice(encoded.indexOf('/'))}`
+  return `${full.startsWith('//') ? 'file:' : 'file://'}${encoded}`
+}

package/src/renderer/shared/utils/workspaceImage.ts

@@ -0,0 +1,17 @@
+/** Read through native IPC or the existing authenticated API; never start a preview service. */
+export function createWorkspaceImageReader(environment: {
+  isNative(): boolean
+  apiBase(): string
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}) {
+  return async (path: string, workspacePath: string): Promise<string> => {
+    if (environment.isNative()) {
+      const { invoke } = await import('@tauri-apps/api/core')
+      return invoke<string>('read_workspace_image', { path, workspacePath })
+    }
+    const response = await environment.fetch(`${environment.apiBase()}/file/image?${new URLSearchParams({ path, workspace: workspacePath })}`)
+    const value = await response.json()
+    if (!response.ok) throw Error(value.error || 'Could not read workspace image')
+    return value.dataUrl
+  }
+}

package/src/renderer/shared/utils/workspaceListPreferences.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import { createWorkspaceListPreferences } from './workspaceListPreferences'
+import { workspacePaths } from './workspaces'
+
+function storage() {
+  const data = new Map<string, string>()
+  return { getItem: (key: string) => data.get(key) ?? null, setItem: (key: string, value: string) => { data.set(key, value) } }
+}
+
+describe('workspace list removal', () => {
+  it('hides removed paths even when current workspace and saved sessions still reference them', () => {
+    const saved = storage()
+    const preferences = createWorkspaceListPreferences(saved)
+    preferences.remove(' /projects/Demo/ ')
+    expect(workspacePaths(['/projects/Demo', '/projects/Mint'], '/projects/Demo', ['/projects/Demo/'], preferences.getSnapshot()))
+      .toEqual(['/projects/Mint'])
+    const reloaded = createWorkspaceListPreferences(saved)
+    expect(workspacePaths([], '/projects/Demo', ['/projects/Demo'], reloaded.getSnapshot())).toEqual([])
+  })
+
+  it('notifies every picker and allows explicitly reopening the folder to restore it', () => {
+    const preferences = createWorkspaceListPreferences(storage())
+    const chat: string[][] = [], code: string[][] = []
+    preferences.subscribe(() => chat.push(preferences.getSnapshot()))
+    const unsubscribe = preferences.subscribe(() => code.push(preferences.getSnapshot()))
+    preferences.remove('C:\\Projects\\Demo\\')
+    expect(chat).toEqual([['C:/Projects/Demo']])
+    expect(code).toEqual([['C:/Projects/Demo']])
+    unsubscribe()
+    preferences.restore('C:/Projects/Demo/')
+    expect(chat).toEqual([['C:/Projects/Demo'], []])
+    expect(code).toHaveLength(1)
+    expect(workspacePaths(['C:/Projects/Demo'], '', [], preferences.getSnapshot())).toEqual(['C:/Projects/Demo'])
+  })
+
+  it('keeps list removal usable when browser storage is blocked', () => {
+    const preferences = createWorkspaceListPreferences({ getItem: () => { throw Error('blocked') }, setItem: () => { throw Error('blocked') } })
+    preferences.remove('/projects/Demo')
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+    preferences.restore('/projects/Demo')
+    expect(preferences.getSnapshot()).toEqual([])
+  })
+
+  it('retains session-only removals when storage can be read but is full', () => {
+    const preferences = createWorkspaceListPreferences({ getItem: () => null, setItem: () => { throw Error('quota exceeded') } })
+    preferences.remove('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+  })
+
+  it('ignores malformed stored preferences and reloads changes from another window', () => {
+    const saved = storage()
+    const otherWindow = createWorkspaceListPreferences(saved)
+    const preferences = createWorkspaceListPreferences(saved)
+    expect(preferences.getSnapshot()).toEqual([])
+    otherWindow.remove('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+    otherWindow.restore('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual([])
+    expect(createWorkspaceListPreferences({ getItem: () => '{invalid', setItem: () => {} }).getSnapshot()).toEqual([])
+  })
+})

package/src/renderer/shared/utils/workspaceListPreferences.ts

@@ -0,0 +1,54 @@
+import { normalizeWorkspacePath, workspacePaths } from './workspaces'
+
+const REMOVED_WORKSPACES_KEY = 'mint:removed-workspace-paths'
+export const EMPTY_REMOVED_WORKSPACES: string[] = []
+
+/** List visibility only: workspace ownership, sessions and files remain untouched. */
+export function createWorkspaceListPreferences(storage: Pick<Storage, 'getItem' | 'setItem'>) {
+  let snapshot: string[] | null = null
+  let sessionOnly = false
+  const listeners = new Set<() => void>()
+  const read = () => {
+    try {
+      const value: unknown = JSON.parse(storage.getItem(REMOVED_WORKSPACES_KEY) || '[]')
+      return Array.isArray(value) ? workspacePaths(value.filter((path): path is string => typeof path === 'string')) : []
+    } catch { return snapshot ?? [] }
+  }
+  const getSnapshot = (): string[] => snapshot ??= read()
+  const update = (paths: string[], persist: boolean) => {
+    if (JSON.stringify(paths) === JSON.stringify(getSnapshot())) return
+    snapshot = paths
+    if (persist) {
+      try { storage.setItem(REMOVED_WORKSPACES_KEY, JSON.stringify(paths)); sessionOnly = false } catch { sessionOnly = true }
+    }
+    listeners.forEach(listener => listener())
+  }
+  return {
+    getSnapshot,
+    subscribe(listener: () => void) { listeners.add(listener); return () => { listeners.delete(listener) } },
+    remove(path: string) {
+      const normalized = normalizeWorkspacePath(path)
+      if (normalized) update(workspacePaths([...getSnapshot(), normalized]), true)
+    },
+    restore(path: string) {
+      const normalized = normalizeWorkspacePath(path)
+      update(getSnapshot().filter(path => path !== normalized), true)
+    },
+    reload() { if (!sessionOnly) update(read(), false) },
+  }
+}
+
+export const workspaceListPreferences = createWorkspaceListPreferences({
+  getItem: key => window.localStorage.getItem(key),
+  setItem: (key, value) => window.localStorage.setItem(key, value),
+})
+
+export function subscribeWorkspaceListPreferences(listener: () => void) {
+  const unsubscribe = workspaceListPreferences.subscribe(listener)
+  workspaceListPreferences.reload()
+  const onStorage = (event: StorageEvent) => {
+    if (!event.key || event.key === REMOVED_WORKSPACES_KEY) workspaceListPreferences.reload()
+  }
+  window.addEventListener('storage', onStorage)
+  return () => { unsubscribe(); window.removeEventListener('storage', onStorage) }
+}