@pheem49/mint 1.15.0 → 1.16.0

package/src/renderer/shared/components/ChunkErrorBoundary.tsx

@@ -1,20 +1,11 @@
 import React from 'react'
+import { ErrorRecovery } from './ui/error-recovery'
 
 interface State {
   hasError: boolean
 }
 
-/**
- * Catches errors from lazy-loaded route chunks (e.g. a stale cached page
- * trying to fetch a hashed JS file that no longer exists after a rebuild)
- * and offers a reload instead of leaving the app permanently blank.
- *
- * Deliberately styled with plain inline styles instead of the app's themed
- * CSS: this screen exists for the case where something in the app's own
- * loading chain already failed, so it shouldn't gamble on `--bg-color` /
- * `--accent` etc. having made it in — a fixed white background reads
- * correctly no matter what broke.
- */
+/** Catches failed route chunks and keeps recovery/window controls available. */
 type Props = { children: React.ReactNode }
 
 export default class ChunkErrorBoundary extends React.Component<Props, State> {
@@ -91,7 +82,7 @@ export default class ChunkErrorBoundary extends React.Component<Props, State> {
             width: '100vw',
             background: '#09090b',
             color: '#e4e4e7',
-            fontFamily: 'Outfit, Inter, ui-sans-serif, system-ui, sans-serif',
+            fontFamily: "'IBM Plex Sans Thai', 'Noto Sans Thai', 'Inter', ui-sans-serif, system-ui, sans-serif",
             boxSizing: 'border-box',
             overflow: 'hidden',
           }}
@@ -186,96 +177,7 @@ export default class ChunkErrorBoundary extends React.Component<Props, State> {
             </div>
           </div>
 
-          <div
-            style={{
-              flex: 1,
-              display: 'flex',
-              flexDirection: 'column',
-              alignItems: 'center',
-              justifyContent: 'center',
-              padding: 24,
-              boxSizing: 'border-box',
-            }}
-          >
-            <div
-              style={{
-                display: 'flex',
-                flexDirection: 'column',
-                alignItems: 'center',
-                maxWidth: 420,
-                textAlign: 'center',
-                padding: '32px 28px',
-                borderRadius: 20,
-                background: '#18181b',
-                border: '1px solid rgba(255, 255, 255, 0.08)',
-                boxShadow: '0 20px 40px rgba(0, 0, 0, 0.6)',
-                gap: 16,
-              }}
-            >
-              <div
-                style={{
-                  width: 48,
-                  height: 48,
-                  borderRadius: 14,
-                  background: 'rgba(16, 185, 129, 0.12)',
-                  border: '1px solid rgba(16, 185, 129, 0.25)',
-                  display: 'flex',
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                  color: '#10b981',
-                  fontSize: '1.4rem',
-                  fontWeight: 700,
-                }}
-              >
-                ✦
-              </div>
-              <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
-                <h2 style={{ margin: 0, fontSize: '1.15rem', fontWeight: 650, color: '#f4f4f5' }}>
-                  Mint needs to refresh
-                </h2>
-                <span style={{ fontSize: '0.88rem', color: '#a1a1aa', lineHeight: 1.5 }}>
-                  An asset failed to load or a new version was deployed. Refreshing will load the latest version.
-                </span>
-              </div>
-              <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginTop: 8 }}>
-                <button
-                  type="button"
-                  onClick={this.handleReset}
-                  style={{
-                    padding: '10px 18px',
-                    borderRadius: 12,
-                    border: '1px solid rgba(255, 255, 255, 0.12)',
-                    background: 'rgba(255, 255, 255, 0.06)',
-                    color: '#e4e4e7',
-                    fontWeight: 600,
-                    fontSize: '0.88rem',
-                    cursor: 'pointer',
-                    transition: 'background 0.15s ease',
-                  }}
-                >
-                  Back to Chat
-                </button>
-                <button
-                  type="button"
-                  onClick={this.handleReload}
-                  style={{
-                    padding: '10px 22px',
-                    borderRadius: 12,
-                    border: 'none',
-                    background: '#10b981',
-                    color: '#06120c',
-                    fontWeight: 650,
-                    fontSize: '0.88rem',
-                    cursor: 'pointer',
-                    boxShadow: '0 4px 14px rgba(16, 185, 129, 0.25)',
-                    transition: 'background 0.15s ease, transform 0.1s ease',
-                  }}
-                >
-                  Refresh &amp; Update
-                </button>
-              </div>
-            </div>
-          </div>
+          <ErrorRecovery onBackToChat={this.handleReset} onRefresh={this.handleReload} />
         </div>
       )
     }

