@pheem49/mint 1.14.0 → 1.16.0

package/src/renderer/shared/types.ts

@@ -27,6 +27,7 @@ export interface ChatResponse {
   text: string
   thought?: string | null
   fallbackProvider?: string | null
+  fallbackReason?: string | null
 }
 
 export interface TtsUrl {
@@ -39,6 +40,15 @@ export interface DocumentAttachment {
   dataUri: string
 }
 
+export interface SourceAttachment {
+  name: string
+  kind: 'image' | 'file' | 'video'
+  mimeType: string
+  thumbnailDataUri: string | null
+}
+export interface SessionAttachment extends SourceAttachment { id: number; interactionId: number | null; libraryItemId?: string | null; availability?: string | null; trashed?: boolean }
+export interface ConversationSources { attachments: SessionAttachment[]; webSearchProgress: AgentProgress[] }
+
 export interface PlanTaskItem {
   id: string
   title: string
@@ -71,11 +81,24 @@ export interface RunTelemetrySummary {
   retriesCount: number
 }
 
+export type ToolStatus = 'success' | 'failed' | 'timed_out' | 'cancelled'
+export interface McpArtifact {
+  id: string; name: string; mimeType: string; kind: 'image' | 'file' | 'link'; size: number
+  chatId: string; callId: string; server: string; uri?: string
+}
+
 export type AgentProgress =
+  | { type: 'ToolDiscovery'; data: { server: string; tool: string; message: string } }
+  | { type: 'DeviceState'; data: { callId: string; server: string; tool: string; update: { state: 'accepted' | 'running' | 'verified' | 'failed' | 'unconfirmed'; deviceId?: string | null; operationId?: string | null; target: Record<string, unknown> | null; actual: Record<string, unknown> | null; observationSeq?: number | null; elapsedSecs: number; message: string } } }
+  | { type: 'ToolProgress'; data: { callId: string; server: string; tool: string; update: { progress: number; total?: number; message?: string; elapsedSecs: number } } }
+  | { type: 'ToolArtifacts'; data: { callId: string; artifacts: McpArtifact[]; warnings: string[] } }
   | { type: 'Thinking'; data: { elapsed_secs: number; agent_name?: string; model_name?: string } }
+  | { type: 'ContextCompaction'; data: { status: 'started' | 'completed' | 'failed'; message: string; subagent?: string } }
   | { type: 'Thought'; data: { thought: string } }
-  | { type: 'ToolStart'; data: { action: string; input: Record<string, unknown>; subagent?: string } }
-  | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string; subagent?: string } }
+  | { type: 'ThinkingDelta'; data: { id: string; delta: string; elapsed_ms: number } }
+  | { type: 'ExtendedThinking'; data: { id?: string; thought: string; elapsed_ms?: number } }
+  | { type: 'ToolStart'; data: { action: string; input: Record<string, unknown>; subagent?: string; callId?: string } }
+  | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string; subagent?: string; callId?: string; status?: ToolStatus } }
   | { type: 'PlanUpdated'; data: { plan: ActivePlan } }
   | { type: 'RunCompleted'; data: { summary: RunTelemetrySummary } }
 
@@ -88,17 +111,48 @@ export interface InteractionMemory {
   model: string
   fallbackProvider?: string | null
   createdAt: string
+  status: 'queued' | 'running' | 'completed' | 'failed' | 'interrupted'
   agentActivity?: AgentProgress[] | null
 }
 
+export interface ConversationSnapshot {
+  interactions: InteractionMemory[]
+  cursor: number
+  hasOlder: boolean
+}
+
+export interface ConversationChanges {
+  changes: { sequence: number; interactionId: number; interaction: InteractionMemory | null }[]
+  cursor: number
+  hasMore: boolean
+}
+
 export interface ChatSession {
   id: string
   title: string
   kind: string
   createdAt: string
   updatedAt: string
+  workspacePath?: string | null
+  gitBranch?: string | null
+  mainLanguage?: string | null
+  messageCount?: number
+  totalBytes?: number
 }
 
