@pheem49/mint 1.15.0 → 1.16.0

package/src/renderer/shared/fonts.css

@@ -0,0 +1,46 @@
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url('/fonts/inter-regular.woff2') format('woff2');
+}
+
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 700;
+    font-display: swap;
+    src: url('/fonts/inter-bold.woff2') format('woff2');
+}
+
+@font-face {
+    font-family: 'Noto Sans Thai';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url('/fonts/noto-sans-thai.woff2') format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Noto Sans Thai';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url('/fonts/noto-sans-thai-thai.woff2') format('woff2');
+    unicode-range: U+02D7, U+0303, U+0331, U+0E01-0E5B, U+200C-200D, U+25CC;
+}
+
+@font-face {
+    font-family: 'IBM Plex Sans Thai';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url('/fonts/ibm-plex-sans-thai.woff2') format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+:root {
+    --font-ui: 'IBM Plex Sans Thai', 'Noto Sans Thai', 'Inter', ui-sans-serif, system-ui, sans-serif;
+}

package/src/renderer/shared/fonts.ts

@@ -1,16 +1,7 @@
-// Keep the default UI and code faces self-hosted for offline desktop use.
-// Import only the families and weights the initial UI uses; alternative font
-// selections fall back to the operating system instead of inflating every
-// launch with complete Unicode coverage we do not render by default.
-import '@fontsource/prompt/latin-400.css';
-import '@fontsource/prompt/thai-400.css';
-import '@fontsource/prompt/latin-500.css';
-import '@fontsource/prompt/thai-500.css';
-import '@fontsource/prompt/latin-600.css';
-import '@fontsource/prompt/thai-600.css';
-import '@fontsource/prompt/latin-700.css';
-import '@fontsource/prompt/thai-700.css';
+// UI families live in public/fonts so Desktop and Web use the same local files.
+import './fonts.css';
 
+// Keep the code face independently bundled until it has a local replacement.
 import '@fontsource/fira-code/latin-400.css';
 import '@fontsource/fira-code/symbols2-400.css';
 import '@fontsource/fira-code/latin-500.css';

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

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/renderer/shared/library/controller.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import { createLibraryController } from './controller'
+import type { LibraryItem, LibraryPage, LibraryQuery } from '../types'
+const item = (id: string): LibraryItem => ({ id, name: `${id}.md`, filename: `${id}.md`, kind: 'file', mimeType: 'text/markdown', size: 5, createdAt: '2026-10-15T00:00:00Z', origin: 'uploaded', source: 'chat', message: '', deletedAt: null, thumbnailStatus: 'unavailable', availability: 'ready', references: [] })
+const deferred = <T,>() => { let resolve!: (value: T) => void; const promise = new Promise<T>(r => { resolve = r }); return { promise, resolve } }
+describe('Library controller', () => {
+  it('rejects stale search pages and keeps known files after a refresh fails', async () => {
+    const late = deferred<LibraryPage>(); let fail = false
+    const controller = createLibraryController({ list: async query => { if (fail) throw new Error('Offline'); return query.search === 'old' ? late.promise : { items: [item('new')], nextCursor: null } }, setTrashed: async () => {}, remove: async () => {} })
+    const old = controller.setQuery({ search: 'old' })
+    await controller.setQuery({ search: 'new' }); late.resolve({ items: [item('old')], nextCursor: null }); await old
+    expect(controller.getSnapshot().items.map(i => i.id)).toEqual(['new'])
+    fail = true; await controller.refresh()
+    expect(controller.getSnapshot().items.map(i => i.id)).toEqual(['new'])
+    expect(controller.getSnapshot().error).toContain('Offline')
+  })
+  it('paginates with the returned cursor and surfaces failed Trash actions', async () => {
+    const queries: LibraryQuery[] = []; let fail = true
+    const controller = createLibraryController({ list: async query => { queries.push(query); return query.cursor ? { items: [item('second')], nextCursor: null } : { items: [item('first')], nextCursor: 'next' } }, setTrashed: async () => { if (fail) throw new Error('Locked') }, remove: async () => {} })
+    await controller.refresh(); await controller.loadMore()
+    expect(queries[1].cursor).toBe('next')
+    expect(controller.getSnapshot().items.map(i => i.id)).toEqual(['first', 'second'])
+    await controller.setTrashed('first', true)
+    expect(controller.getSnapshot().items).toHaveLength(2)
+    expect(controller.getSnapshot().actionError).toContain('Locked')
+    fail = false; await controller.setTrashed('first', true)
+    expect(controller.getSnapshot().items.map(i => i.id)).toEqual(['second'])
+  })
+})
+
+it('does not resurrect a trashed file when an older refresh finishes', async()=>{
+ const late=deferred<LibraryPage>();let initial=true
+ const controller=createLibraryController({list:async()=>initial?(initial=false,{items:[item('one')],nextCursor:null}):late.promise,setTrashed:async()=>{},remove:async()=>{}})
+ await controller.refresh();const refresh=controller.refresh()
+ await controller.setTrashed('one',true)
+ late.resolve({items:[item('one')],nextCursor:null});await refresh
+ expect(controller.getSnapshot().items).toEqual([])
+ expect(controller.getSnapshot().loading).toBe(false)
+})
+
+it('removes a Trash entry only after system Trash succeeds and rejects a stale refresh',async()=>{
+ let fail=true;let initial=true;const late=deferred<LibraryPage>()
+ const controller=createLibraryController({list:async()=>initial?(initial=false,{items:[item('one')],nextCursor:null}):late.promise,setTrashed:async()=>{},remove:async()=>{if(fail)throw new Error('System Trash unavailable')}})
+ await controller.setQuery({trashed:true});await controller.remove('one')
+ expect(controller.getSnapshot().items).toHaveLength(1);expect(controller.getSnapshot().actionError).toContain('System Trash unavailable')
+ const refresh=controller.refresh();fail=false;await controller.remove('one');late.resolve({items:[item('one')],nextCursor:null});await refresh
+ expect(controller.getSnapshot().items).toEqual([])
+})
+
+it('refreshes every loaded page while thumbnail statuses change', async () => {
+  let ready = false
+  const first = Array.from({ length: 40 }, (_, i) => ({ ...item(`first-${i}`), thumbnailStatus: ready ? 'ready' as const : 'pending' as const }))
+  const second = Array.from({ length: 40 }, (_, i) => item(`second-${i}`))
+  const controller = createLibraryController({ list: async q => q.cursor ? { items: second, nextCursor: 'page-three' } : { items: first.map(i => ({ ...i, thumbnailStatus: ready ? 'ready' : 'pending' })), nextCursor: 'page-two' }, setTrashed: async () => {}, remove: async () => {} })
+  await controller.refresh(); await controller.loadMore()
+  expect(controller.getSnapshot().items).toHaveLength(80)
+  ready = true; await controller.refresh()
+  expect(controller.getSnapshot().items).toHaveLength(80)
+  expect(controller.getSnapshot().items[0].thumbnailStatus).toBe('ready')
+  expect(controller.getSnapshot().nextCursor).toBe('page-three')
+})

package/src/renderer/shared/library/controller.ts

@@ -0,0 +1,57 @@
+import type { LibraryItem, LibraryPage, LibraryQuery } from '../types'
+export interface LibraryOperations {
+  list(query: LibraryQuery): Promise<LibraryPage>
+  setTrashed(id: string, trashed: boolean): Promise<void>
+  remove(id: string): Promise<void>
+}
+export interface LibraryState { items: LibraryItem[]; query: LibraryQuery; nextCursor: string | null; loading: boolean; error: string; actionId: string | null; actionError: string }
+export function createLibraryController(api: LibraryOperations) {
+  let state: LibraryState = { items: [], query: {}, nextCursor: null, loading: false, error: '', actionId: null, actionError: '' }
+  let generation = 0
+  let loadedPages = 1
+  const listeners = new Set<() => void>()
+  const update = (patch: Partial<LibraryState>) => { state = { ...state, ...patch }; listeners.forEach(listener => listener()) }
+  const load = async (append = false) => {
+    if (append && (state.loading || !state.nextCursor)) return
+    const current = ++generation
+    const query = { ...state.query, cursor: append ? state.nextCursor : undefined }
+    const pagesToRefresh = append ? 1 : loadedPages
+    update({ loading: true, error: '' })
+    try {
+      let page = await api.list(query)
+      if (current !== generation) return
+      let pagesRead = 1
+      const refreshedItems = [...page.items]
+      while (!append && pagesRead < pagesToRefresh && page.nextCursor) {
+        page = await api.list({ ...query, cursor: page.nextCursor })
+        if (current !== generation) return
+        refreshedItems.push(...page.items)
+        pagesRead++
+      }
+      if (!append) page = { ...page, items: refreshedItems }
+      loadedPages = append ? loadedPages + 1 : pagesRead
+      const items = append ? [...new Map([...state.items, ...page.items].map(item => [item.id, item])).values()] : page.items
+      update({ items, nextCursor: page.nextCursor })
+    } catch (error) { if (current === generation) update({ error: String(error) }) }
+    finally { if (current === generation) update({ loading: false }) }
+  }
+  const mutate = async (id: string, operation: () => Promise<void>) => {
+    if (state.actionId) return
+    const current = generation
+    update({ actionId: id, actionError: '' })
+    try {
+      await operation()
+      if (current === generation) { generation++; update({ items: state.items.filter(item => item.id !== id), loading: false }) }
+      else await load()
+    } catch (error) { update({ actionError: String(error) }) }
+    finally { update({ actionId: null }) }
+  }
+  return {
+    remove: (id: string) => mutate(id, () => api.remove(id)),
+    getSnapshot: () => state,
+    subscribe: (listener: () => void) => { listeners.add(listener); return () => { listeners.delete(listener) } },
+    setQuery: async (query: LibraryQuery) => { loadedPages = 1; update({ query: { ...query, cursor: undefined }, items: [], nextCursor: null, actionError: '' }); await load() },
+    refresh: () => load(), loadMore: () => load(true),
+    setTrashed: (id: string, trashed: boolean) => mutate(id, () => api.setTrashed(id, trashed)),
+  }
+}

package/src/renderer/shared/library/transport.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { createLibraryTransport } from './transport'
+describe('Library wire contract', () => {
+  it('encodes filters, uses indexed IDs for content and surfaces server errors', async () => {
+    const calls: {url: URL; method: string}[] = []
+    const api = createLibraryTransport({ isNative: () => false, apiBase: () => 'http://localhost/api', fetch: async (input, init) => {
+      const url = new URL(String(input)); calls.push({url,method:init?.method ?? 'GET'})
+      if(url.pathname.endsWith('/content')) return new Response('hello', {headers:{'Content-Type':'text/markdown'}})
+      if(init?.method === 'POST' || init?.method === 'DELETE') return Response.json({message:'Storage unavailable'}, {status:503})
+      return Response.json({items:[],nextCursor:null})
+    } })
+    await api.listLibrary({kind:'file',search:'สรุป & notes',chatId:'A',trashed:true,cursor:'next/+'})
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url.searchParams.get('search')).toBe('สรุป & notes')
+    expect(calls[0].url.searchParams.get('trashed')).toBe('true')
+    expect(calls[0].url.searchParams.get('cursor')).toBe('next/+')
+    expect(await (await api.readLibraryFile('item 1')).text()).toBe('hello')
+    expect(calls[1].url.pathname).toBe('/api/library/item%201/content')
+    await expect(api.setLibraryTrashed('item 1',true)).rejects.toThrow('Storage unavailable')
+    expect(calls[2].method).toBe('POST')
+    expect(calls[2].url.pathname).toBe('/api/library/item%201/trash')
+    await expect(api.removeLibraryItem('item 1')).rejects.toThrow('Storage unavailable')
+    expect(calls[3].method).toBe('DELETE')
+    expect(calls[3].url.pathname).toBe('/api/library/item%201')
+  })
+})