package/src/renderer/shared/components/CliSessionsView.test.tsx

@@ -0,0 +1,125 @@
+import React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import CliSessionsView from './CliSessionsView'
+import { workspacePaths } from '../utils/workspaces'
+import type { ChatSession } from '../types'
+
+const demo = '/home/pheem49/vscode/Project/Demo'
+const mint = '/home/pheem49/vscode/Project/Mint-CLI'
+const session = (id: string, kind: string, workspacePath?: string): ChatSession => ({
+  id, kind, workspacePath, title: `Task ${id}`,
+  createdAt: '2026-10-05T15:10:24Z', updatedAt: '2026-10-05T15:10:24Z',
+  messageCount: 1, totalBytes: 100,
+})
+
+function render(chatSessions: ChatSession[], workspacePath?: string, recentWorkspacePaths?: string[]) {
+  return renderToStaticMarkup(<CliSessionsView
+    chatSessions={chatSessions}
+    workspacePath={workspacePath}
+    recentWorkspacePaths={recentWorkspacePaths}
+    activeConversationId="conversation-demo"
+    onSelectSession={() => {}}
+    onDeleteSession={() => {}}
+    onRenameSession={() => {}}
+  />)
+}
+
+describe('Code hub Current Project', () => {
+  it('shows only CLI sessions in the selected project and counts the visible scope', () => {
+    const html = render([
+      session('conversation-demo', 'conversation', demo),
+      session('cli::demo', 'cli', demo),
+      session('cli::mint', 'cli', mint),
+      session('conversation-mint', 'conversation', mint),
+    ], demo)
+    expect(html).not.toContain('Task conversation-demo')
+    expect(html).toContain('Task cli::demo')
+    expect(html).not.toContain('Task cli::mint')
+    expect(html).not.toContain('Task conversation-mint')
+    expect(html).toMatch(/code-header-count[^>]*>1 session</)
+    expect(html).not.toContain('mint --resume conversation-demo')
+  })
+
+  it('identifies a project without CLI sessions even when other repositories have sessions', () => {
+    const html = render([
+      session('conversation-demo', 'conversation', demo),
+      session('cli::mint', 'cli', mint),
+    ], demo)
+    expect(html).toMatch(/code-header-count[^>]*>0 sessions</)
+    expect(html).toContain('No CLI sessions found in Demo.')
+    expect(html).toContain(`title="${demo}"`)
+  })
+
+  it('uses the searchable workspace dialog trigger in Code hub', () => {
+    const html = render([session('cli::mint', 'cli', mint)], mint)
+    expect(html).toContain('aria-label="Change workspace: Mint-CLI"')
+    expect(html).toContain('aria-haspopup="dialog"')
+    expect(html).toContain(`title="${mint}"`)
+  })
+
+  it('counts CLI sessions outside an empty project and offers to show them all', () => {
+    const html = render([
+      session('conversation-demo', 'conversation', demo),
+      ...Array.from({ length: 37 }, (_, i) => session(`cli::mint-${i}`, 'cli', mint)),
+    ], demo)
+    expect(html).toContain('37 CLI sessions outside this project')
+    expect(html).toMatch(/>Show all sessions<\/button>/)
+  })
+
+  it('does not offer a show-all empty-state action when no CLI sessions exist', () => {
+    const html = render([session('conversation-demo', 'conversation', demo)], demo)
+    expect(html).not.toMatch(/>Show all sessions<\/button>/)
+    expect(html).not.toContain('CLI sessions outside this project')
+  })
+
+  it('does not mix unassigned sessions into a selected project', () => {
+    const html = render([
+      session('cli::global', 'cli'),
+      session('conversation-global', 'conversation'),
+      session('cli::demo', 'cli', demo),
+    ], demo)
+    expect(html).toContain('Task cli::demo')
+    expect(html).not.toContain('Task cli::global')
+    expect(html).not.toContain('Task conversation-global')
+  })
+
+  it.each([
+    [demo, ` ${demo}/ `],
+    ['C:\\Projects\\Demo', 'C:/Projects/Demo/'],
+  ])('matches equivalent workspace spellings: %s', (stored, selected) => {
+    expect(render([session('cli::demo', 'cli', stored)], selected)).toContain('Task cli::demo')
+  })
+
+  it('keeps distinct directories and Linux case differences separate', () => {
+    const html = render([
+      session('cli::prefix', 'cli', `${demo}-other`),
+      session('cli::case', 'cli', demo.toLowerCase()),
+    ], demo)
+    expect(html).not.toContain('Task cli::prefix')
+    expect(html).not.toContain('Task cli::case')
+  })
+
+  it('requests a project selection instead of showing every session when no workspace is selected', () => {
+    const html = render([session('cli::demo', 'cli', demo)])
+    expect(html).not.toContain('Task cli::demo')
+    expect(html).toContain('Select a project')
+  })
+})
+
+
+describe('shared workspace catalog', () => {
+  it('includes session-only projects without changing the recent-folder order', () => {
+    expect(workspacePaths([mint, demo], mint, ['/home/pheem49', '/projects/FableMint', demo]))
+      .toEqual([mint, demo, '/home/pheem49', '/projects/FableMint'])
+  })
+  it('deduplicates equivalent paths and retains distinct folders with the same name', () => {
+    expect(workspacePaths([` ${mint}/ `, mint, '/another/Mint-CLI'], '', [undefined, 'C:\\Projects\\Demo', 'C:/Projects/Demo/']))
+      .toEqual([mint, '/another/Mint-CLI', 'C:/Projects/Demo'])
+  })
+})
+
+it('preserves absolute Windows drive roots when deduplicating workspace folders', () => {
+  expect(workspacePaths(['C:\\', 'C:/', '/'], 'C:/', ['C:/Projects/Demo/']))
+    .toEqual(['C:/', '/', 'C:/Projects/Demo'])
+})