+export interface GitBranchInfo {
+  isRepository: boolean
+  currentBranch: string | null
+  detachedHead: string | null
+  branches: string[]
+  remoteBranches: string[]
+  isDirty: boolean
+}
+
+export type GitBranchChangeOutcome =
+  | { status: 'changed'; info: GitBranchInfo }
+  | { status: 'confirmation_required'; info: GitBranchInfo }
+
 export interface PictureEntry {
   id: string
   filename: string
@@ -112,6 +166,17 @@ export interface PictureEntry {
   thumbnailUrl?: string
 }
 
+export interface LibraryReference { chatId: string; interactionId: number | null }
+export interface LibraryItem {
+  id: string; name: string; filename: string; kind: 'image' | 'video' | 'file'; mimeType: string; size: number
+  createdAt: string; origin: 'uploaded' | 'generated' | 'legacy'; source: string; message: string
+  deletedAt: string | null; thumbnailStatus: 'pending' | 'ready' | 'unavailable'; availability: 'ready' | 'missing'
+  references: LibraryReference[]
+}
+export interface LibraryQuery { kind?: 'image' | 'video' | 'file'; search?: string; chatId?: string; trashed?: boolean; cursor?: string | null }
+export interface LibraryPage { items: LibraryItem[]; nextCursor: string | null }
+export interface AttachmentMetadata { requestId: string; imageNames: string[]; videoNames: string[] }
+
 export interface ImageGenRequest {
   prompt: string
   negativePrompt?: string
@@ -154,6 +219,35 @@ export interface WorkspaceTreeEntry {
   kind: 'file' | 'directory'
   children: WorkspaceTreeEntry[]
 }
+export interface WorkspaceSnapshot { path: string; tree: WorkspaceTreeEntry; git: GitBranchInfo; revision: number }
+export interface WorkspaceOperation { root: string; relativePath: string; revision: number }
+export interface WorkspaceHistoryEntry { id: string; label: string; path: string; kind: string; destination: string | null; expected: string | null; backup: string | null }
+
+export interface VideoGenRequest {
+  prompt: string
+  negativePrompt?: string
+  aspectRatio: '16:9' | '9:16' | '1:1'
+  duration: 5 | 8
+  model?: string
+  provider: string
+}
+
+export interface VideoGenEntry {
+  id: string
+  url: string
+  path: string
+  message?: string
+  createdAt?: string
+}
+
+export interface VideoGenResponse {
+  videos: VideoGenEntry[]
+  provider: string
+  model: string
+  description?: string
+}
+
+export interface VideoGenProviders { active: string; available: string[] }
 
 export interface DetectedTools {
   docker: boolean
@@ -229,6 +323,25 @@ export interface LinkedFolderDraft {
   description?: string
 }
 
+export interface LinkedFolderStatus {
+  indexedFiles: number
+  indexedAt?: string | null
+  indexError?: string | null
+  pendingJobs: number
+  failedJobs: number
+  lastJobError?: string | null
+}
+
+export interface LinkedFolderNote {
+  id: string
+  folder: string
+  path: string
+  content: string
+  createdAt: string
+  status: 'pending' | 'saved' | 'failed'
+  error?: string | null
+}
+
 export interface DiffHunk {
   oldText: string
   newText: string
@@ -266,9 +379,31 @@ export interface CustomProviderHeader {
 export interface CustomProviderConfig {
   id: string
   displayName: string
+  logoDataUrl?: string
   baseUrl: string
   apiKey: string
   models: CustomProviderModel[]
   headers: CustomProviderHeader[]
 }
 
+export type BackgroundJobStatus = 'running' | 'stopping' | 'completed' | 'failed' | 'stopped'
+export interface BackgroundJob {
+  id: string
+  command: string
+  cwd: string
+  workspacePath: string
+  chatId: string | null
+  pid: number | null
+  status: BackgroundJobStatus
+  exitCode: number | null
+  error: string | null
+  startedAt: number
+  endedAt: number | null
+  elapsedSeconds: number
+  serverUrl: string | null
+}
+export interface BackgroundJobOutput extends BackgroundJob {
+  stdout: string
+  stderr: string
+  truncated: boolean
+}

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

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+import { describeTool, activitiesFrom } from './agentActivity'
+import { viewedImagesFrom } from './viewedImages'
+import { reduceLiveAgentProgress } from '../agentProgress'
+import type { AgentProgress } from '../types'
+
+describe('skill reading activity', () => {
+  const input = { path: '/repo/.agents/skills/review/SKILL.md', skill_name: 'review' }
+  it('shows a reading label while the tool runs', () => {
+    expect(describeTool('read_file', input).label).toBe('Reading skill: review')
+  })
+  it('shows loaded only after a complete successful skill read', () => {
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { action: 'read_file', input } },
+      { type: 'ToolEnd', data: { action: 'read_file', input, result: '[Loaded skill: review]\nInstructions' } },
+    ])
+    expect(view.items[0].label).toBe('Loaded skill: review')
+  })
+  it('does not claim a failed skill read was loaded', () => {
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { action: 'read_file', input } },
+      { type: 'ToolEnd', data: { action: 'read_file', input, result: 'Error: denied' } },
+    ])
+    expect(view.items[0].state).toBe('error')
+    expect(view.items[0].label).not.toContain('Loaded skill:')
+  })
+  it('matches parallel completions to the skill that finished', () => {
+    const second = { path: '/repo/skills/test/SKILL.md', skill_name: 'test' }
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { action: 'read_file', input } },
+      { type: 'ToolStart', data: { action: 'read_file', input: second } },
+      { type: 'ToolEnd', data: { action: 'read_file', input, result: '[Loaded skill: review]\nInstructions' } },
+    ])
+    expect(view.items[0].label).toBe('Loaded skill: review')
+    expect(view.items[1].label).toBe('Reading skill: test')
+    expect(view.timeline?.filter(item => item.kind === 'activity')).toHaveLength(2)
+  })
+  it('does not mark a line-range preview as a full skill load', () => {
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { action: 'read_file', input } },
+      { type: 'ToolEnd', data: { action: 'read_file', input, result: '1 | Header only' } },
+    ])
+    expect(view.items[0].label).toBe('Read skill preview: review')
+  })
+})
+
+describe('MCP tool outcomes', () => {
+  it('uses the explicit failure status even when diagnostic text has no error prefix', () => {
+    const input = { server: 'blender', tool: 'render' }
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { callId: 'render-1', action: 'mcp_tool', input } },
+      { type: 'ToolEnd', data: { callId: 'render-1', action: 'mcp_tool', input, result: 'render failed', status: 'failed' } },
+    ] as any)
+    expect(view.items[0].state).toBe('error')
+  })
+})
+
+it('shows a readable view_image result instead of raw image bytes while preserving hook notes', () => {
+  const input = { path: '/workspace/screen.png' }
+  const view = activitiesFrom([
+    { type: 'ToolStart', data: { action: 'view_image', input } },
+    { type: 'ToolEnd', data: { action: 'view_image', input, result: 'data:image/png;base64,aGVsbG8=\n\n[Hook] Checked' } },
+  ])
+  expect(view.items[0].result).not.toContain('data:image/')
+  expect(view.items[0].result).toContain('Image displayed below')
+  expect(view.items[0].result).toContain('[Hook] Checked')
+})
+
+it('keeps viewed image identity stable when earlier text-only activities are trimmed', () => {
+  const earlier: AgentProgress[] = Array.from({ length: 10 }, () => ({ type: 'ToolEnd', data: { action: 'read_file', input: {}, result: 'Read' } }))
+  const image: AgentProgress = { type: 'ToolEnd', data: { action: 'view_image', input: { path: 'image.png' }, result: 'data:image/png;base64,aGVsbG8=' } }
+  const initial = [...earlier, image]
+  const later = Array.from({ length: 40 }, () => ({ type: 'ToolEnd' as const, data: { action: 'read_file', input: {}, result: 'Read' } })).reduce(reduceLiveAgentProgress, initial)
+  expect(viewedImagesFrom(later).map(item => item.id)).toEqual(viewedImagesFrom(initial).map(item => item.id))
+})

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

