diff --git a/.github/workflows/auto-assign.yml b/.github/workflows/auto-assign.yml
new file mode 100644
index 000000000..eb488911d
--- /dev/null
+++ b/.github/workflows/auto-assign.yml
@@ -0,0 +1,25 @@
+name: Auto Assign
+
+on:
+  issues:
+    types: [opened]
+  pull_request:
+    types: [opened]
+
+jobs:
+  assign:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Assign to pedramamini
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issueNumber = context.issue?.number || context.payload.pull_request?.number;
+            if (issueNumber) {
+              await github.rest.issues.addAssignees({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                assignees: ['pedramamini']
+              });
+            }
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 48ffebd79..a74899c05 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -14,6 +14,7 @@ Deep technical documentation for Maestro's architecture and design patterns. For
 - [Theme System](#theme-system)
 - [Settings Persistence](#settings-persistence)
 - [Claude Sessions API](#claude-sessions-api)
+- [Auto Run System](#auto-run-system)
 - [Error Handling Patterns](#error-handling-patterns)
 
 ---
@@ -92,7 +93,7 @@ React frontend with no direct Node.js access:
 | Directory | Purpose |
 |-----------|---------|
 | `components/` | React UI components |
-| `hooks/` | Custom React hooks (useSettings, useSessionManager, useFileExplorer) |
+| `hooks/` | Custom React hooks (useSettings, useSessionManager, useFileExplorer, useBatchProcessor) |
 | `services/` | IPC wrappers (git.ts, process.ts) |
 | `contexts/` | React contexts (LayerStackContext) |
 | `constants/` | Themes, shortcuts, modal priorities |
@@ -594,6 +595,187 @@ const unsubscribe = window.maestro.claude.onGlobalStatsUpdate((stats) => {
 
 ---
 
+## Auto Run System
+
+File-based document runner for automating multi-step tasks. Users configure a folder of markdown documents containing checkbox tasks that are processed sequentially by AI agents.
+
+### Component Architecture
+
+| Component | Purpose |
+|-----------|---------|
+| `AutoRun.tsx` | Main panel showing current document with edit/preview modes |
+| `AutoRunSetupModal.tsx` | First-time setup for selecting the Runner Docs folder |
+| `AutoRunDocumentSelector.tsx` | Dropdown for switching between markdown documents |
+| `BatchRunnerModal.tsx` | Configuration modal for multi-document batch execution |
+| `PlaybookNameModal.tsx` | Modal for naming saved playbook configurations |
+| `PlaybookDeleteConfirmModal.tsx` | Confirmation modal for playbook deletion |
+| `useBatchProcessor.ts` | Hook managing batch execution logic |
+
+### Data Types
+
+```typescript
+// Document entry in the batch run queue (supports duplicates)
+interface BatchDocumentEntry {
+  id: string;              // Unique ID for drag-drop and duplicates
+  filename: string;        // Document filename (without .md)
+  resetOnCompletion: boolean;  // Uncheck all boxes when done
+  isDuplicate: boolean;    // True if this is a duplicate entry
+}
+
+// Git worktree configuration for parallel work
+interface WorktreeConfig {
+  enabled: boolean;              // Whether to use a worktree
+  path: string;                  // Absolute path for the worktree
+  branchName: string;            // Branch name to use/create
+  createPROnCompletion: boolean; // Create PR when Auto Run finishes
+}
+
+// Configuration for starting a batch run
+interface BatchRunConfig {
+  documents: BatchDocumentEntry[];  // Ordered list of docs to run
+  prompt: string;                   // Agent prompt template
+  loopEnabled: boolean;             // Loop back to first doc when done
+  worktree?: WorktreeConfig;        // Optional worktree configuration
+}
+
+// Runtime batch processing state
+interface BatchRunState {
+  isRunning: boolean;
+  isStopping: boolean;
+  documents: string[];           // Document filenames in order
+  currentDocumentIndex: number;  // Which document we're on (0-based)
+  currentDocTasksTotal: number;
+  currentDocTasksCompleted: number;
+  totalTasksAcrossAllDocs: number;
+  completedTasksAcrossAllDocs: number;
+  loopEnabled: boolean;
+  loopIteration: number;         // How many times we've looped
+  folderPath: string;
+  worktreeActive: boolean;
+  worktreePath?: string;
+  worktreeBranch?: string;
+}
+
+// Saved playbook configuration
+interface Playbook {
+  id: string;
+  name: string;
+  createdAt: number;
+  updatedAt: number;
+  documents: PlaybookDocumentEntry[];
+  loopEnabled: boolean;
+  prompt: string;
+  worktreeSettings?: {
+    branchNameTemplate: string;
+    createPROnCompletion: boolean;
+  };
+}
+```
+
+### Session Fields
+
+Auto Run state is stored per-session:
+
+```typescript
+// In Session interface
+autoRunFolderPath?: string;      // Persisted folder path for Runner Docs
+autoRunSelectedFile?: string;     // Currently selected markdown filename
+autoRunMode?: 'edit' | 'preview'; // Current editing mode
+autoRunEditScrollPos?: number;    // Scroll position in edit mode
+autoRunPreviewScrollPos?: number; // Scroll position in preview mode
+autoRunCursorPosition?: number;   // Cursor position in edit mode
+batchRunnerPrompt?: string;       // Custom batch runner prompt
+batchRunnerPromptModifiedAt?: number;
+```
+
+### IPC Handlers
+
+```typescript
+// List markdown files in a directory
+'autorun:listDocs': (folderPath: string) => Promise<{ success, files, error? }>
+
+// Read a markdown document
+'autorun:readDoc': (folderPath: string, filename: string) => Promise<{ success, content, error? }>
+
+// Write a markdown document
+'autorun:writeDoc': (folderPath: string, filename: string, content: string) => Promise<{ success, error? }>
+
+// Save image to folder
+'autorun:saveImage': (folderPath: string, docName: string, base64Data: string, extension: string) =>
+  Promise<{ success, relativePath, error? }>
+
+// Delete image
+'autorun:deleteImage': (folderPath: string, relativePath: string) => Promise<{ success, error? }>
+
+// List images for a document
+'autorun:listImages': (folderPath: string, docName: string) => Promise<{ success, images, error? }>
+
+// Playbook CRUD operations
+'playbooks:list': (sessionId: string) => Promise<{ success, playbooks, error? }>
+'playbooks:create': (sessionId: string, playbook) => Promise<{ success, playbook, error? }>
+'playbooks:update': (sessionId: string, playbookId: string, updates) => Promise<{ success, playbook, error? }>
+'playbooks:delete': (sessionId: string, playbookId: string) => Promise<{ success, error? }>
+```
+
+### Git Worktree Integration
+
+When worktree is enabled, Auto Run operates in an isolated directory:
+
+```typescript
+// Check if worktree exists and get branch info
+'git:worktreeInfo': (worktreePath: string) => Promise<{
+  success: boolean;
+  exists: boolean;
+  isWorktree: boolean;
+  currentBranch?: string;
+  repoRoot?: string;
+}>
+
+// Create or reuse a worktree
+'git:worktreeSetup': (mainRepoCwd: string, worktreePath: string, branchName: string) => Promise<{
+  success: boolean;
+  created: boolean;
+  currentBranch: string;
+  branchMismatch: boolean;
+}>
+
+// Checkout a branch in a worktree
+'git:worktreeCheckout': (worktreePath: string, branchName: string, createIfMissing: boolean) => Promise<{
+  success: boolean;
+  hasUncommittedChanges: boolean;
+}>
+
+// Create PR from worktree branch
+'git:createPR': (worktreePath: string, baseBranch: string, title: string, body: string) => Promise<{
+  success: boolean;
+  prUrl?: string;
+}>
+```
+
+### Execution Flow
+
+1. **Setup**: User selects Runner Docs folder via `AutoRunSetupModal`
+2. **Document Selection**: Documents appear in `AutoRunDocumentSelector` dropdown
+3. **Editing**: `AutoRun` component provides edit/preview modes with auto-save (5s debounce)
+4. **Batch Configuration**: `BatchRunnerModal` allows ordering documents, enabling loop/reset, configuring worktree
+5. **Playbooks**: Save/load configurations for repeated batch runs
+6. **Execution**: `useBatchProcessor` hook processes documents sequentially
+7. **Progress**: RightPanel shows document and task-level progress
+
+### Write Queue Integration
+
+Without worktree mode, Auto Run tasks queue through the existing execution queue:
+- Auto Run tasks are marked as write operations (`readOnlyMode: false`)
+- Manual write messages queue behind Auto Run (sequential)
+- Read-only operations from other tabs can run in parallel
+
+With worktree mode:
+- Auto Run operates in a separate directory
+- No queue conflicts with main workspace
+- True parallelization enabled
+
+---
+
 ## Error Handling Patterns
 
 ### IPC Handlers (Main Process)
diff --git a/CLAUDE.md b/CLAUDE.md
index 3d925fbcc..723233308 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,7 +8,7 @@ Use these terms consistently in code, comments, and documentation:
 
 ### UI Components
 - **Left Bar** - Left sidebar with session list and groups (`SessionList.tsx`)
-- **Right Bar** - Right sidebar with Files, History, Scratchpad tabs (`RightPanel.tsx`)
+- **Right Bar** - Right sidebar with Files, History, Auto Run tabs (`RightPanel.tsx`)
 - **Main Window** - Center workspace (`MainPanel.tsx`)
   - **AI Terminal** - Main window in AI mode (interacting with AI agents)
   - **Command Terminal** - Main window in terminal/shell mode
@@ -172,7 +172,8 @@ interface Session {
   toolType: ToolType;           // 'claude-code' | 'aider' | 'terminal' | etc.
   state: SessionState;          // 'idle' | 'busy' | 'error' | 'connecting'
   inputMode: 'ai' | 'terminal'; // Which process receives input
-  cwd: string;                  // Working directory
+  cwd: string;                  // Current working directory (can change via cd)
+  projectRoot: string;          // Initial working directory (never changes, used for Claude session storage)
   aiPid: number;                // AI process ID
   terminalPid: number;          // Terminal process ID
   aiLogs: LogEntry[];           // AI output history
@@ -223,3 +224,59 @@ The `window.maestro` API exposes:
 ### Modal Escape Not Working
 1. Register with layer stack (don't handle Escape locally)
 2. Check priority is set correctly
+
+## Keyboard Shortcuts
+
+Key shortcuts for navigation and common actions. Full list available via `⌘+/` (Help).
+
+### Panel Navigation
+| Shortcut | Action |
+|----------|--------|
+| `⌥⌘←` | Toggle Left Panel |
+| `⌥⌘→` | Toggle Right Panel |
+| `⌘⇧F` | Go to Files Tab |
+| `⌘⇧H` | Go to History Tab |
+| `⌘⇧1` | Go to Auto Run Tab |
+
+### Session Management
+| Shortcut | Action |
+|----------|--------|
+| `⌘N` | New Agent |
+| `⌘[` / `⌘]` | Previous/Next Agent |
+| `⌥⌘1-0` | Jump to Session 1-10 |
+| `⌘⇧⌫` | Remove Agent |
+| `⌘⇧M` | Move Session to Group |
+
+### Tab Management (AI Mode)
+| Shortcut | Action |
+|----------|--------|
+| `⌘T` | New Tab |
+| `⌘W` | Close Tab |
+| `⌘⇧T` | Reopen Closed Tab |
+| `⌘1-9` | Go to Tab 1-9 |
+| `⌘0` | Go to Last Tab |
+| `⌥⌘T` | Tab Switcher |
+
+### Mode & Focus
+| Shortcut | Action |
+|----------|--------|
+| `⌘J` | Switch AI/Shell Mode |
+| `⌘.` | Focus Input Field |
+| `⌘⇧A` | Focus Left Panel |
+| `⌘R` | Toggle Read-Only Mode |
+| `⌘E` | Toggle Markdown Raw/Preview |
+
+### Git & System
+| Shortcut | Action |
+|----------|--------|
+| `⌘⇧D` | View Git Diff |
+| `⌘⇧G` | View Git Log |
+| `⌥⌘L` | System Log Viewer |
+| `⌥⌘P` | System Process Monitor |
+
+### Quick Access
+| Shortcut | Action |
+|----------|--------|
+| `⌘K` | Quick Actions |
+| `⌘,` | Open Settings |
+| `⌘/` | Show All Shortcuts |
diff --git a/README.md b/README.md
index 03fa444de..52884eb2e 100644
--- a/README.md
+++ b/README.md
@@ -63,7 +63,7 @@ Download the latest release for your platform from the [Releases](https://github
 - 🔀 **Git Integration** - Automatic git status, diff tracking, and workspace detection
 - 📁 **File Explorer** - Browse project files with syntax highlighting and markdown preview
 - 📋 **Session Management** - Group, rename, bookmark, and organize your sessions
-- 📝 **Scratchpad** - Built-in markdown editor with live preview for task management
+- 📝 **Auto Run** - File-system-based document runner for automated task management with playbooks
 - ⚡ **Slash Commands** - Extensible command system with autocomplete
 - 📬 **Message Queueing** - Queue messages while AI is busy; they're sent automatically when ready
 - 🌐 **Mobile Remote Control** - Access agents from your phone with QR codes, live agents, and a mobile-optimized web interface
@@ -133,9 +133,9 @@ Each session shows a color-coded status indicator:
 |--------|-------|---------------|
 | Go to Files Tab | `Cmd+Shift+F` | `Ctrl+Shift+F` |
 | Go to History Tab | `Cmd+Shift+H` | `Ctrl+Shift+H` |
-| Go to Scratchpad | `Cmd+Shift+S` | `Ctrl+Shift+S` |
+| Go to Auto Run Tab | `Cmd+Shift+1` | `Ctrl+Shift+1` |
 | Toggle Markdown Raw/Preview | `Cmd+E` | `Ctrl+E` |
-| Insert Checkbox (Scratchpad) | `Cmd+L` | `Ctrl+L` |
+| Insert Checkbox (Auto Run) | `Cmd+L` | `Ctrl+L` |
 
 ### Input & Output
 
@@ -238,15 +238,23 @@ Summarize what I worked on yesterday and suggest priorities for today.
 
 See the full list of available variables in the **Template Variables** section within the Custom AI Commands panel.
 
-## Automatic Runner
+## Auto Run
 
-The Automatic Runner lets you batch-process tasks using AI agents. Define your tasks as markdown checkboxes in the Scratchpad, and Maestro will work through them one by one, spawning a fresh AI session for each task.
+Auto Run is a file-system-based document runner that lets you batch-process tasks using AI agents. Select a folder containing markdown documents with task checkboxes, and Maestro will work through them one by one, spawning a fresh AI session for each task.
+
+### Setting Up Auto Run
+
+1. Navigate to the **Auto Run** tab in the right panel (`Cmd+Shift+1`)
+2. Select a folder containing your markdown task documents
+3. Each `.md` file becomes a selectable document
 
 ### Creating Tasks
 
-Use markdown checkboxes in the Scratchpad tab:
+Use markdown checkboxes in your documents:
 
 ```markdown
+# Feature Implementation Plan
+
 - [ ] Implement user authentication
 - [ ] Add unit tests for the login flow
 - [ ] Update API documentation
@@ -254,16 +262,51 @@ Use markdown checkboxes in the Scratchpad tab:
 
 **Tip**: Press `Cmd+L` (Mac) or `Ctrl+L` (Windows/Linux) to quickly insert a new checkbox at your cursor position.
 
-### Running the Automation
+### Running Single Documents
+
+1. Select a document from the dropdown
+2. Click the **Run** button (or the ▶ icon)
+3. Customize the agent prompt if needed, then click **Go**
+
+### Multi-Document Batch Runs
+
+Auto Run supports running multiple documents in sequence:
+
+1. Click **Run** to open the Batch Runner Modal
+2. Click **+ Add Docs** to add more documents to the queue
+3. Drag to reorder documents as needed
+4. Configure options per document:
+   - **Reset on Completion** - Uncheck all boxes when document completes (for repeatable tasks)
+   - **Duplicate** - Add the same document multiple times
+5. Enable **Loop Mode** to cycle back to the first document after completing the last
+6. Click **Go** to start the batch run
+
+### Playbooks
 
-1. Navigate to the **Scratchpad** tab in the right panel
-2. Add your tasks as unchecked markdown checkboxes (`- [ ]`)
-3. Click the **Run** button (or the ▶ icon)
-4. Customize the agent prompt if needed, then click **Go**
+Save your batch configurations for reuse:
+
+1. Configure your documents, order, and options
+2. Click **Save as Playbook** and enter a name
+3. Load saved playbooks from the **Load Playbook** dropdown
+4. Update or discard changes to loaded playbooks
+
+### Git Worktree Support
+
+For parallel work without file conflicts:
+
+1. Enable **Worktree** in the Batch Runner Modal
+2. Specify a worktree path and branch name
+3. Auto Run operates in the isolated worktree
+4. Optionally create a PR when the batch completes
+
+Without a worktree, Auto Run queues with other write operations to prevent conflicts.
+
+### Progress Tracking
 
 The runner will:
 - Process tasks serially from top to bottom
-- Spawn a fresh AI session for each task
+- Skip documents with no unchecked tasks
+- Show progress: "Document X of Y" and "Task X of Y"
 - Mark tasks as complete (`- [x]`) when done
 - Log each completion to the **History** panel
 
@@ -280,11 +323,13 @@ Each completed task is logged to the History panel with:
 - `Enter` - View full response
 - `Esc` - Close detail view and return to list
 
-### Read-Only Mode
+### Auto-Save
+
+Documents auto-save after 5 seconds of inactivity, and immediately when switching documents. Full undo/redo support with `Cmd+Z` / `Cmd+Shift+Z`.
 
-While automation is running, the AI operates in **read-only/plan mode**. You can still send messages to review progress, but the agent won't make changes. This prevents conflicts between manual interactions and automated tasks.
+### Image Support
 
-The input area shows a **READ-ONLY** indicator with a warning-tinted background during automation.
+Paste images directly into your documents. Images are saved to an `images/` subfolder with relative paths for portability.
 
 ### Stopping the Runner
 
@@ -295,7 +340,7 @@ Click the **Stop** button at any time. The runner will:
 
 ### Parallel Batches
 
-You can run separate batch processes in different Maestro sessions simultaneously. Each session maintains its own independent batch state.
+You can run separate batch processes in different Maestro sessions simultaneously. Each session maintains its own independent batch state. With Git worktrees enabled, you can work on the main branch while Auto Run operates in an isolated worktree.
 
 ## Configuration
 
diff --git a/src/main/index.ts b/src/main/index.ts
index 42303423b..a88cf757b 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -1,5 +1,7 @@
 import { app, BrowserWindow, ipcMain, dialog, shell } from 'electron';
 import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
 import fs from 'fs/promises';
 import { ProcessManager } from './process-manager';
 import { WebServer } from './web-server';
@@ -698,6 +700,10 @@ function setupIpcHandlers() {
   });
 
   ipcMain.handle('sessions:setAll', async (_, sessions: any[]) => {
+    // Debug: log autoRunFolderPath values received from renderer
+    const autoRunPaths = sessions.map((s: any) => ({ id: s.id, name: s.name, autoRunFolderPath: s.autoRunFolderPath }));
+    logger.debug('[Sessions:setAll] Received sessions with autoRunFolderPaths:', 'Sessions', autoRunPaths);
+
     // Get previous sessions to detect changes
     const previousSessions = sessionsStore.get('sessions', []);
     const previousSessionMap = new Map(previousSessions.map((s: any) => [s.id, s]));
@@ -742,6 +748,12 @@ function setupIpcHandlers() {
     }
 
     sessionsStore.set('sessions', sessions);
+
+    // Debug: verify what was stored
+    const storedSessions = sessionsStore.get('sessions', []);
+    const storedAutoRunPaths = storedSessions.map((s: any) => ({ id: s.id, name: s.name, autoRunFolderPath: s.autoRunFolderPath }));
+    logger.debug('[Sessions:setAll] After store, autoRunFolderPaths:', 'Sessions', storedAutoRunPaths);
+
     return true;
   });
 
@@ -1129,7 +1141,293 @@ function setupIpcHandlers() {
     }
   });
 
+  // Git worktree operations for Auto Run parallelization
+
+  // Get information about a worktree at a given path
+  ipcMain.handle('git:worktreeInfo', async (_, worktreePath: string) => {
+    try {
+      // Check if the path exists
+      try {
+        await fs.access(worktreePath);
+      } catch {
+        return { success: true, exists: false, isWorktree: false };
+      }
+
+      // Check if it's a git directory (could be main repo or worktree)
+      const isInsideWorkTree = await execFileNoThrow('git', ['rev-parse', '--is-inside-work-tree'], worktreePath);
+      if (isInsideWorkTree.exitCode !== 0) {
+        return { success: true, exists: true, isWorktree: false };
+      }
+
+      // Get the git directory path
+      const gitDirResult = await execFileNoThrow('git', ['rev-parse', '--git-dir'], worktreePath);
+      if (gitDirResult.exitCode !== 0) {
+        return { success: false, error: 'Failed to get git directory' };
+      }
+      const gitDir = gitDirResult.stdout.trim();
+
+      // A worktree's .git is a file pointing to the main repo, not a directory
+      // Check if this is a worktree by looking for .git file (not directory) or checking git-common-dir
+      const gitCommonDirResult = await execFileNoThrow('git', ['rev-parse', '--git-common-dir'], worktreePath);
+      const gitCommonDir = gitCommonDirResult.exitCode === 0 ? gitCommonDirResult.stdout.trim() : gitDir;
+
+      // If git-dir and git-common-dir are different, this is a worktree
+      const isWorktree = gitDir !== gitCommonDir;
+
+      // Get the current branch
+      const branchResult = await execFileNoThrow('git', ['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+      const currentBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : undefined;
+
+      // Get the repository root (of the main repository)
+      const repoRootResult = await execFileNoThrow('git', ['rev-parse', '--show-toplevel'], worktreePath);
+      let repoRoot: string | undefined;
+
+      if (isWorktree && gitCommonDir) {
+        // For worktrees, we need to find the main repo root from the common dir
+        // The common dir points to the .git folder of the main repo
+        // The main repo root is the parent of the .git folder
+        const path = require('path');
+        const commonDirAbs = path.isAbsolute(gitCommonDir)
+          ? gitCommonDir
+          : path.resolve(worktreePath, gitCommonDir);
+        repoRoot = path.dirname(commonDirAbs);
+      } else if (repoRootResult.exitCode === 0) {
+        repoRoot = repoRootResult.stdout.trim();
+      }
+
+      return {
+        success: true,
+        exists: true,
+        isWorktree,
+        currentBranch,
+        repoRoot
+      };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
+  // Get the root directory of the git repository
+  ipcMain.handle('git:getRepoRoot', async (_, cwd: string) => {
+    try {
+      const result = await execFileNoThrow('git', ['rev-parse', '--show-toplevel'], cwd);
+      if (result.exitCode !== 0) {
+        return { success: false, error: result.stderr || 'Not a git repository' };
+      }
+      return { success: true, root: result.stdout.trim() };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
+  // Create or reuse a worktree
+  ipcMain.handle('git:worktreeSetup', async (_, mainRepoCwd: string, worktreePath: string, branchName: string) => {
+    try {
+      const path = require('path');
+
+      // First check if the worktree path already exists
+      let pathExists = true;
+      try {
+        await fs.access(worktreePath);
+      } catch {
+        pathExists = false;
+      }
+
+      if (pathExists) {
+        // Check if it's already a worktree of this repo
+        const worktreeInfoResult = await execFileNoThrow('git', ['rev-parse', '--is-inside-work-tree'], worktreePath);
+        if (worktreeInfoResult.exitCode !== 0) {
+          return { success: false, error: 'Path exists but is not a git worktree or repository' };
+        }
+
+        // Get the common dir to check if it's the same repo
+        const gitCommonDirResult = await execFileNoThrow('git', ['rev-parse', '--git-common-dir'], worktreePath);
+        const mainGitDirResult = await execFileNoThrow('git', ['rev-parse', '--git-dir'], mainRepoCwd);
+
+        if (gitCommonDirResult.exitCode === 0 && mainGitDirResult.exitCode === 0) {
+          const worktreeCommonDir = path.resolve(worktreePath, gitCommonDirResult.stdout.trim());
+          const mainGitDir = path.resolve(mainRepoCwd, mainGitDirResult.stdout.trim());
+
+          // Normalize paths for comparison
+          const normalizedWorktreeCommon = path.normalize(worktreeCommonDir);
+          const normalizedMainGit = path.normalize(mainGitDir);
+
+          if (normalizedWorktreeCommon !== normalizedMainGit) {
+            return { success: false, error: 'Worktree path belongs to a different repository' };
+          }
+        }
+
+        // Get current branch in the existing worktree
+        const currentBranchResult = await execFileNoThrow('git', ['rev-parse', '--abbrev-ref', 'HEAD'], worktreePath);
+        const currentBranch = currentBranchResult.exitCode === 0 ? currentBranchResult.stdout.trim() : '';
+
+        return {
+          success: true,
+          created: false,
+          currentBranch,
+          requestedBranch: branchName,
+          branchMismatch: currentBranch !== branchName && branchName !== ''
+        };
+      }
+
+      // Worktree doesn't exist, create it
+      // First check if the branch exists
+      const branchExistsResult = await execFileNoThrow('git', ['rev-parse', '--verify', branchName], mainRepoCwd);
+      const branchExists = branchExistsResult.exitCode === 0;
+
+      let createResult;
+      if (branchExists) {
+        // Branch exists, just add worktree pointing to it
+        createResult = await execFileNoThrow('git', ['worktree', 'add', worktreePath, branchName], mainRepoCwd);
+      } else {
+        // Branch doesn't exist, create it with -b flag
+        createResult = await execFileNoThrow('git', ['worktree', 'add', '-b', branchName, worktreePath], mainRepoCwd);
+      }
+
+      if (createResult.exitCode !== 0) {
+        return { success: false, error: createResult.stderr || 'Failed to create worktree' };
+      }
+
+      return {
+        success: true,
+        created: true,
+        currentBranch: branchName,
+        requestedBranch: branchName,
+        branchMismatch: false
+      };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
+  // Checkout a branch in a worktree (with uncommitted changes check)
+  ipcMain.handle('git:worktreeCheckout', async (_, worktreePath: string, branchName: string, createIfMissing: boolean) => {
+    try {
+      // Check for uncommitted changes
+      const statusResult = await execFileNoThrow('git', ['status', '--porcelain'], worktreePath);
+      if (statusResult.exitCode !== 0) {
+        return { success: false, hasUncommittedChanges: false, error: 'Failed to check git status' };
+      }
+
+      const hasUncommittedChanges = statusResult.stdout.trim().length > 0;
+      if (hasUncommittedChanges) {
+        return {
+          success: false,
+          hasUncommittedChanges: true,
+          error: 'Worktree has uncommitted changes. Please commit or stash them first.'
+        };
+      }
+
+      // Check if branch exists
+      const branchExistsResult = await execFileNoThrow('git', ['rev-parse', '--verify', branchName], worktreePath);
+      const branchExists = branchExistsResult.exitCode === 0;
+
+      let checkoutResult;
+      if (branchExists) {
+        checkoutResult = await execFileNoThrow('git', ['checkout', branchName], worktreePath);
+      } else if (createIfMissing) {
+        checkoutResult = await execFileNoThrow('git', ['checkout', '-b', branchName], worktreePath);
+      } else {
+        return { success: false, hasUncommittedChanges: false, error: `Branch '${branchName}' does not exist` };
+      }
+
+      if (checkoutResult.exitCode !== 0) {
+        return { success: false, hasUncommittedChanges: false, error: checkoutResult.stderr || 'Checkout failed' };
+      }
+
+      return { success: true, hasUncommittedChanges: false };
+    } catch (error) {
+      return { success: false, hasUncommittedChanges: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
+  // Create a PR from the worktree branch to a base branch
+  ipcMain.handle('git:createPR', async (_, worktreePath: string, baseBranch: string, title: string, body: string) => {
+    try {
+      // First, push the current branch to origin
+      const pushResult = await execFileNoThrow('git', ['push', '-u', 'origin', 'HEAD'], worktreePath);
+      if (pushResult.exitCode !== 0) {
+        return { success: false, error: `Failed to push branch: ${pushResult.stderr}` };
+      }
+
+      // Create the PR using gh CLI
+      const prResult = await execFileNoThrow('gh', [
+        'pr', 'create',
+        '--base', baseBranch,
+        '--title', title,
+        '--body', body
+      ], worktreePath);
+
+      if (prResult.exitCode !== 0) {
+        // Check if gh CLI is not installed
+        if (prResult.stderr.includes('command not found') || prResult.stderr.includes('not recognized')) {
+          return { success: false, error: 'GitHub CLI (gh) is not installed. Please install it to create PRs.' };
+        }
+        return { success: false, error: prResult.stderr || 'Failed to create PR' };
+      }
+
+      // The PR URL is typically in stdout
+      const prUrl = prResult.stdout.trim();
+      return { success: true, prUrl };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
+  // Check if GitHub CLI (gh) is installed and authenticated
+  ipcMain.handle('git:checkGhCli', async () => {
+    try {
+      // Check if gh is installed by running gh --version
+      const versionResult = await execFileNoThrow('gh', ['--version']);
+      if (versionResult.exitCode !== 0) {
+        return { installed: false, authenticated: false };
+      }
+
+      // Check if gh is authenticated by running gh auth status
+      const authResult = await execFileNoThrow('gh', ['auth', 'status']);
+      const authenticated = authResult.exitCode === 0;
+
+      return { installed: true, authenticated };
+    } catch {
+      return { installed: false, authenticated: false };
+    }
+  });
+
+  // Get the default branch name (main or master)
+  ipcMain.handle('git:getDefaultBranch', async (_, cwd: string) => {
+    try {
+      // First try to get the default branch from remote
+      const remoteResult = await execFileNoThrow('git', ['remote', 'show', 'origin'], cwd);
+      if (remoteResult.exitCode === 0) {
+        // Parse "HEAD branch: main" from the output
+        const match = remoteResult.stdout.match(/HEAD branch:\s*(\S+)/);
+        if (match) {
+          return { success: true, branch: match[1] };
+        }
+      }
+
+      // Fallback: check if main or master exists locally
+      const mainResult = await execFileNoThrow('git', ['rev-parse', '--verify', 'main'], cwd);
+      if (mainResult.exitCode === 0) {
+        return { success: true, branch: 'main' };
+      }
+
+      const masterResult = await execFileNoThrow('git', ['rev-parse', '--verify', 'master'], cwd);
+      if (masterResult.exitCode === 0) {
+        return { success: true, branch: 'master' };
+      }
+
+      return { success: false, error: 'Could not determine default branch' };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+  });
+
   // File system operations
+  ipcMain.handle('fs:homeDir', () => {
+    return os.homedir();
+  });
+
   ipcMain.handle('fs:readDir', async (_, dirPath: string) => {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
     // Convert Dirent objects to plain objects for IPC serialization
@@ -2924,23 +3222,40 @@ function setupIpcHandlers() {
 
   // Get all named sessions across all projects (for Tab Switcher "All Named" view)
   ipcMain.handle('claude:getAllNamedSessions', async () => {
+    const os = await import('os');
+    const homeDir = os.default.homedir();
+    const claudeProjectsDir = path.join(homeDir, '.claude', 'projects');
+
     const allOrigins = claudeSessionOriginsStore.get('origins', {});
     const namedSessions: Array<{
       claudeSessionId: string;
       projectPath: string;
       sessionName: string;
       starred?: boolean;
+      lastActivityAt?: number;
     }> = [];
 
     for (const [projectPath, sessions] of Object.entries(allOrigins)) {
       for (const [claudeSessionId, info] of Object.entries(sessions)) {
         // Handle both old string format and new object format
         if (typeof info === 'object' && info.sessionName) {
+          // Try to get last activity time from the session file
+          let lastActivityAt: number | undefined;
+          try {
+            const encodedPath = encodeClaudeProjectPath(projectPath);
+            const sessionFile = path.join(claudeProjectsDir, encodedPath, `${claudeSessionId}.jsonl`);
+            const stats = await fs.stat(sessionFile);
+            lastActivityAt = stats.mtime.getTime();
+          } catch {
+            // Session file may not exist or be inaccessible
+          }
+
           namedSessions.push({
             claudeSessionId,
             projectPath,
             sessionName: info.sessionName,
             starred: info.starred,
+            lastActivityAt,
           });
         }
       }
@@ -3209,13 +3524,526 @@ function setupIpcHandlers() {
     const attachmentsDir = path.join(userDataPath, 'attachments', sessionId);
     return { success: true, path: attachmentsDir };
   });
+
+  // ============================================
+  // Auto Run IPC Handlers
+  // ============================================
+
+  // List markdown files in a directory for Auto Run (with recursive subfolder support)
+  ipcMain.handle('autorun:listDocs', async (_event, folderPath: string) => {
+    try {
+      // Validate the folder path exists
+      const folderStat = await fs.stat(folderPath);
+      if (!folderStat.isDirectory()) {
+        return { success: false, files: [], tree: [], error: 'Path is not a directory' };
+      }
+
+      // Recursive function to build tree structure
+      interface TreeNode {
+        name: string;
+        type: 'file' | 'folder';
+        path: string;  // Relative path from root folder
+        children?: TreeNode[];
+      }
+
+      const scanDirectory = async (dirPath: string, relativePath: string = ''): Promise<TreeNode[]> => {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const nodes: TreeNode[] = [];
+
+        // Sort entries: folders first, then files, both alphabetically
+        const sortedEntries = entries
+          .filter(entry => !entry.name.startsWith('.'))
+          .sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) return -1;
+            if (!a.isDirectory() && b.isDirectory()) return 1;
+            return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+          });
+
+        for (const entry of sortedEntries) {
+          const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+          if (entry.isDirectory()) {
+            // Recursively scan subdirectory
+            const children = await scanDirectory(path.join(dirPath, entry.name), entryRelativePath);
+            // Only include folders that contain .md files (directly or in subfolders)
+            if (children.length > 0) {
+              nodes.push({
+                name: entry.name,
+                type: 'folder',
+                path: entryRelativePath,
+                children
+              });
+            }
+          } else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+            // Add .md file (without extension in name, but keep in path)
+            nodes.push({
+              name: entry.name.slice(0, -3),
+              type: 'file',
+              path: entryRelativePath.slice(0, -3)  // Remove .md from path too
+            });
+          }
+        }
+
+        return nodes;
+      };
+
+      const tree = await scanDirectory(folderPath);
+
+      // Also build flat list for backwards compatibility
+      const flattenTree = (nodes: TreeNode[]): string[] => {
+        const files: string[] = [];
+        for (const node of nodes) {
+          if (node.type === 'file') {
+            files.push(node.path);
+          } else if (node.children) {
+            files.push(...flattenTree(node.children));
+          }
+        }
+        return files;
+      };
+
+      const files = flattenTree(tree);
+
+      logger.info(`Listed ${files.length} markdown files in ${folderPath} (with subfolders)`, 'AutoRun');
+      return { success: true, files, tree };
+    } catch (error) {
+      logger.error('Error listing Auto Run docs', 'AutoRun', error);
+      return { success: false, files: [], tree: [], error: String(error) };
+    }
+  });
+
+  // Read a markdown document for Auto Run (supports subdirectories)
+  ipcMain.handle(
+    'autorun:readDoc',
+    async (_event, folderPath: string, filename: string) => {
+      try {
+        // Reject obvious traversal attempts
+        if (filename.includes('..')) {
+          return { success: false, content: '', error: 'Invalid filename' };
+        }
+
+        // Ensure filename has .md extension
+        const fullFilename = filename.endsWith('.md')
+          ? filename
+          : `${filename}.md`;
+
+        const filePath = path.join(folderPath, fullFilename);
+
+        // Validate the file is within the folder path (prevent traversal)
+        const resolvedPath = path.resolve(filePath);
+        const resolvedFolder = path.resolve(folderPath);
+        if (!resolvedPath.startsWith(resolvedFolder + path.sep) && resolvedPath !== resolvedFolder) {
+          return { success: false, content: '', error: 'Invalid file path' };
+        }
+
+        // Check if file exists
+        try {
+          await fs.access(filePath);
+        } catch {
+          return { success: false, content: '', error: 'File not found' };
+        }
+
+        // Read the file
+        const content = await fs.readFile(filePath, 'utf-8');
+
+        logger.info(`Read Auto Run doc: ${fullFilename}`, 'AutoRun');
+        return { success: true, content };
+      } catch (error) {
+        logger.error('Error reading Auto Run doc', 'AutoRun', error);
+        return { success: false, content: '', error: String(error) };
+      }
+    }
+  );
+
+  // Write a markdown document for Auto Run (supports subdirectories)
+  ipcMain.handle(
+    'autorun:writeDoc',
+    async (_event, folderPath: string, filename: string, content: string) => {
+      try {
+        // Reject obvious traversal attempts
+        if (filename.includes('..')) {
+          return { success: false, error: 'Invalid filename' };
+        }
+
+        // Ensure filename has .md extension
+        const fullFilename = filename.endsWith('.md')
+          ? filename
+          : `${filename}.md`;
+
+        const filePath = path.join(folderPath, fullFilename);
+
+        // Validate the file is within the folder path (prevent traversal)
+        const resolvedPath = path.resolve(filePath);
+        const resolvedFolder = path.resolve(folderPath);
+        if (!resolvedPath.startsWith(resolvedFolder + path.sep) && resolvedPath !== resolvedFolder) {
+          return { success: false, error: 'Invalid file path' };
+        }
+
+        // Ensure the parent directory exists (create if needed for subdirectories)
+        const parentDir = path.dirname(filePath);
+        try {
+          await fs.access(parentDir);
+        } catch {
+          // Parent dir doesn't exist - create it if it's within folderPath
+          const resolvedParent = path.resolve(parentDir);
+          if (resolvedParent.startsWith(resolvedFolder)) {
+            await fs.mkdir(parentDir, { recursive: true });
+          } else {
+            return { success: false, error: 'Invalid parent directory' };
+          }
+        }
+
+        // Write the file
+        await fs.writeFile(filePath, content, 'utf-8');
+
+        logger.info(`Wrote Auto Run doc: ${fullFilename}`, 'AutoRun');
+        return { success: true };
+      } catch (error) {
+        logger.error('Error writing Auto Run doc', 'AutoRun', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // Save image to Auto Run folder
+  ipcMain.handle(
+    'autorun:saveImage',
+    async (
+      _event,
+      folderPath: string,
+      docName: string,
+      base64Data: string,
+      extension: string
+    ) => {
+      try {
+        // Sanitize docName to prevent directory traversal
+        const sanitizedDocName = path.basename(docName).replace(/\.md$/i, '');
+        if (sanitizedDocName.includes('..') || sanitizedDocName.includes('/')) {
+          return { success: false, error: 'Invalid document name' };
+        }
+
+        // Validate extension (only allow common image formats)
+        const allowedExtensions = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'];
+        const sanitizedExtension = extension.toLowerCase().replace(/[^a-z]/g, '');
+        if (!allowedExtensions.includes(sanitizedExtension)) {
+          return { success: false, error: 'Invalid image extension' };
+        }
+
+        // Create images subdirectory if it doesn't exist
+        const imagesDir = path.join(folderPath, 'images');
+        try {
+          await fs.mkdir(imagesDir, { recursive: true });
+        } catch {
+          // Directory might already exist, that's fine
+        }
+
+        // Generate filename: {docName}-{timestamp}.{ext}
+        const timestamp = Date.now();
+        const filename = `${sanitizedDocName}-${timestamp}.${sanitizedExtension}`;
+        const filePath = path.join(imagesDir, filename);
+
+        // Validate the file is within the folder path (prevent traversal)
+        const resolvedPath = path.resolve(filePath);
+        const resolvedFolder = path.resolve(folderPath);
+        if (!resolvedPath.startsWith(resolvedFolder)) {
+          return { success: false, error: 'Invalid file path' };
+        }
+
+        // Decode and write the image
+        const buffer = Buffer.from(base64Data, 'base64');
+        await fs.writeFile(filePath, buffer);
+
+        // Return the relative path for markdown insertion
+        const relativePath = `images/${filename}`;
+        logger.info(`Saved Auto Run image: ${relativePath}`, 'AutoRun');
+        return { success: true, relativePath };
+      } catch (error) {
+        logger.error('Error saving Auto Run image', 'AutoRun', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // Delete image from Auto Run folder
+  ipcMain.handle(
+    'autorun:deleteImage',
+    async (_event, folderPath: string, relativePath: string) => {
+      try {
+        // Sanitize relativePath to prevent directory traversal
+        const normalizedPath = path.normalize(relativePath);
+        if (
+          normalizedPath.includes('..') ||
+          path.isAbsolute(normalizedPath) ||
+          !normalizedPath.startsWith('images/')
+        ) {
+          return { success: false, error: 'Invalid image path' };
+        }
+
+        const filePath = path.join(folderPath, normalizedPath);
+
+        // Validate the file is within the folder path (prevent traversal)
+        const resolvedPath = path.resolve(filePath);
+        const resolvedFolder = path.resolve(folderPath);
+        if (!resolvedPath.startsWith(resolvedFolder)) {
+          return { success: false, error: 'Invalid file path' };
+        }
+
+        // Check if file exists
+        try {
+          await fs.access(filePath);
+        } catch {
+          return { success: false, error: 'Image file not found' };
+        }
+
+        // Delete the file
+        await fs.unlink(filePath);
+        logger.info(`Deleted Auto Run image: ${relativePath}`, 'AutoRun');
+        return { success: true };
+      } catch (error) {
+        logger.error('Error deleting Auto Run image', 'AutoRun', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // List images for a document (by prefix match)
+  ipcMain.handle(
+    'autorun:listImages',
+    async (_event, folderPath: string, docName: string) => {
+      try {
+        // Sanitize docName to prevent directory traversal
+        const sanitizedDocName = path.basename(docName).replace(/\.md$/i, '');
+        if (sanitizedDocName.includes('..') || sanitizedDocName.includes('/')) {
+          return { success: false, error: 'Invalid document name' };
+        }
+
+        const imagesDir = path.join(folderPath, 'images');
+
+        // Check if images directory exists
+        try {
+          await fs.access(imagesDir);
+        } catch {
+          // No images directory means no images
+          return { success: true, images: [] };
+        }
+
+        // Read directory contents
+        const files = await fs.readdir(imagesDir);
+
+        // Filter files that start with the docName prefix
+        const imageExtensions = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'];
+        const images = files
+          .filter((file) => {
+            // Check if filename starts with docName-
+            if (!file.startsWith(`${sanitizedDocName}-`)) {
+              return false;
+            }
+            // Check if it has a valid image extension
+            const ext = file.split('.').pop()?.toLowerCase();
+            return ext && imageExtensions.includes(ext);
+          })
+          .map((file) => ({
+            filename: file,
+            relativePath: `images/${file}`,
+          }));
+
+        return { success: true, images };
+      } catch (error) {
+        logger.error('Error listing Auto Run images', 'AutoRun', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // ============================================
+  // Playbook IPC Handlers
+  // ============================================
+
+  // Helper: Get path to playbooks file for a session
+  function getPlaybooksFilePath(sessionId: string): string {
+    const userDataPath = app.getPath('userData');
+    return path.join(userDataPath, 'playbooks', `${sessionId}.json`);
+  }
+
+  // Helper: Read playbooks from file
+  async function readPlaybooks(sessionId: string): Promise<any[]> {
+    const filePath = getPlaybooksFilePath(sessionId);
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const data = JSON.parse(content);
+      return Array.isArray(data.playbooks) ? data.playbooks : [];
+    } catch {
+      // File doesn't exist or is invalid, return empty array
+      return [];
+    }
+  }
+
+  // Helper: Write playbooks to file
+  async function writePlaybooks(sessionId: string, playbooks: any[]): Promise<void> {
+    const filePath = getPlaybooksFilePath(sessionId);
+    const dir = path.dirname(filePath);
+
+    // Ensure the playbooks directory exists
+    await fs.mkdir(dir, { recursive: true });
+
+    // Write the playbooks file
+    await fs.writeFile(filePath, JSON.stringify({ playbooks }, null, 2), 'utf-8');
+  }
+
+  // List all playbooks for a session
+  ipcMain.handle('playbooks:list', async (_event, sessionId: string) => {
+    try {
+      const playbooks = await readPlaybooks(sessionId);
+      logger.info(`Listed ${playbooks.length} playbooks for session ${sessionId}`, 'Playbooks');
+      return { success: true, playbooks };
+    } catch (error) {
+      logger.error('Error listing playbooks', 'Playbooks', error);
+      return { success: false, playbooks: [], error: String(error) };
+    }
+  });
+
+  // Create a new playbook
+  ipcMain.handle(
+    'playbooks:create',
+    async (
+      _event,
+      sessionId: string,
+      playbook: {
+        name: string;
+        documents: any[];
+        loopEnabled: boolean;
+        prompt: string;
+        worktreeSettings?: {
+          branchNameTemplate: string;
+          createPROnCompletion: boolean;
+          prTargetBranch?: string;
+        };
+      }
+    ) => {
+      try {
+        const playbooks = await readPlaybooks(sessionId);
+
+        // Create new playbook with generated ID and timestamps
+        const now = Date.now();
+        const newPlaybook: {
+          id: string;
+          name: string;
+          createdAt: number;
+          updatedAt: number;
+          documents: any[];
+          loopEnabled: boolean;
+          prompt: string;
+          worktreeSettings?: {
+            branchNameTemplate: string;
+            createPROnCompletion: boolean;
+            prTargetBranch?: string;
+          };
+        } = {
+          id: crypto.randomUUID(),
+          name: playbook.name,
+          createdAt: now,
+          updatedAt: now,
+          documents: playbook.documents,
+          loopEnabled: playbook.loopEnabled,
+          prompt: playbook.prompt,
+        };
+
+        // Include worktree settings if provided
+        if (playbook.worktreeSettings) {
+          newPlaybook.worktreeSettings = playbook.worktreeSettings;
+        }
+
+        // Add to list and save
+        playbooks.push(newPlaybook);
+        await writePlaybooks(sessionId, playbooks);
+
+        logger.info(`Created playbook "${playbook.name}" for session ${sessionId}`, 'Playbooks');
+        return { success: true, playbook: newPlaybook };
+      } catch (error) {
+        logger.error('Error creating playbook', 'Playbooks', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // Update an existing playbook
+  ipcMain.handle(
+    'playbooks:update',
+    async (
+      _event,
+      sessionId: string,
+      playbookId: string,
+      updates: Partial<{
+        name: string;
+        documents: any[];
+        loopEnabled: boolean;
+        prompt: string;
+        updatedAt: number;
+        worktreeSettings?: {
+          branchNameTemplate: string;
+          createPROnCompletion: boolean;
+          prTargetBranch?: string;
+        };
+      }>
+    ) => {
+      try {
+        const playbooks = await readPlaybooks(sessionId);
+
+        // Find the playbook to update
+        const index = playbooks.findIndex((p: any) => p.id === playbookId);
+        if (index === -1) {
+          return { success: false, error: 'Playbook not found' };
+        }
+
+        // Update the playbook
+        const updatedPlaybook = {
+          ...playbooks[index],
+          ...updates,
+          updatedAt: Date.now(),
+        };
+        playbooks[index] = updatedPlaybook;
+
+        await writePlaybooks(sessionId, playbooks);
+
+        logger.info(`Updated playbook "${updatedPlaybook.name}" for session ${sessionId}`, 'Playbooks');
+        return { success: true, playbook: updatedPlaybook };
+      } catch (error) {
+        logger.error('Error updating playbook', 'Playbooks', error);
+        return { success: false, error: String(error) };
+      }
+    }
+  );
+
+  // Delete a playbook
+  ipcMain.handle('playbooks:delete', async (_event, sessionId: string, playbookId: string) => {
+    try {
+      const playbooks = await readPlaybooks(sessionId);
+
+      // Find the playbook to delete
+      const index = playbooks.findIndex((p: any) => p.id === playbookId);
+      if (index === -1) {
+        return { success: false, error: 'Playbook not found' };
+      }
+
+      const deletedName = playbooks[index].name;
+
+      // Remove from list and save
+      playbooks.splice(index, 1);
+      await writePlaybooks(sessionId, playbooks);
+
+      logger.info(`Deleted playbook "${deletedName}" from session ${sessionId}`, 'Playbooks');
+      return { success: true };
+    } catch (error) {
+      logger.error('Error deleting playbook', 'Playbooks', error);
+      return { success: false, error: String(error) };
+    }
+  });
 }
 
 // Handle process output streaming (set up after initialization)
 function setupProcessListeners() {
   if (processManager) {
     processManager.on('data', (sessionId: string, data: string) => {
-      console.log('[IPC] Forwarding process:data to renderer:', { sessionId, dataLength: data.length, hasMainWindow: !!mainWindow });
       mainWindow?.webContents.send('process:data', sessionId, data);
 
       // Broadcast to web clients - extract base session ID (remove -ai or -terminal suffix)
@@ -3283,7 +4111,6 @@ function setupProcessListeners() {
       totalCostUsd: number;
       contextWindow: number;
     }) => {
-      console.log('[IPC] Forwarding process:usage to renderer:', { sessionId, usageStats });
       mainWindow?.webContents.send('process:usage', sessionId, usageStats);
     });
   }
diff --git a/src/main/preload.ts b/src/main/preload.ts
index be04a3f3e..74def9077 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -219,10 +219,59 @@ contextBridge.exposeInMainWorld('maestro', {
     show: (cwd: string, hash: string) => ipcRenderer.invoke('git:show', cwd, hash),
     showFile: (cwd: string, ref: string, filePath: string) =>
       ipcRenderer.invoke('git:showFile', cwd, ref, filePath) as Promise<{ content?: string; error?: string }>,
+    // Git worktree operations for Auto Run parallelization
+    worktreeInfo: (worktreePath: string) =>
+      ipcRenderer.invoke('git:worktreeInfo', worktreePath) as Promise<{
+        success: boolean;
+        exists?: boolean;
+        isWorktree?: boolean;
+        currentBranch?: string;
+        repoRoot?: string;
+        error?: string;
+      }>,
+    getRepoRoot: (cwd: string) =>
+      ipcRenderer.invoke('git:getRepoRoot', cwd) as Promise<{
+        success: boolean;
+        root?: string;
+        error?: string;
+      }>,
+    worktreeSetup: (mainRepoCwd: string, worktreePath: string, branchName: string) =>
+      ipcRenderer.invoke('git:worktreeSetup', mainRepoCwd, worktreePath, branchName) as Promise<{
+        success: boolean;
+        created?: boolean;
+        currentBranch?: string;
+        requestedBranch?: string;
+        branchMismatch?: boolean;
+        error?: string;
+      }>,
+    worktreeCheckout: (worktreePath: string, branchName: string, createIfMissing: boolean) =>
+      ipcRenderer.invoke('git:worktreeCheckout', worktreePath, branchName, createIfMissing) as Promise<{
+        success: boolean;
+        hasUncommittedChanges: boolean;
+        error?: string;
+      }>,
+    createPR: (worktreePath: string, baseBranch: string, title: string, body: string) =>
+      ipcRenderer.invoke('git:createPR', worktreePath, baseBranch, title, body) as Promise<{
+        success: boolean;
+        prUrl?: string;
+        error?: string;
+      }>,
+    getDefaultBranch: (cwd: string) =>
+      ipcRenderer.invoke('git:getDefaultBranch', cwd) as Promise<{
+        success: boolean;
+        branch?: string;
+        error?: string;
+      }>,
+    checkGhCli: () =>
+      ipcRenderer.invoke('git:checkGhCli') as Promise<{
+        installed: boolean;
+        authenticated: boolean;
+      }>,
   },
 
   // File System API
   fs: {
+    homeDir: () => ipcRenderer.invoke('fs:homeDir') as Promise<string>,
     readDir: (dirPath: string) => ipcRenderer.invoke('fs:readDir', dirPath),
     readFile: (filePath: string) => ipcRenderer.invoke('fs:readFile', filePath),
     stat: (filePath: string) => ipcRenderer.invoke('fs:stat', filePath),
@@ -375,6 +424,7 @@ contextBridge.exposeInMainWorld('maestro', {
         projectPath: string;
         sessionName: string;
         starred?: boolean;
+        lastActivityAt?: number;
       }>>,
     deleteMessagePair: (projectPath: string, sessionId: string, userMessageUuid: string, fallbackContent?: string) =>
       ipcRenderer.invoke('claude:deleteMessagePair', projectPath, sessionId, userMessageUuid, fallbackContent),
@@ -432,6 +482,68 @@ contextBridge.exposeInMainWorld('maestro', {
     getPath: (sessionId: string) =>
       ipcRenderer.invoke('attachments:getPath', sessionId),
   },
+
+  // Auto Run API (file-system-based document runner)
+  autorun: {
+    listDocs: (folderPath: string) =>
+      ipcRenderer.invoke('autorun:listDocs', folderPath),
+    readDoc: (folderPath: string, filename: string) =>
+      ipcRenderer.invoke('autorun:readDoc', folderPath, filename),
+    writeDoc: (folderPath: string, filename: string, content: string) =>
+      ipcRenderer.invoke('autorun:writeDoc', folderPath, filename, content),
+    saveImage: (
+      folderPath: string,
+      docName: string,
+      base64Data: string,
+      extension: string
+    ) =>
+      ipcRenderer.invoke(
+        'autorun:saveImage',
+        folderPath,
+        docName,
+        base64Data,
+        extension
+      ),
+    deleteImage: (folderPath: string, relativePath: string) =>
+      ipcRenderer.invoke('autorun:deleteImage', folderPath, relativePath),
+    listImages: (folderPath: string, docName: string) =>
+      ipcRenderer.invoke('autorun:listImages', folderPath, docName),
+  },
+
+  // Playbooks API (saved batch run configurations)
+  playbooks: {
+    list: (sessionId: string) =>
+      ipcRenderer.invoke('playbooks:list', sessionId),
+    create: (
+      sessionId: string,
+      playbook: {
+        name: string;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+        worktreeSettings?: {
+          branchNameTemplate: string;
+          createPROnCompletion: boolean;
+        };
+      }
+    ) => ipcRenderer.invoke('playbooks:create', sessionId, playbook),
+    update: (
+      sessionId: string,
+      playbookId: string,
+      updates: Partial<{
+        name: string;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+        worktreeSettings?: {
+          branchNameTemplate: string;
+          createPROnCompletion: boolean;
+        };
+      }>
+    ) => ipcRenderer.invoke('playbooks:update', sessionId, playbookId, updates),
+    delete: (sessionId: string, playbookId: string) =>
+      ipcRenderer.invoke('playbooks:delete', sessionId, playbookId),
+  },
 });
 
 // Type definitions for TypeScript
@@ -509,8 +621,50 @@ export interface MaestroAPI {
     }>;
     show: (cwd: string, hash: string) => Promise<{ stdout: string; stderr: string }>;
     showFile: (cwd: string, ref: string, filePath: string) => Promise<{ content?: string; error?: string }>;
+    // Git worktree operations for Auto Run parallelization
+    worktreeInfo: (worktreePath: string) => Promise<{
+      success: boolean;
+      exists?: boolean;
+      isWorktree?: boolean;
+      currentBranch?: string;
+      repoRoot?: string;
+      error?: string;
+    }>;
+    getRepoRoot: (cwd: string) => Promise<{
+      success: boolean;
+      root?: string;
+      error?: string;
+    }>;
+    worktreeSetup: (mainRepoCwd: string, worktreePath: string, branchName: string) => Promise<{
+      success: boolean;
+      created?: boolean;
+      currentBranch?: string;
+      requestedBranch?: string;
+      branchMismatch?: boolean;
+      error?: string;
+    }>;
+    worktreeCheckout: (worktreePath: string, branchName: string, createIfMissing: boolean) => Promise<{
+      success: boolean;
+      hasUncommittedChanges: boolean;
+      error?: string;
+    }>;
+    createPR: (worktreePath: string, baseBranch: string, title: string, body: string) => Promise<{
+      success: boolean;
+      prUrl?: string;
+      error?: string;
+    }>;
+    getDefaultBranch: (cwd: string) => Promise<{
+      success: boolean;
+      branch?: string;
+      error?: string;
+    }>;
+    checkGhCli: () => Promise<{
+      installed: boolean;
+      authenticated: boolean;
+    }>;
   };
   fs: {
+    homeDir: () => Promise<string>;
     readDir: (dirPath: string) => Promise<DirectoryEntry[]>;
     readFile: (filePath: string) => Promise<string>;
     stat: (filePath: string) => Promise<{
@@ -717,6 +871,100 @@ export interface MaestroAPI {
     list: (sessionId: string) => Promise<{ success: boolean; files: string[]; error?: string }>;
     getPath: (sessionId: string) => Promise<{ success: boolean; path: string }>;
   };
+  autorun: {
+    listDocs: (
+      folderPath: string
+    ) => Promise<{ success: boolean; files: string[]; error?: string }>;
+    readDoc: (
+      folderPath: string,
+      filename: string
+    ) => Promise<{ success: boolean; content?: string; error?: string }>;
+    writeDoc: (
+      folderPath: string,
+      filename: string,
+      content: string
+    ) => Promise<{ success: boolean; error?: string }>;
+    saveImage: (
+      folderPath: string,
+      docName: string,
+      base64Data: string,
+      extension: string
+    ) => Promise<{ success: boolean; relativePath?: string; error?: string }>;
+    deleteImage: (
+      folderPath: string,
+      relativePath: string
+    ) => Promise<{ success: boolean; error?: string }>;
+    listImages: (
+      folderPath: string,
+      docName: string
+    ) => Promise<{
+      success: boolean;
+      images?: { filename: string; relativePath: string }[];
+      error?: string;
+    }>;
+  };
+  playbooks: {
+    list: (sessionId: string) => Promise<{
+      success: boolean;
+      playbooks: Array<{
+        id: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+      }>;
+      error?: string;
+    }>;
+    create: (
+      sessionId: string,
+      playbook: {
+        name: string;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+      }
+    ) => Promise<{
+      success: boolean;
+      playbook?: {
+        id: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+      };
+      error?: string;
+    }>;
+    update: (
+      sessionId: string,
+      playbookId: string,
+      updates: Partial<{
+        name: string;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+      }>
+    ) => Promise<{
+      success: boolean;
+      playbook?: {
+        id: string;
+        name: string;
+        createdAt: number;
+        updatedAt: number;
+        documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+        loopEnabled: boolean;
+        prompt: string;
+      };
+      error?: string;
+    }>;
+    delete: (sessionId: string, playbookId: string) => Promise<{
+      success: boolean;
+      error?: string;
+    }>;
+  };
 }
 
 declare global {
diff --git a/src/main/process-manager.ts b/src/main/process-manager.ts
index ff3c191de..e56ab9057 100644
--- a/src/main/process-manager.ts
+++ b/src/main/process-manager.ts
@@ -157,20 +157,19 @@ export class ProcessManager extends EventEmitter {
         }
 
         // Build environment for PTY process
-        // For terminal sessions, we want the shell to build its own PATH from startup files
-        // (.zprofile, .zshrc, etc.) rather than inheriting Electron's limited PATH.
-        // Electron launched from Finder gets a minimal PATH from launchd, not the user's shell PATH.
+        // For terminal sessions, pass minimal env with base system PATH.
+        // Shell startup files (.zprofile, .zshrc) will prepend user paths (homebrew, go, etc.)
+        // We need the base system paths or commands like sort, find, head won't work.
         let ptyEnv: NodeJS.ProcessEnv;
         if (isTerminal) {
-          // For terminals: pass minimal env, let shell startup files set PATH
-          // This ensures the terminal has the same environment as a regular terminal app
           ptyEnv = {
             HOME: process.env.HOME,
             USER: process.env.USER,
             SHELL: process.env.SHELL,
             TERM: 'xterm-256color',
             LANG: process.env.LANG || 'en_US.UTF-8',
-            // Don't pass PATH - let the shell build it from scratch via .zprofile/.zshrc
+            // Provide base system PATH - shell startup files will prepend user paths
+            PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin',
           };
         } else {
           // For AI agents in PTY mode: pass full env (they need NODE_PATH, etc.)
@@ -297,18 +296,8 @@ export class ProcessManager extends EventEmitter {
             console.error('[ProcessManager] stdout error:', err);
           });
           childProcess.stdout.on('data', (data: Buffer | string) => {
-            console.log('[ProcessManager] >>> STDOUT EVENT FIRED <<<');
-            console.log('[ProcessManager] stdout event fired for session:', sessionId);
           const output = data.toString();
 
-          console.log('[ProcessManager] stdout data received:', {
-            sessionId,
-            isBatchMode,
-            isStreamJsonMode,
-            dataLength: output.length,
-            dataPreview: output.substring(0, 200)
-          });
-
           if (isStreamJsonMode) {
             // In stream-json mode, each line is a JSONL message
             // Accumulate and process complete lines
@@ -379,12 +368,10 @@ export class ProcessManager extends EventEmitter {
                     contextWindow
                   };
 
-                  console.log('[ProcessManager] Emitting usage stats from stream-json:', usageStats);
                   this.emit('usage', sessionId, usageStats);
                 }
               } catch (e) {
                 // If it's not valid JSON, emit as raw text
-                console.log('[ProcessManager] Non-JSON line in stream-json mode:', line.substring(0, 100));
                 this.emit('data', sessionId, line);
               }
             }
@@ -487,18 +474,8 @@ export class ProcessManager extends EventEmitter {
                   contextWindow
                 };
 
-                console.log('[ProcessManager] Emitting usage stats:', usageStats);
                 this.emit('usage', sessionId, usageStats);
               }
-
-              // Emit full response for debugging
-              console.log('[ProcessManager] Batch mode JSON response:', {
-                sessionId,
-                hasResult: !!jsonResponse.result,
-                hasSessionId: !!jsonResponse.session_id,
-                sessionIdValue: jsonResponse.session_id,
-                hasCost: jsonResponse.total_cost_usd !== undefined
-              });
             } catch (error) {
               console.error('[ProcessManager] Failed to parse JSON response:', error);
               // Emit raw buffer as fallback
@@ -706,31 +683,32 @@ export class ProcessManager extends EventEmitter {
         // Fish auto-sources config.fish, just run the command
         wrappedCommand = command;
       } else if (shellName === 'zsh') {
-        // Source .zshrc for aliases, then use eval to parse command AFTER aliases are loaded
-        // Without eval, the shell parses the command before .zshrc is sourced, so aliases aren't available
+        // Source both .zprofile (login shell - PATH setup) and .zshrc (interactive - aliases, functions)
+        // This matches what a login interactive shell does (zsh -l -i)
+        // Without eval, the shell parses the command before configs are sourced, so aliases aren't available
         const escapedCommand = command.replace(/'/g, "'\\''");
-        wrappedCommand = `source ~/.zshrc 2>/dev/null; eval '${escapedCommand}'`;
+        wrappedCommand = `source ~/.zprofile 2>/dev/null; source ~/.zshrc 2>/dev/null; eval '${escapedCommand}'`;
       } else if (shellName === 'bash') {
-        // Source .bashrc for aliases, use eval for same reason as zsh
+        // Source both .bash_profile (login shell) and .bashrc (interactive)
         const escapedCommand = command.replace(/'/g, "'\\''");
-        wrappedCommand = `source ~/.bashrc 2>/dev/null; eval '${escapedCommand}'`;
+        wrappedCommand = `source ~/.bash_profile 2>/dev/null; source ~/.bashrc 2>/dev/null; eval '${escapedCommand}'`;
       } else {
         // Other POSIX-compatible shells
         wrappedCommand = command;
       }
 
-      // Ensure PATH includes standard binary locations
-      // Electron's main process may have a stripped-down PATH
-      const env = { ...process.env };
-      const standardPaths = '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin';
-      if (env.PATH) {
-        // Prepend standard paths if not already present
-        if (!env.PATH.includes('/bin')) {
-          env.PATH = `${standardPaths}:${env.PATH}`;
-        }
-      } else {
-        env.PATH = standardPaths;
-      }
+      // Pass minimal environment with a base PATH for essential system commands.
+      // Shell startup files (.zprofile, .zshrc) will prepend user paths to this.
+      // We need the base system paths or commands like sort, find, head won't work.
+      const env: NodeJS.ProcessEnv = {
+        HOME: process.env.HOME,
+        USER: process.env.USER,
+        SHELL: process.env.SHELL,
+        TERM: 'xterm-256color',
+        LANG: process.env.LANG || 'en_US.UTF-8',
+        // Provide base system PATH - shell startup files will prepend user paths (homebrew, go, etc.)
+        PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin',
+      };
 
       // Resolve shell to full path - Electron's internal PATH may not include /bin
       // where common shells like zsh and bash are located
diff --git a/src/main/tunnel-manager.ts b/src/main/tunnel-manager.ts
index 5e6d6957e..c9925f327 100644
--- a/src/main/tunnel-manager.ts
+++ b/src/main/tunnel-manager.ts
@@ -1,5 +1,6 @@
 import { ChildProcess, spawn } from 'child_process';
 import { logger } from './utils/logger';
+import { getCloudflaredPath, isCloudflaredInstalled } from './utils/cliDetection';
 
 export interface TunnelStatus {
   isRunning: boolean;
@@ -27,10 +28,18 @@ class TunnelManager {
     // Stop any existing tunnel first
     await this.stop();
 
+    // Ensure cloudflared is installed and get its path
+    const installed = await isCloudflaredInstalled();
+    if (!installed) {
+      return { success: false, error: 'cloudflared is not installed' };
+    }
+
+    const cloudflaredBinary = getCloudflaredPath() || 'cloudflared';
+
     return new Promise((resolve) => {
-      logger.info(`Starting cloudflared tunnel for port ${port}`, 'TunnelManager');
+      logger.info(`Starting cloudflared tunnel for port ${port} using ${cloudflaredBinary}`, 'TunnelManager');
 
-      this.process = spawn('cloudflared', [
+      this.process = spawn(cloudflaredBinary, [
         'tunnel', '--url', `http://localhost:${port}`
       ]);
 
diff --git a/src/main/utils/cliDetection.ts b/src/main/utils/cliDetection.ts
index 67acf66e5..bd21e950a 100644
--- a/src/main/utils/cliDetection.ts
+++ b/src/main/utils/cliDetection.ts
@@ -1,6 +1,42 @@
 import { execFileNoThrow } from './execFile';
+import * as os from 'os';
 
 let cloudflaredInstalledCache: boolean | null = null;
+let cloudflaredPathCache: string | null = null;
+
+/**
+ * Build an expanded PATH that includes common binary installation locations.
+ * This is necessary because packaged Electron apps don't inherit shell environment.
+ */
+function getExpandedEnv(): NodeJS.ProcessEnv {
+  const home = os.homedir();
+  const env = { ...process.env };
+
+  const additionalPaths = [
+    '/opt/homebrew/bin',           // Homebrew on Apple Silicon
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',              // Homebrew on Intel, common install location
+    '/usr/local/sbin',
+    `${home}/.local/bin`,          // User local installs
+    `${home}/bin`,                 // User bin directory
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin',
+  ];
+
+  const currentPath = env.PATH || '';
+  const pathParts = currentPath.split(':');
+
+  for (const p of additionalPaths) {
+    if (!pathParts.includes(p)) {
+      pathParts.unshift(p);
+    }
+  }
+
+  env.PATH = pathParts.join(':');
+  return env;
+}
 
 export async function isCloudflaredInstalled(): Promise<boolean> {
   // Return cached result if available
@@ -10,12 +46,23 @@ export async function isCloudflaredInstalled(): Promise<boolean> {
 
   // Use 'which' on macOS/Linux, 'where' on Windows
   const command = process.platform === 'win32' ? 'where' : 'which';
-  const result = await execFileNoThrow(command, ['cloudflared']);
-  cloudflaredInstalledCache = result.exitCode === 0;
+  const env = getExpandedEnv();
+  const result = await execFileNoThrow(command, ['cloudflared'], undefined, env);
+
+  if (result.exitCode === 0 && result.stdout.trim()) {
+    cloudflaredInstalledCache = true;
+    cloudflaredPathCache = result.stdout.trim().split('\n')[0];
+  } else {
+    cloudflaredInstalledCache = false;
+  }
 
   return cloudflaredInstalledCache;
 }
 
+export function getCloudflaredPath(): string | null {
+  return cloudflaredPathCache;
+}
+
 export function clearCloudflaredCache(): void {
   cloudflaredInstalledCache = null;
 }
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 7b98a9277..9dd1a3cf0 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -24,6 +24,7 @@ import { PromptComposerModal } from './components/PromptComposerModal';
 import { ExecutionQueueBrowser } from './components/ExecutionQueueBrowser';
 import { StandingOvationOverlay } from './components/StandingOvationOverlay';
 import { PlaygroundPanel } from './components/PlaygroundPanel';
+import { AutoRunSetupModal } from './components/AutoRunSetupModal';
 import { CONDUCTOR_BADGES } from './constants/conductorBadges';
 
 // Import custom hooks
@@ -43,7 +44,7 @@ import { gitService } from './services/git';
 // Import types and constants
 import type {
   ToolType, SessionState, RightPanelTab,
-  FocusArea, LogEntry, Session, Group, AITab, UsageStats, QueuedItem
+  FocusArea, LogEntry, Session, Group, AITab, UsageStats, QueuedItem, BatchRunConfig
 } from './types';
 import { THEMES } from './constants/themes';
 import { generateId } from './utils/ids';
@@ -51,7 +52,7 @@ import { getContextColor } from './utils/theme';
 import { fuzzyMatch } from './utils/search';
 import { setActiveTab, createTab, closeTab, reopenClosedTab, getActiveTab, getWriteModeTab, navigateToNextTab, navigateToPrevTab, navigateToTabByIndex, navigateToLastTab } from './utils/tabHelpers';
 import { TAB_SHORTCUTS } from './constants/shortcuts';
-import { shouldOpenExternally, loadFileTree, getAllFolderPaths, flattenTree } from './utils/fileExplorer';
+import { shouldOpenExternally, loadFileTree, getAllFolderPaths, flattenTree, compareFileTrees, FileTreeChanges } from './utils/fileExplorer';
 import { substituteTemplateVariables } from './utils/templateVariables';
 
 // Strip leading emojis from a string for alphabetical sorting
@@ -232,6 +233,9 @@ export default function MaestroConsole() {
   // Batch Runner Modal State
   const [batchRunnerModalOpen, setBatchRunnerModalOpen] = useState(false);
 
+  // Auto Run Setup Modal State
+  const [autoRunSetupModalOpen, setAutoRunSetupModalOpen] = useState(false);
+
   // Tab Switcher Modal State
   const [tabSwitcherOpen, setTabSwitcherOpen] = useState(false);
 
@@ -274,6 +278,12 @@ export default function MaestroConsole() {
   const [isLiveMode, setIsLiveMode] = useState(false);
   const [webInterfaceUrl, setWebInterfaceUrl] = useState<string | null>(null);
 
+  // Auto Run document management state
+  const [autoRunDocumentList, setAutoRunDocumentList] = useState<string[]>([]);
+  const [autoRunDocumentTree, setAutoRunDocumentTree] = useState<Array<{ name: string; type: 'file' | 'folder'; path: string; children?: unknown[] }>>([]);
+  const [autoRunContent, setAutoRunContent] = useState<string>('');
+  const [autoRunIsLoadingDocuments, setAutoRunIsLoadingDocuments] = useState(false);
+
   // Restore focus when LogViewer closes to ensure global hotkeys work
   useEffect(() => {
     // When LogViewer closes, restore focus to main container or input
@@ -328,6 +338,11 @@ export default function MaestroConsole() {
   // Restore a persisted session by respawning its process
   const restoreSession = async (session: Session): Promise<Session> => {
     try {
+      // Migration: ensure projectRoot is set (for sessions created before this field was added)
+      if (!session.projectRoot) {
+        session = { ...session, projectRoot: session.cwd };
+      }
+
       // Sessions must have aiTabs - if missing, this is a data corruption issue
       if (!session.aiTabs || session.aiTabs.length === 0) {
         console.error('[restoreSession] Session has no aiTabs - data corruption, skipping:', session.id);
@@ -655,7 +670,14 @@ export default function MaestroConsole() {
     });
 
     // Handle process exit
-    const unsubscribeExit = window.maestro.process.onExit((sessionId: string, code: number) => {
+    const unsubscribeExit = window.maestro.process.onExit(async (sessionId: string, code: number) => {
+      // Log all exit events to help diagnose thinking pill disappearing prematurely
+      console.log('[onExit] Process exit event received:', {
+        rawSessionId: sessionId,
+        exitCode: code,
+        timestamp: new Date().toISOString()
+      });
+
       // Parse sessionId to determine which process exited
       // Format: {id}-ai-{tabId}, {id}-terminal, {id}-batch-{timestamp}
       let actualSessionId: string;
@@ -679,6 +701,26 @@ export default function MaestroConsole() {
         isFromAi = false;
       }
 
+      // SAFETY CHECK: Verify the process is actually gone before transitioning to idle
+      // This prevents the thinking pill from disappearing while the process is still running
+      // (which can happen if we receive a stale/duplicate exit event)
+      if (isFromAi) {
+        try {
+          const activeProcesses = await window.maestro.process.getActiveProcesses();
+          const processStillRunning = activeProcesses.some(p => p.sessionId === sessionId);
+          if (processStillRunning) {
+            console.warn('[onExit] Process still running despite exit event, ignoring:', {
+              sessionId,
+              activeProcesses: activeProcesses.map(p => p.sessionId)
+            });
+            return;
+          }
+        } catch (error) {
+          console.error('[onExit] Failed to verify process status:', error);
+          // Continue with exit handling if we can't verify - better than getting stuck
+        }
+      }
+
       // For AI exits, gather toast data BEFORE state update to avoid side effects in updater
       // React 18 StrictMode may call state updater functions multiple times
       let toastData: {
@@ -896,6 +938,18 @@ export default function MaestroConsole() {
           const newState = anyTabStillBusy ? 'busy' as SessionState : 'idle' as SessionState;
           const newBusySource = anyTabStillBusy ? s.busySource : undefined;
 
+          // Log state transition for debugging thinking pill issues
+          console.log('[onExit] Session state transition:', {
+            sessionId: s.id.substring(0, 8),
+            tabIdFromSession: tabIdFromSession?.substring(0, 8),
+            previousState: s.state,
+            newState,
+            previousBusySource: s.busySource,
+            newBusySource,
+            anyTabStillBusy,
+            tabStates: updatedAiTabs.map(t => ({ id: t.id.substring(0, 8), state: t.state }))
+          });
+
           // Task complete - also clear pending AI command flag
           return {
             ...s,
@@ -1181,9 +1235,15 @@ export default function MaestroConsole() {
       setSessions(prev => prev.map(s => {
         if (s.id !== actualSessionId) return s;
 
-        // Check if any AI tabs are still busy - don't clear session state if so
+        // Check if any AI tabs are still busy
         const anyAiTabBusy = s.aiTabs?.some(tab => tab.state === 'busy') || false;
 
+        // Determine new state:
+        // - If AI tabs are busy, session stays busy with busySource 'ai'
+        // - Otherwise, session becomes idle
+        const newState = anyAiTabBusy ? 'busy' as SessionState : 'idle' as SessionState;
+        const newBusySource = anyAiTabBusy ? 'ai' as const : undefined;
+
         // Only show exit code if non-zero (error)
         if (code !== 0) {
           const exitLog: LogEntry = {
@@ -1194,18 +1254,16 @@ export default function MaestroConsole() {
           };
           return {
             ...s,
-            // Only clear session state if no AI tabs are busy
-            state: anyAiTabBusy ? s.state : 'idle' as SessionState,
-            busySource: anyAiTabBusy ? s.busySource : undefined,
+            state: newState,
+            busySource: newBusySource,
             shellLogs: [...s.shellLogs, exitLog]
           };
         }
 
         return {
           ...s,
-          // Only clear session state if no AI tabs are busy
-          state: anyAiTabBusy ? s.state : 'idle' as SessionState,
-          busySource: anyAiTabBusy ? s.busySource : undefined
+          state: newState,
+          busySource: newBusySource
         };
       }));
     });
@@ -1677,7 +1735,8 @@ export default function MaestroConsole() {
 
       // Save the current AI input to the PREVIOUS tab before loading new tab's input
       // This ensures we don't lose draft input when clicking directly on another tab
-      if (prevTabId && aiInputValueLocal) {
+      // Also ensures clearing the input (empty string) is persisted when switching away
+      if (prevTabId) {
         setSessions(prev => prev.map(s => ({
           ...s,
           aiTabs: s.aiTabs.map(tab =>
@@ -1882,10 +1941,14 @@ export default function MaestroConsole() {
 
   // --- BATCH PROCESSOR ---
   // Helper to spawn a Claude agent and wait for completion (for a specific session)
-  const spawnAgentForSession = useCallback(async (sessionId: string, prompt: string): Promise<{ success: boolean; response?: string; claudeSessionId?: string; usageStats?: UsageStats }> => {
+  // cwdOverride allows running in a different directory (e.g., for worktree mode)
+  const spawnAgentForSession = useCallback(async (sessionId: string, prompt: string, cwdOverride?: string): Promise<{ success: boolean; response?: string; claudeSessionId?: string; usageStats?: UsageStats }> => {
     const session = sessions.find(s => s.id === sessionId);
     if (!session) return { success: false };
 
+    // Use override cwd if provided (worktree mode), otherwise use session's cwd
+    const effectiveCwd = cwdOverride || session.cwd;
+
     // This spawns a new Claude session and waits for completion
     try {
       const agent = await window.maestro.agents.get('claude-code');
@@ -1971,17 +2034,18 @@ export default function MaestroConsole() {
 
         cleanupExit = window.maestro.process.onExit((sid: string) => {
           if (sid === targetSessionId) {
-            // Clean up listeners and resolve
+            // Clean up listeners
             cleanup();
 
             // Check for queued items BEFORE updating state (using sessionsRef for latest state)
             const currentSession = sessionsRef.current.find(s => s.id === sessionId);
             let queuedItemToProcess: { sessionId: string; item: QueuedItem } | null = null;
+            const hasQueuedItems = currentSession && currentSession.executionQueue.length > 0;
 
-            if (currentSession && currentSession.executionQueue.length > 0) {
+            if (hasQueuedItems) {
               queuedItemToProcess = {
                 sessionId: sessionId,
-                item: currentSession.executionQueue[0]
+                item: currentSession!.executionQueue[0]
               };
             }
 
@@ -2063,17 +2127,41 @@ export default function MaestroConsole() {
               }, 0);
             }
 
-            resolve({ success: true, response: responseText, claudeSessionId, usageStats: taskUsageStats });
+            // For batch processing (Auto Run): if there are queued items from manual writes,
+            // wait for the queue to drain before resolving. This ensures batch tasks don't
+            // race with queued manual writes. Worktree mode can skip this since it operates
+            // in a separate directory with no file conflicts.
+            // Note: cwdOverride is set when worktree is enabled
+            if (hasQueuedItems && !cwdOverride) {
+              // Wait for queue to drain by polling session state
+              // The queue is processed sequentially, so we wait until session becomes idle
+              const waitForQueueDrain = () => {
+                const checkSession = sessionsRef.current.find(s => s.id === sessionId);
+                if (!checkSession || checkSession.state === 'idle' || checkSession.executionQueue.length === 0) {
+                  // Queue drained or session idle - safe to continue batch
+                  resolve({ success: true, response: responseText, claudeSessionId, usageStats: taskUsageStats });
+                } else {
+                  // Queue still processing - check again
+                  setTimeout(waitForQueueDrain, 100);
+                }
+              };
+              // Start polling after a short delay to let state update propagate
+              setTimeout(waitForQueueDrain, 50);
+            } else {
+              // No queued items or worktree mode - resolve immediately
+              resolve({ success: true, response: responseText, claudeSessionId, usageStats: taskUsageStats });
+            }
           }
         });
 
         // Spawn the agent with permission-mode plan for batch processing
+        // Use effectiveCwd which may be a worktree path for parallel execution
         const commandToUse = agent.path || agent.command;
         const spawnArgs = [...(agent.args || []), '--permission-mode', 'plan'];
         window.maestro.process.spawn({
           sessionId: targetSessionId,
           toolType: 'claude-code',
-          cwd: session.cwd,
+          cwd: effectiveCwd,
           command: commandToUse,
           args: spawnArgs,
           prompt
@@ -2307,6 +2395,34 @@ export default function MaestroConsole() {
           }
         }
       }
+    },
+    onPRResult: (info) => {
+      // Find group name for the session
+      const session = sessions.find(s => s.id === info.sessionId);
+      const sessionGroup = session?.groupId ? groups.find(g => g.id === session.groupId) : null;
+      const groupName = sessionGroup?.name || 'Ungrouped';
+
+      if (info.success) {
+        // PR created successfully - show success toast with PR URL
+        addToast({
+          type: 'success',
+          title: 'PR Created',
+          message: info.prUrl || 'Pull request created successfully',
+          group: groupName,
+          project: info.sessionName,
+          sessionId: info.sessionId,
+        });
+      } else {
+        // PR creation failed - show warning (not error, since the auto-run itself succeeded)
+        addToast({
+          type: 'warning',
+          title: 'PR Creation Failed',
+          message: info.error || 'Failed to create pull request',
+          group: groupName,
+          project: info.sessionName,
+          sessionId: info.sessionId,
+        });
+      }
     }
   });
 
@@ -2321,13 +2437,76 @@ export default function MaestroConsole() {
     setBatchRunnerModalOpen(true);
   }, []);
 
-  // Handler to start batch run from modal
-  const handleStartBatchRun = useCallback((prompt: string) => {
+  // Handler for switching to autorun tab - shows setup modal if no folder configured
+  const handleSetActiveRightTab = useCallback((tab: RightPanelTab) => {
+    if (tab === 'autorun' && activeSession && !activeSession.autoRunFolderPath) {
+      // No folder configured - show setup modal
+      setAutoRunSetupModalOpen(true);
+      // Still switch to the tab (it will show an empty state or the modal)
+      setActiveRightTab(tab);
+    } else {
+      setActiveRightTab(tab);
+    }
+  }, [activeSession]);
+
+  // Handler for auto run folder selection from setup modal
+  const handleAutoRunFolderSelected = useCallback(async (folderPath: string) => {
     if (!activeSession) return;
+
+    // Load the document list from the folder
+    const result = await window.maestro.autorun.listDocs(folderPath);
+    if (result.success) {
+      setAutoRunDocumentList(result.files || []);
+      setAutoRunDocumentTree((result.tree as Array<{ name: string; type: 'file' | 'folder'; path: string; children?: unknown[] }>) || []);
+      // Auto-select first document if available
+      const firstFile = result.files?.[0] || null;
+      setSessions(prev => prev.map(s =>
+        s.id === activeSession.id
+          ? {
+              ...s,
+              autoRunFolderPath: folderPath,
+              autoRunSelectedFile: firstFile,
+            }
+          : s
+      ));
+      // Load content of first document
+      if (firstFile) {
+        const contentResult = await window.maestro.autorun.readDoc(folderPath, firstFile + '.md');
+        if (contentResult.success) {
+          setAutoRunContent(contentResult.content || '');
+        }
+      }
+    } else {
+      setSessions(prev => prev.map(s =>
+        s.id === activeSession.id
+          ? { ...s, autoRunFolderPath: folderPath }
+          : s
+      ));
+    }
+    setAutoRunSetupModalOpen(false);
+    // Switch to the autorun tab now that folder is configured
+    setActiveRightTab('autorun');
+    setRightPanelOpen(true);
+    setActiveFocus('right');
+  }, [activeSession]);
+
+  // Handler to start batch run from modal with multi-document support
+  const handleStartBatchRun = useCallback((config: BatchRunConfig) => {
+    if (!activeSession || !activeSession.autoRunFolderPath) return;
     setBatchRunnerModalOpen(false);
-    startBatchRun(activeSession.id, activeSession.scratchPadContent, prompt);
+    startBatchRun(activeSession.id, config, activeSession.autoRunFolderPath);
   }, [activeSession, startBatchRun]);
 
+  // Memoized function to get task count for a document (used by BatchRunnerModal)
+  const getDocumentTaskCount = useCallback(async (filename: string) => {
+    if (!activeSession?.autoRunFolderPath) return 0;
+    const result = await window.maestro.autorun.readDoc(activeSession.autoRunFolderPath, filename + '.md');
+    if (!result.success || !result.content) return 0;
+    // Count unchecked tasks: - [ ] pattern
+    const matches = result.content.match(/^[\s]*-\s*\[\s*\]\s*.+$/gm);
+    return matches ? matches.length : 0;
+  }, [activeSession?.autoRunFolderPath]);
+
   // Handler to stop batch run for active session (with confirmation)
   const handleStopBatchRun = useCallback(() => {
     if (!activeSession) return;
@@ -2390,14 +2569,17 @@ export default function MaestroConsole() {
       // Use provided messages or fetch them
       let messages: LogEntry[];
       if (providedMessages && providedMessages.length > 0) {
+        console.log('[handleResumeSession] Using provided messages:', providedMessages.length);
         messages = providedMessages;
       } else {
+        console.log('[handleResumeSession] Loading messages for:', claudeSessionId, 'cwd:', activeSession.cwd);
         // Load the session messages
         const result = await window.maestro.claude.readSessionMessages(
           activeSession.cwd,
           claudeSessionId,
           { offset: 0, limit: 100 }
         );
+        console.log('[handleResumeSession] Loaded result:', result);
 
         // Convert to log entries
         messages = result.messages.map((msg: { type: string; content: string; timestamp: string; uuid: string }) => ({
@@ -2406,6 +2588,7 @@ export default function MaestroConsole() {
           source: msg.type === 'user' ? 'user' as const : 'stdout' as const,
           text: msg.content || ''
         }));
+        console.log('[handleResumeSession] Converted to', messages.length, 'log entries');
       }
 
       // Look up starred status and session name from stores if not provided
@@ -2430,20 +2613,23 @@ export default function MaestroConsole() {
         }
       }
 
-      // Create a new tab with the session data using the helper function
-      const { session: updatedSession } = createTab(activeSession, {
-        claudeSessionId,
-        logs: messages,
-        name,
-        starred: isStarred
-      });
-
       // Update the session and switch to AI mode
-      setSessions(prev => prev.map(s =>
-        s.id === activeSession.id
-          ? { ...updatedSession, inputMode: 'ai' }
-          : s
-      ));
+      // IMPORTANT: Use functional update to get fresh session state and avoid race conditions
+      console.log('[handleResumeSession] Creating tab with', messages.length, 'logs, name:', name, 'starred:', isStarred);
+      setSessions(prev => prev.map(s => {
+        if (s.id !== activeSession.id) return s;
+
+        // Create tab from the CURRENT session state (not stale closure value)
+        const { session: updatedSession, tab: newTab } = createTab(s, {
+          claudeSessionId,
+          logs: messages,
+          name,
+          starred: isStarred
+        });
+
+        console.log('[handleResumeSession] Created tab:', newTab.id, 'with', newTab.logs.length, 'logs, activeTabId:', updatedSession.activeTabId);
+        return { ...updatedSession, inputMode: 'ai' };
+      }));
       setActiveClaudeSessionId(claudeSessionId);
     } catch (error) {
       console.error('Failed to resume session:', error);
@@ -2608,6 +2794,13 @@ export default function MaestroConsole() {
     // Handle Shift+[ producing { and Shift+] producing }
     if (mainKey === '[' && (key === '[' || key === '{')) return true;
     if (mainKey === ']' && (key === ']' || key === '}')) return true;
+    // Handle Shift+number producing symbol (US keyboard layout)
+    // Shift+1='!', Shift+2='@', Shift+3='#', etc.
+    const shiftNumberMap: Record<string, string> = {
+      '!': '1', '@': '2', '#': '3', '$': '4', '%': '5',
+      '^': '6', '&': '7', '*': '8', '(': '9', ')': '0'
+    };
+    if (shiftNumberMap[key] === mainKey) return true;
 
     return key === mainKey;
   };
@@ -2994,9 +3187,9 @@ export default function MaestroConsole() {
       }
       else if (ctx.isShortcut(e, 'help')) ctx.setShortcutsHelpOpen(true);
       else if (ctx.isShortcut(e, 'settings')) { ctx.setSettingsModalOpen(true); ctx.setSettingsTab('general'); }
-      else if (ctx.isShortcut(e, 'goToFiles')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.setActiveRightTab('files'); ctx.setActiveFocus('right'); }
-      else if (ctx.isShortcut(e, 'goToHistory')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.setActiveRightTab('history'); ctx.setActiveFocus('right'); }
-      else if (ctx.isShortcut(e, 'goToScratchpad')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.setActiveRightTab('scratchpad'); ctx.setActiveFocus('right'); }
+      else if (ctx.isShortcut(e, 'goToFiles')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.handleSetActiveRightTab('files'); ctx.setActiveFocus('right'); }
+      else if (ctx.isShortcut(e, 'goToHistory')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.handleSetActiveRightTab('history'); ctx.setActiveFocus('right'); }
+      else if (ctx.isShortcut(e, 'goToAutoRun')) { e.preventDefault(); ctx.setRightPanelOpen(true); ctx.handleSetActiveRightTab('autorun'); ctx.setActiveFocus('right'); }
       else if (ctx.isShortcut(e, 'openImageCarousel')) {
         e.preventDefault();
         if (ctx.stagedImages.length > 0) {
@@ -3047,6 +3240,16 @@ export default function MaestroConsole() {
         // Jump to the bottom of the current main panel output (AI logs or terminal output)
         ctx.logsEndRef.current?.scrollIntoView({ behavior: 'instant' });
       }
+      else if (ctx.isShortcut(e, 'toggleMarkdownMode')) {
+        // Toggle markdown raw mode for AI message history
+        // Skip when in AutoRun panel (it has its own Cmd+E handler for edit/preview toggle)
+        // Skip when FilePreview is open (it handles its own Cmd+E)
+        const isInAutoRunPanel = ctx.activeFocus === 'right' && ctx.activeRightTab === 'autorun';
+        if (!isInAutoRunPanel && !ctx.previewFile) {
+          e.preventDefault();
+          ctx.setMarkdownRawMode(!ctx.markdownRawMode);
+        }
+      }
 
       // Opt+Cmd+NUMBER: Jump to visible session by number (1-9, 0=10th)
       // Use e.code instead of e.key because Option key on macOS produces special characters
@@ -3158,9 +3361,9 @@ export default function MaestroConsole() {
             ));
           }
         }
-        // Cmd+1 through Cmd+8: Jump to specific tab by index (disabled in unread-only mode)
+        // Cmd+1 through Cmd+9: Jump to specific tab by index (disabled in unread-only mode)
         if (!ctx.showUnreadOnly) {
-          for (let i = 1; i <= 8; i++) {
+          for (let i = 1; i <= 9; i++) {
             if (ctx.isTabShortcut(e, `goToTab${i}`)) {
               e.preventDefault();
               const result = ctx.navigateToTabByIndex(ctx.activeSession, i - 1);
@@ -3172,7 +3375,7 @@ export default function MaestroConsole() {
               break;
             }
           }
-          // Cmd+9: Jump to last tab
+          // Cmd+0: Jump to last tab
           if (ctx.isTabShortcut(e, 'goToLastTab')) {
             e.preventDefault();
             const result = ctx.navigateToLastTab(ctx.activeSession);
@@ -3264,6 +3467,44 @@ export default function MaestroConsole() {
     }
   }, [shortcutsHelpOpen]);
 
+  // Load Auto Run document list and content when session changes or autorun tab becomes active
+  useEffect(() => {
+    const loadAutoRunData = async () => {
+      if (!activeSession?.autoRunFolderPath) {
+        setAutoRunDocumentList([]);
+        setAutoRunDocumentTree([]);
+        setAutoRunContent('');
+        return;
+      }
+
+      // Load document list
+      setAutoRunIsLoadingDocuments(true);
+      const listResult = await window.maestro.autorun.listDocs(activeSession.autoRunFolderPath);
+      if (listResult.success) {
+        setAutoRunDocumentList(listResult.files || []);
+        setAutoRunDocumentTree((listResult.tree as Array<{ name: string; type: 'file' | 'folder'; path: string; children?: unknown[] }>) || []);
+      }
+      setAutoRunIsLoadingDocuments(false);
+
+      // Load content of selected document
+      if (activeSession.autoRunSelectedFile) {
+        const contentResult = await window.maestro.autorun.readDoc(
+          activeSession.autoRunFolderPath,
+          activeSession.autoRunSelectedFile + '.md'
+        );
+        if (contentResult.success) {
+          setAutoRunContent(contentResult.content || '');
+        } else {
+          setAutoRunContent('');
+        }
+      } else {
+        setAutoRunContent('');
+      }
+    };
+
+    loadAutoRunData();
+  }, [activeSessionId, activeSession?.autoRunFolderPath, activeSession?.autoRunSelectedFile]);
+
   // Auto-scroll logs
   const activeTabLogs = activeSession ? getActiveTab(activeSession)?.logs : undefined;
   useEffect(() => {
@@ -3452,6 +3693,7 @@ export default function MaestroConsole() {
         state: 'idle',
         cwd: workingDir,
         fullPath: workingDir,
+        projectRoot: workingDir, // Store the initial directory (never changes)
         isGitRepo,
         gitBranches,
         gitTags,
@@ -3459,7 +3701,6 @@ export default function MaestroConsole() {
         aiLogs: [], // Deprecated - logs are now in aiTabs
         shellLogs: [{ id: generateId(), timestamp: Date.now(), source: 'system', text: 'Shell Session Ready.' }],
         workLog: [],
-        scratchPadContent: '',
         contextUsage: 0,
         inputMode: agentId === 'terminal' ? 'terminal' : 'ai',
         // AI process PID (terminal uses runCommand which spawns fresh shells)
@@ -3617,16 +3858,16 @@ export default function MaestroConsole() {
     processMonitorOpen, logViewerOpen, createGroupModalOpen, confirmModalOpen, renameInstanceModalOpen,
     renameGroupModalOpen, activeSession, previewFile, fileTreeFilter, fileTreeFilterOpen, gitDiffPreview,
     gitLogOpen, lightboxImage, hasOpenLayers, hasOpenModal, visibleSessions, sortedSessions, groups,
-    bookmarksCollapsed, leftSidebarOpen, editingSessionId, editingGroupId,
+    bookmarksCollapsed, leftSidebarOpen, editingSessionId, editingGroupId, markdownRawMode,
     setLeftSidebarOpen, setRightPanelOpen, addNewSession, deleteSession, setQuickActionInitialMode,
     setQuickActionOpen, cycleSession, toggleInputMode, setShortcutsHelpOpen, setSettingsModalOpen,
-    setSettingsTab, setActiveRightTab, setActiveFocus, setBookmarksCollapsed, setGroups,
+    setSettingsTab, setActiveRightTab, handleSetActiveRightTab, setActiveFocus, setBookmarksCollapsed, setGroups,
     setSelectedSidebarIndex, setActiveSessionId, handleViewGitDiff, setGitLogOpen, setActiveClaudeSessionId,
     setAgentSessionsOpen, setLogViewerOpen, setProcessMonitorOpen, logsEndRef, inputRef, terminalOutputRef,
     setSessions, createTab, closeTab, reopenClosedTab, getActiveTab, setRenameTabId, setRenameTabInitialName,
     setRenameTabModalOpen, navigateToNextTab, navigateToPrevTab, navigateToTabByIndex, navigateToLastTab,
     setFileTreeFilterOpen, isShortcut, isTabShortcut, handleNavBack, handleNavForward, toggleUnreadFilter,
-    setTabSwitcherOpen, showUnreadOnly, stagedImages, handleSetLightboxImage
+    setTabSwitcherOpen, showUnreadOnly, stagedImages, handleSetLightboxImage, setMarkdownRawMode
   };
 
   const toggleGroup = (groupId: string) => {
@@ -3720,38 +3961,177 @@ export default function MaestroConsole() {
     }
   };
 
-  const updateScratchPad = useCallback((content: string) => {
-    setSessions(prev => prev.map(s => s.id === activeSessionId ? { ...s, scratchPadContent: content } : s));
-  }, [activeSessionId]);
+  // Auto Run document content change handler
+  const handleAutoRunContentChange = useCallback(async (content: string) => {
+    setAutoRunContent(content);
+    // Auto-save to file
+    if (activeSession?.autoRunFolderPath && activeSession?.autoRunSelectedFile) {
+      await window.maestro.autorun.writeDoc(
+        activeSession.autoRunFolderPath,
+        activeSession.autoRunSelectedFile + '.md',
+        content
+      );
+    }
+  }, [activeSession?.autoRunFolderPath, activeSession?.autoRunSelectedFile]);
 
-  const updateScratchPadState = useCallback((state: {
+  // Auto Run mode change handler
+  const handleAutoRunModeChange = useCallback((mode: 'edit' | 'preview') => {
+    if (!activeSession) return;
+    setSessions(prev => prev.map(s =>
+      s.id === activeSession.id ? { ...s, autoRunMode: mode } : s
+    ));
+  }, [activeSession]);
+
+  // File tree auto-refresh interval change handler
+  const handleAutoRefreshChange = useCallback((interval: number) => {
+    if (!activeSession) return;
+    setSessions(prev => prev.map(s =>
+      s.id === activeSession.id ? { ...s, fileTreeAutoRefreshInterval: interval } : s
+    ));
+  }, [activeSession]);
+
+  // Auto Run state change handler (scroll/cursor positions)
+  const handleAutoRunStateChange = useCallback((state: {
     mode: 'edit' | 'preview';
     cursorPosition: number;
     editScrollPos: number;
     previewScrollPos: number;
   }) => {
-    setSessions(prev => prev.map(s => s.id === activeSessionId ? {
-      ...s,
-      scratchPadMode: state.mode,
-      scratchPadCursorPosition: state.cursorPosition,
-      scratchPadEditScrollPos: state.editScrollPos,
-      scratchPadPreviewScrollPos: state.previewScrollPos
-    } : s));
-  }, [activeSessionId]);
+    if (!activeSession) return;
+    setSessions(prev => prev.map(s =>
+      s.id === activeSession.id ? {
+        ...s,
+        autoRunMode: state.mode,
+        autoRunCursorPosition: state.cursorPosition,
+        autoRunEditScrollPos: state.editScrollPos,
+        autoRunPreviewScrollPos: state.previewScrollPos,
+      } : s
+    ));
+  }, [activeSession]);
 
-  const processInput = async (overrideInputValue?: string) => {
-    const effectiveInputValue = overrideInputValue ?? inputValue;
-    if (!activeSession || (!effectiveInputValue.trim() && stagedImages.length === 0)) {
+  // Auto Run document selection handler
+  const handleAutoRunSelectDocument = useCallback(async (filename: string) => {
+    if (!activeSession?.autoRunFolderPath) return;
+
+    // Save current document first if there's content
+    if (activeSession.autoRunSelectedFile && autoRunContent) {
+      await window.maestro.autorun.writeDoc(
+        activeSession.autoRunFolderPath,
+        activeSession.autoRunSelectedFile + '.md',
+        autoRunContent
+      );
+    }
+
+    // Load new document content FIRST (before updating selectedFile)
+    // This ensures content prop updates atomically with the file selection
+    const result = await window.maestro.autorun.readDoc(
+      activeSession.autoRunFolderPath,
+      filename + '.md'
+    );
+    const newContent = result.success ? (result.content || '') : '';
+
+    // Update content first, then selected file
+    // This prevents the AutoRun component from seeing mismatched file/content
+    setAutoRunContent(newContent);
+
+    // Then update the selected file
+    setSessions(prev => prev.map(s =>
+      s.id === activeSession.id ? { ...s, autoRunSelectedFile: filename } : s
+    ));
+  }, [activeSession, autoRunContent]);
+
+  // Auto Run refresh handler - reload document list and show flash notification
+  const handleAutoRunRefresh = useCallback(async () => {
+    if (!activeSession?.autoRunFolderPath) return;
+    const previousCount = autoRunDocumentList.length;
+    setAutoRunIsLoadingDocuments(true);
+    const result = await window.maestro.autorun.listDocs(activeSession.autoRunFolderPath);
+    if (result.success) {
+      const newFiles = result.files || [];
+      setAutoRunDocumentList(newFiles);
+      setAutoRunIsLoadingDocuments(false);
+
+      // Show flash notification with result
+      const diff = newFiles.length - previousCount;
+      let message: string;
+      if (diff > 0) {
+        message = `Found ${diff} new document${diff === 1 ? '' : 's'}`;
+      } else if (diff < 0) {
+        message = `${Math.abs(diff)} document${Math.abs(diff) === 1 ? '' : 's'} removed`;
+      } else {
+        message = 'Refresh complete, no new documents';
+      }
+      setSuccessFlashNotification(message);
+      setTimeout(() => setSuccessFlashNotification(null), 2000);
       return;
     }
+    setAutoRunIsLoadingDocuments(false);
+  }, [activeSession?.autoRunFolderPath, autoRunDocumentList.length]);
+
+  // Auto Run open setup handler
+  const handleAutoRunOpenSetup = useCallback(() => {
+    setAutoRunSetupModalOpen(true);
+  }, []);
+
+  // Auto Run create new document handler
+  const handleAutoRunCreateDocument = useCallback(async (filename: string): Promise<boolean> => {
+    if (!activeSession?.autoRunFolderPath) return false;
+
+    try {
+      // Create the document with empty content so placeholder hint shows
+      const result = await window.maestro.autorun.writeDoc(
+        activeSession.autoRunFolderPath,
+        filename + '.md',
+        ''
+      );
+
+      if (result.success) {
+        // Refresh the document list
+        const listResult = await window.maestro.autorun.listDocs(activeSession.autoRunFolderPath);
+        if (listResult.success) {
+          setAutoRunDocumentList(listResult.files || []);
+        }
+
+        // Select the new document and switch to edit mode
+        setSessions(prev => prev.map(s =>
+          s.id === activeSession.id ? { ...s, autoRunSelectedFile: filename, autoRunMode: 'edit' } : s
+        ));
+
+        // Load the new document content
+        const contentResult = await window.maestro.autorun.readDoc(
+          activeSession.autoRunFolderPath,
+          filename + '.md'
+        );
+        if (contentResult.success) {
+          setAutoRunContent(contentResult.content || '');
+        }
+
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error('Failed to create document:', error);
+      return false;
+    }
+  }, [activeSession]);
 
-    // Block slash commands when agent is busy (in AI mode)
-    if (effectiveInputValue.trim().startsWith('/') && activeSession.state === 'busy' && activeSession.inputMode === 'ai') {
-      showFlashNotification('Commands disabled while agent is working');
+  const processInput = async (overrideInputValue?: string) => {
+    const effectiveInputValue = overrideInputValue ?? inputValue;
+    console.log('[processInput] Called with:', {
+      overrideInputValue,
+      inputValue,
+      effectiveInputValue,
+      activeSessionId: activeSession?.id,
+      inputMode: activeSession?.inputMode,
+      stagedImagesCount: stagedImages.length
+    });
+    if (!activeSession || (!effectiveInputValue.trim() && stagedImages.length === 0)) {
+      console.log('[processInput] Early return - no session or empty input');
       return;
     }
 
     // Handle slash commands (custom AI commands only - built-in commands have been removed)
+    // Note: slash commands are queued like regular messages when agent is busy
     if (effectiveInputValue.trim().startsWith('/')) {
       const commandText = effectiveInputValue.trim();
       const isTerminalMode = activeSession.inputMode === 'terminal';
@@ -3803,6 +4183,8 @@ export default function MaestroConsole() {
             // If session is busy, just add to queue - it will be processed when current item finishes
             if (sessionIsIdle) {
               // Set up session and tab state for immediate processing
+              // NOTE: Don't add to executionQueue when processing immediately - it's not actually queued,
+              // and adding it would cause duplicate display (once as sent message, once in queue section)
               setSessions(prev => prev.map(s => {
                 if (s.id !== activeSessionId) return s;
 
@@ -3821,8 +4203,7 @@ export default function MaestroConsole() {
                   currentCycleTokens: 0,
                   currentCycleBytes: 0,
                   aiTabs: updatedAiTabs,
-                  // Add to queue - it will be removed by exit handler or stay for display
-                  executionQueue: [...s.executionQueue, queuedItem],
+                  // Don't add to queue - we're processing immediately, not queuing
                   aiCommandHistory: Array.from(new Set([...(s.aiCommandHistory || []), commandText])).slice(-50),
                 };
               }));
@@ -4829,152 +5210,13 @@ export default function MaestroConsole() {
       } else if (e.key === 'ArrowUp') {
         e.preventDefault();
         setSelectedSlashCommandIndex(prev => Math.max(prev - 1, 0));
-      } else if (e.key === 'Tab') {
-        // Tab just fills in the command text
-        e.preventDefault();
-        setInputValue(filteredCommands[selectedSlashCommandIndex]?.command || inputValue);
-        setSlashCommandOpen(false);
-      } else if (e.key === 'Enter' && filteredCommands.length > 0) {
-        // Enter executes the command directly
+      } else if (e.key === 'Tab' || e.key === 'Enter') {
+        // Tab or Enter fills in the command text (user can then press Enter again to execute)
         e.preventDefault();
-        const selectedCommand = filteredCommands[selectedSlashCommandIndex];
-        if (selectedCommand) {
+        if (filteredCommands[selectedSlashCommandIndex]) {
+          setInputValue(filteredCommands[selectedSlashCommandIndex].command);
           setSlashCommandOpen(false);
-          setInputValue('');
-          if (inputRef.current) inputRef.current.style.height = 'auto';
-
-          // Execute the custom AI command (substitute template variables and send to agent)
-          if ('prompt' in selectedCommand && selectedCommand.prompt) {
-            // Use the same spawn logic as processInput for proper tab-based session ID tracking
-            (async () => {
-              let gitBranch: string | undefined;
-              if (activeSession.isGitRepo) {
-                try {
-                  const status = await gitService.getStatus(activeSession.cwd);
-                  gitBranch = status.branch;
-                } catch {
-                  // Ignore git errors
-                }
-              }
-              const substitutedPrompt = substituteTemplateVariables(
-                selectedCommand.prompt,
-                { session: activeSession, gitBranch }
-              );
-
-              // Get the active tab for proper targeting
-              const activeTab = getActiveTab(activeSession);
-              if (!activeTab) {
-                console.error('[handleInputKeyDown] No active tab for slash command');
-                return;
-              }
-
-              // Build target session ID using tab ID (same pattern as processInput)
-              const targetSessionId = `${activeSessionId}-ai-${activeTab.id}`;
-              const isNewSession = !activeTab.claudeSessionId;
-
-              // Add user log showing the command with its interpolated prompt to active tab
-              const newEntry: LogEntry = {
-                id: generateId(),
-                timestamp: Date.now(),
-                source: 'user',
-                text: substitutedPrompt,
-                aiCommand: {
-                  command: selectedCommand.command,
-                  description: selectedCommand.description
-                }
-              };
-
-              // Update session state: add log, set busy, set awaitingSessionId for new sessions
-              setSessions(prev => prev.map(s => {
-                if (s.id !== activeSessionId) return s;
-
-                // Update the active tab's logs and state
-                const updatedAiTabs = s.aiTabs.map(tab =>
-                  tab.id === activeTab.id
-                    ? {
-                        ...tab,
-                        logs: [...tab.logs, newEntry],
-                        state: 'busy' as const,
-                        thinkingStartTime: Date.now(),
-                        awaitingSessionId: isNewSession ? true : tab.awaitingSessionId
-                      }
-                    : tab
-                );
-
-                return {
-                  ...s,
-                  state: 'busy' as SessionState,
-                  busySource: 'ai',
-                  thinkingStartTime: Date.now(),
-                  currentCycleTokens: 0,
-                  currentCycleBytes: 0,
-                  aiCommandHistory: Array.from(new Set([...(s.aiCommandHistory || []), selectedCommand.command])).slice(-50),
-                  pendingAICommandForSynopsis: selectedCommand.command,
-                  aiTabs: updatedAiTabs
-                };
-              }));
-
-              // Spawn the agent with proper session ID format (same as processInput)
-              try {
-                const agent = await window.maestro.agents.get('claude-code');
-                if (!agent) throw new Error('Claude Code agent not found');
-
-                // Get fresh session state to avoid stale closure
-                const freshSession = sessionsRef.current.find(s => s.id === activeSessionId);
-                if (!freshSession) throw new Error('Session not found');
-
-                const freshActiveTab = getActiveTab(freshSession);
-                const tabClaudeSessionId = freshActiveTab?.claudeSessionId;
-
-                // Build spawn args with resume if we have a session ID
-                const spawnArgs = [...(agent.args || [])];
-                if (tabClaudeSessionId) {
-                  spawnArgs.push('--resume', tabClaudeSessionId);
-                }
-
-                // Add read-only mode if tab has it enabled
-                if (freshActiveTab?.readOnlyMode) {
-                  spawnArgs.push('--permission-mode', 'plan');
-                }
-
-                const commandToUse = agent.path || agent.command;
-                await window.maestro.process.spawn({
-                  sessionId: targetSessionId,
-                  toolType: 'claude-code',
-                  cwd: freshSession.cwd,
-                  command: commandToUse,
-                  args: spawnArgs,
-                  prompt: substitutedPrompt
-                });
-              } catch (error: any) {
-                console.error('[handleInputKeyDown] Failed to spawn Claude for slash command:', error);
-                setSessions(prev => prev.map(s => {
-                  if (s.id !== activeSessionId) return s;
-                  const errorEntry: LogEntry = {
-                    id: generateId(),
-                    timestamp: Date.now(),
-                    source: 'system',
-                    text: `Error: Failed to run ${selectedCommand.command} - ${error.message}`
-                  };
-                  const updatedAiTabs = s.aiTabs.map(tab =>
-                    tab.id === activeTab.id
-                      ? { ...tab, state: 'idle' as const, logs: [...tab.logs, errorEntry] }
-                      : tab
-                  );
-                  return {
-                    ...s,
-                    state: 'idle' as SessionState,
-                    busySource: undefined,
-                    aiTabs: updatedAiTabs
-                  };
-                }));
-              }
-            })();
-          } else {
-            // Claude Code slash command (no prompt property) - send raw command text
-            // Claude Code will expand the command itself from .claude/commands/*.md
-            processInput(selectedCommand.command);
-          }
+          inputRef.current?.focus();
         }
       } else if (e.key === 'Escape') {
         e.preventDefault();
@@ -5160,16 +5402,21 @@ export default function MaestroConsole() {
     }));
   };
 
-  // Refresh file tree for a session
-  const refreshFileTree = useCallback(async (sessionId: string) => {
+  // Refresh file tree for a session and return the changes detected
+  const refreshFileTree = useCallback(async (sessionId: string): Promise<FileTreeChanges | undefined> => {
     const session = sessions.find(s => s.id === sessionId);
-    if (!session) return;
+    if (!session) return undefined;
 
     try {
-      const tree = await loadFileTree(session.cwd);
+      const oldTree = session.fileTree || [];
+      const newTree = await loadFileTree(session.cwd);
+      const changes = compareFileTrees(oldTree, newTree);
+
       setSessions(prev => prev.map(s =>
-        s.id === sessionId ? { ...s, fileTree: tree, fileTreeError: undefined } : s
+        s.id === sessionId ? { ...s, fileTree: newTree, fileTreeError: undefined } : s
       ));
+
+      return changes;
     } catch (error) {
       console.error('File tree refresh error:', error);
       const errorMsg = (error as Error)?.message || 'Unknown error';
@@ -5180,6 +5427,7 @@ export default function MaestroConsole() {
           fileTreeError: `Cannot access directory: ${session.cwd}\n${errorMsg}`
         } : s
       ));
+      return undefined;
     }
   }, [sessions]);
 
@@ -5569,6 +5817,20 @@ export default function MaestroConsole() {
               setTimeout(() => setSuccessFlashNotification(null), 2000);
             }
           }}
+          onDebugReleaseQueuedItem={() => {
+            if (!activeSession || activeSession.executionQueue.length === 0) return;
+            const [nextItem, ...remainingQueue] = activeSession.executionQueue;
+            // Update state to remove item from queue
+            setSessions(prev => prev.map(s => {
+              if (s.id !== activeSessionId) return s;
+              return { ...s, executionQueue: remainingQueue };
+            }));
+            // Process the item
+            processQueuedItem(activeSessionId, nextItem);
+            console.log('[Debug] Released queued item:', nextItem);
+          }}
+          markdownRawMode={markdownRawMode}
+          onToggleMarkdownRawMode={() => setMarkdownRawMode(!markdownRawMode)}
         />
       )}
       {lightboxImage && (
@@ -5855,6 +6117,7 @@ export default function MaestroConsole() {
         setActiveClaudeSessionId={setActiveClaudeSessionId}
         onResumeClaudeSession={(claudeSessionId: string, messages: LogEntry[], sessionName?: string, starred?: boolean) => {
           // Opens the Claude session as a new tab (or switches to existing tab if duplicate)
+          console.log('[onResumeClaudeSession] Called with:', claudeSessionId, 'messages:', messages.length, 'name:', sessionName, 'starred:', starred);
           handleResumeSession(claudeSessionId, messages, sessionName, starred);
         }}
         onNewClaudeSession={() => {
@@ -6237,7 +6500,7 @@ export default function MaestroConsole() {
             rightPanelWidth={rightPanelWidth}
             setRightPanelWidthState={setRightPanelWidth}
             activeRightTab={activeRightTab}
-            setActiveRightTab={setActiveRightTab}
+            setActiveRightTab={handleSetActiveRightTab}
             activeFocus={activeFocus}
             setActiveFocus={setActiveFocus}
             fileTreeFilter={fileTreeFilter}
@@ -6257,8 +6520,18 @@ export default function MaestroConsole() {
             updateSessionWorkingDirectory={updateSessionWorkingDirectory}
             refreshFileTree={refreshFileTree}
             setSessions={setSessions}
-            updateScratchPad={updateScratchPad}
-            updateScratchPadState={updateScratchPadState}
+            onAutoRefreshChange={handleAutoRefreshChange}
+            autoRunDocumentList={autoRunDocumentList}
+            autoRunDocumentTree={autoRunDocumentTree}
+            autoRunContent={autoRunContent}
+            autoRunIsLoadingDocuments={autoRunIsLoadingDocuments}
+            onAutoRunContentChange={handleAutoRunContentChange}
+            onAutoRunModeChange={handleAutoRunModeChange}
+            onAutoRunStateChange={handleAutoRunStateChange}
+            onAutoRunSelectDocument={handleAutoRunSelectDocument}
+            onAutoRunCreateDocument={handleAutoRunCreateDocument}
+            onAutoRunRefresh={handleAutoRunRefresh}
+            onAutoRunOpenSetup={handleAutoRunOpenSetup}
             batchRunState={activeBatchRunState}
             onOpenBatchRunner={handleOpenBatchRunner}
             onStopBatchRun={handleStopBatchRun}
@@ -6269,15 +6542,23 @@ export default function MaestroConsole() {
         </ErrorBoundary>
       )}
 
+      {/* --- AUTO RUN SETUP MODAL --- */}
+      {autoRunSetupModalOpen && (
+        <AutoRunSetupModal
+          theme={theme}
+          onClose={() => setAutoRunSetupModalOpen(false)}
+          onFolderSelected={handleAutoRunFolderSelected}
+          currentFolder={activeSession?.autoRunFolderPath}
+          sessionName={activeSession?.name}
+        />
+      )}
+
       {/* --- BATCH RUNNER MODAL --- */}
-      {batchRunnerModalOpen && activeSession && (
+      {batchRunnerModalOpen && activeSession && activeSession.autoRunFolderPath && (
         <BatchRunnerModal
           theme={theme}
           onClose={() => setBatchRunnerModalOpen(false)}
-          onGo={(prompt) => {
-            // Start the batch run
-            handleStartBatchRun(prompt);
-          }}
+          onGo={handleStartBatchRun}
           onSave={(prompt) => {
             // Save the custom prompt and modification timestamp to the session (persisted across restarts)
             setSessions(prev => prev.map(s =>
@@ -6287,7 +6568,12 @@ export default function MaestroConsole() {
           initialPrompt={activeSession.batchRunnerPrompt || ''}
           lastModifiedAt={activeSession.batchRunnerPromptModifiedAt}
           showConfirmation={showConfirmation}
-          scratchpadContent={activeSession.scratchPadContent}
+          folderPath={activeSession.autoRunFolderPath}
+          currentDocument={activeSession.autoRunSelectedFile || ''}
+          allDocuments={autoRunDocumentList}
+          getDocumentTaskCount={getDocumentTaskCount}
+          sessionId={activeSession.id}
+          sessionCwd={activeSession.cwd}
         />
       )}
 
@@ -6297,25 +6583,17 @@ export default function MaestroConsole() {
           theme={theme}
           tabs={activeSession.aiTabs}
           activeTabId={activeSession.activeTabId}
-          cwd={activeSession.cwd}
+          projectRoot={activeSession.projectRoot}
           shortcut={TAB_SHORTCUTS.tabSwitcher}
           onTabSelect={(tabId) => {
             setSessions(prev => prev.map(s =>
               s.id === activeSession.id ? { ...s, activeTabId: tabId } : s
             ));
           }}
-          onNamedSessionSelect={(claudeSessionId, projectPath, sessionName) => {
-            // Open a closed named session as a new tab in the current session
-            // Note: The session might be from a different project - we'll open it anyway
-            // and let Claude Code handle the context appropriately
-            const result = createTab(activeSession, {
-              claudeSessionId,
-              name: sessionName,
-              logs: [], // Will be populated when the session is resumed
-            });
-            setSessions(prev => prev.map(s =>
-              s.id === activeSession.id ? result.session : s
-            ));
+          onNamedSessionSelect={(claudeSessionId, _projectPath, sessionName, starred) => {
+            // Open a closed named session as a new tab - use handleResumeSession to properly load messages
+            console.log('[onNamedSessionSelect] Opening session:', claudeSessionId, 'name:', sessionName, 'starred:', starred);
+            handleResumeSession(claudeSessionId, [], sessionName, starred);
             // Focus input so user can start interacting immediately
             setActiveFocus('main');
             setTimeout(() => inputRef.current?.focus(), 50);
@@ -6331,6 +6609,12 @@ export default function MaestroConsole() {
         theme={theme}
         initialValue={inputValue}
         onSubmit={(value) => setInputValue(value)}
+        onSend={(value) => {
+          // Set the input value and trigger send
+          setInputValue(value);
+          // Use setTimeout to ensure state updates before processing
+          setTimeout(() => processInput(value), 0);
+        }}
         sessionName={activeSession?.name}
       />
 
diff --git a/src/renderer/components/AboutModal.tsx b/src/renderer/components/AboutModal.tsx
index af1027b51..fbd36f5d4 100644
--- a/src/renderer/components/AboutModal.tsx
+++ b/src/renderer/components/AboutModal.tsx
@@ -192,6 +192,7 @@ export function AboutModal({ theme, sessions, autoRunStats, onClose }: AboutModa
           <AchievementCard
             theme={theme}
             autoRunStats={autoRunStats}
+            globalStats={globalStats}
             onEscapeWithBadgeOpen={(handler) => { badgeEscapeHandlerRef.current = handler; }}
           />
 
diff --git a/src/renderer/components/AchievementCard.tsx b/src/renderer/components/AchievementCard.tsx
index 77e97c7ea..a2f1eb326 100644
--- a/src/renderer/components/AchievementCard.tsx
+++ b/src/renderer/components/AchievementCard.tsx
@@ -125,9 +125,22 @@ function interpolateColor(color1: string, color2: string, t: number): string {
   return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
 }
 
+interface ClaudeGlobalStats {
+  totalSessions: number;
+  totalMessages: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCacheReadTokens: number;
+  totalCacheCreationTokens: number;
+  totalCostUsd: number;
+  totalSizeBytes: number;
+  isComplete?: boolean;
+}
+
 interface AchievementCardProps {
   theme: Theme;
   autoRunStats: AutoRunStats;
+  globalStats?: ClaudeGlobalStats | null;
 }
 
 interface BadgeTooltipProps {
@@ -242,7 +255,7 @@ function BadgeTooltip({ badge, theme, isUnlocked, position, onClose }: BadgeTool
  * Achievement card component for displaying in the About modal
  * Shows current badge, progress to next level, and stats
  */
-export function AchievementCard({ theme, autoRunStats, onEscapeWithBadgeOpen }: AchievementCardProps & { onEscapeWithBadgeOpen?: (handler: (() => boolean) | null) => void }) {
+export function AchievementCard({ theme, autoRunStats, globalStats, onEscapeWithBadgeOpen }: AchievementCardProps & { onEscapeWithBadgeOpen?: (handler: (() => boolean) | null) => void }) {
   const [selectedBadge, setSelectedBadge] = useState<number | null>(null);
   const [historyExpanded, setHistoryExpanded] = useState(false);
   const [shareMenuOpen, setShareMenuOpen] = useState(false);
@@ -345,117 +358,275 @@ export function AchievementCard({ theme, autoRunStats, onEscapeWithBadgeOpen }:
     return lines;
   };
 
+  // Format token count with K/M suffix
+  const formatTokens = (count: number): string => {
+    if (count >= 1_000_000) {
+      return `${(count / 1_000_000).toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+      return `${(count / 1_000).toFixed(1)}K`;
+    }
+    return count.toString();
+  };
+
+  // Draw the maestro conductor silhouette
+  const drawMaestroSilhouette = (ctx: CanvasRenderingContext2D, x: number, y: number, size: number) => {
+    ctx.save();
+    ctx.translate(x, y);
+    const scale = size / 512;
+    ctx.scale(scale, scale);
+
+    ctx.fillStyle = '#FFFFFF';
+
+    // Head - profile facing left
+    ctx.beginPath();
+    ctx.ellipse(180, 80, 55, 60, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Nose bump
+    ctx.beginPath();
+    ctx.ellipse(118, 85, 12, 8, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Hair/top of head
+    ctx.beginPath();
+    ctx.ellipse(185, 35, 40, 25, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Neck
+    ctx.fillRect(155, 130, 50, 40);
+
+    // Collar area
+    ctx.beginPath();
+    ctx.moveTo(140, 165);
+    ctx.lineTo(260, 165);
+    ctx.lineTo(250, 185);
+    ctx.lineTo(150, 185);
+    ctx.closePath();
+    ctx.fill();
+
+    // Bow tie
+    ctx.beginPath();
+    ctx.ellipse(200, 175, 25, 10, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Torso
+    ctx.beginPath();
+    ctx.moveTo(140, 185);
+    ctx.lineTo(120, 350);
+    ctx.lineTo(280, 350);
+    ctx.lineTo(260, 185);
+    ctx.closePath();
+    ctx.fill();
+
+    // Left arm
+    ctx.beginPath();
+    ctx.moveTo(140, 200);
+    ctx.quadraticCurveTo(90, 220, 80, 280);
+    ctx.quadraticCurveTo(75, 300, 90, 310);
+    ctx.lineTo(110, 305);
+    ctx.quadraticCurveTo(120, 290, 115, 260);
+    ctx.quadraticCurveTo(130, 240, 145, 230);
+    ctx.closePath();
+    ctx.fill();
+
+    // Left hand
+    ctx.beginPath();
+    ctx.ellipse(85, 295, 18, 22, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Right arm raised with baton
+    ctx.beginPath();
+    ctx.moveTo(260, 200);
+    ctx.quadraticCurveTo(300, 180, 330, 130);
+    ctx.quadraticCurveTo(340, 115, 355, 100);
+    ctx.lineTo(365, 110);
+    ctx.quadraticCurveTo(350, 130, 340, 145);
+    ctx.quadraticCurveTo(315, 195, 270, 220);
+    ctx.closePath();
+    ctx.fill();
+
+    // Right hand
+    ctx.beginPath();
+    ctx.ellipse(350, 95, 15, 18, 0, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Baton
+    ctx.strokeStyle = '#FFFFFF';
+    ctx.lineWidth = 6;
+    ctx.lineCap = 'round';
+    ctx.beginPath();
+    ctx.moveTo(360, 85);
+    ctx.lineTo(395, 20);
+    ctx.stroke();
+
+    ctx.restore();
+  };
+
   // Generate shareable achievement card as canvas
   const generateShareImage = useCallback(async (): Promise<HTMLCanvasElement> => {
     const canvas = document.createElement('canvas');
     const ctx = canvas.getContext('2d')!;
 
     const width = 600;
-    const height = 400;
+    const height = 380;
     canvas.width = width;
     canvas.height = height;
 
-    // Background gradient
-    const bgGradient = ctx.createLinearGradient(0, 0, width, height);
-    bgGradient.addColorStop(0, '#1a1a2e');
-    bgGradient.addColorStop(1, '#16213e');
+    // Background gradient matching app icon (radial gradient from center)
+    const bgGradient = ctx.createRadialGradient(
+      width / 2, height / 2, 0,
+      width / 2, height / 2, width * 0.7
+    );
+    bgGradient.addColorStop(0, '#2d1f4e');  // Lighter purple center
+    bgGradient.addColorStop(1, '#1a1a2e');  // Dark purple edges
     ctx.fillStyle = bgGradient;
-    ctx.roundRect(0, 0, width, height, 16);
+    ctx.roundRect(0, 0, width, height, 20);
+    ctx.fill();
+
+    // Subtle gradient overlay for depth
+    const overlayGradient = ctx.createLinearGradient(0, 0, 0, height);
+    overlayGradient.addColorStop(0, 'rgba(139, 92, 246, 0.15)');
+    overlayGradient.addColorStop(0.5, 'rgba(0, 0, 0, 0)');
+    overlayGradient.addColorStop(1, 'rgba(0, 0, 0, 0.2)');
+    ctx.fillStyle = overlayGradient;
+    ctx.roundRect(0, 0, width, height, 20);
     ctx.fill();
 
-    // Border
-    ctx.strokeStyle = goldColor;
-    ctx.lineWidth = 3;
-    ctx.roundRect(0, 0, width, height, 16);
+    // Border with purple glow effect
+    ctx.strokeStyle = '#8B5CF6';
+    ctx.lineWidth = 2;
+    ctx.roundRect(0, 0, width, height, 20);
+    ctx.stroke();
+
+    // Outer glow border
+    ctx.strokeStyle = 'rgba(139, 92, 246, 0.3)';
+    ctx.lineWidth = 4;
+    ctx.roundRect(-2, -2, width + 4, height + 4, 22);
     ctx.stroke();
 
-    // Header accent
-    const headerGradient = ctx.createLinearGradient(0, 0, width, 100);
-    headerGradient.addColorStop(0, `${purpleAccent}40`);
-    headerGradient.addColorStop(1, 'transparent');
-    ctx.fillStyle = headerGradient;
-    ctx.fillRect(0, 0, width, 100);
+    // Draw conductor silhouette in top left (subtle, as background element)
+    ctx.save();
+    ctx.globalAlpha = 0.08;
+    drawMaestroSilhouette(ctx, -20, 20, 280);
+    ctx.restore();
+
+    // Trophy icon circle with gradient
+    const trophyX = width / 2;
+    const trophyY = 52;
+    const trophyRadius = 32;
 
-    // Trophy icon (simplified circle)
     ctx.beginPath();
-    ctx.arc(width / 2, 60, 30, 0, Math.PI * 2);
-    const trophyGradient = ctx.createRadialGradient(width / 2, 60, 0, width / 2, 60, 30);
-    trophyGradient.addColorStop(0, '#FFA500');
-    trophyGradient.addColorStop(1, goldColor);
+    ctx.arc(trophyX, trophyY, trophyRadius, 0, Math.PI * 2);
+    const trophyGradient = ctx.createRadialGradient(trophyX, trophyY - 10, 0, trophyX, trophyY, trophyRadius);
+    trophyGradient.addColorStop(0, '#FFE066');
+    trophyGradient.addColorStop(1, '#F59E0B');
     ctx.fillStyle = trophyGradient;
     ctx.fill();
 
     // Trophy emoji
-    ctx.fillStyle = '#FFFFFF';
-    ctx.font = 'bold 28px system-ui';
+    ctx.font = 'bold 32px system-ui';
     ctx.textAlign = 'center';
-    ctx.fillText('🏆', width / 2, 70);
+    ctx.textBaseline = 'middle';
+    ctx.fillStyle = '#78350F';
+    ctx.fillText('🏆', trophyX, trophyY + 2);
 
     // Title
-    ctx.font = 'bold 24px system-ui';
-    ctx.fillStyle = goldColor;
-    ctx.fillText('MAESTRO ACHIEVEMENTS', width / 2, 120);
+    ctx.font = 'bold 18px system-ui';
+    ctx.fillStyle = '#F472B6';  // Pink accent like in screenshots
+    ctx.letterSpacing = '2px';
+    ctx.fillText('MAESTRO ACHIEVEMENTS', width / 2, 105);
 
     if (currentBadge) {
-      // Level badge
-      ctx.font = 'bold 18px system-ui';
+      // Level indicator with stars
+      ctx.font = 'bold 14px system-ui';
       ctx.fillStyle = goldColor;
-      ctx.fillText(`⭐ Level ${currentBadge.level} of 11 ⭐`, width / 2, 155);
-
-      // Badge name
-      ctx.font = 'bold 28px system-ui';
-      ctx.fillStyle = purpleAccent;
-      ctx.fillText(currentBadge.name, width / 2, 190);
-
-      // Flavor text
-      ctx.font = 'italic 14px system-ui';
-      ctx.fillStyle = '#CCCCCC';
-      const flavorLines = wrapText(ctx, `"${currentBadge.flavorText}"`, width - 80);
-      let yOffset = 225;
+      ctx.fillText(`★ Level ${currentBadge.level} of 11 ★`, width / 2, 130);
+
+      // Badge name - larger and more prominent
+      ctx.font = 'bold 26px system-ui';
+      ctx.fillStyle = '#F472B6';
+      ctx.fillText(currentBadge.name, width / 2, 162);
+
+      // Flavor text in quotes
+      ctx.font = 'italic 13px system-ui';
+      ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';
+      const flavorLines = wrapText(ctx, `"${currentBadge.flavorText}"`, width - 100);
+      let yOffset = 190;
       flavorLines.forEach(line => {
         ctx.fillText(line, width / 2, yOffset);
         yOffset += 18;
       });
     } else {
       // No badge yet
-      ctx.font = 'bold 20px system-ui';
-      ctx.fillStyle = '#AAAAAA';
-      ctx.fillText('Journey Just Beginning...', width / 2, 170);
+      ctx.font = 'bold 22px system-ui';
+      ctx.fillStyle = 'rgba(255, 255, 255, 0.7)';
+      ctx.fillText('Journey Just Beginning...', width / 2, 155);
 
       ctx.font = '14px system-ui';
-      ctx.fillStyle = '#888888';
-      ctx.fillText('Complete 15 minutes of AutoRun to unlock first badge', width / 2, 200);
+      ctx.fillStyle = 'rgba(255, 255, 255, 0.5)';
+      ctx.fillText('Complete 15 minutes of AutoRun to unlock first badge', width / 2, 185);
     }
 
-    // Stats box
-    const statsY = 300;
-    ctx.fillStyle = 'rgba(255, 255, 255, 0.1)';
-    ctx.roundRect(50, statsY - 10, width - 100, 50, 8);
+    // Stats container with dark background
+    const statsY = 240;
+    const statsHeight = 85;
+    ctx.fillStyle = 'rgba(0, 0, 0, 0.35)';
+    ctx.roundRect(30, statsY, width - 60, statsHeight, 12);
     ctx.fill();
 
-    ctx.font = '14px system-ui';
-    ctx.fillStyle = '#AAAAAA';
-    ctx.textAlign = 'left';
-    ctx.fillText('Total AutoRun:', 70, statsY + 15);
-    ctx.fillStyle = '#FFFFFF';
-    ctx.font = 'bold 14px system-ui';
-    ctx.fillText(formatCumulativeTime(autoRunStats.cumulativeTimeMs), 180, statsY + 15);
+    // Stats border
+    ctx.strokeStyle = 'rgba(139, 92, 246, 0.3)';
+    ctx.lineWidth = 1;
+    ctx.roundRect(30, statsY, width - 60, statsHeight, 12);
+    ctx.stroke();
 
-    ctx.fillStyle = '#AAAAAA';
-    ctx.font = '14px system-ui';
-    ctx.fillText('Longest Run:', 350, statsY + 15);
-    ctx.fillStyle = '#FFFFFF';
-    ctx.font = 'bold 14px system-ui';
-    ctx.fillText(formatCumulativeTime(autoRunStats.longestRunMs), 450, statsY + 15);
+    // Stats grid - 4 columns
+    const statsColWidth = (width - 60) / 4;
+    const statsCenterY = statsY + statsHeight / 2;
+
+    // Helper to draw a stat
+    const drawStat = (x: number, value: string, label: string) => {
+      ctx.font = 'bold 20px system-ui';
+      ctx.fillStyle = '#FFFFFF';
+      ctx.textAlign = 'center';
+      ctx.fillText(value, x, statsCenterY - 5);
+
+      ctx.font = '11px system-ui';
+      ctx.fillStyle = 'rgba(255, 255, 255, 0.6)';
+      ctx.fillText(label, x, statsCenterY + 15);
+    };
+
+    // Column 1: Total AutoRun
+    drawStat(30 + statsColWidth * 0.5, formatCumulativeTime(autoRunStats.cumulativeTimeMs), 'Total AutoRun');
 
-    // Footer branding
-    ctx.font = 'bold 12px system-ui';
-    ctx.fillStyle = '#666666';
+    // Column 2: Longest Run
+    drawStat(30 + statsColWidth * 1.5, formatCumulativeTime(autoRunStats.longestRunMs), 'Longest Run');
+
+    // Column 3: Sessions (from globalStats)
+    const sessionsValue = globalStats?.totalSessions?.toLocaleString() || '—';
+    drawStat(30 + statsColWidth * 2.5, sessionsValue, 'Sessions');
+
+    // Column 4: Total Tokens (from globalStats)
+    const totalTokens = globalStats
+      ? globalStats.totalInputTokens + globalStats.totalOutputTokens
+      : 0;
+    const tokensValue = totalTokens > 0 ? formatTokens(totalTokens) : '—';
+    drawStat(30 + statsColWidth * 3.5, tokensValue, 'Total Tokens');
+
+    // Footer with branding and GitHub
+    ctx.font = 'bold 11px system-ui';
+    ctx.fillStyle = 'rgba(255, 255, 255, 0.5)';
     ctx.textAlign = 'center';
-    ctx.fillText('MAESTRO • Agent Orchestration Command Center', width / 2, height - 20);
+    ctx.fillText('MAESTRO • Agent Orchestration Command Center', width / 2, height - 30);
+
+    // GitHub link
+    ctx.font = '10px system-ui';
+    ctx.fillStyle = 'rgba(139, 92, 246, 0.8)';
+    ctx.fillText('github.com/pedramamini/Maestro', width / 2, height - 14);
 
     return canvas;
-  }, [currentBadge, autoRunStats.cumulativeTimeMs, autoRunStats.longestRunMs, purpleAccent]);
+  }, [currentBadge, autoRunStats.cumulativeTimeMs, autoRunStats.longestRunMs, globalStats]);
 
   // Copy to clipboard
   const copyToClipboard = useCallback(async () => {
@@ -518,7 +689,7 @@ export function AchievementCard({ theme, autoRunStats, onEscapeWithBadgeOpen }:
 
           {shareMenuOpen && (
             <div
-              className="absolute right-0 top-full mt-1 p-1.5 rounded-lg shadow-xl z-50 min-w-[160px]"
+              className="absolute right-0 top-full mt-1 p-1.5 rounded-lg shadow-xl z-50"
               style={{
                 backgroundColor: theme.colors.bgSidebar,
                 border: `1px solid ${theme.colors.border}`,
@@ -529,12 +700,12 @@ export function AchievementCard({ theme, autoRunStats, onEscapeWithBadgeOpen }:
                   copyToClipboard();
                   setShareMenuOpen(false);
                 }}
-                className="w-full flex items-center gap-2 px-3 py-2 rounded text-sm hover:bg-white/10 transition-colors"
+                className="w-full flex items-center gap-2 px-3 py-2 rounded text-sm whitespace-nowrap hover:bg-white/10 transition-colors"
               >
                 {copySuccess ? (
-                  <Check className="w-4 h-4" style={{ color: theme.colors.success }} />
+                  <Check className="w-4 h-4 shrink-0" style={{ color: theme.colors.success }} />
                 ) : (
-                  <Copy className="w-4 h-4" style={{ color: theme.colors.textDim }} />
+                  <Copy className="w-4 h-4 shrink-0" style={{ color: theme.colors.textDim }} />
                 )}
                 <span style={{ color: theme.colors.textMain }}>
                   {copySuccess ? 'Copied!' : 'Copy to Clipboard'}
@@ -545,9 +716,9 @@ export function AchievementCard({ theme, autoRunStats, onEscapeWithBadgeOpen }:
                   downloadImage();
                   setShareMenuOpen(false);
                 }}
-                className="w-full flex items-center gap-2 px-3 py-2 rounded text-sm hover:bg-white/10 transition-colors"
+                className="w-full flex items-center gap-2 px-3 py-2 rounded text-sm whitespace-nowrap hover:bg-white/10 transition-colors"
               >
-                <Download className="w-4 h-4" style={{ color: theme.colors.textDim }} />
+                <Download className="w-4 h-4 shrink-0" style={{ color: theme.colors.textDim }} />
                 <span style={{ color: theme.colors.textMain }}>Save as Image</span>
               </button>
             </div>
diff --git a/src/renderer/components/AgentPromptComposerModal.tsx b/src/renderer/components/AgentPromptComposerModal.tsx
new file mode 100644
index 000000000..38e293446
--- /dev/null
+++ b/src/renderer/components/AgentPromptComposerModal.tsx
@@ -0,0 +1,220 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { X, FileText, Variable, ChevronDown, ChevronRight } from 'lucide-react';
+import type { Theme } from '../types';
+import { useLayerStack } from '../contexts/LayerStackContext';
+import { MODAL_PRIORITIES } from '../constants/modalPriorities';
+import { TEMPLATE_VARIABLES } from '../utils/templateVariables';
+
+interface AgentPromptComposerModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  theme: Theme;
+  initialValue: string;
+  onSubmit: (value: string) => void;
+}
+
+// Simple token estimation (roughly 4 chars per token for English text)
+function estimateTokenCount(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
+export function AgentPromptComposerModal({
+  isOpen,
+  onClose,
+  theme,
+  initialValue,
+  onSubmit,
+}: AgentPromptComposerModalProps) {
+  const [value, setValue] = useState(initialValue);
+  const [variablesExpanded, setVariablesExpanded] = useState(false);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const { registerLayer, unregisterLayer } = useLayerStack();
+  const onCloseRef = useRef(onClose);
+  onCloseRef.current = onClose;
+  const onSubmitRef = useRef(onSubmit);
+  onSubmitRef.current = onSubmit;
+  const valueRef = useRef(value);
+  valueRef.current = value;
+
+  // Sync value when modal opens with new initialValue
+  useEffect(() => {
+    if (isOpen) {
+      setValue(initialValue);
+    }
+  }, [isOpen, initialValue]);
+
+  // Focus textarea when modal opens
+  useEffect(() => {
+    if (isOpen && textareaRef.current) {
+      textareaRef.current.focus();
+      // Move cursor to end
+      textareaRef.current.selectionStart = textareaRef.current.value.length;
+      textareaRef.current.selectionEnd = textareaRef.current.value.length;
+    }
+  }, [isOpen]);
+
+  // Register with layer stack for Escape handling
+  useEffect(() => {
+    if (isOpen) {
+      const id = registerLayer({
+        type: 'modal',
+        priority: MODAL_PRIORITIES.AGENT_PROMPT_COMPOSER,
+        onEscape: () => {
+          // Save the current value back before closing
+          onSubmitRef.current(valueRef.current);
+          onCloseRef.current();
+        },
+      });
+      return () => unregisterLayer(id);
+    }
+  }, [isOpen, registerLayer, unregisterLayer]);
+
+  if (!isOpen) return null;
+
+  const handleDone = () => {
+    onSubmit(value);
+    onClose();
+  };
+
+  const tokenCount = estimateTokenCount(value);
+
+  return (
+    <div
+      className="fixed inset-0 z-[10001] flex items-center justify-center"
+      style={{ backgroundColor: 'rgba(0,0,0,0.7)' }}
+      onClick={(e) => {
+        if (e.target === e.currentTarget) {
+          onSubmit(value);
+          onClose();
+        }
+      }}
+    >
+      <div
+        className="w-[90vw] h-[85vh] max-w-5xl rounded-xl border shadow-2xl flex flex-col overflow-hidden"
+        style={{
+          backgroundColor: theme.colors.bgMain,
+          borderColor: theme.colors.border,
+        }}
+      >
+        {/* Header */}
+        <div
+          className="flex items-center justify-between px-4 py-3 border-b shrink-0"
+          style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgSidebar }}
+        >
+          <div className="flex items-center gap-2">
+            <FileText className="w-5 h-5" style={{ color: theme.colors.accent }} />
+            <span className="font-medium" style={{ color: theme.colors.textMain }}>
+              Agent Prompt Editor
+            </span>
+          </div>
+          <div className="flex items-center gap-3">
+            <button
+              onClick={handleDone}
+              className="p-1.5 rounded hover:bg-white/10 transition-colors"
+              title="Close (Escape)"
+            >
+              <X className="w-5 h-5" style={{ color: theme.colors.textDim }} />
+            </button>
+          </div>
+        </div>
+
+        {/* Template Variables - Collapsible */}
+        <div
+          className="border-b shrink-0"
+          style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgSidebar }}
+        >
+          <button
+            onClick={() => setVariablesExpanded(!variablesExpanded)}
+            className="w-full px-4 py-2 flex items-center justify-between hover:bg-white/5 transition-colors"
+          >
+            <div className="flex items-center gap-2">
+              <Variable className="w-4 h-4" style={{ color: theme.colors.accent }} />
+              <span className="text-xs font-bold uppercase" style={{ color: theme.colors.textDim }}>
+                Template Variables
+              </span>
+            </div>
+            {variablesExpanded ? (
+              <ChevronDown className="w-4 h-4" style={{ color: theme.colors.textDim }} />
+            ) : (
+              <ChevronRight className="w-4 h-4" style={{ color: theme.colors.textDim }} />
+            )}
+          </button>
+          {variablesExpanded && (
+            <div className="px-4 pb-3 pt-1">
+              <p className="text-xs mb-2" style={{ color: theme.colors.textDim }}>
+                Use these variables in your prompt. They will be replaced with actual values at runtime.
+              </p>
+              <div className="grid grid-cols-2 gap-x-6 gap-y-1 max-h-40 overflow-y-auto scrollbar-thin">
+                {TEMPLATE_VARIABLES.map(({ variable, description }) => (
+                  <div key={variable} className="flex items-center gap-2 py-0.5 min-w-0">
+                    <code
+                      className="text-xs font-mono px-1.5 py-0.5 rounded shrink-0 cursor-pointer hover:opacity-80"
+                      style={{ backgroundColor: theme.colors.bgActivity, color: theme.colors.accent }}
+                      onClick={() => {
+                        // Insert variable at cursor position
+                        if (textareaRef.current) {
+                          const start = textareaRef.current.selectionStart;
+                          const end = textareaRef.current.selectionEnd;
+                          const newValue = value.substring(0, start) + variable + value.substring(end);
+                          setValue(newValue);
+                          // Restore focus and set cursor position after the inserted variable
+                          requestAnimationFrame(() => {
+                            if (textareaRef.current) {
+                              textareaRef.current.focus();
+                              textareaRef.current.selectionStart = start + variable.length;
+                              textareaRef.current.selectionEnd = start + variable.length;
+                            }
+                          });
+                        }
+                      }}
+                      title="Click to insert"
+                    >
+                      {variable}
+                    </code>
+                    <span className="text-xs" style={{ color: theme.colors.textDim }}>
+                      {description}
+                    </span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+
+        {/* Textarea */}
+        <div className="flex-1 p-4 overflow-hidden">
+          <textarea
+            ref={textareaRef}
+            value={value}
+            onChange={(e) => setValue(e.target.value)}
+            className="w-full h-full bg-transparent resize-none outline-none text-sm leading-relaxed scrollbar-thin font-mono"
+            style={{ color: theme.colors.textMain }}
+            placeholder="Enter your agent prompt..."
+          />
+        </div>
+
+        {/* Footer */}
+        <div
+          className="flex items-center justify-between px-4 py-3 border-t shrink-0"
+          style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgSidebar }}
+        >
+          <div className="text-xs flex items-center gap-3" style={{ color: theme.colors.textDim }}>
+            <span>{value.length.toLocaleString()} characters</span>
+            <span>~{tokenCount.toLocaleString()} tokens</span>
+          </div>
+          <button
+            onClick={handleDone}
+            className="flex items-center gap-2 px-4 py-2 rounded-lg font-medium transition-all hover:opacity-90"
+            style={{
+              backgroundColor: theme.colors.accent,
+              color: theme.colors.accentForeground,
+            }}
+          >
+            Done
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/renderer/components/AgentSessionsBrowser.tsx b/src/renderer/components/AgentSessionsBrowser.tsx
index 3861baea8..629d6fcc9 100644
--- a/src/renderer/components/AgentSessionsBrowser.tsx
+++ b/src/renderer/components/AgentSessionsBrowser.tsx
@@ -650,6 +650,7 @@ export function AgentSessionsBrowser({
 
   // Handle resuming a session
   const handleResume = useCallback(() => {
+    console.log('[AgentSessionsBrowser.handleResume] Called, viewingSession:', viewingSession?.sessionId, 'messages:', messages.length);
     if (viewingSession) {
       // Convert messages to LogEntry format for AI terminal
       const logEntries: LogEntry[] = messages.map((msg, idx) => ({
@@ -658,6 +659,7 @@ export function AgentSessionsBrowser({
         source: msg.type === 'user' ? 'user' as const : 'stdout' as const,
         text: msg.content || (msg.toolUse ? `[Tool: ${msg.toolUse[0]?.name || 'unknown'}]` : '[No content]'),
       }));
+      console.log('[AgentSessionsBrowser.handleResume] Converted to', logEntries.length, 'logEntries, calling onResumeSession');
       // Pass session name and starred status for the new tab
       const isStarred = starredSessions.has(viewingSession.sessionId);
       onResumeSession(viewingSession.sessionId, logEntries, viewingSession.sessionName, isStarred);
diff --git a/src/renderer/components/Scratchpad.tsx b/src/renderer/components/AutoRun.tsx
similarity index 67%
rename from src/renderer/components/Scratchpad.tsx
rename to src/renderer/components/AutoRun.tsx
index 9d50c492b..e67b449d7 100644
--- a/src/renderer/components/Scratchpad.tsx
+++ b/src/renderer/components/AutoRun.tsx
@@ -3,20 +3,34 @@ import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter';
 import { vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism';
-import { Eye, Edit, Play, Square, HelpCircle, Loader2, Image, X, Search, ChevronUp, ChevronDown, ChevronRight, ChevronLeft, Copy, Check, Trash2 } from 'lucide-react';
-import type { BatchRunState, SessionState } from '../types';
+import { Eye, Edit, Play, Square, HelpCircle, Loader2, Image, X, Search, ChevronUp, ChevronDown, ChevronRight, ChevronLeft, Copy, Check, Trash2, FolderOpen, FileText, RefreshCw } from 'lucide-react';
+import type { BatchRunState, SessionState, Theme } from '../types';
 import { AutoRunnerHelpModal } from './AutoRunnerHelpModal';
 import { MermaidRenderer } from './MermaidRenderer';
+import { AutoRunDocumentSelector } from './AutoRunDocumentSelector';
 
 // Memoize remarkPlugins array - it never changes
 const REMARK_PLUGINS = [remarkGfm];
 
-interface ScratchpadProps {
-  content: string;
-  onChange: (content: string) => void;
-  theme: any;
+interface AutoRunProps {
+  theme: Theme;
   sessionId: string; // Maestro session ID for per-session attachment storage
-  initialMode?: 'edit' | 'preview';
+
+  // Folder & document state
+  folderPath: string | null;
+  selectedFile: string | null;
+  documentList: string[];  // Filenames without .md
+  documentTree?: Array<{ name: string; type: 'file' | 'folder'; path: string; children?: unknown[] }>;  // Tree structure for subfolders
+
+  // Content state
+  content: string;
+  onContentChange: (content: string) => void;
+
+  // Mode state
+  mode: 'edit' | 'preview';
+  onModeChange: (mode: 'edit' | 'preview') => void;
+
+  // Scroll/cursor state
   initialCursorPosition?: number;
   initialEditScrollPos?: number;
   initialPreviewScrollPos?: number;
@@ -26,28 +40,49 @@ interface ScratchpadProps {
     editScrollPos: number;
     previewScrollPos: number;
   }) => void;
+
+  // Actions
+  onOpenSetup: () => void;
+  onRefresh: () => void;
+  onSelectDocument: (filename: string) => void;
+  onCreateDocument: (filename: string) => Promise<boolean>;
+  isLoadingDocuments?: boolean;
+
   // Batch processing props
   batchRunState?: BatchRunState;
   onOpenBatchRunner?: () => void;
   onStopBatchRun?: () => void;
+
   // Session state for disabling Run when agent is busy
   sessionState?: SessionState;
+
+  // Legacy prop for backwards compatibility
+  onChange?: (content: string) => void;
 }
 
 // Cache for loaded images to avoid repeated IPC calls
 const imageCache = new Map<string, string>();
 
-// Custom image component that loads attachments from the session storage
+// Undo/Redo state interface
+interface UndoState {
+  content: string;
+  cursorPosition: number;
+}
+
+// Maximum undo history entries per document
+const MAX_UNDO_HISTORY = 50;
+
+// Custom image component that loads images from the Auto Run folder or external URLs
 function AttachmentImage({
   src,
   alt,
-  sessionId,
+  folderPath,
   theme,
   onImageClick
 }: {
   src?: string;
   alt?: string;
-  sessionId: string;
+  folderPath: string | null;
   theme: any;
   onImageClick?: (filename: string) => void;
 }) {
@@ -62,11 +97,11 @@ function AttachmentImage({
       return;
     }
 
-    // Check if this is an attachment reference (maestro-attachment://filename)
-    if (src.startsWith('maestro-attachment://')) {
-      const fname = src.replace('maestro-attachment://', '');
+    // Check if this is a relative path (e.g., images/{docName}-{timestamp}.{ext})
+    if (src.startsWith('images/') && folderPath) {
+      const fname = src.split('/').pop() || src;
       setFilename(fname);
-      const cacheKey = `${sessionId}:${fname}`;
+      const cacheKey = `${folderPath}:${src}`;
 
       // Check cache first
       if (imageCache.has(cacheKey)) {
@@ -75,16 +110,22 @@ function AttachmentImage({
         return;
       }
 
-      // Load from attachment storage
-      window.maestro.attachments.load(sessionId, fname).then(result => {
-        if (result.success && result.dataUrl) {
-          imageCache.set(cacheKey, result.dataUrl);
-          setDataUrl(result.dataUrl);
-        } else {
-          setError(result.error || 'Failed to load image');
-        }
-        setLoading(false);
-      });
+      // Load from folder using absolute path
+      const absolutePath = `${folderPath}/${src}`;
+      window.maestro.fs.readFile(absolutePath)
+        .then((result) => {
+          if (result.startsWith('data:')) {
+            imageCache.set(cacheKey, result);
+            setDataUrl(result);
+          } else {
+            setError('Invalid image data');
+          }
+          setLoading(false);
+        })
+        .catch((err) => {
+          setError(`Failed to load image: ${err.message || 'Unknown error'}`);
+          setLoading(false);
+        });
     } else if (src.startsWith('data:')) {
       // Already a data URL
       setDataUrl(src);
@@ -112,9 +153,10 @@ function AttachmentImage({
           setLoading(false);
         });
     } else {
-      // Relative path or other - try to load as file (may fail if not an absolute path)
+      // Other relative path - try to load as file from folderPath if available
       setFilename(src.split('/').pop() || null);
-      window.maestro.fs.readFile(src)
+      const pathToLoad = folderPath ? `${folderPath}/${src}` : src;
+      window.maestro.fs.readFile(pathToLoad)
         .then((result) => {
           if (result.startsWith('data:')) {
             setDataUrl(result);
@@ -128,7 +170,7 @@ function AttachmentImage({
           setLoading(false);
         });
     }
-  }, [src, sessionId]);
+  }, [src, folderPath]);
 
   if (loading) {
     return (
@@ -303,25 +345,49 @@ function ImagePreview({
 }
 
 // Inner implementation component
-function ScratchpadInner({
-  content,
-  onChange,
+function AutoRunInner({
   theme,
   sessionId,
-  initialMode = 'edit',
+  folderPath,
+  selectedFile,
+  documentList,
+  documentTree,
+  content,
+  onContentChange,
+  mode: externalMode,
+  onModeChange,
   initialCursorPosition = 0,
   initialEditScrollPos = 0,
   initialPreviewScrollPos = 0,
   onStateChange,
+  onOpenSetup,
+  onRefresh,
+  onSelectDocument,
+  onCreateDocument,
+  isLoadingDocuments = false,
   batchRunState,
   onOpenBatchRunner,
   onStopBatchRun,
-  sessionState
-}: ScratchpadProps) {
+  sessionState,
+  onChange,  // Legacy prop for backwards compatibility
+}: AutoRunProps) {
   const isLocked = batchRunState?.isRunning || false;
   const isAgentBusy = sessionState === 'busy' || sessionState === 'connecting';
   const isStopping = batchRunState?.isStopping || false;
-  const [mode, setMode] = useState<'edit' | 'preview'>(initialMode);
+
+  // Use external mode if provided, otherwise use local state
+  const [localMode, setLocalMode] = useState<'edit' | 'preview'>(externalMode || 'edit');
+  const mode = externalMode || localMode;
+  const setMode = useCallback((newMode: 'edit' | 'preview') => {
+    if (onModeChange) {
+      onModeChange(newMode);
+    } else {
+      setLocalMode(newMode);
+    }
+  }, [onModeChange]);
+
+  // Use onContentChange if provided, otherwise fall back to legacy onChange
+  const handleContentChange = onContentChange || onChange || (() => {});
 
   // Local content state for responsive typing - syncs to parent on blur
   const [localContent, setLocalContent] = useState(content);
@@ -329,6 +395,131 @@ function ScratchpadInner({
   // Track if user is actively editing (to avoid overwriting their changes)
   const isEditingRef = useRef(false);
 
+  // Auto-save timer ref for 5-second debounce
+  const autoSaveTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Track the last saved content to avoid unnecessary saves
+  const lastSavedContentRef = useRef<string>(content);
+
+  // Undo/Redo history maps - keyed by document filename (selectedFile)
+  // Using refs so history persists across re-renders without triggering re-renders
+  const undoHistoryRef = useRef<Map<string, UndoState[]>>(new Map());
+  const redoHistoryRef = useRef<Map<string, UndoState[]>>(new Map());
+  // Track last content that was snapshotted for undo
+  const lastUndoSnapshotRef = useRef<string>(content);
+  // Timer ref for debounced undo snapshots
+  const undoSnapshotTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Push current state to undo history (call BEFORE making changes)
+  const pushUndoState = useCallback((contentToSnapshot?: string, cursorPos?: number) => {
+    if (!selectedFile) return;
+
+    const snapshotContent = contentToSnapshot ?? localContent;
+    const snapshotCursor = cursorPos ?? textareaRef.current?.selectionStart ?? 0;
+
+    // Only push if content actually differs from last snapshot
+    if (snapshotContent === lastUndoSnapshotRef.current) return;
+
+    const currentState: UndoState = {
+      content: snapshotContent,
+      cursorPosition: snapshotCursor,
+    };
+
+    // Get or create history array for this document
+    const history = undoHistoryRef.current.get(selectedFile) || [];
+    history.push(currentState);
+
+    // Limit to MAX_UNDO_HISTORY entries
+    if (history.length > MAX_UNDO_HISTORY) {
+      history.shift();
+    }
+
+    undoHistoryRef.current.set(selectedFile, history);
+
+    // Update last snapshot reference
+    lastUndoSnapshotRef.current = snapshotContent;
+
+    // Clear redo stack on new edit action
+    redoHistoryRef.current.set(selectedFile, []);
+  }, [selectedFile, localContent]);
+
+  // Schedule a debounced undo snapshot (called on each content change)
+  const scheduleUndoSnapshot = useCallback((previousContent: string, previousCursor: number) => {
+    // Clear any pending snapshot
+    if (undoSnapshotTimeoutRef.current) {
+      clearTimeout(undoSnapshotTimeoutRef.current);
+    }
+
+    // Schedule snapshot after 1 second of inactivity
+    undoSnapshotTimeoutRef.current = setTimeout(() => {
+      pushUndoState(previousContent, previousCursor);
+    }, 1000);
+  }, [pushUndoState]);
+
+  // Handle undo (Cmd+Z)
+  const handleUndo = useCallback(() => {
+    if (!selectedFile) return;
+
+    const undoStack = undoHistoryRef.current.get(selectedFile) || [];
+    if (undoStack.length === 0) return;
+
+    // Save current state to redo stack before undoing
+    const redoStack = redoHistoryRef.current.get(selectedFile) || [];
+    redoStack.push({
+      content: localContent,
+      cursorPosition: textareaRef.current?.selectionStart || 0,
+    });
+    redoHistoryRef.current.set(selectedFile, redoStack);
+
+    // Pop and apply the undo state
+    const prevState = undoStack.pop()!;
+    undoHistoryRef.current.set(selectedFile, undoStack);
+
+    // Update content without pushing to undo stack
+    setLocalContent(prevState.content);
+    lastUndoSnapshotRef.current = prevState.content;
+
+    // Restore cursor position after React re-renders
+    requestAnimationFrame(() => {
+      if (textareaRef.current) {
+        textareaRef.current.setSelectionRange(prevState.cursorPosition, prevState.cursorPosition);
+        textareaRef.current.focus();
+      }
+    });
+  }, [selectedFile, localContent]);
+
+  // Handle redo (Cmd+Shift+Z)
+  const handleRedo = useCallback(() => {
+    if (!selectedFile) return;
+
+    const redoStack = redoHistoryRef.current.get(selectedFile) || [];
+    if (redoStack.length === 0) return;
+
+    // Save current state to undo stack before redoing
+    const undoStack = undoHistoryRef.current.get(selectedFile) || [];
+    undoStack.push({
+      content: localContent,
+      cursorPosition: textareaRef.current?.selectionStart || 0,
+    });
+    undoHistoryRef.current.set(selectedFile, undoStack);
+
+    // Pop and apply the redo state
+    const nextState = redoStack.pop()!;
+    redoHistoryRef.current.set(selectedFile, redoStack);
+
+    // Update content without pushing to undo stack
+    setLocalContent(nextState.content);
+    lastUndoSnapshotRef.current = nextState.content;
+
+    // Restore cursor position after React re-renders
+    requestAnimationFrame(() => {
+      if (textareaRef.current) {
+        textareaRef.current.setSelectionRange(nextState.cursorPosition, nextState.cursorPosition);
+        textareaRef.current.focus();
+      }
+    });
+  }, [selectedFile, localContent]);
+
   // Sync local content from prop when session changes (switching sessions)
   useEffect(() => {
     if (sessionId !== prevSessionIdRef.current) {
@@ -351,9 +542,67 @@ function ScratchpadInner({
   const syncContentToParent = useCallback(() => {
     isEditingRef.current = false;
     if (localContent !== content) {
-      onChange(localContent);
+      handleContentChange(localContent);
+    }
+  }, [localContent, content, handleContentChange]);
+
+  // Auto-save to disk with 5-second debounce
+  useEffect(() => {
+    // Only save if we have a folder and selected file
+    if (!folderPath || !selectedFile) return;
+
+    // Never auto-save empty content - this prevents wiping files during load
+    if (!localContent) return;
+
+    // Only save if content has actually changed from last saved
+    if (localContent === lastSavedContentRef.current) return;
+
+    // Clear any existing timeout
+    if (autoSaveTimeoutRef.current) {
+      clearTimeout(autoSaveTimeoutRef.current);
     }
-  }, [localContent, content, onChange]);
+
+    // Schedule save after 5 seconds of inactivity
+    autoSaveTimeoutRef.current = setTimeout(async () => {
+      // Double-check content hasn't been externally synced
+      if (localContent !== lastSavedContentRef.current) {
+        try {
+          await window.maestro.autorun.writeDoc(folderPath, selectedFile + '.md', localContent);
+          lastSavedContentRef.current = localContent;
+          // Also sync to parent state so UI stays consistent
+          handleContentChange(localContent);
+        } catch (err) {
+          console.error('Auto-save failed:', err);
+        }
+      }
+    }, 5000);
+
+    // Cleanup on unmount or when dependencies change
+    return () => {
+      if (autoSaveTimeoutRef.current) {
+        clearTimeout(autoSaveTimeoutRef.current);
+      }
+    };
+  }, [localContent, folderPath, selectedFile, handleContentChange]);
+
+  // Clear auto-save timer and update lastSavedContent when document changes (session or file change)
+  useEffect(() => {
+    // Clear pending auto-save when document changes
+    if (autoSaveTimeoutRef.current) {
+      clearTimeout(autoSaveTimeoutRef.current);
+      autoSaveTimeoutRef.current = null;
+    }
+    // Clear pending undo snapshot when document changes
+    if (undoSnapshotTimeoutRef.current) {
+      clearTimeout(undoSnapshotTimeoutRef.current);
+      undoSnapshotTimeoutRef.current = null;
+    }
+    // Reset lastSavedContent to the new content
+    lastSavedContentRef.current = content;
+    // Reset lastUndoSnapshot to the new content (so first edit creates a proper undo point)
+    lastUndoSnapshotRef.current = content;
+  }, [selectedFile, sessionId, content]);
+
   // Track mode before auto-run to restore when it ends
   const modeBeforeAutoRunRef = useRef<'edit' | 'preview' | null>(null);
   const [helpModalOpen, setHelpModalOpen] = useState(false);
@@ -371,6 +620,8 @@ function ScratchpadInner({
   const [currentMatchIndex, setCurrentMatchIndex] = useState(0);
   const [totalMatches, setTotalMatches] = useState(0);
   const matchElementsRef = useRef<HTMLElement[]>([]);
+  // Refresh animation state for empty state button
+  const [isRefreshingEmpty, setIsRefreshingEmpty] = useState(false);
   const searchInputRef = useRef<HTMLInputElement>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const previewRef = useRef<HTMLDivElement>(null);
@@ -380,24 +631,33 @@ function ScratchpadInner({
   const previewScrollPosRef = useRef(initialPreviewScrollPos);
   const editScrollPosRef = useRef(initialEditScrollPos);
 
-  // Load existing attachments for this session
+  // Load existing images for the current document from the Auto Run folder
   useEffect(() => {
-    if (sessionId) {
-      window.maestro.attachments.list(sessionId).then(result => {
-        if (result.success) {
-          setAttachmentsList(result.files);
-          // Load previews for existing attachments
-          result.files.forEach(filename => {
-            window.maestro.attachments.load(sessionId, filename).then(loadResult => {
-              if (loadResult.success && loadResult.dataUrl) {
-                setAttachmentPreviews(prev => new Map(prev).set(filename, loadResult.dataUrl!));
+    if (folderPath && selectedFile) {
+      window.maestro.autorun.listImages(folderPath, selectedFile).then((result: { success: boolean; images?: { filename: string; relativePath: string }[]; error?: string }) => {
+        if (result.success && result.images) {
+          // Store relative paths (e.g., "images/{docName}-{timestamp}.{ext}")
+          const relativePaths = result.images.map((img: { filename: string; relativePath: string }) => img.relativePath);
+          setAttachmentsList(relativePaths);
+          // Load previews for existing images
+          result.images.forEach((img: { filename: string; relativePath: string }) => {
+            const absolutePath = `${folderPath}/${img.relativePath}`;
+            window.maestro.fs.readFile(absolutePath).then(dataUrl => {
+              if (dataUrl.startsWith('data:')) {
+                setAttachmentPreviews(prev => new Map(prev).set(img.relativePath, dataUrl));
               }
+            }).catch(() => {
+              // Image file might be missing, ignore
             });
           });
         }
       });
+    } else {
+      // Clear attachments when no document is selected
+      setAttachmentsList([]);
+      setAttachmentPreviews(new Map());
     }
-  }, [sessionId]);
+  }, [folderPath, selectedFile]);
 
   // Auto-switch to preview mode when auto-run starts, restore when it ends
   useEffect(() => {
@@ -462,6 +722,54 @@ function ScratchpadInner({
     }
   }, [mode]);
 
+  // Track previous selectedFile to detect document changes
+  const prevSelectedFileRef = useRef(selectedFile);
+  // Track previous content to detect when content prop actually changes
+  const prevContentRef = useRef(content);
+
+  // Handle document selection change - focus and reset editing state
+  useEffect(() => {
+    if (!selectedFile) return;
+
+    const isNewDocument = selectedFile !== prevSelectedFileRef.current;
+    prevSelectedFileRef.current = selectedFile;
+
+    if (isNewDocument) {
+      // Reset editing flag so content syncs properly for new document
+      isEditingRef.current = false;
+      // Reset lastSavedContent to prevent auto-save from firing with stale comparison
+      lastSavedContentRef.current = content;
+      // Focus on document change
+      requestAnimationFrame(() => {
+        if (mode === 'edit' && textareaRef.current) {
+          textareaRef.current.focus();
+        } else if (mode === 'preview' && previewRef.current) {
+          previewRef.current.focus();
+        }
+      });
+    }
+  }, [selectedFile, content, mode]);
+
+  // Sync content from prop - only when content prop actually changes
+  useEffect(() => {
+    // Skip if no document selected
+    if (!selectedFile) return;
+
+    // Only sync when the content PROP actually changed (not just a re-render)
+    const contentPropChanged = content !== prevContentRef.current;
+    prevContentRef.current = content;
+
+    if (!contentPropChanged) return;
+
+    // Skip if user is actively editing - don't overwrite their changes
+    if (isEditingRef.current) return;
+
+    // Content prop changed - sync to local state
+    setLocalContent(content);
+    // Update lastSavedContent so auto-save knows this is the baseline
+    lastSavedContentRef.current = content;
+  }, [selectedFile, content]);
+
   // Save cursor position and scroll position when they change
   const handleCursorOrScrollChange = () => {
     if (textareaRef.current) {
@@ -493,6 +801,17 @@ function ScratchpadInner({
     }
   };
 
+  // Handle refresh for empty state with animation
+  const handleEmptyStateRefresh = useCallback(async () => {
+    setIsRefreshingEmpty(true);
+    try {
+      await onRefresh();
+    } finally {
+      // Keep spinner visible for at least 500ms for visual feedback
+      setTimeout(() => setIsRefreshingEmpty(false), 500);
+    }
+  }, [onRefresh]);
+
   // Open search function
   const openSearch = useCallback(() => {
     setSearchOpen(true);
@@ -602,44 +921,66 @@ function ScratchpadInner({
 
   // Handle image paste
   const handlePaste = useCallback(async (e: React.ClipboardEvent) => {
-    if (isLocked || !sessionId) return;
+    if (isLocked || !folderPath || !selectedFile) {
+      console.log('[AutoRun] Paste blocked:', { isLocked, folderPath, selectedFile });
+      return;
+    }
 
     const items = e.clipboardData?.items;
-    if (!items) return;
+    if (!items) {
+      console.log('[AutoRun] No clipboard items');
+      return;
+    }
 
+    console.log('[AutoRun] Clipboard items:', items.length);
     for (let i = 0; i < items.length; i++) {
       const item = items[i];
+      console.log('[AutoRun] Item', i, ':', item.type);
       if (item.type.startsWith('image/')) {
         e.preventDefault();
 
         const file = item.getAsFile();
-        if (!file) continue;
+        if (!file) {
+          console.log('[AutoRun] Could not get file from item');
+          continue;
+        }
+
+        console.log('[AutoRun] Processing image:', file.name, file.type, file.size);
 
         // Read as base64
         const reader = new FileReader();
         reader.onload = async (event) => {
           const base64Data = event.target?.result as string;
-          if (!base64Data) return;
+          if (!base64Data) {
+            console.log('[AutoRun] No base64 data');
+            return;
+          }
 
-          // Generate unique filename
-          const timestamp = Date.now();
+          // Extract the base64 content without the data URL prefix
+          const base64Content = base64Data.replace(/^data:image\/\w+;base64,/, '');
           const extension = item.type.split('/')[1] || 'png';
-          const filename = `image_${timestamp}.${extension}`;
 
-          // Save to attachments
-          const result = await window.maestro.attachments.save(sessionId, base64Data, filename);
-          if (result.success && result.filename) {
-            // Update attachments list
-            setAttachmentsList(prev => [...prev, result.filename!]);
-            setAttachmentPreviews(prev => new Map(prev).set(result.filename!, base64Data));
+          console.log('[AutoRun] Saving image to:', folderPath, 'doc:', selectedFile, 'ext:', extension);
 
-            // Insert markdown reference at cursor position
+          // Save to Auto Run folder using the new API
+          const result = await window.maestro.autorun.saveImage(folderPath, selectedFile, base64Content, extension);
+          console.log('[AutoRun] Save result:', result);
+          if (result.success && result.relativePath) {
+            // Update attachments list with the relative path
+            const filename = result.relativePath.split('/').pop() || result.relativePath;
+            setAttachmentsList(prev => [...prev, result.relativePath!]);
+            setAttachmentPreviews(prev => new Map(prev).set(result.relativePath!, base64Data));
+
+            // Insert markdown reference at cursor position using relative path
             const textarea = textareaRef.current;
             if (textarea) {
               const cursorPos = textarea.selectionStart;
               const textBefore = localContent.substring(0, cursorPos);
               const textAfter = localContent.substring(cursorPos);
-              const imageMarkdown = `![${result.filename}](maestro-attachment://${result.filename})`;
+              const imageMarkdown = `![${filename}](${result.relativePath})`;
+
+              // Push undo state before modifying content
+              pushUndoState();
 
               // Add newlines if not at start of line
               let prefix = '';
@@ -654,7 +995,8 @@ function ScratchpadInner({
               const newContent = textBefore + prefix + imageMarkdown + suffix + textAfter;
               // Update local state and sync to parent immediately for explicit user action
               setLocalContent(newContent);
-              onChange(newContent);
+              handleContentChange(newContent);
+              lastUndoSnapshotRef.current = newContent;
 
               // Move cursor after the inserted markdown
               const newCursorPos = cursorPos + prefix.length + imageMarkdown.length + suffix.length;
@@ -669,61 +1011,77 @@ function ScratchpadInner({
         break; // Only handle first image
       }
     }
-  }, [localContent, isLocked, onChange, sessionId]);
+  }, [localContent, isLocked, handleContentChange, folderPath, selectedFile, pushUndoState]);
 
   // Handle file input for manual image upload
   const handleFileSelect = useCallback(async (e: React.ChangeEvent<HTMLInputElement>) => {
     const file = e.target.files?.[0];
-    if (!file || !sessionId) return;
+    if (!file || !folderPath || !selectedFile) return;
 
     const reader = new FileReader();
     reader.onload = async (event) => {
       const base64Data = event.target?.result as string;
       if (!base64Data) return;
 
-      const timestamp = Date.now();
+      // Extract the base64 content without the data URL prefix
+      const base64Content = base64Data.replace(/^data:image\/\w+;base64,/, '');
       const extension = file.name.split('.').pop() || 'png';
-      const filename = `image_${timestamp}.${extension}`;
 
-      const result = await window.maestro.attachments.save(sessionId, base64Data, filename);
-      if (result.success && result.filename) {
-        setAttachmentsList(prev => [...prev, result.filename!]);
-        setAttachmentPreviews(prev => new Map(prev).set(result.filename!, base64Data));
+      // Save to Auto Run folder using the new API
+      const result = await window.maestro.autorun.saveImage(folderPath, selectedFile, base64Content, extension);
+      if (result.success && result.relativePath) {
+        const filename = result.relativePath.split('/').pop() || result.relativePath;
+        setAttachmentsList(prev => [...prev, result.relativePath!]);
+        setAttachmentPreviews(prev => new Map(prev).set(result.relativePath!, base64Data));
+
+        // Push undo state before modifying content
+        pushUndoState();
 
         // Insert at end of content - update local and sync to parent immediately
-        const imageMarkdown = `\n![${result.filename}](maestro-attachment://${result.filename})\n`;
+        const imageMarkdown = `\n![${filename}](${result.relativePath})\n`;
         const newContent = localContent + imageMarkdown;
         setLocalContent(newContent);
-        onChange(newContent);
+        handleContentChange(newContent);
+        lastUndoSnapshotRef.current = newContent;
       }
     };
     reader.readAsDataURL(file);
 
     // Reset input so same file can be selected again
     e.target.value = '';
-  }, [localContent, onChange, sessionId]);
+  }, [localContent, handleContentChange, folderPath, selectedFile, pushUndoState]);
 
-  // Handle removing an attachment
-  const handleRemoveAttachment = useCallback(async (filename: string) => {
-    if (!sessionId) return;
+  // Handle removing an attachment (relativePath is like "images/{docName}-{timestamp}.{ext}")
+  const handleRemoveAttachment = useCallback(async (relativePath: string) => {
+    if (!folderPath) return;
 
-    await window.maestro.attachments.delete(sessionId, filename);
-    setAttachmentsList(prev => prev.filter(f => f !== filename));
+    // Delete the image file
+    await window.maestro.autorun.deleteImage(folderPath, relativePath);
+    setAttachmentsList(prev => prev.filter(f => f !== relativePath));
     setAttachmentPreviews(prev => {
       const newMap = new Map(prev);
-      newMap.delete(filename);
+      newMap.delete(relativePath);
       return newMap;
     });
 
+    // Push undo state before modifying content
+    pushUndoState();
+
+    // Extract just the filename for the alt text pattern
+    const filename = relativePath.split('/').pop() || relativePath;
     // Remove the markdown reference from content - update local and sync to parent immediately
-    const regex = new RegExp(`!\\[${filename}\\]\\(maestro-attachment://${filename}\\)\\n?`, 'g');
+    // Match both the full relative path and just filename in the alt text
+    const escapedPath = relativePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`!\\[${escapedFilename}\\]\\(${escapedPath}\\)\\n?`, 'g');
     const newContent = localContent.replace(regex, '');
     setLocalContent(newContent);
-    onChange(newContent);
+    handleContentChange(newContent);
+    lastUndoSnapshotRef.current = newContent;
 
     // Clear from cache
-    imageCache.delete(`${sessionId}:${filename}`);
-  }, [localContent, onChange, sessionId]);
+    imageCache.delete(`${folderPath}:${relativePath}`);
+  }, [localContent, handleContentChange, folderPath, pushUndoState]);
 
   // Lightbox helpers - handles both attachment filenames and external URLs
   const openLightboxByFilename = useCallback((filenameOrUrl: string) => {
@@ -783,14 +1141,14 @@ function ScratchpadInner({
   }, [lightboxFilename, lightboxExternalUrl, attachmentPreviews]);
 
   const deleteLightboxImage = useCallback(async () => {
-    if (!lightboxFilename || !sessionId) return;
+    if (!lightboxFilename || !folderPath) return;
 
     // Store the current index before deletion
     const currentIndex = lightboxCurrentIndex;
     const totalImages = attachmentsList.length;
 
-    // Delete the attachment
-    await window.maestro.attachments.delete(sessionId, lightboxFilename);
+    // Delete the image file using autorun API
+    await window.maestro.autorun.deleteImage(folderPath, lightboxFilename);
     setAttachmentsList(prev => prev.filter(f => f !== lightboxFilename));
     setAttachmentPreviews(prev => {
       const newMap = new Map(prev);
@@ -798,14 +1156,22 @@ function ScratchpadInner({
       return newMap;
     });
 
+    // Push undo state before modifying content
+    pushUndoState();
+
+    // Extract just the filename for the alt text pattern
+    const filename = lightboxFilename.split('/').pop() || lightboxFilename;
     // Remove the markdown reference from content - update local and sync to parent immediately
-    const regex = new RegExp(`!\\[${lightboxFilename}\\]\\(maestro-attachment://${lightboxFilename}\\)\\n?`, 'g');
+    const escapedPath = lightboxFilename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`!\\[${escapedFilename}\\]\\(${escapedPath}\\)\\n?`, 'g');
     const newContent = localContent.replace(regex, '');
     setLocalContent(newContent);
-    onChange(newContent);
+    handleContentChange(newContent);
+    lastUndoSnapshotRef.current = newContent;
 
     // Clear from cache
-    imageCache.delete(`${sessionId}:${lightboxFilename}`);
+    imageCache.delete(`${folderPath}:${lightboxFilename}`);
 
     // Navigate to next/prev image or close lightbox
     if (totalImages <= 1) {
@@ -820,9 +1186,21 @@ function ScratchpadInner({
       const newList = attachmentsList.filter(f => f !== lightboxFilename);
       setLightboxFilename(newList[currentIndex] || null);
     }
-  }, [lightboxFilename, lightboxCurrentIndex, attachmentsList, sessionId, localContent, onChange, closeLightbox]);
+  }, [lightboxFilename, lightboxCurrentIndex, attachmentsList, folderPath, localContent, handleContentChange, closeLightbox, pushUndoState]);
 
   const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
+    // Cmd+Z to undo, Cmd+Shift+Z to redo
+    if ((e.metaKey || e.ctrlKey) && e.key === 'z') {
+      e.preventDefault();
+      e.stopPropagation();
+      if (e.shiftKey) {
+        handleRedo();
+      } else {
+        handleUndo();
+      }
+      return;
+    }
+
     // Command-E to toggle between edit and preview
     if ((e.metaKey || e.ctrlKey) && e.key === 'e') {
       e.preventDefault();
@@ -849,6 +1227,9 @@ function ScratchpadInner({
       const textBeforeCursor = localContent.substring(0, cursorPos);
       const textAfterCursor = localContent.substring(cursorPos);
 
+      // Push undo state before modifying content
+      pushUndoState();
+
       // Check if we're at the start of a line or have text before
       const lastNewline = textBeforeCursor.lastIndexOf('\n');
       const lineStart = lastNewline === -1 ? 0 : lastNewline + 1;
@@ -868,6 +1249,8 @@ function ScratchpadInner({
       }
 
       setLocalContent(newContent);
+      // Update lastUndoSnapshot since we pushed state explicitly
+      lastUndoSnapshotRef.current = newContent;
       setTimeout(() => {
         if (textareaRef.current) {
           textareaRef.current.setSelectionRange(newCursorPos, newCursorPos);
@@ -893,8 +1276,11 @@ function ScratchpadInner({
         // Task list: continue with unchecked checkbox
         const indent = taskListMatch[1];
         e.preventDefault();
+        // Push undo state before modifying content
+        pushUndoState();
         const newContent = textBeforeCursor + '\n' + indent + '- [ ] ' + textAfterCursor;
         setLocalContent(newContent);
+        lastUndoSnapshotRef.current = newContent;
         setTimeout(() => {
           if (textareaRef.current) {
             const newPos = cursorPos + indent.length + 7; // "\n" + indent + "- [ ] "
@@ -906,8 +1292,11 @@ function ScratchpadInner({
         const indent = unorderedListMatch[1];
         const marker = unorderedListMatch[2];
         e.preventDefault();
+        // Push undo state before modifying content
+        pushUndoState();
         const newContent = textBeforeCursor + '\n' + indent + marker + ' ' + textAfterCursor;
         setLocalContent(newContent);
+        lastUndoSnapshotRef.current = newContent;
         setTimeout(() => {
           if (textareaRef.current) {
             const newPos = cursorPos + indent.length + 3; // "\n" + indent + marker + " "
@@ -919,8 +1308,11 @@ function ScratchpadInner({
         const indent = orderedListMatch[1];
         const num = parseInt(orderedListMatch[2]);
         e.preventDefault();
+        // Push undo state before modifying content
+        pushUndoState();
         const newContent = textBeforeCursor + '\n' + indent + (num + 1) + '. ' + textAfterCursor;
         setLocalContent(newContent);
+        lastUndoSnapshotRef.current = newContent;
         setTimeout(() => {
           if (textareaRef.current) {
             const newPos = cursorPos + indent.length + (num + 1).toString().length + 3; // "\n" + indent + num + ". "
@@ -1032,22 +1424,23 @@ function ScratchpadInner({
       <AttachmentImage
         src={src}
         alt={alt}
-        sessionId={sessionId}
+        folderPath={folderPath}
         theme={theme}
         onImageClick={openLightboxByFilename}
         {...props}
       />
     )
-  }), [theme, sessionId, openLightboxByFilename]);
+  }), [theme, folderPath, openLightboxByFilename]);
 
   return (
     <div
       ref={containerRef}
-      className="h-full flex flex-col outline-none"
+      className="h-full flex flex-col outline-none relative"
       tabIndex={-1}
       onKeyDown={(e) => {
         if ((e.metaKey || e.ctrlKey) && e.key === 'e') {
           e.preventDefault();
+          e.stopPropagation();
           toggleMode();
         }
         // CMD+F to open search (works in both modes from container)
@@ -1059,6 +1452,23 @@ function ScratchpadInner({
         }
       }}
     >
+      {/* Select Folder Button - shown when no folder is configured */}
+      {!folderPath && (
+        <div className="pt-2 flex justify-center">
+          <button
+            onClick={onOpenSetup}
+            className="flex items-center gap-1.5 px-3 py-1.5 rounded text-xs font-medium transition-colors hover:opacity-90"
+            style={{
+              backgroundColor: theme.colors.accent,
+              color: theme.colors.accentForeground,
+            }}
+          >
+            <FolderOpen className="w-3.5 h-3.5" />
+            Select Auto Run Folder
+          </button>
+        </div>
+      )}
+
       {/* Mode Toggle */}
       <div className="flex gap-2 mb-3 justify-center pt-2">
         <button
@@ -1148,7 +1558,7 @@ function ScratchpadInner({
               color: theme.colors.accentForeground,
               border: `1px solid ${theme.colors.accent}`
             }}
-            title={isAgentBusy ? "Cannot run while agent is thinking" : "Run batch processing on scratchpad tasks"}
+            title={isAgentBusy ? "Cannot run while agent is thinking" : "Run batch processing on Auto Run tasks"}
           >
             <Play className="w-3.5 h-3.5" />
             Run
@@ -1165,6 +1575,23 @@ function ScratchpadInner({
         </button>
       </div>
 
+      {/* Document Selector */}
+      {folderPath && (
+        <div className="px-2 mb-2">
+          <AutoRunDocumentSelector
+            theme={theme}
+            documents={documentList}
+            documentTree={documentTree as import('./AutoRunDocumentSelector').DocTreeNode[] | undefined}
+            selectedDocument={selectedFile}
+            onSelectDocument={onSelectDocument}
+            onRefresh={onRefresh}
+            onChangeFolder={onOpenSetup}
+            onCreateDocument={onCreateDocument}
+            isLoading={isLoadingDocuments}
+          />
+        </div>
+      )}
+
       {/* Attached Images Preview (edit mode) */}
       {mode === 'edit' && attachmentsList.length > 0 && (
         <div
@@ -1267,22 +1694,76 @@ function ScratchpadInner({
       )}
 
       {/* Content Area */}
-      <div className="flex-1 overflow-hidden">
-        {mode === 'edit' ? (
+      <div className="flex-1 min-h-0">
+        {/* Empty folder state - show when folder is configured but has no documents */}
+        {folderPath && documentList.length === 0 && !isLoadingDocuments ? (
+          <div
+            className="h-full flex flex-col items-center justify-center text-center px-6"
+            style={{ color: theme.colors.textDim }}
+          >
+            <div
+              className="w-16 h-16 rounded-full flex items-center justify-center mb-4"
+              style={{ backgroundColor: theme.colors.bgActivity }}
+            >
+              <FileText className="w-8 h-8" style={{ color: theme.colors.textDim }} />
+            </div>
+            <h3
+              className="text-lg font-semibold mb-2"
+              style={{ color: theme.colors.textMain }}
+            >
+              No Documents Found
+            </h3>
+            <p className="mb-4 max-w-xs text-sm">
+              The selected folder doesn't contain any markdown (.md) files.
+            </p>
+            <p className="mb-6 max-w-xs text-xs" style={{ color: theme.colors.textDim }}>
+              Create a markdown file in the folder to get started, or select a different folder.
+            </p>
+            <div className="flex gap-3">
+              <button
+                onClick={handleEmptyStateRefresh}
+                className="flex items-center gap-2 px-4 py-2 rounded text-sm transition-colors hover:opacity-90"
+                style={{
+                  backgroundColor: 'transparent',
+                  color: theme.colors.textMain,
+                  border: `1px solid ${theme.colors.border}`,
+                }}
+              >
+                <RefreshCw className={`w-4 h-4 ${isRefreshingEmpty ? 'animate-spin' : ''}`} />
+                Refresh
+              </button>
+              <button
+                onClick={onOpenSetup}
+                className="flex items-center gap-2 px-4 py-2 rounded text-sm transition-colors hover:opacity-90"
+                style={{
+                  backgroundColor: theme.colors.accent,
+                  color: theme.colors.accentForeground,
+                }}
+              >
+                <FolderOpen className="w-4 h-4" />
+                Change Folder
+              </button>
+            </div>
+          </div>
+        ) : mode === 'edit' ? (
           <textarea
             ref={textareaRef}
             value={localContent}
             onChange={(e) => {
               if (!isLocked) {
                 isEditingRef.current = true;
+                // Schedule undo snapshot with current content before the change
+                const previousContent = localContent;
+                const previousCursor = textareaRef.current?.selectionStart || 0;
                 setLocalContent(e.target.value);
+                scheduleUndoSnapshot(previousContent, previousCursor);
               }
             }}
             onFocus={() => { isEditingRef.current = true; }}
             onBlur={syncContentToParent}
             onKeyDown={!isLocked ? handleKeyDown : undefined}
             onPaste={handlePaste}
-            placeholder="Write your notes in markdown... (paste images from clipboard)"
+            placeholder="Capture notes, images, and tasks in Markdown."
             readOnly={isLocked}
             className={`w-full h-full border rounded p-4 bg-transparent outline-none resize-none font-mono text-sm ${isLocked ? 'cursor-not-allowed opacity-70' : ''}`}
             style={{
@@ -1441,14 +1922,19 @@ function ScratchpadInner({
   );
 }
 
-// Memoized Scratchpad component with custom comparison to prevent unnecessary re-renders
-export const Scratchpad = memo(ScratchpadInner, (prevProps, nextProps) => {
+// Memoized AutoRun component with custom comparison to prevent unnecessary re-renders
+export const AutoRun = memo(AutoRunInner, (prevProps, nextProps) => {
   // Only re-render when these specific props actually change
   return (
     prevProps.content === nextProps.content &&
     prevProps.sessionId === nextProps.sessionId &&
-    prevProps.initialMode === nextProps.initialMode &&
+    prevProps.mode === nextProps.mode &&
     prevProps.theme === nextProps.theme &&
+    // Document state
+    prevProps.folderPath === nextProps.folderPath &&
+    prevProps.selectedFile === nextProps.selectedFile &&
+    prevProps.documentList === nextProps.documentList &&
+    prevProps.isLoadingDocuments === nextProps.isLoadingDocuments &&
     // Compare batch run state values, not object reference
     prevProps.batchRunState?.isRunning === nextProps.batchRunState?.isRunning &&
     prevProps.batchRunState?.isStopping === nextProps.batchRunState?.isStopping &&
@@ -1457,10 +1943,14 @@ export const Scratchpad = memo(ScratchpadInner, (prevProps, nextProps) => {
     // Session state affects UI (busy disables Run button)
     prevProps.sessionState === nextProps.sessionState &&
     // Callbacks are typically stable, but check identity
-    prevProps.onChange === nextProps.onChange &&
+    prevProps.onContentChange === nextProps.onContentChange &&
+    prevProps.onModeChange === nextProps.onModeChange &&
     prevProps.onStateChange === nextProps.onStateChange &&
     prevProps.onOpenBatchRunner === nextProps.onOpenBatchRunner &&
-    prevProps.onStopBatchRun === nextProps.onStopBatchRun
+    prevProps.onStopBatchRun === nextProps.onStopBatchRun &&
+    prevProps.onOpenSetup === nextProps.onOpenSetup &&
+    prevProps.onRefresh === nextProps.onRefresh &&
+    prevProps.onSelectDocument === nextProps.onSelectDocument
     // Note: initialCursorPosition, initialEditScrollPos, initialPreviewScrollPos
     // are intentionally NOT compared - they're only used on mount
   );
diff --git a/src/renderer/components/AutoRunDocumentSelector.tsx b/src/renderer/components/AutoRunDocumentSelector.tsx
new file mode 100644
index 000000000..762bf2d42
--- /dev/null
+++ b/src/renderer/components/AutoRunDocumentSelector.tsx
@@ -0,0 +1,491 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { ChevronDown, ChevronRight, RefreshCw, FolderOpen, Plus, Folder } from 'lucide-react';
+import type { Theme } from '../types';
+
+// Tree node type for folder structure
+export interface DocTreeNode {
+  name: string;
+  type: 'file' | 'folder';
+  path: string;
+  children?: DocTreeNode[];
+}
+
+interface AutoRunDocumentSelectorProps {
+  theme: Theme;
+  documents: string[];  // List of document filenames (without .md extension) - flat list for backwards compat
+  documentTree?: DocTreeNode[];  // Tree structure for folder display
+  selectedDocument: string | null;
+  onSelectDocument: (filename: string) => void;
+  onRefresh: () => void;
+  onChangeFolder: () => void;
+  onCreateDocument: (filename: string) => Promise<boolean>;  // Returns true if created successfully
+  isLoading?: boolean;
+}
+
+export function AutoRunDocumentSelector({
+  theme,
+  documents,
+  documentTree,
+  selectedDocument,
+  onSelectDocument,
+  onRefresh,
+  onChangeFolder,
+  onCreateDocument,
+  isLoading = false,
+}: AutoRunDocumentSelectorProps) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [showCreateModal, setShowCreateModal] = useState(false);
+  const [newDocName, setNewDocName] = useState('');
+  const [isCreating, setIsCreating] = useState(false);
+  const [expandedFolders, setExpandedFolders] = useState<Set<string>>(new Set());
+  const [selectedCreateFolder, setSelectedCreateFolder] = useState<string>('');  // For creating in subfolder
+  const dropdownRef = useRef<HTMLDivElement>(null);
+  const buttonRef = useRef<HTMLButtonElement>(null);
+  const createInputRef = useRef<HTMLInputElement>(null);
+
+  // Check for duplicate document name (including path)
+  const normalizedNewName = newDocName.trim().toLowerCase().replace(/\.md$/i, '');
+  const fullNewPath = selectedCreateFolder
+    ? `${selectedCreateFolder}/${normalizedNewName}`.toLowerCase()
+    : normalizedNewName;
+  const isDuplicate = fullNewPath && documents.some(
+    doc => doc.toLowerCase() === fullNewPath
+  );
+
+  // Toggle folder expansion
+  const toggleFolder = (folderPath: string) => {
+    setExpandedFolders(prev => {
+      const next = new Set(prev);
+      if (next.has(folderPath)) {
+        next.delete(folderPath);
+      } else {
+        next.add(folderPath);
+      }
+      return next;
+    });
+  };
+
+  // Get display name for selected document (just the filename, not full path)
+  const getDisplayName = (path: string) => {
+    const parts = path.split('/');
+    return parts[parts.length - 1];
+  };
+
+  // Close dropdown when clicking outside
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) {
+        setIsOpen(false);
+      }
+    }
+
+    if (isOpen) {
+      document.addEventListener('mousedown', handleClickOutside);
+      return () => document.removeEventListener('mousedown', handleClickOutside);
+    }
+  }, [isOpen]);
+
+  // Close dropdown on Escape
+  useEffect(() => {
+    function handleKeyDown(event: KeyboardEvent) {
+      if (event.key === 'Escape' && isOpen) {
+        setIsOpen(false);
+        buttonRef.current?.focus();
+      }
+    }
+
+    if (isOpen) {
+      document.addEventListener('keydown', handleKeyDown);
+      return () => document.removeEventListener('keydown', handleKeyDown);
+    }
+  }, [isOpen]);
+
+  // Focus input when create modal opens
+  useEffect(() => {
+    if (showCreateModal) {
+      requestAnimationFrame(() => {
+        createInputRef.current?.focus();
+      });
+    }
+  }, [showCreateModal]);
+
+  const handleSelectDocument = (doc: string) => {
+    onSelectDocument(doc);
+    setIsOpen(false);
+  };
+
+  const handleCreateDocument = async () => {
+    const trimmedName = newDocName.trim();
+    if (!trimmedName || isCreating || isDuplicate) return;
+
+    setIsCreating(true);
+
+    // Add .md extension if not present
+    let filename = trimmedName;
+    if (!filename.toLowerCase().endsWith('.md')) {
+      filename += '.md';
+    }
+
+    // Remove .md for the document name (our convention)
+    let docName = filename.replace(/\.md$/i, '');
+
+    // Include folder path if creating in a subfolder
+    if (selectedCreateFolder) {
+      docName = `${selectedCreateFolder}/${docName}`;
+    }
+
+    const success = await onCreateDocument(docName);
+
+    if (success) {
+      setShowCreateModal(false);
+      setNewDocName('');
+    }
+
+    setIsCreating(false);
+  };
+
+  const handleCloseCreateModal = () => {
+    setShowCreateModal(false);
+    setNewDocName('');
+    setSelectedCreateFolder('');
+  };
+
+  // Extract folders from tree for the create modal folder selector
+  const getFoldersFromTree = (nodes: DocTreeNode[], parentPath: string = ''): { path: string; name: string; depth: number }[] => {
+    const folders: { path: string; name: string; depth: number }[] = [];
+    const depth = parentPath ? parentPath.split('/').length : 0;
+
+    for (const node of nodes) {
+      if (node.type === 'folder') {
+        folders.push({ path: node.path, name: node.name, depth });
+        if (node.children) {
+          folders.push(...getFoldersFromTree(node.children, node.path));
+        }
+      }
+    }
+    return folders;
+  };
+
+  const availableFolders = documentTree ? getFoldersFromTree(documentTree) : [];
+
+  // Render tree node recursively
+  const renderTreeNode = (node: DocTreeNode, depth: number = 0): React.ReactNode => {
+    const isExpanded = expandedFolders.has(node.path);
+    const paddingLeft = depth * 16 + 12;
+
+    if (node.type === 'folder') {
+      return (
+        <div key={node.path}>
+          <button
+            onClick={() => toggleFolder(node.path)}
+            className="w-full flex items-center gap-1.5 py-1.5 text-sm transition-colors hover:bg-white/5"
+            style={{ paddingLeft, color: theme.colors.textDim }}
+          >
+            {isExpanded ? (
+              <ChevronDown className="w-3 h-3 shrink-0" />
+            ) : (
+              <ChevronRight className="w-3 h-3 shrink-0" />
+            )}
+            <Folder className="w-3.5 h-3.5 shrink-0" style={{ color: theme.colors.accent }} />
+            <span className="truncate">{node.name}</span>
+          </button>
+          {isExpanded && node.children && (
+            <div>
+              {node.children.map(child => renderTreeNode(child, depth + 1))}
+            </div>
+          )}
+        </div>
+      );
+    }
+
+    // File node
+    return (
+      <button
+        key={node.path}
+        onClick={() => handleSelectDocument(node.path)}
+        className="w-full text-left py-1.5 text-sm transition-colors hover:bg-white/5"
+        style={{
+          paddingLeft,
+          color: node.path === selectedDocument ? theme.colors.accent : theme.colors.textMain,
+          backgroundColor: node.path === selectedDocument ? theme.colors.bgActivity : 'transparent',
+        }}
+      >
+        {node.name}
+      </button>
+    );
+  };
+
+  return (
+    <>
+      <div className="flex items-center gap-2 mb-3">
+        {/* Document Dropdown */}
+        <div ref={dropdownRef} className="relative flex-1">
+          <button
+            ref={buttonRef}
+            onClick={() => setIsOpen(!isOpen)}
+            className="w-full flex items-center justify-between px-3 py-2 rounded text-sm transition-colors hover:opacity-90"
+            style={{
+              backgroundColor: theme.colors.bgActivity,
+              color: theme.colors.textMain,
+              border: `1px solid ${theme.colors.border}`,
+            }}
+          >
+            <span className="truncate">
+              {selectedDocument || 'Select a document...'}
+            </span>
+            <ChevronDown
+              className={`w-4 h-4 ml-2 shrink-0 transition-transform ${isOpen ? 'rotate-180' : ''}`}
+              style={{ color: theme.colors.textDim }}
+            />
+          </button>
+
+          {/* Dropdown Menu */}
+          {isOpen && (
+            <div
+              className="absolute top-full left-0 right-0 mt-1 rounded shadow-lg overflow-hidden z-50"
+              style={{
+                backgroundColor: theme.colors.bgSidebar,
+                border: `1px solid ${theme.colors.border}`,
+                maxHeight: '300px',
+                overflowY: 'auto',
+              }}
+            >
+              {documents.length === 0 ? (
+                <div
+                  className="px-3 py-2 text-sm"
+                  style={{ color: theme.colors.textDim }}
+                >
+                  No markdown files found
+                </div>
+              ) : documentTree && documentTree.length > 0 ? (
+                // Render tree structure if available
+                <div className="py-1">
+                  {documentTree.map(node => renderTreeNode(node))}
+                </div>
+              ) : (
+                // Fallback to flat list
+                documents.map((doc) => (
+                  <button
+                    key={doc}
+                    onClick={() => handleSelectDocument(doc)}
+                    className="w-full text-left px-3 py-2 text-sm transition-colors hover:bg-white/5"
+                    style={{
+                      color: doc === selectedDocument ? theme.colors.accent : theme.colors.textMain,
+                      backgroundColor: doc === selectedDocument ? theme.colors.bgActivity : 'transparent',
+                    }}
+                  >
+                    {doc}
+                  </button>
+                ))
+              )}
+
+              {/* Divider */}
+              <div
+                className="border-t my-1"
+                style={{ borderColor: theme.colors.border }}
+              />
+
+              {/* Change Folder Option */}
+              <button
+                onClick={() => {
+                  setIsOpen(false);
+                  onChangeFolder();
+                }}
+                className="w-full flex items-center gap-2 px-3 py-2 text-sm transition-colors hover:bg-white/5"
+                style={{ color: theme.colors.textDim }}
+              >
+                <FolderOpen className="w-4 h-4" />
+                Change Folder...
+              </button>
+            </div>
+          )}
+        </div>
+
+        {/* Create New Document Button */}
+        <button
+          onClick={() => setShowCreateModal(true)}
+          className="p-2 rounded transition-colors hover:bg-white/10"
+          style={{
+            color: theme.colors.textDim,
+            border: `1px solid ${theme.colors.border}`,
+          }}
+          title="Create new document"
+        >
+          <Plus className="w-4 h-4" />
+        </button>
+
+        {/* Refresh Button */}
+        <button
+          onClick={onRefresh}
+          disabled={isLoading}
+          className={`p-2 rounded transition-colors hover:bg-white/10 ${isLoading ? 'opacity-50 cursor-not-allowed' : ''}`}
+          style={{
+            color: theme.colors.textDim,
+            border: `1px solid ${theme.colors.border}`,
+          }}
+          title="Refresh document list"
+        >
+          <RefreshCw className={`w-4 h-4 ${isLoading ? 'animate-spin' : ''}`} />
+        </button>
+
+        {/* Change Folder Button */}
+        <button
+          onClick={onChangeFolder}
+          className="p-2 rounded transition-colors hover:bg-white/10"
+          style={{
+            color: theme.colors.textDim,
+            border: `1px solid ${theme.colors.border}`,
+          }}
+          title="Change folder"
+        >
+          <FolderOpen className="w-4 h-4" />
+        </button>
+      </div>
+
+      {/* Create New Document Modal */}
+      {showCreateModal && (
+        <div
+          className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-[10000] animate-in fade-in duration-200"
+          role="dialog"
+          aria-modal="true"
+          aria-label="Create New Document"
+          onClick={(e) => {
+            if (e.target === e.currentTarget) {
+              handleCloseCreateModal();
+            }
+          }}
+          onKeyDown={(e) => {
+            if (e.key === 'Escape') {
+              e.stopPropagation();
+              handleCloseCreateModal();
+            }
+          }}
+        >
+          <div
+            className="w-[400px] border rounded-lg shadow-2xl overflow-hidden"
+            style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+            onClick={(e) => e.stopPropagation()}
+          >
+            {/* Header */}
+            <div
+              className="p-4 border-b flex items-center justify-between"
+              style={{ borderColor: theme.colors.border }}
+            >
+              <div className="flex items-center gap-2">
+                <Plus className="w-4 h-4" style={{ color: theme.colors.accent }} />
+                <h3 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
+                  Create New Document
+                </h3>
+              </div>
+            </div>
+
+            {/* Content */}
+            <div className="p-6 space-y-4">
+              {/* Folder Selector - only show if there are subfolders */}
+              {availableFolders.length > 0 && (
+                <div>
+                  <label
+                    className="block text-xs mb-2 font-medium"
+                    style={{ color: theme.colors.textDim }}
+                  >
+                    Location
+                  </label>
+                  <select
+                    value={selectedCreateFolder}
+                    onChange={(e) => setSelectedCreateFolder(e.target.value)}
+                    className="w-full p-3 rounded border bg-transparent outline-none cursor-pointer"
+                    style={{
+                      borderColor: theme.colors.border,
+                      color: theme.colors.textMain,
+                      backgroundColor: theme.colors.bgActivity
+                    }}
+                  >
+                    <option value="" style={{ backgroundColor: theme.colors.bgSidebar }}>
+                      Root folder
+                    </option>
+                    {availableFolders.map(folder => (
+                      <option
+                        key={folder.path}
+                        value={folder.path}
+                        style={{ backgroundColor: theme.colors.bgSidebar }}
+                      >
+                        {'  '.repeat(folder.depth)}{folder.depth > 0 ? '└ ' : ''}{folder.name}/
+                      </option>
+                    ))}
+                  </select>
+                </div>
+              )}
+
+              {/* Document Name Input */}
+              <div>
+                <label
+                  className="block text-xs mb-2 font-medium"
+                  style={{ color: theme.colors.textDim }}
+                >
+                  Document Name
+                </label>
+                <input
+                  ref={createInputRef}
+                  type="text"
+                  value={newDocName}
+                  onChange={(e) => setNewDocName(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter' && newDocName.trim() && !isDuplicate) {
+                      e.preventDefault();
+                      handleCreateDocument();
+                    }
+                  }}
+                  placeholder="my-tasks"
+                  className="w-full p-3 rounded border bg-transparent outline-none focus:ring-1"
+                  style={{
+                    borderColor: isDuplicate ? theme.colors.error : theme.colors.border,
+                    color: theme.colors.textMain
+                  }}
+                />
+                {isDuplicate ? (
+                  <p className="text-xs mt-2" style={{ color: theme.colors.error }}>
+                    A document with this name already exists{selectedCreateFolder ? ` in ${selectedCreateFolder}` : ''}
+                  </p>
+                ) : (
+                  <p className="text-xs mt-2" style={{ color: theme.colors.textDim }}>
+                    {selectedCreateFolder
+                      ? `Will create: ${selectedCreateFolder}/${newDocName || 'my-tasks'}.md`
+                      : 'The .md extension will be added automatically if not provided.'
+                    }
+                  </p>
+                )}
+              </div>
+            </div>
+
+            {/* Footer */}
+            <div
+              className="p-4 border-t flex justify-end gap-3"
+              style={{ borderColor: theme.colors.border }}
+            >
+              <button
+                type="button"
+                onClick={handleCloseCreateModal}
+                className="px-4 py-2 rounded border hover:bg-white/5 transition-colors"
+                style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+              >
+                Cancel
+              </button>
+              <button
+                type="button"
+                onClick={handleCreateDocument}
+                disabled={!newDocName.trim() || isCreating || isDuplicate}
+                className="px-4 py-2 rounded font-bold transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+                style={{
+                  backgroundColor: theme.colors.accent,
+                  color: theme.colors.accentForeground
+                }}
+              >
+                {isCreating ? 'Creating...' : 'Create'}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </>
+  );
+}
diff --git a/src/renderer/components/AutoRunSetupModal.tsx b/src/renderer/components/AutoRunSetupModal.tsx
new file mode 100644
index 000000000..07b8d9f36
--- /dev/null
+++ b/src/renderer/components/AutoRunSetupModal.tsx
@@ -0,0 +1,308 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { X, Folder, FileText, Play, CheckSquare } from 'lucide-react';
+import type { Theme } from '../types';
+import { useLayerStack } from '../contexts/LayerStackContext';
+import { MODAL_PRIORITIES } from '../constants/modalPriorities';
+
+interface AutoRunSetupModalProps {
+  theme: Theme;
+  onClose: () => void;
+  onFolderSelected: (folderPath: string) => void;
+  currentFolder?: string; // If changing existing folder
+  sessionName?: string; // Name of the agent session
+}
+
+export function AutoRunSetupModal({ theme, onClose, onFolderSelected, currentFolder, sessionName }: AutoRunSetupModalProps) {
+  const [selectedFolder, setSelectedFolder] = useState(currentFolder || '');
+  const [homeDir, setHomeDir] = useState<string>('');
+  const [folderValidation, setFolderValidation] = useState<{
+    checking: boolean;
+    valid: boolean;
+    docCount: number;
+    error?: string;
+  }>({ checking: false, valid: false, docCount: 0 });
+  const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
+  const layerIdRef = useRef<string>();
+  const modalRef = useRef<HTMLDivElement>(null);
+  const continueButtonRef = useRef<HTMLButtonElement>(null);
+
+  // Fetch home directory on mount for tilde expansion
+  useEffect(() => {
+    window.maestro.fs.homeDir().then(setHomeDir);
+  }, []);
+
+  // Expand tilde in path
+  const expandTilde = (path: string): string => {
+    if (!homeDir) return path;
+    if (path === '~') return homeDir;
+    if (path.startsWith('~/')) return homeDir + path.slice(1);
+    return path;
+  };
+
+  // Validate folder and count markdown documents (debounced)
+  useEffect(() => {
+    if (!selectedFolder.trim()) {
+      setFolderValidation({ checking: false, valid: false, docCount: 0 });
+      return;
+    }
+
+    // If path starts with ~ but homeDir isn't loaded yet, wait
+    if (selectedFolder.startsWith('~') && !homeDir) {
+      setFolderValidation({ checking: true, valid: false, docCount: 0 });
+      return;
+    }
+
+    // Debounce the validation
+    const timeoutId = setTimeout(async () => {
+      setFolderValidation(prev => ({ ...prev, checking: true }));
+
+      try {
+        // Expand tilde inline to avoid closure issues
+        let expandedPath = selectedFolder.trim();
+        if (homeDir) {
+          if (expandedPath === '~') {
+            expandedPath = homeDir;
+          } else if (expandedPath.startsWith('~/')) {
+            expandedPath = homeDir + expandedPath.slice(1);
+          }
+        }
+
+        const result = await window.maestro.autorun.listDocs(expandedPath);
+
+        if (result.success) {
+          setFolderValidation({
+            checking: false,
+            valid: true,
+            docCount: result.files?.length || 0
+          });
+        } else {
+          setFolderValidation({
+            checking: false,
+            valid: false,
+            docCount: 0,
+            error: 'Folder not found or not accessible'
+          });
+        }
+      } catch {
+        setFolderValidation({
+          checking: false,
+          valid: false,
+          docCount: 0,
+          error: 'Failed to access folder'
+        });
+      }
+    }, 300);
+
+    return () => clearTimeout(timeoutId);
+  }, [selectedFolder, homeDir]);
+
+  // Register layer on mount
+  useEffect(() => {
+    const id = registerLayer({
+      type: 'modal',
+      priority: MODAL_PRIORITIES.AUTORUN_SETUP,
+      blocksLowerLayers: true,
+      capturesFocus: true,
+      focusTrap: 'strict',
+      ariaLabel: 'Set Up Auto Run',
+      onEscape: onClose,
+    });
+    layerIdRef.current = id;
+
+    return () => {
+      if (layerIdRef.current) {
+        unregisterLayer(layerIdRef.current);
+      }
+    };
+  }, [registerLayer, unregisterLayer]);
+
+  // Update handler when dependencies change
+  useEffect(() => {
+    if (layerIdRef.current) {
+      updateLayerHandler(layerIdRef.current, onClose);
+    }
+  }, [onClose, updateLayerHandler]);
+
+  const handleSelectFolder = async () => {
+    const folder = await window.maestro.dialog.selectFolder();
+    if (folder) {
+      setSelectedFolder(folder);
+      // Focus continue button after folder picker selection (not on typing)
+      requestAnimationFrame(() => {
+        continueButtonRef.current?.focus();
+      });
+    }
+  };
+
+  const handleContinue = () => {
+    if (selectedFolder) {
+      // Expand tilde before passing to callback
+      const expandedPath = expandTilde(selectedFolder.trim());
+      onFolderSelected(expandedPath);
+      onClose();
+    }
+  };
+
+  return (
+    <div
+      className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-[9999] animate-in fade-in duration-200"
+      role="dialog"
+      aria-modal="true"
+      aria-label="Set Up Auto Run"
+      tabIndex={-1}
+      ref={modalRef}
+      onKeyDown={(e) => {
+        // Handle Cmd+O for folder picker
+        if ((e.key === 'o' || e.key === 'O') && (e.metaKey || e.ctrlKey)) {
+          e.preventDefault();
+          e.stopPropagation();
+          handleSelectFolder();
+          return;
+        }
+        // Handle Enter for continue when folder is selected
+        if (e.key === 'Enter' && selectedFolder) {
+          e.preventDefault();
+          e.stopPropagation();
+          handleContinue();
+          return;
+        }
+        // Stop propagation of all other keyboard events
+        if (e.key !== 'Escape') {
+          e.stopPropagation();
+        }
+      }}
+    >
+      <div
+        className="w-[520px] rounded-xl border shadow-2xl overflow-hidden"
+        style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+      >
+        {/* Header */}
+        <div className="p-4 border-b flex items-center justify-between" style={{ borderColor: theme.colors.border }}>
+          <h2 className="text-lg font-bold" style={{ color: theme.colors.textMain }}>
+            {currentFolder ? 'Change Auto Run Folder' : 'Set Up Auto Run'}
+          </h2>
+          <button onClick={onClose} style={{ color: theme.colors.textDim }}>
+            <X className="w-5 h-5" />
+          </button>
+        </div>
+
+        {/* Body */}
+        <div className="p-6 space-y-5">
+          {/* Explanation */}
+          <div className="space-y-4">
+            <p className="text-sm leading-relaxed" style={{ color: theme.colors.textMain }}>
+              Auto Run lets you manage and execute Markdown documents containing open tasks.
+              Select a folder that contains your task documents. Each Maestro agent is assigned its own working folder.
+            </p>
+
+            {/* Feature list */}
+            <div className="space-y-3">
+              <div className="flex items-start gap-3">
+                <FileText className="w-5 h-5 mt-0.5 flex-shrink-0" style={{ color: theme.colors.accent }} />
+                <div>
+                  <div className="text-sm font-medium" style={{ color: theme.colors.textMain }}>
+                    Markdown Documents
+                  </div>
+                  <div className="text-xs" style={{ color: theme.colors.textDim }}>
+                    Each .md file in your folder becomes a runnable document
+                  </div>
+                </div>
+              </div>
+
+              <div className="flex items-start gap-3">
+                <CheckSquare className="w-5 h-5 mt-0.5 flex-shrink-0" style={{ color: theme.colors.accent }} />
+                <div>
+                  <div className="text-sm font-medium" style={{ color: theme.colors.textMain }}>
+                    Checkbox Tasks
+                  </div>
+                  <div className="text-xs" style={{ color: theme.colors.textDim }}>
+                    Use markdown checkboxes (- [ ]) to define tasks that can be automated
+                  </div>
+                </div>
+              </div>
+
+              <div className="flex items-start gap-3">
+                <Play className="w-5 h-5 mt-0.5 flex-shrink-0" style={{ color: theme.colors.accent }} />
+                <div>
+                  <div className="text-sm font-medium" style={{ color: theme.colors.textMain }}>
+                    Batch Execution
+                  </div>
+                  <div className="text-xs" style={{ color: theme.colors.textDim }}>
+                    Run multiple documents in sequence with loop and reset options
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          {/* Folder Selection */}
+          <div
+            className="p-4 rounded-lg border"
+            style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgMain + '50' }}
+          >
+            <label className="block text-xs font-bold opacity-70 uppercase mb-2" style={{ color: theme.colors.textMain }}>
+              Auto Run Folder
+            </label>
+            <div className="flex gap-2">
+              <input
+                type="text"
+                value={selectedFolder}
+                onChange={(e) => setSelectedFolder(e.target.value)}
+                placeholder={sessionName ? `Select Auto Run folder for ${sessionName}` : 'Select Auto Run folder'}
+                className="flex-1 p-2 rounded border bg-transparent outline-none font-mono text-sm"
+                style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+              />
+              <button
+                onClick={handleSelectFolder}
+                className="p-2 rounded border hover:bg-white/5 transition-colors"
+                style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+                title="Browse folders (Cmd+O)"
+              >
+                <Folder className="w-5 h-5" />
+              </button>
+            </div>
+            {selectedFolder && (
+              <div className="mt-2 text-xs">
+                {folderValidation.checking ? (
+                  <span style={{ color: theme.colors.textDim }}>Checking folder...</span>
+                ) : folderValidation.valid ? (
+                  <span style={{ color: theme.colors.success }}>
+                    {folderValidation.docCount === 0
+                      ? 'Folder found (no markdown documents yet)'
+                      : `Found ${folderValidation.docCount} markdown document${folderValidation.docCount === 1 ? '' : 's'}`}
+                  </span>
+                ) : folderValidation.error ? (
+                  <span style={{ color: theme.colors.error }}>{folderValidation.error}</span>
+                ) : null}
+              </div>
+            )}
+          </div>
+        </div>
+
+        {/* Footer */}
+        <div className="p-4 border-t flex justify-end gap-2" style={{ borderColor: theme.colors.border }}>
+          <button
+            onClick={onClose}
+            className="px-4 py-2 rounded border hover:bg-white/5 transition-colors"
+            style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+          >
+            Cancel
+          </button>
+          <button
+            ref={continueButtonRef}
+            onClick={handleContinue}
+            disabled={!selectedFolder}
+            className="px-4 py-2 rounded disabled:opacity-50 disabled:cursor-not-allowed outline-none focus:ring-2 focus:ring-offset-1"
+            style={{
+              backgroundColor: theme.colors.accent,
+              color: theme.colors.accentForeground,
+              '--tw-ring-color': theme.colors.accent,
+            } as React.CSSProperties}
+          >
+            Continue
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/renderer/components/AutoRunnerHelpModal.tsx b/src/renderer/components/AutoRunnerHelpModal.tsx
index f046b5a3f..a1f379746 100644
--- a/src/renderer/components/AutoRunnerHelpModal.tsx
+++ b/src/renderer/components/AutoRunnerHelpModal.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useRef } from 'react';
-import { X, CheckSquare, Play, History, Eye, Square, Keyboard } from 'lucide-react';
+import { X, FolderOpen, FileText, CheckSquare, Play, Settings, History, Eye, Square, Keyboard, Repeat, RotateCcw, BookMarked, GitBranch, Image } from 'lucide-react';
 import type { Theme } from '../types';
 import { useLayerStack } from '../contexts/LayerStackContext';
 import { MODAL_PRIORITIES } from '../constants/modalPriorities';
@@ -53,7 +53,7 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
 
       {/* Modal */}
       <div
-        className="relative w-full max-w-2xl max-h-[80vh] overflow-hidden rounded-lg border shadow-2xl flex flex-col"
+        className="relative w-full max-w-2xl max-h-[85vh] overflow-hidden rounded-lg border shadow-2xl flex flex-col"
         style={{
           backgroundColor: theme.colors.bgSidebar,
           borderColor: theme.colors.border
@@ -65,7 +65,7 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
           style={{ borderColor: theme.colors.border }}
         >
           <h2 className="text-lg font-bold" style={{ color: theme.colors.textMain }}>
-            Automatic Runner Guide
+            Auto Run Guide
           </h2>
           <button
             onClick={onClose}
@@ -83,23 +83,48 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
           {/* Introduction */}
           <section>
             <p className="text-sm leading-relaxed" style={{ color: theme.colors.textDim }}>
-              Maestro's Automatic Runner lets you batch-process tasks using AI agents.
-              Define your tasks as markdown checkboxes, and let the AI work through them one by one, each time with a fresh context window.
+              Auto Run is a file-system-based document runner that automates AI-driven task execution.
+              Create markdown documents with checkbox tasks, and let AI agents work through them one by one,
+              each with a fresh context window. Run single documents or chain multiple documents together
+              for complex workflows.
             </p>
           </section>
 
-          {/* Creating Tasks */}
+          {/* Setting Up */}
           <section>
             <div className="flex items-center gap-2 mb-3">
-              <CheckSquare className="w-5 h-5" style={{ color: theme.colors.accent }} />
-              <h3 className="font-bold">Creating Tasks</h3>
+              <FolderOpen className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Setting Up a Runner Docs Folder</h3>
             </div>
             <div
               className="text-sm space-y-2 pl-7"
               style={{ color: theme.colors.textDim }}
             >
               <p>
-                Use markdown checkboxes to define tasks in the Scratchpad:
+                When you first open the Auto Run tab, you'll be prompted to select a folder
+                containing your task documents. This folder will store all your markdown files
+                with tasks to automate.
+              </p>
+              <p>
+                You can change this folder at any time by clicking <strong style={{ color: theme.colors.textMain }}>"Change Folder"</strong> in
+                the document dropdown.
+              </p>
+            </div>
+          </section>
+
+          {/* Document Format */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <FileText className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Document Format</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <p>
+                Create markdown files (<code>.md</code>) in your Runner Docs folder.
+                Each file can contain multiple tasks defined as markdown checkboxes:
               </p>
               <div
                 className="font-mono text-xs p-3 rounded border"
@@ -108,17 +133,37 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
                   borderColor: theme.colors.border
                 }}
               >
+                # Feature Plan<br /><br />
                 - [ ] Implement user authentication<br />
                 - [ ] Add unit tests for the login flow<br />
-                - [ ] Update documentation
+                - [ ] Update API documentation<br />
+                - [ ] Review and optimize database queries
               </div>
+              <p>
+                Tasks are processed from top to bottom. When an AI agent completes a task,
+                it checks off the box (<code>- [x]</code>) and exits. The next agent picks
+                up the next unchecked task.
+              </p>
+            </div>
+          </section>
+
+          {/* Creating Tasks */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <CheckSquare className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Creating Tasks</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
               <div
-                className="flex items-center gap-2 mt-3 px-3 py-2 rounded"
+                className="flex items-center gap-2 px-3 py-2 rounded"
                 style={{ backgroundColor: theme.colors.accent + '15' }}
               >
                 <Keyboard className="w-4 h-4" style={{ color: theme.colors.accent }} />
                 <span>
-                  <strong style={{ color: theme.colors.textMain }}>Tip:</strong> Press{' '}
+                  <strong style={{ color: theme.colors.textMain }}>Quick Insert:</strong> Press{' '}
                   <kbd
                     className="px-1.5 py-0.5 rounded text-[10px] font-mono font-bold"
                     style={{
@@ -128,45 +173,159 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
                   >
                     {formatShortcutKeys(['Meta', 'l'])}
                   </kbd>{' '}
-                  to quickly insert a new checkbox at your cursor position.
+                  to insert a new checkbox at your cursor.
                 </span>
               </div>
+              <p>
+                Write clear, specific task descriptions. Each task should be independently
+                completable—the AI starts fresh for each one without context from previous tasks.
+              </p>
+              <p>
+                <strong style={{ color: theme.colors.textMain }}>Tip:</strong> Prefix tasks with
+                unique identifiers (e.g., <code>FEAT-001:</code>) for easy tracking in history logs.
+              </p>
             </div>
           </section>
 
-          {/* Running Tasks */}
+          {/* Image Attachments */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <Image className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Image Attachments</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <p>
+                Paste images directly into your documents or click the camera button to attach files.
+                Images are saved to an <code>images/</code> subfolder and linked with relative paths.
+              </p>
+              <p>
+                Use images to provide visual context—screenshots of bugs, UI mockups, diagrams, or
+                reference materials that help the AI understand the task.
+              </p>
+            </div>
+          </section>
+
+          {/* Running Single Document */}
           <section>
             <div className="flex items-center gap-2 mb-3">
               <Play className="w-5 h-5" style={{ color: theme.colors.accent }} />
-              <h3 className="font-bold">Running the Automation</h3>
+              <h3 className="font-bold">Running a Single Document</h3>
             </div>
             <div
               className="text-sm space-y-2 pl-7"
               style={{ color: theme.colors.textDim }}
             >
               <p>
-                Click the <strong style={{ color: theme.colors.textMain }}>Run</strong> button to start.
-                A prompt editor will appear where you can customize instructions for the AI agent.
+                Click <strong style={{ color: theme.colors.textMain }}>Run</strong> to open the batch runner.
+                By default, the currently selected document is ready to run.
               </p>
               <p>
-                The runner will iterate through each unchecked task (<code>- [ ]</code>),
-                spawning a fresh AI session for each one. Tasks are processed serially,
-                ensuring each completes before the next begins.
+                The runner spawns a fresh AI session for each unchecked task. When a task completes,
+                the agent checks it off and exits. If tasks remain, another agent is spawned for the next task.
               </p>
               <p>
-                Each session starts with a clean context that's pre-loaded with the
-                project instructions and all requisite information to work intelligently—without
-                carrying over context from previous tasks. This isolation prevents
-                cross-contamination between tasks while keeping each agent fully informed.
+                The document is provided to the agent as a file path, giving it direct access to read and modify tasks.
               </p>
+            </div>
+          </section>
+
+          {/* Running Multiple Documents */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <Settings className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Running Multiple Documents</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
               <p>
-                The scratchpad file is passed to the AI via the <code>$$SCRATCHPAD$$</code> placeholder,
-                so the agent can read and modify tasks directly.
+                Click <strong style={{ color: theme.colors.textMain }}>"+ Add Docs"</strong> in the batch runner
+                to select additional documents. Documents are processed sequentially in the order shown.
+              </p>
+              <p>
+                <strong style={{ color: theme.colors.textMain }}>Drag to reorder:</strong> Use the grip handle
+                to rearrange documents in the queue.
+              </p>
+              <p>
+                Documents with zero unchecked tasks are automatically skipped.
+              </p>
+            </div>
+          </section>
+
+          {/* Reset on Completion */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <RotateCcw className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Reset on Completion</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <p>
+                Enable the reset toggle (<RotateCcw className="w-3 h-3 inline" />) on any document to
+                uncheck all tasks when that document completes. This is useful for recurring task lists.
+              </p>
+              <p>
+                Reset-enabled documents can be duplicated in the queue, allowing the same document to
+                run multiple times in a single batch.
               </p>
             </div>
           </section>
 
-          {/* History Logs */}
+          {/* Loop Mode */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <Repeat className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Loop Mode</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <p>
+                When running multiple documents, enable <strong style={{ color: theme.colors.textMain }}>Loop</strong> to
+                continuously cycle through the document queue until all documents have zero tasks remaining.
+              </p>
+              <p>
+                Combined with reset-on-completion, this creates perpetual workflows—perfect for monitoring
+                tasks, recurring maintenance, or continuous integration scenarios.
+              </p>
+            </div>
+          </section>
+
+          {/* Playbooks */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <BookMarked className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Playbooks</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <p>
+                Save your batch run configurations as <strong style={{ color: theme.colors.textMain }}>Playbooks</strong> for
+                quick reuse. A playbook stores:
+              </p>
+              <ul className="list-disc ml-4 space-y-1">
+                <li>Document selection and order</li>
+                <li>Reset-on-completion settings per document</li>
+                <li>Loop mode preference</li>
+                <li>Custom agent prompt</li>
+              </ul>
+              <p>
+                Load a saved playbook with one click and modify it as needed—changes can be saved
+                back or discarded.
+              </p>
+            </div>
+          </section>
+
+          {/* History & Tracking */}
           <section>
             <div className="flex items-center gap-2 mb-3">
               <History className="w-5 h-5" style={{ color: theme.colors.accent }} />
@@ -177,16 +336,12 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
               style={{ color: theme.colors.textDim }}
             >
               <p>
-                Each completed task is logged to the <strong style={{ color: theme.colors.textMain }}>History</strong> panel
+                Completed tasks appear in the <strong style={{ color: theme.colors.textMain }}>History</strong> panel
                 with an <span style={{ color: theme.colors.warning }}>AUTO</span> label.
               </p>
               <p>
-                History entries include a session ID pill that you can click to jump directly
-                to that AI conversation, allowing you to review what the agent did.
-              </p>
-              <p>
-                Use <code>/synopsis</code> to manually add summaries, or <code>/clear</code> to
-                capture a synopsis before starting fresh.
+                Click the session ID pill to jump directly to that AI conversation and review
+                what the agent did. Use <code>/synopsis</code> to add manual summaries.
               </p>
             </div>
           </section>
@@ -202,46 +357,136 @@ export function AutoRunnerHelpModal({ theme, onClose }: AutoRunnerHelpModalProps
               style={{ color: theme.colors.textDim }}
             >
               <p>
-                While automation is running, the AI interpreter operates in{' '}
-                <strong style={{ color: theme.colors.warning }}>read-only/plan mode</strong>.
+                While Auto Run is active, the AI interpreter operates in{' '}
+                <strong style={{ color: theme.colors.warning }}>read-only mode</strong>.
+                You can send messages to analyze code, but file modifications queue until Auto Run completes.
               </p>
               <p>
-                You can still send messages to the AI, but it will only be able to read and plan—not
-                make changes. This prevents conflicts between your manual interactions and the
-                automated tasks.
+                The input shows a <span style={{ color: theme.colors.warning }}>READ-ONLY</span> indicator
+                as a reminder. This prevents conflicts between manual and automated work...
               </p>
               <p>
-                The input area will show a <span style={{ color: theme.colors.warning }}>READ-ONLY</span> indicator
-                and have a subtle warning background to remind you of this mode.
+                <em style={{ color: theme.colors.textMain }}>Unless</em> you enable Git Worktree:
               </p>
             </div>
           </section>
 
-          {/* Stopping */}
+          {/* Git Worktree */}
           <section>
             <div className="flex items-center gap-2 mb-3">
-              <Square className="w-5 h-5" style={{ color: theme.colors.error }} />
-              <h3 className="font-bold">Stopping the Runner</h3>
+              <GitBranch className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Git Worktree (Parallel Work)</h3>
             </div>
             <div
               className="text-sm space-y-2 pl-7"
               style={{ color: theme.colors.textDim }}
             >
               <p>
-                You can request a stop at any time by clicking the{' '}
-                <strong style={{ color: theme.colors.error }}>Stop</strong> button in the header
-                or scratchpad.
+                For Git repositories, enable <strong style={{ color: theme.colors.textMain }}>Git Worktree</strong> to
+                run Auto Run in an isolated working directory. This allows you to continue working
+                in the main project while Auto Run operates independently—no read-only restrictions.
+              </p>
+              <p>
+                Specify a worktree path and branch name. Optionally enable <strong style={{ color: theme.colors.textMain }}>"Create PR on completion"</strong> to
+                automatically open a pull request when all tasks finish.
               </p>
+            </div>
+          </section>
+
+          {/* Stopping */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <Square className="w-5 h-5" style={{ color: theme.colors.error }} />
+              <h3 className="font-bold">Stopping Auto Run</h3>
+            </div>
+            <div
+              className="text-sm space-y-2 pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
               <p>
-                The runner will complete the current task before stopping gracefully.
-                This ensures no work is left in an incomplete state.
+                Click <strong style={{ color: theme.colors.error }}>Stop</strong> in the header or Auto Run panel
+                to gracefully stop. The current task completes before stopping—no work is left incomplete.
               </p>
               <p>
-                Any completed tasks will remain checked, and you can resume later by
-                clicking Run again.
+                Completed tasks remain checked. Resume anytime by clicking Run again.
               </p>
             </div>
           </section>
+
+          {/* Keyboard Shortcuts */}
+          <section>
+            <div className="flex items-center gap-2 mb-3">
+              <Keyboard className="w-5 h-5" style={{ color: theme.colors.accent }} />
+              <h3 className="font-bold">Keyboard Shortcuts</h3>
+            </div>
+            <div
+              className="text-sm pl-7"
+              style={{ color: theme.colors.textDim }}
+            >
+              <div className="space-y-2">
+                <div className="flex items-center gap-3">
+                  <kbd
+                    className="px-2 py-1 rounded text-xs font-mono font-bold min-w-[80px] text-center"
+                    style={{
+                      backgroundColor: theme.colors.bgActivity,
+                      border: `1px solid ${theme.colors.border}`
+                    }}
+                  >
+                    {formatShortcutKeys(['Meta', 'Shift', '1'])}
+                  </kbd>
+                  <span>Open Auto Run tab</span>
+                </div>
+                <div className="flex items-center gap-3">
+                  <kbd
+                    className="px-2 py-1 rounded text-xs font-mono font-bold min-w-[80px] text-center"
+                    style={{
+                      backgroundColor: theme.colors.bgActivity,
+                      border: `1px solid ${theme.colors.border}`
+                    }}
+                  >
+                    {formatShortcutKeys(['Meta', 'e'])}
+                  </kbd>
+                  <span>Toggle Edit/Preview mode</span>
+                </div>
+                <div className="flex items-center gap-3">
+                  <kbd
+                    className="px-2 py-1 rounded text-xs font-mono font-bold min-w-[80px] text-center"
+                    style={{
+                      backgroundColor: theme.colors.bgActivity,
+                      border: `1px solid ${theme.colors.border}`
+                    }}
+                  >
+                    {formatShortcutKeys(['Meta', 'l'])}
+                  </kbd>
+                  <span>Insert checkbox at cursor</span>
+                </div>
+                <div className="flex items-center gap-3">
+                  <kbd
+                    className="px-2 py-1 rounded text-xs font-mono font-bold min-w-[80px] text-center"
+                    style={{
+                      backgroundColor: theme.colors.bgActivity,
+                      border: `1px solid ${theme.colors.border}`
+                    }}
+                  >
+                    {formatShortcutKeys(['Meta', 'z'])}
+                  </kbd>
+                  <span>Undo</span>
+                </div>
+                <div className="flex items-center gap-3">
+                  <kbd
+                    className="px-2 py-1 rounded text-xs font-mono font-bold min-w-[80px] text-center"
+                    style={{
+                      backgroundColor: theme.colors.bgActivity,
+                      border: `1px solid ${theme.colors.border}`
+                    }}
+                  >
+                    {formatShortcutKeys(['Meta', 'Shift', 'z'])}
+                  </kbd>
+                  <span>Redo</span>
+                </div>
+              </div>
+            </div>
+          </section>
         </div>
 
         {/* Footer */}
diff --git a/src/renderer/components/BatchRunnerModal.tsx b/src/renderer/components/BatchRunnerModal.tsx
index 9fcb58f15..94a9bad4a 100644
--- a/src/renderer/components/BatchRunnerModal.tsx
+++ b/src/renderer/components/BatchRunnerModal.tsx
@@ -1,26 +1,39 @@
-import React, { useState, useEffect, useRef } from 'react';
-import { X, RotateCcw, Play, Variable, ChevronDown, ChevronRight, Save } from 'lucide-react';
-import type { Theme } from '../types';
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { X, RotateCcw, Play, Variable, ChevronDown, ChevronRight, Save, GripVertical, Plus, Repeat, FolderOpen, Bookmark, GitBranch, AlertTriangle, Loader2, Maximize2 } from 'lucide-react';
+import type { Theme, BatchDocumentEntry, BatchRunConfig, Playbook, PlaybookDocumentEntry, WorktreeConfig } from '../types';
 import { useLayerStack } from '../contexts/LayerStackContext';
 import { MODAL_PRIORITIES } from '../constants/modalPriorities';
 import { TEMPLATE_VARIABLES } from '../utils/templateVariables';
+import { PlaybookDeleteConfirmModal } from './PlaybookDeleteConfirmModal';
+import { PlaybookNameModal } from './PlaybookNameModal';
+import { AgentPromptComposerModal } from './AgentPromptComposerModal';
 
 // Default batch processing prompt
-export const DEFAULT_BATCH_PROMPT = `CRITICAL: You must complete EXACTLY ONE task and then exit. Do not attempt multiple tasks.
+export const DEFAULT_BATCH_PROMPT = `# Context
 
-Your responsibilities are as follows:
+You are **{{AGENT_NAME}}**, a Maestro-managed AI agent working on the **{{PROJECT_NAME}}** project.
+
+- **Project Path:** {{PROJECT_PATH}}
+- **Git Branch:** {{GIT_BRANCH}}
+- **Auto Run Folder:** {{AUTORUN_FOLDER}}
+- **Loop Iteration:** {{LOOP_NUMBER}}
+
+---
+
+## Instructions
 
 1. Project Orientation
-    Begin by reviewing claude.md in this folder to understand the project's structure, conventions, and workflow expectations.
+    Begin by reviewing CLAUDE.md (when available) in this folder to understand the project's structure, conventions, and workflow expectations.
 
 2. Task Selection
-    Navigate to $$SCRATCHPAD$$ and select the FIRST unchecked task (- [ ]) from top to bottom. Note that there may be relevant images associated with the task, analyze them, and include in your final synopsis back how many images you analyzed in preparation for solving the task.
+    Process the FIRST unchecked task (- [ ]) from top to bottom. Note that there may be relevant images associated with the task, analyze them, and include in your final synopsis back how many images you analyzed in preparation for solving the task.
 
     IMPORTANT: You will only work on this single task. If it appears to have logical subtasks, treat them as one cohesive unit—but do not move on to the next top-level task.
 
 3. Task Evaluation
     - Fully understand the task and inspect the relevant code.
-    - If you determine the task should not be executed, mark it as completed anyway and record a concise explanation of why it was skipped.
+    - If you determine the task should not be executed, mark it as completed anyway and record a concise explanation of why it was skipped directly in the document.
+    - If upon examining the code carefully you decide there is a better approach, take it, and document record a detailed explanation of why directly in the document.
 
 4. Task Implementation
     Implement the task according to the project's established style, architecture, and coding norms.
@@ -34,10 +47,10 @@ Your responsibilities are as follows:
       - If implementation failed, explain the failure and do NOT check off the item.
 
 6. Version Control
-    For any code or documentation changes:
+    For any code or documentation changes, if we're in a Github repo:
     - Commit using a descriptive message prefixed with MAESTRO:.
     - Push to GitHub.
-    - Update claude.md, README.md, or any other top-level documentation if appropriate.
+    - Update CLAUDE.md, README.md, or any other top-level documentation if appropriate.
 
 7. Exit Immediately
     After completing (or skipping) the single task, EXIT. Do not proceed to additional tasks—another agent instance will handle them.
@@ -49,12 +62,20 @@ If there are no remaining open tasks, exit immediately and state that there is n
 interface BatchRunnerModalProps {
   theme: Theme;
   onClose: () => void;
-  onGo: (prompt: string) => void;
+  onGo: (config: BatchRunConfig) => void;
   onSave: (prompt: string) => void;
   initialPrompt?: string;
   lastModifiedAt?: number;
   showConfirmation: (message: string, onConfirm: () => void) => void;
-  scratchpadContent?: string;
+  // Multi-document support
+  folderPath: string;
+  currentDocument: string;
+  allDocuments: string[]; // All available docs in folder (without .md)
+  getDocumentTaskCount: (filename: string) => Promise<number>; // Get task count for a document
+  // Session ID for playbook storage
+  sessionId: string;
+  // Session cwd for git worktree support
+  sessionCwd: string;
 }
 
 // Helper function to count unchecked tasks in scratchpad content
@@ -83,27 +104,359 @@ function formatLastModified(timestamp: number): string {
 }
 
 export function BatchRunnerModal(props: BatchRunnerModalProps) {
-  const { theme, onClose, onGo, onSave, initialPrompt, lastModifiedAt, showConfirmation, scratchpadContent } = props;
+  const {
+    theme,
+    onClose,
+    onGo,
+    onSave,
+    initialPrompt,
+    lastModifiedAt,
+    showConfirmation,
+    folderPath,
+    currentDocument,
+    allDocuments,
+    getDocumentTaskCount,
+    sessionId,
+    sessionCwd
+  } = props;
+
+  // Document list state
+  const [documents, setDocuments] = useState<BatchDocumentEntry[]>(() => {
+    // Initialize with current document
+    if (currentDocument) {
+      return [{
+        id: crypto.randomUUID(),
+        filename: currentDocument,
+        resetOnCompletion: false,
+        isDuplicate: false
+      }];
+    }
+    return [];
+  });
 
-  // Count unchecked tasks
-  const taskCount = countUncheckedTasks(scratchpadContent || '');
-  const hasNoTasks = taskCount === 0;
+  // Task counts per document (keyed by filename)
+  const [taskCounts, setTaskCounts] = useState<Record<string, number>>({});
+  const [loadingTaskCounts, setLoadingTaskCounts] = useState(true);
 
+  // Document selector modal state
+  const [showDocSelector, setShowDocSelector] = useState(false);
+  const [selectedDocsInSelector, setSelectedDocsInSelector] = useState<Set<string>>(new Set());
+
+  // Loop mode state
+  const [loopEnabled, setLoopEnabled] = useState(false);
+  const [maxLoops, setMaxLoops] = useState<number | null>(null); // null = infinite
+  const [showMaxLoopsSlider, setShowMaxLoopsSlider] = useState(false);
+
+  // Prompt state
   const [prompt, setPrompt] = useState(initialPrompt || DEFAULT_BATCH_PROMPT);
   const [variablesExpanded, setVariablesExpanded] = useState(false);
   const [savedPrompt, setSavedPrompt] = useState(initialPrompt || '');
+  const [promptComposerOpen, setPromptComposerOpen] = useState(false);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
 
+  // Drag state for reordering
+  const [draggedId, setDraggedId] = useState<string | null>(null);
+  const [dragOverId, setDragOverId] = useState<string | null>(null);
+
+  // Playbook state
+  const [playbooks, setPlaybooks] = useState<Playbook[]>([]);
+  const [loadedPlaybook, setLoadedPlaybook] = useState<Playbook | null>(null);
+  const [loadingPlaybooks, setLoadingPlaybooks] = useState(true);
+  const [showPlaybookDropdown, setShowPlaybookDropdown] = useState(false);
+  const [showSavePlaybookModal, setShowSavePlaybookModal] = useState(false);
+  const [savingPlaybook, setSavingPlaybook] = useState(false);
+  const [showDeleteConfirmModal, setShowDeleteConfirmModal] = useState(false);
+  const [playbookToDelete, setPlaybookToDelete] = useState<Playbook | null>(null);
+  const playbackDropdownRef = useRef<HTMLDivElement>(null);
+
+  // Git worktree state - only show worktree section for git repos
+  const [isGitRepo, setIsGitRepo] = useState(false);
+  const [checkingGitRepo, setCheckingGitRepo] = useState(true);
+
+  // Worktree configuration state
+  const [worktreeEnabled, setWorktreeEnabled] = useState(false);
+  const [worktreePath, setWorktreePath] = useState('');
+  const [branchName, setBranchName] = useState('');
+  const [createPROnCompletion, setCreatePROnCompletion] = useState(false);
+  const [prTargetBranch, setPrTargetBranch] = useState('main');
+  const [availableBranches, setAvailableBranches] = useState<string[]>([]);
+  const [showBranchDropdown, setShowBranchDropdown] = useState(false);
+  const branchDropdownRef = useRef<HTMLDivElement>(null);
+  const [ghCliStatus, setGhCliStatus] = useState<{ installed: boolean; authenticated: boolean } | null>(null);
+
+  // Worktree validation state
+  const [worktreeValidation, setWorktreeValidation] = useState<{
+    checking: boolean;
+    exists: boolean;
+    isWorktree: boolean;
+    currentBranch?: string;
+    branchMismatch: boolean;
+    sameRepo: boolean;
+    hasUncommittedChanges?: boolean;
+    error?: string;
+  }>({ checking: false, exists: false, isWorktree: false, branchMismatch: false, sameRepo: true });
+
   const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
   const layerIdRef = useRef<string>();
 
+  // Use ref for getDocumentTaskCount to avoid dependency issues
+  const getDocumentTaskCountRef = useRef(getDocumentTaskCount);
+  getDocumentTaskCountRef.current = getDocumentTaskCount;
+
+  // Load task counts for all documents (only when document list changes)
+  useEffect(() => {
+    const loadTaskCounts = async () => {
+      setLoadingTaskCounts(true);
+      const counts: Record<string, number> = {};
+
+      for (const doc of allDocuments) {
+        try {
+          counts[doc] = await getDocumentTaskCountRef.current(doc);
+        } catch {
+          counts[doc] = 0;
+        }
+      }
+
+      setTaskCounts(counts);
+      setLoadingTaskCounts(false);
+    };
+
+    loadTaskCounts();
+  }, [allDocuments]);
+
+  // Load playbooks on mount
+  useEffect(() => {
+    const loadPlaybooks = async () => {
+      setLoadingPlaybooks(true);
+      try {
+        const result = await window.maestro.playbooks.list(sessionId);
+        if (result.success) {
+          setPlaybooks(result.playbooks);
+        }
+      } catch (error) {
+        console.error('Failed to load playbooks:', error);
+      }
+      setLoadingPlaybooks(false);
+    };
+
+    loadPlaybooks();
+  }, [sessionId]);
+
+  // Check if session cwd is a git repo on mount (for worktree support)
+  useEffect(() => {
+    const checkGitRepo = async () => {
+      setCheckingGitRepo(true);
+      try {
+        const result = await window.maestro.git.isRepo(sessionCwd);
+        const isRepo = result === true;
+        setIsGitRepo(isRepo);
+
+        // If it's a git repo, fetch available branches and check gh CLI
+        if (isRepo) {
+          const [branchResult, ghResult] = await Promise.all([
+            window.maestro.git.branches(sessionCwd),
+            window.maestro.git.checkGhCli()
+          ]);
+
+          if (branchResult.branches && branchResult.branches.length > 0) {
+            setAvailableBranches(branchResult.branches);
+            // Set default target branch to 'main' or 'master' if available
+            if (branchResult.branches.includes('main')) {
+              setPrTargetBranch('main');
+            } else if (branchResult.branches.includes('master')) {
+              setPrTargetBranch('master');
+            } else {
+              setPrTargetBranch(branchResult.branches[0]);
+            }
+          }
+
+          setGhCliStatus(ghResult);
+        }
+      } catch (error) {
+        console.error('Failed to check if git repo:', error);
+        setIsGitRepo(false);
+      }
+      setCheckingGitRepo(false);
+    };
+
+    checkGitRepo();
+  }, [sessionCwd]);
+
+  // Validate worktree path when it changes (debounced 500ms)
+  useEffect(() => {
+    // Reset validation state when worktree is disabled or path is empty
+    if (!worktreeEnabled || !worktreePath) {
+      setWorktreeValidation({
+        checking: false,
+        exists: false,
+        isWorktree: false,
+        branchMismatch: false,
+        sameRepo: true,
+        hasUncommittedChanges: false
+      });
+      return;
+    }
+
+    // Set checking state immediately
+    setWorktreeValidation(prev => ({ ...prev, checking: true }));
+
+    // Debounce the validation check
+    const timeoutId = setTimeout(async () => {
+      try {
+        // Check if the path exists and get worktree info
+        const worktreeInfoResult = await window.maestro.git.worktreeInfo(worktreePath);
+
+        if (!worktreeInfoResult.success) {
+          setWorktreeValidation({
+            checking: false,
+            exists: false,
+            isWorktree: false,
+            branchMismatch: false,
+            sameRepo: true,
+            hasUncommittedChanges: false,
+            error: worktreeInfoResult.error
+          });
+          return;
+        }
+
+        // If the path doesn't exist, that's fine - it will be created
+        if (!worktreeInfoResult.exists) {
+          setWorktreeValidation({
+            checking: false,
+            exists: false,
+            isWorktree: false,
+            branchMismatch: false,
+            sameRepo: true,
+            hasUncommittedChanges: false
+          });
+          return;
+        }
+
+        // Path exists - check if it's part of the same repo
+        const mainRepoRootResult = await window.maestro.git.getRepoRoot(sessionCwd);
+        const sameRepo = mainRepoRootResult.success &&
+          worktreeInfoResult.repoRoot === mainRepoRootResult.root;
+
+        // Check for branch mismatch (only if branch name is provided)
+        const branchMismatch = branchName !== '' &&
+          worktreeInfoResult.currentBranch !== branchName;
+
+        // If there's a branch mismatch and it's the same repo, check for uncommitted changes
+        // This helps warn users that checkout will fail if there are uncommitted changes
+        let hasUncommittedChanges = false;
+        if (branchMismatch && sameRepo) {
+          try {
+            // Use git status to check for uncommitted changes in the worktree
+            const statusResult = await window.maestro.git.status(worktreePath);
+            // If there's any output from git status --porcelain, there are changes
+            hasUncommittedChanges = statusResult.stdout.trim().length > 0;
+          } catch {
+            // If we can't check, assume no uncommitted changes
+            hasUncommittedChanges = false;
+          }
+        }
+
+        setWorktreeValidation({
+          checking: false,
+          exists: true,
+          isWorktree: worktreeInfoResult.isWorktree || false,
+          currentBranch: worktreeInfoResult.currentBranch,
+          branchMismatch,
+          sameRepo,
+          hasUncommittedChanges,
+          error: !sameRepo ? 'This path contains a worktree for a different repository' : undefined
+        });
+      } catch (error) {
+        console.error('Failed to validate worktree path:', error);
+        setWorktreeValidation({
+          checking: false,
+          exists: false,
+          isWorktree: false,
+          branchMismatch: false,
+          sameRepo: true,
+          hasUncommittedChanges: false,
+          error: 'Failed to validate worktree path'
+        });
+      }
+    }, 500); // 500ms debounce
+
+    // Cleanup timeout on unmount or when dependencies change
+    return () => clearTimeout(timeoutId);
+  }, [worktreePath, branchName, worktreeEnabled, sessionCwd]);
+
+  // Calculate total tasks across selected documents (excluding missing documents)
+  const totalTaskCount = documents.reduce((sum, doc) => {
+    // Don't count tasks from missing documents
+    if (doc.isMissing) return sum;
+    return sum + (taskCounts[doc.filename] || 0);
+  }, 0);
+  const hasNoTasks = totalTaskCount === 0;
+
+  // Count missing documents for warning display
+  const missingDocCount = documents.filter(doc => doc.isMissing).length;
+  const hasMissingDocs = missingDocCount > 0;
+
+  // Track if the current configuration differs from the loaded playbook
+  const isPlaybookModified = useMemo(() => {
+    if (!loadedPlaybook) return false;
+
+    // Compare documents
+    const currentDocs = documents.map(d => ({
+      filename: d.filename,
+      resetOnCompletion: d.resetOnCompletion
+    }));
+    const savedDocs = loadedPlaybook.documents;
+
+    if (currentDocs.length !== savedDocs.length) return true;
+    for (let i = 0; i < currentDocs.length; i++) {
+      if (currentDocs[i].filename !== savedDocs[i].filename ||
+          currentDocs[i].resetOnCompletion !== savedDocs[i].resetOnCompletion) {
+        return true;
+      }
+    }
+
+    // Compare loop setting
+    if (loopEnabled !== loadedPlaybook.loopEnabled) return true;
+
+    // Compare maxLoops setting
+    const savedMaxLoops = loadedPlaybook.maxLoops ?? null;
+    if (maxLoops !== savedMaxLoops) return true;
+
+    // Compare prompt
+    if (prompt !== loadedPlaybook.prompt) return true;
+
+    // Compare worktree settings
+    const savedWorktree = loadedPlaybook.worktreeSettings;
+    if (savedWorktree) {
+      // Playbook has worktree settings - check if current state differs
+      if (!worktreeEnabled) return true;
+      if (branchName !== savedWorktree.branchNameTemplate) return true;
+      if (createPROnCompletion !== savedWorktree.createPROnCompletion) return true;
+      if (savedWorktree.prTargetBranch && prTargetBranch !== savedWorktree.prTargetBranch) return true;
+    } else {
+      // Playbook doesn't have worktree settings - modified if worktree is now enabled with a branch
+      if (worktreeEnabled && branchName) return true;
+    }
+
+    return false;
+  }, [documents, loopEnabled, maxLoops, prompt, loadedPlaybook, worktreeEnabled, branchName, createPROnCompletion, prTargetBranch]);
+
   // Register layer on mount
   useEffect(() => {
     const id = registerLayer({
       type: 'modal',
       priority: MODAL_PRIORITIES.BATCH_RUNNER,
       onEscape: () => {
-        onClose();
+        if (showDeleteConfirmModal) {
+          setShowDeleteConfirmModal(false);
+          setPlaybookToDelete(null);
+        } else if (showSavePlaybookModal) {
+          setShowSavePlaybookModal(false);
+        } else if (showDocSelector) {
+          setShowDocSelector(false);
+        } else {
+          onClose();
+        }
       }
     });
     layerIdRef.current = id;
@@ -113,21 +466,32 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
         unregisterLayer(layerIdRef.current);
       }
     };
-  }, [registerLayer, unregisterLayer]);
+  }, [registerLayer, unregisterLayer, showDocSelector, showSavePlaybookModal, showDeleteConfirmModal]);
 
   // Update handler when dependencies change
   useEffect(() => {
     if (layerIdRef.current) {
       updateLayerHandler(layerIdRef.current, () => {
-        onClose();
+        if (showDeleteConfirmModal) {
+          setShowDeleteConfirmModal(false);
+          setPlaybookToDelete(null);
+        } else if (showSavePlaybookModal) {
+          setShowSavePlaybookModal(false);
+        } else if (showDocSelector) {
+          setShowDocSelector(false);
+        } else {
+          onClose();
+        }
       });
     }
-  }, [onClose, updateLayerHandler]);
+  }, [onClose, updateLayerHandler, showDocSelector, showSavePlaybookModal, showDeleteConfirmModal]);
 
-  // Focus textarea on mount
+  // Focus textarea on mount (if not showing doc selector)
   useEffect(() => {
-    setTimeout(() => textareaRef.current?.focus(), 100);
-  }, []);
+    if (!showDocSelector) {
+      setTimeout(() => textareaRef.current?.focus(), 100);
+    }
+  }, [showDocSelector]);
 
   const handleReset = () => {
     showConfirmation(
@@ -146,13 +510,337 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
   const handleGo = () => {
     // Also save when running
     onSave(prompt);
-    onGo(prompt);
+
+    // Filter out missing documents before starting batch run
+    const validDocuments = documents.filter(doc => !doc.isMissing);
+
+    // Build config with optional worktree settings
+    const config: BatchRunConfig = {
+      documents: validDocuments,
+      prompt,
+      loopEnabled,
+      maxLoops: loopEnabled ? maxLoops : null
+    };
+
+    // Add worktree config if enabled and valid
+    if (worktreeEnabled && isGitRepo && worktreePath && branchName) {
+      config.worktree = {
+        enabled: true,
+        path: worktreePath,
+        branchName,
+        createPROnCompletion,
+        prTargetBranch
+      };
+    }
+
+    onGo(config);
     onClose();
   };
 
+  // Document list handlers
+  const handleRemoveDocument = useCallback((id: string) => {
+    setDocuments(prev => prev.filter(d => d.id !== id));
+  }, []);
+
+  const handleToggleReset = useCallback((id: string) => {
+    setDocuments(prev => prev.map(d =>
+      d.id === id ? { ...d, resetOnCompletion: !d.resetOnCompletion } : d
+    ));
+  }, []);
+
+  const handleDuplicateDocument = useCallback((id: string) => {
+    setDocuments(prev => {
+      const index = prev.findIndex(d => d.id === id);
+      if (index === -1) return prev;
+
+      const original = prev[index];
+      const duplicate: BatchDocumentEntry = {
+        id: crypto.randomUUID(),
+        filename: original.filename,
+        resetOnCompletion: original.resetOnCompletion, // Inherit reset setting
+        isDuplicate: true
+      };
+
+      // Insert duplicate immediately after the original
+      return [
+        ...prev.slice(0, index + 1),
+        duplicate,
+        ...prev.slice(index + 1)
+      ];
+    });
+  }, []);
+
+  const handleOpenDocSelector = useCallback(() => {
+    // Pre-select currently added documents
+    const currentFilenames = new Set(documents.map(d => d.filename));
+    setSelectedDocsInSelector(currentFilenames);
+    setShowDocSelector(true);
+  }, [documents]);
+
+  const handleAddSelectedDocs = useCallback(() => {
+    // Get filenames already in the list
+    const existingFilenames = new Set(documents.map(d => d.filename));
+
+    // Add new documents that are selected but not already in list
+    const newDocs: BatchDocumentEntry[] = [];
+    selectedDocsInSelector.forEach(filename => {
+      if (!existingFilenames.has(filename)) {
+        newDocs.push({
+          id: crypto.randomUUID(),
+          filename,
+          resetOnCompletion: false,
+          isDuplicate: false
+        });
+      }
+    });
+
+    // Also remove documents that were deselected
+    const filteredDocs = documents.filter(d => selectedDocsInSelector.has(d.filename));
+
+    setDocuments([...filteredDocs, ...newDocs]);
+    setShowDocSelector(false);
+  }, [documents, selectedDocsInSelector]);
+
+  // Drag and drop handlers
+  const handleDragStart = useCallback((e: React.DragEvent, id: string) => {
+    setDraggedId(id);
+    e.dataTransfer.effectAllowed = 'move';
+  }, []);
+
+  const handleDragOver = useCallback((e: React.DragEvent, id: string) => {
+    e.preventDefault();
+    if (draggedId && draggedId !== id) {
+      setDragOverId(id);
+    }
+  }, [draggedId]);
+
+  const handleDragEnd = useCallback(() => {
+    if (draggedId && dragOverId && draggedId !== dragOverId) {
+      setDocuments(prev => {
+        const items = [...prev];
+        const draggedIndex = items.findIndex(d => d.id === draggedId);
+        const targetIndex = items.findIndex(d => d.id === dragOverId);
+
+        if (draggedIndex !== -1 && targetIndex !== -1) {
+          const [removed] = items.splice(draggedIndex, 1);
+          items.splice(targetIndex, 0, removed);
+        }
+
+        return items;
+      });
+    }
+    setDraggedId(null);
+    setDragOverId(null);
+  }, [draggedId, dragOverId]);
+
   const isModified = prompt !== DEFAULT_BATCH_PROMPT;
   const hasUnsavedChanges = prompt !== savedPrompt && prompt !== DEFAULT_BATCH_PROMPT;
 
+  // Toggle document selection in the selector modal
+  const toggleDocInSelector = useCallback((filename: string) => {
+    setSelectedDocsInSelector(prev => {
+      const next = new Set(prev);
+      if (next.has(filename)) {
+        next.delete(filename);
+      } else {
+        next.add(filename);
+      }
+      return next;
+    });
+  }, []);
+
+  // Handle loading a playbook
+  const handleLoadPlaybook = useCallback((playbook: Playbook) => {
+    // Convert stored entries to BatchDocumentEntry with IDs
+    // Also detect missing documents (documents in playbook that don't exist in allDocuments)
+    const allDocsSet = new Set(allDocuments);
+
+    const entries: BatchDocumentEntry[] = playbook.documents.map((doc, index) => ({
+      id: crypto.randomUUID(),
+      filename: doc.filename,
+      resetOnCompletion: doc.resetOnCompletion,
+      // Mark as duplicate if same filename appears earlier
+      isDuplicate: playbook.documents.slice(0, index).some(d => d.filename === doc.filename),
+      // Mark as missing if document doesn't exist in the folder
+      isMissing: !allDocsSet.has(doc.filename)
+    }));
+
+    setDocuments(entries);
+    setLoopEnabled(playbook.loopEnabled);
+    setMaxLoops(playbook.maxLoops ?? null);
+    setShowMaxLoopsSlider(playbook.maxLoops != null);
+    setPrompt(playbook.prompt);
+    setLoadedPlaybook(playbook);
+    setShowPlaybookDropdown(false);
+
+    // Restore worktree settings if present
+    if (playbook.worktreeSettings) {
+      setWorktreeEnabled(true);
+      setBranchName(playbook.worktreeSettings.branchNameTemplate);
+      setCreatePROnCompletion(playbook.worktreeSettings.createPROnCompletion);
+      if (playbook.worktreeSettings.prTargetBranch) {
+        setPrTargetBranch(playbook.worktreeSettings.prTargetBranch);
+      }
+    } else {
+      // Clear worktree settings if playbook doesn't have them
+      setWorktreeEnabled(false);
+      setBranchName('');
+      setCreatePROnCompletion(false);
+    }
+  }, [allDocuments]);
+
+  // Handle opening the delete confirmation modal
+  const handleDeletePlaybook = useCallback((playbook: Playbook, e: React.MouseEvent) => {
+    e.stopPropagation();
+    setPlaybookToDelete(playbook);
+    setShowDeleteConfirmModal(true);
+  }, []);
+
+  // Handle confirming the delete action
+  const handleConfirmDeletePlaybook = useCallback(async () => {
+    if (!playbookToDelete) return;
+
+    try {
+      const result = await window.maestro.playbooks.delete(sessionId, playbookToDelete.id);
+      if (result.success) {
+        setPlaybooks(prev => prev.filter(p => p.id !== playbookToDelete.id));
+        // If the deleted playbook was loaded, clear it
+        if (loadedPlaybook?.id === playbookToDelete.id) {
+          setLoadedPlaybook(null);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to delete playbook:', error);
+    }
+
+    setShowDeleteConfirmModal(false);
+    setPlaybookToDelete(null);
+  }, [sessionId, playbookToDelete, loadedPlaybook]);
+
+  // Handle canceling the delete action
+  const handleCancelDeletePlaybook = useCallback(() => {
+    setShowDeleteConfirmModal(false);
+    setPlaybookToDelete(null);
+  }, []);
+
+  // Handle saving a new playbook
+  const handleSaveAsPlaybook = useCallback(async (name: string) => {
+    if (savingPlaybook) return;
+
+    setSavingPlaybook(true);
+    try {
+      // Build playbook data, including worktree settings if enabled
+      const playbookData: Parameters<typeof window.maestro.playbooks.create>[1] = {
+        name,
+        documents: documents.map(d => ({
+          filename: d.filename,
+          resetOnCompletion: d.resetOnCompletion
+        })),
+        loopEnabled,
+        maxLoops,
+        prompt
+      };
+
+      // Include worktree settings if worktree is enabled
+      // Note: We store branchName as the template - users can modify it when loading
+      if (worktreeEnabled && branchName) {
+        playbookData.worktreeSettings = {
+          branchNameTemplate: branchName,
+          createPROnCompletion,
+          prTargetBranch
+        };
+      }
+
+      const result = await window.maestro.playbooks.create(sessionId, playbookData);
+
+      if (result.success) {
+        setPlaybooks(prev => [...prev, result.playbook]);
+        setLoadedPlaybook(result.playbook);
+        setShowSavePlaybookModal(false);
+      }
+    } catch (error) {
+      console.error('Failed to save playbook:', error);
+    }
+    setSavingPlaybook(false);
+  }, [sessionId, documents, loopEnabled, maxLoops, prompt, worktreeEnabled, branchName, createPROnCompletion, prTargetBranch, savingPlaybook]);
+
+  // Handle updating an existing playbook
+  const handleSaveUpdate = useCallback(async () => {
+    if (!loadedPlaybook || savingPlaybook) return;
+
+    setSavingPlaybook(true);
+    try {
+      // Build update data, including worktree settings if enabled
+      const updateData: Parameters<typeof window.maestro.playbooks.update>[2] = {
+        documents: documents.map(d => ({
+          filename: d.filename,
+          resetOnCompletion: d.resetOnCompletion
+        })),
+        loopEnabled,
+        maxLoops,
+        prompt,
+        updatedAt: Date.now()
+      };
+
+      // Include worktree settings if worktree is enabled, otherwise clear them
+      if (worktreeEnabled && branchName) {
+        updateData.worktreeSettings = {
+          branchNameTemplate: branchName,
+          createPROnCompletion,
+          prTargetBranch
+        };
+      } else {
+        // Explicitly set to undefined to clear previous worktree settings
+        updateData.worktreeSettings = undefined;
+      }
+
+      const result = await window.maestro.playbooks.update(sessionId, loadedPlaybook.id, updateData);
+
+      if (result.success) {
+        setLoadedPlaybook(result.playbook);
+        setPlaybooks(prev => prev.map(p => p.id === result.playbook.id ? result.playbook : p));
+      }
+    } catch (error) {
+      console.error('Failed to update playbook:', error);
+    }
+    setSavingPlaybook(false);
+  }, [sessionId, loadedPlaybook, documents, loopEnabled, maxLoops, prompt, worktreeEnabled, branchName, createPROnCompletion, prTargetBranch, savingPlaybook]);
+
+  // Handle discarding changes and reloading original playbook configuration
+  const handleDiscardChanges = useCallback(() => {
+    if (loadedPlaybook) {
+      handleLoadPlaybook(loadedPlaybook);
+    }
+  }, [loadedPlaybook, handleLoadPlaybook]);
+
+  // Close dropdown when clicking outside
+  useEffect(() => {
+    const handleClickOutside = (e: MouseEvent) => {
+      if (playbackDropdownRef.current && !playbackDropdownRef.current.contains(e.target as Node)) {
+        setShowPlaybookDropdown(false);
+      }
+    };
+
+    if (showPlaybookDropdown) {
+      document.addEventListener('mousedown', handleClickOutside);
+      return () => document.removeEventListener('mousedown', handleClickOutside);
+    }
+  }, [showPlaybookDropdown]);
+
+  // Close branch dropdown when clicking outside
+  useEffect(() => {
+    const handleClickOutside = (e: MouseEvent) => {
+      if (branchDropdownRef.current && !branchDropdownRef.current.contains(e.target as Node)) {
+        setShowBranchDropdown(false);
+      }
+    };
+
+    if (showBranchDropdown) {
+      document.addEventListener('mousedown', handleClickOutside);
+      return () => document.removeEventListener('mousedown', handleClickOutside);
+    }
+  }, [showBranchDropdown]);
+
   return (
     <div
       className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-[9999] animate-in fade-in duration-200"
@@ -162,33 +850,16 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
       tabIndex={-1}
     >
       <div
-        className="w-[700px] max-h-[80vh] border rounded-lg shadow-2xl overflow-hidden flex flex-col"
+        className="w-[700px] max-h-[85vh] border rounded-lg shadow-2xl overflow-hidden flex flex-col"
         style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
       >
         {/* Header */}
         <div className="p-4 border-b flex items-center justify-between shrink-0" style={{ borderColor: theme.colors.border }}>
-          <div className="flex flex-col gap-1">
-            <div className="flex items-center gap-3">
-              <h2 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
-                Batch Run Configuration
-              </h2>
-              {isModified && (
-                <span
-                  className="text-[10px] px-2 py-0.5 rounded-full"
-                  style={{ backgroundColor: theme.colors.accent + '20', color: theme.colors.accent }}
-                >
-                  CUSTOMIZED
-                </span>
-              )}
-            </div>
-            {isModified && lastModifiedAt && (
-              <span className="text-[10px]" style={{ color: theme.colors.textDim }}>
-                Last modified {formatLastModified(lastModifiedAt)}
-              </span>
-            )}
-          </div>
+          <h2 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
+            Auto Run Configuration
+          </h2>
           <div className="flex items-center gap-4">
-            {/* Task Count Badge */}
+            {/* Total Task Count Badge */}
             <div
               className="flex items-center gap-2 px-3 py-1.5 rounded-lg"
               style={{
@@ -200,13 +871,13 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
                 className="text-lg font-bold"
                 style={{ color: hasNoTasks ? theme.colors.error : theme.colors.success }}
               >
-                {taskCount}
+                {loadingTaskCounts ? '...' : totalTaskCount}
               </span>
               <span
                 className="text-xs font-medium"
                 style={{ color: hasNoTasks ? theme.colors.error : theme.colors.success }}
               >
-                {taskCount === 1 ? 'task' : 'tasks'}
+                {totalTaskCount === 1 ? 'task' : 'tasks'}
               </span>
             </div>
             <button onClick={onClose} style={{ color: theme.colors.textDim }}>
@@ -216,12 +887,765 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
         </div>
 
         {/* Content */}
-        <div className="flex-1 overflow-hidden flex flex-col p-6 gap-4">
-          <div className="flex flex-col gap-2 flex-1 min-h-0">
-            <div className="flex items-center justify-between">
+        <div className="flex-1 overflow-y-auto p-6">
+          {/* Playbook Section */}
+          <div className="mb-6 flex items-center justify-between">
+            {/* Load Playbook Dropdown - only show when playbooks exist or one is loaded */}
+            {(playbooks.length > 0 || loadedPlaybook) ? (
+              <div className="relative" ref={playbackDropdownRef}>
+                <button
+                  onClick={() => setShowPlaybookDropdown(!showPlaybookDropdown)}
+                  className="flex items-center gap-2 px-3 py-1.5 rounded-lg border hover:bg-white/5 transition-colors"
+                  style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+                  disabled={loadingPlaybooks}
+                >
+                  <FolderOpen className="w-4 h-4" style={{ color: theme.colors.accent }} />
+                  <span className="text-sm">
+                    {loadedPlaybook ? loadedPlaybook.name : 'Load Playbook'}
+                  </span>
+                  <ChevronDown className="w-3.5 h-3.5" style={{ color: theme.colors.textDim }} />
+                </button>
+
+                {/* Dropdown Menu */}
+                {showPlaybookDropdown && (
+                  <div
+                    className="absolute top-full left-0 mt-1 w-64 rounded-lg border shadow-lg z-10 overflow-hidden"
+                    style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+                  >
+                    <div className="max-h-48 overflow-y-auto">
+                      {playbooks.map((pb) => (
+                        <div
+                          key={pb.id}
+                          className={`flex items-center gap-2 px-3 py-2 hover:bg-white/5 cursor-pointer transition-colors ${
+                            loadedPlaybook?.id === pb.id ? 'bg-white/10' : ''
+                          }`}
+                          onClick={() => handleLoadPlaybook(pb)}
+                        >
+                          <span
+                            className="flex-1 text-sm truncate"
+                            style={{ color: theme.colors.textMain }}
+                          >
+                            {pb.name}
+                          </span>
+                          <span
+                            className="text-[10px] shrink-0"
+                            style={{ color: theme.colors.textDim }}
+                          >
+                            {pb.documents.length} doc{pb.documents.length !== 1 ? 's' : ''}
+                          </span>
+                          <button
+                            onClick={(e) => handleDeletePlaybook(pb, e)}
+                            className="p-1 rounded hover:bg-white/10 transition-colors shrink-0"
+                            style={{ color: theme.colors.textDim }}
+                            title="Delete playbook"
+                          >
+                            <X className="w-3 h-3" />
+                          </button>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            ) : (
+              <div /> /* Empty placeholder to maintain flex layout */
+            )}
+
+            {/* Right side: Save as Playbook OR Save Update/Discard buttons */}
+            <div className="flex items-center gap-2">
+              {/* Save as Playbook button - shown when >1 doc and no playbook loaded */}
+              {documents.length > 1 && !loadedPlaybook && (
+                <button
+                  onClick={() => setShowSavePlaybookModal(true)}
+                  className="flex items-center gap-2 px-3 py-1.5 rounded-lg border hover:bg-white/5 transition-colors"
+                  style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+                >
+                  <Bookmark className="w-4 h-4" style={{ color: theme.colors.accent }} />
+                  <span className="text-sm">Save as Playbook</span>
+                </button>
+              )}
+
+              {/* Save Update and Discard buttons - shown when playbook is loaded and modified */}
+              {loadedPlaybook && isPlaybookModified && (
+                <>
+                  <button
+                    onClick={handleDiscardChanges}
+                    className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg border hover:bg-white/5 transition-colors"
+                    style={{ borderColor: theme.colors.border, color: theme.colors.textDim }}
+                    title="Discard changes and reload original playbook configuration"
+                  >
+                    <RotateCcw className="w-3.5 h-3.5" />
+                    <span className="text-sm">Discard</span>
+                  </button>
+                  <button
+                    onClick={handleSaveUpdate}
+                    disabled={savingPlaybook}
+                    className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg border hover:bg-white/5 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+                    style={{ borderColor: theme.colors.accent, color: theme.colors.accent }}
+                    title="Save changes to the loaded playbook"
+                  >
+                    <Save className="w-3.5 h-3.5" />
+                    <span className="text-sm">{savingPlaybook ? 'Saving...' : 'Save Update'}</span>
+                  </button>
+                </>
+              )}
+            </div>
+          </div>
+
+          {/* Documents Section */}
+          <div className="mb-6">
+            <div className="flex items-center justify-between mb-3">
               <label className="text-xs font-bold uppercase" style={{ color: theme.colors.textDim }}>
-                Agent Prompt
+                Documents to Run
               </label>
+              <button
+                onClick={handleOpenDocSelector}
+                className="flex items-center gap-1 text-xs px-2 py-1 rounded hover:bg-white/10 transition-colors"
+                style={{ color: theme.colors.accent }}
+              >
+                <Plus className="w-3 h-3" />
+                Add Docs
+              </button>
+            </div>
+
+            {/* Document List with Loop Indicator */}
+            <div className={`relative ${loopEnabled && documents.length > 1 ? 'ml-7' : ''}`}>
+              {/* Loop path - right-angled lines from bottom around left to top */}
+              {loopEnabled && documents.length > 1 && (
+                <>
+                  {/* Left vertical line */}
+                  <div
+                    className="absolute pointer-events-none"
+                    style={{
+                      left: -24,
+                      top: 8,
+                      bottom: 8,
+                      width: 3,
+                      backgroundColor: theme.colors.accent,
+                      borderRadius: 1.5
+                    }}
+                  />
+                  {/* Top horizontal line - stops before document */}
+                  <div
+                    className="absolute pointer-events-none"
+                    style={{
+                      left: -24,
+                      top: 8,
+                      width: 18,
+                      height: 3,
+                      backgroundColor: theme.colors.accent,
+                      borderRadius: 1.5
+                    }}
+                  />
+                  {/* Bottom horizontal line - stops before document */}
+                  <div
+                    className="absolute pointer-events-none"
+                    style={{
+                      left: -24,
+                      bottom: 8,
+                      width: 18,
+                      height: 3,
+                      backgroundColor: theme.colors.accent,
+                      borderRadius: 1.5
+                    }}
+                  />
+                  {/* Arrow head pointing right (toward top doc) */}
+                  <div
+                    className="absolute pointer-events-none"
+                    style={{
+                      left: -10,
+                      top: 2,
+                      width: 0,
+                      height: 0,
+                      borderTop: '6px solid transparent',
+                      borderBottom: '6px solid transparent',
+                      borderLeft: `9px solid ${theme.colors.accent}`
+                    }}
+                  />
+                </>
+              )}
+              <div
+                className="rounded-lg border overflow-hidden"
+                style={{ backgroundColor: theme.colors.bgMain, borderColor: theme.colors.border }}
+              >
+              {documents.length === 0 ? (
+                <div className="p-4 text-center" style={{ color: theme.colors.textDim }}>
+                  <p className="text-sm">No documents selected</p>
+                  <p className="text-xs mt-1">Click "+ Add Docs" to select documents to run</p>
+                </div>
+              ) : (
+                <div className="divide-y" style={{ borderColor: theme.colors.border }}>
+                  {documents.map((doc) => {
+                    const docTaskCount = taskCounts[doc.filename] ?? 0;
+                    const isBeingDragged = draggedId === doc.id;
+                    const isDragTarget = dragOverId === doc.id;
+
+                    return (
+                      <div
+                        key={doc.id}
+                        draggable={!doc.isMissing} // Don't allow dragging missing docs
+                        onDragStart={(e) => !doc.isMissing && handleDragStart(e, doc.id)}
+                        onDragOver={(e) => handleDragOver(e, doc.id)}
+                        onDragEnd={handleDragEnd}
+                        className={`flex items-center gap-3 px-3 py-2 transition-all ${
+                          isBeingDragged ? 'opacity-50' : ''
+                        } ${isDragTarget ? 'bg-white/10' : 'hover:bg-white/5'} ${
+                          doc.isMissing ? 'opacity-60' : ''
+                        }`}
+                        style={{
+                          borderColor: theme.colors.border,
+                          backgroundColor: doc.isMissing ? theme.colors.error + '08' : undefined
+                        }}
+                      >
+                        {/* Drag Handle */}
+                        <GripVertical
+                          className={`w-4 h-4 shrink-0 ${doc.isMissing ? 'cursor-not-allowed' : 'cursor-grab active:cursor-grabbing'}`}
+                          style={{ color: doc.isMissing ? theme.colors.error + '60' : theme.colors.textDim }}
+                        />
+
+                        {/* Document Name */}
+                        <span
+                          className={`flex-1 text-sm font-medium truncate ${doc.isMissing ? 'line-through' : ''}`}
+                          style={{ color: doc.isMissing ? theme.colors.error : theme.colors.textMain }}
+                        >
+                          {doc.filename}
+                        </span>
+
+                        {/* Missing Indicator */}
+                        {doc.isMissing && (
+                          <span
+                            className="text-[10px] px-1.5 py-0.5 rounded shrink-0 uppercase font-bold"
+                            style={{
+                              backgroundColor: theme.colors.error + '20',
+                              color: theme.colors.error
+                            }}
+                            title="This document no longer exists in the folder"
+                          >
+                            Missing
+                          </span>
+                        )}
+
+                        {/* Task Count Badge (hidden for missing docs) */}
+                        {!doc.isMissing && (
+                          <span
+                            className="text-xs px-2 py-0.5 rounded shrink-0"
+                            style={{
+                              backgroundColor: docTaskCount === 0 ? theme.colors.error + '20' : theme.colors.success + '20',
+                              color: docTaskCount === 0 ? theme.colors.error : theme.colors.success
+                            }}
+                          >
+                            {loadingTaskCounts ? '...' : `${docTaskCount} ${docTaskCount === 1 ? 'task' : 'tasks'}`}
+                          </span>
+                        )}
+
+                        {/* Reset Toggle Button (hidden for missing docs) */}
+                        {!doc.isMissing && (() => {
+                          // Check if this document has duplicates (other entries with same filename)
+                          const hasDuplicates = documents.filter(d => d.filename === doc.filename).length > 1;
+                          const canDisableReset = !hasDuplicates;
+
+                          let tooltipText: string;
+                          if (doc.resetOnCompletion) {
+                            if (canDisableReset) {
+                              tooltipText = 'Reset enabled: uncompleted tasks will be re-checked when done. Click to disable.';
+                            } else {
+                              tooltipText = 'Reset enabled: uncompleted tasks will be re-checked when done. Remove duplicates to disable.';
+                            }
+                          } else {
+                            tooltipText = 'Enable reset: uncompleted tasks will be re-checked when this document completes';
+                          }
+
+                          return (
+                            <button
+                              onClick={() => {
+                                if (!doc.resetOnCompletion || canDisableReset) {
+                                  handleToggleReset(doc.id);
+                                }
+                              }}
+                              className={`p-1 rounded transition-colors shrink-0 ${
+                                doc.resetOnCompletion
+                                  ? (canDisableReset ? 'hover:bg-white/10' : 'cursor-not-allowed')
+                                  : 'hover:bg-white/10'
+                              }`}
+                              style={{
+                                backgroundColor: doc.resetOnCompletion ? theme.colors.accent + '20' : 'transparent',
+                                color: doc.resetOnCompletion ? theme.colors.accent : theme.colors.textDim,
+                                opacity: doc.resetOnCompletion && !canDisableReset ? 0.7 : 1
+                              }}
+                              title={tooltipText}
+                            >
+                              <RotateCcw className="w-3.5 h-3.5" />
+                            </button>
+                          );
+                        })()}
+
+                        {/* Duplicate Button (only shown for reset-enabled docs that aren't missing) */}
+                        {doc.resetOnCompletion && !doc.isMissing && (
+                          <button
+                            onClick={() => handleDuplicateDocument(doc.id)}
+                            className="p-1 rounded hover:bg-white/10 transition-colors shrink-0"
+                            style={{ color: theme.colors.textDim }}
+                            title="Duplicate document"
+                          >
+                            <Plus className="w-3.5 h-3.5" />
+                          </button>
+                        )}
+
+                        {/* Remove Button (only for duplicates, multiple docs, OR missing docs) */}
+                        {(doc.isDuplicate || documents.length > 1 || doc.isMissing) && (
+                          <button
+                            onClick={() => handleRemoveDocument(doc.id)}
+                            className="p-1 rounded hover:bg-white/10 transition-colors shrink-0"
+                            style={{ color: doc.isMissing ? theme.colors.error : theme.colors.textDim }}
+                            title={doc.isMissing ? 'Remove missing document' : 'Remove document'}
+                          >
+                            <X className="w-3.5 h-3.5" />
+                          </button>
+                        )}
+                      </div>
+                    );
+                  })}
+                </div>
+              )}
+              </div>
+            </div>
+
+            {/* Missing Documents Warning */}
+            {hasMissingDocs && (
+              <div
+                className="mt-2 flex items-center gap-2 p-2 rounded border text-xs"
+                style={{
+                  backgroundColor: theme.colors.warning + '10',
+                  borderColor: theme.colors.warning + '40',
+                  color: theme.colors.warning
+                }}
+              >
+                <AlertTriangle className="w-3.5 h-3.5 shrink-0" />
+                <span>
+                  {missingDocCount} document{missingDocCount > 1 ? 's' : ''} no longer exist{missingDocCount === 1 ? 's' : ''} in the folder and will be skipped
+                </span>
+              </div>
+            )}
+
+            {/* Total Summary with Loop Button */}
+            {documents.length > 1 && (
+              <div className="mt-2 flex items-center justify-between">
+                {/* Loop Mode Toggle with Max Loops Control */}
+                <div className="flex items-center gap-2">
+                  {/* Loop Toggle Button */}
+                  <button
+                    onClick={() => setLoopEnabled(!loopEnabled)}
+                    className={`flex items-center gap-1.5 px-2.5 py-1 rounded-lg border transition-colors ${
+                      loopEnabled ? 'border-accent' : 'border-border hover:bg-white/5'
+                    }`}
+                    style={{
+                      borderColor: loopEnabled ? theme.colors.accent : theme.colors.border,
+                      backgroundColor: loopEnabled ? theme.colors.accent + '15' : 'transparent'
+                    }}
+                    title="Loop back to first document when finished"
+                  >
+                    <Repeat
+                      className="w-3.5 h-3.5"
+                      style={{ color: loopEnabled ? theme.colors.accent : theme.colors.textDim }}
+                    />
+                    <span
+                      className="text-xs font-medium"
+                      style={{ color: loopEnabled ? theme.colors.accent : theme.colors.textMain }}
+                    >
+                      Loop
+                    </span>
+                  </button>
+
+                  {/* Max Loops Control - only shown when loop is enabled */}
+                  {loopEnabled && (
+                    <div
+                      className="flex items-center rounded-lg border overflow-hidden"
+                      style={{ borderColor: theme.colors.border }}
+                    >
+                      {/* Infinity Toggle */}
+                      <button
+                        onClick={() => {
+                          setShowMaxLoopsSlider(false);
+                          setMaxLoops(null);
+                        }}
+                        className={`px-2.5 py-1 text-xs font-medium transition-colors ${
+                          !showMaxLoopsSlider ? 'bg-white/10' : 'hover:bg-white/5'
+                        }`}
+                        style={{
+                          color: !showMaxLoopsSlider ? theme.colors.accent : theme.colors.textDim
+                        }}
+                        title="Loop forever until all tasks complete"
+                      >
+                        <span className="text-xl leading-none">∞</span>
+                      </button>
+                      {/* Max Toggle */}
+                      <button
+                        onClick={() => {
+                          setShowMaxLoopsSlider(true);
+                          if (maxLoops === null) {
+                            setMaxLoops(5); // Default to 5 loops
+                          }
+                        }}
+                        className={`px-2.5 py-1 text-xs font-medium transition-colors border-l ${
+                          showMaxLoopsSlider ? 'bg-white/10' : 'hover:bg-white/5'
+                        }`}
+                        style={{
+                          color: showMaxLoopsSlider ? theme.colors.accent : theme.colors.textDim,
+                          borderColor: theme.colors.border
+                        }}
+                        title="Set maximum loop iterations"
+                      >
+                        max
+                      </button>
+                    </div>
+                  )}
+
+                  {/* Slider for max loops - shown when max is selected */}
+                  {loopEnabled && showMaxLoopsSlider && (
+                    <div className="flex items-center gap-2">
+                      <input
+                        type="range"
+                        min="1"
+                        max="25"
+                        value={maxLoops ?? 5}
+                        onChange={(e) => setMaxLoops(parseInt(e.target.value))}
+                        className="w-32 h-1 rounded-lg appearance-none cursor-pointer"
+                        style={{
+                          background: `linear-gradient(to right, ${theme.colors.accent} 0%, ${theme.colors.accent} ${((maxLoops ?? 5) / 25) * 100}%, ${theme.colors.border} ${((maxLoops ?? 5) / 25) * 100}%, ${theme.colors.border} 100%)`
+                        }}
+                      />
+                      <span
+                        className="text-xs font-mono w-6 text-center"
+                        style={{ color: theme.colors.accent }}
+                      >
+                        {maxLoops}
+                      </span>
+                    </div>
+                  )}
+                </div>
+                <span className="text-xs" style={{ color: theme.colors.textDim }}>
+                  Total: {loadingTaskCounts ? '...' : totalTaskCount} tasks across {documents.length - missingDocCount} {hasMissingDocs ? 'available ' : ''}document{documents.length - missingDocCount !== 1 ? 's' : ''}
+                  {hasMissingDocs && ` (${missingDocCount} missing)`}
+                </span>
+              </div>
+            )}
+
+          </div>
+
+          {/* Git Worktree Section - only visible for git repos */}
+          {isGitRepo && !checkingGitRepo && (
+            <div className="mb-6">
+              <div className="flex items-center gap-2 mb-3">
+                <GitBranch className="w-4 h-4" style={{ color: theme.colors.accent }} />
+                <label className="text-xs font-bold uppercase" style={{ color: theme.colors.textDim }}>
+                  Git Worktree
+                </label>
+                <span className="text-[10px] px-2 py-0.5 rounded" style={{ backgroundColor: theme.colors.accent + '20', color: theme.colors.accent }}>
+                  enables parallel work
+                </span>
+              </div>
+
+              {/* Enable Worktree Toggle */}
+              <div className="flex items-center gap-3 mb-4">
+                <button
+                  onClick={() => setWorktreeEnabled(!worktreeEnabled)}
+                  className={`flex items-center gap-2 px-3 py-1.5 rounded-lg border transition-colors ${
+                    worktreeEnabled ? 'border-accent' : 'border-border hover:bg-white/5'
+                  }`}
+                  style={{
+                    borderColor: worktreeEnabled ? theme.colors.accent : theme.colors.border,
+                    backgroundColor: worktreeEnabled ? theme.colors.accent + '15' : 'transparent'
+                  }}
+                >
+                  <div
+                    className={`w-4 h-4 rounded border flex items-center justify-center ${
+                      worktreeEnabled ? 'bg-accent border-accent' : ''
+                    }`}
+                    style={{
+                      borderColor: worktreeEnabled ? theme.colors.accent : theme.colors.border,
+                      backgroundColor: worktreeEnabled ? theme.colors.accent : 'transparent'
+                    }}
+                  >
+                    {worktreeEnabled && (
+                      <svg className="w-3 h-3 text-white" viewBox="0 0 12 12" fill="none">
+                        <path d="M2 6L5 9L10 3" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+                      </svg>
+                    )}
+                  </div>
+                  <span
+                    className="text-sm font-medium"
+                    style={{ color: worktreeEnabled ? theme.colors.accent : theme.colors.textMain }}
+                  >
+                    Enable Worktree
+                  </span>
+                </button>
+              </div>
+
+              {/* Worktree Configuration (only shown when enabled) */}
+              {worktreeEnabled && (
+                <div
+                  className="rounded-lg border p-4 space-y-4"
+                  style={{ backgroundColor: theme.colors.bgMain, borderColor: theme.colors.border }}
+                >
+                  {/* Worktree Path */}
+                  <div>
+                    <label className="text-xs font-medium mb-1.5 block" style={{ color: theme.colors.textDim }}>
+                      Worktree Path
+                    </label>
+                    <div className="flex gap-2">
+                      <input
+                        type="text"
+                        value={worktreePath}
+                        onChange={(e) => setWorktreePath(e.target.value)}
+                        placeholder="/path/to/worktree"
+                        className="flex-1 px-3 py-2 rounded border bg-transparent outline-none text-sm"
+                        style={{
+                          borderColor: theme.colors.border,
+                          color: theme.colors.textMain
+                        }}
+                      />
+                      <button
+                        onClick={async () => {
+                          const result = await window.maestro.dialog.selectFolder();
+                          if (result) {
+                            setWorktreePath(result);
+                          }
+                        }}
+                        className="px-3 py-2 rounded border hover:bg-white/5 transition-colors text-sm"
+                        style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+                      >
+                        Browse
+                      </button>
+                    </div>
+                  </div>
+
+                  {/* Branch Name */}
+                  <div>
+                    <label className="text-xs font-medium mb-1.5 block" style={{ color: theme.colors.textDim }}>
+                      Branch Name
+                    </label>
+                    <input
+                      type="text"
+                      value={branchName}
+                      onChange={(e) => setBranchName(e.target.value)}
+                      placeholder="autorun-feature-xyz"
+                      className="w-full px-3 py-2 rounded border bg-transparent outline-none text-sm"
+                      style={{
+                        borderColor: theme.colors.border,
+                        color: theme.colors.textMain
+                      }}
+                    />
+                  </div>
+
+                  {/* Validation Warnings */}
+                  {worktreeValidation.checking && (
+                    <div className="flex items-center gap-2 text-xs" style={{ color: theme.colors.textDim }}>
+                      <div className="animate-spin w-3 h-3 border border-current border-t-transparent rounded-full" />
+                      Checking worktree...
+                    </div>
+                  )}
+
+                  {/* Info: Existing worktree with same branch (no mismatch) */}
+                  {!worktreeValidation.checking && worktreeValidation.exists && !worktreeValidation.branchMismatch && worktreeValidation.sameRepo && worktreeValidation.currentBranch && (
+                    <div
+                      className="flex items-center gap-2 p-3 rounded border"
+                      style={{
+                        backgroundColor: theme.colors.accent + '10',
+                        borderColor: theme.colors.accent + '40'
+                      }}
+                    >
+                      <GitBranch
+                        className="w-4 h-4 shrink-0"
+                        style={{ color: theme.colors.accent }}
+                      />
+                      <p className="text-sm" style={{ color: theme.colors.textMain }}>
+                        Existing worktree on branch "{worktreeValidation.currentBranch}"
+                      </p>
+                    </div>
+                  )}
+
+                  {/* Warning: Worktree exists with different branch */}
+                  {!worktreeValidation.checking && worktreeValidation.exists && worktreeValidation.branchMismatch && worktreeValidation.sameRepo && (
+                    <div
+                      className="flex items-start gap-2 p-3 rounded border"
+                      style={{
+                        backgroundColor: worktreeValidation.hasUncommittedChanges
+                          ? theme.colors.error + '10'
+                          : theme.colors.warning + '10',
+                        borderColor: worktreeValidation.hasUncommittedChanges
+                          ? theme.colors.error
+                          : theme.colors.warning
+                      }}
+                    >
+                      <AlertTriangle
+                        className="w-4 h-4 mt-0.5 shrink-0"
+                        style={{
+                          color: worktreeValidation.hasUncommittedChanges
+                            ? theme.colors.error
+                            : theme.colors.warning
+                        }}
+                      />
+                      <div className="text-sm">
+                        <p style={{
+                          color: worktreeValidation.hasUncommittedChanges
+                            ? theme.colors.error
+                            : theme.colors.warning
+                        }}>
+                          Worktree exists with branch "{worktreeValidation.currentBranch}"
+                        </p>
+                        <p style={{ color: theme.colors.textDim }}>
+                          Will checkout to "{branchName}"
+                          {worktreeValidation.hasUncommittedChanges && (
+                            <span style={{ color: theme.colors.error }}>
+                              {' '}(uncommitted changes will block checkout)
+                            </span>
+                          )}
+                        </p>
+                      </div>
+                    </div>
+                  )}
+
+                  {/* Error: Worktree belongs to different repo */}
+                  {!worktreeValidation.checking && worktreeValidation.exists && !worktreeValidation.sameRepo && (
+                    <div
+                      className="flex items-start gap-2 p-3 rounded border"
+                      style={{
+                        backgroundColor: theme.colors.error + '10',
+                        borderColor: theme.colors.error
+                      }}
+                    >
+                      <AlertTriangle className="w-4 h-4 mt-0.5 shrink-0" style={{ color: theme.colors.error }} />
+                      <p className="text-sm" style={{ color: theme.colors.error }}>
+                        This path contains a worktree for a different repository. Please choose a different path.
+                      </p>
+                    </div>
+                  )}
+
+                  {/* Create PR on Completion */}
+                  <div className="pt-2 border-t" style={{ borderColor: theme.colors.border }}>
+                    {ghCliStatus === null ? (
+                      // Still checking gh CLI status
+                      <div className="flex items-center gap-2 text-xs" style={{ color: theme.colors.textDim }}>
+                        <Loader2 className="w-3 h-3 animate-spin" />
+                        Checking GitHub CLI...
+                      </div>
+                    ) : !ghCliStatus.installed ? (
+                      // gh CLI not installed
+                      <div className="flex items-center gap-2 text-xs" style={{ color: theme.colors.textDim }}>
+                        <AlertTriangle className="w-4 h-4 shrink-0" style={{ color: theme.colors.warning }} />
+                        <span>
+                          Install{' '}
+                          <a
+                            href="https://cli.github.com"
+                            target="_blank"
+                            rel="noopener noreferrer"
+                            className="underline hover:opacity-80"
+                            style={{ color: theme.colors.accent }}
+                            onClick={(e) => e.stopPropagation()}
+                          >
+                            GitHub CLI
+                          </a>
+                          {' '}to enable automatic PR creation
+                        </span>
+                      </div>
+                    ) : !ghCliStatus.authenticated ? (
+                      // gh CLI installed but not authenticated
+                      <div className="flex items-center gap-2 text-xs" style={{ color: theme.colors.textDim }}>
+                        <AlertTriangle className="w-4 h-4 shrink-0" style={{ color: theme.colors.warning }} />
+                        <span>
+                          Run <code className="px-1 py-0.5 rounded" style={{ backgroundColor: theme.colors.bgActivity }}>gh auth login</code> to enable automatic PR creation
+                        </span>
+                      </div>
+                    ) : (
+                      // gh CLI installed and authenticated - show the checkbox
+                      <div className="flex items-center gap-3">
+                        <button
+                          onClick={() => setCreatePROnCompletion(!createPROnCompletion)}
+                          className="flex items-center gap-2"
+                        >
+                          <div
+                            className={`w-4 h-4 rounded border flex items-center justify-center ${
+                              createPROnCompletion ? 'bg-accent border-accent' : ''
+                            }`}
+                            style={{
+                              borderColor: createPROnCompletion ? theme.colors.accent : theme.colors.border,
+                              backgroundColor: createPROnCompletion ? theme.colors.accent : 'transparent'
+                            }}
+                          >
+                            {createPROnCompletion && (
+                              <svg className="w-3 h-3 text-white" viewBox="0 0 12 12" fill="none">
+                                <path d="M2 6L5 9L10 3" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+                              </svg>
+                            )}
+                          </div>
+                          <span className="text-sm" style={{ color: theme.colors.textMain }}>
+                            Create PR on completion
+                          </span>
+                        </button>
+                        {/* Target branch selector */}
+                        <div className="relative" ref={branchDropdownRef}>
+                          <button
+                            onClick={() => setShowBranchDropdown(!showBranchDropdown)}
+                            className="flex items-center gap-1 text-xs px-2 py-1 rounded hover:bg-white/10 transition-colors"
+                            style={{ color: theme.colors.textDim }}
+                            title="Select target branch for PR"
+                          >
+                            <span>→</span>
+                            <span style={{ color: theme.colors.textMain }}>{prTargetBranch}</span>
+                            <ChevronDown className="w-3 h-3" />
+                          </button>
+                          {showBranchDropdown && availableBranches.length > 0 && (
+                            <div
+                              className="absolute bottom-full left-0 mb-1 w-48 max-h-48 overflow-y-auto rounded-lg border shadow-xl"
+                              style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+                            >
+                              {availableBranches.map((branch) => (
+                                <button
+                                  key={branch}
+                                  onClick={() => {
+                                    setPrTargetBranch(branch);
+                                    setShowBranchDropdown(false);
+                                  }}
+                                  className={`w-full text-left px-3 py-2 text-xs hover:bg-white/10 transition-colors ${
+                                    branch === prTargetBranch ? 'bg-white/5' : ''
+                                  }`}
+                                  style={{
+                                    color: branch === prTargetBranch ? theme.colors.accent : theme.colors.textMain
+                                  }}
+                                >
+                                  {branch}
+                                </button>
+                              ))}
+                            </div>
+                          )}
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+
+          {/* Divider */}
+          <div className="border-t mb-6" style={{ borderColor: theme.colors.border }} />
+
+          {/* Agent Prompt Section */}
+          <div className="flex flex-col gap-2">
+            <div className="flex items-center justify-between">
+              <div className="flex items-center gap-3">
+                <label className="text-xs font-bold uppercase" style={{ color: theme.colors.textDim }}>
+                  Agent Prompt
+                </label>
+                {isModified && (
+                  <span
+                    className="text-[10px] px-2 py-0.5 rounded-full"
+                    style={{ backgroundColor: theme.colors.accent + '20', color: theme.colors.accent }}
+                  >
+                    CUSTOMIZED
+                  </span>
+                )}
+              </div>
               <button
                 onClick={handleReset}
                 disabled={!isModified}
@@ -234,7 +1658,12 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
               </button>
             </div>
             <div className="text-[10px] mb-2" style={{ color: theme.colors.textDim }}>
-              Use <code className="px-1 py-0.5 rounded" style={{ backgroundColor: theme.colors.bgActivity }}>$$SCRATCHPAD$$</code> as placeholder for the scratchpad file path
+              This prompt is sent to the AI agent for each document in the queue.{' '}
+              {isModified && lastModifiedAt && (
+                <span style={{ color: theme.colors.textMain }}>
+                  Last modified {formatLastModified(lastModifiedAt)}.
+                </span>
+              )}
             </div>
 
             {/* Template Variables Documentation */}
@@ -281,18 +1710,28 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
                 </div>
               )}
             </div>
-            <textarea
-              ref={textareaRef}
-              value={prompt}
-              onChange={(e) => setPrompt(e.target.value)}
-              className="flex-1 w-full p-4 rounded border bg-transparent outline-none resize-none font-mono text-sm"
-              style={{
-                borderColor: theme.colors.border,
-                color: theme.colors.textMain,
-                minHeight: '300px'
-              }}
-              placeholder="Enter the prompt for the batch agent..."
-            />
+            <div className="relative">
+              <textarea
+                ref={textareaRef}
+                value={prompt}
+                onChange={(e) => setPrompt(e.target.value)}
+                className="w-full p-4 pr-10 rounded border bg-transparent outline-none resize-none font-mono text-sm"
+                style={{
+                  borderColor: theme.colors.border,
+                  color: theme.colors.textMain,
+                  minHeight: '200px'
+                }}
+                placeholder="Enter the prompt for the batch agent..."
+              />
+              <button
+                onClick={() => setPromptComposerOpen(true)}
+                className="absolute top-2 right-2 p-1.5 rounded hover:bg-white/10 transition-colors"
+                style={{ color: theme.colors.textDim }}
+                title="Expand editor"
+              >
+                <Maximize2 className="w-4 h-4" />
+              </button>
+            </div>
           </div>
         </div>
 
@@ -317,16 +1756,155 @@ export function BatchRunnerModal(props: BatchRunnerModalProps) {
           </button>
           <button
             onClick={handleGo}
-            disabled={hasNoTasks}
+            disabled={hasNoTasks || documents.length === 0 || documents.length === missingDocCount}
             className="flex items-center gap-2 px-4 py-2 rounded text-white font-bold disabled:opacity-40 disabled:cursor-not-allowed"
-            style={{ backgroundColor: hasNoTasks ? theme.colors.textDim : theme.colors.accent }}
-            title={hasNoTasks ? 'No unchecked tasks in scratchpad' : 'Run batch processing'}
+            style={{ backgroundColor: (hasNoTasks || documents.length === 0 || documents.length === missingDocCount) ? theme.colors.textDim : theme.colors.accent }}
+            title={
+              documents.length === 0 ? 'No documents selected' :
+              documents.length === missingDocCount ? 'All selected documents are missing' :
+              hasNoTasks ? 'No unchecked tasks in documents' :
+              'Run batch processing'
+            }
           >
             <Play className="w-4 h-4" />
             Go
           </button>
         </div>
       </div>
+
+      {/* Document Selector Modal */}
+      {showDocSelector && (
+        <div
+          className="fixed inset-0 bg-black/50 flex items-center justify-center z-[10000]"
+          onClick={() => setShowDocSelector(false)}
+        >
+          <div
+            className="w-[400px] max-h-[60vh] border rounded-lg shadow-2xl overflow-hidden flex flex-col"
+            style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+            onClick={(e) => e.stopPropagation()}
+          >
+            {/* Selector Header */}
+            <div className="p-4 border-b flex items-center justify-between shrink-0" style={{ borderColor: theme.colors.border }}>
+              <h3 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
+                Select Documents
+              </h3>
+              <button onClick={() => setShowDocSelector(false)} style={{ color: theme.colors.textDim }}>
+                <X className="w-4 h-4" />
+              </button>
+            </div>
+
+            {/* Document Checkboxes */}
+            <div className="flex-1 overflow-y-auto p-2">
+              {allDocuments.length === 0 ? (
+                <div className="p-4 text-center" style={{ color: theme.colors.textDim }}>
+                  <p className="text-sm">No documents found in folder</p>
+                </div>
+              ) : (
+                <div className="space-y-1">
+                  {allDocuments.map((filename) => {
+                    const isSelected = selectedDocsInSelector.has(filename);
+                    const docTaskCount = taskCounts[filename] ?? 0;
+
+                    return (
+                      <button
+                        key={filename}
+                        onClick={() => toggleDocInSelector(filename)}
+                        className={`w-full flex items-center gap-3 px-3 py-2 rounded transition-colors ${
+                          isSelected ? 'bg-white/10' : 'hover:bg-white/5'
+                        }`}
+                      >
+                        {/* Checkbox */}
+                        <div
+                          className={`w-4 h-4 rounded border flex items-center justify-center shrink-0 ${
+                            isSelected ? 'bg-accent border-accent' : ''
+                          }`}
+                          style={{
+                            borderColor: isSelected ? theme.colors.accent : theme.colors.border,
+                            backgroundColor: isSelected ? theme.colors.accent : 'transparent'
+                          }}
+                        >
+                          {isSelected && (
+                            <svg className="w-3 h-3 text-white" viewBox="0 0 12 12" fill="none">
+                              <path d="M2 6L5 9L10 3" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+                            </svg>
+                          )}
+                        </div>
+
+                        {/* Filename */}
+                        <span
+                          className="flex-1 text-sm text-left truncate"
+                          style={{ color: theme.colors.textMain }}
+                        >
+                          {filename}
+                        </span>
+
+                        {/* Task Count */}
+                        <span
+                          className="text-xs px-2 py-0.5 rounded shrink-0"
+                          style={{
+                            backgroundColor: docTaskCount === 0 ? theme.colors.textDim + '20' : theme.colors.success + '20',
+                            color: docTaskCount === 0 ? theme.colors.textDim : theme.colors.success
+                          }}
+                        >
+                          {loadingTaskCounts ? '...' : `${docTaskCount} ${docTaskCount === 1 ? 'task' : 'tasks'}`}
+                        </span>
+                      </button>
+                    );
+                  })}
+                </div>
+              )}
+            </div>
+
+            {/* Selector Footer */}
+            <div className="p-4 border-t flex justify-end gap-2 shrink-0" style={{ borderColor: theme.colors.border }}>
+              <button
+                onClick={() => setShowDocSelector(false)}
+                className="px-4 py-2 rounded border hover:bg-white/5 transition-colors"
+                style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleAddSelectedDocs}
+                className="px-4 py-2 rounded text-white font-bold"
+                style={{ backgroundColor: theme.colors.accent }}
+              >
+                Add ({selectedDocsInSelector.size})
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Save Playbook Modal */}
+      {showSavePlaybookModal && (
+        <PlaybookNameModal
+          theme={theme}
+          onSave={handleSaveAsPlaybook}
+          onCancel={() => setShowSavePlaybookModal(false)}
+          title="Save as Playbook"
+          saveButtonText={savingPlaybook ? 'Saving...' : 'Save'}
+        />
+      )}
+
+      {/* Playbook Delete Confirmation Modal */}
+      {showDeleteConfirmModal && playbookToDelete && (
+        <PlaybookDeleteConfirmModal
+          theme={theme}
+          playbookName={playbookToDelete.name}
+          onConfirm={handleConfirmDeletePlaybook}
+          onCancel={handleCancelDeletePlaybook}
+        />
+      )}
+
+      {/* Agent Prompt Composer Modal */}
+      <AgentPromptComposerModal
+        isOpen={promptComposerOpen}
+        onClose={() => setPromptComposerOpen(false)}
+        theme={theme}
+        initialValue={prompt}
+        onSubmit={(value) => setPrompt(value)}
+      />
     </div>
   );
 }
diff --git a/src/renderer/components/FileExplorerPanel.tsx b/src/renderer/components/FileExplorerPanel.tsx
index fa33ee834..af30aac99 100644
--- a/src/renderer/components/FileExplorerPanel.tsx
+++ b/src/renderer/components/FileExplorerPanel.tsx
@@ -1,10 +1,20 @@
-import React, { useEffect, useRef } from 'react';
-import { ChevronRight, ChevronDown, ChevronUp, Folder, RefreshCw } from 'lucide-react';
+import React, { useEffect, useRef, useState, useCallback } from 'react';
+import { createPortal } from 'react-dom';
+import { ChevronRight, ChevronDown, ChevronUp, Folder, RefreshCw, Check } from 'lucide-react';
 import type { Session, Theme, FileChangeType } from '../types';
+import type { FileTreeChanges } from '../utils/fileExplorer';
 import { getFileIcon } from '../utils/theme';
 import { useLayerStack } from '../contexts/LayerStackContext';
 import { MODAL_PRIORITIES } from '../constants/modalPriorities';
 
+// Auto-refresh interval options in seconds
+const AUTO_REFRESH_OPTIONS = [
+  { label: 'Every 5 seconds', value: 5 },
+  { label: 'Every 20 seconds', value: 20 },
+  { label: 'Every 60 seconds', value: 60 },
+  { label: 'Every 3 minutes', value: 180 },
+];
+
 interface FileNode {
   name: string;
   type: 'file' | 'folder';
@@ -32,8 +42,9 @@ interface FileExplorerPanelProps {
   expandAllFolders: (activeSessionId: string, activeSession: Session, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => void;
   collapseAllFolders: (activeSessionId: string, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => void;
   updateSessionWorkingDirectory: (activeSessionId: string, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => Promise<void>;
-  refreshFileTree: (sessionId: string) => Promise<void>;
+  refreshFileTree: (sessionId: string) => Promise<FileTreeChanges | undefined>;
   setSessions: React.Dispatch<React.SetStateAction<Session[]>>;
+  onAutoRefreshChange?: (interval: number) => void;
 }
 
 export function FileExplorerPanel(props: FileExplorerPanelProps) {
@@ -41,11 +52,137 @@ export function FileExplorerPanel(props: FileExplorerPanelProps) {
     session, theme, fileTreeFilter, setFileTreeFilter, fileTreeFilterOpen, setFileTreeFilterOpen,
     filteredFileTree, selectedFileIndex, setSelectedFileIndex, activeFocus, activeRightTab,
     previewFile, setActiveFocus, fileTreeContainerRef, fileTreeFilterInputRef, toggleFolder, handleFileClick, expandAllFolders,
-    collapseAllFolders, updateSessionWorkingDirectory, refreshFileTree, setSessions
+    collapseAllFolders, updateSessionWorkingDirectory, refreshFileTree, setSessions, onAutoRefreshChange
   } = props;
 
   const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
   const layerIdRef = useRef<string>();
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const [flashMessage, setFlashMessage] = useState<string | null>(null);
+  const flashTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Refresh overlay state
+  const [overlayOpen, setOverlayOpen] = useState(false);
+  const [overlayPosition, setOverlayPosition] = useState<{ top: number; left: number } | null>(null);
+  const refreshButtonRef = useRef<HTMLButtonElement>(null);
+  const hoverTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const isOverOverlayRef = useRef(false);
+  const autoRefreshTimerRef = useRef<NodeJS.Timeout | null>(null);
+
+  // Get current auto-refresh interval from session
+  const autoRefreshInterval = session.fileTreeAutoRefreshInterval || 0;
+
+  // Handle refresh with animation and flash notification
+  const handleRefresh = useCallback(async () => {
+    setIsRefreshing(true);
+    // Clear any existing flash message
+    if (flashTimeoutRef.current) {
+      clearTimeout(flashTimeoutRef.current);
+      flashTimeoutRef.current = null;
+    }
+    setFlashMessage(null);
+
+    try {
+      const changes = await refreshFileTree(session.id);
+
+      // Show flash notification with change count
+      if (changes) {
+        const message = changes.totalChanges === 0
+          ? 'No changes detected'
+          : `Detected ${changes.totalChanges} change${changes.totalChanges === 1 ? '' : 's'}`;
+        setFlashMessage(message);
+
+        // Auto-hide after 2 seconds
+        flashTimeoutRef.current = setTimeout(() => {
+          setFlashMessage(null);
+          flashTimeoutRef.current = null;
+        }, 2000);
+      }
+    } finally {
+      // Keep spinner visible for at least 500ms for visual feedback
+      setTimeout(() => setIsRefreshing(false), 500);
+    }
+  }, [refreshFileTree, session.id]);
+
+  // Silent refresh for auto-refresh (no flash notification)
+  const silentRefresh = useCallback(async () => {
+    await refreshFileTree(session.id);
+  }, [refreshFileTree, session.id]);
+
+  // Auto-refresh timer
+  useEffect(() => {
+    // Clear existing timer
+    if (autoRefreshTimerRef.current) {
+      clearInterval(autoRefreshTimerRef.current);
+      autoRefreshTimerRef.current = null;
+    }
+
+    // Start new timer if interval is set
+    if (autoRefreshInterval > 0) {
+      autoRefreshTimerRef.current = setInterval(() => {
+        silentRefresh();
+      }, autoRefreshInterval * 1000);
+    }
+
+    // Cleanup on unmount or interval change
+    return () => {
+      if (autoRefreshTimerRef.current) {
+        clearInterval(autoRefreshTimerRef.current);
+        autoRefreshTimerRef.current = null;
+      }
+    };
+  }, [autoRefreshInterval, silentRefresh]);
+
+  // Cleanup flash timeout on unmount
+  useEffect(() => {
+    return () => {
+      if (flashTimeoutRef.current) {
+        clearTimeout(flashTimeoutRef.current);
+      }
+    };
+  }, []);
+
+  // Hover handlers for refresh button overlay
+  const handleRefreshMouseEnter = useCallback(() => {
+    hoverTimeoutRef.current = setTimeout(() => {
+      if (refreshButtonRef.current) {
+        const rect = refreshButtonRef.current.getBoundingClientRect();
+        setOverlayPosition({ top: rect.bottom + 4, left: rect.right });
+      }
+      setOverlayOpen(true);
+    }, 400);
+  }, []);
+
+  const handleRefreshMouseLeave = useCallback(() => {
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+      hoverTimeoutRef.current = null;
+    }
+    // Delay closing to allow mouse to reach overlay
+    hoverTimeoutRef.current = setTimeout(() => {
+      if (!isOverOverlayRef.current) {
+        setOverlayOpen(false);
+      }
+    }, 100);
+  }, []);
+
+  const handleOverlayMouseEnter = useCallback(() => {
+    isOverOverlayRef.current = true;
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+      hoverTimeoutRef.current = null;
+    }
+  }, []);
+
+  const handleOverlayMouseLeave = useCallback(() => {
+    isOverOverlayRef.current = false;
+    setOverlayOpen(false);
+  }, []);
+
+  const handleIntervalSelect = useCallback((interval: number) => {
+    onAutoRefreshChange?.(interval);
+    setOverlayOpen(false);
+  }, [onAutoRefreshChange]);
 
   // Register layer when filter is open
   useEffect(() => {
@@ -139,7 +276,38 @@ export function FileExplorerPanel(props: FileExplorerPanelProps) {
   };
 
   return (
-    <div className="space-y-2">
+    <div className="space-y-2 relative">
+      {/* Flash notification for refresh results */}
+      {flashMessage && (
+        <div
+          className="absolute inset-x-0 top-16 z-20 flex justify-center pointer-events-none"
+          style={{
+            animation: 'fadeInOut 2s ease-in-out forwards',
+          }}
+        >
+          <style>
+            {`
+              @keyframes fadeInOut {
+                0% { opacity: 0; transform: translateY(-8px); }
+                15% { opacity: 1; transform: translateY(0); }
+                85% { opacity: 1; transform: translateY(0); }
+                100% { opacity: 0; transform: translateY(-8px); }
+              }
+            `}
+          </style>
+          <div
+            className="px-4 py-2 rounded-lg shadow-lg text-xs font-medium"
+            style={{
+              backgroundColor: theme.colors.bgActivity,
+              color: theme.colors.textMain,
+              border: `1px solid ${theme.colors.border}`,
+            }}
+          >
+            {flashMessage}
+          </div>
+        </div>
+      )}
+
       {/* File Tree Filter */}
       {fileTreeFilterOpen && (
         <div className="mb-3 pt-4">
@@ -166,12 +334,18 @@ export function FileExplorerPanel(props: FileExplorerPanelProps) {
         <span className="opacity-50 truncate min-w-0 flex-1" title={session.cwd}>{session.cwd}</span>
         <div className="flex items-center gap-1 flex-shrink-0">
           <button
-            onClick={() => refreshFileTree(session.id)}
+            ref={refreshButtonRef}
+            onClick={handleRefresh}
+            onMouseEnter={handleRefreshMouseEnter}
+            onMouseLeave={handleRefreshMouseLeave}
             className="p-1 rounded hover:bg-white/10 transition-colors"
-            title="Refresh file tree"
-            style={{ color: theme.colors.textDim }}
+            title={autoRefreshInterval > 0 ? `Auto-refresh every ${autoRefreshInterval}s` : "Refresh file tree"}
+            style={{
+              color: autoRefreshInterval > 0 ? theme.colors.accent : theme.colors.textDim,
+              backgroundColor: autoRefreshInterval > 0 ? `${theme.colors.accent}20` : 'transparent'
+            }}
           >
-            <RefreshCw className="w-3.5 h-3.5" />
+            <RefreshCw className={`w-3.5 h-3.5 ${isRefreshing ? 'animate-spin' : ''}`} />
           </button>
           <button
             onClick={() => expandAllFolders(session.id, session, setSessions)}
@@ -224,6 +398,73 @@ export function FileExplorerPanel(props: FileExplorerPanelProps) {
           )}
         </>
       )}
+
+      {/* Auto-refresh overlay - rendered via portal */}
+      {overlayOpen && overlayPosition && createPortal(
+        <div
+          className="fixed z-[100] rounded-lg shadow-xl border overflow-hidden"
+          style={{
+            backgroundColor: theme.colors.bgSidebar,
+            borderColor: theme.colors.border,
+            minWidth: '180px',
+            top: overlayPosition.top,
+            left: overlayPosition.left,
+            transform: 'translateX(-100%)'
+          }}
+          onMouseEnter={handleOverlayMouseEnter}
+          onMouseLeave={handleOverlayMouseLeave}
+        >
+          {/* Header */}
+          <div
+            className="px-3 py-2 text-xs font-medium border-b"
+            style={{
+              backgroundColor: theme.colors.bgActivity,
+              borderColor: theme.colors.border,
+              color: theme.colors.textMain
+            }}
+          >
+            Auto-refresh
+          </div>
+
+          {/* Options */}
+          <div className="p-1">
+            {AUTO_REFRESH_OPTIONS.map((option) => (
+              <button
+                key={option.value}
+                onClick={() => handleIntervalSelect(option.value)}
+                className="w-full flex items-center justify-between gap-2 px-2 py-1.5 rounded text-xs hover:bg-white/10 transition-colors"
+                style={{
+                  color: autoRefreshInterval === option.value ? theme.colors.accent : theme.colors.textMain,
+                  backgroundColor: autoRefreshInterval === option.value ? `${theme.colors.accent}15` : 'transparent'
+                }}
+              >
+                <span>{option.label}</span>
+                {autoRefreshInterval === option.value && (
+                  <Check className="w-3.5 h-3.5" style={{ color: theme.colors.accent }} />
+                )}
+              </button>
+            ))}
+
+            {/* Disable option - only shown when auto-refresh is active */}
+            {autoRefreshInterval > 0 && (
+              <>
+                <div
+                  className="my-1 border-t"
+                  style={{ borderColor: theme.colors.border }}
+                />
+                <button
+                  onClick={() => handleIntervalSelect(0)}
+                  className="w-full flex items-center gap-2 px-2 py-1.5 rounded text-xs hover:bg-white/10 transition-colors"
+                  style={{ color: theme.colors.textDim }}
+                >
+                  Disable auto-refresh
+                </button>
+              </>
+            )}
+          </div>
+        </div>,
+        document.body
+      )}
     </div>
   );
 }
diff --git a/src/renderer/components/InputArea.tsx b/src/renderer/components/InputArea.tsx
index 525cdb270..14fef2201 100644
--- a/src/renderer/components/InputArea.tsx
+++ b/src/renderer/components/InputArea.tsx
@@ -1,5 +1,5 @@
 import React, { useRef, useEffect, useMemo } from 'react';
-import { Terminal, Cpu, Keyboard, ImageIcon, X, ArrowUp, StopCircle, Eye, History, File, Folder, GitBranch, Tag, PenLine } from 'lucide-react';
+import { Terminal, Cpu, Keyboard, ImageIcon, X, ArrowUp, Eye, History, File, Folder, GitBranch, Tag, PenLine } from 'lucide-react';
 import type { Session, Theme, BatchRunState } from '../types';
 import type { TabCompletionSuggestion, TabCompletionFilter } from '../hooks/useTabCompletion';
 import { ThinkingStatusPill } from './ThinkingStatusPill';
@@ -154,7 +154,11 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
   );
 
   // Refs for slash command items to enable scroll-into-view
+  // Reset refs array length when filtered commands change to avoid stale refs
   const slashCommandItemRefs = useRef<(HTMLDivElement | null)[]>([]);
+  if (slashCommandItemRefs.current.length !== filteredSlashCommands.length) {
+    slashCommandItemRefs.current = slashCommandItemRefs.current.slice(0, filteredSlashCommands.length);
+  }
 
   // Refs for tab completion items to enable scroll-into-view
   const tabCompletionItemRefs = useRef<(HTMLDivElement | null)[]>([]);
@@ -223,6 +227,7 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
           autoRunState={autoRunState}
           activeSessionId={session.id}
           onStopAutoRun={onStopAutoRun}
+          onInterrupt={handleInterrupt}
         />
       )}
 
@@ -263,10 +268,10 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
       {/* Slash Command Autocomplete */}
       {slashCommandOpen && filteredSlashCommands.length > 0 && (
         <div
-          className="absolute bottom-full left-0 right-0 mb-2 border rounded-lg shadow-2xl max-h-64 overflow-hidden"
+          className="absolute bottom-full left-0 right-0 mb-2 border rounded-lg shadow-2xl overflow-hidden"
           style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
         >
-          <div className="overflow-y-auto max-h-64 scrollbar-thin">
+          <div className="overflow-y-auto max-h-64 scrollbar-thin" style={{ overscrollBehavior: 'contain' }}>
             {filteredSlashCommands.map((cmd, idx) => (
               <div
                 key={cmd.command}
@@ -279,11 +284,14 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
                   color: idx === safeSelectedIndex ? theme.colors.bgMain : theme.colors.textMain
                 }}
                 onClick={() => {
+                  // Single click just selects the item
+                  setSelectedSlashCommandIndex(idx);
+                }}
+                onDoubleClick={() => {
+                  // Double click fills in the command text
                   setInputValue(cmd.command);
                   setSlashCommandOpen(false);
                   inputRef.current?.focus();
-                  // Execute the command after a brief delay to let state update
-                  setTimeout(() => processInput(), 10);
                 }}
                 onMouseEnter={() => setSelectedSlashCommandIndex(idx)}
               >
@@ -554,9 +562,12 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
 
                 // Show slash command autocomplete when typing /
                 if (value.startsWith('/') && !value.includes(' ')) {
+                  // Only reset selection when modal first opens, not on every keystroke
+                  if (!slashCommandOpen) {
+                    setSelectedSlashCommandIndex(0);
+                  }
                   setSlashCommandOpen(true);
-                  // Always reset selection to first item when filter changes
-                  setSelectedSlashCommandIndex(0);
+                  // Clamp selection if filtered list shrinks (handled by safeSelectedIndex in render)
                 } else {
                   setSlashCommandOpen(false);
                 }
@@ -707,41 +718,31 @@ export const InputArea = React.memo(function InputArea(props: InputAreaProps) {
         {/* Mode Toggle & Send/Interrupt Button - Right Side */}
         <div className="flex flex-col gap-2">
           <button
+            type="button"
             onClick={toggleInputMode}
-            className="p-2 rounded border transition-all"
+            className="p-2 rounded-lg border transition-all"
             style={{
-              backgroundColor: session.inputMode === 'terminal' ? theme.colors.bgActivity : theme.colors.accentDim,
+              backgroundColor: theme.colors.bgMain,
               borderColor: theme.colors.border,
-              color: session.inputMode === 'terminal' ? theme.colors.textDim : theme.colors.accentText
+              color: theme.colors.textDim
             }}
             title="Toggle Mode (Cmd+J)"
           >
             {session.inputMode === 'terminal' ? <Terminal className="w-4 h-4" /> : <Cpu className="w-4 h-4" />}
           </button>
-          {/* Show interrupt button only in AI mode when busy. Terminal mode always shows send button
-              because terminal doesn't block - you can send commands while others are running */}
-          {session.state === 'busy' && session.inputMode === 'ai' ? (
-            <button
-              onClick={handleInterrupt}
-              className="p-2 rounded-md text-white hover:opacity-90 shadow-sm transition-all animate-pulse"
-              style={{ backgroundColor: theme.colors.error }}
-              title="Interrupt Claude (Ctrl+C)"
-            >
-              <StopCircle className="w-4 h-4" />
-            </button>
-          ) : (
-            <button
-              onClick={processInput}
-              className="p-2 rounded-md shadow-sm transition-all hover:opacity-90 cursor-pointer"
-              style={{
-                backgroundColor: theme.colors.accent,
-                color: theme.colors.accentForeground
-              }}
-              title={session.inputMode === 'terminal' ? 'Run command (Enter)' : 'Send message'}
-            >
-              <ArrowUp className="w-4 h-4" />
-            </button>
-          )}
+          {/* Send button - always visible. Stop button is now in ThinkingStatusPill */}
+          <button
+            type="button"
+            onClick={() => processInput()}
+            className="p-2 rounded-md shadow-sm transition-all hover:opacity-90 cursor-pointer"
+            style={{
+              backgroundColor: theme.colors.accent,
+              color: theme.colors.accentForeground
+            }}
+            title={session.inputMode === 'terminal' ? 'Run command (Enter)' : 'Send message'}
+          >
+            <ArrowUp className="w-4 h-4" />
+          </button>
         </div>
       </div>
     </div>
diff --git a/src/renderer/components/LogViewer.tsx b/src/renderer/components/LogViewer.tsx
index 385c3a705..ee765240a 100644
--- a/src/renderer/components/LogViewer.tsx
+++ b/src/renderer/components/LogViewer.tsx
@@ -245,15 +245,7 @@ export function LogViewer({ theme, onClose, logLevel = 'info', savedSelectedLeve
       e.preventDefault();
       setSearchOpen(true);
     }
-    // Scroll with arrow keys (only when search is not open)
-    else if (e.key === 'ArrowUp' && !searchOpen) {
-      e.preventDefault();
-      containerRef.current?.scrollBy({ top: -100, behavior: 'smooth' });
-    } else if (e.key === 'ArrowDown' && !searchOpen) {
-      e.preventDefault();
-      containerRef.current?.scrollBy({ top: 100, behavior: 'smooth' });
-    }
-    // Jump to top/bottom
+    // Jump to top/bottom with Cmd+Up/Down
     else if ((e.metaKey || e.ctrlKey) && e.key === 'ArrowUp' && !searchOpen) {
       e.preventDefault();
       containerRef.current?.scrollTo({ top: 0, behavior: 'smooth' });
@@ -261,6 +253,28 @@ export function LogViewer({ theme, onClose, logLevel = 'info', savedSelectedLeve
       e.preventDefault();
       containerRef.current?.scrollTo({ top: containerRef.current.scrollHeight, behavior: 'smooth' });
     }
+    // Page up/down with Opt+Up/Down
+    else if (e.altKey && e.key === 'ArrowUp' && !searchOpen) {
+      e.preventDefault();
+      const container = containerRef.current;
+      if (container) {
+        container.scrollBy({ top: -container.clientHeight * 0.8, behavior: 'smooth' });
+      }
+    } else if (e.altKey && e.key === 'ArrowDown' && !searchOpen) {
+      e.preventDefault();
+      const container = containerRef.current;
+      if (container) {
+        container.scrollBy({ top: container.clientHeight * 0.8, behavior: 'smooth' });
+      }
+    }
+    // Scroll with plain arrow keys (only when search is not open)
+    else if (e.key === 'ArrowUp' && !searchOpen) {
+      e.preventDefault();
+      containerRef.current?.scrollBy({ top: -100, behavior: 'smooth' });
+    } else if (e.key === 'ArrowDown' && !searchOpen) {
+      e.preventDefault();
+      containerRef.current?.scrollBy({ top: 100, behavior: 'smooth' });
+    }
   };
 
   const getLevelColor = (level: string) => {
diff --git a/src/renderer/components/NewInstanceModal.tsx b/src/renderer/components/NewInstanceModal.tsx
index e9a5a4db9..c97a8a990 100644
--- a/src/renderer/components/NewInstanceModal.tsx
+++ b/src/renderer/components/NewInstanceModal.tsx
@@ -32,6 +32,7 @@ export function NewInstanceModal({ isOpen, onClose, onCreate, theme, defaultAgen
   const [loading, setLoading] = useState(true);
   const [refreshingAgent, setRefreshingAgent] = useState<string | null>(null);
   const [debugInfo, setDebugInfo] = useState<AgentDebugInfo | null>(null);
+  const [homeDir, setHomeDir] = useState<string>('');
 
   // Layer stack integration
   const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
@@ -39,6 +40,19 @@ export function NewInstanceModal({ isOpen, onClose, onCreate, theme, defaultAgen
   const modalRef = useRef<HTMLDivElement>(null);
   const nameInputRef = useRef<HTMLInputElement>(null);
 
+  // Fetch home directory on mount for tilde expansion
+  useEffect(() => {
+    window.maestro.fs.homeDir().then(setHomeDir);
+  }, []);
+
+  // Expand tilde in path
+  const expandTilde = (path: string): string => {
+    if (!homeDir) return path;
+    if (path === '~') return homeDir;
+    if (path.startsWith('~/')) return homeDir + path.slice(1);
+    return path;
+  };
+
   // Define handlers first before they're used in effects
   const loadAgents = async () => {
     setLoading(true);
@@ -87,13 +101,15 @@ export function NewInstanceModal({ isOpen, onClose, onCreate, theme, defaultAgen
 
   const handleCreate = React.useCallback(() => {
     const name = instanceName || agents.find(a => a.id === selectedAgent)?.name || 'New Agent';
-    onCreate(selectedAgent, workingDir, name);
+    // Expand tilde before passing to callback
+    const expandedWorkingDir = expandTilde(workingDir.trim());
+    onCreate(selectedAgent, expandedWorkingDir, name);
     onClose();
 
     // Reset
     setInstanceName('');
     setWorkingDir('');
-  }, [instanceName, agents, selectedAgent, workingDir, onCreate, onClose]);
+  }, [instanceName, agents, selectedAgent, workingDir, onCreate, onClose, expandTilde]);
 
   // Effects
   useEffect(() => {
diff --git a/src/renderer/components/PlaybookDeleteConfirmModal.tsx b/src/renderer/components/PlaybookDeleteConfirmModal.tsx
new file mode 100644
index 000000000..4d8c945c1
--- /dev/null
+++ b/src/renderer/components/PlaybookDeleteConfirmModal.tsx
@@ -0,0 +1,131 @@
+import React, { useEffect, useRef } from 'react';
+import { X, Trash2 } from 'lucide-react';
+import type { Theme } from '../types';
+import { useLayerStack } from '../contexts/LayerStackContext';
+import { MODAL_PRIORITIES } from '../constants/modalPriorities';
+
+interface PlaybookDeleteConfirmModalProps {
+  theme: Theme;
+  playbookName: string;
+  onConfirm: () => void;
+  onCancel: () => void;
+}
+
+export function PlaybookDeleteConfirmModal({
+  theme,
+  playbookName,
+  onConfirm,
+  onCancel
+}: PlaybookDeleteConfirmModalProps) {
+  const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
+  const layerIdRef = useRef<string>();
+  const confirmButtonRef = useRef<HTMLButtonElement>(null);
+
+  // Auto-focus the confirm button so Enter will trigger it
+  useEffect(() => {
+    confirmButtonRef.current?.focus();
+  }, []);
+
+  // Register layer on mount
+  useEffect(() => {
+    const id = registerLayer({
+      id: '',
+      type: 'modal',
+      priority: MODAL_PRIORITIES.PLAYBOOK_DELETE_CONFIRM,
+      blocksLowerLayers: true,
+      capturesFocus: true,
+      focusTrap: 'strict',
+      ariaLabel: 'Delete Playbook Confirmation',
+      onEscape: onCancel
+    });
+    layerIdRef.current = id;
+
+    return () => {
+      if (layerIdRef.current) {
+        unregisterLayer(layerIdRef.current);
+      }
+    };
+  }, [registerLayer, unregisterLayer]);
+
+  // Update handler when dependencies change
+  useEffect(() => {
+    if (layerIdRef.current) {
+      updateLayerHandler(layerIdRef.current, onCancel);
+    }
+  }, [onCancel, updateLayerHandler]);
+
+  const handleConfirmClick = () => {
+    onConfirm();
+    onCancel(); // Close the modal after confirming
+  };
+
+  return (
+    <div
+      className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-[10000] animate-in fade-in duration-200"
+      role="dialog"
+      aria-modal="true"
+      aria-label="Delete Playbook Confirmation"
+      tabIndex={-1}
+      onKeyDown={(e) => {
+        e.stopPropagation();
+      }}
+    >
+      <div
+        className="w-[400px] border rounded-lg shadow-2xl overflow-hidden"
+        style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+      >
+        {/* Header */}
+        <div
+          className="p-4 border-b flex items-center justify-between"
+          style={{ borderColor: theme.colors.border }}
+        >
+          <div className="flex items-center gap-2">
+            <Trash2 className="w-4 h-4" style={{ color: theme.colors.error }} />
+            <h3 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
+              Delete Playbook
+            </h3>
+          </div>
+          <button
+            onClick={onCancel}
+            className="p-1 rounded hover:bg-white/10 transition-colors"
+            style={{ color: theme.colors.textDim }}
+          >
+            <X className="w-4 h-4" />
+          </button>
+        </div>
+
+        {/* Content */}
+        <div className="p-6">
+          <p className="text-sm leading-relaxed" style={{ color: theme.colors.textMain }}>
+            Are you sure you want to delete "<strong>{playbookName}</strong>"?
+          </p>
+          <p className="text-xs mt-2" style={{ color: theme.colors.textDim }}>
+            This cannot be undone.
+          </p>
+        </div>
+
+        {/* Footer */}
+        <div
+          className="p-4 border-t flex justify-end gap-3"
+          style={{ borderColor: theme.colors.border }}
+        >
+          <button
+            onClick={onCancel}
+            className="px-4 py-2 rounded border hover:bg-white/5 transition-colors"
+            style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+          >
+            Cancel
+          </button>
+          <button
+            ref={confirmButtonRef}
+            onClick={handleConfirmClick}
+            className="px-4 py-2 rounded font-bold text-white outline-none focus:ring-2 focus:ring-offset-1 transition-colors"
+            style={{ backgroundColor: theme.colors.error }}
+          >
+            Delete
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/renderer/components/PlaybookNameModal.tsx b/src/renderer/components/PlaybookNameModal.tsx
new file mode 100644
index 000000000..ddbb43bf3
--- /dev/null
+++ b/src/renderer/components/PlaybookNameModal.tsx
@@ -0,0 +1,175 @@
+import { useState, useRef, useEffect } from 'react';
+import { X, Save } from 'lucide-react';
+import type { Theme } from '../types';
+import { useLayerStack } from '../contexts/LayerStackContext';
+import { MODAL_PRIORITIES } from '../constants/modalPriorities';
+
+interface PlaybookNameModalProps {
+  theme: Theme;
+  onSave: (name: string) => void;
+  onCancel: () => void;
+  /** Optional initial name for editing existing playbook */
+  initialName?: string;
+  /** Title shown in the modal header */
+  title?: string;
+  /** Button text for the save action */
+  saveButtonText?: string;
+}
+
+export function PlaybookNameModal({
+  theme,
+  onSave,
+  onCancel,
+  initialName = '',
+  title = 'Save Playbook',
+  saveButtonText = 'Save'
+}: PlaybookNameModalProps) {
+  const [name, setName] = useState(initialName);
+  const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
+  const layerIdRef = useRef<string>();
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  // Register layer on mount
+  useEffect(() => {
+    const layerId = registerLayer({
+      type: 'modal',
+      priority: MODAL_PRIORITIES.PLAYBOOK_NAME,
+      blocksLowerLayers: true,
+      capturesFocus: true,
+      focusTrap: 'strict',
+      ariaLabel: title,
+      onEscape: onCancel
+    });
+    layerIdRef.current = layerId;
+
+    return () => {
+      if (layerIdRef.current) {
+        unregisterLayer(layerIdRef.current);
+      }
+    };
+  }, [registerLayer, unregisterLayer, title]);
+
+  // Update handler when dependencies change
+  useEffect(() => {
+    if (layerIdRef.current) {
+      updateLayerHandler(layerIdRef.current, onCancel);
+    }
+  }, [onCancel, updateLayerHandler]);
+
+  // Auto-focus the input on mount
+  useEffect(() => {
+    requestAnimationFrame(() => {
+      inputRef.current?.focus();
+      // Select all text if there's an initial name
+      if (initialName) {
+        inputRef.current?.select();
+      }
+    });
+  }, [initialName]);
+
+  const handleSave = () => {
+    const trimmedName = name.trim();
+    if (trimmedName) {
+      onSave(trimmedName);
+    }
+  };
+
+  const isValid = name.trim().length > 0;
+
+  return (
+    <div
+      className="fixed inset-0 bg-black/70 backdrop-blur-sm flex items-center justify-center z-[10002] animate-in fade-in duration-200"
+      role="dialog"
+      aria-modal="true"
+      aria-label={title}
+      tabIndex={-1}
+      onKeyDown={(e) => {
+        e.stopPropagation();
+      }}
+    >
+      <div
+        className="w-[400px] border rounded-lg shadow-2xl overflow-hidden"
+        style={{ backgroundColor: theme.colors.bgSidebar, borderColor: theme.colors.border }}
+      >
+        {/* Header */}
+        <div
+          className="p-4 border-b flex items-center justify-between"
+          style={{ borderColor: theme.colors.border }}
+        >
+          <div className="flex items-center gap-2">
+            <Save className="w-4 h-4" style={{ color: theme.colors.accent }} />
+            <h3 className="text-sm font-bold" style={{ color: theme.colors.textMain }}>
+              {title}
+            </h3>
+          </div>
+          <button
+            type="button"
+            onClick={onCancel}
+            className="p-1 rounded hover:bg-white/10 transition-colors"
+            style={{ color: theme.colors.textDim }}
+          >
+            <X className="w-4 h-4" />
+          </button>
+        </div>
+
+        {/* Content */}
+        <div className="p-6">
+          <label
+            className="block text-xs mb-2 font-medium"
+            style={{ color: theme.colors.textDim }}
+          >
+            Playbook Name
+          </label>
+          <input
+            ref={inputRef}
+            type="text"
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && isValid) {
+                e.preventDefault();
+                handleSave();
+              }
+            }}
+            placeholder="Enter playbook name..."
+            className="w-full p-3 rounded border bg-transparent outline-none focus:ring-1"
+            style={{
+              borderColor: theme.colors.border,
+              color: theme.colors.textMain
+            }}
+          />
+          <p className="text-xs mt-2" style={{ color: theme.colors.textDim }}>
+            Give your playbook a descriptive name to easily identify it later.
+          </p>
+        </div>
+
+        {/* Footer */}
+        <div
+          className="p-4 border-t flex justify-end gap-3"
+          style={{ borderColor: theme.colors.border }}
+        >
+          <button
+            type="button"
+            onClick={onCancel}
+            className="px-4 py-2 rounded border hover:bg-white/5 transition-colors"
+            style={{ borderColor: theme.colors.border, color: theme.colors.textMain }}
+          >
+            Cancel
+          </button>
+          <button
+            type="button"
+            onClick={handleSave}
+            disabled={!isValid}
+            className="px-4 py-2 rounded font-bold transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+            style={{
+              backgroundColor: theme.colors.accent,
+              color: theme.colors.accentForeground
+            }}
+          >
+            {saveButtonText}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/renderer/components/PlaygroundPanel.tsx b/src/renderer/components/PlaygroundPanel.tsx
index 7f1907f62..07ce17443 100644
--- a/src/renderer/components/PlaygroundPanel.tsx
+++ b/src/renderer/components/PlaygroundPanel.tsx
@@ -1,5 +1,6 @@
-import React, { useState, useEffect, useRef } from 'react';
-import { X, Trophy, FlaskConical, Play, RotateCcw } from 'lucide-react';
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { X, Trophy, FlaskConical, Play, RotateCcw, Sparkles, Copy, Check } from 'lucide-react';
+import confetti from 'canvas-confetti';
 import type { Theme, AutoRunStats } from '../types';
 import { useLayerStack } from '../contexts/LayerStackContext';
 import { MODAL_PRIORITIES } from '../constants/modalPriorities';
@@ -13,7 +14,7 @@ interface PlaygroundPanelProps {
   onClose: () => void;
 }
 
-type TabId = 'achievements';
+type TabId = 'achievements' | 'confetti';
 
 interface Tab {
   id: TabId;
@@ -23,6 +24,37 @@ interface Tab {
 
 const TABS: Tab[] = [
   { id: 'achievements', label: 'Achievements', icon: <Trophy className="w-4 h-4" /> },
+  { id: 'confetti', label: 'Confetti', icon: <Sparkles className="w-4 h-4" /> },
+];
+
+// Available confetti shapes
+type ConfettiShape = 'square' | 'circle' | 'star';
+const CONFETTI_SHAPES: ConfettiShape[] = ['square', 'circle', 'star'];
+
+// Grid position labels
+const GRID_LABELS = [
+  ['Top Left', 'Top Center', 'Top Right'],
+  ['Middle Left', 'Center', 'Middle Right'],
+  ['Bottom Left', 'Bottom Center', 'Bottom Right'],
+];
+
+// Grid position coordinates (x, y)
+const GRID_POSITIONS: [number, number][][] = [
+  [[0, 0], [0.5, 0], [1, 0]],
+  [[0, 0.5], [0.5, 0.5], [1, 0.5]],
+  [[0, 1], [0.5, 1], [1, 1]],
+];
+
+// Default confetti colors
+const DEFAULT_CONFETTI_COLORS = [
+  '#FFD700', // Gold
+  '#FF6B6B', // Red
+  '#4ECDC4', // Teal
+  '#45B7D1', // Blue
+  '#FFA726', // Orange
+  '#BA68C8', // Purple
+  '#F48FB1', // Pink
+  '#FFEAA7', // Yellow
 ];
 
 export function PlaygroundPanel({ theme, themeMode, onClose }: PlaygroundPanelProps) {
@@ -45,6 +77,49 @@ export function PlaygroundPanel({ theme, themeMode, onClose }: PlaygroundPanelPr
   const [ovationBadgeLevel, setOvationBadgeLevel] = useState(1);
   const [ovationIsNewRecord, setOvationIsNewRecord] = useState(false);
 
+  // Confetti playground state
+  const [confettiParticleCount, setConfettiParticleCount] = useState(100);
+  const [confettiAngle, setConfettiAngle] = useState(90);
+  const [confettiSpread, setConfettiSpread] = useState(45);
+  const [confettiStartVelocity, setConfettiStartVelocity] = useState(45);
+  const [confettiGravity, setConfettiGravity] = useState(1);
+  const [confettiDecay, setConfettiDecay] = useState(0.9);
+  const [confettiDrift, setConfettiDrift] = useState(0);
+  const [confettiScalar, setConfettiScalar] = useState(1);
+  const [confettiTicks, setConfettiTicks] = useState(200);
+  const [confettiFlat, setConfettiFlat] = useState(false);
+  const [confettiShapes, setConfettiShapes] = useState<ConfettiShape[]>(['square', 'circle']);
+  const [confettiColors, setConfettiColors] = useState<string[]>(DEFAULT_CONFETTI_COLORS);
+  const [selectedOrigins, setSelectedOrigins] = useState<Set<string>>(new Set(['2-1'])); // Default: bottom center
+  const [copySuccess, setCopySuccess] = useState(false);
+
+  // Handle keyboard shortcuts for tab switching
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Cmd+Shift+[ or Cmd+Shift+] to switch tabs
+      if (e.metaKey && e.shiftKey) {
+        if (e.key === '[' || e.key === '{') {
+          e.preventDefault();
+          setActiveTab(prev => {
+            const currentIdx = TABS.findIndex(t => t.id === prev);
+            const newIdx = currentIdx <= 0 ? TABS.length - 1 : currentIdx - 1;
+            return TABS[newIdx].id;
+          });
+        } else if (e.key === ']' || e.key === '}') {
+          e.preventDefault();
+          setActiveTab(prev => {
+            const currentIdx = TABS.findIndex(t => t.id === prev);
+            const newIdx = currentIdx >= TABS.length - 1 ? 0 : currentIdx + 1;
+            return TABS[newIdx].id;
+          });
+        }
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, []);
+
   // Register layer on mount
   useEffect(() => {
     const id = registerLayer({
@@ -148,6 +223,164 @@ export function PlaygroundPanel({ theme, themeMode, onClose }: PlaygroundPanelPr
     return Math.round(((logValue - LOG_MIN) / (LOG_MAX - LOG_MIN)) * 100);
   };
 
+  // Toggle origin grid selection
+  const toggleOrigin = (row: number, col: number) => {
+    const key = `${row}-${col}`;
+    setSelectedOrigins(prev => {
+      const newSet = new Set(prev);
+      if (newSet.has(key)) {
+        newSet.delete(key);
+      } else {
+        newSet.add(key);
+      }
+      return newSet;
+    });
+  };
+
+  // Toggle confetti shape
+  const toggleShape = (shape: ConfettiShape) => {
+    setConfettiShapes(prev => {
+      if (prev.includes(shape)) {
+        // Don't allow removing last shape
+        if (prev.length === 1) return prev;
+        return prev.filter(s => s !== shape);
+      }
+      return [...prev, shape];
+    });
+  };
+
+  // Fire confetti with current settings
+  const firePlaygroundConfetti = useCallback(() => {
+    if (selectedOrigins.size === 0) return;
+
+    const origins: { x: number; y: number }[] = [];
+    selectedOrigins.forEach(key => {
+      const [row, col] = key.split('-').map(Number);
+      const [x, y] = GRID_POSITIONS[row][col];
+      origins.push({ x, y });
+    });
+
+    origins.forEach(origin => {
+      confetti({
+        particleCount: Math.round(confettiParticleCount / origins.length),
+        angle: confettiAngle,
+        spread: confettiSpread,
+        startVelocity: confettiStartVelocity,
+        gravity: confettiGravity,
+        decay: confettiDecay,
+        drift: confettiDrift,
+        scalar: confettiScalar,
+        ticks: confettiTicks,
+        flat: confettiFlat,
+        shapes: confettiShapes,
+        colors: confettiColors,
+        origin,
+        zIndex: 99999,
+        disableForReducedMotion: false,
+      });
+    });
+  }, [
+    selectedOrigins,
+    confettiParticleCount,
+    confettiAngle,
+    confettiSpread,
+    confettiStartVelocity,
+    confettiGravity,
+    confettiDecay,
+    confettiDrift,
+    confettiScalar,
+    confettiTicks,
+    confettiFlat,
+    confettiShapes,
+    confettiColors,
+  ]);
+
+  // Reset confetti settings to defaults
+  const resetConfettiSettings = () => {
+    setConfettiParticleCount(100);
+    setConfettiAngle(90);
+    setConfettiSpread(45);
+    setConfettiStartVelocity(45);
+    setConfettiGravity(1);
+    setConfettiDecay(0.9);
+    setConfettiDrift(0);
+    setConfettiScalar(1);
+    setConfettiTicks(200);
+    setConfettiFlat(false);
+    setConfettiShapes(['square', 'circle']);
+    setConfettiColors(DEFAULT_CONFETTI_COLORS);
+    setSelectedOrigins(new Set(['2-1']));
+  };
+
+  // Copy confetti settings to clipboard
+  const copyConfettiSettings = useCallback(async () => {
+    // Build origins array from selected grid positions
+    const origins: { x: number; y: number }[] = [];
+    selectedOrigins.forEach(key => {
+      const [row, col] = key.split('-').map(Number);
+      const [x, y] = GRID_POSITIONS[row][col];
+      origins.push({ x, y });
+    });
+
+    const settings = {
+      particleCount: confettiParticleCount,
+      angle: confettiAngle,
+      spread: confettiSpread,
+      startVelocity: confettiStartVelocity,
+      gravity: confettiGravity,
+      decay: confettiDecay,
+      drift: confettiDrift,
+      scalar: confettiScalar,
+      ticks: confettiTicks,
+      flat: confettiFlat,
+      shapes: confettiShapes,
+      colors: confettiColors,
+      origins,
+    };
+
+    // Format as readable code snippet
+    const codeSnippet = `// Confetti Settings
+confetti({
+  particleCount: ${settings.particleCount},
+  angle: ${settings.angle},
+  spread: ${settings.spread},
+  startVelocity: ${settings.startVelocity},
+  gravity: ${settings.gravity},
+  decay: ${settings.decay},
+  drift: ${settings.drift},
+  scalar: ${settings.scalar},
+  ticks: ${settings.ticks},
+  flat: ${settings.flat},
+  shapes: ${JSON.stringify(settings.shapes)},
+  colors: ${JSON.stringify(settings.colors, null, 2).replace(/\n/g, '\n  ')},
+  origin: ${settings.origins.length === 1
+    ? `{ x: ${settings.origins[0].x}, y: ${settings.origins[0].y} }`
+    : `// Multiple origins:\n  // ${settings.origins.map(o => `{ x: ${o.x}, y: ${o.y} }`).join('\n  // ')}`},
+});`;
+
+    try {
+      await navigator.clipboard.writeText(codeSnippet);
+      setCopySuccess(true);
+      setTimeout(() => setCopySuccess(false), 2000);
+    } catch (err) {
+      console.error('Failed to copy settings:', err);
+    }
+  }, [
+    selectedOrigins,
+    confettiParticleCount,
+    confettiAngle,
+    confettiSpread,
+    confettiStartVelocity,
+    confettiGravity,
+    confettiDecay,
+    confettiDrift,
+    confettiScalar,
+    confettiTicks,
+    confettiFlat,
+    confettiShapes,
+    confettiColors,
+  ]);
+
   return (
     <>
       <div
@@ -363,6 +596,340 @@ export function PlaygroundPanel({ theme, themeMode, onClose }: PlaygroundPanelPr
                 </div>
               </div>
             )}
+
+            {activeTab === 'confetti' && (
+              <div className="grid grid-cols-2 gap-6">
+                {/* Left column - Controls */}
+                <div className="space-y-4">
+                  {/* Origin Grid */}
+                  <div
+                    className="p-4 rounded-lg border"
+                    style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgActivity }}
+                  >
+                    <h3 className="text-sm font-bold mb-3" style={{ color: theme.colors.textMain }}>
+                      Launch Origins (click to toggle)
+                    </h3>
+                    <div className="grid grid-cols-3 gap-2 w-fit mx-auto">
+                      {GRID_LABELS.map((row, rowIdx) =>
+                        row.map((label, colIdx) => {
+                          const key = `${rowIdx}-${colIdx}`;
+                          const isSelected = selectedOrigins.has(key);
+                          return (
+                            <button
+                              key={key}
+                              onClick={() => toggleOrigin(rowIdx, colIdx)}
+                              className="w-16 h-16 rounded-lg text-xs font-medium transition-all hover:scale-105"
+                              style={{
+                                backgroundColor: isSelected ? theme.colors.accent : theme.colors.bgMain,
+                                color: isSelected ? '#fff' : theme.colors.textDim,
+                                border: `2px solid ${isSelected ? theme.colors.accent : theme.colors.border}`,
+                              }}
+                              title={label}
+                            >
+                              {label.split(' ').map((word, i) => (
+                                <div key={i}>{word}</div>
+                              ))}
+                            </button>
+                          );
+                        })
+                      )}
+                    </div>
+                    <p className="text-xs mt-3 text-center" style={{ color: theme.colors.textDim }}>
+                      {selectedOrigins.size === 0
+                        ? 'Select at least one origin'
+                        : `${selectedOrigins.size} origin${selectedOrigins.size > 1 ? 's' : ''} selected`}
+                    </p>
+                  </div>
+
+                  {/* Basic Parameters */}
+                  <div
+                    className="p-4 rounded-lg border"
+                    style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgActivity }}
+                  >
+                    <h3 className="text-sm font-bold mb-3" style={{ color: theme.colors.textMain }}>
+                      Basic Parameters
+                    </h3>
+                    <div className="space-y-3">
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Particle Count</span>
+                          <span>{confettiParticleCount}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={10}
+                          max={500}
+                          value={confettiParticleCount}
+                          onChange={e => setConfettiParticleCount(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Angle (degrees)</span>
+                          <span>{confettiAngle}°</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={0}
+                          max={360}
+                          value={confettiAngle}
+                          onChange={e => setConfettiAngle(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Spread (degrees)</span>
+                          <span>{confettiSpread}°</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={0}
+                          max={360}
+                          value={confettiSpread}
+                          onChange={e => setConfettiSpread(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Start Velocity</span>
+                          <span>{confettiStartVelocity}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={1}
+                          max={100}
+                          value={confettiStartVelocity}
+                          onChange={e => setConfettiStartVelocity(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                    </div>
+                  </div>
+
+                  {/* Shapes */}
+                  <div
+                    className="p-4 rounded-lg border"
+                    style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgActivity }}
+                  >
+                    <h3 className="text-sm font-bold mb-3" style={{ color: theme.colors.textMain }}>
+                      Shapes
+                    </h3>
+                    <div className="flex gap-2">
+                      {CONFETTI_SHAPES.map(shape => (
+                        <button
+                          key={shape}
+                          onClick={() => toggleShape(shape)}
+                          className="flex-1 px-3 py-2 rounded text-sm font-medium transition-colors"
+                          style={{
+                            backgroundColor: confettiShapes.includes(shape)
+                              ? theme.colors.accent
+                              : theme.colors.bgMain,
+                            color: confettiShapes.includes(shape) ? '#fff' : theme.colors.textMain,
+                          }}
+                        >
+                          {shape === 'square' ? '■' : shape === 'circle' ? '●' : '★'} {shape}
+                        </button>
+                      ))}
+                    </div>
+                  </div>
+                </div>
+
+                {/* Right column - More Controls */}
+                <div className="space-y-4">
+                  {/* Physics Parameters */}
+                  <div
+                    className="p-4 rounded-lg border"
+                    style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgActivity }}
+                  >
+                    <h3 className="text-sm font-bold mb-3" style={{ color: theme.colors.textMain }}>
+                      Physics
+                    </h3>
+                    <div className="space-y-3">
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Gravity</span>
+                          <span>{confettiGravity.toFixed(2)}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={0}
+                          max={3}
+                          step={0.1}
+                          value={confettiGravity}
+                          onChange={e => setConfettiGravity(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Decay</span>
+                          <span>{confettiDecay.toFixed(2)}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={0.1}
+                          max={1}
+                          step={0.01}
+                          value={confettiDecay}
+                          onChange={e => setConfettiDecay(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Drift</span>
+                          <span>{confettiDrift.toFixed(1)}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={-3}
+                          max={3}
+                          step={0.1}
+                          value={confettiDrift}
+                          onChange={e => setConfettiDrift(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Scalar (size)</span>
+                          <span>{confettiScalar.toFixed(1)}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={0.1}
+                          max={3}
+                          step={0.1}
+                          value={confettiScalar}
+                          onChange={e => setConfettiScalar(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div>
+                        <label className="text-xs flex justify-between" style={{ color: theme.colors.textDim }}>
+                          <span>Ticks (duration)</span>
+                          <span>{confettiTicks}</span>
+                        </label>
+                        <input
+                          type="range"
+                          min={50}
+                          max={500}
+                          value={confettiTicks}
+                          onChange={e => setConfettiTicks(Number(e.target.value))}
+                          className="w-full"
+                        />
+                      </div>
+                      <div className="flex items-center gap-2 pt-1">
+                        <input
+                          type="checkbox"
+                          id="confettiFlat"
+                          checked={confettiFlat}
+                          onChange={e => setConfettiFlat(e.target.checked)}
+                        />
+                        <label htmlFor="confettiFlat" className="text-xs" style={{ color: theme.colors.textDim }}>
+                          Flat (disable 3D wobble)
+                        </label>
+                      </div>
+                    </div>
+                  </div>
+
+                  {/* Colors */}
+                  <div
+                    className="p-4 rounded-lg border"
+                    style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgActivity }}
+                  >
+                    <h3 className="text-sm font-bold mb-3" style={{ color: theme.colors.textMain }}>
+                      Colors
+                    </h3>
+                    <div className="flex flex-wrap gap-2">
+                      {confettiColors.map((color, idx) => (
+                        <div key={idx} className="relative group">
+                          <input
+                            type="color"
+                            value={color}
+                            onChange={e => {
+                              const newColors = [...confettiColors];
+                              newColors[idx] = e.target.value;
+                              setConfettiColors(newColors);
+                            }}
+                            className="w-8 h-8 rounded cursor-pointer border-2"
+                            style={{ borderColor: theme.colors.border }}
+                          />
+                          {confettiColors.length > 1 && (
+                            <button
+                              onClick={() => setConfettiColors(confettiColors.filter((_, i) => i !== idx))}
+                              className="absolute -top-1 -right-1 w-4 h-4 rounded-full text-xs bg-red-500 text-white opacity-0 group-hover:opacity-100 transition-opacity"
+                            >
+                              ×
+                            </button>
+                          )}
+                        </div>
+                      ))}
+                      {confettiColors.length < 12 && (
+                        <button
+                          onClick={() => setConfettiColors([...confettiColors, '#FFFFFF'])}
+                          className="w-8 h-8 rounded border-2 border-dashed flex items-center justify-center text-lg"
+                          style={{ borderColor: theme.colors.border, color: theme.colors.textDim }}
+                        >
+                          +
+                        </button>
+                      )}
+                    </div>
+                  </div>
+
+                  {/* Action Buttons */}
+                  <button
+                    onClick={firePlaygroundConfetti}
+                    disabled={selectedOrigins.size === 0}
+                    className="w-full flex items-center justify-center gap-2 px-4 py-3 rounded-lg font-bold text-lg transition-all hover:scale-[1.02] disabled:opacity-50 disabled:cursor-not-allowed"
+                    style={{
+                      backgroundColor: theme.colors.accent,
+                      color: '#fff',
+                    }}
+                  >
+                    <Sparkles className="w-5 h-5" />
+                    Fire Confetti!
+                  </button>
+
+                  <button
+                    onClick={copyConfettiSettings}
+                    className="w-full flex items-center justify-center gap-2 px-4 py-2 rounded font-medium transition-colors"
+                    style={{
+                      backgroundColor: copySuccess ? theme.colors.success : theme.colors.bgMain,
+                      color: copySuccess ? '#fff' : theme.colors.textMain,
+                      border: `1px solid ${copySuccess ? theme.colors.success : theme.colors.border}`,
+                    }}
+                  >
+                    {copySuccess ? (
+                      <>
+                        <Check className="w-4 h-4" />
+                        Copied!
+                      </>
+                    ) : (
+                      <>
+                        <Copy className="w-4 h-4" />
+                        Copy Settings
+                      </>
+                    )}
+                  </button>
+
+                  <button
+                    onClick={resetConfettiSettings}
+                    className="w-full flex items-center justify-center gap-2 px-4 py-2 rounded font-medium transition-colors border"
+                    style={{
+                      borderColor: theme.colors.border,
+                      color: theme.colors.textDim,
+                    }}
+                  >
+                    <RotateCcw className="w-4 h-4" />
+                    Reset to Defaults
+                  </button>
+                </div>
+              </div>
+            )}
           </div>
         </div>
       </div>
diff --git a/src/renderer/components/ProcessMonitor.tsx b/src/renderer/components/ProcessMonitor.tsx
index fab85298f..380653d8a 100644
--- a/src/renderer/components/ProcessMonitor.tsx
+++ b/src/renderer/components/ProcessMonitor.tsx
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useRef, useCallback } from 'react';
-import { ChevronRight, ChevronDown, ChevronUp, X, Activity, RefreshCw } from 'lucide-react';
+import { ChevronRight, ChevronDown, ChevronUp, X, Activity, RefreshCw, XCircle } from 'lucide-react';
 import type { Session, Group, Theme } from '../types';
 import { useLayerStack } from '../contexts/LayerStackContext';
 import { MODAL_PRIORITIES } from '../constants/modalPriorities';
@@ -27,6 +27,7 @@ interface ProcessNode {
   label: string;
   emoji?: string;
   sessionId?: string;
+  processSessionId?: string; // The full process session ID for killing processes (e.g., "abc123-ai-tab1")
   pid?: number;
   processType?: 'ai' | 'terminal' | 'batch' | 'synopsis';
   isAlive?: boolean;
@@ -44,13 +45,21 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
   const [selectedNodeId, setSelectedNodeId] = useState<string | null>(null);
   const [activeProcesses, setActiveProcesses] = useState<ActiveProcess[]>([]);
   const [isLoading, setIsLoading] = useState(true);
+  const [isRefreshing, setIsRefreshing] = useState(false);
+  const [hasExpandedInitially, setHasExpandedInitially] = useState(false);
+  const [killConfirmProcessId, setKillConfirmProcessId] = useState<string | null>(null);
+  const [isKilling, setIsKilling] = useState(false);
   const containerRef = useRef<HTMLDivElement>(null);
   const selectedNodeRef = useRef<HTMLButtonElement | HTMLDivElement>(null);
+  const killConfirmRef = useRef<HTMLDivElement>(null);
   const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
   const layerIdRef = useRef<string>();
 
   // Fetch active processes from ProcessManager
-  const fetchActiveProcesses = useCallback(async () => {
+  const fetchActiveProcesses = useCallback(async (showRefresh = false) => {
+    if (showRefresh) {
+      setIsRefreshing(true);
+    }
     try {
       const processes = await window.maestro.process.getActiveProcesses();
       setActiveProcesses(processes);
@@ -58,13 +67,38 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
       console.error('Failed to fetch active processes:', error);
     } finally {
       setIsLoading(false);
+      // Keep refresh spinner visible for at least 500ms for visual feedback
+      if (showRefresh) {
+        setTimeout(() => setIsRefreshing(false), 500);
+      }
     }
   }, []);
 
+  // Kill a process by its session ID
+  const killProcess = useCallback(async (processSessionId: string) => {
+    setIsKilling(true);
+    try {
+      await window.maestro.process.kill(processSessionId);
+      // Refresh the process list after killing
+      await fetchActiveProcesses(true);
+    } catch (error) {
+      console.error('Failed to kill process:', error);
+    } finally {
+      setIsKilling(false);
+      setKillConfirmProcessId(null);
+    }
+  }, [fetchActiveProcesses]);
+
+  // Focus kill confirmation dialog when it opens
+  useEffect(() => {
+    if (killConfirmProcessId && killConfirmRef.current) {
+      killConfirmRef.current.focus();
+    }
+  }, [killConfirmProcessId]);
+
   // Register layer on mount
   useEffect(() => {
     const layerId = registerLayer({
-      id: 'process-monitor',
       type: 'modal',
       priority: MODAL_PRIORITIES.PROCESS_MONITOR,
       blocksLowerLayers: true,
@@ -271,6 +305,7 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
           pid: proc.pid,
           processType,
           sessionId: session.id,
+          processSessionId: proc.sessionId, // Full process session ID for killing
           isAlive: true, // Active processes are always alive
           toolType: proc.toolType,
           cwd: proc.cwd,
@@ -326,6 +361,18 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
     return tree;
   };
 
+  // Expand all nodes by default on initial load
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(() => {
+    if (!isLoading && !hasExpandedInitially) {
+      // Build tree and get all expandable node IDs
+      const tree = buildProcessTree();
+      const allIds = getAllExpandableNodeIds(tree);
+      setExpandedNodes(new Set(allIds));
+      setHasExpandedInitially(true);
+    }
+  }, [isLoading, hasExpandedInitially, activeProcesses]);
+
   // Build flat list of visible nodes for keyboard navigation
   const getVisibleNodes = (nodes: ProcessNode[]): ProcessNode[] => {
     const result: ProcessNode[] = [];
@@ -434,7 +481,7 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
       case 'r':
       case 'R':
         e.preventDefault();
-        fetchActiveProcesses();
+        fetchActiveProcesses(true);
         break;
     }
   };
@@ -540,7 +587,7 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
           ref={isSelected ? selectedNodeRef as React.RefObject<HTMLDivElement> : null}
           key={node.id}
           tabIndex={0}
-          className="px-4 py-2 flex items-center gap-2 cursor-default"
+          className="px-4 py-2 flex items-center gap-2 cursor-default group"
           style={{
             paddingLeft: `${paddingLeft}px`,
             color: theme.colors.textMain,
@@ -589,6 +636,22 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
           >
             Running
           </span>
+          {/* Kill button */}
+          {node.processSessionId && (
+            <button
+              className="p-1 rounded opacity-0 group-hover:opacity-100 hover:bg-opacity-20 transition-opacity"
+              style={{ color: theme.colors.error }}
+              onClick={(e) => {
+                e.stopPropagation();
+                setKillConfirmProcessId(node.processSessionId!);
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = `${theme.colors.error}20`}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              title="Kill process"
+            >
+              <XCircle className="w-4 h-4" />
+            </button>
+          )}
         </div>
       );
     }
@@ -636,14 +699,14 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
           </div>
           <div className="flex items-center gap-1">
             <button
-              onClick={() => fetchActiveProcesses()}
+              onClick={() => fetchActiveProcesses(true)}
               className="p-1.5 rounded hover:bg-opacity-10 flex items-center gap-1"
               style={{ color: theme.colors.textDim }}
               onMouseEnter={(e) => e.currentTarget.style.backgroundColor = `${theme.colors.accent}20`}
               onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
               title="Refresh (R)"
             >
-              <RefreshCw className={`w-4 h-4 ${isLoading ? 'animate-spin' : ''}`} />
+              <RefreshCw className={`w-4 h-4 ${isRefreshing ? 'animate-spin' : ''}`} />
             </button>
             <button
               onClick={expandAll}
@@ -726,6 +789,65 @@ export function ProcessMonitor(props: ProcessMonitorProps) {
           </div>
         </div>
       </div>
+
+      {/* Kill confirmation modal */}
+      {killConfirmProcessId && (
+        <div
+          className="fixed inset-0 flex items-center justify-center z-[10000]"
+          style={{ backgroundColor: 'rgba(0,0,0,0.5)' }}
+          onClick={() => setKillConfirmProcessId(null)}
+        >
+          <div
+            ref={killConfirmRef}
+            className="p-4 rounded-lg shadow-xl max-w-md mx-4 outline-none"
+            style={{ backgroundColor: theme.colors.bgMain }}
+            onClick={(e) => e.stopPropagation()}
+            tabIndex={-1}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' && !isKilling) {
+                e.preventDefault();
+                killProcess(killConfirmProcessId);
+              } else if (e.key === 'Escape') {
+                e.preventDefault();
+                setKillConfirmProcessId(null);
+              }
+            }}
+          >
+            <h3 className="text-lg font-semibold mb-2" style={{ color: theme.colors.textMain }}>
+              Kill Process?
+            </h3>
+            <p className="text-sm mb-4" style={{ color: theme.colors.textDim }}>
+              This will forcefully terminate the process. Any unsaved work may be lost.
+            </p>
+            <div className="flex gap-2 justify-end">
+              <button
+                onClick={() => setKillConfirmProcessId(null)}
+                className="px-3 py-1.5 rounded text-sm"
+                style={{ backgroundColor: theme.colors.bgActivity, color: theme.colors.textMain }}
+                disabled={isKilling}
+              >
+                Cancel
+              </button>
+              <button
+                onClick={() => killProcess(killConfirmProcessId)}
+                className="px-3 py-1.5 rounded text-sm flex items-center gap-2"
+                style={{ backgroundColor: theme.colors.error, color: 'white' }}
+                disabled={isKilling}
+                autoFocus
+              >
+                {isKilling ? (
+                  <>
+                    <RefreshCw className="w-3 h-3 animate-spin" />
+                    Killing...
+                  </>
+                ) : (
+                  'Kill Process'
+                )}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </div>
   );
 }
diff --git a/src/renderer/components/PromptComposerModal.tsx b/src/renderer/components/PromptComposerModal.tsx
index a587c2d99..703101856 100644
--- a/src/renderer/components/PromptComposerModal.tsx
+++ b/src/renderer/components/PromptComposerModal.tsx
@@ -10,15 +10,23 @@ interface PromptComposerModalProps {
   theme: Theme;
   initialValue: string;
   onSubmit: (value: string) => void;
+  onSend: (value: string) => void;
   sessionName?: string;
 }
 
+// Simple token estimation (roughly 4 chars per token for English text)
+function estimateTokenCount(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
+
 export function PromptComposerModal({
   isOpen,
   onClose,
   theme,
   initialValue,
   onSubmit,
+  onSend,
   sessionName = 'Claude'
 }: PromptComposerModalProps) {
   const [value, setValue] = useState(initialValue);
@@ -28,6 +36,8 @@ export function PromptComposerModal({
   onCloseRef.current = onClose;
   const onSubmitRef = useRef(onSubmit);
   onSubmitRef.current = onSubmit;
+  const onSendRef = useRef(onSend);
+  onSendRef.current = onSend;
   const valueRef = useRef(value);
   valueRef.current = value;
 
@@ -66,19 +76,22 @@ export function PromptComposerModal({
 
   if (!isOpen) return null;
 
-  const handleSubmit = () => {
-    onSubmit(value);
+  const handleSend = () => {
+    if (!value.trim()) return;
+    onSend(value);
     onClose();
   };
 
   const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-    // Cmd/Ctrl + Enter to submit and close
+    // Cmd/Ctrl + Enter to send the message
     if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
       e.preventDefault();
-      handleSubmit();
+      handleSend();
     }
   };
 
+  const tokenCount = estimateTokenCount(value);
+
   return (
     <div
       className="fixed inset-0 z-50 flex items-center justify-center"
@@ -111,9 +124,9 @@ export function PromptComposerModal({
               — {sessionName}
             </span>
           </div>
-          <div className="flex items-center gap-2">
+          <div className="flex items-center gap-3">
             <span className="text-xs opacity-50" style={{ color: theme.colors.textDim }}>
-              ⌘+Enter to send
+              <span style={{ fontFamily: 'system-ui' }}>⌘</span> + Enter to send
             </span>
             <button
               onClick={() => {
@@ -146,12 +159,14 @@ export function PromptComposerModal({
           className="flex items-center justify-between px-4 py-3 border-t"
           style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgSidebar }}
         >
-          <div className="text-xs" style={{ color: theme.colors.textDim }}>
-            {value.length} characters
+          <div className="text-xs flex items-center gap-3" style={{ color: theme.colors.textDim }}>
+            <span>{value.length} characters</span>
+            <span>~{tokenCount.toLocaleString()} tokens</span>
           </div>
           <button
-            onClick={handleSubmit}
-            className="flex items-center gap-2 px-4 py-2 rounded-lg font-medium transition-all hover:opacity-90"
+            onClick={handleSend}
+            disabled={!value.trim()}
+            className="flex items-center gap-2 px-4 py-2 rounded-lg font-medium transition-all hover:opacity-90 disabled:opacity-50 disabled:cursor-not-allowed"
             style={{
               backgroundColor: theme.colors.accent,
               color: theme.colors.accentForeground,
diff --git a/src/renderer/components/QuickActionsModal.tsx b/src/renderer/components/QuickActionsModal.tsx
index 22e9c120a..d00eab3de 100644
--- a/src/renderer/components/QuickActionsModal.tsx
+++ b/src/renderer/components/QuickActionsModal.tsx
@@ -58,6 +58,9 @@ interface QuickActionsModalProps {
   isAiMode?: boolean;
   setPlaygroundOpen?: (open: boolean) => void;
   onRefreshGitFileState?: () => Promise<void>;
+  onDebugReleaseQueuedItem?: () => void;
+  markdownRawMode?: boolean;
+  onToggleMarkdownRawMode?: () => void;
 }
 
 export function QuickActionsModal(props: QuickActionsModalProps) {
@@ -71,7 +74,8 @@ export function QuickActionsModal(props: QuickActionsModalProps) {
     deleteSession, addNewSession, setSettingsModalOpen, setSettingsTab,
     setShortcutsHelpOpen, setAboutModalOpen, setLogViewerOpen, setProcessMonitorOpen,
     setAgentSessionsOpen, setActiveClaudeSessionId, setGitDiffPreview, setGitLogOpen, startFreshSession,
-    onRenameTab, onToggleReadOnlyMode, onOpenTabSwitcher, tabShortcuts, isAiMode, setPlaygroundOpen, onRefreshGitFileState
+    onRenameTab, onToggleReadOnlyMode, onOpenTabSwitcher, tabShortcuts, isAiMode, setPlaygroundOpen, onRefreshGitFileState,
+    onDebugReleaseQueuedItem, markdownRawMode, onToggleMarkdownRawMode
   } = props;
 
   const [search, setSearch] = useState('');
@@ -216,6 +220,7 @@ export function QuickActionsModal(props: QuickActionsModalProps) {
     ...(isAiMode && onOpenTabSwitcher ? [{ id: 'tabSwitcher', label: 'Tab Switcher', shortcut: tabShortcuts?.tabSwitcher, action: () => { onOpenTabSwitcher(); setQuickActionOpen(false); } }] : []),
     ...(isAiMode && onRenameTab ? [{ id: 'renameTab', label: 'Rename Tab', shortcut: tabShortcuts?.renameTab, action: () => { onRenameTab(); setQuickActionOpen(false); } }] : []),
     ...(isAiMode && onToggleReadOnlyMode ? [{ id: 'toggleReadOnly', label: 'Toggle Read-Only Mode', shortcut: tabShortcuts?.toggleReadOnlyMode, action: () => { onToggleReadOnlyMode(); setQuickActionOpen(false); } }] : []),
+    ...(isAiMode && onToggleMarkdownRawMode ? [{ id: 'toggleMarkdown', label: markdownRawMode ? 'Show Formatted Markdown' : 'Show Raw Markdown', shortcut: shortcuts.toggleMarkdownMode, subtext: markdownRawMode ? 'Currently showing plain text' : 'Currently showing formatted', action: () => { onToggleMarkdownRawMode(); setQuickActionOpen(false); } }] : []),
     ...(activeSession ? [{ id: 'kill', label: `Remove Agent: ${activeSession.name}`, shortcut: shortcuts.killInstance, action: () => deleteSession(activeSessionId) }] : []),
     { id: 'settings', label: 'Settings', shortcut: shortcuts.settings, action: () => { setSettingsModalOpen(true); setQuickActionOpen(false); } },
     { id: 'theme', label: 'Change Theme', action: () => { setSettingsModalOpen(true); setSettingsTab('theme'); setQuickActionOpen(false); } },
@@ -248,7 +253,7 @@ export function QuickActionsModal(props: QuickActionsModalProps) {
     { id: 'about', label: 'About Maestro', action: () => { setAboutModalOpen(true); setQuickActionOpen(false); } },
     { id: 'goToFiles', label: 'Go to Files Tab', action: () => { setRightPanelOpen(true); setActiveRightTab('files'); setQuickActionOpen(false); } },
     { id: 'goToHistory', label: 'Go to History Tab', action: () => { setRightPanelOpen(true); setActiveRightTab('history'); setQuickActionOpen(false); } },
-    { id: 'goToScratchpad', label: 'Go to Scratchpad Tab', action: () => { setRightPanelOpen(true); setActiveRightTab('scratchpad'); setQuickActionOpen(false); } },
+    { id: 'goToAutoRun', label: 'Go to Auto Run Tab', action: () => { setRightPanelOpen(true); setActiveRightTab('autorun'); setQuickActionOpen(false); } },
     // Debug commands - only visible when user types "debug"
     { id: 'debugResetBusy', label: 'Debug: Reset Busy State', subtext: 'Clear stuck thinking/busy state for all sessions', action: () => {
       // Reset all sessions and tabs to idle state
@@ -303,6 +308,15 @@ export function QuickActionsModal(props: QuickActionsModalProps) {
       setPlaygroundOpen(true);
       setQuickActionOpen(false);
     } }] : []),
+    ...(activeSession && activeSession.executionQueue?.length > 0 && onDebugReleaseQueuedItem ? [{
+      id: 'debugReleaseQueued',
+      label: 'Debug: Release Next Queued Item',
+      subtext: `Process next item from queue (${activeSession.executionQueue.length} queued)`,
+      action: () => {
+        onDebugReleaseQueuedItem();
+        setQuickActionOpen(false);
+      }
+    }] : []),
   ];
 
   const groupActions: QuickAction[] = [
diff --git a/src/renderer/components/RightPanel.tsx b/src/renderer/components/RightPanel.tsx
index 53c87db0d..2478183a7 100644
--- a/src/renderer/components/RightPanel.tsx
+++ b/src/renderer/components/RightPanel.tsx
@@ -1,9 +1,10 @@
 import React, { useRef, useEffect, useImperativeHandle, forwardRef } from 'react';
 import { PanelRightClose, PanelRightOpen, Loader2 } from 'lucide-react';
 import type { Session, Theme, RightPanelTab, Shortcut, BatchRunState } from '../types';
+import type { FileTreeChanges } from '../utils/fileExplorer';
 import { FileExplorerPanel } from './FileExplorerPanel';
 import { HistoryPanel, HistoryPanelHandle } from './HistoryPanel';
-import { Scratchpad } from './Scratchpad';
+import { AutoRun } from './AutoRun';
 import { formatShortcutKeys } from '../utils/shortcutFormatter';
 
 export interface RightPanelHandle {
@@ -48,17 +49,27 @@ interface RightPanelProps {
   expandAllFolders: (activeSessionId: string, activeSession: Session, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => void;
   collapseAllFolders: (activeSessionId: string, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => void;
   updateSessionWorkingDirectory: (activeSessionId: string, setSessions: React.Dispatch<React.SetStateAction<Session[]>>) => Promise<void>;
-  refreshFileTree: (sessionId: string) => Promise<void>;
+  refreshFileTree: (sessionId: string) => Promise<FileTreeChanges | undefined>;
   setSessions: React.Dispatch<React.SetStateAction<Session[]>>;
+  onAutoRefreshChange?: (interval: number) => void;
 
-  // Scratchpad handlers
-  updateScratchPad: (content: string) => void;
-  updateScratchPadState: (state: {
+  // Auto Run handlers
+  autoRunDocumentList: string[];        // List of document filenames (without .md)
+  autoRunDocumentTree?: Array<{ name: string; type: 'file' | 'folder'; path: string; children?: unknown[] }>;  // Tree structure for subfolders
+  autoRunContent: string;               // Content of currently selected document
+  autoRunIsLoadingDocuments: boolean;   // Loading state
+  onAutoRunContentChange: (content: string) => void;
+  onAutoRunModeChange: (mode: 'edit' | 'preview') => void;
+  onAutoRunStateChange: (state: {
     mode: 'edit' | 'preview';
     cursorPosition: number;
     editScrollPos: number;
     previewScrollPos: number;
   }) => void;
+  onAutoRunSelectDocument: (filename: string) => void;
+  onAutoRunCreateDocument: (filename: string) => Promise<boolean>;
+  onAutoRunRefresh: () => void;
+  onAutoRunOpenSetup: () => void;
 
   // Batch processing props
   batchRunState?: BatchRunState;
@@ -76,7 +87,10 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
     fileTreeFilter, setFileTreeFilter, fileTreeFilterOpen, setFileTreeFilterOpen,
     filteredFileTree, selectedFileIndex, setSelectedFileIndex, previewFile, fileTreeContainerRef,
     fileTreeFilterInputRef, toggleFolder, handleFileClick, expandAllFolders, collapseAllFolders,
-    updateSessionWorkingDirectory, refreshFileTree, setSessions, updateScratchPad, updateScratchPadState,
+    updateSessionWorkingDirectory, refreshFileTree, setSessions, onAutoRefreshChange,
+    autoRunDocumentList, autoRunDocumentTree, autoRunContent, autoRunIsLoadingDocuments,
+    onAutoRunContentChange, onAutoRunModeChange, onAutoRunStateChange,
+    onAutoRunSelectDocument, onAutoRunCreateDocument, onAutoRunRefresh, onAutoRunOpenSetup,
     batchRunState, onOpenBatchRunner, onStopBatchRun, onJumpToClaudeSession, onResumeSession,
     onOpenSessionAsTab
   } = props;
@@ -153,17 +167,17 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
           {rightPanelOpen ? <PanelRightClose className="w-4 h-4 opacity-50" /> : <PanelRightOpen className="w-4 h-4 opacity-50" />}
         </button>
 
-        {['files', 'history', 'scratchpad'].map(tab => (
+        {['files', 'history', 'autorun'].map(tab => (
           <button
             key={tab}
             onClick={() => setActiveRightTab(tab as RightPanelTab)}
-            className="flex-1 text-xs font-bold border-b-2 capitalize transition-colors"
+            className="flex-1 text-xs font-bold border-b-2 transition-colors"
             style={{
               borderColor: activeRightTab === tab ? theme.colors.accent : 'transparent',
               color: activeRightTab === tab ? theme.colors.textMain : theme.colors.textDim
             }}
           >
-            {tab}
+            {tab === 'autorun' ? 'Auto Run' : tab.charAt(0).toUpperCase() + tab.slice(1)}
           </button>
         ))}
       </div>
@@ -175,7 +189,7 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
         tabIndex={-1}
         onClick={() => {
           setActiveFocus('right');
-          // Only focus the container for file explorer, not for scratchpad (which has its own focus management)
+          // Only focus the container for file explorer, not for autorun (which has its own focus management)
           if (activeRightTab === 'files') {
             fileTreeContainerRef.current?.focus();
           }
@@ -214,6 +228,7 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
             updateSessionWorkingDirectory={updateSessionWorkingDirectory}
             refreshFileTree={refreshFileTree}
             setSessions={setSessions}
+            onAutoRefreshChange={onAutoRefreshChange}
           />
         )}
 
@@ -228,17 +243,27 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
           />
         )}
 
-        {activeRightTab === 'scratchpad' && (
-          <Scratchpad
-            content={session.scratchPadContent}
-            onChange={updateScratchPad}
+        {activeRightTab === 'autorun' && (
+          <AutoRun
             theme={theme}
             sessionId={session.id}
-            initialMode={session.scratchPadMode || 'edit'}
-            initialCursorPosition={session.scratchPadCursorPosition || 0}
-            initialEditScrollPos={session.scratchPadEditScrollPos || 0}
-            initialPreviewScrollPos={session.scratchPadPreviewScrollPos || 0}
-            onStateChange={updateScratchPadState}
+            folderPath={session.autoRunFolderPath || null}
+            selectedFile={session.autoRunSelectedFile || null}
+            documentList={autoRunDocumentList}
+            documentTree={autoRunDocumentTree}
+            content={autoRunContent}
+            onContentChange={onAutoRunContentChange}
+            mode={session.autoRunMode || 'edit'}
+            onModeChange={onAutoRunModeChange}
+            initialCursorPosition={session.autoRunCursorPosition || 0}
+            initialEditScrollPos={session.autoRunEditScrollPos || 0}
+            initialPreviewScrollPos={session.autoRunPreviewScrollPos || 0}
+            onStateChange={onAutoRunStateChange}
+            onOpenSetup={onAutoRunOpenSetup}
+            onRefresh={onAutoRunRefresh}
+            onSelectDocument={onAutoRunSelectDocument}
+            onCreateDocument={onAutoRunCreateDocument}
+            isLoadingDocuments={autoRunIsLoadingDocuments}
             batchRunState={batchRunState}
             onOpenBatchRunner={onOpenBatchRunner}
             onStopBatchRun={onStopBatchRun}
@@ -256,18 +281,57 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
             borderColor: theme.colors.warning
           }}
         >
+          {/* Header with status and overall progress */}
           <div className="flex items-center justify-between mb-2">
             <div className="flex items-center gap-2">
               <Loader2 className="w-4 h-4 animate-spin" style={{ color: theme.colors.warning }} />
               <span className="text-xs font-bold uppercase" style={{ color: theme.colors.textMain }}>
                 {batchRunState.isStopping ? 'Stopping...' : 'Auto Mode Running'}
               </span>
+              {/* Loop iteration indicator */}
+              {batchRunState.loopEnabled && batchRunState.loopIteration > 0 && (
+                <span
+                  className="text-[10px] px-1.5 py-0.5 rounded"
+                  style={{ backgroundColor: theme.colors.accent + '30', color: theme.colors.accent }}
+                >
+                  Loop {batchRunState.loopIteration + 1}
+                </span>
+              )}
             </div>
-            <span className="text-xs font-mono" style={{ color: theme.colors.textDim }}>
-              {batchRunState.completedTasks} / {batchRunState.totalTasks} tasks
-            </span>
           </div>
-          {/* Progress bar */}
+
+          {/* Document progress with inline progress bar - only for multi-document runs */}
+          {batchRunState.documents && batchRunState.documents.length > 1 && (
+            <div className="mb-2">
+              {/* Document name with progress bar */}
+              <div className="flex items-center gap-2">
+                <span
+                  className="text-xs font-medium shrink-0"
+                  style={{ color: theme.colors.textMain }}
+                >
+                  Document {batchRunState.currentDocumentIndex + 1}/{batchRunState.documents.length}: {batchRunState.documents[batchRunState.currentDocumentIndex]}
+                </span>
+                <div
+                  className="flex-1 h-1 rounded-full overflow-hidden"
+                  style={{ backgroundColor: theme.colors.border }}
+                >
+                  <div
+                    className="h-full transition-all duration-300 ease-out"
+                    style={{
+                      width: `${
+                        batchRunState.currentDocTasksTotal > 0
+                          ? (batchRunState.currentDocTasksCompleted / batchRunState.currentDocTasksTotal) * 100
+                          : 0
+                      }%`,
+                      backgroundColor: theme.colors.accent
+                    }}
+                  />
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Overall progress bar */}
           <div
             className="h-1.5 rounded-full overflow-hidden"
             style={{ backgroundColor: theme.colors.border }}
@@ -275,15 +339,37 @@ export const RightPanel = forwardRef<RightPanelHandle, RightPanelProps>(function
             <div
               className="h-full transition-all duration-500 ease-out"
               style={{
-                width: `${batchRunState.totalTasks > 0 ? (batchRunState.completedTasks / batchRunState.totalTasks) * 100 : 0}%`,
+                width: `${
+                  batchRunState.totalTasksAcrossAllDocs > 0
+                    ? (batchRunState.completedTasksAcrossAllDocs / batchRunState.totalTasksAcrossAllDocs) * 100
+                    : batchRunState.totalTasks > 0
+                      ? (batchRunState.completedTasks / batchRunState.totalTasks) * 100
+                      : 0
+                }%`,
                 backgroundColor: batchRunState.isStopping ? theme.colors.error : theme.colors.warning
               }}
             />
           </div>
-          <div className="mt-2 text-[10px]" style={{ color: theme.colors.textDim }}>
-            {batchRunState.isStopping
-              ? 'Waiting for current task to complete before stopping...'
-              : `Task ${batchRunState.currentTaskIndex + 1} in progress...`}
+
+          {/* Overall completed count with loop info */}
+          <div className="mt-2 flex items-center justify-between">
+            <span className="text-[10px]" style={{ color: theme.colors.textDim }}>
+              {batchRunState.isStopping
+                ? 'Waiting for current task to complete before stopping...'
+                : batchRunState.totalTasksAcrossAllDocs > 0
+                  ? `${batchRunState.completedTasksAcrossAllDocs} / ${batchRunState.totalTasksAcrossAllDocs} total tasks completed`
+                  : `${batchRunState.completedTasks} / ${batchRunState.totalTasks} tasks completed`
+              }
+            </span>
+            {/* Loop iteration indicator */}
+            {batchRunState.loopEnabled && (
+              <span
+                className="text-[10px] px-1.5 py-0.5 rounded"
+                style={{ backgroundColor: theme.colors.accent + '20', color: theme.colors.accent }}
+              >
+                Loop {batchRunState.loopIteration + 1} of {batchRunState.maxLoops ?? '∞'}
+              </span>
+            )}
           </div>
         </div>
       )}
diff --git a/src/renderer/components/SessionList.tsx b/src/renderer/components/SessionList.tsx
index 77232ef84..2529785c3 100644
--- a/src/renderer/components/SessionList.tsx
+++ b/src/renderer/components/SessionList.tsx
@@ -611,7 +611,7 @@ export function SessionList(props: SessionListProps) {
   return (
     <div
       tabIndex={0}
-      className={`border-r flex flex-col shrink-0 transition-all duration-300 outline-none relative ${activeFocus === 'sidebar' ? 'ring-1 ring-inset z-10' : ''}`}
+      className={`border-r flex flex-col shrink-0 transition-all duration-300 outline-none relative z-20 ${activeFocus === 'sidebar' ? 'ring-1 ring-inset' : ''}`}
       style={{
         width: leftSidebarOpen ? `${leftSidebarWidthState}px` : '64px',
         backgroundColor: theme.colors.bgSidebar,
diff --git a/src/renderer/components/SettingsModal.tsx b/src/renderer/components/SettingsModal.tsx
index 665c3a575..0bd33e2cf 100644
--- a/src/renderer/components/SettingsModal.tsx
+++ b/src/renderer/components/SettingsModal.tsx
@@ -1273,6 +1273,9 @@ export function SettingsModal(props: SettingsModalProps) {
                     {shortcutsFilter ? `${filteredCount} / ${totalShortcuts}` : totalShortcuts}
                   </span>
                 </div>
+                <p className="text-xs opacity-50 mb-3" style={{ color: theme.colors.textDim }}>
+                  Not all shortcuts can be modified. Press <kbd className="px-1.5 py-0.5 rounded font-mono" style={{ backgroundColor: theme.colors.bgActivity }}>⌘/</kbd> to view the full list of keyboard shortcuts.
+                </p>
                 <div className="space-y-2 flex-1 overflow-y-auto pr-2 scrollbar-thin">
                   {filteredShortcuts.map((sc: Shortcut) => (
                     <div key={sc.id} className="flex items-center justify-between p-3 rounded border" style={{ borderColor: theme.colors.border, backgroundColor: theme.colors.bgMain }}>
diff --git a/src/renderer/components/StandingOvationOverlay.tsx b/src/renderer/components/StandingOvationOverlay.tsx
index fb5007c80..c06fd0937 100644
--- a/src/renderer/components/StandingOvationOverlay.tsx
+++ b/src/renderer/components/StandingOvationOverlay.tsx
@@ -52,110 +52,64 @@ export function StandingOvationOverlay({
   const goldColor = '#FFD700';
   const purpleAccent = theme.colors.accent;
 
-  // Confetti colors - celebratory mix
-  const confettiColors = [
-    goldColor, purpleAccent,
-    '#FF6B6B', '#FF8E53', '#FFA726', // Warm colors
-    '#4ECDC4', '#45B7D1', '#64B5F6', // Cool colors
-    '#FFEAA7', '#FFD54F', // Yellows
-    '#DDA0DD', '#BA68C8', // Purples
+  // Confetti colors from playground
+  const confettiColors = React.useMemo(() => [
+    '#FFD700', // Gold
+    '#FF6B6B', // Red
+    '#4ECDC4', // Teal
+    '#45B7D1', // Blue
+    '#FFA726', // Orange
+    '#BA68C8', // Purple
     '#F48FB1', // Pink
-  ];
+    '#FFEAA7', // Yellow
+  ], []);
 
   // Z-index layering: backdrop (99997) < confetti (99998) < modal (99999)
   const CONFETTI_Z_INDEX = 99998;
 
-  // Fire realistic confetti - cannon-style bursts from off-screen bottom corners
+  // Fire confetti from multiple origins with playground settings
   const fireConfetti = useCallback(() => {
     const defaults = {
-      zIndex: CONFETTI_Z_INDEX,
+      particleCount: 500,
+      angle: 90,
+      spread: 91,
+      startVelocity: 74,
+      gravity: 0.8,
+      decay: 0.9,
+      drift: 1.5,
+      scalar: 1.2,
+      ticks: 355,
+      flat: false,
+      shapes: ['circle', 'star', 'square'] as const,
       colors: confettiColors,
+      zIndex: CONFETTI_Z_INDEX,
       disableForReducedMotion: true,
     };
 
-    // Left cannon burst - origin off-screen left/bottom
+    // Center burst
     confetti({
       ...defaults,
-      particleCount: 144,
-      angle: 55,
-      spread: 55,
-      origin: { x: -0.05, y: 1.1 },
-      startVelocity: 70,
-      gravity: 1,
-      scalar: 1.2,
-      ticks: 200,
+      origin: { x: 0.5, y: 1 },
     });
 
-    // Right cannon burst - origin off-screen right/bottom
+    // Left burst
     confetti({
       ...defaults,
-      particleCount: 144,
-      angle: 125,
-      spread: 55,
-      origin: { x: 1.05, y: 1.1 },
-      startVelocity: 70,
-      gravity: 1,
-      scalar: 1.2,
-      ticks: 200,
+      origin: { x: 0, y: 1 },
     });
 
-    // Delayed second wave - slightly smaller
-    setTimeout(() => {
-      confetti({
-        ...defaults,
-        particleCount: 86,
-        angle: 55,
-        spread: 45,
-        origin: { x: -0.05, y: 1.15 },
-        startVelocity: 62,
-        gravity: 1.1,
-        scalar: 1.0,
-        ticks: 180,
-      });
-      confetti({
-        ...defaults,
-        particleCount: 86,
-        angle: 125,
-        spread: 45,
-        origin: { x: 1.05, y: 1.15 },
-        startVelocity: 62,
-        gravity: 1.1,
-        scalar: 1.0,
-        ticks: 180,
-      });
-    }, 250);
-
-    // Third wave - gentle finish
-    setTimeout(() => {
-      confetti({
-        ...defaults,
-        particleCount: 58,
-        angle: 60,
-        spread: 60,
-        origin: { x: -0.02, y: 1.1 },
-        startVelocity: 55,
-        gravity: 1.2,
-        scalar: 0.9,
-        ticks: 160,
-      });
-      confetti({
-        ...defaults,
-        particleCount: 58,
-        angle: 120,
-        spread: 60,
-        origin: { x: 1.02, y: 1.1 },
-        startVelocity: 55,
-        gravity: 1.2,
-        scalar: 0.9,
-        ticks: 160,
-      });
-    }, 500);
+    // Right burst
+    confetti({
+      ...defaults,
+      origin: { x: 1, y: 1 },
+    });
   }, [confettiColors]);
 
-  // Fire confetti on mount - immediately!
+  // Fire confetti on mount only - empty deps to run once
   useEffect(() => {
     fireConfetti();
-  }, [fireConfetti]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   // Handle graceful close with confetti
   const handleTakeABow = useCallback(() => {
diff --git a/src/renderer/components/TabBar.tsx b/src/renderer/components/TabBar.tsx
index 6ca32f549..810feeb21 100644
--- a/src/renderer/components/TabBar.tsx
+++ b/src/renderer/components/TabBar.tsx
@@ -1,6 +1,6 @@
 import React, { useState, useRef, useCallback, useEffect } from 'react';
 import { createPortal } from 'react-dom';
-import { X, Plus, Star, Copy, Edit2, Mail } from 'lucide-react';
+import { X, Plus, Star, Copy, Edit2, Mail, Pencil } from 'lucide-react';
 import type { AITab, Theme } from '../types';
 
 interface TabBarProps {
@@ -38,6 +38,7 @@ interface TabProps {
   onStar?: (starred: boolean) => void;
   shortcutHint?: number | null;
   registerRef?: (el: HTMLDivElement | null) => void;
+  hasDraft?: boolean;
 }
 
 /**
@@ -78,7 +79,8 @@ function Tab({
   onRename,
   onStar,
   shortcutHint,
-  registerRef
+  registerRef,
+  hasDraft
 }: TabProps) {
   const [isHovered, setIsHovered] = useState(false);
   const [overlayOpen, setOverlayOpen] = useState(false);
@@ -169,6 +171,7 @@ function Tab({
   return (
     <div
       ref={setTabRef}
+      data-tab-id={tab.id}
       className={`
         relative flex items-center gap-1.5 px-3 py-1.5 cursor-pointer
         transition-all duration-150 select-none
@@ -233,6 +236,15 @@ function Tab({
         />
       )}
 
+      {/* Draft indicator - pencil icon for tabs with unsent input or staged images */}
+      {hasDraft && (
+        <Pencil
+          className="w-3 h-3 shrink-0"
+          style={{ color: theme.colors.warning }}
+          title="Has draft message"
+        />
+      )}
+
       {/* Shortcut hint badge - shows tab number for Cmd+1-9 navigation */}
       {shortcutHint !== null && shortcutHint !== undefined && (
         <span
@@ -499,17 +511,18 @@ export function TabBar({
   const tabRefs = useRef<Map<string, HTMLDivElement>>(new Map());
   const [isOverflowing, setIsOverflowing] = useState(false);
 
-  // Scroll active tab into view when it changes or when tabs are added/removed
-  // Use a small delay to ensure the DOM element is rendered and ref is registered
+  // Center the active tab in the scrollable area when activeTabId changes
   useEffect(() => {
-    const timeoutId = setTimeout(() => {
-      const activeTabElement = tabRefs.current.get(activeTabId);
-      if (activeTabElement) {
-        activeTabElement.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'nearest' });
+    requestAnimationFrame(() => {
+      const container = tabBarRef.current;
+      const tabElement = container?.querySelector(`[data-tab-id="${activeTabId}"]`) as HTMLElement | null;
+      if (container && tabElement) {
+        // Calculate scroll position to center the tab
+        const scrollLeft = tabElement.offsetLeft - (container.clientWidth / 2) + (tabElement.offsetWidth / 2);
+        container.scrollTo({ left: scrollLeft, behavior: 'smooth' });
       }
-    }, 0);
-    return () => clearTimeout(timeoutId);
-  }, [activeTabId, tabs.length]);
+    });
+  }, [activeTabId]);
 
   // Can always close tabs - closing the last one creates a fresh new tab
   const canClose = true;
@@ -610,7 +623,7 @@ export function TabBar({
     >
       {/* Unread filter toggle - sticky at the beginning with full-height opaque background */}
       <div
-        className="sticky left-0 flex items-center shrink-0 pl-2 pr-2 self-stretch group"
+        className="sticky left-0 flex items-center shrink-0 pl-2 pr-2 self-stretch"
         style={{ backgroundColor: theme.colors.bgSidebar, zIndex: 5 }}
       >
         <button
@@ -620,6 +633,7 @@ export function TabBar({
             color: showUnreadOnly ? theme.colors.accent : theme.colors.textDim,
             opacity: showUnreadOnly ? 1 : 0.5
           }}
+          title={showUnreadOnly ? 'Showing unread only (Cmd+U)' : 'Filter unread tabs (Cmd+U)'}
         >
           <Mail className="w-4 h-4" />
           {/* Notification dot */}
@@ -628,18 +642,6 @@ export function TabBar({
             style={{ backgroundColor: theme.colors.accent }}
           />
         </button>
-        {/* Hover overlay */}
-        <div
-          className="absolute left-2 top-full mt-1 px-2 py-1 rounded text-xs whitespace-nowrap opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none"
-          style={{
-            backgroundColor: theme.colors.bgSidebar,
-            border: `1px solid ${theme.colors.border}`,
-            color: theme.colors.textMain,
-            zIndex: 6
-          }}
-        >
-          {showUnreadOnly ? 'Showing unread only' : 'Filter unread tabs'}
-        </div>
       </div>
 
       {/* Empty state when filter is on but no unread tabs */}
@@ -689,6 +691,7 @@ export function TabBar({
               onRename={() => handleRenameRequest(tab.id)}
               onStar={onTabStar ? (starred) => onTabStar(tab.id, starred) : undefined}
               shortcutHint={!showUnreadOnly && originalIndex < 9 ? originalIndex + 1 : null}
+              hasDraft={hasDraft(tab)}
               registerRef={(el) => {
                 if (el) {
                   tabRefs.current.set(tab.id, el);
diff --git a/src/renderer/components/TabSwitcherModal.tsx b/src/renderer/components/TabSwitcherModal.tsx
index 96a25143e..6d997bfb7 100644
--- a/src/renderer/components/TabSwitcherModal.tsx
+++ b/src/renderer/components/TabSwitcherModal.tsx
@@ -12,6 +12,7 @@ interface NamedSession {
   projectPath: string;
   sessionName: string;
   starred?: boolean;
+  lastActivityAt?: number;
 }
 
 /** Union type for items in the list */
@@ -23,10 +24,10 @@ interface TabSwitcherModalProps {
   theme: Theme;
   tabs: AITab[];
   activeTabId: string;
-  cwd: string; // Current working directory for syncing tab names
+  projectRoot: string; // The initial project directory (used for Claude session storage)
   shortcut?: Shortcut;
   onTabSelect: (tabId: string) => void;
-  onNamedSessionSelect: (claudeSessionId: string, projectPath: string, sessionName: string) => void;
+  onNamedSessionSelect: (claudeSessionId: string, projectPath: string, sessionName: string, starred?: boolean) => void;
   onClose: () => void;
 }
 
@@ -49,6 +50,32 @@ function formatCost(cost: number): string {
   return '$' + cost.toFixed(2);
 }
 
+/**
+ * Format a timestamp as relative time (e.g., "5m ago", "2h ago", "Dec 3")
+ */
+function formatRelativeTime(timestamp: number): string {
+  const now = Date.now();
+  const diffMs = now - timestamp;
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMins < 1) return 'Now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return new Date(timestamp).toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
+
+/**
+ * Get the last activity timestamp from a tab's logs
+ */
+function getTabLastActivity(tab: AITab): number | undefined {
+  if (!tab.logs || tab.logs.length === 0) return undefined;
+  // Get the most recent log entry timestamp
+  return Math.max(...tab.logs.map(log => log.timestamp));
+}
+
 /**
  * Get context usage percentage from usage stats
  * Uses inputTokens + outputTokens (not cache tokens) to match MainPanel calculation
@@ -141,7 +168,7 @@ export function TabSwitcherModal({
   theme,
   tabs,
   activeTabId,
-  cwd,
+  projectRoot,
   shortcut,
   onTabSelect,
   onNamedSessionSelect,
@@ -157,6 +184,12 @@ export function TabSwitcherModal({
   const selectedItemRef = useRef<HTMLButtonElement>(null);
   const scrollContainerRef = useRef<HTMLDivElement>(null);
   const layerIdRef = useRef<string>();
+  const onCloseRef = useRef(onClose);
+
+  // Keep onClose ref up to date
+  useEffect(() => {
+    onCloseRef.current = onClose;
+  });
 
   const { registerLayer, unregisterLayer, updateLayerHandler } = useLayerStack();
 
@@ -169,7 +202,7 @@ export function TabSwitcherModal({
       capturesFocus: true,
       focusTrap: 'strict',
       ariaLabel: 'Tab Switcher',
-      onEscape: () => onClose()
+      onEscape: () => onCloseRef.current()
     });
 
     return () => {
@@ -177,16 +210,16 @@ export function TabSwitcherModal({
         unregisterLayer(layerIdRef.current);
       }
     };
-  }, [registerLayer, unregisterLayer, onClose]);
+  }, [registerLayer, unregisterLayer]);
 
   // Update handler when onClose changes
   useEffect(() => {
     if (layerIdRef.current) {
       updateLayerHandler(layerIdRef.current, () => {
-        onClose();
+        onCloseRef.current();
       });
     }
-  }, [onClose, updateLayerHandler]);
+  }, [updateLayerHandler]);
 
   // Focus input on mount
   useEffect(() => {
@@ -202,7 +235,7 @@ export function TabSwitcherModal({
       const namedTabs = tabs.filter(t => t.name && t.claudeSessionId);
       await Promise.all(
         namedTabs.map(tab =>
-          window.maestro.claude.updateSessionName(cwd, tab.claudeSessionId!, tab.name!)
+          window.maestro.claude.updateSessionName(projectRoot, tab.claudeSessionId!, tab.name!)
             .catch(err => console.warn('[TabSwitcher] Failed to sync tab name:', err))
         )
       );
@@ -215,7 +248,7 @@ export function TabSwitcherModal({
     if (!namedSessionsLoaded) {
       syncAndLoad();
     }
-  }, [namedSessionsLoaded, tabs, cwd]);
+  }, [namedSessionsLoaded, tabs, projectRoot]);
 
   // Scroll selected item into view
   useEffect(() => {
@@ -248,7 +281,7 @@ export function TabSwitcherModal({
       });
       return sorted.map(tab => ({ type: 'open' as const, tab }));
     } else {
-      // All Named mode - show ALL named sessions (including open ones)
+      // All Named mode - show named sessions for the CURRENT PROJECT only (including open ones)
       // For open tabs, use the 'open' type so we get usage stats; for closed ones use 'named'
       const items: ListItem[] = [];
 
@@ -259,9 +292,9 @@ export function TabSwitcherModal({
         }
       }
 
-      // Add closed named sessions (not currently open)
+      // Add closed named sessions from the SAME PROJECT (not currently open)
       for (const session of namedSessions) {
-        if (!openTabSessionIds.has(session.claudeSessionId)) {
+        if (session.projectPath === projectRoot && !openTabSessionIds.has(session.claudeSessionId)) {
           items.push({ type: 'named' as const, session });
         }
       }
@@ -275,7 +308,7 @@ export function TabSwitcherModal({
 
       return items;
     }
-  }, [viewMode, tabs, namedSessions, openTabSessionIds]);
+  }, [viewMode, tabs, namedSessions, openTabSessionIds, projectRoot]);
 
   // Filter items based on search query
   const filteredItems = useMemo(() => {
@@ -325,7 +358,7 @@ export function TabSwitcherModal({
     if (item.type === 'open') {
       onTabSelect(item.tab.id);
     } else {
-      onNamedSessionSelect(item.session.claudeSessionId, item.session.projectPath, item.session.sessionName);
+      onNamedSessionSelect(item.session.claudeSessionId, item.session.projectPath, item.session.sessionName, item.session.starred);
     }
     onClose();
   };
@@ -512,6 +545,10 @@ export function TabSwitcherModal({
                           <span>{formatCost(cost)}</span>
                         </>
                       )}
+                      {(() => {
+                        const lastActivity = getTabLastActivity(tab);
+                        return lastActivity ? <span>{formatRelativeTime(lastActivity)}</span> : null;
+                      })()}
                     </div>
                   </div>
 
@@ -572,7 +609,9 @@ export function TabSwitcherModal({
                       )}
                     </div>
                     <div className="flex items-center gap-3 text-[10px] opacity-60">
-                      <span className="truncate">{session.projectPath.split('/').slice(-2).join('/')}</span>
+                      {session.lastActivityAt && (
+                        <span>{formatRelativeTime(session.lastActivityAt)}</span>
+                      )}
                     </div>
                   </div>
 
diff --git a/src/renderer/components/TerminalOutput.tsx b/src/renderer/components/TerminalOutput.tsx
index 0a5050dc7..59e95497a 100644
--- a/src/renderer/components/TerminalOutput.tsx
+++ b/src/renderer/components/TerminalOutput.tsx
@@ -577,38 +577,8 @@ const LogItemComponent = memo(({
                 <div className="overflow-x-auto scrollbar-thin" dangerouslySetInnerHTML={{ __html: displayHtmlContent }} />
               ) : isAIMode && !markdownRawMode ? (
                 // Collapsed markdown preview with rendered markdown
-                <div className="prose prose-sm max-w-none" style={{ color: theme.colors.textMain, lineHeight: 1.5 }}>
-                  <style>{`
-                    .prose { line-height: 1.4; }
-                    .prose > *:first-child { margin-top: 0; }
-                    .prose > *:last-child { margin-bottom: 0; }
-                    .prose h1 { color: ${theme.colors.accent}; font-size: 2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h2 { color: ${theme.colors.success}; font-size: 1.75em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h3 { color: ${theme.colors.warning}; font-size: 1.5em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h4 { color: ${theme.colors.textMain}; font-size: 1.35em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h5 { color: ${theme.colors.textMain}; font-size: 1.2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h6 { color: ${theme.colors.textDim}; font-size: 1.1em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose p { color: ${theme.colors.textMain}; margin: 0; line-height: 1.4; }
-                    .prose p:empty { display: none; }
-                    .prose > ul, .prose > ol { color: ${theme.colors.textMain}; margin: 0.5em 0; padding-left: 2em; }
-                    .prose li ul, .prose li ol { margin: 0 !important; padding-left: 1.5em; }
-                    .prose li { margin: 0 !important; padding: 0; line-height: 1.4; display: list-item; }
-                    .prose li > p:first-child { margin: 0 !important; display: contents !important; }
-                    .prose li > p:first-child + ul, .prose li > p:first-child + ol { display: block; margin-top: 0 !important; }
-                    .prose li > p + ul, .prose li > p + ol { margin-top: 0 !important; }
-                    .prose li:has(> input[type="checkbox"]) { list-style: none; margin-left: -1.5em; }
-                    .prose code { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.15em 0.3em; border-radius: 3px; font-size: 0.9em; }
-                    .prose pre { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.5em; border-radius: 6px; overflow-x: auto; margin: 0.5em 0; }
-                    .prose pre code { background: none; padding: 0; }
-                    .prose blockquote { border-left: 3px solid ${theme.colors.border}; padding-left: 0.75em; margin: 0; color: ${theme.colors.textDim}; }
-                    .prose a { color: ${theme.colors.accent}; text-decoration: underline; }
-                    .prose hr { border: none; border-top: 1px solid ${theme.colors.border}; margin: 0.75em 0; }
-                    .prose table { border-collapse: collapse; width: 100%; margin: 0.5em 0; }
-                    .prose th, .prose td { border: 1px solid ${theme.colors.border}; padding: 0.25em 0.5em; text-align: left; }
-                    .prose th { background-color: ${theme.colors.bgSidebar}; font-weight: bold; }
-                    .prose strong { font-weight: bold; }
-                    .prose em { font-style: italic; }
-                  `}</style>
+                // Note: prose styles are injected once at TerminalOutput container level for performance
+                <div className="prose prose-sm max-w-none" style={{ color: theme.colors.textMain, lineHeight: 1.4, paddingLeft: '0.5em' }}>
                   <ReactMarkdown
                     remarkPlugins={[remarkGfm]}
                     components={{
@@ -732,38 +702,8 @@ const LogItemComponent = memo(({
                 </div>
               ) : isAIMode && !markdownRawMode ? (
                 // Expanded markdown rendering
-                <div className="prose prose-sm max-w-none text-sm" style={{ color: theme.colors.textMain, lineHeight: 1.5 }}>
-                  <style>{`
-                    .prose { line-height: 1.4; }
-                    .prose > *:first-child { margin-top: 0; }
-                    .prose > *:last-child { margin-bottom: 0; }
-                    .prose h1 { color: ${theme.colors.accent}; font-size: 2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h2 { color: ${theme.colors.success}; font-size: 1.75em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h3 { color: ${theme.colors.warning}; font-size: 1.5em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h4 { color: ${theme.colors.textMain}; font-size: 1.35em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h5 { color: ${theme.colors.textMain}; font-size: 1.2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose h6 { color: ${theme.colors.textDim}; font-size: 1.1em; font-weight: bold; margin: 0; line-height: 1.4; }
-                    .prose p { color: ${theme.colors.textMain}; margin: 0; line-height: 1.4; }
-                    .prose p:empty { display: none; }
-                    .prose > ul, .prose > ol { color: ${theme.colors.textMain}; margin: 0.5em 0; padding-left: 2em; }
-                    .prose li ul, .prose li ol { margin: 0 !important; padding-left: 1.5em; }
-                    .prose li { margin: 0 !important; padding: 0; line-height: 1.4; display: list-item; }
-                    .prose li > p:first-child { margin: 0 !important; display: contents !important; }
-                    .prose li > p:first-child + ul, .prose li > p:first-child + ol { display: block; margin-top: 0 !important; }
-                    .prose li > p + ul, .prose li > p + ol { margin-top: 0 !important; }
-                    .prose li:has(> input[type="checkbox"]) { list-style: none; margin-left: -1.5em; }
-                    .prose code { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.15em 0.3em; border-radius: 3px; font-size: 0.9em; }
-                    .prose pre { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.5em; border-radius: 6px; overflow-x: auto; margin: 0.5em 0; }
-                    .prose pre code { background: none; padding: 0; }
-                    .prose blockquote { border-left: 3px solid ${theme.colors.border}; padding-left: 0.75em; margin: 0; color: ${theme.colors.textDim}; }
-                    .prose a { color: ${theme.colors.accent}; text-decoration: underline; }
-                    .prose hr { border: none; border-top: 1px solid ${theme.colors.border}; margin: 0.75em 0; }
-                    .prose table { border-collapse: collapse; width: 100%; margin: 0.5em 0; }
-                    .prose th, .prose td { border: 1px solid ${theme.colors.border}; padding: 0.25em 0.5em; text-align: left; }
-                    .prose th { background-color: ${theme.colors.bgSidebar}; font-weight: bold; }
-                    .prose strong { font-weight: bold; }
-                    .prose em { font-style: italic; }
-                  `}</style>
+                // Note: prose styles are injected once at TerminalOutput container level for performance
+                <div className="prose prose-sm max-w-none text-sm" style={{ color: theme.colors.textMain, lineHeight: 1.4, paddingLeft: '0.5em' }}>
                   <ReactMarkdown
                     remarkPlugins={[remarkGfm]}
                     components={{
@@ -869,38 +809,8 @@ const LogItemComponent = memo(({
               </div>
             ) : isAIMode && !markdownRawMode ? (
               // Rendered markdown for AI responses
-              <div className="prose prose-sm max-w-none text-sm" style={{ color: theme.colors.textMain, lineHeight: 1.4 }}>
-                <style>{`
-                  .prose { line-height: 1.4; }
-                  .prose > *:first-child { margin-top: 0; }
-                  .prose > *:last-child { margin-bottom: 0; }
-                  .prose h1 { color: ${theme.colors.accent}; font-size: 2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose h2 { color: ${theme.colors.success}; font-size: 1.75em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose h3 { color: ${theme.colors.warning}; font-size: 1.5em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose h4 { color: ${theme.colors.textMain}; font-size: 1.35em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose h5 { color: ${theme.colors.textMain}; font-size: 1.2em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose h6 { color: ${theme.colors.textDim}; font-size: 1.1em; font-weight: bold; margin: 0; line-height: 1.4; }
-                  .prose p { color: ${theme.colors.textMain}; margin: 0; line-height: 1.4; }
-                  .prose p:empty { display: none; }
-                  .prose > ul, .prose > ol { color: ${theme.colors.textMain}; margin: 0.5em 0; padding-left: 2em; }
-                  .prose li ul, .prose li ol { margin: 0 !important; padding-left: 1.5em; }
-                  .prose li { margin: 0 !important; padding: 0; line-height: 1.4; display: list-item; }
-                  .prose li > p:first-child { margin: 0 !important; display: contents !important; }
-                  .prose li > p:first-child + ul, .prose li > p:first-child + ol { display: block; margin-top: 0 !important; }
-                  .prose li > p + ul, .prose li > p + ol { margin-top: 0 !important; }
-                  .prose li:has(> input[type="checkbox"]) { list-style: none; margin-left: -1.5em; }
-                  .prose code { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.15em 0.3em; border-radius: 3px; font-size: 0.9em; }
-                  .prose pre { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.5em; border-radius: 6px; overflow-x: auto; margin: 0.5em 0; }
-                  .prose pre code { background: none; padding: 0; }
-                  .prose blockquote { border-left: 3px solid ${theme.colors.border}; padding-left: 0.75em; margin: 0; color: ${theme.colors.textDim}; }
-                  .prose a { color: ${theme.colors.accent}; text-decoration: underline; }
-                  .prose hr { border: none; border-top: 1px solid ${theme.colors.border}; margin: 0.75em 0; }
-                  .prose table { border-collapse: collapse; width: 100%; margin: 0.5em 0; }
-                  .prose th, .prose td { border: 1px solid ${theme.colors.border}; padding: 0.25em 0.5em; text-align: left; }
-                  .prose th { background-color: ${theme.colors.bgSidebar}; font-weight: bold; }
-                  .prose strong { font-weight: bold; }
-                  .prose em { font-style: italic; }
-                `}</style>
+              // Note: prose styles are injected once at TerminalOutput container level for performance
+              <div className="prose prose-sm max-w-none text-sm" style={{ color: theme.colors.textMain, lineHeight: 1.4, paddingLeft: '0.5em' }}>
                 <ReactMarkdown
                   remarkPlugins={[remarkGfm]}
                   components={{
@@ -1568,6 +1478,22 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
     lastLogCountRef.current = currentCount;
   }, [filteredLogs.length, isAtBottom, activeTabId]);
 
+  // Auto-scroll to bottom in terminal mode when new output arrives
+  // Terminal mode should always auto-scroll since users expect to see command output immediately
+  useEffect(() => {
+    if (session.inputMode === 'terminal' && scrollContainerRef.current) {
+      // Use requestAnimationFrame to ensure DOM has updated with new content
+      requestAnimationFrame(() => {
+        if (scrollContainerRef.current) {
+          scrollContainerRef.current.scrollTo({
+            top: scrollContainerRef.current.scrollHeight,
+            behavior: 'smooth'
+          });
+        }
+      });
+    }
+  }, [session.inputMode, session.shellLogs.length]);
+
   // Restore scroll position when component mounts or initialScrollTop changes
   // Uses requestAnimationFrame to ensure DOM is ready
   useEffect(() => {
@@ -1626,6 +1552,40 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
   const isTerminal = session.inputMode === 'terminal';
   const isAIMode = session.inputMode === 'ai';
 
+  // Memoized prose styles - applied once at container level instead of per-log-item
+  const proseStyles = useMemo(() => `
+    .prose { line-height: 1.4; overflow: visible; }
+    .prose > *:first-child { margin-top: 0 !important; }
+    .prose > *:last-child { margin-bottom: 0 !important; }
+    .prose * { margin-top: 0; margin-bottom: 0; }
+    .prose h1 { color: ${theme.colors.accent}; font-size: 2em; font-weight: bold; margin: 0.25em 0 !important; line-height: 1.4; }
+    .prose h2 { color: ${theme.colors.success}; font-size: 1.75em; font-weight: bold; margin: 0.25em 0 !important; line-height: 1.4; }
+    .prose h3 { color: ${theme.colors.warning}; font-size: 1.5em; font-weight: bold; margin: 0.25em 0 !important; line-height: 1.4; }
+    .prose h4 { color: ${theme.colors.textMain}; font-size: 1.35em; font-weight: bold; margin: 0.2em 0 !important; line-height: 1.4; }
+    .prose h5 { color: ${theme.colors.textMain}; font-size: 1.2em; font-weight: bold; margin: 0.2em 0 !important; line-height: 1.4; }
+    .prose h6 { color: ${theme.colors.textDim}; font-size: 1.1em; font-weight: bold; margin: 0.2em 0 !important; line-height: 1.4; }
+    .prose p { color: ${theme.colors.textMain}; margin: 0 !important; line-height: 1.4; }
+    .prose p + p { margin-top: 0.5em !important; }
+    .prose p:empty { display: none; }
+    .prose > ul, .prose > ol { color: ${theme.colors.textMain}; margin: 0.25em 0 !important; padding-left: 2em; list-style-position: outside; }
+    .prose li ul, .prose li ol { margin: 0 !important; padding-left: 1.5em; list-style-position: outside; }
+    .prose li { margin: 0 !important; padding: 0; line-height: 1.4; display: list-item; }
+    .prose li > p { margin: 0 !important; display: contents !important; }
+    .prose li > p + ul, .prose li > p + ol { margin-top: 0 !important; }
+    .prose li:has(> input[type="checkbox"]) { list-style: none; margin-left: -1.5em; }
+    .prose code { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.15em 0.3em; border-radius: 3px; font-size: 0.9em; }
+    .prose pre { background-color: ${theme.colors.bgSidebar}; color: ${theme.colors.textMain}; padding: 0.5em; border-radius: 6px; overflow-x: auto; margin: 0.35em 0 !important; }
+    .prose pre code { background: none; padding: 0; }
+    .prose blockquote { border-left: 3px solid ${theme.colors.border}; padding-left: 0.75em; margin: 0.25em 0 !important; color: ${theme.colors.textDim}; }
+    .prose a { color: ${theme.colors.accent}; text-decoration: underline; }
+    .prose hr { border: none; border-top: 1px solid ${theme.colors.border}; margin: 0.5em 0 !important; }
+    .prose table { border-collapse: collapse; width: 100%; margin: 0.35em 0 !important; }
+    .prose th, .prose td { border: 1px solid ${theme.colors.border}; padding: 0.25em 0.5em; text-align: left; }
+    .prose th { background-color: ${theme.colors.bgSidebar}; font-weight: bold; }
+    .prose strong { font-weight: bold; }
+    .prose em { font-style: italic; }
+  `, [theme.colors]);
+
   return (
     <div
       ref={terminalOutputRef}
@@ -1706,6 +1666,8 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
           />
         </div>
       )}
+      {/* Prose styles for markdown rendering - injected once at container level for performance */}
+      <style>{proseStyles}</style>
       {/* Native scroll log list */}
       <div
         ref={scrollContainerRef}
@@ -1905,11 +1867,25 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
           className="fixed inset-0 flex items-center justify-center z-50"
           style={{ backgroundColor: 'rgba(0,0,0,0.5)' }}
           onClick={() => setQueueRemoveConfirmId(null)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter') {
+              e.preventDefault();
+              if (onRemoveQueuedItem) {
+                onRemoveQueuedItem(queueRemoveConfirmId);
+              }
+              setQueueRemoveConfirmId(null);
+            } else if (e.key === 'Escape') {
+              e.preventDefault();
+              setQueueRemoveConfirmId(null);
+            }
+          }}
         >
           <div
             className="p-4 rounded-lg shadow-xl max-w-md mx-4"
             style={{ backgroundColor: theme.colors.bgMain }}
             onClick={(e) => e.stopPropagation()}
+            tabIndex={-1}
+            ref={(el) => el?.focus()}
           >
             <h3 className="text-lg font-semibold mb-2" style={{ color: theme.colors.textMain }}>
               Remove Queued Message?
@@ -1934,6 +1910,7 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
                 }}
                 className="px-3 py-1.5 rounded text-sm"
                 style={{ backgroundColor: theme.colors.error, color: 'white' }}
+                autoFocus
               >
                 Remove
               </button>
@@ -1942,8 +1919,8 @@ export const TerminalOutput = forwardRef<HTMLDivElement, TerminalOutputProps>((p
         </div>
       )}
 
-      {/* New Message Indicator - floating arrow button */}
-      {hasNewMessages && !isAtBottom && (
+      {/* New Message Indicator - floating arrow button (AI mode only, terminal auto-scrolls) */}
+      {hasNewMessages && !isAtBottom && session.inputMode === 'ai' && (
         <button
           onClick={scrollToBottom}
           className="absolute bottom-4 right-6 flex items-center gap-2 px-3 py-2 rounded-full shadow-lg transition-all hover:scale-105 z-20"
diff --git a/src/renderer/components/ThinkingStatusPill.tsx b/src/renderer/components/ThinkingStatusPill.tsx
index ddce69cc8..f4ba625ad 100644
--- a/src/renderer/components/ThinkingStatusPill.tsx
+++ b/src/renderer/components/ThinkingStatusPill.tsx
@@ -23,6 +23,8 @@ interface ThinkingStatusPillProps {
   activeSessionId?: string;
   // Callback to stop auto-run (shows stop button in AutoRunPill when provided)
   onStopAutoRun?: () => void;
+  // Callback to interrupt the current AI session
+  onInterrupt?: () => void;
 }
 
 // ElapsedTimeDisplay - shows time since thinking started
@@ -268,7 +270,7 @@ AutoRunPill.displayName = 'AutoRunPill';
  *
  * When AutoRun is active for the active session, shows AutoRunPill instead.
  */
-function ThinkingStatusPillInner({ sessions, theme, onSessionClick, namedSessions, autoRunState, activeSessionId, onStopAutoRun }: ThinkingStatusPillProps) {
+function ThinkingStatusPillInner({ sessions, theme, onSessionClick, namedSessions, autoRunState, activeSessionId, onStopAutoRun, onInterrupt }: ThinkingStatusPillProps) {
   const [isExpanded, setIsExpanded] = useState(false);
 
   // If AutoRun is active for the current session, show the AutoRun pill instead
@@ -468,6 +470,31 @@ function ThinkingStatusPillInner({ sessions, theme, onSessionClick, namedSession
             )}
           </div>
         )}
+
+        {/* Stop/Interrupt button */}
+        {onInterrupt && (
+          <>
+            <div
+              className="w-px h-4 shrink-0"
+              style={{ backgroundColor: theme.colors.border }}
+            />
+            <button
+              type="button"
+              onClick={onInterrupt}
+              className="flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium transition-colors hover:opacity-80"
+              style={{
+                backgroundColor: theme.colors.error,
+                color: 'white'
+              }}
+              title="Interrupt Claude (Ctrl+C)"
+            >
+              <svg className="w-3 h-3" viewBox="0 0 24 24" fill="currentColor">
+                <rect x="6" y="6" width="12" height="12" rx="1" />
+              </svg>
+              Stop
+            </button>
+          </>
+        )}
       </div>
       {/* End Thinking Pill */}
     </div>
@@ -543,6 +570,10 @@ export const ThinkingStatusPill = memo(ThinkingStatusPillInner, (prevProps, next
     }
   }
 
+  // Note: We intentionally don't compare onInterrupt/onStopAutoRun callbacks
+  // because they may change reference on parent re-renders but are semantically
+  // the same. The component will use the latest callback from props anyway.
+
   return prevProps.theme === nextProps.theme;
 });
 
diff --git a/src/renderer/constants/conductorBadges.ts b/src/renderer/constants/conductorBadges.ts
index 79e1079bb..96e6ea35e 100644
--- a/src/renderer/constants/conductorBadges.ts
+++ b/src/renderer/constants/conductorBadges.ts
@@ -155,7 +155,7 @@ export const CONDUCTOR_BADGES: ConductorBadge[] = [
     name: 'World Maestro',
     shortName: 'World',
     description: 'Conducts top orchestras globally. Commands rarefied fees and has a distinctive interpretive "voice" recognized worldwide.',
-    requiredTimeMs: 1 * 365 * DAY, // 1 year
+    requiredTimeMs: 365 * DAY, // 1 year
     exampleConductor: {
       name: 'Kirill Petrenko',
       era: 'Current',
@@ -267,7 +267,7 @@ export function formatTimeRemaining(cumulativeTimeMs: number, nextBadge: Conduct
   const hours = Math.floor((remaining % DAY) / HOUR);
   const minutes = Math.floor((remaining % HOUR) / MINUTE);
 
-  if (days > 365) {
+  if (days >= 365) {
     const years = Math.floor(days / 365);
     const remainingDays = days % 365;
     return `${years}y ${remainingDays}d remaining`;
@@ -295,7 +295,7 @@ export function formatCumulativeTime(timeMs: number): string {
   const minutes = Math.floor((timeMs % HOUR) / MINUTE);
   const seconds = Math.floor((timeMs % MINUTE) / 1000);
 
-  if (days > 365) {
+  if (days >= 365) {
     const years = Math.floor(days / 365);
     const remainingDays = days % 365;
     return `${years}y ${remainingDays}d`;
diff --git a/src/renderer/constants/modalPriorities.ts b/src/renderer/constants/modalPriorities.ts
index 2b6a2b9b4..42ef66664 100644
--- a/src/renderer/constants/modalPriorities.ts
+++ b/src/renderer/constants/modalPriorities.ts
@@ -20,6 +20,12 @@ export const MODAL_PRIORITIES = {
   /** Confirmation dialogs - highest priority, always on top */
   CONFIRM: 1000,
 
+  /** Playbook delete confirmation - high priority, appears on top of BatchRunner */
+  PLAYBOOK_DELETE_CONFIRM: 950,
+
+  /** Playbook name input modal - appears on top of BatchRunner */
+  PLAYBOOK_NAME: 940,
+
   /** Rename instance modal */
   RENAME_INSTANCE: 900,
 
@@ -44,6 +50,12 @@ export const MODAL_PRIORITIES = {
   /** Prompt composer modal for long prompts */
   PROMPT_COMPOSER: 725,
 
+  /** Agent prompt composer modal (opens from batch runner) */
+  AGENT_PROMPT_COMPOSER: 730,
+
+  /** Auto Run setup/folder selection modal */
+  AUTORUN_SETUP: 710,
+
   /** Quick actions command palette (Cmd+K) */
   QUICK_ACTION: 700,
 
diff --git a/src/renderer/constants/shortcuts.ts b/src/renderer/constants/shortcuts.ts
index 1173fa3f7..0662b544a 100644
--- a/src/renderer/constants/shortcuts.ts
+++ b/src/renderer/constants/shortcuts.ts
@@ -16,7 +16,7 @@ export const DEFAULT_SHORTCUTS: Record<string, Shortcut> = {
   settings: { id: 'settings', label: 'Open Settings', keys: ['Meta', ','] },
   goToFiles: { id: 'goToFiles', label: 'Go to Files Tab', keys: ['Meta', 'Shift', 'f'] },
   goToHistory: { id: 'goToHistory', label: 'Go to History Tab', keys: ['Meta', 'Shift', 'h'] },
-  goToScratchpad: { id: 'goToScratchpad', label: 'Go to Scratchpad Tab', keys: ['Meta', 'Shift', 's'] },
+  goToAutoRun: { id: 'goToAutoRun', label: 'Go to Auto Run Tab', keys: ['Meta', 'Shift', '1'] },
   copyFilePath: { id: 'copyFilePath', label: 'Copy File Path (in Preview)', keys: ['Meta', 'p'] },
   toggleMarkdownMode: { id: 'toggleMarkdownMode', label: 'Toggle Markdown Raw/Preview', keys: ['Meta', 'e'] },
   focusInput: { id: 'focusInput', label: 'Focus Input Field', keys: ['Meta', '.'] },
@@ -57,5 +57,6 @@ export const TAB_SHORTCUTS: Record<string, Shortcut> = {
   goToTab6: { id: 'goToTab6', label: 'Go to Tab 6', keys: ['Meta', '6'] },
   goToTab7: { id: 'goToTab7', label: 'Go to Tab 7', keys: ['Meta', '7'] },
   goToTab8: { id: 'goToTab8', label: 'Go to Tab 8', keys: ['Meta', '8'] },
-  goToLastTab: { id: 'goToLastTab', label: 'Go to Last Tab', keys: ['Meta', '9'] },
+  goToTab9: { id: 'goToTab9', label: 'Go to Tab 9', keys: ['Meta', '9'] },
+  goToLastTab: { id: 'goToLastTab', label: 'Go to Last Tab', keys: ['Meta', '0'] },
 };
diff --git a/src/renderer/global.d.ts b/src/renderer/global.d.ts
index b62f53f31..d6cfb1aec 100644
--- a/src/renderer/global.d.ts
+++ b/src/renderer/global.d.ts
@@ -137,6 +137,44 @@ interface MaestroAPI {
       error: string | null;
     }>;
     show: (cwd: string, hash: string) => Promise<{ stdout: string; stderr: string }>;
+    showFile: (cwd: string, ref: string, filePath: string) => Promise<{ content?: string; error?: string }>;
+    // Git worktree operations for Auto Run parallelization
+    worktreeInfo: (worktreePath: string) => Promise<{
+      success: boolean;
+      exists?: boolean;
+      isWorktree?: boolean;
+      currentBranch?: string;
+      repoRoot?: string;
+      error?: string;
+    }>;
+    getRepoRoot: (cwd: string) => Promise<{
+      success: boolean;
+      root?: string;
+      error?: string;
+    }>;
+    worktreeSetup: (mainRepoCwd: string, worktreePath: string, branchName: string) => Promise<{
+      success: boolean;
+      created?: boolean;
+      currentBranch?: string;
+      requestedBranch?: string;
+      branchMismatch?: boolean;
+      error?: string;
+    }>;
+    worktreeCheckout: (worktreePath: string, branchName: string, createIfMissing: boolean) => Promise<{
+      success: boolean;
+      hasUncommittedChanges: boolean;
+      error?: string;
+    }>;
+    createPR: (worktreePath: string, baseBranch: string, title: string, body: string) => Promise<{
+      success: boolean;
+      prUrl?: string;
+      error?: string;
+    }>;
+    getDefaultBranch: (cwd: string) => Promise<{
+      success: boolean;
+      branch?: string;
+      error?: string;
+    }>;
   };
   fs: {
     readDir: (dirPath: string) => Promise<DirectoryEntry[]>;
@@ -270,6 +308,7 @@ interface MaestroAPI {
       projectPath: string;
       sessionName: string;
       starred?: boolean;
+      lastActivityAt?: number;
     }>>;
     deleteMessagePair: (projectPath: string, sessionId: string, userMessageUuid: string, fallbackContent?: string) => Promise<{ success: boolean; linesRemoved?: number; error?: string }>;
   };
@@ -317,6 +356,55 @@ interface MaestroAPI {
     list: (sessionId: string) => Promise<{ success: boolean; files: string[]; error?: string }>;
     getPath: (sessionId: string) => Promise<{ success: boolean; path: string }>;
   };
+  // Auto Run file operations
+  autorun: {
+    listDocs: (folderPath: string) => Promise<{
+      success: boolean;
+      files: string[];
+      tree?: Array<{
+        name: string;
+        type: 'file' | 'folder';
+        path: string;
+        children?: Array<{
+          name: string;
+          type: 'file' | 'folder';
+          path: string;
+          children?: unknown[];  // Recursive type
+        }>;
+      }>;
+      error?: string;
+    }>;
+    readDoc: (folderPath: string, filename: string) => Promise<{ success: boolean; content?: string; error?: string }>;
+    writeDoc: (folderPath: string, filename: string, content: string) => Promise<{ success: boolean; error?: string }>;
+    saveImage: (folderPath: string, docName: string, base64Data: string, extension: string) => Promise<{ success: boolean; relativePath?: string; error?: string }>;
+    deleteImage: (folderPath: string, relativePath: string) => Promise<{ success: boolean; error?: string }>;
+    listImages: (folderPath: string, docName: string) => Promise<{ success: boolean; images?: Array<{ filename: string; relativePath: string }>; error?: string }>;
+  };
+  // Playbooks API (saved batch run configurations)
+  playbooks: {
+    list: (sessionId: string) => Promise<{ success: boolean; playbooks: Array<{
+      id: string;
+      name: string;
+      createdAt: number;
+      updatedAt: number;
+      documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+      loopEnabled: boolean;
+      prompt: string;
+    }>; error?: string }>;
+    create: (sessionId: string, playbook: {
+      name: string;
+      documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+      loopEnabled: boolean;
+      prompt: string;
+    }) => Promise<{ success: boolean; playbook?: any; error?: string }>;
+    update: (sessionId: string, playbookId: string, updates: Partial<{
+      name: string;
+      documents: Array<{ filename: string; resetOnCompletion: boolean }>;
+      loopEnabled: boolean;
+      prompt: string;
+    }>) => Promise<{ success: boolean; playbook?: any; error?: string }>;
+    delete: (sessionId: string, playbookId: string) => Promise<{ success: boolean; error?: string }>;
+  };
 }
 
 declare global {
diff --git a/src/renderer/hooks/useBatchProcessor.ts b/src/renderer/hooks/useBatchProcessor.ts
index a402dadc1..0e14c3c0a 100644
--- a/src/renderer/hooks/useBatchProcessor.ts
+++ b/src/renderer/hooks/useBatchProcessor.ts
@@ -1,13 +1,33 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
-import type { BatchRunState, Session, HistoryEntry, UsageStats } from '../types';
+import type { BatchRunState, BatchRunConfig, BatchDocumentEntry, Session, HistoryEntry, UsageStats } from '../types';
 
 // Regex to count unchecked markdown checkboxes: - [ ] task
 const UNCHECKED_TASK_REGEX = /^[\s]*-\s*\[\s*\]\s*.+$/gm;
 
+// Regex to match checked markdown checkboxes for reset-on-completion
+const CHECKED_TASK_REGEX = /^(\s*-\s*)\[x\]/gim;
+
 // Default empty batch state
 const DEFAULT_BATCH_STATE: BatchRunState = {
   isRunning: false,
   isStopping: false,
+  // Multi-document progress (new fields)
+  documents: [],
+  currentDocumentIndex: 0,
+  currentDocTasksTotal: 0,
+  currentDocTasksCompleted: 0,
+  totalTasksAcrossAllDocs: 0,
+  completedTasksAcrossAllDocs: 0,
+  // Loop mode
+  loopEnabled: false,
+  loopIteration: 0,
+  // Folder path for file operations
+  folderPath: '',
+  // Worktree tracking
+  worktreeActive: false,
+  worktreePath: undefined,
+  worktreeBranch: undefined,
+  // Legacy fields (kept for backwards compatibility)
   totalTasks: 0,
   completedTasks: 0,
   currentTaskIndex: 0,
@@ -24,13 +44,23 @@ interface BatchCompleteInfo {
   elapsedTimeMs: number;
 }
 
+interface PRResultInfo {
+  sessionId: string;
+  sessionName: string;
+  success: boolean;
+  prUrl?: string;
+  error?: string;
+}
+
 interface UseBatchProcessorProps {
   sessions: Session[];
   onUpdateSession: (sessionId: string, updates: Partial<Session>) => void;
-  onSpawnAgent: (sessionId: string, prompt: string) => Promise<{ success: boolean; response?: string; claudeSessionId?: string; usageStats?: UsageStats }>;
+  onSpawnAgent: (sessionId: string, prompt: string, cwdOverride?: string) => Promise<{ success: boolean; response?: string; claudeSessionId?: string; usageStats?: UsageStats }>;
   onSpawnSynopsis: (sessionId: string, cwd: string, claudeSessionId: string, prompt: string) => Promise<{ success: boolean; response?: string }>;
   onAddHistoryEntry: (entry: Omit<HistoryEntry, 'id'>) => void;
   onComplete?: (info: BatchCompleteInfo) => void;
+  // Callback for PR creation results (success or failure)
+  onPRResult?: (info: PRResultInfo) => void;
   // TTS settings for speaking synopsis after each task
   audioFeedbackEnabled?: boolean;
   audioFeedbackCommand?: string;
@@ -45,8 +75,8 @@ interface UseBatchProcessorReturn {
   hasAnyActiveBatch: boolean;
   // Get list of session IDs with active batches
   activeBatchSessionIds: string[];
-  // Start batch run for a specific session
-  startBatchRun: (sessionId: string, scratchpadContent: string, prompt: string) => Promise<void>;
+  // Start batch run for a specific session with multi-document support
+  startBatchRun: (sessionId: string, config: BatchRunConfig, folderPath: string) => Promise<void>;
   // Stop batch run for a specific session
   stopBatchRun: (sessionId: string) => void;
   // Custom prompts per session
@@ -63,6 +93,14 @@ export function countUnfinishedTasks(content: string): number {
   return matches ? matches.length : 0;
 }
 
+/**
+ * Uncheck all markdown checkboxes in content (for reset-on-completion)
+ * Converts all - [x] to - [ ] (case insensitive)
+ */
+export function uncheckAllTasks(content: string): string {
+  return content.replace(CHECKED_TASK_REGEX, '$1[ ]');
+}
+
 /**
  * Hook for managing batch processing of scratchpad tasks across multiple sessions
  */
@@ -112,6 +150,7 @@ export function useBatchProcessor({
   onSpawnSynopsis,
   onAddHistoryEntry,
   onComplete,
+  onPRResult,
   audioFeedbackEnabled,
   audioFeedbackCommand
 }: UseBatchProcessorProps): UseBatchProcessorReturn {
@@ -123,7 +162,6 @@ export function useBatchProcessor({
 
   // Refs for tracking stop requests per session
   const stopRequestedRefs = useRef<Record<string, boolean>>({});
-  const scratchpadPathRefs = useRef<Record<string, string | null>>({});
 
   // Helper to get batch state for a session
   const getBatchState = useCallback((sessionId: string): BatchRunState => {
@@ -163,56 +201,154 @@ export function useBatchProcessor({
   }, [batchRunStates]);
 
   /**
-   * Start a batch processing run for a specific session
+   * Helper function to read a document and count its tasks
+   */
+  const readDocAndCountTasks = async (folderPath: string, filename: string): Promise<{ content: string; taskCount: number }> => {
+    const result = await window.maestro.autorun.readDoc(folderPath, filename + '.md');
+    if (!result.success || !result.content) {
+      return { content: '', taskCount: 0 };
+    }
+    return { content: result.content, taskCount: countUnfinishedTasks(result.content) };
+  };
+
+  /**
+   * Generate PR body from completed tasks
+   */
+  const generatePRBody = (documents: BatchDocumentEntry[], totalTasksCompleted: number): string => {
+    const docList = documents.map(d => `- ${d.filename}`).join('\n');
+    return `## Auto Run Summary
+
+**Documents processed:**
+${docList}
+
+**Total tasks completed:** ${totalTasksCompleted}
+
+---
+*This PR was automatically created by Maestro Auto Run.*`;
+  };
+
+  /**
+   * Start a batch processing run for a specific session with multi-document support
    */
-  const startBatchRun = useCallback(async (sessionId: string, scratchpadContent: string, prompt: string) => {
+  const startBatchRun = useCallback(async (sessionId: string, config: BatchRunConfig, folderPath: string) => {
     const session = sessions.find(s => s.id === sessionId);
     if (!session) {
       console.error('Session not found for batch processing:', sessionId);
       return;
     }
 
-    // Track batch start time for completion notification
-    const batchStartTime = Date.now();
+    const { documents, prompt, loopEnabled, maxLoops, worktree } = config;
 
-    // Count tasks
-    const totalTasks = countUnfinishedTasks(scratchpadContent);
-
-    if (totalTasks === 0) {
-      console.warn('No unchecked tasks found in scratchpad for session:', sessionId);
+    if (documents.length === 0) {
+      console.warn('No documents provided for batch processing:', sessionId);
       return;
     }
 
+    // Track batch start time for completion notification
+    const batchStartTime = Date.now();
+
     // Reset stop flag for this session
     stopRequestedRefs.current[sessionId] = false;
 
-    // Write scratchpad content to temp file
-    const writeResult = await window.maestro.tempfile.write(
-      scratchpadContent,
-      `maestro-scratchpad-${sessionId}-${Date.now()}.md`
-    );
+    // Set up worktree if enabled
+    let effectiveCwd = session.cwd; // Default to session's cwd
+    let worktreeActive = false;
+    let worktreePath: string | undefined;
+    let worktreeBranch: string | undefined;
 
-    if (!writeResult.success || !writeResult.path) {
-      console.error('Failed to write temp file:', writeResult.error);
-      return;
+    if (worktree?.enabled && worktree.path && worktree.branchName) {
+      console.log('[BatchProcessor] Setting up worktree at', worktree.path, 'with branch', worktree.branchName);
+
+      try {
+        // Set up or reuse the worktree
+        const setupResult = await window.maestro.git.worktreeSetup(
+          session.cwd,
+          worktree.path,
+          worktree.branchName
+        );
+
+        if (!setupResult.success) {
+          console.error('[BatchProcessor] Failed to set up worktree:', setupResult.error);
+          // Show error to user and abort
+          return;
+        }
+
+        // If worktree exists but on different branch, checkout the requested branch
+        if (setupResult.branchMismatch) {
+          console.log('[BatchProcessor] Worktree exists with different branch, checking out', worktree.branchName);
+
+          const checkoutResult = await window.maestro.git.worktreeCheckout(
+            worktree.path,
+            worktree.branchName,
+            true // createIfMissing
+          );
+
+          if (!checkoutResult.success) {
+            if (checkoutResult.hasUncommittedChanges) {
+              console.error('[BatchProcessor] Cannot checkout: worktree has uncommitted changes');
+              // Abort - user needs to handle uncommitted changes first
+              return;
+            } else {
+              console.error('[BatchProcessor] Failed to checkout branch:', checkoutResult.error);
+              return;
+            }
+          }
+        }
+
+        // Worktree is ready - use it as the working directory
+        effectiveCwd = worktree.path;
+        worktreeActive = true;
+        worktreePath = worktree.path;
+        worktreeBranch = worktree.branchName;
+
+        console.log('[BatchProcessor] Worktree ready at', effectiveCwd);
+
+      } catch (error) {
+        console.error('[BatchProcessor] Error setting up worktree:', error);
+        return;
+      }
     }
 
-    scratchpadPathRefs.current[sessionId] = writeResult.path;
+    // Calculate initial total tasks across all documents
+    let initialTotalTasks = 0;
+    for (const doc of documents) {
+      const { taskCount } = await readDocAndCountTasks(folderPath, doc.filename);
+      initialTotalTasks += taskCount;
+    }
 
-    // Replace $$SCRATCHPAD$$ placeholder with actual path
-    const finalPrompt = prompt.replace(/\$\$SCRATCHPAD\$\$/g, writeResult.path);
+    if (initialTotalTasks === 0) {
+      console.warn('No unchecked tasks found across all documents for session:', sessionId);
+      return;
+    }
 
-    // Initialize batch run state for this session
+    // Initialize batch run state
     setBatchRunStates(prev => ({
       ...prev,
       [sessionId]: {
         isRunning: true,
         isStopping: false,
-        totalTasks,
+        // Multi-document progress
+        documents: documents.map(d => d.filename),
+        currentDocumentIndex: 0,
+        currentDocTasksTotal: 0,
+        currentDocTasksCompleted: 0,
+        totalTasksAcrossAllDocs: initialTotalTasks,
+        completedTasksAcrossAllDocs: 0,
+        // Loop mode
+        loopEnabled,
+        loopIteration: 0,
+        maxLoops,
+        // Folder path for file operations
+        folderPath,
+        // Worktree tracking
+        worktreeActive,
+        worktreePath,
+        worktreeBranch,
+        // Legacy fields (for backwards compatibility)
+        totalTasks: initialTotalTasks,
         completedTasks: 0,
         currentTaskIndex: 0,
-        scratchpadPath: writeResult.path,
-        originalContent: scratchpadContent,
+        originalContent: '',
         customPrompt: prompt !== '' ? prompt : undefined,
         sessionIds: [],
         startTime: batchStartTime
@@ -222,152 +358,368 @@ export function useBatchProcessor({
     // Store custom prompt for persistence
     setCustomPrompts(prev => ({ ...prev, [sessionId]: prompt }));
 
-    // Run agent iterations
+    // Collect Claude session IDs and track completion
     const claudeSessionIds: string[] = [];
-    let completedCount = 0;
-
+    let totalCompletedTasks = 0;
+    let loopIteration = 0;
 
-    for (let i = 0; i < totalTasks; i++) {
-      // Check if stop was requested for this session
+    // Main processing loop (handles loop mode)
+    while (true) {
+      // Check for stop request
       if (stopRequestedRefs.current[sessionId]) {
-        console.log('Batch run stopped by user after task', i, 'for session:', sessionId);
+        console.log('[BatchProcessor] Batch run stopped by user for session:', sessionId);
         break;
       }
 
-      // Update current task index
-      setBatchRunStates(prev => ({
-        ...prev,
-        [sessionId]: {
-          ...prev[sessionId],
-          currentTaskIndex: i
+      // Track if any tasks were processed in this iteration
+      let anyTasksProcessedThisIteration = false;
+      // Track tasks completed in non-reset documents this iteration
+      // This is critical for loop mode: if only reset docs have tasks, we'd loop forever
+      let tasksCompletedInNonResetDocs = 0;
+
+      // Process each document in order
+      for (let docIndex = 0; docIndex < documents.length; docIndex++) {
+        // Check for stop request before each document
+        if (stopRequestedRefs.current[sessionId]) {
+          console.log('[BatchProcessor] Batch run stopped by user at document', docIndex, 'for session:', sessionId);
+          break;
         }
-      }));
-
-      try {
-        // Capture start time for elapsed time tracking
-        const taskStartTime = Date.now();
 
-        // Spawn agent with the prompt for this specific session
-        const result = await onSpawnAgent(sessionId, finalPrompt);
+        const docEntry = documents[docIndex];
+        const docFilePath = `${folderPath}/${docEntry.filename}.md`;
 
-        // Capture elapsed time
-        const elapsedTimeMs = Date.now() - taskStartTime;
+        // Read document and count tasks
+        let { taskCount: remainingTasks } = await readDocAndCountTasks(folderPath, docEntry.filename);
 
-        if (result.claudeSessionId) {
-          claudeSessionIds.push(result.claudeSessionId);
-          // Register as auto-initiated Maestro session
-          window.maestro.claude.registerSessionOrigin(session.cwd, result.claudeSessionId, 'auto')
-            .catch(err => console.error('[BatchProcessor] Failed to register session origin:', err));
+        // Skip documents with no tasks
+        if (remainingTasks === 0) {
+          console.log(`[BatchProcessor] Skipping document ${docEntry.filename} - no unchecked tasks`);
+          continue;
         }
 
-        completedCount++;
+        console.log(`[BatchProcessor] Processing document ${docEntry.filename} with ${remainingTasks} tasks`);
 
-        // Update progress
+        // Update state to show current document
         setBatchRunStates(prev => ({
           ...prev,
           [sessionId]: {
             ...prev[sessionId],
-            completedTasks: completedCount,
-            sessionIds: [...(prev[sessionId]?.sessionIds || []), result.claudeSessionId || '']
+            currentDocumentIndex: docIndex,
+            currentDocTasksTotal: remainingTasks,
+            currentDocTasksCompleted: 0
           }
         }));
 
-        // Generate synopsis for successful tasks with a Claude session
-        let shortSummary = `Task ${i + 1} of ${totalTasks}`;
-        let fullSynopsis = shortSummary;
+        let docTasksCompleted = 0;
+
+        // Process tasks in this document until none remain
+        while (remainingTasks > 0) {
+          // Check for stop request before each task
+          if (stopRequestedRefs.current[sessionId]) {
+            console.log('[BatchProcessor] Batch run stopped by user during document', docEntry.filename);
+            break;
+          }
+
+          // Replace $$SCRATCHPAD$$ placeholder with actual document path
+          const finalPrompt = prompt.replace(/\$\$SCRATCHPAD\$\$/g, docFilePath);
 
-        if (result.success && result.claudeSessionId) {
-          // Request a synopsis from the agent by resuming the session
           try {
-            const synopsisResult = await onSpawnSynopsis(
-              sessionId,
-              session.cwd,
-              result.claudeSessionId,
-              BATCH_SYNOPSIS_PROMPT
-            );
-
-            if (synopsisResult.success && synopsisResult.response) {
-              const parsed = parseSynopsis(synopsisResult.response);
-              shortSummary = parsed.shortSummary;
-              fullSynopsis = parsed.fullSynopsis;
+            // Capture start time for elapsed time tracking
+            const taskStartTime = Date.now();
+
+            // Spawn agent with the prompt, using worktree path if active
+            const result = await onSpawnAgent(sessionId, finalPrompt, worktreeActive ? effectiveCwd : undefined);
+
+            // Capture elapsed time
+            const elapsedTimeMs = Date.now() - taskStartTime;
+
+            if (result.claudeSessionId) {
+              claudeSessionIds.push(result.claudeSessionId);
+              // Register as auto-initiated Maestro session
+              window.maestro.claude.registerSessionOrigin(session.cwd, result.claudeSessionId, 'auto')
+                .catch(err => console.error('[BatchProcessor] Failed to register session origin:', err));
+            }
+
+            anyTasksProcessedThisIteration = true;
+
+            // Re-read document to get updated task count
+            const { taskCount: newRemainingTasks } = await readDocAndCountTasks(folderPath, docEntry.filename);
+            const tasksCompletedThisRun = remainingTasks - newRemainingTasks;
+
+            // Update counters
+            docTasksCompleted += tasksCompletedThisRun;
+            totalCompletedTasks += tasksCompletedThisRun;
+
+            // Track non-reset document completions for loop exit logic
+            if (!docEntry.resetOnCompletion) {
+              tasksCompletedInNonResetDocs += tasksCompletedThisRun;
+            }
+
+            // Update progress state
+            setBatchRunStates(prev => ({
+              ...prev,
+              [sessionId]: {
+                ...prev[sessionId],
+                currentDocTasksCompleted: docTasksCompleted,
+                completedTasksAcrossAllDocs: totalCompletedTasks,
+                // Legacy fields
+                completedTasks: totalCompletedTasks,
+                currentTaskIndex: totalCompletedTasks,
+                sessionIds: [...(prev[sessionId]?.sessionIds || []), result.claudeSessionId || '']
+              }
+            }));
+
+            // Generate synopsis for successful tasks with a Claude session
+            let shortSummary = `[${docEntry.filename}] Task completed`;
+            let fullSynopsis = shortSummary;
+
+            if (result.success && result.claudeSessionId) {
+              // Request a synopsis from the agent by resuming the session
+              try {
+                const synopsisResult = await onSpawnSynopsis(
+                  sessionId,
+                  session.cwd,
+                  result.claudeSessionId,
+                  BATCH_SYNOPSIS_PROMPT
+                );
+
+                if (synopsisResult.success && synopsisResult.response) {
+                  const parsed = parseSynopsis(synopsisResult.response);
+                  shortSummary = parsed.shortSummary;
+                  fullSynopsis = parsed.fullSynopsis;
+                }
+              } catch (err) {
+                console.error('[BatchProcessor] Synopsis generation failed:', err);
+              }
+            } else if (!result.success) {
+              shortSummary = `[${docEntry.filename}] Task failed`;
+              fullSynopsis = shortSummary;
             }
-          } catch (err) {
-            console.error('[BatchProcessor] Synopsis generation failed:', err);
-            // Fall back to default summary
+
+            // Add history entry
+            onAddHistoryEntry({
+              type: 'AUTO',
+              timestamp: Date.now(),
+              summary: shortSummary,
+              fullResponse: fullSynopsis,
+              claudeSessionId: result.claudeSessionId,
+              projectPath: session.cwd,
+              sessionId: sessionId,
+              success: result.success,
+              usageStats: result.usageStats,
+              elapsedTimeMs
+            });
+
+            // Speak the synopsis via TTS if audio feedback is enabled
+            if (audioFeedbackEnabled && audioFeedbackCommand && shortSummary) {
+              window.maestro.notification.speak(shortSummary, audioFeedbackCommand).catch(err => {
+                console.error('[BatchProcessor] Failed to speak synopsis:', err);
+              });
+            }
+
+            remainingTasks = newRemainingTasks;
+            console.log(`[BatchProcessor] Document ${docEntry.filename}: ${remainingTasks} tasks remaining`);
+
+          } catch (error) {
+            console.error(`[BatchProcessor] Error running task in ${docEntry.filename} for session ${sessionId}:`, error);
+            // Continue to next task on error
+            remainingTasks--;
           }
-        } else if (!result.success) {
-          shortSummary = `Task ${i + 1} of ${totalTasks} failed`;
-          fullSynopsis = shortSummary;
         }
 
-        // Add history entry with both short summary (for list/toast) and full synopsis (for details)
-        onAddHistoryEntry({
-          type: 'AUTO',
-          timestamp: Date.now(),
-          summary: shortSummary,           // Short 1-2 sentence for list view and toast
-          fullResponse: fullSynopsis,      // Complete synopsis for detail view
-          claudeSessionId: result.claudeSessionId,
-          projectPath: session.cwd,
-          sessionId: sessionId, // Associate with this Maestro session for isolation
-          success: result.success,
-          // Use per-task usage stats returned from spawnAgentForSession
-          usageStats: result.usageStats,
-          elapsedTimeMs
-        });
+        // Check for stop before doing reset
+        if (stopRequestedRefs.current[sessionId]) {
+          break;
+        }
 
-        // Speak the synopsis via TTS if audio feedback is enabled
-        if (audioFeedbackEnabled && audioFeedbackCommand && shortSummary) {
-          window.maestro.notification.speak(shortSummary, audioFeedbackCommand).catch(err => {
-            console.error('[BatchProcessor] Failed to speak synopsis:', err);
-          });
+        // Document complete - handle reset-on-completion if enabled
+        if (docEntry.resetOnCompletion && docTasksCompleted > 0) {
+          console.log(`[BatchProcessor] Resetting document ${docEntry.filename} (reset-on-completion enabled)`);
+
+          // Read the current content and uncheck all tasks
+          const { content: currentContent } = await readDocAndCountTasks(folderPath, docEntry.filename);
+          const resetContent = uncheckAllTasks(currentContent);
+
+          // Write the reset content back
+          await window.maestro.autorun.writeDoc(folderPath, docEntry.filename + '.md', resetContent);
+
+          // If loop is enabled, add the reset tasks back to the total
+          if (loopEnabled) {
+            const resetTaskCount = countUnfinishedTasks(resetContent);
+            setBatchRunStates(prev => ({
+              ...prev,
+              [sessionId]: {
+                ...prev[sessionId],
+                totalTasksAcrossAllDocs: prev[sessionId].totalTasksAcrossAllDocs + resetTaskCount,
+                totalTasks: prev[sessionId].totalTasks + resetTaskCount
+              }
+            }));
+          }
         }
+      }
 
-        // Re-read the scratchpad file to check remaining tasks and sync to UI
-        const readResult = await window.maestro.tempfile.read(writeResult.path);
-        if (readResult.success && readResult.content) {
-          // Sync scratchpad changes to UI after each task
-          console.log('[BatchProcessor] Syncing scratchpad after task', i + 1, 'for session:', sessionId);
-          onUpdateSession(sessionId, { scratchPadContent: readResult.content });
+      // Check if we should continue looping
+      if (!loopEnabled) {
+        // No loop mode - we're done after one pass
+        break;
+      }
 
-          const remainingTasks = countUnfinishedTasks(readResult.content);
-          console.log('[BatchProcessor] Remaining unchecked tasks:', remainingTasks);
+      // Check if we've hit the max loop limit
+      if (maxLoops !== null && maxLoops !== undefined && loopIteration + 1 >= maxLoops) {
+        console.log(`[BatchProcessor] Reached max loop limit (${maxLoops}), exiting loop`);
+        break;
+      }
 
-          // If no more tasks, we're done
-          if (remainingTasks === 0) {
-            console.log('All tasks completed by agent for session:', sessionId);
+      // Check for stop request after full pass
+      if (stopRequestedRefs.current[sessionId]) {
+        break;
+      }
+
+      // Loop mode: check if we should continue looping
+      // Key insight: Reset documents will always have tasks after being reset, so we only
+      // continue looping if there are non-reset documents with remaining tasks
+
+      // Check if there are any non-reset documents in the playbook
+      const hasAnyNonResetDocs = documents.some(doc => !doc.resetOnCompletion);
+
+      if (hasAnyNonResetDocs) {
+        // If we have non-reset docs, only continue if they have remaining tasks
+        let anyNonResetDocsHaveTasks = false;
+        for (const doc of documents) {
+          if (doc.resetOnCompletion) continue;
+
+          const { taskCount } = await readDocAndCountTasks(folderPath, doc.filename);
+          if (taskCount > 0) {
+            anyNonResetDocsHaveTasks = true;
             break;
           }
         }
-      } catch (error) {
-        console.error(`Error running task ${i + 1} for session ${sessionId}:`, error);
-        // Continue to next task on error
+
+        if (!anyNonResetDocsHaveTasks) {
+          console.log('[BatchProcessor] All non-reset documents completed, exiting loop');
+          break;
+        }
+      } else {
+        // All documents are reset documents - exit after one pass
+        // Without non-reset docs to track progress, we'd loop forever
+        console.log('[BatchProcessor] All documents are reset-on-completion, exiting after one pass');
+        break;
       }
-    }
 
-    // Sync back changes from temp file
-    try {
-      const finalReadResult = await window.maestro.tempfile.read(writeResult.path);
-      if (finalReadResult.success && finalReadResult.content) {
-        // Update session's scratchpad content
-        onUpdateSession(sessionId, { scratchPadContent: finalReadResult.content });
+      // Safety check: if we didn't process ANY tasks this iteration but docs still have tasks,
+      // something is wrong - exit to avoid infinite loop
+      if (!anyTasksProcessedThisIteration) {
+        console.warn('[BatchProcessor] No tasks processed but documents still have tasks - exiting to avoid infinite loop');
+        break;
+      }
+
+      // Continue looping
+      loopIteration++;
+      console.log(`[BatchProcessor] Starting loop iteration ${loopIteration + 1}`);
+
+      // Re-scan all documents to get fresh task counts (tasks may have been added/removed)
+      let newTotalTasks = 0;
+      for (const doc of documents) {
+        const { taskCount } = await readDocAndCountTasks(folderPath, doc.filename);
+        newTotalTasks += taskCount;
       }
-    } catch (error) {
-      console.error('Error reading final scratchpad state:', error);
+      console.log(`[BatchProcessor] Loop ${loopIteration + 1}: ${newTotalTasks} tasks across all documents`);
+
+      setBatchRunStates(prev => ({
+        ...prev,
+        [sessionId]: {
+          ...prev[sessionId],
+          loopIteration,
+          totalTasksAcrossAllDocs: newTotalTasks + prev[sessionId].completedTasksAcrossAllDocs,
+          totalTasks: newTotalTasks + prev[sessionId].completedTasks
+        }
+      }));
     }
 
-    // Clean up temp file
-    try {
-      await window.maestro.tempfile.delete(writeResult.path);
-    } catch (error) {
-      console.error('Error deleting temp file:', error);
+    // Create PR if worktree was used, PR creation is enabled, and not stopped
+    const wasStopped = stopRequestedRefs.current[sessionId] || false;
+    const sessionName = session.name || session.cwd.split('/').pop() || 'Unknown';
+    if (worktreeActive && worktree?.createPROnCompletion && !wasStopped && totalCompletedTasks > 0) {
+      console.log('[BatchProcessor] Creating PR from worktree branch', worktreeBranch);
+
+      try {
+        // Use the user-selected target branch, or fall back to default branch detection
+        let baseBranch = worktree.prTargetBranch;
+        if (!baseBranch) {
+          const defaultBranchResult = await window.maestro.git.getDefaultBranch(session.cwd);
+          baseBranch = defaultBranchResult.success && defaultBranchResult.branch
+            ? defaultBranchResult.branch
+            : 'main';
+        }
+
+        // Generate PR title and body
+        const prTitle = `Auto Run: ${documents.length} document(s) processed`;
+        const prBody = generatePRBody(documents, totalCompletedTasks);
+
+        // Create the PR
+        const prResult = await window.maestro.git.createPR(
+          effectiveCwd,
+          baseBranch,
+          prTitle,
+          prBody
+        );
+
+        if (prResult.success) {
+          console.log('[BatchProcessor] PR created successfully:', prResult.prUrl);
+          // Notify caller of successful PR creation
+          if (onPRResult) {
+            onPRResult({
+              sessionId,
+              sessionName,
+              success: true,
+              prUrl: prResult.prUrl
+            });
+          }
+        } else {
+          console.warn('[BatchProcessor] PR creation failed:', prResult.error);
+          // Notify caller of PR creation failure (doesn't fail the run)
+          if (onPRResult) {
+            onPRResult({
+              sessionId,
+              sessionName,
+              success: false,
+              error: prResult.error
+            });
+          }
+        }
+      } catch (error) {
+        console.error('[BatchProcessor] Error creating PR:', error);
+        // Notify caller of PR creation error (doesn't fail the run)
+        if (onPRResult) {
+          onPRResult({
+            sessionId,
+            sessionName,
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error'
+          });
+        }
+      }
     }
 
-    // Reset state for this session
+    // Reset state for this session (clear worktree tracking)
     setBatchRunStates(prev => ({
       ...prev,
       [sessionId]: {
         isRunning: false,
         isStopping: false,
+        documents: [],
+        currentDocumentIndex: 0,
+        currentDocTasksTotal: 0,
+        currentDocTasksCompleted: 0,
+        totalTasksAcrossAllDocs: 0,
+        completedTasksAcrossAllDocs: 0,
+        loopEnabled: false,
+        loopIteration: 0,
+        folderPath: '',
+        // Clear worktree tracking
+        worktreeActive: false,
+        worktreePath: undefined,
+        worktreeBranch: undefined,
         totalTasks: 0,
         completedTasks: 0,
         currentTaskIndex: 0,
@@ -376,21 +728,18 @@ export function useBatchProcessor({
       }
     }));
 
-    scratchpadPathRefs.current[sessionId] = null;
-
     // Call completion callback if provided
     if (onComplete) {
-      const wasStopped = stopRequestedRefs.current[sessionId] || false;
       onComplete({
         sessionId,
         sessionName: session.name || session.cwd.split('/').pop() || 'Unknown',
-        completedTasks: completedCount,
-        totalTasks,
+        completedTasks: totalCompletedTasks,
+        totalTasks: initialTotalTasks,
         wasStopped,
         elapsedTimeMs: Date.now() - batchStartTime
       });
     }
-  }, [sessions, onUpdateSession, onSpawnAgent, onAddHistoryEntry, onComplete]);
+  }, [sessions, onUpdateSession, onSpawnAgent, onSpawnSynopsis, onAddHistoryEntry, onComplete, onPRResult, audioFeedbackEnabled, audioFeedbackCommand]);
 
   /**
    * Request to stop the batch run for a specific session after current task completes
diff --git a/src/renderer/hooks/useSessionManager.ts b/src/renderer/hooks/useSessionManager.ts
index d99532888..e5b810d33 100644
--- a/src/renderer/hooks/useSessionManager.ts
+++ b/src/renderer/hooks/useSessionManager.ts
@@ -235,7 +235,6 @@ export function useSessionManager(): UseSessionManagerReturn {
         aiLogs: [],  // Start with clean AI Terminal (no superfluous messages)
         shellLogs: [],  // Start with clean Command Terminal (no superfluous messages)
         workLog: [],
-        scratchPadContent: '',
         contextUsage: 0,
         inputMode: agentId === 'terminal' ? 'terminal' : 'ai',
         // AI process PID (terminal uses runCommand which spawns fresh shells)
@@ -310,23 +309,21 @@ export function useSessionManager(): UseSessionManagerReturn {
     }));
   };
 
-  const updateScratchPad = (content: string) => {
-    setSessions(prev => prev.map(s => s.id === activeSessionId ? { ...s, scratchPadContent: content } : s));
+  // TODO: Auto Run content is now stored in files, not session state
+  // This function will be removed once AutoRun component is updated to use file-based storage
+  const updateScratchPad = (_content: string) => {
+    // No-op: content is now stored in files via autorun:writeDoc IPC
   };
 
-  const updateScratchPadState = (state: {
+  // TODO: Auto Run state tracking to be updated once new autoRun session fields are added
+  // This function will be updated to use the new autoRun* fields
+  const updateScratchPadState = (_state: {
     mode: 'edit' | 'preview';
     cursorPosition: number;
     editScrollPos: number;
     previewScrollPos: number;
   }) => {
-    setSessions(prev => prev.map(s => s.id === activeSessionId ? {
-      ...s,
-      scratchPadMode: state.mode,
-      scratchPadCursorPosition: state.cursorPosition,
-      scratchPadEditScrollPos: state.editScrollPos,
-      scratchPadPreviewScrollPos: state.previewScrollPos
-    } : s));
+    // No-op until new autoRun* fields are added to Session interface
   };
 
   const startRenamingSession = (sessId: string) => {
diff --git a/src/renderer/types/index.ts b/src/renderer/types/index.ts
index 1d05a13bc..d311b6e02 100644
--- a/src/renderer/types/index.ts
+++ b/src/renderer/types/index.ts
@@ -6,8 +6,8 @@ export { Theme, ThemeId, ThemeMode, ThemeColors, isValidThemeId } from '../../sh
 export type ToolType = 'claude' | 'claude-code' | 'aider' | 'opencode' | 'terminal';
 export type SessionState = 'idle' | 'busy' | 'waiting_input' | 'connecting' | 'error';
 export type FileChangeType = 'modified' | 'added' | 'deleted';
-export type RightPanelTab = 'files' | 'history' | 'scratchpad';
-export type ScratchPadMode = 'raw' | 'preview' | 'wysiwyg';
+export type RightPanelTab = 'files' | 'history' | 'autorun';
+// Note: ScratchPadMode was removed as part of the Scratchpad → Auto Run migration
 export type FocusArea = 'sidebar' | 'main' | 'right';
 export type LLMProvider = 'openrouter' | 'anthropic' | 'ollama';
 
@@ -92,20 +92,104 @@ export interface HistoryEntry {
   validated?: boolean; // For AUTO entries: whether a human has validated the task completion
 }
 
+// Document entry in the batch run queue (supports duplicates)
+export interface BatchDocumentEntry {
+  id: string;              // Unique ID for this entry (for drag-drop and duplicates)
+  filename: string;        // The actual document filename (without .md)
+  resetOnCompletion: boolean;  // Uncheck all boxes when done
+  isDuplicate: boolean;    // True if this is a duplicate (can be removed)
+  isMissing?: boolean;     // True if this document no longer exists in the folder (for playbook loading)
+}
+
+// Git worktree configuration for Auto Run
+export interface WorktreeConfig {
+  enabled: boolean;              // Whether to use a worktree
+  path: string;                  // Absolute path for the worktree
+  branchName: string;            // Branch name to use/create
+  createPROnCompletion: boolean; // Create PR when Auto Run finishes
+  prTargetBranch: string;        // Target branch for the PR (e.g., 'main')
+}
+
+// Configuration for starting a batch run
+export interface BatchRunConfig {
+  documents: BatchDocumentEntry[];  // Ordered list of docs to run
+  prompt: string;
+  loopEnabled: boolean;    // Loop back to first doc when done
+  maxLoops?: number | null;  // Max loop iterations (null/undefined = infinite)
+  worktree?: WorktreeConfig;     // Optional worktree configuration
+}
+
 // Batch processing state
 export interface BatchRunState {
   isRunning: boolean;
   isStopping: boolean; // Waiting for current task to finish before stopping
+
+  // Document-level progress (multi-document support)
+  documents: string[];           // Ordered list of document filenames to process
+  currentDocumentIndex: number;  // Which document we're on (0-based)
+
+  // Task-level progress within current document
+  currentDocTasksTotal: number;     // Total tasks in current document
+  currentDocTasksCompleted: number; // Completed tasks in current document
+
+  // Overall progress (grows as reset docs add tasks back)
+  totalTasksAcrossAllDocs: number;
+  completedTasksAcrossAllDocs: number;
+
+  // Loop mode
+  loopEnabled: boolean;
+  loopIteration: number;  // How many times we've looped (0 = first pass)
+  maxLoops?: number | null;  // Max loop iterations (null/undefined = infinite)
+
+  // Folder path for file operations
+  folderPath: string;
+
+  // Worktree tracking
+  worktreeActive: boolean;       // Currently running in a worktree
+  worktreePath?: string;         // Path to the active worktree
+  worktreeBranch?: string;       // Branch name in the worktree
+
+  // Legacy fields (kept for backwards compatibility during migration)
   totalTasks: number;
   completedTasks: number;
   currentTaskIndex: number;
   scratchpadPath?: string; // Path to temp file
   originalContent: string; // Original scratchpad content for sync back
+
+  // Prompt configuration
   customPrompt?: string; // User's custom prompt if modified
   sessionIds: string[]; // Claude session IDs from each iteration
   startTime?: number; // Timestamp when batch run started
 }
 
+// Document entry within a playbook (similar to BatchDocumentEntry but for storage)
+export interface PlaybookDocumentEntry {
+  filename: string;                  // Document filename (without .md)
+  resetOnCompletion: boolean;
+  // Note: isDuplicate is not stored - duplicates are just repeated entries
+}
+
+// A saved Playbook configuration
+export interface Playbook {
+  id: string;                        // Unique ID (UUID)
+  name: string;                      // User-defined name
+  createdAt: number;                 // Timestamp
+  updatedAt: number;                 // Timestamp
+
+  // Configuration
+  documents: PlaybookDocumentEntry[];  // Ordered list of documents
+  loopEnabled: boolean;
+  maxLoops?: number | null;          // Max loop iterations (null/undefined = infinite)
+  prompt: string;                    // Custom agent prompt
+
+  // Optional worktree settings (path not stored - user selects each time)
+  worktreeSettings?: {
+    branchNameTemplate: string;    // e.g., "autorun-{playbook}-{timestamp}"
+    createPROnCompletion: boolean;
+    prTargetBranch?: string;       // Target branch for PR (e.g., 'main')
+  };
+}
+
 // Usage statistics from Claude Code CLI
 export interface UsageStats {
   inputTokens: number;
@@ -182,10 +266,10 @@ export interface Session {
   state: SessionState;
   cwd: string;
   fullPath: string;
+  projectRoot: string; // The initial working directory (never changes, used for Claude session storage)
   aiLogs: LogEntry[];
   shellLogs: LogEntry[];
   workLog: WorkLogItem[];
-  scratchPadContent: string;
   contextUsage: number;
   // Usage statistics from AI responses
   usageStats?: UsageStats;
@@ -216,11 +300,6 @@ export interface Session {
   // Command history (separate for each mode)
   aiCommandHistory?: string[];
   shellCommandHistory?: string[];
-  // Scratchpad state tracking
-  scratchPadCursorPosition?: number;
-  scratchPadEditScrollPos?: number;
-  scratchPadPreviewScrollPos?: number;
-  scratchPadMode?: 'edit' | 'preview';
   // Claude Code session ID for conversation continuity
   // DEPRECATED: Use aiTabs[activeIndex].claudeSessionId instead
   claudeSessionId?: string;
@@ -264,6 +343,17 @@ export interface Session {
   terminalScrollTop?: number;
   // Draft input for terminal mode (persisted across session switches)
   terminalDraftInput?: string;
+
+  // Auto Run panel state (file-based document runner)
+  autoRunFolderPath?: string;           // Persisted folder path for Runner Docs
+  autoRunSelectedFile?: string;          // Currently selected markdown filename
+  autoRunMode?: 'edit' | 'preview';      // Current editing mode
+  autoRunEditScrollPos?: number;         // Scroll position in edit mode
+  autoRunPreviewScrollPos?: number;      // Scroll position in preview mode
+  autoRunCursorPosition?: number;        // Cursor position in edit mode
+
+  // File tree auto-refresh interval in seconds (0 = disabled)
+  fileTreeAutoRefreshInterval?: number;
 }
 
 export interface Group {
diff --git a/src/renderer/utils/fileExplorer.ts b/src/renderer/utils/fileExplorer.ts
index e0599884c..1242d2993 100644
--- a/src/renderer/utils/fileExplorer.ts
+++ b/src/renderer/utils/fileExplorer.ts
@@ -108,3 +108,77 @@ export function flattenTree(
   });
   return result;
 }
+
+export interface FileTreeChanges {
+  totalChanges: number;
+  newFiles: number;
+  newFolders: number;
+  removedFiles: number;
+  removedFolders: number;
+}
+
+/**
+ * Helper to collect all paths from a file tree
+ */
+function collectPaths(
+  nodes: FileTreeNode[],
+  currentPath = ''
+): { files: Set<string>; folders: Set<string> } {
+  const files = new Set<string>();
+  const folders = new Set<string>();
+
+  for (const node of nodes) {
+    const fullPath = currentPath ? `${currentPath}/${node.name}` : node.name;
+    if (node.type === 'folder') {
+      folders.add(fullPath);
+      if (node.children) {
+        const childPaths = collectPaths(node.children, fullPath);
+        childPaths.files.forEach(f => files.add(f));
+        childPaths.folders.forEach(f => folders.add(f));
+      }
+    } else {
+      files.add(fullPath);
+    }
+  }
+
+  return { files, folders };
+}
+
+/**
+ * Compare two file trees and count the differences
+ */
+export function compareFileTrees(
+  oldTree: FileTreeNode[],
+  newTree: FileTreeNode[]
+): FileTreeChanges {
+  const oldPaths = collectPaths(oldTree);
+  const newPaths = collectPaths(newTree);
+
+  // Count new items (in new but not in old)
+  let newFiles = 0;
+  let newFolders = 0;
+  for (const file of newPaths.files) {
+    if (!oldPaths.files.has(file)) newFiles++;
+  }
+  for (const folder of newPaths.folders) {
+    if (!oldPaths.folders.has(folder)) newFolders++;
+  }
+
+  // Count removed items (in old but not in new)
+  let removedFiles = 0;
+  let removedFolders = 0;
+  for (const file of oldPaths.files) {
+    if (!newPaths.files.has(file)) removedFiles++;
+  }
+  for (const folder of oldPaths.folders) {
+    if (!newPaths.folders.has(folder)) removedFolders++;
+  }
+
+  return {
+    totalChanges: newFiles + newFolders + removedFiles + removedFolders,
+    newFiles,
+    newFolders,
+    removedFiles,
+    removedFolders
+  };
+}
diff --git a/src/renderer/utils/tabHelpers.ts b/src/renderer/utils/tabHelpers.ts
index fa343234d..ef6008df7 100644
--- a/src/renderer/utils/tabHelpers.ts
+++ b/src/renderer/utils/tabHelpers.ts
@@ -7,6 +7,13 @@ import { generateId } from './ids';
 // Maximum number of closed tabs to keep in history
 const MAX_CLOSED_TAB_HISTORY = 25;
 
+/**
+ * Check if a tab has draft content (unsent input or staged images).
+ */
+function hasDraft(tab: AITab): boolean {
+  return (tab.inputValue && tab.inputValue.trim() !== '') || (tab.stagedImages && tab.stagedImages.length > 0);
+}
+
 /**
  * Get the currently active AI tab for a session.
  * Returns the tab matching activeTabId, or the first tab if not found.
@@ -385,10 +392,10 @@ export function getBusyTabs(session: Session): AITab[] {
 /**
  * Navigate to the next tab in the session's tab list.
  * Wraps around to the first tab if currently on the last tab.
- * When showUnreadOnly is true, only cycles through unread tabs.
+ * When showUnreadOnly is true, only cycles through unread tabs and tabs with drafts.
  *
  * @param session - The Maestro session
- * @param showUnreadOnly - If true, only navigate through unread tabs
+ * @param showUnreadOnly - If true, only navigate through unread tabs and tabs with drafts
  * @returns Object containing the new active tab and updated session, or null if less than 2 tabs
  *
  * @example
@@ -403,8 +410,9 @@ export function navigateToNextTab(session: Session, showUnreadOnly = false): Set
   }
 
   // Get the list of tabs to navigate through
+  // When filtering, include unread tabs and tabs with drafts (unsent input or staged images)
   const navigableTabs = showUnreadOnly
-    ? session.aiTabs.filter(tab => tab.hasUnread)
+    ? session.aiTabs.filter(tab => tab.hasUnread || hasDraft(tab))
     : session.aiTabs;
 
   if (navigableTabs.length === 0) {
@@ -447,10 +455,10 @@ export function navigateToNextTab(session: Session, showUnreadOnly = false): Set
 /**
  * Navigate to the previous tab in the session's tab list.
  * Wraps around to the last tab if currently on the first tab.
- * When showUnreadOnly is true, only cycles through unread tabs.
+ * When showUnreadOnly is true, only cycles through unread tabs and tabs with drafts.
  *
  * @param session - The Maestro session
- * @param showUnreadOnly - If true, only navigate through unread tabs
+ * @param showUnreadOnly - If true, only navigate through unread tabs and tabs with drafts
  * @returns Object containing the new active tab and updated session, or null if less than 2 tabs
  *
  * @example
@@ -465,8 +473,9 @@ export function navigateToPrevTab(session: Session, showUnreadOnly = false): Set
   }
 
   // Get the list of tabs to navigate through
+  // When filtering, include unread tabs and tabs with drafts (unsent input or staged images)
   const navigableTabs = showUnreadOnly
-    ? session.aiTabs.filter(tab => tab.hasUnread)
+    ? session.aiTabs.filter(tab => tab.hasUnread || hasDraft(tab))
     : session.aiTabs;
 
   if (navigableTabs.length === 0) {
@@ -509,11 +518,11 @@ export function navigateToPrevTab(session: Session, showUnreadOnly = false): Set
 /**
  * Navigate to a specific tab by its index (0-based).
  * Used for Cmd+1 through Cmd+8 shortcuts.
- * When showUnreadOnly is true, navigates within the filtered unread tabs list.
+ * When showUnreadOnly is true, navigates within the filtered list (unread + drafts).
  *
  * @param session - The Maestro session
  * @param index - The 0-based index of the tab to navigate to
- * @param showUnreadOnly - If true, navigate within unread tabs only
+ * @param showUnreadOnly - If true, navigate within unread tabs and tabs with drafts
  * @returns Object containing the new active tab and updated session, or null if index out of bounds
  *
  * @example
@@ -529,8 +538,9 @@ export function navigateToTabByIndex(session: Session, index: number, showUnread
   }
 
   // Get the list of tabs to navigate through
+  // When filtering, include unread tabs and tabs with drafts (unsent input or staged images)
   const navigableTabs = showUnreadOnly
-    ? session.aiTabs.filter(tab => tab.hasUnread)
+    ? session.aiTabs.filter(tab => tab.hasUnread || hasDraft(tab))
     : session.aiTabs;
 
   // Check if index is within bounds
@@ -559,11 +569,11 @@ export function navigateToTabByIndex(session: Session, index: number, showUnread
 
 /**
  * Navigate to the last tab in the session's tab list.
- * Used for Cmd+9 shortcut.
- * When showUnreadOnly is true, navigates to the last unread tab.
+ * Used for Cmd+0 shortcut.
+ * When showUnreadOnly is true, navigates to the last tab in the filtered list (unread + drafts).
  *
  * @param session - The Maestro session
- * @param showUnreadOnly - If true, navigate to last unread tab
+ * @param showUnreadOnly - If true, navigate to last unread/draft tab
  * @returns Object containing the new active tab and updated session, or null if no tabs
  *
  * @example
@@ -577,8 +587,9 @@ export function navigateToLastTab(session: Session, showUnreadOnly = false): Set
     return null;
   }
 
+  // When filtering, include unread tabs and tabs with drafts (unsent input or staged images)
   const navigableTabs = showUnreadOnly
-    ? session.aiTabs.filter(tab => tab.hasUnread)
+    ? session.aiTabs.filter(tab => tab.hasUnread || hasDraft(tab))
     : session.aiTabs;
 
   if (navigableTabs.length === 0) {
diff --git a/src/renderer/utils/templateVariables.ts b/src/renderer/utils/templateVariables.ts
index b72e0c8ec..f91aad9d6 100644
--- a/src/renderer/utils/templateVariables.ts
+++ b/src/renderer/utils/templateVariables.ts
@@ -8,13 +8,19 @@ import type { Session } from '../types';
  * Session Variables:
  *   {{SESSION_ID}}        - Maestro session ID (unique identifier)
  *   {{SESSION_NAME}}      - Current session name
- *   {{CLAUDE_SESSION_ID}} - Claude Code session ID (for conversation continuity)
+ *   {{AGENT_SESSION_ID}}  - Agent session ID (for conversation continuity)
  *   {{TOOL_TYPE}}         - Agent type (claude-code, aider, etc.)
+ *   {{AGENT_NAME}}        - Agent name (same as session name)
+ *   {{AGENT_GROUP}}       - Agent's group name (if grouped)
  *
  * Project Variables:
  *   {{PROJECT_PATH}}      - Full path to project directory
  *   {{PROJECT_NAME}}      - Project folder name (last segment of path)
  *   {{CWD}}               - Current working directory (alias for PROJECT_PATH)
+ *   {{AUTORUN_FOLDER}}    - Auto Run documents folder path
+ *
+ * Auto Run Variables:
+ *   {{LOOP_NUMBER}}       - Current loop iteration (starts at 1)
  *
  * Date/Time Variables:
  *   {{DATE}}              - Current date (YYYY-MM-DD)
@@ -34,37 +40,39 @@ import type { Session } from '../types';
  *
  * Context Variables:
  *   {{CONTEXT_USAGE}}     - Current context window usage percentage
- *   {{INPUT_MODE}}        - Current input mode (ai or terminal)
  */
 
 export interface TemplateContext {
   session: Session;
   gitBranch?: string;
+  groupName?: string;
+  autoRunFolder?: string;
+  loopNumber?: number;
 }
 
 // List of all available template variables for documentation
 export const TEMPLATE_VARIABLES = [
-  { variable: '{{SESSION_ID}}', description: 'Maestro session ID (unique identifier)' },
-  { variable: '{{SESSION_NAME}}', description: 'Current session name' },
-  { variable: '{{CLAUDE_SESSION_ID}}', description: 'Claude Code session ID (for conversation continuity)' },
-  { variable: '{{TOOL_TYPE}}', description: 'Agent type (claude-code, aider, etc.)' },
-  { variable: '{{PROJECT_PATH}}', description: 'Full path to project directory' },
+  { variable: '{{SESSION_ID}}', description: 'Maestro session ID' },
+  { variable: '{{SESSION_NAME}}', description: 'Session name' },
+  { variable: '{{AGENT_SESSION_ID}}', description: 'Agent session ID' },
+  { variable: '{{TOOL_TYPE}}', description: 'Agent type' },
+  { variable: '{{AGENT_NAME}}', description: 'Agent name' },
+  { variable: '{{AGENT_GROUP}}', description: 'Agent group name' },
+  { variable: '{{PROJECT_PATH}}', description: 'Project directory path' },
   { variable: '{{PROJECT_NAME}}', description: 'Project folder name' },
-  { variable: '{{CWD}}', description: 'Current working directory' },
-  { variable: '{{DATE}}', description: 'Current date (YYYY-MM-DD)' },
-  { variable: '{{TIME}}', description: 'Current time (HH:MM:SS)' },
+  { variable: '{{CWD}}', description: 'Working directory' },
+  { variable: '{{AUTORUN_FOLDER}}', description: 'Auto Run folder path' },
+  { variable: '{{LOOP_NUMBER}}', description: 'Current loop iteration (1+)' },
+  { variable: '{{DATE}}', description: 'Date (YYYY-MM-DD)' },
+  { variable: '{{TIME}}', description: 'Time (HH:MM:SS)' },
   { variable: '{{DATETIME}}', description: 'Full datetime' },
   { variable: '{{TIMESTAMP}}', description: 'Unix timestamp (ms)' },
-  { variable: '{{DATE_SHORT}}', description: 'Short date (MM/DD/YY)' },
-  { variable: '{{TIME_SHORT}}', description: 'Short time (HH:MM)' },
+  { variable: '{{DATE_SHORT}}', description: 'Date (MM/DD/YY)' },
+  { variable: '{{TIME_SHORT}}', description: 'Time (HH:MM)' },
   { variable: '{{YEAR}}', description: 'Current year' },
-  { variable: '{{MONTH}}', description: 'Current month (01-12)' },
-  { variable: '{{DAY}}', description: 'Current day (01-31)' },
-  { variable: '{{WEEKDAY}}', description: 'Day of week' },
-  { variable: '{{GIT_BRANCH}}', description: 'Current git branch (if git repo)' },
-  { variable: '{{IS_GIT_REPO}}', description: '"true" or "false"' },
-  { variable: '{{CONTEXT_USAGE}}', description: 'Context window usage %' },
-  { variable: '{{INPUT_MODE}}', description: 'Current input mode (ai/terminal)' },
+  { variable: '{{GIT_BRANCH}}', description: 'Git branch name' },
+  { variable: '{{IS_GIT_REPO}}', description: 'Is git repo (true/false)' },
+  { variable: '{{CONTEXT_USAGE}}', description: 'Context usage %' },
 ];
 
 /**
@@ -74,7 +82,7 @@ export function substituteTemplateVariables(
   template: string,
   context: TemplateContext
 ): string {
-  const { session, gitBranch } = context;
+  const { session, gitBranch, groupName, autoRunFolder, loopNumber } = context;
   const now = new Date();
 
   // Build replacements map
@@ -82,13 +90,19 @@ export function substituteTemplateVariables(
     // Session variables
     'SESSION_ID': session.id,
     'SESSION_NAME': session.name,
-    'CLAUDE_SESSION_ID': session.claudeSessionId || '',
+    'AGENT_SESSION_ID': session.claudeSessionId || '',
     'TOOL_TYPE': session.toolType,
+    'AGENT_NAME': session.name,
+    'AGENT_GROUP': groupName || '',
 
     // Project variables
     'PROJECT_PATH': session.fullPath || session.cwd,
     'PROJECT_NAME': (session.fullPath || session.cwd).split('/').pop() || '',
     'CWD': session.cwd,
+    'AUTORUN_FOLDER': autoRunFolder || session.autoRunFolderPath || '',
+
+    // Loop tracking (1-indexed, defaults to 1 if not in loop mode)
+    'LOOP_NUMBER': String(loopNumber ?? 1),
 
     // Date/Time variables
     'DATE': now.toISOString().split('T')[0],
@@ -108,7 +122,6 @@ export function substituteTemplateVariables(
 
     // Context variables
     'CONTEXT_USAGE': String(session.contextUsage || 0),
-    'INPUT_MODE': session.inputMode,
   };
 
   // Perform case-insensitive replacement