package/src/renderer/shared/components/CliSessionsView.tsx

@@ -1,15 +1,20 @@
+import SelectField from './SelectField'
 import React, { useState, useMemo, useEffect, useRef } from 'react'
 import type { ChatSession } from '../types'
 import { parseUtcDate } from '../utils/ui'
+import { normalizeWorkspacePath, workspacePaths } from '../utils/workspaces'
+import WorkspaceSelector from './WorkspaceSelector'
 import '../css/code-sessions.css'
 
 export interface CliSessionsViewProps {
   chatSessions: ChatSession[]
   activeConversationId: string
   workspacePath?: string
+  recentWorkspacePaths?: string[]
   onSelectSession: (id: string) => void
   onDeleteSession: (id: string) => void
   onRenameSession: (id: string, newTitle: string) => void
+  onSelectFolder?: () => Promise<string | null>
   onRefreshSessions?: () => void
   onShowToast?: (message: string) => void
 }
@@ -40,13 +45,16 @@ function getFolderBasename(path?: string | null): string {
   return parts[parts.length - 1] || path
 }
 
+
 export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(function CliSessionsView({
   chatSessions,
   activeConversationId,
   workspacePath,
+  recentWorkspacePaths,
   onSelectSession,
   onDeleteSession,
   onRenameSession,
+  onSelectFolder,
   onRefreshSessions,
   onShowToast,
 }) {
@@ -55,6 +63,14 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
   const [sortBy, setSortBy] = useState<'recent' | 'messages' | 'oldest'>('recent')
   const [editingSessionId, setEditingSessionId] = useState<string | null>(null)
   const [editTitleValue, setEditTitleValue] = useState('')
+  const [selectedWorkspace, setSelectedWorkspace] = useState(() => normalizeWorkspacePath(workspacePath))
+  useEffect(() => {
+    setSelectedWorkspace(normalizeWorkspacePath(workspacePath))
+  }, [workspacePath])
+  const currentWorkspace = selectedWorkspace
+  const projectName = getFolderBasename(currentWorkspace)
+  const projectPaths = useMemo(() => workspacePaths(recentWorkspacePaths || [], selectedWorkspace),
+    [recentWorkspacePaths, selectedWorkspace])
 
   const onRefreshRef = useRef(onRefreshSessions)
   useEffect(() => {
@@ -74,12 +90,17 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
   const allCliSessions = useMemo(() => {
     return chatSessions.filter((s) => s.kind === 'cli' || s.id.startsWith('cli'))
   }, [chatSessions])
+  const projectSessionCount = allCliSessions.filter((session) =>
+    currentWorkspace && normalizeWorkspacePath(session.workspacePath) === currentWorkspace).length
+  const otherSessionCount = allCliSessions.length - projectSessionCount
+  const showOtherSessions = scopeFilter === 'workspace' && !searchQuery.trim()
+    && projectSessionCount === 0 && otherSessionCount > 0
 
   const filteredSessions = useMemo(() => {
     return allCliSessions
       .filter((s) => {
-        if (scopeFilter === 'workspace' && workspacePath && s.workspacePath) {
-          if (s.workspacePath !== workspacePath) return false
+        if (scopeFilter === 'workspace') {
+          if (!currentWorkspace || normalizeWorkspacePath(s.workspacePath) !== currentWorkspace) return false
         }
 
         if (!searchQuery.trim()) return true
@@ -103,7 +124,7 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
         }
         return timeB - timeA
       })
-  }, [allCliSessions, scopeFilter, workspacePath, searchQuery, sortBy])
+  }, [allCliSessions, scopeFilter, currentWorkspace, searchQuery, sortBy])
 
   const handleCopyResumeCommand = (e: React.MouseEvent, sessionId: string) => {
     e.stopPropagation()
@@ -162,22 +183,42 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
               <span>Code sessions</span>
             </h1>
             <span className="code-header-count">
-              {allCliSessions.length} {allCliSessions.length === 1 ? 'session' : 'sessions'}
+              {filteredSessions.length} {filteredSessions.length === 1 ? 'session' : 'sessions'}
             </span>
           </div>
           <p className="code-header-subtitle">
-            Terminal conversations and agent runs from your active repositories.
+            {scopeFilter === 'workspace'
+              ? currentWorkspace
+                ? <>CLI sessions in <strong title={currentWorkspace}>{projectName}</strong>.</>
+                : 'Select a project above to view its CLI sessions.'
+              : 'CLI sessions across all repositories.'}
           </p>
         </div>
 
         {/* Right side controls: Scope switch & refresh */}
-        <div style={{ display: 'flex', alignItems: 'center', gap: '8px', flexWrap: 'wrap' }}>
+        <div className="code-header-controls">
+          <WorkspaceSelector
+            currentPath={currentWorkspace}
+            recentPaths={projectPaths}
+            placement="below"
+            onSelectWorkspace={async (path) => {
+              try {
+                const selected = path || await onSelectFolder?.()
+                if (selected) {
+                  setSelectedWorkspace(normalizeWorkspacePath(selected))
+                  setScopeFilter('workspace')
+                }
+              } catch (error) {
+                onShowToast?.(`Could not open folder: ${error instanceof Error ? error.message : String(error)}`)
+              }
+            }}
+          />
           <div className="code-segmented-toggle">
             <button
               type="button"
               className={`code-segmented-btn ${scopeFilter === 'workspace' ? 'active' : ''}`}
               onClick={() => setScopeFilter('workspace')}
-              title="Show sessions from current workspace"
+              title="Show sessions from the selected project"
             >
               Current Project
             </button>
@@ -191,16 +232,16 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
             </button>
           </div>
 
-          <select
+          <SelectField fullWidth={false} aria-label="Sort sessions"
             className="code-sort-select"
             value={sortBy}
-            onChange={(e) => setSortBy(e.target.value as any)}
+            onValueChange={(nextValue) => setSortBy(nextValue as any)}
             title="Sort sessions"
           >
             <option value="recent">Recently active</option>
             <option value="messages">Most turns</option>
             <option value="oldest">Oldest first</option>
-          </select>
+          </SelectField>
 
           {onRefreshSessions && (
             <button
@@ -265,12 +306,19 @@ export const CliSessionsView: React.FC<CliSessionsViewProps> = React.memo(functi
           </div>
           <div className="code-terminal-body">
             <p className="code-terminal-text">
-              {searchQuery
+              {searchQuery.trim()
                 ? 'No terminal sessions match your query.'
-                : scopeFilter === 'workspace' && allCliSessions.length > 0
-                ? 'No sessions found in this project. Switch to "All Repositories" or start one in this directory:'
+                : scopeFilter === 'workspace'
+                ? currentWorkspace
+                  ? `No CLI sessions found in ${projectName}.${otherSessionCount > 0 ? ` ${otherSessionCount} CLI ${otherSessionCount === 1 ? 'session' : 'sessions'} outside this project.` : ' Run Mint in this project directory to begin:'}`
+                  : 'Select a project above, or switch to "All Repositories" to view your CLI sessions.'
                 : 'No terminal sessions recorded yet. Launch Mint in any repository to begin:'}
             </p>
+            {showOtherSessions && (
+              <button type="button" className="code-segmented-btn active code-show-all-btn"
+                onClick={() => { setSearchQuery(''); setScopeFilter('all') }}
+              >Show all sessions</button>
+            )}
             <div className="code-terminal-codeblock">
               <span>$ mint</span>
               <button

package/src/renderer/shared/components/CodeReviewPage.tsx

@@ -1,7 +1,10 @@
+import SelectField from './SelectField'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import type { PointerEvent as ReactPointerEvent } from 'react'
-import type { FileChange, GitBranchInfo } from '../types'
+import type { FileChange, GitBranchInfo, WorkspaceHistoryEntry } from '../types'
 import { workspacePlatform } from '../platform'
+import { useWorkspaceUndo } from '../workspaceUndo'
+import { HistoryDetails, UndoConfirmation } from './ReviewHistory'
 import GitBranchSelector from './GitBranchSelector'
 import {
   materialFolderIcon,
@@ -26,6 +29,31 @@ function diffLines(text: string) {
   return text.replace(/\n$/, '').split('\n')
 }
 
+/** Display paths inside the selected workspace, with a boundary-safe prefix. */
+function workspaceRelativePath(path: string, workspace?: string | null): string | null {
+  const normalized = path.replace(/\\/g, '/')
+  const root = workspace?.replace(/\\/g, '/').replace(/\/+$/, '')
+  const isAbsolute = /^(\/|[a-z]:\/)/i.test(normalized)
+  let relative = normalized
+  if (root && isAbsolute) {
+    const windows = /^[a-z]:\//i.test(root) || root.startsWith('//')
+    const prefix = `${root}/`
+    if (!(windows ? normalized.toLowerCase().startsWith(prefix.toLowerCase()) : normalized.startsWith(prefix))) return null
+    relative = normalized.slice(prefix.length)
+  } else if (!root && isAbsolute) {
+    return normalized
+  }
+  const parts: string[] = []
+  for (const part of relative.split('/')) {
+    if (!part || part === '.') continue
+    if (part === '..') {
+      if (!parts.length) return null
+      parts.pop()
+    } else parts.push(part)
+  }
+  return parts.length ? parts.join('/') : null
+}
+
 interface TreeNode {
   name: string
   path: string
@@ -84,10 +112,23 @@ export default function CodeReviewPage({
   onBack,
   onOpenFiles,
 }: Props) {
+  const workspaceRef = useRef(workspacePath)
+  workspaceRef.current = workspacePath
+  const diffRequest = useRef(0)
+  const [tab, setTab] = useState<'changes' | 'history'>('changes')
+  const [historyRevision, setHistoryRevision] = useState(0)
+  const [historySelection, setHistorySelection] = useState('')
+  const [confirmation, setConfirmation] = useState<{ root: string; entry: WorkspaceHistoryEntry } | null>(null)
+  const [undoNotice, setUndoNotice] = useState('')
+  const [undonePaths, setUndonePaths] = useState<Set<string>>(new Set())
   const [workspaceDiffs, setWorkspaceDiffs] = useState<FileChange[]>([])
   const [isLoadingDiff, setIsLoadingDiff] = useState(false)
   const [gitInfo, setGitInfo] = useState<GitBranchInfo | null>(null)
-  const hasAgentChanges = Boolean(changes && changes.length > 0)
+  const agentChanges = useMemo(() => (changes || []).flatMap(change => {
+    const path = workspaceRelativePath(change.path, workspacePath)
+    return path ? [{ ...change, path }] : []
+  }), [changes, workspacePath])
+  const hasAgentChanges = agentChanges.length > 0
 
   const [diffScope, setDiffScope] = useState<'workspace' | 'agent'>(
     hasAgentChanges ? 'agent' : 'workspace'
@@ -98,18 +139,24 @@ export default function CodeReviewPage({
   // Fetch real Git diff and branch info from workspace
   const loadWorkspaceDiff = useCallback(async () => {
     if (!workspacePath) return
+    const request = ++diffRequest.current
+    setHistoryRevision(value => value + 1)
     setIsLoadingDiff(true)
     try {
       const [diffs, branch] = await Promise.all([
         workspacePlatform.getWorkspaceGitDiff(workspacePath),
         workspacePlatform.getGitBranchInfo(workspacePath).catch(() => null),
       ])
-      setWorkspaceDiffs(diffs || [])
+      if (workspaceRef.current !== workspacePath || request !== diffRequest.current) return
+      setWorkspaceDiffs((diffs || []).flatMap(change => {
+        const path = workspaceRelativePath(change.path, workspacePath)
+        return path ? [{ ...change, path }] : []
+      }))
       if (branch) setGitInfo(branch)
     } catch (e) {
       console.error('Failed to load workspace git diff:', e)
     } finally {
-      setIsLoadingDiff(false)
+      if (workspaceRef.current === workspacePath && request === diffRequest.current) setIsLoadingDiff(false)
     }
   }, [workspacePath])
 
@@ -117,18 +164,41 @@ export default function CodeReviewPage({
     loadWorkspaceDiff()
   }, [loadWorkspaceDiff])
 
+  const history = useWorkspaceUndo(workspacePath || '', historyRevision, () => { void loadWorkspaceDiff() })
+  useEffect(() => {
+    setConfirmation(null)
+    setHistorySelection('')
+    setUndoNotice('')
+    setUndonePaths(new Set())
+    setWorkspaceDiffs([])
+  }, [workspacePath])
+  const undoConfirmed = async () => {
+    if (!confirmation || confirmation.root !== workspacePath) return
+    if (await history.undo(confirmation.entry.id)) {
+      if (workspaceRef.current !== confirmation.root) return
+      setUndonePaths(previous => new Set([...previous,
+        workspaceRelativePath(confirmation.entry.path, confirmation.root) || '',
+        workspaceRelativePath(confirmation.entry.destination || '', confirmation.root) || '',
+      ]))
+      setDiffScope('workspace')
+      setUndoNotice(`Undone: ${confirmation.entry.label.replace(/^Undo /, '')}`)
+      setConfirmation(null)
+      void loadWorkspaceDiff()
+    }
+  }
+
   const activeChanges = useMemo(() => {
     if (diffScope === 'agent' && hasAgentChanges) {
-      return changes!
+      return agentChanges.filter(change => !undonePaths.has(change.path))
     }
     if (workspaceDiffs.length > 0) {
       return workspaceDiffs
     }
     if (hasAgentChanges) {
-      return changes!
+      return agentChanges.filter(change => !undonePaths.has(change.path))
     }
     return []
-  }, [diffScope, hasAgentChanges, changes, workspaceDiffs])
+  }, [diffScope, hasAgentChanges, agentChanges, workspaceDiffs, undonePaths])
 
   const filteredChanges = useMemo(() => {
     if (!filterQuery.trim()) return activeChanges
@@ -147,6 +217,15 @@ export default function CodeReviewPage({
   const currentIndex = Math.max(0, filteredChanges.findIndex((c) => c.path === selectedPath))
   const selectedChange = filteredChanges[currentIndex] || filteredChanges[0]
 
+  const selectedHistory = history.entries.find(entry => entry.id === historySelection) || history.entries[0]
+  const selectedFileHistory = selectedChange && history.entries.find(entry =>
+    workspaceRelativePath(entry.path, workspacePath) === selectedChange.path ||
+    workspaceRelativePath(entry.destination || '', workspacePath) === selectedChange.path)
+  const canUndoFile = Boolean(selectedFileHistory && selectedFileHistory.id === history.entries[0]?.id)
+  const requestUndo = (entry: WorkspaceHistoryEntry) => {
+    if (workspacePath) setConfirmation({ root: workspacePath, entry })
+  }
+
   const totalAdditions = activeChanges.reduce((sum, change) => sum + change.additions, 0)
   const totalDeletions = activeChanges.reduce((sum, change) => sum + change.deletions, 0)
 
@@ -374,6 +453,27 @@ export default function CodeReviewPage({
         </div>
       </header>
 
+      <div className="review-tabs" role="tablist" aria-label="Review views">
+        <button type="button" role="tab" id="review-changes-tab" aria-selected={tab === 'changes'} aria-controls="review-changes" onClick={() => setTab('changes')}>Changes</button>
+        <button type="button" role="tab" id="review-history-tab" aria-selected={tab === 'history'} aria-controls="review-history" onClick={() => setTab('history')}>File history ({history.entries.length})</button>
+      </div>
+      {history.error && <p className="review-feedback" role="alert">{history.error}</p>}
+      {undoNotice && <p className="review-feedback" role="status">{undoNotice}</p>}
+      {tab === 'history' && <section id="review-history" role="tabpanel" aria-labelledby="review-history-tab" className="review-history-panel">
+        {!workspacePath ? <p>Select a workspace to view file history.</p> : history.loading && history.entries.length === 0 ? <p>Loading file history…</p> : history.entries.length === 0 ? <p>No saved file history in this workspace.</p> : <>
+          <label className="review-history-picker">Saved action
+            <SelectField aria-label="Saved action" value={selectedHistory?.id || ''} onValueChange={(nextValue) => setHistorySelection(nextValue)}>
+              {history.entries.map((entry, index) => <option key={entry.id} value={entry.id}>{index === 0 ? 'Latest · ' : ''}{entry.label.replace(/^Undo /, '')}</option>)}
+            </SelectField>
+          </label>
+          {selectedHistory && <>
+            <HistoryDetails entry={selectedHistory} />
+            <button type="button" className="review-undo-button" disabled={history.busy || selectedHistory.id !== history.entries[0]?.id} onClick={() => requestUndo(selectedHistory)}>Undo action…</button>
+            {selectedHistory.id !== history.entries[0]?.id && <p>Undo newer actions first. History is restored in reverse order.</p>}
+          </>}
+        </>}
+      </section>}
+      {tab === 'changes' && <div id="review-changes" role="tabpanel" aria-labelledby="review-changes-tab" className="review-changes-panel">
       {/* Large diff / status banner */}
       <div className="code-review-banner">
         <div className="code-review-banner-left">
@@ -396,7 +496,7 @@ export default function CodeReviewPage({
                 className={`code-review-scope-btn ${diffScope === 'agent' ? 'is-active' : ''}`}
                 onClick={() => setDiffScope('agent')}
               >
-                AI Edits ({changes?.length || 0})
+                AI Edits ({agentChanges.length})
               </button>
             </div>
           ) : (
@@ -455,6 +555,7 @@ export default function CodeReviewPage({
                 <span className="code-review-file-bar-path" title={selectedChange.path}>
                   {selectedChange.path}
                 </span>
+                <button type="button" className="review-undo-button" disabled={!canUndoFile || history.busy} title={canUndoFile ? selectedFileHistory?.label : selectedFileHistory ? 'Undo newer workspace actions first in File history.' : 'No saved undo action for this file.'} onClick={() => selectedFileHistory && requestUndo(selectedFileHistory)}>Undo edit…</button>
                 <span className="code-review-file-bar-stat-add">+{selectedChange.additions}</span>
                 <span className="code-review-file-bar-stat-del">-{selectedChange.deletions}</span>
               </div>
@@ -560,6 +661,8 @@ export default function CodeReviewPage({
           </aside>
         )}
       </div>
+      </div>}
+      {confirmation && confirmation.root === workspacePath && <UndoConfirmation entry={confirmation.entry} busy={history.busy} error={history.error} onCancel={() => setConfirmation(null)} onConfirm={() => { void undoConfirmed() }} />}
     </main>
   )
 }