@pheem49/mint 1.15.0 → 1.16.0

package/src/renderer/shared/utils/mcpResults.test.tsx

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest'
+import React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import McpToolResults from '../components/McpToolResults'
+import { reduceLiveAgentProgress, compactAgentProgressForPersistence } from '../agentProgress'
+
+describe('MCP progress retention', () => {
+  it('keeps artifacts visible after later tools and folds progress by call', () => {
+    let events: any[] = [{ type: 'ToolArtifacts', data: { callId: 'a', artifacts: [{ id: 'image' }], warnings: [] } }]
+    for (let i = 0; i < 30; i++) events = reduceLiveAgentProgress(events, { type: 'Thought', data: { thought: 'working' } })
+    for (let i = 0; i < 30; i++) events = reduceLiveAgentProgress(events, { type: 'ToolEnd', data: { action: 'read_file', input: {}, result: 'ok' } })
+    for (let i = 1; i < 4; i++) events = reduceLiveAgentProgress(events, { type: 'ToolProgress', data: { callId: 'a', server: 's', tool: 't', update: { progress: i, total: 4, elapsedSecs: i } } } as any)
+    expect(events.filter(e => e.type === 'ToolArtifacts')).toHaveLength(1)
+    expect(events.filter(e => e.type === 'ToolProgress')).toHaveLength(1)
+    expect((events.find(e => e.type === 'ToolProgress') as any).data.update.progress).toBe(3)
+  })
+  it('persists only the last progress per call without losing attachments', () => {
+    const events: any[] = [1, 2].map(progress => ({ type: 'ToolProgress', data: { callId: 'a', server: 's', tool: 't', update: { progress } } }))
+    events.push({ type: 'ToolArtifacts', data: { callId: 'a', artifacts: [], warnings: ['file unavailable'] } })
+    const persisted = compactAgentProgressForPersistence(events)
+    expect(persisted.filter(e => e.type === 'ToolProgress')).toHaveLength(1)
+    expect(persisted.filter(e => e.type === 'ToolArtifacts')).toHaveLength(1)
+  })
+})
+
+describe('MCP result display', () => {
+  it('shows blocked legacy calls as failed instead of completed', () => {
+    const html = renderToStaticMarkup(<McpToolResults progress={[{ type: 'ToolEnd', data: { callId: 'blocked', action: 'mcp_tool', input: {server: 's', tool: 'render'}, result: 'Blocked by hook: denied' } }]} />)
+    expect(html).toContain('Failed')
+    expect(html).not.toContain('Completed')
+  })
+  it('shows attachments and terminal status without an assistant summary', () => {
+    const progress: any[] = [
+      { type: 'ToolStart', data: { callId: 'a', action: 'mcp_tool', input: { server: 'blender', tool: 'render' } } },
+      { type: 'ToolArtifacts', data: { callId: 'a', artifacts: [{ id: 'link', kind: 'link', name: 'model.obj', uri: 'https://example.test/model.obj' }], warnings: [] } },
+      { type: 'ToolEnd', data: { callId: 'a', action: 'mcp_tool', input: { server: 'blender', tool: 'render' }, status: 'timed_out', result: 'unconfirmed' } },
+    ]
+    const html = renderToStaticMarkup(<McpToolResults progress={progress} />)
+    expect(html).toContain('model.obj')
+    expect(html).toContain('href="https://example.test/model.obj"')
+    expect(html).toContain('remote completion is unconfirmed')
+    expect(html).not.toContain('Completed')
+  })
+  it('does not turn custom or executable resource URIs into browser links', () => {
+    const progress: any[] = [{ type: 'ToolArtifacts', data: { callId: 'a', warnings: [], artifacts: [{ id: 'x', kind: 'link', name: 'resource', uri: 'javascript:alert(1)' }] } }]
+    const html = renderToStaticMarkup(<McpToolResults progress={progress} />)
+    expect(html).toContain('resource')
+    expect(html).not.toContain('href=')
+  })
+  it('shows real progress only for an active call', () => {
+    const progress: any[] = [{ type: 'ToolProgress', data: { callId: 'a', server: 's', tool: 'render', update: { progress: 25, total: 100, message: 'Rendering', elapsedSecs: 3 } } }]
+    expect(renderToStaticMarkup(<McpToolResults progress={progress} running />)).toContain('value="25"')
+    progress.push({ type: 'ToolEnd', data: { callId: 'a', action: 'mcp_tool', input: {}, result: 'stopped', status: 'cancelled' } })
+    const html = renderToStaticMarkup(<McpToolResults progress={progress} />)
+    expect(html).toContain('remote work may still be running')
+    expect(html).not.toContain('<progress')
+  })
+})
+
+describe('Device verification display', () => {
+  const event = (state: string, seq = 1): any => ({type:'DeviceState', data:{callId:'motor',server:'device',tool:'set_speed',update:{state,deviceId:'motor',operationId:'op',target:{rpm:100},actual:{rpm:state==='verified'?100:0},observationSeq:seq,elapsedSecs:2,message:'Observed device state'}}})
+  it('distinguishes receipt, running, and verified completion', () => {
+    expect(renderToStaticMarkup(<McpToolResults progress={[event('accepted')]} running />)).toContain('Command accepted')
+    expect(renderToStaticMarkup(<McpToolResults progress={[event('running')]} running />)).toContain('Awaiting device completion')
+    const html=renderToStaticMarkup(<McpToolResults progress={[event('verified',3)]} />)
+    expect(html).toContain('Device completion verified')
+    expect(html).toContain('rpm')
+    expect(html).toContain('100')
+  })
+  it('retains acceptance and the latest observation in saved history', () => {
+    let events: any[]=[]
+    for(const state of ['accepted','running','running','verified']) events=reduceLiveAgentProgress(events,event(state))
+    for(let i=0;i<40;i++) events=reduceLiveAgentProgress(events,{type:'ToolEnd',data:{action:'read_file',input:{},result:'ok'}})
+    const states=compactAgentProgressForPersistence(events).filter(e=>e.type==='DeviceState')
+    expect(states).toHaveLength(2)
+    expect((states[0] as any).data.update.state).toBe('accepted')
+    expect((states[1] as any).data.update.state).toBe('verified')
+  })
+  it('shows discovery without claiming execution', () => {
+    const html=renderToStaticMarkup(<McpToolResults progress={[{type:'ToolDiscovery',data:{server:'device',tool:'move',message:'Reading definition'}} as any]} />)
+    expect(html).toContain('Reading definition')
+    expect(html).not.toContain('Completed')
+  })
+})
+
+it('shows stopped waiting when interrupted during a device operation', () => {
+  const progress: any[]=[{type:'DeviceState',data:{callId:'a',server:'device',tool:'move',update:{state:'running',deviceId:'motor',operationId:'op',target:{position:10},actual:{position:3},observationSeq:2,elapsedSecs:1,message:'Moving'}}}]
+  const html=renderToStaticMarkup(<McpToolResults progress={progress} interrupted />)
+  expect(html).toContain('Stopped waiting')
+  expect(html).not.toContain('Awaiting device completion')
+})

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