@@ -4,6 +4,8 @@
  * Shared by both Desktop and Web ChatPanel — do NOT duplicate this.
  */
 import type { AgentProgress } from '../types'
+import { isInternalCot } from '../agentProgress'
+import { viewedImageDataUri } from './viewedImages'
 
 export interface AgentActivity {
   label: string
@@ -11,6 +13,7 @@ export interface AgentActivity {
   kind: 'file' | 'folder' | 'search' | 'terminal' | 'tool' | 'calc'
   state: 'active' | 'done' | 'error' | 'retry'
   action?: string
+  callId?: string
   /** Raw ToolEnd output text, shown when the row is expanded in the UI. */
   result?: string
 }
@@ -26,10 +29,18 @@ export interface AgentActivityGroup {
   items: AgentActivity[]
 }
 
+export type TimelineItem =
+  | { id: string; kind: 'activity'; activity: AgentActivity }
+  | { id: string; kind: 'group'; group: AgentActivityGroup }
+  | { id: string; kind: 'thought'; thought: string }
+  | { id: string; kind: 'extendedThinking'; thought: string; streaming?: boolean; elapsedMs?: number }
+
 export interface AgentActivityView {
   summary: string
   items: AgentActivity[]
   groups?: AgentActivityGroup[]
+  /** Unified chronological list of thoughts, extended thinking, and tool activities. */
+  timeline?: TimelineItem[]
 }
 
 function activityDetail(input: Record<string, unknown>, key: string): string {
@@ -122,7 +133,8 @@ export function describeTool(action: string, input: Record<string, unknown>): Ag
 
   return {
     // Raw tool/action identifier, matching how the CLI labels activity (e.g. "[web_search]").
-    label: action,
+    label: action === 'read_file' && activityDetail(input, 'skill_name')
+      ? `Reading skill: ${activityDetail(input, 'skill_name')}` : action,
     target: formatActivityTarget(target),
     kind: activityKind(action, target),
     state: 'active',
@@ -234,37 +246,159 @@ function finalizeGroup(group: AgentActivityGroup): AgentActivityGroup {
     group.title = `Searched web (${count} queries)`
   } else {
     const readableAction = action.replaceAll('_', ' ')
-    group.title = `Executed ${count} ${readableAction} steps`
+    group.title = `Executed ${count} ${readableAction}`
   }
 
   return group
 }
 
 export function activitiesFrom(progress: AgentProgress[]): AgentActivityView {
+  const cached = activityCache.get(progress)
+  if (cached?.length === progress.length) return cached.view
+  const view = deriveActivitiesFrom(progress)
+  activityCache.set(progress, { length: progress.length, view })
+  return view
+}
+
+const activityCache = new WeakMap<AgentProgress[], { length: number; view: AgentActivityView }>()
+
+function deriveActivitiesFrom(progress: AgentProgress[]): AgentActivityView {
   const activities: AgentActivity[] = []
+  const timeline: TimelineItem[] = []
+  let currentGroup: AgentActivityGroup | null = null
+  let nextId = 0
+
+  const flushGroup = () => {
+    if (!currentGroup) return
+    const finalized = finalizeGroup(currentGroup)
+    if (finalized.count > 1) {
+      timeline.push({ id: finalized.id, kind: 'group', group: finalized })
+    } else if (finalized.items.length === 1) {
+      timeline.push({ id: finalized.id, kind: 'activity', activity: finalized.items[0] })
+    }
+    currentGroup = null
+  }
+
   for (const event of progress) {
     if (event.type === 'ToolStart') {
-      activities.push(describeTool(event.data.action, event.data.input))
+      const item = describeTool(event.data.action, event.data.input)
+      item.callId = event.data.callId
+      activities.push(item)
+
+      // Keep each skill's lifecycle visible instead of hiding it in a files group.
+      if (event.data.action === 'read_file' && activityDetail(event.data.input, 'skill_name')) {
+        flushGroup()
+        timeline.push({ id: `skill-${nextId++}`, kind: 'activity', activity: item })
+        continue
+      }
+
+      const actionKey = item.action || item.label
+      if (!currentGroup || currentGroup.action !== actionKey) {
+        flushGroup()
+        currentGroup = {
+          id: `timeline-group-${nextId++}-${actionKey}`,
+          action: actionKey,
+          label: item.label,
+          kind: item.kind,
+          title: item.target,
+          count: 1,
+          state: item.state,
+          items: [item],
+        }
+      } else {
+        currentGroup.items.push(item)
+        currentGroup.count += 1
+        if (item.state === 'active') {
+          currentGroup.state = 'active'
+        }
+      }
     } else if (event.type === 'ToolEnd') {
+      const finished = describeTool(event.data.action, event.data.input)
       for (let index = activities.length - 1; index >= 0; index -= 1) {
         if (activities[index].state !== 'active') continue
-        activities[index].state = event.data.result.startsWith('Error:') ? 'error' : 'done'
-        activities[index].result = event.data.result
+        if (event.data.callId && activities[index].callId !== event.data.callId) continue
+        if (activities[index].action !== finished.action || activities[index].target !== finished.target) continue
+        activities[index].state = event.data.status ? (event.data.status === 'success' ? 'done' : 'error') : /^(Error:|Blocked|User denied)/.test(event.data.result) ? 'error' : 'done'
+        const viewedImage = event.data.action === 'view_image' ? viewedImageDataUri(event.data.result) : null
+        activities[index].result = viewedImage ? event.data.result.replace(viewedImage, '[Image displayed below]') : event.data.result
+        if (event.data.action === 'read_file') {
+          const loaded = event.data.result.match(/^\[Loaded skill: ([^\n]+)\]\n/)
+          if (loaded) activities[index].label = `Loaded skill: ${loaded[1]}`
+          else if (activities[index].label.startsWith('Reading skill:')) {
+            activities[index].label = activities[index].state === 'error'
+              ? activities[index].label.replace('Reading skill:', 'Failed to read skill:')
+              : activities[index].label.replace('Reading skill:', 'Read skill preview:')
+          }
+        }
         if (activities[index].action === 'ask_user' && event.data.result.startsWith('User answered:')) {
           const answer = event.data.result.replace('User answered:', '').trim()
           activities[index].target = `(Answered: "${answer}") ${activities[index].target}`
         }
         break
       }
+      if (currentGroup) {
+        const hasActive = currentGroup.items.some((it) => it.state === 'active')
+        const hasDone = currentGroup.items.some((it) => it.state === 'done')
+        const hasError = currentGroup.items.some((it) => it.state === 'error')
+        const hasRetry = currentGroup.items.some((it) => it.state === 'retry')
+        currentGroup.state = hasActive ? 'active' : hasDone ? 'done' : hasRetry ? 'retry' : hasError ? 'error' : 'done'
+      }
+    } else if (event.type === 'ContextCompaction') {
+      if (event.data.status !== 'started') {
+        flushGroup()
+        timeline.push({ id: `context-${nextId++}`, kind: 'thought', thought: event.data.subagent ? `[${event.data.subagent}] ${event.data.message}` : event.data.message })
+      }
+    } else if (event.type === 'Thought') {
+      const text = event.data?.thought?.trim()
+      if (text) {
+        flushGroup()
+        const isCot = isInternalCot(text)
+        const kind = isCot ? 'extendedThinking' : 'thought'
+        const lastItem = timeline[timeline.length - 1]
+        if (lastItem && 'thought' in lastItem && lastItem.thought === text) {
+          if (lastItem.kind === 'extendedThinking' && kind === 'thought') {
+            timeline[timeline.length - 1] = { id: lastItem.id, kind, thought: text }
+          }
+        } else if (!lastItem || lastItem.kind !== kind || ('thought' in lastItem && lastItem.thought !== text)) {
+          timeline.push({ id: `thought-${nextId++}`, kind, thought: text })
+        }
+      }
+    } else if (event.type === 'ThinkingDelta') {
+      const text = event.data?.delta
+      if (text) {
+        flushGroup()
+        timeline.push({
+          id: event.data.id,
+          kind: 'extendedThinking',
+          thought: text,
+          streaming: true,
+          elapsedMs: event.data.elapsed_ms,
+        })
+      }
+    } else if (event.type === 'ExtendedThinking') {
+      const text = event.data?.thought?.trim()
+      if (text) {
+        flushGroup()
+        const lastItem = timeline[timeline.length - 1]
+        if (!lastItem || lastItem.kind !== 'extendedThinking' || ('thought' in lastItem && lastItem.thought !== text)) {
+          timeline.push({
+            id: event.data.id || `ext-thought-${nextId++}`,
+            kind: 'extendedThinking',
+            thought: text,
+            streaming: false,
+            elapsedMs: event.data.elapsed_ms,
+          })
+        }
+      }
     }
   }
 
+  flushGroup()
+
   const runSucceeded = progress.some(
     (e) => e.type === 'RunCompleted' && (e.data?.summary?.outcome === 'SUCCESS' || e.data?.summary?.outcome === 'success')
   )
 
-  // Mark intermediate errors as 'retry' if the agent continued running or succeeded later,
-  // or if the overall run succeeded (meaning the trailing error was non-fatal/recovered)
   for (let i = 0; i < activities.length; i++) {
     if (activities[i].state === 'error') {
       const hasSubsequentSuccessOrActive = activities.slice(i + 1).some(
@@ -276,8 +410,18 @@ export function activitiesFrom(progress: AgentProgress[]): AgentActivityView {
     }
   }
 
+  for (const item of timeline) {
+    if (item.kind === 'group') {
+      const hasActive = item.group.items.some((it) => it.state === 'active')
+      const hasDone = item.group.items.some((it) => it.state === 'done')
+      const hasError = item.group.items.some((it) => it.state === 'error')
+      const hasRetry = item.group.items.some((it) => it.state === 'retry')
+      item.group.state = hasActive ? 'active' : hasDone ? 'done' : hasRetry ? 'retry' : hasError ? 'error' : 'done'
+    }
+  }
+
   const items = activities.slice(-25)
-  return { summary: activitySummary(activities), items, groups: groupActivities(items) }
+  return { summary: activitySummary(activities), items, groups: groupActivities(items), timeline: timeline.slice(-60) }
 }
 
 export interface WebSearchSource {
@@ -335,3 +479,19 @@ export function parseWebSearchSources(progress: AgentProgress[]): WebSearchSourc
   return sources
 }
 
+/**
+ * Strips repeated conversation greetings (e.g. "สวัสดีค่ะพี่ภีม 🌿", "Hello...")
+ * from intermediate agent progress notes so only the concrete action note is shown.
+ */
+export function cleanIntermediateThought(text: string): string {
+  if (!text) return ''
+  let cleaned = text.trim()
+  // Strip leading greetings like "สวัสดีค่ะพี่ภีม 🌿", "สวัสดีครับ 🌿", "Hello...", etc.
+  cleaned = cleaned.replace(
+    /^(สวัสดีค่ะ|สวัสดีครับ|หวัดดีค่ะ|หวัดดีครับ|สวัสดี|hello|hi|hey)\s*(พี่[^\s,]+|คุณ[^\s,]+|[^\s,]+)?\s*(🌿|🍃|✨|🌱)?\s*[,—–-]?\s*/i,
+    ''
+  )
+  // Strip leading bullet characters
+  cleaned = cleaned.replace(/^[\s•\-\*]+\s*/, '')
+  return cleaned.trim() || text.trim()
+}

package/src/renderer/shared/utils/approval.tsx

@@ -13,6 +13,12 @@ export interface ApprovalDetails {
   isDangerous: boolean
 }
 
+// Skill changes require a decision for this proposal, including in sessions
+// where ordinary tool requests have already been allowed.
+export function requiresExplicitApproval(approval: Record<string, unknown> | undefined): boolean {
+  return !!approval?.SkillWrite
+}
+
 function parseDiffStats(diffText?: string): string {
   if (!diffText) return ''
   let additions = 0
@@ -44,6 +50,7 @@ export function renderApprovalDetails(approval: any): ApprovalDetails {
     const { server, tool, arguments: args } = approval.McpTool
     return { title: `Run MCP Tool: ${server}/${tool}`, body: typeof args === 'string' ? args : JSON.stringify(args, null, 2), reason: 'Running external MCP tool.', isDangerous: false }
   }
+  if (approval.SkillWrite) return { title: 'Save Skill', body: `Path: ${approval.SkillWrite.path}`, reason: 'This changes instructions used in future tasks. Review the proposed changes before saving.', isDangerous: false }
   if (approval.UserApproval) return { title: approval.UserApproval.title, body: approval.UserApproval.prompt, reason: 'The agent requested explicit approval.', isDangerous: false }
   if (approval.AskUser) {
     const hasOptions = Array.isArray(approval.AskUser.options) && approval.AskUser.options.length > 0

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

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest'
+import { installRendererPlatform } from '../platform'
+import * as desktopAdapter from '../../src/tauri'
+import { openArtifactInMintBrowser } from './artifactBrowser'
+
+const native = vi.hoisted(() => ({ invoke: vi.fn(async () => undefined) }))
+vi.mock('@tauri-apps/api/core', () => ({ invoke: native.invoke }))
+
+const url = 'http://127.0.0.1:12345/site/index.html'
+describe('opening a preview in Mint Browser', () => {
+  it('opens an existing served URL through Mint Browser on Desktop', async () => {
+    const opened: string[] = []
+    await openArtifactInMintBrowser({ path: 'site/index.html', url }, '/projects/Demo', {
+      desktop: true,
+      startPreview: async () => { throw new Error('An existing URL must be reused') },
+      openMintBrowser: async (target) => { opened.push(target) },
+    })
+    expect(opened).toEqual([url])
+  })
+  it('serves chat artifacts from their pinned project before opening Mint Browser', async () => {
+    const actions: unknown[] = []
+    await openArtifactInMintBrowser({ path: 'site/index.html', workspacePath: '/projects/Original' }, '/projects/Other', {
+      desktop: true,
+      startPreview: async (root, path, mint) => { actions.push([root, path, mint]); return { url, jobId: 'preview-1' } },
+      openMintBrowser: async (target) => { actions.push(target) },
+    })
+    expect(actions).toEqual([['/projects/Original', 'site/index.html', false], url])
+  })
+  it('opens the controlled browser through the authenticated local backend on Web', async () => {
+    const requests: unknown[] = []
+    await openArtifactInMintBrowser({ path: 'site/index.html', url, workspacePath: '/projects/Demo' }, undefined, {
+      desktop: false,
+      startPreview: async (root, path, mint) => { requests.push([root, path, mint]); return { url, jobId: 'preview-1' } },
+      openMintBrowser: async () => { throw new Error('Web must not call native IPC') },
+    })
+    expect(requests).toEqual([['/projects/Demo', 'site/index.html', true]])
+  })
+  it('reports browser launch failures so the button can show an error', async () => {
+    await expect(openArtifactInMintBrowser({ path: 'site/index.html', url }, undefined, {
+      desktop: true,
+      startPreview: async () => { throw new Error('Unexpected server startup') },
+      openMintBrowser: async () => { throw new Error('Chrome unavailable') },
+    })).rejects.toThrow('Chrome unavailable')
+  })
+  it('does not start a server without a source project', async () => {
+    await expect(openArtifactInMintBrowser({ path: 'site/index.html' }, undefined, {
+      desktop: true,
+      startPreview: async () => { throw new Error('Unexpected server startup') },
+      openMintBrowser: async () => { throw new Error('Unexpected browser startup') },
+    })).rejects.toThrow('Select a project')
+  })
+})
+
+it('sends the existing open_mint_browser IPC command for the default Desktop action', async () => {
+  installRendererPlatform({ ...desktopAdapter, isTauriRuntime: () => true })
+  native.invoke.mockClear()
+  await openArtifactInMintBrowser({ path: 'site/index.html', url }, undefined)
+  expect(native.invoke).toHaveBeenCalledWith('open_mint_browser', { url })
+})
+
+it.each([
+  ['/projects/Demo', '/projects/Demo/site/index.html', 'site/index.html'],
+  ['C:\\Projects\\Demo', 'c:\\projects\\demo\\site\\index.html', 'site/index.html'],
+])('opens absolute artifact paths relative to their source project %s', async (root, path, relative) => {
+  const requests: unknown[] = []
+  await openArtifactInMintBrowser({ path, workspacePath: root }, '/projects/Other', {
+    desktop: true,
+    startPreview: async (workspace, file, mint) => { requests.push([workspace, file, mint]); return { url, jobId: 'preview-1' } },
+    openMintBrowser: async () => {},
+  })
+  expect(requests).toEqual([[root, relative, false]])
+})
+
+it('rejects an absolute artifact from a different project without starting a server', async () => {
+  await expect(openArtifactInMintBrowser({ path: '/projects/Demo-copy/index.html', workspacePath: '/projects/Demo' }, undefined, {
+    desktop: true,
+    startPreview: async () => { throw new Error('Unexpected server startup') },
+    openMintBrowser: async () => {},
+  })).rejects.toThrow('outside its source project')
+})