@pheem49/mint 1.15.0 → 1.16.0

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

@@ -1,3 +1,5 @@
+import '../css/effects.css'
+import { initializeEffectVisibility } from '../utils/effectVisibility'
 /**
  * shared/theme/themeManager.ts
  * Centralized theme controller and runtime state manager.
@@ -47,7 +49,9 @@ export const applyTheme = (cfg: any): void => {
   if (typeof document === 'undefined') return
 
   const rawTheme = cfg.theme || 'dark'
-  const surfaceStyle = cfg.surfaceStyle || (cfg.glassBlur === 'none' ? 'opaque' : 'glass')
+  // Match Settings: disabling glass also disables translucent surfaces, even
+  // when an older configuration still contains surfaceStyle: 'glass'.
+  const surfaceStyle = cfg.glassBlur === 'none' ? 'opaque' : (cfg.surfaceStyle || 'glass')
   const accentColor = cfg.accentColor || '#10b981'
   const rgb = hexToRgb(accentColor)
   const contrastText = getContrastText(accentColor)
@@ -72,6 +76,9 @@ export const applyTheme = (cfg: any): void => {
     systemThemeMediaQuery = null
   }
 
+  initializeEffectVisibility()
+  document.documentElement.setAttribute('data-reduced-effects', String(cfg.reducedEffects === true))
+
   // Set DOM data attributes
   document.documentElement.setAttribute('data-theme', effectiveTheme)
   document.documentElement.setAttribute('data-surface', surfaceStyle)
@@ -118,9 +125,15 @@ export const applyTheme = (cfg: any): void => {
     }
     if (cfg.customPanelBg) {
       const pRgb = hexToRgb(cfg.customPanelBg)
-      document.documentElement.style.setProperty('--bg-surface', `rgba(${pRgb.r}, ${pRgb.g}, ${pRgb.b}, 0.75)`)
-      document.documentElement.style.setProperty('--panel-bg', `rgba(${pRgb.r}, ${pRgb.g}, ${pRgb.b}, 0.75)`)
-      document.documentElement.style.setProperty('--surface-bg', `rgba(${pRgb.r}, ${pRgb.g}, ${pRgb.b}, 0.62)`)
+      const panelSurface = surfaceStyle === 'opaque'
+        ? cfg.customPanelBg
+        : `rgba(${pRgb.r}, ${pRgb.g}, ${pRgb.b}, 0.75)`
+      const raisedSurface = surfaceStyle === 'opaque'
+        ? cfg.customPanelBg
+        : `rgba(${pRgb.r}, ${pRgb.g}, ${pRgb.b}, 0.62)`
+      document.documentElement.style.setProperty('--bg-surface', panelSurface)
+      document.documentElement.style.setProperty('--panel-bg', panelSurface)
+      document.documentElement.style.setProperty('--surface-bg', raisedSurface)
     }
     return
   }

package/src/renderer/shared/types.ts

@@ -40,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
@@ -72,13 +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: '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 } }
-  | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string; subagent?: string } }
+  | { 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 } }
 
@@ -146,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
@@ -190,6 +221,7 @@ export interface 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
@@ -353,3 +385,25 @@ export interface CustomProviderConfig {
   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

@@ -5,6 +5,7 @@
  */
 import type { AgentProgress } from '../types'
 import { isInternalCot } from '../agentProgress'
+import { viewedImageDataUri } from './viewedImages'
 
 export interface AgentActivity {
   label: string
@@ -12,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
 }
@@ -131,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',
@@ -250,6 +253,16 @@ function finalizeGroup(group: AgentActivityGroup): AgentActivityGroup {
 }
 
 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