@@ -0,0 +1,7 @@
+import type { ModViewport } from '../mods'
+export function modViewport(width: number, height: number, surface: 'web' | 'desktop', open: boolean): ModViewport | null {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 24 || height < 1) return null
+  const widthPx = Math.min(100000, Math.floor(width - 24))
+  const heightPx = Math.min(100000, Math.floor(height))
+  return { surface, widthPx, heightPx, columns: Math.min(10000, Math.max(1, Math.floor(widthPx / 8))), rows: Math.min(10000, Math.max(1, Math.floor(heightPx / 20))), sidePanelOpen: open }
+}

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+
+import { createNativeRecordingSession as create } from './nativeRecordingSession'
+
+function deferred() {
+  let resolve!: () => void
+  const promise = new Promise<void>(done => { resolve = done })
+  return { promise, resolve }
+}
+
+describe('native microphone recording lifecycle', () => {
+  it('discards a canceled recording even when device startup finishes later', async () => {
+    const ready = deferred(); const calls: string[] = []
+    const session = create({
+      startRecording: async () => { calls.push('start'); await ready.promise },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'should not send' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    const start = session.start()
+    const cancel = session.cancel()
+    ready.resolve()
+    expect(await start).toBe(false)
+    await cancel
+    expect(calls).toEqual(['start', 'discard'])
+  })
+  it('waits for startup before stopping, transcribes once, and permits another recording', async () => {
+    const ready = deferred(); const calls: string[] = []
+    const session = create({
+      startRecording: async () => { calls.push('start'); await ready.promise },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'Hello Mint' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    const start = session.start(); const stop = session.stop(); const duplicate = session.stop()
+    ready.resolve(); await start
+    expect(await stop).toBe('Hello Mint'); expect(await duplicate).toBe('Hello Mint')
+    expect(calls).toEqual(['start', 'transcribe'])
+    expect(await session.start()).toBe(true); await session.cancel()
+    expect(calls).toEqual(['start', 'transcribe', 'start', 'discard'])
+  })
+  it('does not transcribe or discard when opening the microphone is denied', async () => {
+    const calls: string[] = []
+    const session = create({
+      startRecording: async () => { throw new Error('Microphone denied') },
+      stopRecordingAndTranscribe: async () => { calls.push('transcribe'); return 'wrong' },
+      cancelRecording: async () => { calls.push('discard') }
+    })
+    await expect(session.start()).rejects.toThrow('Microphone denied')
+    await session.cancel(); expect(calls).toEqual([])
+  })
+  it('suppresses a transcript when canceled during transcription', async () => {
+    const ready = deferred()
+    const session = create({
+      startRecording: async () => {},
+      stopRecordingAndTranscribe: async () => { await ready.promise; return 'late transcript' },
+      cancelRecording: async () => { throw new Error('already stopped') }
+    })
+    await session.start(); const stop = session.stop(); await Promise.resolve()
+    const cancel = session.cancel(); ready.resolve()
+    expect(await stop).toBeNull(); await cancel
+  })
+})

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

@@ -0,0 +1,46 @@
+export interface NativeRecordingBackend {
+  startRecording: () => Promise<void>
+  stopRecordingAndTranscribe: () => Promise<string>
+  cancelRecording: () => Promise<void>
+}
+
+/** One recorder lifecycle, including stop/cancel requests made during device startup. */
+export function createNativeRecordingSession(backend: NativeRecordingBackend) {
+  type Run = { phase: 'starting' | 'recording' | 'ending'; cancelled: boolean; ready: Promise<void>; result?: Promise<string | null> }
+  let run: Run | null = null
+
+  const start = async () => {
+    if (run) return false
+    const current: Run = { phase: 'starting', cancelled: false, ready: Promise.resolve() }
+    run = current
+    current.ready = backend.startRecording()
+    try {
+      await current.ready
+      if (current.phase !== 'starting') return false
+      current.phase = 'recording'
+      return true
+    } catch (error) {
+      if (run === current) run = null
+      throw error
+    }
+  }
+  const finish = (cancelled: boolean): Promise<string | null> => {
+    const current = run
+    if (!current) return Promise.resolve(null)
+    current.cancelled ||= cancelled
+    if (current.result) return current.result
+    current.phase = 'ending'
+    current.result = (async () => {
+      try {
+        try { await current.ready } catch { return null }
+        if (current.cancelled) { await backend.cancelRecording(); return null }
+        const text = await backend.stopRecordingAndTranscribe()
+        return current.cancelled ? null : text
+      } finally {
+        if (run === current) run = null
+      }
+    })()
+    return current.result
+  }
+  return { start, stop: () => finish(false), cancel: async () => { await finish(true) } }
+}

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

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest'
+import { shouldNotify } from './notificationSettings'
+
+it('preserves existing notifications when settings have not been saved yet', () => {
+  expect(shouldNotify(null, 'replies', 'os')).toBe(true)
+})
+it('applies master, category, and delivery switches independently', () => {
+  expect(shouldNotify({ enabled: false }, 'approvals', 'inApp')).toBe(false)
+  expect(shouldNotify({ replies: false }, 'replies', 'os')).toBe(false)
+  expect(shouldNotify({ replies: false }, 'approvals', 'os')).toBe(true)
+  expect(shouldNotify({ os: false }, 'system', 'os')).toBe(false)
+  expect(shouldNotify({ os: false }, 'system', 'inApp')).toBe(true)
+  expect(shouldNotify({ inApp: false }, 'system', 'inApp')).toBe(false)
+})

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

@@ -0,0 +1,23 @@
+export const DEFAULT_NOTIFICATION_SETTINGS = {
+  enabled: true, replies: true, approvals: true, system: true, os: true, inApp: true,
+}
+export type NotificationSettings = typeof DEFAULT_NOTIFICATION_SETTINGS
+export function readNotificationSettings(settings: unknown): NotificationSettings {
+  const data = settings && typeof settings === 'object' ? settings as Record<string, unknown> : {}
+  return Object.fromEntries(Object.entries(DEFAULT_NOTIFICATION_SETTINGS).map(([key, fallback]) =>
+    [key, typeof data[key] === 'boolean' ? data[key] : fallback])) as NotificationSettings
+}
+export function shouldNotify(settings: unknown, kind: 'replies' | 'approvals' | 'system', channel: 'os' | 'inApp'): boolean {
+  const preferences = readNotificationSettings(settings)
+  return preferences.enabled && preferences[kind] && preferences[channel]
+}
+
+export async function notificationPermission(request = false): Promise<NotificationPermission | 'unsupported'> {
+  if ((window as any).__TAURI_INTERNALS__) {
+    const api = await import('@tauri-apps/plugin-notification')
+    if (await api.isPermissionGranted()) return 'granted'
+    return request ? api.requestPermission() : 'default'
+  }
+  if (typeof Notification === 'undefined') return 'unsupported'
+  return request ? Notification.requestPermission() : Notification.permission
+}

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

@@ -0,0 +1,51 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { sendBrowserNotification, clearBrowserNotifications, deliverNotification, receiveProactiveNotification } from './notifications'
+
+const shown: any[] = []
+class BrowserNotification {
+  static permission = 'granted'
+  close = vi.fn()
+  onclick?: () => void
+  onclose?: () => void
+  constructor(public title: string, public options: any) { shown.push(this) }
+}
+afterEach(() => { clearBrowserNotifications(); shown.length = 0; vi.unstubAllGlobals() })
+it('closes every outstanding notification when returning to Mint', async () => {
+  vi.stubGlobal('Notification', BrowserNotification)
+  await sendBrowserNotification('One')
+  await sendBrowserNotification('Two')
+  expect(shown).toHaveLength(2)
+  clearBrowserNotifications()
+  expect(shown.every(n => n.close.mock.calls.length === 1)).toBe(true)
+})
+it('opens the originating chat on click and dismisses that notification', async () => {
+  vi.stubGlobal('Notification', BrowserNotification)
+  const opened: string[] = []
+  await sendBrowserNotification('Done', 'chat-one', id => opened.push(id))
+  shown[0].onclick()
+  expect(opened).toEqual(['chat-one'])
+  expect(shown[0].close).toHaveBeenCalledOnce()
+})
+it('reports a rejected delivery without propagating it into the chat run', async () => {
+  const errors: string[] = []
+  await expect(deliverNotification(() => Promise.reject(new Error('No service')), message => errors.push(message))).resolves.toBeUndefined()
+  expect(errors).toEqual(['Could not send notification: No service'])
+})
+it('shows a background event in-app and sends its originating chat to the OS', async () => {
+  const notices: unknown[] = []
+  const deliveries: unknown[] = []
+  await receiveProactiveNotification({ message: 'Task completed', type: 'info', chatId: 'task-chat' }, true,
+    notice => notices.push(notice), async (body, chatId) => { deliveries.push({ body, chatId }) })
+  expect(notices).toEqual([{ message: 'Task completed', type: 'info', chatId: 'task-chat' }])
+  expect(deliveries).toEqual([{ body: 'Task completed', chatId: 'task-chat' }])
+})
+it('keeps foreground system events in-app and ignores malformed events', async () => {
+  const notices: unknown[] = []
+  const deliveries: unknown[] = []
+  const show = (notice: unknown) => { notices.push(notice) }
+  const send = async (body: string) => { deliveries.push(body) }
+  await receiveProactiveNotification({ message: 'Battery low', type: 'warning' }, false, show, send)
+  await receiveProactiveNotification({ message: '' }, true, show, send)
+  expect(notices).toEqual([{ message: 'Battery low', type: 'warning', chatId: undefined }])
+  expect(deliveries).toEqual([])
+})

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

@@ -0,0 +1,54 @@
+const active = new Set<Notification>()
+let generation = 0
+
+export async function sendBrowserNotification(body: string, chatId?: string, openChat?: (id: string) => void): Promise<void> {
+  if (typeof Notification === 'undefined') throw new Error('Notifications are not supported here.')
+  const started = generation
+  let permission = Notification.permission
+  if (permission === 'default') permission = await Notification.requestPermission()
+  if (permission !== 'granted') throw new Error('Notification permission is not granted.')
+  // Returning to Mint while a permission prompt was pending cancels this delivery.
+  if (started !== generation) return
+  const notification = new Notification('Mint Agent', { body })
+  active.add(notification)
+  notification.onclose = () => active.delete(notification)
+  notification.onclick = () => {
+    notification.close()
+    active.delete(notification)
+    if (chatId) openChat?.(chatId)
+    else if (typeof window !== 'undefined') window.focus()
+  }
+}
+
+export function clearBrowserNotifications(): void {
+  generation++
+  for (const notification of active) notification.close()
+  active.clear()
+}
+
+export async function deliverNotification(send: () => unknown, report: (message: string) => void): Promise<void> {
+  try { await send() }
+  catch (error) { report('Could not send notification: ' + (error instanceof Error ? error.message : String(error))) }
+}
+
+export function openNotificationChat(chatId: string): void {
+  window.focus()
+  window.dispatchEvent(new CustomEvent('mint:notification-click', { detail: { chatId } }))
+}
+
+export type NotificationNotice = { message: string; chatId?: string; type?: string }
+export async function receiveProactiveNotification(
+  payload: unknown, background: boolean, show: (notice: NotificationNotice) => void,
+  send: (body: string, chatId?: string) => Promise<void>,
+): Promise<void> {
+  if (!payload || typeof payload !== 'object') return
+  const data = payload as Record<string, unknown>
+  if (typeof data.message !== 'string' || !data.message.trim()) return
+  const notice = {
+    message: data.message,
+    chatId: typeof data.chatId === 'string' ? data.chatId : undefined,
+    type: typeof data.type === 'string' ? data.type : undefined,
+  }
+  show(notice)
+  if (background) await send(notice.message, notice.chatId)
+}

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

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { insertPastedText, pastedTextLabel } from './pastedText'
+
+describe('long clipboard text on Desktop and Web', () => {
+  it('collapses seven lines while retaining the complete submitted value', () => {
+    const result = insertPastedText('before selection after', 7, 16, 'a\rb\rc\rd\re\rf\rg')
+    expect(result.collapsed).toBe(true)
+    expect(result.value).toBe('before a\nb\nc\nd\ne\nf\ng after')
+    expect(result.text).toBe('a\nb\nc\nd\ne\nf\ng')
+    expect(result.caret).toBe(20)
+  })
+  it('keeps six lines inline and normalizes mixed clipboard line endings', () => {
+    const result = insertPastedText('', 0, 0, 'a\r\nb\rc\nd\ne\nf\r\n')
+    expect(result.collapsed).toBe(false)
+    expect(result.value).toBe('a\nb\nc\nd\ne\nf\n')
+  })
+  it('counts Unicode characters rather than UTF-16 units in the badge', () => {
+    expect(pastedTextLabel('🙂\na\nb\nc\nd\ne\nf')).toBe('[Pasted Content 13 chars]')
+  })
+})

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

@@ -0,0 +1,13 @@
+export function insertPastedText(value: string, start: number, end: number, text: string) {
+  const normalized = text.replace(/\r\n?/g, '\n')
+  return {
+    value: value.slice(0, start) + normalized + value.slice(end),
+    text: normalized,
+    caret: start + normalized.length,
+    collapsed: normalized.replace(/\n$/, '').split('\n').length > 6,
+  }
+}
+
+export function pastedTextLabel(text: string) {
+  return `[Pasted Content ${Array.from(text).length} chars]`
+}

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import { parseFileChangesFromProgress } from '../agentProgress'
+import { activitiesFrom } from './agentActivity'
+import type { AgentProgress } from '../types'
+
+describe('immutable progress summaries', () => {
+  it('reuses file summaries while a turn has no new events', () => {
+    const progress: AgentProgress[] = []
+    expect(parseFileChangesFromProgress(progress)).toBe(parseFileChangesFromProgress(progress))
+  })
+  it('reuses activity views across unrelated UI updates', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'read_file', input: { path: '/a.ts' } } }]
+    expect(activitiesFrom(progress)).toBe(activitiesFrom(progress))
+  })
+  it('adds a completed file edit without changing the cached earlier snapshot', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'write_file', input: { path: '/a.ts', content: 'first\nsecond' } } }]
+    const before = parseFileChangesFromProgress(progress)
+    const next: AgentProgress[] = [...progress, { type: 'ToolEnd', data: { action: 'write_file', input: {}, result: 'ok' } }]
+    expect(parseFileChangesFromProgress(next)).toEqual([{ path: '/a.ts', created: true, additions: 2, deletions: 0, hunks: [{ oldText: '', newText: 'first\nsecond' }] }])
+    expect(before).toEqual([])
+    expect(parseFileChangesFromProgress(progress)).toBe(before)
+  })
+  it('updates activity when a new progress snapshot arrives', () => {
+    const progress: AgentProgress[] = [{ type: 'ToolStart', data: { action: 'read_file', input: { path: '/a.ts' } } }]
+    const before = activitiesFrom(progress)
+    const next: AgentProgress[] = [...progress, { type: 'ToolEnd', data: { action: 'read_file', input: { path: '/a.ts' }, result: 'content' } }]
+    const after = activitiesFrom(next)
+    expect(after).not.toBe(before)
+    expect(before.items[0].state).not.toBe(after.items[0].state)
+    expect(activitiesFrom(progress)).toBe(before)
+  })
+})

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

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+import { collectSessionSources } from './sessionSources'
+import type { AgentProgress } from '../types'
+import { createElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import SessionSources from '../components/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', () => {
+  it('includes sent images and files alongside historical and live searches, deduplicating pages', () => {
+    const result = collectSessionSources({ attachments: [
+      { id: 1, interactionId: 3, name: 'photo.png', kind: 'image', mimeType: 'image/png', thumbnailDataUri: 'data:image/png;base64,aGVsbG8=' },
+      { id: 2, interactionId: 7, name: 'notes.pdf', kind: 'file', mimeType: 'application/pdf', thumbnailDataUri: null },
+    ], webSearchProgress: [search('https://example.com/docs')] }, [search('https://example.com/docs'), search('https://other.example/guide')])
+    expect(result.map(source => source.name)).toEqual(['photo.png', 'notes.pdf', 'Reference', 'Reference'])
+    expect(result[0]).toMatchObject({ kind: 'image', interactionId: 3, thumbnailDataUri: 'data:image/png;base64,aGVsbG8=' })
+    expect(result[1]).toMatchObject({ kind: 'file', detail: 'PDF' })
+    expect(result[2]).toMatchObject({ kind: 'web', url: 'https://example.com/docs', detail: 'example.com' })
+  })
+  it('does not turn non-web URLs or failed searches into source links', () => {
+    expect(collectSessionSources({ attachments: [], webSearchProgress: [search('javascript:alert(1)'), search('file:///etc/passwd')] })).toEqual([])
+    expect(collectSessionSources({ attachments: [], webSearchProgress: [search('https://example.com')] })).toHaveLength(1)
+  })
+  it('shows website favicons from the existing web-search source metadata', () => {
+    const sources = collectSessionSources({ attachments: [], webSearchProgress: [search('https://open.spotify.com/track/example?secret=private', 'Song')] })
+    expect(sources[0]).toMatchObject({ faviconUrl: 'https://www.google.com/s2/favicons?sz=32&domain=open.spotify.com' })
+    const html = renderToStaticMarkup(createElement(SessionSources, { sources, loading: false, error: '', onRetry: () => {}, onOpenLibrary: () => {} }))
+    expect(html).toContain('src="https://www.google.com/s2/favicons?sz=32&domain=open.spotify.com"')
+    expect(html).toContain('referrerPolicy="no-referrer"')
+  })
+})

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