package/src/renderer/shared/library/transport.ts

@@ -0,0 +1,60 @@
+import type { LibraryItem, LibraryPage, LibraryQuery } from '../types';
+interface Environment {
+  isNative(): boolean;
+  apiBase(): string;
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export function createLibraryTransport(environment: Environment) {
+  const request = async (path: string, init?: RequestInit) => {
+    const response = await environment.fetch(`${environment.apiBase()}/library${path}`, init);
+    if (!response.ok) {
+      const data = await response.json().catch(() => null);
+      throw new Error(data?.message || `Library unavailable (${response.status})`);
+    }
+    return response;
+  };
+  return {
+    async removeLibraryItem(id: string): Promise<void> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('remove_library_item', { id });
+        return;
+      }
+      await request(`/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    },
+    async listLibrary(query: LibraryQuery): Promise<LibraryPage> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        return invoke('list_library', { query });
+      }
+      const params = new URLSearchParams();
+      Object.entries(query).forEach(([key, value]) => { if (value !== undefined && value !== null && value !== '')
+        params.set(key, String(value)); });
+      return (await request(`?${params}`)).json();
+    },
+    async getLibraryItem(id: string): Promise<LibraryItem> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        return invoke('get_library_item', { id });
+      }
+      return (await request(`/${encodeURIComponent(id)}`)).json();
+    },
+    async setLibraryTrashed(id: string, trashed: boolean): Promise<void> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        await invoke('set_library_trashed', { id, trashed });
+        return;
+      }
+      await request(`/${encodeURIComponent(id)}/${trashed ? 'trash' : 'restore'}`, { method: 'POST' });
+    },
+    async readLibraryFile(id: string, thumbnail = false): Promise<Blob> {
+      if (environment.isNative()) {
+        const { invoke } = await import('@tauri-apps/api/core');
+        const uri = await invoke<string>('read_library_file', { id, thumbnail });
+        // Use a local data URI; remote fetch always passes through the authenticated adapter.
+        return (await fetch(uri)).blob();
+      }
+      return (await request(`/${encodeURIComponent(id)}/${thumbnail ? 'thumbnail' : 'content'}`)).blob();
+    },
+  };
+}

package/src/renderer/shared/library/useLibraryFile.ts

@@ -0,0 +1,38 @@
+import { useEffect, useState } from 'react';
+import { libraryPlatform } from '../platform';
+/** Own each object URL for exactly one mounted consumer, including late responses. */
+export function useLibraryFile(id: string | null, thumbnail = false, revision = 0) {
+  const [state, setState] = useState<{
+    url: string;
+    blob: Blob | null;
+    error: string;
+  }>({ url: '', blob: null, error: '' });
+  useEffect(() => {
+    let active = true;
+    let url = '';
+    setState({ url: '', blob: null, error: '' });
+    if (id)
+      libraryPlatform.readLibraryFile(id, thumbnail).then(blob => {
+        if (!active)
+          return;
+        url = URL.createObjectURL(blob);
+        setState({ url, blob, error: '' });
+      }).catch(error => { if (active)
+        setState({ url: '', blob: null, error: String(error) }); });
+    return () => { active = false; if (url)
+      URL.revokeObjectURL(url); };
+  }, [id, thumbnail, revision]);
+  return state;
+}
+export async function downloadLibraryFile(id: string, name: string) {
+  const blob = await libraryPlatform.readLibraryFile(id);
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = name;
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+  // Allow the browser to start consuming the download before releasing its URL.
+  setTimeout(() => URL.revokeObjectURL(url), 1000);
+}

package/src/renderer/shared/mods.ts

@@ -0,0 +1,58 @@
+export interface ModNode {
+  color?: 'default' | 'yellow' | 'cyan' | 'blue' | 'magenta' | 'red'
+  direction?: 'row' | 'column'
+  type: 'text' | 'stack' | 'button' | 'input' | 'table' | 'badge' | 'progress'
+  text?: string
+  label?: string
+  action?: string
+  value?: string | number
+  max?: number
+  children?: ModNode[]
+  columns?: string[]
+  rows?: (string | number | null)[][]
+}
+export interface ModTestReport { passed: number; failed: number; tests: { file: string; name: string; passed: boolean; error?: string | null }[] }
+
+export interface ModRecord {
+  id: string
+  name: string
+  hash?: string
+  activeHash?: string
+  instanceId?: string
+  enabled: boolean
+  changed?: boolean
+  error?: string | null
+  reloadError?: string | null
+  sourceError?: string
+  source?: string
+  readme?: string
+  manifest?: { id: string; name: string; version: string; sdkVersion: number; entry: string; permissions: string[] }
+  revisions: string[]
+  snapshot?: { ui: { above_composer?: ModNode; side_panel?: ModNode }; commands: { name: string; description: string }[]; logs: string[] }
+}
+export interface ModOperation {
+  workspacePath: string
+  chatId: string
+  action: 'list' | 'enable' | 'disable' | 'action' | 'command' | 'validate' | 'rollback' | 'export' | 'import' | 'close' | 'run_request' | 'inspect_package' | 'hot_reload' | 'viewport' | 'usage' | 'test'
+  id?: string
+  scope?: 'chat' | 'workspace' | 'global'
+  grantPermissions?: boolean
+  expectedHash?: string
+  hash?: string
+  instanceId?: string
+  command?: string
+  value?: string | boolean
+  viewport?: ModViewport
+  package?: string
+}
+export interface ModResponse {
+  session?: { hotReload: boolean; viewport: ModViewport }
+  testReport?: ModTestReport
+  id?: string
+  expectedHash?: string | null
+  mods?: ModRecord[]
+  toolRequests?: { id: string; modId: string; action: string; input: unknown }[]
+  package?: string
+  filename?: string
+}
+export interface ModViewport { surface: 'terminal' | 'desktop' | 'web' | null; columns?: number | null; rows?: number | null; widthPx?: number | null; heightPx?: number | null; sidePanelOpen?: boolean }

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

@@ -1,8 +1,30 @@
-import { describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import { authPlatform, installRendererPlatform, installWorkspacePlatform, workspacePlatform, type WorkspacePlatform } from './platform'
 import * as desktopAdapter from '../src/tauri'
 import * as webAdapter from '../src-web/tauri'
 
+afterEach(() => vi.unstubAllGlobals())
+
+describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as const)('%s skill inventory', (_name, adapter) => {
+  it('forwards the selected workspace and returns skill location metadata', async () => {
+    vi.stubGlobal('window', {
+      location: { hostname: 'localhost', port: '9000', protocol: 'http:' },
+      localStorage: { getItem: () => null },
+    })
+    let requestUrl: URL | undefined
+    const skills = [{ id: 0, name: 'example', sourcePath: '/selected project/skills/example.md',
+      content: 'selected workspace', updatedAt: '', createdAt: '', location: 'workspace',
+      description: null, is_workspace: true }]
+    vi.stubGlobal('fetch', async (input: string) => {
+      requestUrl = new URL(input, 'http://localhost:9000')
+      return new Response(JSON.stringify(skills), { headers: { 'Content-Type': 'application/json' } })
+    })
+    await expect(adapter.listLearnedSkills('/selected project')).resolves.toEqual(skills)
+    expect(requestUrl?.pathname).toBe('/api/learned-skills')
+    expect(requestUrl?.searchParams.get('workspacePath')).toBe('/selected project')
+  })
+})
+
 describe('renderer platform interfaces', () => {
   it('accepts both complete runtime adapters', () => {
     expect(() => installRendererPlatform(desktopAdapter)).not.toThrow()
@@ -26,9 +48,43 @@ describe('renderer platform interfaces', () => {
       getWorkspaceSnapshot: vi.fn(), getWorkspaceGitDiff: vi.fn(), getGitBranchInfo: vi.fn(), switchGitBranch: vi.fn(),
       createGitBranch: vi.fn(), checkoutRemoteGitBranch: vi.fn(), getGitGraph: vi.fn(),
       createWorkspaceFile, createWorkspaceFolder: vi.fn(), deleteWorkspaceItem: vi.fn(),
+      moveWorkspaceItem: vi.fn(), listWorkspaceHistory: vi.fn(), undoWorkspaceAction: vi.fn(),
     } satisfies WorkspacePlatform
     installWorkspacePlatform(adapter)
     await expect(workspacePlatform.createWorkspaceFile(operation)).resolves.toEqual(snapshot)
     expect(createWorkspaceFile).toHaveBeenCalledWith(operation)
   })
 })
+
+it('routes background terminal controls through both platform adapters', async () => {
+  const { backgroundPlatform } = await import('./platform')
+  for (const adapter of [desktopAdapter, webAdapter]) {
+    expect(adapter.listBackgroundJobs).toBeTypeOf('function')
+    expect(adapter.getBackgroundJob).toBeTypeOf('function')
+    expect(adapter.stopBackgroundJob).toBeTypeOf('function')
+  }
+  const job = { id: 'bg-backend-1', status: 'running' }
+  const listBackgroundJobs = vi.fn(async () => [job])
+  const getBackgroundJob = vi.fn(async () => ({ ...job, stdout: 'hello', stderr: '' }))
+  const stopBackgroundJob = vi.fn(async () => ({ ...job, status: 'stopping' }))
+  installRendererPlatform(new Proxy({ listBackgroundJobs, getBackgroundJob, stopBackgroundJob }, { get: (target, name) => target[name as keyof typeof target] || vi.fn() }) as any)
+  await expect(backgroundPlatform.list('/Demo')).resolves.toEqual([job])
+  await expect(backgroundPlatform.output(job.id)).resolves.toMatchObject({ stdout: 'hello' })
+  await expect(backgroundPlatform.stop(job.id)).resolves.toMatchObject({ status: 'stopping' })
+  expect(listBackgroundJobs).toHaveBeenCalledWith('/Demo')
+  expect(getBackgroundJob).toHaveBeenCalledWith(job.id)
+  expect(stopBackgroundJob).toHaveBeenCalledWith(job.id)
+})
+
+describe.each([['Desktop fallback', desktopAdapter], ['Web', webAdapter]] as const)('%s workspace mods', (_name, adapter) => {
+  it('forwards explicit workspace, chat, instance and action identity', async () => {
+    vi.stubGlobal('window', { location: { hostname: 'localhost', port: '9000', protocol: 'http:' }, localStorage: { getItem: () => null } })
+    let body: unknown
+    vi.stubGlobal('fetch', async (_url: unknown, init: RequestInit) => {
+      body = JSON.parse(String(init.body))
+      return new Response(JSON.stringify({ mods: [] }), { headers: { 'Content-Type': 'application/json' } })
+    })
+    await adapter.modsOperation({ workspacePath: '/project', chatId: 'chat-a', action: 'action', id: 'checklist', instanceId: 'revision-instance', command: 'add', value: 'Test' })
+    expect(body).toEqual({ workspacePath: '/project', chatId: 'chat-a', action: 'action', id: 'checklist', instanceId: 'revision-instance', command: 'add', value: 'Test' })
+  })
+})

package/src/renderer/shared/platform.ts

@@ -51,6 +51,7 @@ export type SlashEffect =
   | { kind: 'config_changed' }
   | { kind: 'provider_changed'; display: string }
   | { kind: 'workspace_changed'; path: string }
+  | { kind: 'workspace_files_changed' }
   | { kind: 'history_cleared' }
   | { kind: 'fast_mode_changed'; enabled: boolean }
   | { kind: 'multi_agent_changed'; enabled: boolean }
@@ -66,8 +67,14 @@ export type SlashResponse =
   | { kind: 'not_handled' }
 
 export interface MintPlatformApi {
+  modsOperation(operation: import("./mods").ModOperation): Promise<import("./mods").ModResponse>
+  readMcpArtifact(id: string): Promise<string>
+  listBackgroundJobs(workspace?: string): Promise<import("./types").BackgroundJob[]>
+  getBackgroundJob(id: string): Promise<import("./types").BackgroundJobOutput>
+  stopBackgroundJob(id: string): Promise<import("./types").BackgroundJob>
+  deleteBackgroundJob(id: string): Promise<void>
   authRegister(name: string | undefined, email: string, password: string): Promise<AuthUser>
-  runSlashCommand(input: string, cwd?: string | null): Promise<SlashResponse>
+  runSlashCommand(input: string, cwd?: string | null, chatId?: string | null): Promise<SlashResponse>
   authLogin(email: string, password: string): Promise<AuthUser>
   authLogout(): Promise<void>
   authGetCurrentUser(): Promise<AuthUser | null>
@@ -84,6 +91,8 @@ export interface MintPlatformApi {
     workspacePath?: string | null,
     chatId?: string | null,
     agentId?: string | null,
+    planMode?: boolean,
+    attachmentMetadata?: import('./types').AttachmentMetadata,
   ): Promise<ChatResponse>
   streamChatMessage(
     message: string,
@@ -101,11 +110,14 @@ export interface MintPlatformApi {
     pinnedMcpServer?: string | null,
     onApprovalRequested?: (payload: { token: string; approval: any }) => void,
     onTurnStarted?: (interactionId: number) => void,
+    attachmentMetadata?: import('./types').AttachmentMetadata,
   ): Promise<ChatResponse>
   getTtsUrls(text: string): Promise<TtsUrl[]>
   cancelChatMessage(chatId: string): Promise<void>
   getRecentInteractions(limit?: number, chatId?: string | null, workspacePath?: string | null): Promise<InteractionMemory[]>
   getConversationSnapshot(chatId: string, beforeId?: number | null, limit?: number): Promise<ConversationSnapshot>
+  getConversationSources(chatId: string): Promise<import('./types').ConversationSources>
+  saveSourceAttachments(chatId: string, interactionId: number, attachments: import('./types').SourceAttachment[]): Promise<void>
   getConversationChanges(chatId: string, after: number, limit?: number): Promise<ConversationChanges>
   saveSystemInteraction(
     chatId: string,
@@ -129,6 +141,11 @@ export interface MintPlatformApi {
   saveSubagent(draft: SubagentDraft, workspacePath?: string): Promise<SubagentDefinition>
   deleteSubagent(sourcePath: string): Promise<void>
   clearChatHistory(chatId?: string | null): Promise<number>
+  listLibrary(query: import('./types').LibraryQuery): Promise<import('./types').LibraryPage>
+  getLibraryItem(id: string): Promise<import('./types').LibraryItem>
+  removeLibraryItem(id: string): Promise<void>
+  setLibraryTrashed(id: string, trashed: boolean): Promise<void>
+  readLibraryFile(id: string, thumbnail?: boolean): Promise<Blob>
   listSavedPictures(): Promise<PictureEntry[]>
   deleteSavedPicture(id: string): Promise<void>
   generateImages(req: ImageGenRequest): Promise<ImageGenResponse>
@@ -144,6 +161,10 @@ export interface MintPlatformApi {
   createWorkspaceFile(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
   createWorkspaceFolder(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
   deleteWorkspaceItem(operation: WorkspaceOperation): Promise<import('./types').WorkspaceSnapshot>
+  moveWorkspaceItem(operation: WorkspaceOperation, destination: string): Promise<import('./types').WorkspaceSnapshot>
+  startHtmlPreview(root: string, relativePath: string, mintBrowser?: boolean): Promise<{ url: string; jobId: string }>
+  listWorkspaceHistory(root: string): Promise<import('./types').WorkspaceHistoryEntry[]>
+  undoWorkspaceAction(root: string, revision: number, expectedId?: string): Promise<import('./types').WorkspaceSnapshot>
   selectWorkspaceDirectory(): Promise<string | null>
   selectLinkedFolderPath(): Promise<string | null>
   submitToolApproval(token: string, approved: boolean, answer?: string): Promise<void>
@@ -174,6 +195,10 @@ export type WorkspacePlatform = Pick<
   | 'createWorkspaceFile'
   | 'createWorkspaceFolder'
   | 'deleteWorkspaceItem'
+  | 'moveWorkspaceItem'
+  | 'startHtmlPreview'
+  | 'listWorkspaceHistory'
+  | 'undoWorkspaceAction'
 >
 
 let workspaceAdapter: WorkspacePlatform | undefined
@@ -238,6 +263,7 @@ 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'),
   renameChatSession: operation('renameChatSession'), getRecentInteractions: operation('getRecentInteractions'),
   getConversationSnapshot: operation('getConversationSnapshot'), getConversationChanges: operation('getConversationChanges'),
@@ -271,6 +297,7 @@ export const catalogPlatform = {
 
 /** Image and video generation and saved media seam. */
 export const mediaPlatform = {
+  readMcpArtifact: operation('readMcpArtifact'),
   generateImages: operation('generateImages'), getImageGenProviders: operation('getImageGenProviders'),
   fetchImageProviderModels: operation('fetchImageProviderModels'), listSavedPictures: operation('listSavedPictures'),
   generateVideo: operation('generateVideo'), getVideoGenProviders: operation('getVideoGenProviders'),
@@ -278,6 +305,13 @@ export const mediaPlatform = {
 }
 
 /** Runtime capabilities and native picker seam. */
+export const backgroundPlatform = {
+  list: operation("listBackgroundJobs"),
+  output: operation("getBackgroundJob"),
+  stop: operation("stopBackgroundJob"),
+  delete: operation("deleteBackgroundJob"),
+}
+
 export const runtimePlatform = {
   appIconPath: () => String(requireRendererPlatform().APP_ICON_PATH ?? './assets/icon.png'),
   getRuntimeStatus: operation('getRuntimeStatus'), setActiveModel: operation('setActiveModel'),
@@ -309,4 +343,15 @@ export const workspacePlatform: WorkspacePlatform = {
   createWorkspaceFile: (...args) => requireWorkspacePlatform().createWorkspaceFile(...args),
   createWorkspaceFolder: (...args) => requireWorkspacePlatform().createWorkspaceFolder(...args),
   deleteWorkspaceItem: (...args) => requireWorkspacePlatform().deleteWorkspaceItem(...args),
+  moveWorkspaceItem: (...args) => requireWorkspacePlatform().moveWorkspaceItem(...args),
+  startHtmlPreview: (...args) => requireWorkspacePlatform().startHtmlPreview(...args),
+  listWorkspaceHistory: (...args) => requireWorkspacePlatform().listWorkspaceHistory(...args),
+  undoWorkspaceAction: (...args) => requireWorkspacePlatform().undoWorkspaceAction(...args),
+}
+
+export const modsPlatform = { operation: operation("modsOperation") }
+
+export const libraryPlatform: Pick<MintPlatformApi, 'listLibrary' | 'getLibraryItem' | 'setLibraryTrashed' | 'removeLibraryItem' | 'readLibraryFile'> = {
+ listLibrary: operation('listLibrary'), getLibraryItem: operation('getLibraryItem'),
+ removeLibraryItem: operation('removeLibraryItem'), setLibraryTrashed: operation('setLibraryTrashed'), readLibraryFile: operation('readLibraryFile'),
 }

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

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { applyTheme } from './themeManager'
+
+describe('theme surface settings', () => {
+  let attributes: Map<string, string>
+  let properties: Map<string, string>
+
+  beforeEach(() => {
+    attributes = new Map()
+    properties = new Map()
+    // The Node test environment supplies only the DOM boundary used by applyTheme.
+    vi.stubGlobal('document', {
+      documentElement: {
+        setAttribute: (name: string, value: string) => attributes.set(name, value),
+        style: {
+          setProperty: (name: string, value: string) => properties.set(name, value),
+          removeProperty: (name: string) => properties.delete(name),
+        },
+      },
+      body: { style: {} },
+    })
+  })
+
+  afterEach(() => vi.unstubAllGlobals())
+
+  it.each([undefined, 'glass', 'opaque'])('uses opaque surfaces when blur is disabled and surfaceStyle is %s', (surfaceStyle) => {
+    applyTheme({ theme: 'dark', surfaceStyle, glassBlur: 'none' })
+    expect(attributes.get('data-surface')).toBe('opaque')
+    expect(properties.get('--glass-blur')).toBe('none')
+  })
+
+  it('preserves enabled glass surfaces and the selected blur', () => {
+    applyTheme({ theme: 'dark', surfaceStyle: 'glass', glassBlur: 'blur(24px)' })
+    expect(attributes.get('data-surface')).toBe('glass')
+    expect(properties.get('--glass-blur')).toBe('blur(24px)')
+  })
+
+  it('keeps explicit opaque surfaces solid despite a saved blur value', () => {
+    applyTheme({ theme: 'light', surfaceStyle: 'opaque', glassBlur: 'blur(16px)' })
+    expect(attributes.get('data-surface')).toBe('opaque')
+    expect(properties.get('--glass-blur')).toBe('none')
+  })
+})