@@ -269,8 +282,16 @@ export function activitiesFrom(progress: AgentProgress[]): AgentActivityView {
   for (const event of progress) {
     if (event.type === 'ToolStart') {
       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()
@@ -292,10 +313,23 @@ export function activitiesFrom(progress: AgentProgress[]): AgentActivityView {
         }
       }
     } 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}`
@@ -309,6 +343,11 @@ export function activitiesFrom(progress: AgentProgress[]): AgentActivityView {
         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) {

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')
+})

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

@@ -0,0 +1,41 @@
+import type { ArtifactFile } from '../components/ArtifactPreviewPanel'
+import { runtimePlatform, workspacePlatform } from '../platform'
+
+interface BrowserApi {
+  desktop: boolean
+  startPreview(root: string, path: string, mintBrowser: boolean): Promise<{ url: string; jobId: string }>
+  openMintBrowser(url: string): Promise<void>
+}
+
+export async function openArtifactInMintBrowser(
+  artifact: ArtifactFile,
+  workspace: string | undefined,
+  api: BrowserApi = {
+    desktop: runtimePlatform.isTauriRuntime(),
+    startPreview: (root, path, mint) => workspacePlatform.startHtmlPreview(root, path, mint),
+    openMintBrowser: async (url) => {
+      const { invoke } = await import('@tauri-apps/api/core')
+      await invoke('open_mint_browser', { url })
+    },
+  },
+): Promise<void> {
+  if (api.desktop && artifact.url) {
+    await api.openMintBrowser(artifact.url)
+    return
+  }
+  const root = (artifact.workspacePath ?? workspace)?.trim()
+  if (!root) throw new Error('Select a project before opening its preview in Mint Browser')
+  let path = artifact.path.replace(/\\/g, '/')
+  if (/^(\/|[a-z]:\/)/i.test(path)) {
+    const normalizedRoot = root.replace(/\\/g, '/').replace(/\/+$/, '')
+    const prefix = `${normalizedRoot}/`
+    const windows = /^[a-z]:\//i.test(normalizedRoot) || normalizedRoot.startsWith('//')
+    if (!(windows ? path.toLowerCase().startsWith(prefix.toLowerCase()) : path.startsWith(prefix))) {
+      throw new Error('This file is outside its source project')
+    }
+    path = path.slice(prefix.length)
+  }
+  // The authenticated local Web endpoint launches the same automation browser on the backend.
+  const preview = await api.startPreview(root, path, !api.desktop)
+  if (api.desktop) await api.openMintBrowser(preview.url)
+}

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

@@ -0,0 +1,48 @@
+import React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { activeCompactionFrom } from './contextCompaction'
+import { ContextCompactionStatus } from '../components/ContextCompactionStatus'
+import { activitiesFrom } from './agentActivity'
+import type { AgentProgress } from '../types'
+
+const started = { type: 'ContextCompaction', data: { status: 'started', message: 'Summarizing earlier steps to continue working' } } as const
+const completed = { type: 'ContextCompaction', data: { status: 'completed', message: 'Context compacted' } } as const
+const failed = { type: 'ContextCompaction', data: { status: 'failed', message: 'Context compaction failed: provider unavailable. Continuing with the original context.' } } as const
+
+describe('context compaction progress', () => {
+  it('keeps compaction active until its terminal event, then allows normal working status', () => {
+    expect(activeCompactionFrom([started, { type: 'Thinking', data: { elapsed_secs: 10 } }])?.message).toContain('Summarizing earlier steps')
+    expect(activeCompactionFrom([started, completed])).toBeNull()
+    expect(activeCompactionFrom([started, failed])).toBeNull()
+    expect(activeCompactionFrom([started, completed, started])).not.toBeNull()
+  })
+  it('renders the elapsed timer, explanatory text and animated gradient label', () => {
+    const html = renderToStaticMarkup(<ContextCompactionStatus elapsedSeconds={12} />)
+    expect(html).toContain('Compacting context')
+    expect(html).toContain('12s')
+    expect(html).toContain('Summarizing earlier steps to continue working')
+    expect(html).toContain('thinking-status-label')
+    expect(html).toContain('role="status"')
+  })
+  it('keeps completion and actionable failure visible in activity history, without a completed start row', () => {
+    const timeline = activitiesFrom([started, completed, started, failed]).timeline
+    expect(timeline?.map(item => 'thought' in item ? item.thought : '')).toEqual([completed.data.message, failed.data.message])
+  })
+})
+
+it('keeps the collective timer active until all parallel subagents finish', () => {
+  const a = { ...started, data: { ...started.data, subagent: 'A' } }
+  const b = { ...started, data: { ...started.data, subagent: 'B' } }
+  const doneA = { ...completed, data: { ...completed.data, subagent: 'A' } }
+  const doneB = { ...completed, data: { ...completed.data, subagent: 'B' } }
+  expect(activeCompactionFrom([a, b, doneA])?.index).toBe(0)
+  expect(activeCompactionFrom([a, b, doneA, doneB])).toBeNull()
+})
+
+it('keeps repeated-name subagents active until every lifecycle finishes', () => {
+  const child = { ...started, data: { ...started.data, subagent: 'reviewer' } }
+  const done = { ...completed, data: { ...completed.data, subagent: 'reviewer' } }
+  expect(activeCompactionFrom([child, child, done])?.index).toBe(0)
+  expect(activeCompactionFrom([child, child, done, done])).toBeNull()
+})

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

@@ -0,0 +1,21 @@
+import type { AgentProgress } from '../types'
+
+export function activeCompactionFrom(progress: AgentProgress[]) {
+  const pending = new Map<string, { count: number; data: Extract<AgentProgress, { type: 'ContextCompaction' }>['data'] }>()
+  let cycleIndex = 0
+  for (let index = 0; index < progress.length; index++) {
+    const event = progress[index]
+    if (event.type !== 'ContextCompaction') continue
+    const scope = event.data.subagent ?? ''
+    if (event.data.status === 'started') {
+      if (pending.size === 0) cycleIndex = index
+      pending.set(scope, { count: (pending.get(scope)?.count ?? 0) + 1, data: event.data })
+    } else {
+      const entry = pending.get(scope)
+      if (entry && entry.count > 1) entry.count--
+      else pending.delete(scope)
+    }
+  }
+  const active = pending.values().next().value
+  return active ? { ...active.data, index: cycleIndex } : null
+}

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

@@ -0,0 +1,9 @@
+// Each renderer window owns its visibility listener for its lifetime.
+const initialized = new WeakSet<Document>()
+export function initializeEffectVisibility(): void {
+  if (typeof document === 'undefined' || !document.addEventListener || initialized.has(document)) return
+  initialized.add(document)
+  const update = () => document.documentElement.setAttribute('data-effects-hidden', String(document.hidden))
+  document.addEventListener('visibilitychange', update)
+  update()
+}

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

@@ -417,13 +417,13 @@ function renderMessageImage(src: string | undefined, alt: string | undefined, so
         className="chat-media-card chat-media-card--thumbnail"
         style={{ margin: '6px 0 10px', borderRadius: '10px', overflow: 'hidden', border: '1px solid var(--border, rgba(255,255,255,0.12))', background: 'var(--panel-bg, #141416)', maxWidth: '420px' }}
       >
-        <a href={pageUrl} target="_blank" rel="noopener noreferrer" title={sourceUrl ? `Open source page: ${label}` : label} style={{ display: 'block', textDecoration: 'none' }}>
+        <a href={pageUrl} target="_blank" rel="noopener noreferrer" title={sourceUrl ? `Open source page: ${label}` : label} style={{ display: 'flex', justifyContent: 'center', textDecoration: 'none' }}>
           <img
             src={url}
             alt={label}
             loading="lazy"
             referrerPolicy="no-referrer"
-            style={{ width: '100%', maxHeight: '200px', objectFit: 'cover', display: 'block' }}
+            style={{ width: 'auto', height: 'auto', maxWidth: '100%', maxHeight: '420px', objectFit: 'contain', display: 'block' }}
             onError={(e) => { const card = e.currentTarget.closest('.chat-media-card') as HTMLElement | null; if (card) card.style.display = 'none' }}
           />
         </a>
@@ -700,7 +700,7 @@ function splitVideoSegments(text: string): Segment[] {
 }
 
 export function renderFormattedMessage(text: string, webSources: WebSearchSource[] = []): ReactNode {
-  const displayText = readableAssistantText(text)
+  const displayText = readableAssistantText(text.replace(/\r\n?/g, '\n'))
   if (!displayText) return null
 
   const segments = splitVideoSegments(displayText)