@@ -0,0 +1,34 @@
+import type { AgentProgress, ConversationSources } from '../types'
+import { parseWebSearchSources } from './agentActivity'
+
+export interface SessionSource {
+  id: string
+  kind: 'image' | 'file' | 'video' | 'web'
+  name: string
+  detail: string
+  interactionId?: number
+  thumbnailDataUri?: string
+  faviconUrl?: string
+  url?: string
+}
+
+export function collectSessionSources(persisted: ConversationSources, liveProgress: AgentProgress[] = []): SessionSource[] {
+  const attachments: SessionSource[] = persisted.attachments.map(attachment => ({
+    id: `attachment:${attachment.id}`, kind: attachment.kind, name: attachment.name,
+    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,
+  }))
+  const seen = new Set<string>()
+  const web: SessionSource[] = []
+  const progress = [...persisted.webSearchProgress, ...liveProgress].filter(event => event.type !== 'ToolEnd' || !event.data.status || event.data.status === 'success')
+  for (const source of parseWebSearchSources(progress)) {
+    const url = new URL(source.url)
+    if (!['http:', 'https:'].includes(url.protocol)) continue
+    url.hash = ''
+    if (seen.has(url.href)) continue
+    seen.add(url.href)
+    web.push({ id: `web:${url.href}`, kind: 'web', name: source.title || source.domain, detail: source.domain, url: url.href, faviconUrl: source.faviconUrl })
+  }
+  return [...attachments, ...web]
+}

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

@@ -74,7 +74,7 @@ export function executeSlashCommand(input: string): SlashCommandExecutionResult
         handled: true,
         action: 'system_message',
         systemText:
-          '🧍 **Project Avatar** — the desktop app renders the live companion automatically. Use the CLI `/avatar link` to pair an external viewer.',
+          '🧍 **Project Avatar** — use the CLI `/avatar link` to pair a Project Avatar viewer. The separate Mint Companion app connects locally to Mint for Live2D.',
       }
 
     default:

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

@@ -0,0 +1,28 @@
+import type { SourceAttachment } from '../types'
+import type { PromptOptions } from '../conversation/lifecycle'
+
+async function thumbnail(dataUri: string): Promise<string | null> {
+  try {
+    const image = new Image()
+    image.src = dataUri
+    await image.decode()
+    const ratio = Math.min(1, 160 / Math.max(image.naturalWidth, image.naturalHeight))
+    const canvas = document.createElement('canvas')
+    canvas.width = Math.max(1, Math.round(image.naturalWidth * ratio))
+    canvas.height = Math.max(1, Math.round(image.naturalHeight * ratio))
+    const context = canvas.getContext('2d')
+    if (!context) return null
+    context.drawImage(image, 0, 0, canvas.width, canvas.height)
+    return canvas.toDataURL('image/webp', .75)
+  } catch { return null }
+}
+
+export async function sourceAttachments(options: PromptOptions): Promise<SourceAttachment[]> {
+  const mime = (uri: string) => /^data:([^;,]+)/.exec(uri)?.[1] || 'application/octet-stream'
+  const images = await Promise.all((options.imageAttachments || []).map(async image => ({
+    name: image.name, kind: 'image' as const, mimeType: mime(image.dataUri), thumbnailDataUri: await thumbnail(image.dataUri),
+  })))
+  const videos = (options.videoAttachments || []).map(video => ({ name: video.name, kind: 'video' as const, mimeType: mime(video.dataUri), thumbnailDataUri: null }))
+  const document = options.documentAttachment
+  return [...images, ...videos, ...(document ? [{ name: document.filename, kind: 'file' as const, mimeType: mime(document.dataUri), thumbnailDataUri: null }] : [])]
+}