Merge pull request #54 from AndyMik90/v2.5.6

chore: update version number to 2.5.6 in package.json
2025-12-20 01:27:32 +01:00 · 2025-12-20 01:27:15 +01:00 · 2025-12-20 01:26:35 +01:00 · 2025-12-20 01:26:23 +01:00 · 2025-12-20 01:24:40 +01:00 · 2025-12-20 01:18:10 +01:00
136 changed files with 8507 additions and 1035 deletions
@@ -0,0 +1,132 @@
+name: Build Native Module Prebuilds
+
+on:
+  # Build on releases
+  release:
+    types: [published]
+  # Manual trigger for testing
+  workflow_dispatch:
+    inputs:
+      electron_version:
+        description: 'Electron version to build for'
+        required: false
+        default: '39.2.6'
+
+env:
+  # Default Electron version - update when upgrading Electron in package.json
+  ELECTRON_VERSION: ${{ github.event.inputs.electron_version || '39.2.6' }}
+
+jobs:
+  build-windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        arch: [x64]
+        # Add arm64 when GitHub Actions supports Windows ARM runners
+        # arch: [x64, arm64]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Install Visual Studio Build Tools
+        uses: microsoft/setup-msbuild@v2
+
+      - name: Install node-pty and rebuild for Electron
+        working-directory: auto-claude-ui
+        shell: pwsh
+        run: |
+          # Install only node-pty
+          pnpm add node-pty@1.1.0-beta42
+
+          # Get Electron ABI version
+          $electronAbi = (npx electron-abi $env:ELECTRON_VERSION)
+          Write-Host "Building for Electron $env:ELECTRON_VERSION (ABI: $electronAbi)"
+
+          # Rebuild node-pty for Electron
+          npx @electron/rebuild --version $env:ELECTRON_VERSION --module-dir node_modules/node-pty --arch ${{ matrix.arch }}
+
+      - name: Package prebuilt binaries
+        working-directory: auto-claude-ui
+        shell: pwsh
+        run: |
+          $electronAbi = (npx electron-abi $env:ELECTRON_VERSION)
+          $prebuildDir = "prebuilds/win32-${{ matrix.arch }}-electron-$electronAbi"
+
+          New-Item -ItemType Directory -Force -Path $prebuildDir
+
+          # Copy all built native files
+          $buildDir = "node_modules/node-pty/build/Release"
+          if (Test-Path $buildDir) {
+            Copy-Item "$buildDir/*.node" $prebuildDir/ -Force
+            Copy-Item "$buildDir/*.dll" $prebuildDir/ -Force -ErrorAction SilentlyContinue
+            Copy-Item "$buildDir/*.exe" $prebuildDir/ -Force -ErrorAction SilentlyContinue
+
+            # Also copy conpty files if they exist in subdirectory
+            if (Test-Path "$buildDir/conpty") {
+              Copy-Item "$buildDir/conpty/*" $prebuildDir/ -Force
+            }
+          }
+
+          # List what we packaged
+          Write-Host "Packaged prebuilds:"
+          Get-ChildItem $prebuildDir
+
+      - name: Create archive
+        working-directory: auto-claude-ui
+        shell: pwsh
+        run: |
+          $electronAbi = (npx electron-abi $env:ELECTRON_VERSION)
+          $archiveName = "node-pty-win32-${{ matrix.arch }}-electron-$electronAbi.zip"
+
+          Compress-Archive -Path "prebuilds/*" -DestinationPath $archiveName
+
+          Write-Host "Created archive: $archiveName"
+          Get-ChildItem $archiveName
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: node-pty-win32-${{ matrix.arch }}
+          path: auto-claude-ui/node-pty-*.zip
+          retention-days: 90
+
+      - name: Upload to release
+        if: github.event_name == 'release'
+        uses: softprops/action-gh-release@v1
+        with:
+          files: auto-claude-ui/node-pty-*.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  # Create a combined prebuilds package
+  package-prebuilds:
+    needs: build-windows
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: List artifacts
+        run: |
+          echo "Downloaded artifacts:"
+          find artifacts -type f -name "*.zip"
+
+      - name: Upload combined artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: node-pty-prebuilds-all
+          path: artifacts/**/*.zip
+          retention-days: 90
@@ -0,0 +1,71 @@
+name: Validate Version
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  validate-version:
+    name: Validate package.json version matches tag
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Extract version from tag
+        id: tag_version
+        run: |
+          # Extract version from tag (e.g., v2.5.5 -> 2.5.5)
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          echo "version=$TAG_VERSION" >> $GITHUB_OUTPUT
+          echo "Tag version: $TAG_VERSION"
+
+      - name: Extract version from package.json
+        id: package_version
+        run: |
+          # Read version from package.json
+          PACKAGE_VERSION=$(node -p "require('./auto-claude-ui/package.json').version")
+          echo "version=$PACKAGE_VERSION" >> $GITHUB_OUTPUT
+          echo "Package.json version: $PACKAGE_VERSION"
+
+      - name: Compare versions
+        run: |
+          TAG_VERSION="${{ steps.tag_version.outputs.version }}"
+          PACKAGE_VERSION="${{ steps.package_version.outputs.version }}"
+
+          echo "=========================================="
+          echo "Version Validation"
+          echo "=========================================="
+          echo "Git tag version:      v$TAG_VERSION"
+          echo "package.json version: $PACKAGE_VERSION"
+          echo "=========================================="
+
+          if [ "$TAG_VERSION" != "$PACKAGE_VERSION" ]; then
+            echo ""
+            echo "❌ ERROR: Version mismatch detected!"
+            echo ""
+            echo "The version in package.json ($PACKAGE_VERSION) does not match"
+            echo "the git tag version ($TAG_VERSION)."
+            echo ""
+            echo "To fix this:"
+            echo "  1. Delete this tag: git tag -d v$TAG_VERSION"
+            echo "  2. Update package.json version to $TAG_VERSION"
+            echo "  3. Commit the change"
+            echo "  4. Recreate the tag: git tag -a v$TAG_VERSION -m 'Release v$TAG_VERSION'"
+            echo ""
+            echo "Or use the automated script:"
+            echo "  node scripts/bump-version.js $TAG_VERSION"
+            echo ""
+            exit 1
+          fi
+
+          echo ""
+          echo "✅ SUCCESS: Versions match!"
+          echo ""
+
+      - name: Version validation result
+        if: success()
+        run: |
+          echo "::notice::Version validation passed - package.json version matches tag v${{ steps.tag_version.outputs.version }}"
@@ -1,3 +1,169 @@
+## 2.5.5 - Enhanced Agent Reliability & Build Workflow
+
+### ✨ New Features
+
+- Required GitHub setup flow after Auto Claude initialization to ensure proper configuration
+- Atomic log saving mechanism to prevent log file corruption during concurrent operations
+- Per-session model and thinking level selection in insights management
+- Multi-auth token support and ANTHROPIC_BASE_URL passthrough for flexible authentication
+- Comprehensive DEBUG logging at Claude SDK invocation points for improved troubleshooting
+- Auto-download of prebuilt node-pty binaries for Windows environments
+- Enhanced merge workflow with current branch detection for accurate change previews
+- Phase configuration module and enhanced agent profiles for improved flexibility
+- Stage-only merge handling with comprehensive verification checks
+- Authentication failure detection system with patterns and validation checks across agent pipeline
+
+### 🛠️ Improvements
+
+- Changed default agent profile from 'balanced' to 'auto' for more adaptive behavior
+- Better GitHub issue tracking and improved user experience in issue management
+- Improved merge preview accuracy using git diff counts for file statistics
+- Preserved roadmap generation state when switching between projects
+- Enhanced agent profiles with phase configuration support
+
+### 🐛 Bug Fixes
+
+- Resolved CI test failures and improved merge preview reliability
+- Fixed CI failures related to linting, formatting, and tests
+- Prevented dialog skip during project initialization flow
+- Updated model IDs for Sonnet and Haiku to match current Claude versions
+- Fixed branch namespace conflict detection to prevent worktree creation failures
+- Removed duplicate LINEAR_API_KEY checks and consolidated imports
+- Python 3.10+ version requirement enforced with proper version checking
+- Prevented command injection vulnerabilities in GitHub API calls
+
+### 🔧 Other Changes
+
+- Code cleanup and test fixture updates
+- Removed redundant auto-claude/specs directory structure
+- Untracked .auto-claude directory to respect gitignore rules
+
+---
+
+## What's Changed
+
+- fix: resolve CI test failures and improve merge preview by @AndyMik90 in de2eccd
+- chore: code cleanup and test fixture updates by @AndyMik90 in 948db57
+- refactor: change default agent profile from 'balanced' to 'auto' by @AndyMik90 in f98a13e
+- security: prevent command injection in GitHub API calls by @AndyMik90 in 24ff491
+- fix: resolve CI failures (lint, format, test) by @AndyMik90 in a8f2d0b
+- fix: use git diff count for totalFiles in merge preview by @AndyMik90 in 46d2536
+- feat: enhance stage-only merge handling with verification checks by @AndyMik90 in 7153558
+- feat: introduce phase configuration module and enhance agent profiles by @AndyMik90 in 2672528
+- fix: preserve roadmap generation state when switching projects by @AndyMik90 in 569e921
+- feat: add required GitHub setup flow after Auto Claude initialization by @AndyMik90 in 03ccce5
+- chore: remove redundant auto-claude/specs directory by @AndyMik90 in 64d5170
+- chore: untrack .auto-claude directory (should be gitignored) by @AndyMik90 in 0710c13
+- fix: prevent dialog skip during project initialization by @AndyMik90 in 56cedec
+- feat: enhance merge workflow by detecting current branch by @AndyMik90 in c0c8067
+- fix: update model IDs for Sonnet and Haiku by @AndyMik90 in 059315d
+- feat: add comprehensive DEBUG logging and fix lint errors by @AndyMik90 in 99cf21e
+- feat: implement atomic log saving to prevent corruption by @AndyMik90 in da5e26b
+- feat: add better github issue tracking and UX by @AndyMik90 in c957eaa
+- feat: add comprehensive DEBUG logging to Claude SDK invocation points by @AndyMik90 in 73d01c0
+- feat: auto-download prebuilt node-pty binaries for Windows by @AndyMik90 in 41a507f
+- feat(insights): add per-session model and thinking level selection by @AndyMik90 in e02aa59
+- fix: require Python 3.10+ and add version check by @AndyMik90 in 9a5ca8c
+- fix: detect branch namespace conflict blocking worktree creation by @AndyMik90 in 63a1d3c
+- fix: remove duplicate LINEAR_API_KEY check and consolidate imports by @Jacob in 7d351e3
+- feat: add multi-auth token support and ANTHROPIC_BASE_URL passthrough by @Jacob in 9dea155
+
+## 2.5.0 - Roadmap Intelligence & Workflow Refinements
+
+### ✨ New Features
+
+- Interactive competitor analysis viewer for roadmap planning with real-time data visualization
+
+- GitHub issue label mapping to task categories for improved organization and tracking
+
+- GitHub issue comment selection in task creation workflow for better context integration
+
+- TaskCreationWizard enhanced with drag-and-drop support for file references and inline @mentions
+
+- Roadmap generation now includes stop functionality and comprehensive debug logging
+
+### 🛠️ Improvements
+
+- Refined visual drop zone feedback in file reference system for more subtle user guidance
+
+- Remove auto-expand behavior for referenced files on draft restore to improve UX
+
+- Always-visible referenced files section in TaskCreationWizard for better discoverability
+
+- Drop zone wrapper added around main modal content area for improved drag-and-drop ergonomics
+
+- Stuck task detection now enabled for ai_review status to better track blocked work
+
+- Enhanced React component stability with proper key usage in RoadmapHeader and PhaseProgressIndicator
+
+### 🐛 Bug Fixes
+
+- Corrected CompetitorAnalysisViewer type definitions for proper TypeScript compliance
+
+- Fixed multiple CodeRabbit review feedback items for improved code quality
+
+- Resolved React key warnings in PhaseProgressIndicator component
+
+- Fixed git status parsing in merge preview for accurate worktree state detection
+
+- Corrected path resolution in runners for proper module imports and .env loading
+
+- Resolved CI lint and TypeScript errors across codebase
+
+- Fixed HTTP error handling and path resolution issues in core modules
+
+- Corrected worktree test to match intended branch detection behavior
+
+- Refined TaskReview component conditional rendering for proper staged task display
+
+---
+
+## What's Changed
+
+- feat: add interactive competitor analysis viewer for roadmap by @AndyMik90 in 7ff326d
+
+- fix: correct CompetitorAnalysisViewer to match type definitions by @AndyMik90 in 4f1766b
+
+- fix: address multiple CodeRabbit review feedback items by @AndyMik90 in 48f7c3c
+
+- fix: use stable React keys instead of array indices in RoadmapHeader by @AndyMik90 in 892e01d
+
+- fix: additional fixes for http error handling and path resolution by @AndyMik90 in 54501cb
+
+- fix: update worktree test to match intended branch detection behavior by @AndyMik90 in f1d578f
+
+- fix: resolve CI lint and TypeScript errors by @AndyMik90 in 2e3a5d9
+
+- feat: enhance roadmap generation with stop functionality and debug logging by @AndyMik90 in a6dad42
+
+- fix: correct path resolution in runners for module imports and .env loading by @AndyMik90 in 3d24f8f
+
+- fix: resolve React key warning in PhaseProgressIndicator by @AndyMik90 in 9106038
+
+- fix: enable stuck task detection for ai_review status by @AndyMik90 in 895ed9f
+
+- feat: map GitHub issue labels to task categories by @AndyMik90 in cbe14fd
+
+- feat: add GitHub issue comment selection and fix auto-start bug by @AndyMik90 in 4c1dd89
+
+- feat: enhance TaskCreationWizard with drag-and-drop support for file references and inline @mentions by @AndyMik90 in d93eefe
+
+- cleanup docs by @AndyMik90 in 8e891df
+
+- fix: correct git status parsing in merge preview by @AndyMik90 in c721dc2
+
+- Update TaskReview component to refine conditional rendering for staged tasks, ensuring proper display when staging is unsuccessful by @AndyMik90 in 1a2b7a1
+
+- auto-claude: subtask-2-3 - Refine visual drop zone feedback to be more subtle by @AndyMik90 in 6cff442
+
+- auto-claude: subtask-2-1 - Remove showFiles auto-expand on draft restore by @AndyMik90 in 12bf69d
+
+- auto-claude: subtask-1-3 - Create an always-visible referenced files section by @AndyMik90 in 3818b46
+
+- auto-claude: subtask-1-2 - Add drop zone wrapper around main modal content area by @AndyMik90 in 219b66d
+
+- auto-claude: subtask-1-1 - Remove Reference Files toggle button by @AndyMik90 in 4e63e85
+
 ## 2.4.0 - Enhanced Cross-Platform Experience with OAuth & Auto-Updates

 ### ✨ New Features
@@ -81,6 +81,21 @@ auto-claude/.venv/bin/pytest tests/ -m "not slow"
 python auto-claude/validate_spec.py --spec-dir auto-claude/specs/001-feature --checkpoint all
 ```

+### Releases
+```bash
+# Automated version bump and release (recommended)
+node scripts/bump-version.js patch   # 2.5.5 -> 2.5.6
+node scripts/bump-version.js minor   # 2.5.5 -> 2.6.0
+node scripts/bump-version.js major   # 2.5.5 -> 3.0.0
+node scripts/bump-version.js 2.6.0   # Set specific version
+
+# Then push to trigger GitHub release workflows
+git push origin main
+git push origin v2.6.0
+```
+
+See [RELEASE.md](RELEASE.md) for detailed release process documentation.
+
 ## Architecture

 ### Core Pipeline
@@ -4,7 +4,7 @@ Your AI coding companion. Build features, fix bugs, and ship faster — with aut

 ![Auto Claude Kanban Board](.github/assets/Auto-Claude-Kanban.png)

-[![Discord](https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/maj9EWmY)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/KCXaPBr4Dj)

 ## What It Does ✨

@@ -35,7 +35,7 @@ The Desktop UI is the recommended way to use Auto Claude. It provides visual tas
 ### Prerequisites

 1. **Node.js 18+** - [Download Node.js](https://nodejs.org/)
-2. **Python 3.9+** - [Download Python](https://www.python.org/downloads/)
+2. **Python 3.10+** - [Download Python](https://www.python.org/downloads/)
 3. **Docker Desktop** - Required for the Memory Layer
 4. **Claude Code CLI** - `npm install -g @anthropic-ai/claude-code`
 5. **Claude Subscription** - Requires [Claude Pro or Max](https://claude.ai/upgrade) for Claude Code access
@@ -114,6 +114,18 @@ pnpm run build && pnpm run start
 # or: npm run build && npm run start
 ```

+<details>
+<summary><b>Windows users:</b> If installation fails with node-gyp errors, click here</summary>
+
+Auto Claude automatically downloads prebuilt binaries for Windows. If prebuilts aren't available for your Electron version yet, you'll need Visual Studio Build Tools:
+
+1. Download [Visual Studio Build Tools 2022](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+2. Select "Desktop development with C++" workload
+3. In "Individual Components", add "MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs"
+4. Restart terminal and run `npm install` again
+
+</details>
+
 ### Step 4: Start Building

 1. Add your project in the UI
@@ -309,7 +321,7 @@ See `auto-claude/.env.example` for complete configuration options.

 Join our Discord to get help, share what you're building, and connect with other Auto Claude users:

-[![Discord](https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/maj9EWmY)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/KCXaPBr4Dj)

 ## 🤝 Contributing

@@ -0,0 +1,186 @@
+# Release Process
+
+This document describes how to create a new release of Auto Claude.
+
+## Automated Release Process (Recommended)
+
+We provide an automated script that handles version bumping, git commits, and tagging to ensure version consistency.
+
+### Prerequisites
+
+- Clean git working directory (no uncommitted changes)
+- You're on the branch you want to release from (usually `main`)
+
+### Steps
+
+1. **Run the version bump script:**
+
+   ```bash
+   # Bump patch version (2.5.5 -> 2.5.6)
+   node scripts/bump-version.js patch
+
+   # Bump minor version (2.5.5 -> 2.6.0)
+   node scripts/bump-version.js minor
+
+   # Bump major version (2.5.5 -> 3.0.0)
+   node scripts/bump-version.js major
+
+   # Set specific version
+   node scripts/bump-version.js 2.6.0
+   ```
+
+   This script will:
+   - ✅ Update `auto-claude-ui/package.json` with the new version
+   - ✅ Create a git commit with the version change
+   - ✅ Create a git tag (e.g., `v2.5.6`)
+   - ⚠️  **NOT** push to remote (you control when to push)
+
+2. **Review the changes:**
+
+   ```bash
+   git log -1              # View the commit
+   git show v2.5.6         # View the tag
+   ```
+
+3. **Push to GitHub:**
+
+   ```bash
+   # Push the commit
+   git push origin main
+
+   # Push the tag
+   git push origin v2.5.6
+   ```
+
+4. **Create GitHub Release:**
+
+   - Go to [GitHub Releases](https://github.com/AndyMik90/Auto-Claude/releases)
+   - Click "Draft a new release"
+   - Select the tag you just pushed (e.g., `v2.5.6`)
+   - Add release notes (describe what changed)
+   - Click "Publish release"
+
+5. **Automated builds will trigger:**
+
+   - ✅ Version validation workflow will verify version consistency
+   - ✅ Tests will run (`test-on-tag.yml`)
+   - ✅ Native module prebuilds will be created (`build-prebuilds.yml`)
+   - ✅ Discord notification will be sent (`discord-release.yml`)
+
+## Manual Release Process (Not Recommended)
+
+If you need to create a release manually, follow these steps **carefully** to avoid version mismatches:
+
+1. **Update `auto-claude-ui/package.json`:**
+
+   ```json
+   {
+     "version": "2.5.6"
+   }
+   ```
+
+2. **Commit the change:**
+
+   ```bash
+   git add auto-claude-ui/package.json
+   git commit -m "chore: bump version to 2.5.6"
+   ```
+
+3. **Create and push tag:**
+
+   ```bash
+   git tag -a v2.5.6 -m "Release v2.5.6"
+   git push origin main
+   git push origin v2.5.6
+   ```
+
+4. **Create GitHub Release** (same as step 4 above)
+
+## Version Validation
+
+A GitHub Action automatically validates that the version in `package.json` matches the git tag.
+
+If there's a mismatch, the workflow will **fail** with a clear error message:
+
+```
+❌ ERROR: Version mismatch detected!
+
+The version in package.json (2.5.0) does not match
+the git tag version (2.5.5).
+
+To fix this:
+  1. Delete this tag: git tag -d v2.5.5
+  2. Update package.json version to 2.5.5
+  3. Commit the change
+  4. Recreate the tag: git tag -a v2.5.5 -m 'Release v2.5.5'
+```
+
+This validation ensures we never ship a release where the updater shows the wrong version.
+
+## Troubleshooting
+
+### Version Mismatch Error
+
+If you see a version mismatch error in GitHub Actions:
+
+1. **Delete the incorrect tag:**
+   ```bash
+   git tag -d v2.5.6                    # Delete locally
+   git push origin :refs/tags/v2.5.6    # Delete remotely
+   ```
+
+2. **Use the automated script:**
+   ```bash
+   node scripts/bump-version.js 2.5.6
+   git push origin main
+   git push origin v2.5.6
+   ```
+
+### Git Working Directory Not Clean
+
+If the version bump script fails with "Git working directory is not clean":
+
+```bash
+# Commit or stash your changes first
+git status
+git add .
+git commit -m "your changes"
+
+# Then run the version bump script
+node scripts/bump-version.js patch
+```
+
+## Release Checklist
+
+Use this checklist when creating a new release:
+
+- [ ] All tests passing on main branch
+- [ ] CHANGELOG updated (if applicable)
+- [ ] Run `node scripts/bump-version.js <type>`
+- [ ] Review commit and tag
+- [ ] Push commit and tag to GitHub
+- [ ] Create GitHub Release with release notes
+- [ ] Verify version validation passed
+- [ ] Verify builds completed successfully
+- [ ] Test the updater shows correct version
+
+## What Gets Released
+
+When you create a release, the following are built and published:
+
+1. **Native module prebuilds** - Windows node-pty binaries
+2. **Electron app packages** - Desktop installers (triggered manually or via electron-builder)
+3. **Discord notification** - Sent to the Auto Claude community
+
+## Version Numbering
+
+We follow [Semantic Versioning (SemVer)](https://semver.org/):
+
+- **MAJOR** version (X.0.0) - Breaking changes
+- **MINOR** version (0.X.0) - New features (backward compatible)
+- **PATCH** version (0.0.X) - Bug fixes (backward compatible)
+
+Examples:
+- `2.5.5 -> 2.5.6` - Bug fix
+- `2.5.6 -> 2.6.0` - New feature
+- `2.6.0 -> 3.0.0` - Breaking change
@@ -20,7 +20,7 @@ export default defineConfig({
          index: resolve(__dirname, 'src/main/index.ts')
        },
        // Only node-pty needs to be external (native module rebuilt by electron-builder)
-        external: ['node-pty']
+        external: ['@lydell/node-pty']
      }
    }
  },
@@ -1,12 +1,12 @@
 {
  "name": "auto-claude-ui",
-  "version": "2.5.0",
+  "version": "2.5.6",
  "description": "Desktop UI for Auto Claude autonomous coding framework",
  "main": "./out/main/index.js",
  "author": "Auto Claude Team",
  "license": "AGPL-3.0",
  "scripts": {
-    "postinstall": "electron-rebuild",
+    "postinstall": "node scripts/postinstall.js",
    "dev": "electron-vite dev",
    "build": "electron-vite build",
    "start": "electron .",
@@ -30,6 +30,7 @@
    "@dnd-kit/core": "^6.3.1",
    "@dnd-kit/sortable": "^10.0.0",
    "@dnd-kit/utilities": "^3.2.2",
+    "@lydell/node-pty": "^1.1.0",
    "@radix-ui/react-alert-dialog": "^1.1.15",
    "@radix-ui/react-checkbox": "^1.1.4",
    "@radix-ui/react-collapsible": "^1.1.3",
@@ -59,7 +60,6 @@
    "ioredis": "^5.8.2",
    "lucide-react": "^0.560.0",
    "motion": "^12.23.26",
-    "node-pty": "^1.1.0-beta42",
    "react": "^19.2.3",
    "react-dom": "^19.2.3",
    "react-markdown": "^10.1.0",
@@ -104,12 +104,13 @@
  "pnpm": {
    "overrides": {
      "electron-builder-squirrel-windows": "^26.0.12",
-      "dmg-builder": "^26.0.12"
+      "dmg-builder": "^26.0.12",
+      "node-pty": "npm:@lydell/node-pty@^1.1.0"
    },
    "onlyBuiltDependencies": [
      "electron",
-      "esbuild",
-      "node-pty"
+      "electron-winstaller",
+      "esbuild"
    ]
  },
  "build": {
@@ -132,8 +133,8 @@
    ],
    "extraResources": [
      {
-        "from": "node_modules/node-pty",
-        "to": "node_modules/node-pty"
+        "from": "node_modules/@lydell/node-pty",
+        "to": "node_modules/@lydell/node-pty"
      },
      {
        "from": "resources/icon.ico",
@@ -180,5 +181,6 @@
    "*.{ts,tsx}": [
      "eslint --fix"
    ]
-  }
+  },
+  "packageManager": "pnpm@10.26.1+sha512.664074abc367d2c9324fdc18037097ce0a8f126034160f709928e9e9f95d98714347044e5c3164d65bd5da6c59c6be362b107546292a8eecb7999196e5ce58fa"
 }
@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * Download prebuilt native modules for Windows
+ *
+ * This script downloads pre-compiled node-pty binaries from GitHub releases,
+ * eliminating the need for Visual Studio Build Tools on Windows.
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const GITHUB_REPO = 'AndyMik90/Auto-Claude';
+const GITHUB_API = 'https://api.github.com';
+
+/**
+ * Get the Electron ABI version for the installed Electron
+ */
+function getElectronAbi() {
+  try {
+    // Try to get from electron-abi package
+    const result = execSync('npx electron-abi', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return result;
+  } catch {
+    // Fallback: read from electron package
+    try {
+      const electronPkg = require('electron/package.json');
+      const version = electronPkg.version;
+      // Electron 39.x = ABI 140
+      const majorVersion = parseInt(version.split('.')[0], 10);
+      // This is a rough mapping, electron-abi is more accurate
+      const abiMap = {
+        39: 140,
+        38: 139,
+        37: 136,
+        36: 135,
+        35: 134,
+        34: 132,
+        33: 131,
+        32: 130,
+        31: 129,
+        30: 128,
+      };
+      return abiMap[majorVersion] || null;
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Get the latest release from GitHub
+ */
+function getLatestRelease() {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.github.com',
+      path: `/repos/${GITHUB_REPO}/releases/latest`,
+      headers: {
+        'User-Agent': 'Auto-Claude-Installer',
+        Accept: 'application/vnd.github.v3+json',
+      },
+    };
+
+    https
+      .get(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          if (res.statusCode === 200) {
+            resolve(JSON.parse(data));
+          } else if (res.statusCode === 404) {
+            resolve(null); // No releases yet
+          } else {
+            reject(new Error(`GitHub API returned ${res.statusCode}`));
+          }
+        });
+      })
+      .on('error', reject);
+  });
+}
+
+/**
+ * Find prebuild asset in release
+ */
+function findPrebuildAsset(release, arch, electronAbi) {
+  if (!release || !release.assets) return null;
+
+  const assetName = `node-pty-win32-${arch}-electron-${electronAbi}.zip`;
+  return release.assets.find((asset) => asset.name === assetName);
+}
+
+/**
+ * Download a file from URL
+ */
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+
+    const request = (url) => {
+      https
+        .get(url, { headers: { 'User-Agent': 'Auto-Claude-Installer' } }, (res) => {
+          if (res.statusCode === 302 || res.statusCode === 301) {
+            // Follow redirect
+            request(res.headers.location);
+            return;
+          }
+
+          if (res.statusCode !== 200) {
+            reject(new Error(`Download failed with status ${res.statusCode}`));
+            return;
+          }
+
+          res.pipe(file);
+          file.on('finish', () => {
+            file.close();
+            resolve();
+          });
+        })
+        .on('error', (err) => {
+          fs.unlink(destPath, () => {}); // Delete partial file
+          reject(err);
+        });
+    };
+
+    request(url);
+  });
+}
+
+/**
+ * Extract zip file (using built-in tools)
+ */
+function extractZip(zipPath, destDir) {
+  const { execSync } = require('child_process');
+
+  // Use PowerShell on Windows
+  execSync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`, {
+    stdio: 'inherit',
+  });
+}
+
+/**
+ * Main function to download and install prebuilds
+ */
+async function downloadPrebuilds() {
+  const arch = process.arch; // x64 or arm64
+  const electronAbi = getElectronAbi();
+
+  if (!electronAbi) {
+    console.log('[prebuilds] Could not determine Electron ABI version');
+    return { success: false, reason: 'unknown-abi' };
+  }
+
+  console.log(`[prebuilds] Looking for prebuilds: win32-${arch}, Electron ABI ${electronAbi}`);
+
+  // Check for prebuilds in GitHub releases
+  let release;
+  try {
+    release = await getLatestRelease();
+  } catch (err) {
+    console.log(`[prebuilds] Could not fetch releases: ${err.message}`);
+    return { success: false, reason: 'fetch-failed' };
+  }
+
+  if (!release) {
+    console.log('[prebuilds] No releases found');
+    return { success: false, reason: 'no-releases' };
+  }
+
+  const asset = findPrebuildAsset(release, arch, electronAbi);
+  if (!asset) {
+    console.log(`[prebuilds] No prebuild found for win32-${arch}-electron-${electronAbi}`);
+    console.log('[prebuilds] Available assets:', release.assets?.map((a) => a.name).join(', ') || 'none');
+    return { success: false, reason: 'no-matching-prebuild' };
+  }
+
+  console.log(`[prebuilds] Found prebuild: ${asset.name}`);
+
+  // Download the prebuild
+  const tempDir = path.join(__dirname, '..', '.prebuild-temp');
+  const zipPath = path.join(tempDir, asset.name);
+  const nodePtyDir = path.join(__dirname, '..', 'node_modules', 'node-pty');
+  const buildDir = path.join(nodePtyDir, 'build', 'Release');
+
+  try {
+    // Create temp directory
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    console.log(`[prebuilds] Downloading ${asset.name}...`);
+    await downloadFile(asset.browser_download_url, zipPath);
+
+    console.log('[prebuilds] Extracting...');
+    extractZip(zipPath, tempDir);
+
+    // Find the extracted prebuild directory
+    const extractedDir = path.join(tempDir, 'prebuilds', `win32-${arch}-electron-${electronAbi}`);
+
+    if (!fs.existsSync(extractedDir)) {
+      throw new Error(`Extracted directory not found: ${extractedDir}`);
+    }
+
+    // Ensure build/Release directory exists
+    fs.mkdirSync(buildDir, { recursive: true });
+
+    // Copy files to node_modules/node-pty/build/Release
+    const files = fs.readdirSync(extractedDir);
+    for (const file of files) {
+      const src = path.join(extractedDir, file);
+      const dest = path.join(buildDir, file);
+      fs.copyFileSync(src, dest);
+      console.log(`[prebuilds] Installed: ${file}`);
+    }
+
+    // Cleanup temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+
+    console.log('[prebuilds] Successfully installed prebuilt binaries!');
+    return { success: true };
+  } catch (err) {
+    // Cleanup on error
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    console.log(`[prebuilds] Download/extract failed: ${err.message}`);
+    return { success: false, reason: 'install-failed', error: err.message };
+  }
+}
+
+// Export for use by postinstall
+module.exports = { downloadPrebuilds, getElectronAbi };
+
+// Run if called directly
+if (require.main === module) {
+  downloadPrebuilds()
+    .then((result) => {
+      if (!result.success) {
+        process.exit(1);
+      }
+    })
+    .catch((err) => {
+      console.error('[prebuilds] Error:', err);
+      process.exit(1);
+    });
+}
@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * Post-install script for Auto Claude UI
+ *
+ * On Windows:
+ *   1. Try to download prebuilt node-pty binaries from GitHub releases
+ *   2. Fall back to electron-rebuild if prebuilds aren't available
+ *   3. Show helpful error message if compilation fails
+ *
+ * On macOS/Linux:
+ *   1. Run electron-rebuild (compilers are typically available)
+ */
+
+const { spawn } = require('child_process');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const isWindows = os.platform() === 'win32';
+
+const WINDOWS_BUILD_TOOLS_HELP = `
+================================================================================
+  VISUAL STUDIO BUILD TOOLS REQUIRED
+================================================================================
+
+Prebuilt binaries weren't available for your Electron version, and compilation
+requires Visual Studio Build Tools.
+
+To install:
+
+  1. Download Visual Studio Build Tools 2022:
+     https://visualstudio.microsoft.com/visual-cpp-build-tools/
+
+  2. Run installer and select:
+     - "Desktop development with C++" workload
+
+  3. In "Individual Components", also select:
+     - "MSVC v143 - VS 2022 C++ x64/x86 Spectre-mitigated libs"
+
+  4. Restart your terminal and run: npm install
+
+================================================================================
+`;
+
+/**
+ * Run electron-rebuild
+ */
+function runElectronRebuild() {
+  return new Promise((resolve, reject) => {
+    const npx = isWindows ? 'npx.cmd' : 'npx';
+    const child = spawn(npx, ['electron-rebuild'], {
+      stdio: 'inherit',
+      shell: isWindows,
+      cwd: path.join(__dirname, '..'),
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ success: true });
+      } else {
+        reject(new Error(`electron-rebuild exited with code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
+}
+
+/**
+ * Check if node-pty is already built
+ */
+function isNodePtyBuilt() {
+  const buildDir = path.join(__dirname, '..', 'node_modules', 'node-pty', 'build', 'Release');
+  if (!fs.existsSync(buildDir)) return false;
+
+  // Check for the main .node file
+  const files = fs.readdirSync(buildDir);
+  return files.some((f) => f.endsWith('.node'));
+}
+
+/**
+ * Main postinstall logic
+ */
+async function main() {
+  console.log('[postinstall] Setting up native modules for Electron...\n');
+
+  // If node-pty is already built (e.g., from a previous successful install), skip
+  if (isNodePtyBuilt()) {
+    console.log('[postinstall] Native modules already built, skipping rebuild.');
+    return;
+  }
+
+  if (isWindows) {
+    // On Windows, try prebuilds first
+    console.log('[postinstall] Windows detected - checking for prebuilt binaries...\n');
+
+    try {
+      // Dynamic import to handle case where the script doesn't exist yet
+      const { downloadPrebuilds } = require('./download-prebuilds.js');
+      const result = await downloadPrebuilds();
+
+      if (result.success) {
+        console.log('\n[postinstall] Successfully installed prebuilt binaries!');
+        console.log('[postinstall] No Visual Studio Build Tools required.\n');
+        return;
+      }
+
+      console.log(`\n[postinstall] Prebuilds not available (${result.reason})`);
+      console.log('[postinstall] Falling back to electron-rebuild...\n');
+    } catch (err) {
+      console.log('[postinstall] Could not check for prebuilds:', err.message);
+      console.log('[postinstall] Falling back to electron-rebuild...\n');
+    }
+  }
+
+  // Run electron-rebuild
+  try {
+    console.log('[postinstall] Running electron-rebuild...\n');
+    await runElectronRebuild();
+    console.log('\n[postinstall] Native modules built successfully!');
+  } catch (error) {
+    console.error('\n[postinstall] Failed to build native modules.\n');
+
+    if (isWindows) {
+      console.error(WINDOWS_BUILD_TOOLS_HELP);
+    } else {
+      console.error('Error:', error.message);
+      console.error('\nYou may need to install build tools for your platform:');
+      console.error('  macOS: xcode-select --install');
+      console.error('  Linux: sudo apt-get install build-essential\n');
+    }
+
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('[postinstall] Unexpected error:', err);
+  process.exit(1);
+});
@@ -29,6 +29,14 @@ vi.mock('child_process', () => ({
  spawn: vi.fn(() => mockProcess)
 }));

+// Mock claude-profile-manager to bypass auth checks in tests
+vi.mock('../../main/claude-profile-manager', () => ({
+  getClaudeProfileManager: () => ({
+    hasValidAuth: () => true,
+    getActiveProfile: () => ({ profileId: 'default', profileName: 'Default' })
+  })
+}));
+
 // Auto-claude source path (for getAutoBuildSourcePath to find)
 const AUTO_CLAUDE_SOURCE = path.join(TEST_DIR, 'auto-claude-source');

@@ -0,0 +1,560 @@
+/**
+ * Unit tests for rate limit and auth failure detection
+ * Tests detection patterns for rate limiting and authentication failures
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock the claude-profile-manager before importing
+vi.mock('../claude-profile-manager', () => ({
+  getClaudeProfileManager: vi.fn(() => ({
+    getActiveProfile: vi.fn(() => ({
+      id: 'test-profile-id',
+      name: 'Test Profile',
+      isDefault: true
+    })),
+    getProfile: vi.fn((id: string) => ({
+      id,
+      name: 'Test Profile',
+      isDefault: true
+    })),
+    getBestAvailableProfile: vi.fn(() => null),
+    recordRateLimitEvent: vi.fn()
+  }))
+}));
+
+describe('Rate Limit Detector', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('detectRateLimit', () => {
+    it('should detect rate limit with reset time', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const output = 'Limit reached · resets Dec 17 at 6am (Europe/Oslo)';
+      const result = detectRateLimit(output);
+
+      expect(result.isRateLimited).toBe(true);
+      expect(result.resetTime).toBe('Dec 17 at 6am (Europe/Oslo)');
+      expect(result.limitType).toBe('weekly');
+    });
+
+    it('should detect rate limit with bullet character', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const output = 'Limit reached • resets 11:59pm';
+      const result = detectRateLimit(output);
+
+      expect(result.isRateLimited).toBe(true);
+      expect(result.resetTime).toBe('11:59pm');
+      expect(result.limitType).toBe('session');
+    });
+
+    it('should detect secondary rate limit indicators', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const testCases = [
+        'rate limit exceeded',
+        'usage limit reached',
+        'You have exceeded your limit',
+        'too many requests'
+      ];
+
+      for (const output of testCases) {
+        const result = detectRateLimit(output);
+        expect(result.isRateLimited).toBe(true);
+      }
+    });
+
+    it('should return false for non-rate-limit output', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const output = 'Task completed successfully';
+      const result = detectRateLimit(output);
+
+      expect(result.isRateLimited).toBe(false);
+    });
+
+    it('should return false for empty output', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const result = detectRateLimit('');
+
+      expect(result.isRateLimited).toBe(false);
+    });
+  });
+
+  describe('isRateLimitError', () => {
+    it('should return true for rate limit errors', async () => {
+      const { isRateLimitError } = await import('../rate-limit-detector');
+
+      expect(isRateLimitError('Limit reached · resets Dec 17 at 6am')).toBe(true);
+      expect(isRateLimitError('rate limit exceeded')).toBe(true);
+    });
+
+    it('should return false for non-rate-limit errors', async () => {
+      const { isRateLimitError } = await import('../rate-limit-detector');
+
+      expect(isRateLimitError('authentication required')).toBe(false);
+      expect(isRateLimitError('Task completed')).toBe(false);
+    });
+  });
+
+  describe('extractResetTime', () => {
+    it('should extract reset time from rate limit message', async () => {
+      const { extractResetTime } = await import('../rate-limit-detector');
+
+      const output = 'Limit reached · resets Dec 17 at 6am (Europe/Oslo)';
+      const resetTime = extractResetTime(output);
+
+      expect(resetTime).toBe('Dec 17 at 6am (Europe/Oslo)');
+    });
+
+    it('should return null for non-rate-limit output', async () => {
+      const { extractResetTime } = await import('../rate-limit-detector');
+
+      const output = 'Task completed successfully';
+      const resetTime = extractResetTime(output);
+
+      expect(resetTime).toBeNull();
+    });
+  });
+});
+
+describe('Auth Failure Detection', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('detectAuthFailure', () => {
+    it('should detect "authentication required" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Error: authentication required';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+      expect(result.message).toContain('authentication required');
+    });
+
+    it('should detect "authentication is required" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Authentication is required to proceed';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "not authenticated" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Error: not authenticated';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "not yet authenticated" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'You are not yet authenticated';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "login required" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Login required';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "oauth token invalid" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'OAuth token is invalid';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "oauth token expired" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'OAuth token expired';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('expired');
+    });
+
+    it('should detect "oauth token missing" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'OAuth token missing';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "unauthorized" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Error: Unauthorized';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "please log in" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Please log in to continue';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      // "please log in" doesn't contain 'required' keyword, so classified as 'unknown'
+      expect(result.failureType).toBeDefined();
+    });
+
+    it('should detect "please authenticate" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Please authenticate before proceeding';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      // "please authenticate" doesn't contain 'required' keyword, so classified as 'unknown'
+      expect(result.failureType).toBeDefined();
+    });
+
+    it('should detect "invalid credentials" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Invalid credentials provided';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "invalid token" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Invalid token';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "auth failed" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Auth failed';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+    });
+
+    it('should detect "authentication error" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Authentication error occurred';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+    });
+
+    it('should detect "session expired" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Your session expired';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('expired');
+    });
+
+    it('should detect "access denied" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Access denied';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "permission denied" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Permission denied';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "401 unauthorized" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'HTTP 401 Unauthorized';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('invalid');
+    });
+
+    it('should detect "credentials missing" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Credentials are missing';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('missing');
+    });
+
+    it('should detect "credentials expired" pattern', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Credentials expired';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.failureType).toBe('expired');
+    });
+
+    it('should return false for rate limit errors (not auth failure)', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Limit reached · resets Dec 17 at 6am';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(false);
+    });
+
+    it('should return false for normal output', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Task completed successfully';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(false);
+    });
+
+    it('should return false for empty output', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('');
+
+      expect(result.isAuthFailure).toBe(false);
+    });
+
+    it('should include profile ID in result', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('authentication required', 'custom-profile');
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.profileId).toBe('custom-profile');
+    });
+
+    it('should use active profile ID when not specified', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('authentication required');
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.profileId).toBe('test-profile-id');
+    });
+
+    it('should include original error in result', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = 'Error: authentication required for this action';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.originalError).toBe(output);
+    });
+
+    it('should provide user-friendly message for missing auth', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('authentication required');
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.message).toContain('Settings');
+      expect(result.message).toContain('Claude Profiles');
+    });
+
+    it('should provide user-friendly message for expired auth', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('session expired');
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.message).toContain('expired');
+      expect(result.message).toContain('re-authenticate');
+    });
+
+    it('should provide user-friendly message for invalid auth', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const result = detectAuthFailure('unauthorized');
+
+      expect(result.isAuthFailure).toBe(true);
+      expect(result.message).toContain('Invalid');
+    });
+  });
+
+  describe('isAuthFailureError', () => {
+    it('should return true for auth failure errors', async () => {
+      const { isAuthFailureError } = await import('../rate-limit-detector');
+
+      expect(isAuthFailureError('authentication required')).toBe(true);
+      expect(isAuthFailureError('not authenticated')).toBe(true);
+      expect(isAuthFailureError('unauthorized')).toBe(true);
+      expect(isAuthFailureError('invalid token')).toBe(true);
+    });
+
+    it('should return false for non-auth-failure errors', async () => {
+      const { isAuthFailureError } = await import('../rate-limit-detector');
+
+      expect(isAuthFailureError('Limit reached · resets Dec 17')).toBe(false);
+      expect(isAuthFailureError('Task completed')).toBe(false);
+      expect(isAuthFailureError('')).toBe(false);
+    });
+  });
+
+  describe('auth failure does not match rate limit patterns', () => {
+    it('should not detect auth failure as rate limit', async () => {
+      const { detectRateLimit } = await import('../rate-limit-detector');
+
+      const authErrors = [
+        'authentication required',
+        'not authenticated',
+        'unauthorized',
+        'invalid token',
+        'session expired',
+        'please log in'
+      ];
+
+      for (const error of authErrors) {
+        const result = detectRateLimit(error);
+        expect(result.isRateLimited).toBe(false);
+      }
+    });
+
+    it('should not detect rate limit as auth failure', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const rateLimitErrors = [
+        'Limit reached · resets Dec 17 at 6am',
+        'rate limit exceeded',
+        'too many requests',
+        'usage limit reached'
+      ];
+
+      for (const error of rateLimitErrors) {
+        const result = detectAuthFailure(error);
+        expect(result.isAuthFailure).toBe(false);
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle multiline output with auth failure', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = `Starting task...
+Processing...
+Error: authentication required
+Please authenticate and try again.`;
+
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+    });
+
+    it('should handle case-insensitive matching', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const testCases = [
+        'AUTHENTICATION REQUIRED',
+        'Authentication Required',
+        'UNAUTHORIZED',
+        'Unauthorized',
+        'NOT AUTHENTICATED',
+        'Not Authenticated'
+      ];
+
+      for (const output of testCases) {
+        const result = detectAuthFailure(output);
+        expect(result.isAuthFailure).toBe(true);
+      }
+    });
+
+    it('should handle partial matches correctly', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      // Should NOT match - word is part of a different context
+      const falsePositives = [
+        'The authenticated user can proceed',  // has 'authenticated' but not an error
+        'Authorization header set correctly'   // different word
+      ];
+
+      // Note: Some false positives may still match due to pattern design
+      // The patterns are intentionally broad to catch errors
+      for (const output of falsePositives) {
+        const result = detectAuthFailure(output);
+        // Just verify it runs without error - actual match depends on pattern design
+        expect(typeof result.isAuthFailure).toBe('boolean');
+      }
+    });
+
+    it('should handle JSON error responses', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = '{"error": "unauthorized", "message": "Please authenticate"}';
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+    });
+
+    it('should handle error stack traces with auth failure', async () => {
+      const { detectAuthFailure } = await import('../rate-limit-detector');
+
+      const output = `Error: authentication required
+    at validateToken (/app/auth.js:42)
+    at processRequest (/app/handler.js:15)
+    at main (/app/index.js:8)`;
+
+      const result = detectAuthFailure(output);
+
+      expect(result.isAuthFailure).toBe(true);
+    });
+  });
+});
@@ -5,6 +5,7 @@ import { AgentState } from './agent-state';
 import { AgentEvents } from './agent-events';
 import { AgentProcessManager } from './agent-process';
 import { AgentQueueManager } from './agent-queue';
+import { getClaudeProfileManager } from '../claude-profile-manager';
 import {
  SpecCreationMetadata,
  TaskExecutionOptions,
@@ -89,6 +90,13 @@ export class AgentManager extends EventEmitter {
    specDir?: string,
    metadata?: SpecCreationMetadata
  ): void {
+    // Pre-flight auth check: Verify active profile has valid authentication
+    const profileManager = getClaudeProfileManager();
+    if (!profileManager.hasValidAuth()) {
+      this.emit('error', taskId, 'Claude authentication required. Please authenticate in Settings > Claude Profiles before starting tasks.');
+      return;
+    }
+
    const autoBuildSource = this.processManager.getAutoBuildSourcePath();

    if (!autoBuildSource) {
@@ -120,6 +128,20 @@ export class AgentManager extends EventEmitter {
      args.push('--auto-approve');
    }

+    // Pass model and thinking level configuration
+    // For auto profile, use phase-specific config; otherwise use single model/thinking
+    if (metadata?.isAutoProfile && metadata.phaseModels && metadata.phaseThinking) {
+      // Pass the spec phase model and thinking level to spec_runner
+      args.push('--model', metadata.phaseModels.spec);
+      args.push('--thinking-level', metadata.phaseThinking.spec);
+    } else if (metadata?.model) {
+      // Non-auto profile: use single model and thinking level
+      args.push('--model', metadata.model);
+      if (metadata.thinkingLevel) {
+        args.push('--thinking-level', metadata.thinkingLevel);
+      }
+    }
+
    // Store context for potential restart
    this.storeTaskContext(taskId, projectPath, '', {}, true, taskDescription, specDir, metadata);

@@ -136,6 +158,13 @@ export class AgentManager extends EventEmitter {
    specId: string,
    options: TaskExecutionOptions = {}
  ): void {
+    // Pre-flight auth check: Verify active profile has valid authentication
+    const profileManager = getClaudeProfileManager();
+    if (!profileManager.hasValidAuth()) {
+      this.emit('error', taskId, 'Claude authentication required. Please authenticate in Settings > Claude Profiles before starting tasks.');
+      return;
+    }
+
    const autoBuildSource = this.processManager.getAutoBuildSourcePath();

    if (!autoBuildSource) {
@@ -168,6 +197,8 @@ export class AgentManager extends EventEmitter {

    // Note: --parallel was removed from run.py CLI - parallel execution is handled internally by the agent
    // The options.parallel and options.workers are kept for future use or logging purposes
+    // Note: Model configuration is read from task_metadata.json by the Python scripts,
+    // which allows per-phase configuration for planner, coder, and QA phases

    // Store context for potential restart
    this.storeTaskContext(taskId, projectPath, specId, options, false);
@@ -6,9 +6,10 @@ import { EventEmitter } from 'events';
 import { AgentState } from './agent-state';
 import { AgentEvents } from './agent-events';
 import { ProcessType, ExecutionProgressData } from './types';
-import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv } from '../rate-limit-detector';
+import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv, detectAuthFailure } from '../rate-limit-detector';
 import { projectStore } from '../project-store';
 import { getClaudeProfileManager } from '../claude-profile-manager';
+import { findPythonCommand, parsePythonCommand } from '../python-detector';

 /**
 * Process spawning and lifecycle management
@@ -17,7 +18,8 @@ export class AgentProcessManager {
  private state: AgentState;
  private events: AgentEvents;
  private emitter: EventEmitter;
-  private pythonPath: string = 'python3';
+  // Auto-detect Python command on initialization
+  private pythonPath: string = findPythonCommand() || 'python';
  private autoBuildSourcePath: string = '';

  constructor(state: AgentState, events: AgentEvents, emitter: EventEmitter) {
@@ -161,7 +163,9 @@ export class AgentProcessManager {
    // Get active Claude profile environment (CLAUDE_CONFIG_DIR if not default)
    const profileEnv = getProfileEnv();

-    const childProcess = spawn(this.pythonPath, args, {
+    // Parse Python command to handle space-separated commands like "py -3"
+    const [pythonCommand, pythonBaseArgs] = parsePythonCommand(this.pythonPath);
+    const childProcess = spawn(pythonCommand, [...pythonBaseArgs, ...args], {
      cwd,
      env: {
        ...process.env,
@@ -237,6 +241,10 @@ export class AgentProcessManager {
      const log = data.toString('utf8');
      this.emitter.emit('log', taskId, log);
      processLog(log);
+      // Print to console when DEBUG is enabled (visible in pnpm dev terminal)
+      if (['true', '1', 'yes', 'on'].includes(process.env.DEBUG?.toLowerCase() ?? '')) {
+        console.log(`[Agent:${taskId}] ${log.trim()}`);
+      }
    });

    // Handle stderr - explicitly decode as UTF-8 for cross-platform Unicode support
@@ -246,6 +254,10 @@ export class AgentProcessManager {
      // so we treat it as log, not error
      this.emitter.emit('log', taskId, log);
      processLog(log);
+      // Print to console when DEBUG is enabled (visible in pnpm dev terminal)
+      if (['true', '1', 'yes', 'on'].includes(process.env.DEBUG?.toLowerCase() ?? '')) {
+        console.log(`[Agent:${taskId}] ${log.trim()}`);
+      }
    });

    // Handle process exit
@@ -300,6 +312,17 @@ export class AgentProcessManager {
            taskId
          });
          this.emitter.emit('sdk-rate-limit', rateLimitInfo);
+        } else {
+          // Not rate limited - check for authentication failure
+          const authFailureDetection = detectAuthFailure(allOutput);
+          if (authFailureDetection.isAuthFailure) {
+            this.emitter.emit('auth-failure', taskId, {
+              profileId: authFailureDetection.profileId,
+              failureType: authFailureDetection.failureType,
+              message: authFailureDetection.message,
+              originalError: authFailureDetection.originalError
+            });
+          }
        }
      }

@@ -8,6 +8,7 @@ import { AgentProcessManager } from './agent-process';
 import { IdeationConfig } from './types';
 import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv } from '../rate-limit-detector';
 import { debugLog, debugError } from '../../shared/utils/debug-logger';
+import { parsePythonCommand } from '../python-detector';

 /**
 * Queue management for ideation and roadmap generation
@@ -206,7 +207,9 @@ export class AgentQueueManager {
      tokenPreview: hasToken ? oauthToken?.substring(0, 20) + '...' : 'none'
    });

-    const childProcess = spawn(pythonPath, args, {
+    // Parse Python command to handle space-separated commands like "py -3"
+    const [pythonCommand, pythonBaseArgs] = parsePythonCommand(pythonPath);
+    const childProcess = spawn(pythonCommand, [...pythonBaseArgs, ...args], {
      cwd,
      env: finalEnv
    });
@@ -441,7 +444,9 @@ export class AgentQueueManager {
      tokenPreview: hasToken ? oauthToken?.substring(0, 20) + '...' : 'none'
    });

-    const childProcess = spawn(pythonPath, args, {
+    // Parse Python command to handle space-separated commands like "py -3"
+    const [pythonCommand, pythonBaseArgs] = parsePythonCommand(pythonPath);
+    const childProcess = spawn(pythonCommand, [...pythonBaseArgs, ...args], {
      cwd,
      env: finalEnv
    });
@@ -48,6 +48,23 @@ export interface TaskExecutionOptions {

 export interface SpecCreationMetadata {
  requireReviewBeforeCoding?: boolean;
+  // Auto profile - phase-based model and thinking configuration
+  isAutoProfile?: boolean;
+  phaseModels?: {
+    spec: 'haiku' | 'sonnet' | 'opus';
+    planning: 'haiku' | 'sonnet' | 'opus';
+    coding: 'haiku' | 'sonnet' | 'opus';
+    qa: 'haiku' | 'sonnet' | 'opus';
+  };
+  phaseThinking?: {
+    spec: 'none' | 'low' | 'medium' | 'high' | 'ultrathink';
+    planning: 'none' | 'low' | 'medium' | 'high' | 'ultrathink';
+    coding: 'none' | 'low' | 'medium' | 'high' | 'ultrathink';
+    qa: 'none' | 'low' | 'medium' | 'high' | 'ultrathink';
+  };
+  // Non-auto profile - single model and thinking level
+  model?: 'haiku' | 'sonnet' | 'opus';
+  thinkingLevel?: 'none' | 'low' | 'medium' | 'high' | 'ultrathink';
 }

 export interface IdeationProgressData {
@@ -27,7 +27,7 @@ export type {
 } from './updater/types';

 // Export version management
-export { getBundledVersion } from './updater/version-manager';
+export { getBundledVersion, getEffectiveVersion } from './updater/version-manager';

 // Export path resolution
 export {
@@ -27,13 +27,15 @@ import {
  getCommits,
  getBranchDiffCommits
 } from './git-integration';
+import { findPythonCommand } from '../python-detector';

 /**
 * Main changelog service - orchestrates all changelog operations
 * Delegates to specialized modules for specific concerns
 */
 export class ChangelogService extends EventEmitter {
-  private pythonPath: string = 'python3';
+  // Auto-detect Python command on initialization
+  private pythonPath: string = findPythonCommand() || 'python';
  private claudePath: string = 'claude';
  private autoBuildSourcePath: string = '';
  private cachedEnv: Record<string, string> | null = null;
@@ -12,6 +12,7 @@ import { buildChangelogPrompt, buildGitPrompt, createGenerationScript } from './
 import { extractChangelog } from './parser';
 import { getCommits, getBranchDiffCommits } from './git-integration';
 import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv } from '../rate-limit-detector';
+import { parsePythonCommand } from '../python-detector';

 /**
 * Core changelog generation logic
@@ -139,7 +140,9 @@ export class ChangelogGenerator extends EventEmitter {
    // Build environment with explicit critical variables
    const spawnEnv = this.buildSpawnEnvironment();

-    const childProcess = spawn(this.pythonPath, ['-c', script], {
+    // Parse Python command to handle space-separated commands like "py -3"
+    const [pythonCommand, pythonBaseArgs] = parsePythonCommand(this.pythonPath);
+    const childProcess = spawn(pythonCommand, [...pythonBaseArgs, '-c', script], {
      cwd: this.autoBuildSourcePath,
      env: spawnEnv
    });
@@ -3,6 +3,7 @@ import * as path from 'path';
 import * as os from 'os';
 import type { GitCommit } from '../../shared/types';
 import { getProfileEnv } from '../rate-limit-detector';
+import { parsePythonCommand } from '../python-detector';

 interface VersionSuggestion {
  version: string;
@@ -52,7 +53,9 @@ export class VersionSuggester {
    const spawnEnv = this.buildSpawnEnvironment();

    return new Promise((resolve, _reject) => {
-      const childProcess = spawn(this.pythonPath, ['-c', script], {
+      // Parse Python command to handle space-separated commands like "py -3"
+      const [pythonCommand, pythonBaseArgs] = parsePythonCommand(this.pythonPath);
+      const childProcess = spawn(pythonCommand, [...pythonBaseArgs, '-c', script], {
        cwd: this.autoBuildSourcePath,
        env: spawnEnv
      });
@@ -451,6 +451,34 @@ export class ClaudeProfileManager {
    return isProfileAuthenticatedImpl(profile);
  }

+  /**
+   * Check if a profile has valid authentication for starting tasks.
+   * A profile is considered authenticated if:
+   * 1) It has a valid OAuth token (not expired), OR
+   * 2) It has an authenticated configDir (credential files exist)
+   *
+   * @param profileId - Optional profile ID to check. If not provided, checks active profile.
+   * @returns true if the profile can authenticate, false otherwise
+   */
+  hasValidAuth(profileId?: string): boolean {
+    const profile = profileId ? this.getProfile(profileId) : this.getActiveProfile();
+    if (!profile) {
+      return false;
+    }
+
+    // Check 1: Profile has a valid OAuth token
+    if (hasValidToken(profile)) {
+      return true;
+    }
+
+    // Check 2 & 3: Profile has authenticated configDir (works for both default and non-default)
+    if (this.isProfileAuthenticated(profile)) {
+      return true;
+    }
+
+    return false;
+  }
+
  /**
   * Get environment variables for invoking Claude with a specific profile
   */
@@ -2,7 +2,8 @@ import { EventEmitter } from 'events';
 import type {
  InsightsSession,
  InsightsSessionSummary,
-  InsightsChatMessage
+  InsightsChatMessage,
+  InsightsModelConfig
 } from '../shared/types';
 import { InsightsConfig } from './insights/config';
 import { InsightsPaths } from './insights/paths';
@@ -111,7 +112,12 @@ export class InsightsService extends EventEmitter {
  /**
   * Send a message and get AI response
   */
-  async sendMessage(projectId: string, projectPath: string, message: string): Promise<void> {
+  async sendMessage(
+    projectId: string,
+    projectPath: string,
+    message: string,
+    modelConfig?: InsightsModelConfig
+  ): Promise<void> {
    // Cancel any existing session
    this.executor.cancelSession(projectId);

@@ -150,13 +156,17 @@ export class InsightsService extends EventEmitter {
      content: m.content
    }));

+    // Use provided modelConfig or fall back to session's config
+    const configToUse = modelConfig || session.modelConfig;
+
    try {
      // Execute insights query
      const result = await this.executor.execute(
        projectId,
        projectPath,
        message,
-        conversationHistory
+        conversationHistory,
+        configToUse
      );

      // Add assistant message to session
@@ -177,6 +187,13 @@ export class InsightsService extends EventEmitter {
      console.error('[InsightsService] Error executing insights:', error);
    }
  }
+
+  /**
+   * Update model configuration for a session
+   */
+  updateSessionModelConfig(projectPath: string, sessionId: string, modelConfig: InsightsModelConfig): boolean {
+    return this.sessionManager.updateSessionModelConfig(projectPath, sessionId, modelConfig);
+  }
 }

 // Singleton instance
@@ -2,13 +2,15 @@ import path from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { app } from 'electron';
 import { getProfileEnv } from '../rate-limit-detector';
+import { findPythonCommand } from '../python-detector';

 /**
 * Configuration manager for insights service
 * Handles path detection and environment variable loading
 */
 export class InsightsConfig {
-  private pythonPath: string = 'python3';
+  // Auto-detect Python command on initialization
+  private pythonPath: string = findPythonCommand() || 'python';
  private autoBuildSourcePath: string = '';

  /**
@@ -6,8 +6,10 @@ import type {
  InsightsChatMessage,
  InsightsChatStatus,
  InsightsStreamChunk,
-  InsightsToolUsage
+  InsightsToolUsage,
+  InsightsModelConfig
 } from '../../shared/types';
+import { MODEL_ID_MAP } from '../../shared/constants';
 import { InsightsConfig } from './config';
 import { detectRateLimit, createSDKRateLimitInfo } from '../rate-limit-detector';

@@ -59,7 +61,8 @@ export class InsightsExecutor extends EventEmitter {
    projectId: string,
    projectPath: string,
    message: string,
-    conversationHistory: Array<{ role: string; content: string }>
+    conversationHistory: Array<{ role: string; content: string }>,
+    modelConfig?: InsightsModelConfig
  ): Promise<ProcessorResult> {
    // Cancel any existing session
    this.cancelSession(projectId);
@@ -69,7 +72,7 @@ export class InsightsExecutor extends EventEmitter {
      throw new Error('Auto Claude source not found');
    }

-    const runnerPath = path.join(autoBuildSource, 'insights_runner.py');
+    const runnerPath = path.join(autoBuildSource, 'runners', 'insights_runner.py');
    if (!existsSync(runnerPath)) {
      throw new Error('insights_runner.py not found in auto-claude directory');
    }
@@ -83,13 +86,23 @@ export class InsightsExecutor extends EventEmitter {
    // Get process environment
    const processEnv = this.config.getProcessEnv();

-    // Spawn Python process
-    const proc = spawn(this.config.getPythonPath(), [
+    // Build command arguments
+    const args = [
      runnerPath,
      '--project-dir', projectPath,
      '--message', message,
      '--history', JSON.stringify(conversationHistory)
-    ], {
+    ];
+
+    // Add model config if provided
+    if (modelConfig) {
+      const modelId = MODEL_ID_MAP[modelConfig.model] || MODEL_ID_MAP['sonnet'];
+      args.push('--model', modelId);
+      args.push('--thinking-level', modelConfig.thinkingLevel);
+    }
+
+    // Spawn Python process
+    const proc = spawn(this.config.getPythonPath(), args, {
      cwd: autoBuildSource,
      env: processEnv
    });
@@ -1,4 +1,4 @@
-import type { InsightsSession, InsightsSessionSummary } from '../../shared/types';
+import type { InsightsSession, InsightsSessionSummary, InsightsModelConfig } from '../../shared/types';
 import { SessionStorage } from './session-storage';
 import { InsightsPaths } from './paths';

@@ -119,6 +119,30 @@ export class SessionManager {
    return true;
  }

+  /**
+   * Update model configuration for a session
+   */
+  updateSessionModelConfig(projectPath: string, sessionId: string, modelConfig: InsightsModelConfig): boolean {
+    const session = this.storage.loadSessionById(projectPath, sessionId);
+    if (!session) return false;
+
+    session.modelConfig = modelConfig;
+    session.updatedAt = new Date();
+    this.storage.saveSession(projectPath, session);
+
+    // Update cache if this session is cached
+    for (const [projectId, cachedSession] of this.sessions) {
+      if (cachedSession.id === sessionId) {
+        cachedSession.modelConfig = modelConfig;
+        cachedSession.updatedAt = new Date();
+        this.sessions.set(projectId, cachedSession);
+        break;
+      }
+    }
+
+    return true;
+  }
+
  /**
   * Save session to disk and update cache
   */
@@ -5,7 +5,8 @@ import type { IPCResult } from '../../shared/types';
 import path from 'path';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import type { AutoBuildSourceUpdateProgress, SourceEnvConfig, SourceEnvCheckResult } from '../../shared/types';
-import { checkForUpdates as checkSourceUpdates, downloadAndApplyUpdate, getBundledVersion, getEffectiveSourcePath } from '../auto-claude-updater';
+import { checkForUpdates as checkSourceUpdates, downloadAndApplyUpdate, getBundledVersion, getEffectiveVersion, getEffectiveSourcePath } from '../auto-claude-updater';
+import { debugLog } from '../../shared/utils/debug-logger';


 /**
@@ -21,10 +22,16 @@ export function registerAutobuildSourceHandlers(
  ipcMain.handle(
    IPC_CHANNELS.AUTOBUILD_SOURCE_CHECK,
    async (): Promise<IPCResult<{ updateAvailable: boolean; currentVersion: string; latestVersion?: string; releaseNotes?: string; releaseUrl?: string; error?: string }>> => {
+      console.log('[autobuild-source] Check for updates called');
+      debugLog('[IPC] AUTOBUILD_SOURCE_CHECK called');
      try {
        const result = await checkSourceUpdates();
+        console.log('[autobuild-source] Check result:', JSON.stringify(result, null, 2));
+        debugLog('[IPC] AUTOBUILD_SOURCE_CHECK result:', result);
        return { success: true, data: result };
      } catch (error) {
+        console.error('[autobuild-source] Check error:', error);
+        debugLog('[IPC] AUTOBUILD_SOURCE_CHECK error:', error);
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Failed to check for updates'
@@ -36,25 +43,33 @@ export function registerAutobuildSourceHandlers(
  ipcMain.on(
    IPC_CHANNELS.AUTOBUILD_SOURCE_DOWNLOAD,
    () => {
+      debugLog('[IPC] Autobuild source download requested');
      const mainWindow = getMainWindow();
-      if (!mainWindow) return;
+      if (!mainWindow) {
+        debugLog('[IPC] No main window available, aborting update');
+        return;
+      }

      // Start download in background
      downloadAndApplyUpdate((progress) => {
+        debugLog('[IPC] Update progress:', progress.stage, progress.message);
        mainWindow.webContents.send(
          IPC_CHANNELS.AUTOBUILD_SOURCE_PROGRESS,
          progress
        );
      }).then((result) => {
        if (result.success) {
+          debugLog('[IPC] Update completed successfully, version:', result.version);
          mainWindow.webContents.send(
            IPC_CHANNELS.AUTOBUILD_SOURCE_PROGRESS,
            {
              stage: 'complete',
-              message: `Updated to version ${result.version}`
+              message: `Updated to version ${result.version}`,
+              newVersion: result.version // Include new version for UI refresh
            } as AutoBuildSourceUpdateProgress
          );
        } else {
+          debugLog('[IPC] Update failed:', result.error);
          mainWindow.webContents.send(
            IPC_CHANNELS.AUTOBUILD_SOURCE_PROGRESS,
            {
@@ -64,6 +79,7 @@ export function registerAutobuildSourceHandlers(
          );
        }
      }).catch((error) => {
+        debugLog('[IPC] Update error:', error instanceof Error ? error.message : error);
        mainWindow.webContents.send(
          IPC_CHANNELS.AUTOBUILD_SOURCE_PROGRESS,
          {
@@ -88,7 +104,9 @@ export function registerAutobuildSourceHandlers(
    IPC_CHANNELS.AUTOBUILD_SOURCE_VERSION,
    async (): Promise<IPCResult<string>> => {
      try {
-        const version = getBundledVersion();
+        // Use effective version which accounts for source updates
+        const version = getEffectiveVersion();
+        debugLog('[IPC] Returning effective version:', version);
        return { success: true, data: version };
      } catch (error) {
        return {
@@ -62,6 +62,10 @@ export function registerEnvHandlers(
    if (config.githubAutoSync !== undefined) {
      existingVars['GITHUB_AUTO_SYNC'] = config.githubAutoSync ? 'true' : 'false';
    }
+    // Git/Worktree Settings
+    if (config.defaultBranch !== undefined) {
+      existingVars['DEFAULT_BRANCH'] = config.defaultBranch;
+    }
    if (config.graphitiEnabled !== undefined) {
      existingVars['GRAPHITI_ENABLED'] = config.graphitiEnabled ? 'true' : 'false';
    }
@@ -109,6 +113,13 @@ ${existingVars['GITHUB_TOKEN'] ? `GITHUB_TOKEN=${existingVars['GITHUB_TOKEN']}`
 ${existingVars['GITHUB_REPO'] ? `GITHUB_REPO=${existingVars['GITHUB_REPO']}` : '# GITHUB_REPO=owner/repo'}
 ${existingVars['GITHUB_AUTO_SYNC'] !== undefined ? `GITHUB_AUTO_SYNC=${existingVars['GITHUB_AUTO_SYNC']}` : '# GITHUB_AUTO_SYNC=false'}

+# =============================================================================
+# GIT/WORKTREE SETTINGS (OPTIONAL)
+# =============================================================================
+# Default base branch for worktree creation
+# If not set, Auto Claude will auto-detect main/master, or fall back to current branch
+${existingVars['DEFAULT_BRANCH'] ? `DEFAULT_BRANCH=${existingVars['DEFAULT_BRANCH']}` : '# DEFAULT_BRANCH=main'}
+
 # =============================================================================
 # UI SETTINGS (OPTIONAL)
 # =============================================================================
@@ -216,6 +227,11 @@ ${existingVars['GRAPHITI_DATABASE'] ? `GRAPHITI_DATABASE=${existingVars['GRAPHIT
        config.githubAutoSync = true;
      }

+      // Git/Worktree config
+      if (vars['DEFAULT_BRANCH']) {
+        config.defaultBranch = vars['DEFAULT_BRANCH'];
+      }
+
      if (vars['GRAPHITI_ENABLED']?.toLowerCase() === 'true') {
        config.graphitiEnabled = true;
      }
@@ -8,8 +8,8 @@ import type { IPCResult, FileNode } from '../../shared/types';
 const IGNORED_DIRS = new Set([
  'node_modules', '.git', '__pycache__', 'dist', 'build',
  '.next', '.nuxt', 'coverage', '.cache', '.venv', 'venv',
-  '.idea', '.vscode', 'out', '.turbo', '.auto-claude',
-  '.worktrees', 'vendor', 'target', '.gradle', '.maven'
+  'out', '.turbo', '.worktrees',
+  'vendor', 'target', '.gradle', '.maven'
 ]);

 /**
@@ -29,8 +29,11 @@ export function registerFileHandlers(): void {
        // Filter and map entries
        const nodes: FileNode[] = [];
        for (const entry of entries) {
-          // Skip hidden files (except .env which is often useful)
-          if (entry.name.startsWith('.') && entry.name !== '.env') continue;
+          // Skip hidden files (not directories) except useful ones like .env, .gitignore
+          if (!entry.isDirectory() && entry.name.startsWith('.') &&
+              !['.env', '.gitignore', '.env.example', '.env.local'].includes(entry.name)) {
+            continue;
+          }
          // Skip ignored directories
          if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue;

@@ -6,7 +6,7 @@ import { ipcMain } from 'electron';
 import { IPC_CHANNELS } from '../../../shared/constants';
 import type { IPCResult, GitHubIssue } from '../../../shared/types';
 import { projectStore } from '../../project-store';
-import { getGitHubConfig, githubFetch } from './utils';
+import { getGitHubConfig, githubFetch, normalizeRepoReference } from './utils';
 import type { GitHubAPIIssue, GitHubAPIComment } from './types';

 /**
@@ -57,16 +57,32 @@ export function registerGetIssues(): void {
      }

      try {
+        const normalizedRepo = normalizeRepoReference(config.repo);
+        if (!normalizedRepo) {
+          return {
+            success: false,
+            error: 'Invalid repository format. Use owner/repo or GitHub URL.'
+          };
+        }
+
        const issues = await githubFetch(
          config.token,
-          `/repos/${config.repo}/issues?state=${state}&per_page=100&sort=updated`
-        ) as GitHubAPIIssue[];
+          `/repos/${normalizedRepo}/issues?state=${state}&per_page=100&sort=updated`
+        );
+
+        // Ensure issues is an array
+        if (!Array.isArray(issues)) {
+          return {
+            success: false,
+            error: 'Unexpected response format from GitHub API'
+          };
+        }

        // Filter out pull requests
-        const issuesOnly = issues.filter(issue => !issue.pull_request);
+        const issuesOnly = issues.filter((issue: GitHubAPIIssue) => !issue.pull_request);

-        const result: GitHubIssue[] = issuesOnly.map(issue =>
-          transformIssue(issue, config.repo)
+        const result: GitHubIssue[] = issuesOnly.map((issue: GitHubAPIIssue) =>
+          transformIssue(issue, normalizedRepo)
        );

        return { success: true, data: result };
@@ -98,12 +114,20 @@ export function registerGetIssue(): void {
      }

      try {
+        const normalizedRepo = normalizeRepoReference(config.repo);
+        if (!normalizedRepo) {
+          return {
+            success: false,
+            error: 'Invalid repository format. Use owner/repo or GitHub URL.'
+          };
+        }
+
        const issue = await githubFetch(
          config.token,
-          `/repos/${config.repo}/issues/${issueNumber}`
+          `/repos/${normalizedRepo}/issues/${issueNumber}`
        ) as GitHubAPIIssue;

-        const result = transformIssue(issue, config.repo);
+        const result = transformIssue(issue, normalizedRepo);

        return { success: true, data: result };
      } catch (error) {
@@ -134,9 +158,17 @@ export function registerGetIssueComments(): void {
      }

      try {
+        const normalizedRepo = normalizeRepoReference(config.repo);
+        if (!normalizedRepo) {
+          return {
+            success: false,
+            error: 'Invalid repository format. Use owner/repo or GitHub URL.'
+          };
+        }
+
        const comments = await githubFetch(
          config.token,
-          `/repos/${config.repo}/issues/${issueNumber}/comments`
+          `/repos/${normalizedRepo}/issues/${issueNumber}/comments`
        ) as GitHubAPIComment[];

        return { success: true, data: comments };
@@ -4,7 +4,7 @@
 */

 import { ipcMain } from 'electron';
-import { execSync, spawn } from 'child_process';
+import { execSync, execFileSync, spawn } from 'child_process';
 import { IPC_CHANNELS } from '../../../shared/constants';
 import type { IPCResult } from '../../../shared/types';

@@ -21,6 +21,18 @@ function debugLog(message: string, data?: unknown): void {
  }
 }

+// Regex pattern to validate GitHub repository format (owner/repo)
+// Allows alphanumeric characters, hyphens, underscores, and periods
+const GITHUB_REPO_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+
+/**
+ * Validate that a repository string matches the expected owner/repo format
+ * Prevents command injection by rejecting strings with shell metacharacters
+ */
+function isValidGitHubRepo(repo: string): boolean {
+  return GITHUB_REPO_PATTERN.test(repo);
+}
+
 /**
 * Check if gh CLI is installed
 */
@@ -296,6 +308,106 @@ export function registerListUserRepos(): void {
  );
 }

+/**
+ * Detect GitHub repository from git remote origin
+ */
+export function registerDetectGitHubRepo(): void {
+  ipcMain.handle(
+    IPC_CHANNELS.GITHUB_DETECT_REPO,
+    async (_event: Electron.IpcMainInvokeEvent, projectPath: string): Promise<IPCResult<string>> => {
+      debugLog('detectGitHubRepo handler called', { projectPath });
+      try {
+        // Get the remote URL
+        debugLog('Running: git remote get-url origin');
+        const remoteUrl = execSync('git remote get-url origin', {
+          encoding: 'utf-8',
+          cwd: projectPath,
+          stdio: 'pipe'
+        }).trim();
+
+        debugLog('Remote URL:', remoteUrl);
+
+        // Parse GitHub repo from URL
+        // Formats:
+        // - https://github.com/owner/repo.git
+        // - git@github.com:owner/repo.git
+        // - https://github.com/owner/repo
+        const match = remoteUrl.match(/github\.com[/:]([^/]+\/[^/]+?)(?:\.git)?$/);
+        if (match) {
+          const repo = match[1];
+          debugLog('Detected repo:', repo);
+          return {
+            success: true,
+            data: repo
+          };
+        }
+
+        debugLog('Could not parse GitHub repo from URL');
+        return {
+          success: false,
+          error: 'Remote URL is not a GitHub repository'
+        };
+      } catch (error) {
+        debugLog('Failed to detect repo:', error instanceof Error ? error.message : error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Failed to detect GitHub repository'
+        };
+      }
+    }
+  );
+}
+
+/**
+ * Get branches from GitHub repository
+ */
+export function registerGetGitHubBranches(): void {
+  ipcMain.handle(
+    IPC_CHANNELS.GITHUB_GET_BRANCHES,
+    async (_event: Electron.IpcMainInvokeEvent, repo: string, _token: string): Promise<IPCResult<string[]>> => {
+      debugLog('getGitHubBranches handler called', { repo });
+      
+      // Validate repo format to prevent command injection
+      if (!isValidGitHubRepo(repo)) {
+        debugLog('Invalid repo format rejected:', repo);
+        return {
+          success: false,
+          error: 'Invalid repository format. Expected: owner/repo'
+        };
+      }
+      
+      try {
+        // Use gh CLI to list branches (uses authenticated session)
+        // Use execFileSync with separate arguments to avoid shell injection
+        const apiEndpoint = `repos/${repo}/branches`;
+        debugLog(`Running: gh api ${apiEndpoint} --paginate --jq '.[].name'`);
+        const output = execFileSync(
+          'gh',
+          ['api', apiEndpoint, '--paginate', '--jq', '.[].name'],
+          {
+            encoding: 'utf-8',
+            stdio: 'pipe'
+          }
+        );
+
+        const branches = output.trim().split('\n').filter(b => b.length > 0);
+        debugLog('Found branches:', branches.length);
+
+        return {
+          success: true,
+          data: branches
+        };
+      } catch (error) {
+        debugLog('Failed to get branches:', error instanceof Error ? error.message : error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : 'Failed to get branches'
+        };
+      }
+    }
+  );
+}
+
 /**
 * Register all GitHub OAuth handlers
 */
@@ -307,5 +419,7 @@ export function registerGithubOAuthHandlers(): void {
  registerGetGhToken();
  registerGetGhUser();
  registerListUserRepos();
+  registerDetectGitHubRepo();
+  registerGetGitHubBranches();
  debugLog('GitHub OAuth handlers registered');
 }
@@ -6,7 +6,7 @@ import { ipcMain } from 'electron';
 import { IPC_CHANNELS } from '../../../shared/constants';
 import type { IPCResult, GitHubRepository, GitHubSyncStatus } from '../../../shared/types';
 import { projectStore } from '../../project-store';
-import { getGitHubConfig, githubFetch } from './utils';
+import { getGitHubConfig, githubFetch, normalizeRepoReference } from './utils';
 import type { GitHubAPIRepository } from './types';

 /**
@@ -33,16 +33,28 @@ export function registerCheckConnection(): void {
      }

      try {
+        // Normalize repo reference (handles full URLs, git URLs, etc.)
+        const normalizedRepo = normalizeRepoReference(config.repo);
+        if (!normalizedRepo) {
+          return {
+            success: true,
+            data: {
+              connected: false,
+              error: 'Invalid repository format. Use owner/repo or GitHub URL.'
+            }
+          };
+        }
+
        // Fetch repo info
        const repoData = await githubFetch(
          config.token,
-          `/repos/${config.repo}`
+          `/repos/${normalizedRepo}`
        ) as { full_name: string; description?: string };

        // Count open issues
        const issuesData = await githubFetch(
          config.token,
-          `/repos/${config.repo}/issues?state=open&per_page=1`
+          `/repos/${normalizedRepo}/issues?state=open&per_page=1`
        ) as unknown[];

        const openCount = Array.isArray(issuesData) ? issuesData.length : 0;
@@ -71,7 +83,7 @@ export function registerCheckConnection(): void {
 }

 /**
- * Get list of GitHub repositories
+ * Get list of GitHub repositories (personal + organization)
 */
 export function registerGetRepositories(): void {
  ipcMain.handle(
@@ -88,9 +100,11 @@ export function registerGetRepositories(): void {
      }

      try {
+        // Fetch user's personal + organization repos
+        // affiliation parameter includes: owner, collaborator, organization_member
        const repos = await githubFetch(
          config.token,
-          '/user/repos?per_page=100&sort=updated'
+          '/user/repos?per_page=100&sort=updated&affiliation=owner,collaborator,organization_member'
        ) as GitHubAPIRepository[];

        const result: GitHubRepository[] = repos.map(repo => ({
@@ -54,6 +54,32 @@ export function getGitHubConfig(project: Project): GitHubConfig | null {
  }
 }

+/**
+ * Normalize a GitHub repository reference to owner/repo format
+ * Handles:
+ * - owner/repo (already normalized)
+ * - https://github.com/owner/repo
+ * - https://github.com/owner/repo.git
+ * - git@github.com:owner/repo.git
+ */
+export function normalizeRepoReference(repo: string): string {
+  if (!repo) return '';
+
+  // Remove trailing .git if present
+  let normalized = repo.replace(/\.git$/, '');
+
+  // Handle full GitHub URLs
+  if (normalized.startsWith('https://github.com/')) {
+    normalized = normalized.replace('https://github.com/', '');
+  } else if (normalized.startsWith('http://github.com/')) {
+    normalized = normalized.replace('http://github.com/', '');
+  } else if (normalized.startsWith('git@github.com:')) {
+    normalized = normalized.replace('git@github.com:', '');
+  }
+
+  return normalized.trim();
+}
+
 /**
 * Make a request to the GitHub API
 */
@@ -3,7 +3,7 @@ import type { BrowserWindow } from 'electron';
 import path from 'path';
 import { existsSync, readdirSync, mkdirSync, writeFileSync } from 'fs';
 import { IPC_CHANNELS, getSpecsDir, AUTO_BUILD_PATHS } from '../../shared/constants';
-import type { IPCResult, InsightsSession, InsightsSessionSummary, Task, TaskMetadata } from '../../shared/types';
+import type { IPCResult, InsightsSession, InsightsSessionSummary, InsightsModelConfig, Task, TaskMetadata } from '../../shared/types';
 import { projectStore } from '../project-store';
 import { insightsService } from '../insights-service';

@@ -32,7 +32,7 @@ export function registerInsightsHandlers(

  ipcMain.on(
    IPC_CHANNELS.INSIGHTS_SEND_MESSAGE,
-    async (_, projectId: string, message: string) => {
+    async (_, projectId: string, message: string, modelConfig?: InsightsModelConfig) => {
      const project = projectStore.getProject(projectId);
      if (!project) {
        const mainWindow = getMainWindow();
@@ -44,7 +44,7 @@ export function registerInsightsHandlers(

      // Note: Python environment initialization should be handled by insightsService
      // or added here with proper dependency injection if needed
-      insightsService.sendMessage(projectId, project.path, message);
+      insightsService.sendMessage(projectId, project.path, message, modelConfig);
    }
  );

@@ -241,4 +241,57 @@ export function registerInsightsHandlers(
    }
  );

+  // Update model configuration for a session
+  ipcMain.handle(
+    IPC_CHANNELS.INSIGHTS_UPDATE_MODEL_CONFIG,
+    async (_, projectId: string, sessionId: string, modelConfig: InsightsModelConfig): Promise<IPCResult> => {
+      const project = projectStore.getProject(projectId);
+      if (!project) {
+        return { success: false, error: 'Project not found' };
+      }
+
+      const success = insightsService.updateSessionModelConfig(project.path, sessionId, modelConfig);
+      if (success) {
+        return { success: true };
+      }
+      return { success: false, error: 'Failed to update model configuration' };
+    }
+  );
+
+  // ============================================
+  // Insights Event Forwarding (Service -> Renderer)
+  // ============================================
+
+  // Forward streaming chunks to renderer
+  insightsService.on('stream-chunk', (projectId: string, chunk: unknown) => {
+    const mainWindow = getMainWindow();
+    if (mainWindow) {
+      mainWindow.webContents.send(IPC_CHANNELS.INSIGHTS_STREAM_CHUNK, projectId, chunk);
+    }
+  });
+
+  // Forward status updates to renderer
+  insightsService.on('status', (projectId: string, status: unknown) => {
+    const mainWindow = getMainWindow();
+    if (mainWindow) {
+      mainWindow.webContents.send(IPC_CHANNELS.INSIGHTS_STATUS, projectId, status);
+    }
+  });
+
+  // Forward errors to renderer
+  insightsService.on('error', (projectId: string, error: string) => {
+    const mainWindow = getMainWindow();
+    if (mainWindow) {
+      mainWindow.webContents.send(IPC_CHANNELS.INSIGHTS_ERROR, projectId, error);
+    }
+  });
+
+  // Forward SDK rate limit events to renderer
+  insightsService.on('sdk-rate-limit', (rateLimitInfo: unknown) => {
+    const mainWindow = getMainWindow();
+    if (mainWindow) {
+      mainWindow.webContents.send(IPC_CHANNELS.CLAUDE_SDK_RATE_LIMIT, rateLimitInfo);
+    }
+  });
+
 }
@@ -50,7 +50,7 @@ export function registerLinearHandlers(
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
-        'Authorization': apiKey
+        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify({ query, variables })
    });
@@ -160,6 +160,16 @@ export function registerRoadmapHandlers(
    }
  );

+  // Get roadmap generation status - allows frontend to query if generation is running
+  ipcMain.handle(
+    IPC_CHANNELS.ROADMAP_GET_STATUS,
+    async (_, projectId: string): Promise<IPCResult<{ isRunning: boolean }>> => {
+      const isRunning = agentManager.isRoadmapRunning(projectId);
+      debugLog('[Roadmap Handler] Get status:', { projectId, isRunning });
+      return { success: true, data: { isRunning } };
+    }
+  );
+
  ipcMain.on(
    IPC_CHANNELS.ROADMAP_GENERATE,
    (_, projectId: string, enableCompetitorAnalysis?: boolean) => {
@@ -10,6 +10,7 @@ import type {
 } from '../../shared/types';
 import { AgentManager } from '../agent';
 import type { BrowserWindow } from 'electron';
+import { getEffectiveVersion } from '../auto-claude-updater';

 const settingsPath = path.join(app.getPath('userData'), 'settings.json');

@@ -264,7 +265,10 @@ export function registerSettingsHandlers(
  // ============================================

  ipcMain.handle(IPC_CHANNELS.APP_VERSION, async (): Promise<string> => {
-    return app.getVersion();
+    // Use effective version which accounts for source updates
+    const version = getEffectiveVersion();
+    console.log('[settings-handlers] APP_VERSION returning:', version);
+    return version;
  });

  // ============================================
@@ -3,10 +3,12 @@ import { IPC_CHANNELS, AUTO_BUILD_PATHS, getSpecsDir } from '../../../shared/con
 import type { IPCResult, TaskStartOptions, TaskStatus } from '../../../shared/types';
 import path from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { spawnSync } from 'child_process';
 import { AgentManager } from '../../agent';
 import { fileWatcher } from '../../file-watcher';
 import { findTaskAndProject } from './shared';
 import { checkGitStatus } from '../../project-initializer';
+import { getClaudeProfileManager } from '../../claude-profile-manager';

 /**
 * Register task execution handlers (start, stop, review, status management, recovery)
@@ -62,6 +64,18 @@ export function registerTaskExecutionHandlers(
        return;
      }

+      // Check authentication - Claude requires valid auth to run tasks
+      const profileManager = getClaudeProfileManager();
+      if (!profileManager.hasValidAuth()) {
+        console.warn('[TASK_START] No valid authentication for active profile');
+        mainWindow.webContents.send(
+          IPC_CHANNELS.TASK_ERROR,
+          taskId,
+          'Claude authentication required. Please go to Settings > Claude Profiles and authenticate your account, or set an OAuth token.'
+        );
+        return;
+      }
+
      console.warn('[TASK_START] Found task:', task.specId, 'status:', task.status, 'subtasks:', task.subtasks.length);

      // Start file watcher for this task
@@ -187,6 +201,11 @@ export function registerTaskExecutionHandlers(
        task.specId
      );

+      // Check if worktree exists - QA needs to run in the worktree where the build happened
+      const worktreePath = path.join(project.path, '.worktrees', task.specId);
+      const worktreeSpecDir = path.join(worktreePath, specsBaseDir, task.specId);
+      const hasWorktree = existsSync(worktreePath);
+
      if (approved) {
        // Write approval to QA report
        const qaReportPath = path.join(specDir, AUTO_BUILD_PATHS.QA_REPORT);
@@ -204,15 +223,60 @@ export function registerTaskExecutionHandlers(
          );
        }
      } else {
-        // Write feedback for QA fixer
-        const fixRequestPath = path.join(specDir, 'QA_FIX_REQUEST.md');
+        // Reset and discard all changes from worktree merge in main
+        // The worktree still has all changes, so nothing is lost
+        if (hasWorktree) {
+          // Step 1: Unstage all changes
+          const resetResult = spawnSync('git', ['reset', 'HEAD'], {
+            cwd: project.path,
+            encoding: 'utf-8',
+            stdio: 'pipe'
+          });
+          if (resetResult.status === 0) {
+            console.log('[TASK_REVIEW] Unstaged changes in main');
+          }
+
+          // Step 2: Discard all working tree changes (restore to pre-merge state)
+          const checkoutResult = spawnSync('git', ['checkout', '--', '.'], {
+            cwd: project.path,
+            encoding: 'utf-8',
+            stdio: 'pipe'
+          });
+          if (checkoutResult.status === 0) {
+            console.log('[TASK_REVIEW] Discarded working tree changes in main');
+          }
+
+          // Step 3: Clean untracked files that came from the merge
+          const cleanResult = spawnSync('git', ['clean', '-fd'], {
+            cwd: project.path,
+            encoding: 'utf-8',
+            stdio: 'pipe'
+          });
+          if (cleanResult.status === 0) {
+            console.log('[TASK_REVIEW] Cleaned untracked files in main');
+          }
+
+          console.log('[TASK_REVIEW] Main branch restored to pre-merge state');
+        }
+
+        // Write feedback for QA fixer - write to WORKTREE spec dir if it exists
+        // The QA process runs in the worktree where the build and implementation_plan.json are
+        const targetSpecDir = hasWorktree ? worktreeSpecDir : specDir;
+        const fixRequestPath = path.join(targetSpecDir, 'QA_FIX_REQUEST.md');
+
+        console.warn('[TASK_REVIEW] Writing QA fix request to:', fixRequestPath);
+        console.warn('[TASK_REVIEW] hasWorktree:', hasWorktree, 'worktreePath:', worktreePath);
+
        writeFileSync(
          fixRequestPath,
          `# QA Fix Request\n\nStatus: REJECTED\n\n## Feedback\n\n${feedback || 'No feedback provided'}\n\nCreated at: ${new Date().toISOString()}\n`
        );

-        // Restart QA process with dev mode
-        agentManager.startQAProcess(taskId, project.path, task.specId);
+        // Restart QA process - use worktree path if it exists, otherwise main project
+        // The QA process needs to run where the implementation_plan.json with completed subtasks is
+        const qaProjectPath = hasWorktree ? worktreePath : project.path;
+        console.warn('[TASK_REVIEW] Starting QA process with projectPath:', qaProjectPath);
+        agentManager.startQAProcess(taskId, qaProjectPath, task.specId);

        const mainWindow = getMainWindow();
        if (mainWindow) {
@@ -265,6 +329,37 @@ export function registerTaskExecutionHandlers(
        }
      }

+      // Validate status transition - 'human_review' requires actual work to have been done
+      // This prevents tasks from being incorrectly marked as ready for review when execution failed
+      if (status === 'human_review') {
+        const specsBaseDirForValidation = getSpecsDir(project.autoBuildPath);
+        const specDirForValidation = path.join(
+          project.path,
+          specsBaseDirForValidation,
+          task.specId
+        );
+        const specFilePath = path.join(specDirForValidation, AUTO_BUILD_PATHS.SPEC_FILE);
+
+        // Check if spec.md exists and has meaningful content (at least 100 chars)
+        const MIN_SPEC_CONTENT_LENGTH = 100;
+        let specContent = '';
+        try {
+          if (existsSync(specFilePath)) {
+            specContent = readFileSync(specFilePath, 'utf-8');
+          }
+        } catch {
+          // Ignore read errors - treat as empty spec
+        }
+
+        if (!specContent || specContent.length < MIN_SPEC_CONTENT_LENGTH) {
+          console.warn(`[TASK_UPDATE_STATUS] Blocked attempt to set status 'human_review' for task ${taskId}. No spec has been created yet.`);
+          return {
+            success: false,
+            error: "Cannot move to human review - no spec has been created yet. The task must complete processing before review."
+          };
+        }
+      }
+
      // Get the spec directory
      const specsBaseDir = getSpecsDir(project.autoBuildPath);
      const specDir = path.join(
@@ -334,6 +429,20 @@ export function registerTaskExecutionHandlers(
            return { success: false, error: gitStatusCheck.error || 'Git repository required' };
          }

+          // Check authentication before auto-starting
+          const profileManager = getClaudeProfileManager();
+          if (!profileManager.hasValidAuth()) {
+            console.warn('[TASK_UPDATE_STATUS] No valid authentication for active profile');
+            if (mainWindow) {
+              mainWindow.webContents.send(
+                IPC_CHANNELS.TASK_ERROR,
+                taskId,
+                'Claude authentication required. Please go to Settings > Claude Profiles and authenticate your account, or set an OAuth token.'
+              );
+            }
+            return { success: false, error: 'Claude authentication required' };
+          }
+
          console.warn('[TASK_UPDATE_STATUS] Auto-starting task:', taskId);

          // Start file watcher for this task
@@ -562,6 +671,23 @@ export function registerTaskExecutionHandlers(
            };
          }

+          // Check authentication before auto-restarting
+          const profileManager = getClaudeProfileManager();
+          if (!profileManager.hasValidAuth()) {
+            console.warn('[Recovery] Auth check failed, cannot auto-restart task');
+            // Recovery succeeded but we can't restart without auth
+            return {
+              success: true,
+              data: {
+                taskId,
+                recovered: true,
+                newStatus,
+                message: 'Task recovered but cannot restart: Claude authentication required. Please go to Settings > Claude Profiles and authenticate your account.',
+                autoRestarted: false
+              }
+            };
+          }
+
          try {
            // Set status to in_progress for the restart
            newStatus = 'in_progress';
@@ -3,12 +3,13 @@ import { IPC_CHANNELS, AUTO_BUILD_PATHS } from '../../../shared/constants';
 import type { IPCResult, WorktreeStatus, WorktreeDiff, WorktreeDiffFile, WorktreeMergeResult, WorktreeDiscardResult, WorktreeListResult, WorktreeListItem } from '../../../shared/types';
 import path from 'path';
 import { existsSync, readdirSync, statSync } from 'fs';
-import { execSync, spawn } from 'child_process';
+import { execSync, spawn, spawnSync } from 'child_process';
 import { projectStore } from '../../project-store';
 import { PythonEnvManager } from '../../python-env-manager';
 import { getEffectiveSourcePath } from '../../auto-claude-updater';
 import { getProfileEnv } from '../../rate-limit-detector';
 import { findTaskAndProject } from './shared';
+import { findPythonCommand, parsePythonCommand } from '../../python-detector';

 /**
 * Register worktree management handlers
@@ -272,6 +273,31 @@ export function registerWorktreeHandlers(
        const worktreePath = path.join(project.path, '.worktrees', task.specId);
        debug('Worktree path:', worktreePath, 'exists:', existsSync(worktreePath));

+        // Check if changes are already staged (for stage-only mode)
+        if (options?.noCommit) {
+          const stagedResult = spawnSync('git', ['diff', '--staged', '--name-only'], {
+            cwd: project.path,
+            encoding: 'utf-8'
+          });
+
+          if (stagedResult.status === 0 && stagedResult.stdout?.trim()) {
+            const stagedFiles = stagedResult.stdout.trim().split('\n');
+            debug('Changes already staged:', stagedFiles.length, 'files');
+            // Return success - changes are already staged
+            return {
+              success: true,
+              data: {
+                success: true,
+                merged: false,
+                message: `Changes already staged (${stagedFiles.length} files). Review with git diff --staged.`,
+                staged: true,
+                alreadyStaged: true,
+                projectPath: project.path
+              }
+            };
+          }
+        }
+
        // Get git status before merge
        try {
          const gitStatusBefore = execSync('git status --short', { cwd: project.path, encoding: 'utf-8' });
@@ -294,7 +320,7 @@ export function registerWorktreeHandlers(
          args.push('--no-commit');
        }

-        const pythonPath = pythonEnvManager.getPythonPath() || 'python3';
+        const pythonPath = pythonEnvManager.getPythonPath() || findPythonCommand() || 'python';
        debug('Running command:', pythonPath, args.join(' '));
        debug('Working directory:', sourcePath);

@@ -310,7 +336,9 @@ export function registerWorktreeHandlers(
          let timeoutId: NodeJS.Timeout | null = null;
          let resolved = false;

-          const mergeProcess = spawn(pythonPath, args, {
+          // Parse Python command to handle space-separated commands like "py -3"
+          const [pythonCommand, pythonBaseArgs] = parsePythonCommand(pythonPath);
+          const mergeProcess = spawn(pythonCommand, [...pythonBaseArgs, ...args], {
            cwd: sourcePath,
            env: {
              ...process.env,
@@ -402,12 +430,75 @@ export function registerWorktreeHandlers(
            if (code === 0) {
              const isStageOnly = options?.noCommit === true;

-              // For stage-only: keep in human_review so user commits manually
-              // For full merge: mark as done
-              const newStatus = isStageOnly ? 'human_review' : 'done';
-              const planStatus = isStageOnly ? 'review' : 'completed';
+              // Verify changes were actually staged when stage-only mode is requested
+              // This prevents false positives when merge was already committed previously
+              let hasActualStagedChanges = false;
+              let mergeAlreadyCommitted = false;

-              debug('Merge successful. isStageOnly:', isStageOnly, 'newStatus:', newStatus);
+              if (isStageOnly) {
+                try {
+                  const gitDiffStaged = execSync('git diff --staged --stat', { cwd: project.path, encoding: 'utf-8' });
+                  hasActualStagedChanges = gitDiffStaged.trim().length > 0;
+                  debug('Stage-only verification: hasActualStagedChanges:', hasActualStagedChanges);
+
+                  if (!hasActualStagedChanges) {
+                    // Check if worktree branch was already merged (merge commit exists)
+                    const specBranch = `auto-claude/${task.specId}`;
+                    try {
+                      // Check if current branch contains all commits from spec branch
+                      const mergeBaseResult = execSync(
+                        `git merge-base --is-ancestor ${specBranch} HEAD 2>/dev/null && echo "merged" || echo "not-merged"`,
+                        { cwd: project.path, encoding: 'utf-8' }
+                      ).trim();
+                      mergeAlreadyCommitted = mergeBaseResult === 'merged';
+                      debug('Merge already committed check:', mergeAlreadyCommitted);
+                    } catch {
+                      // Branch may not exist or other error - assume not merged
+                      debug('Could not check merge status, assuming not merged');
+                    }
+                  }
+                } catch (e) {
+                  debug('Failed to verify staged changes:', e);
+                }
+              }
+
+              // Determine actual status based on verification
+              let newStatus: string;
+              let planStatus: string;
+              let message: string;
+              let staged: boolean;
+
+              if (isStageOnly && !hasActualStagedChanges && mergeAlreadyCommitted) {
+                // Stage-only was requested but merge was already committed previously
+                // Mark as done since changes are already in the branch
+                newStatus = 'done';
+                planStatus = 'completed';
+                message = 'Changes were already merged and committed. Task marked as done.';
+                staged = false;
+                debug('Stage-only requested but merge already committed. Marking as done.');
+              } else if (isStageOnly && !hasActualStagedChanges) {
+                // Stage-only was requested but no changes to stage (and not committed)
+                // This could mean nothing to merge or an error - keep in human_review for investigation
+                newStatus = 'human_review';
+                planStatus = 'review';
+                message = 'No changes to stage. The worktree may have no differences from the current branch.';
+                staged = false;
+                debug('Stage-only requested but no changes to stage.');
+              } else if (isStageOnly) {
+                // Stage-only with actual staged changes - expected success case
+                newStatus = 'human_review';
+                planStatus = 'review';
+                message = 'Changes staged in main project. Review with git status and commit when ready.';
+                staged = true;
+              } else {
+                // Full merge (not stage-only)
+                newStatus = 'done';
+                planStatus = 'completed';
+                message = 'Changes merged successfully';
+                staged = false;
+              }
+
+              debug('Merge result. isStageOnly:', isStageOnly, 'newStatus:', newStatus, 'staged:', staged);

              // Persist the status change to implementation_plan.json
              const planPath = path.join(specDir, AUTO_BUILD_PATHS.IMPLEMENTATION_PLAN);
@@ -419,7 +510,7 @@ export function registerWorktreeHandlers(
                  plan.status = newStatus;
                  plan.planStatus = planStatus;
                  plan.updated_at = new Date().toISOString();
-                  if (isStageOnly) {
+                  if (staged) {
                    plan.stagedAt = new Date().toISOString();
                    plan.stagedInMainProject = true;
                  }
@@ -434,17 +525,13 @@ export function registerWorktreeHandlers(
                mainWindow.webContents.send(IPC_CHANNELS.TASK_STATUS_CHANGE, taskId, newStatus);
              }

-              const message = isStageOnly
-                ? 'Changes staged in main project. Review with git status and commit when ready.'
-                : 'Changes merged successfully';
-
              resolve({
                success: true,
                data: {
                  success: true,
                  message,
-                  staged: isStageOnly,
-                  projectPath: isStageOnly ? project.path : undefined
+                  staged,
+                  projectPath: staged ? project.path : undefined
                }
              });
            } else {
@@ -563,14 +650,16 @@ export function registerWorktreeHandlers(
          '--merge-preview'
        ];

-        const pythonPath = pythonEnvManager.getPythonPath() || 'python3';
+        const pythonPath = pythonEnvManager.getPythonPath() || findPythonCommand() || 'python';
        console.warn('[IPC] Running merge preview:', pythonPath, args.join(' '));

        // Get profile environment for consistency
        const previewProfileEnv = getProfileEnv();

        return new Promise((resolve) => {
-          const previewProcess = spawn(pythonPath, args, {
+          // Parse Python command to handle space-separated commands like "py -3"
+          const [pythonCommand, pythonBaseArgs] = parsePythonCommand(pythonPath);
+          const previewProcess = spawn(pythonCommand, [...pythonBaseArgs, ...args], {
            cwd: sourcePath,
            env: { ...process.env, ...previewProfileEnv, PYTHONUNBUFFERED: '1', PYTHONIOENCODING: 'utf-8', PYTHONUTF8: '1', DEBUG: 'true' }
          });
@@ -7,6 +7,8 @@ import { getUsageMonitor } from '../claude-profile/usage-monitor';
 import { TerminalManager } from '../terminal-manager';
 import { projectStore } from '../project-store';
 import { terminalNameGenerator } from '../terminal-name-generator';
+import { debugLog, debugError } from '../../shared/utils/debug-logger';
+import { escapeShellArg } from '../../shared/utils/shell-escape';


 /**
@@ -162,14 +164,108 @@ export function registerTerminalHandlers(
  ipcMain.handle(
    IPC_CHANNELS.CLAUDE_PROFILE_SET_ACTIVE,
    async (_, profileId: string): Promise<IPCResult> => {
+      debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] ========== PROFILE SWITCH START ==========');
+      debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Requested profile ID:', profileId);
+
      try {
        const profileManager = getClaudeProfileManager();
+        const previousProfile = profileManager.getActiveProfile();
+        const previousProfileId = previousProfile.id;
+        const newProfile = profileManager.getProfile(profileId);
+
+        debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Previous profile:', {
+          id: previousProfile.id,
+          name: previousProfile.name,
+          hasOAuthToken: !!previousProfile.oauthToken,
+          isDefault: previousProfile.isDefault
+        });
+
+        debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] New profile:', newProfile ? {
+          id: newProfile.id,
+          name: newProfile.name,
+          hasOAuthToken: !!newProfile.oauthToken,
+          isDefault: newProfile.isDefault
+        } : 'NOT FOUND');
+
        const success = profileManager.setActiveProfile(profileId);
+        debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] setActiveProfile result:', success);
+
        if (!success) {
+          debugError('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Profile not found, aborting');
          return { success: false, error: 'Profile not found' };
        }
+
+        // If the profile actually changed, restart Claude in active terminals
+        // This ensures existing Claude sessions use the new profile's OAuth token
+        const profileChanged = previousProfileId !== profileId;
+        debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Profile changed:', profileChanged, {
+          previousProfileId,
+          newProfileId: profileId
+        });
+
+        if (profileChanged) {
+          const activeTerminalIds = terminalManager.getActiveTerminalIds();
+          debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Active terminal IDs:', activeTerminalIds);
+
+          const switchPromises: Promise<void>[] = [];
+          const terminalsInClaudeMode: string[] = [];
+          const terminalsNotInClaudeMode: string[] = [];
+
+          for (const terminalId of activeTerminalIds) {
+            const isClaudeMode = terminalManager.isClaudeMode(terminalId);
+            debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Terminal check:', {
+              terminalId,
+              isClaudeMode
+            });
+
+            if (isClaudeMode) {
+              terminalsInClaudeMode.push(terminalId);
+              debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Queuing terminal for profile switch:', terminalId);
+              switchPromises.push(
+                terminalManager.switchClaudeProfile(terminalId, profileId)
+                  .then(() => {
+                    debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Terminal profile switch SUCCESS:', terminalId);
+                  })
+                  .catch((err) => {
+                    debugError('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Terminal profile switch FAILED:', terminalId, err);
+                    throw err; // Re-throw so Promise.allSettled correctly reports rejections
+                  })
+              );
+            } else {
+              terminalsNotInClaudeMode.push(terminalId);
+            }
+          }
+
+          debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Terminal summary:', {
+            total: activeTerminalIds.length,
+            inClaudeMode: terminalsInClaudeMode.length,
+            notInClaudeMode: terminalsNotInClaudeMode.length,
+            terminalsToSwitch: terminalsInClaudeMode,
+            terminalsSkipped: terminalsNotInClaudeMode
+          });
+
+          // Wait for all switches to complete (but don't fail the main operation if some fail)
+          if (switchPromises.length > 0) {
+            debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Waiting for', switchPromises.length, 'terminal switches...');
+            const results = await Promise.allSettled(switchPromises);
+            const fulfilled = results.filter(r => r.status === 'fulfilled').length;
+            const rejected = results.filter(r => r.status === 'rejected').length;
+            debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Switch results:', {
+              total: results.length,
+              fulfilled,
+              rejected
+            });
+          } else {
+            debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] No terminals in Claude mode to switch');
+          }
+        } else {
+          debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] Same profile selected, no terminal switches needed');
+        }
+
+        debugLog('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] ========== PROFILE SWITCH COMPLETE ==========');
        return { success: true };
      } catch (error) {
+        debugError('[terminal-handlers:CLAUDE_PROFILE_SET_ACTIVE] EXCEPTION:', error);
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Failed to set active Claude profile'
@@ -208,7 +304,7 @@ export function registerTerminalHandlers(
          const { mkdirSync, existsSync } = await import('fs');
          if (!existsSync(profile.configDir)) {
            mkdirSync(profile.configDir, { recursive: true });
-            console.warn('[IPC] Created config directory:', profile.configDir);
+            debugLog('[IPC] Created config directory:', profile.configDir);
          }
        }

@@ -217,7 +313,7 @@ export function registerTerminalHandlers(
        const terminalId = `claude-login-${profileId}-${Date.now()}`;
        const homeDir = process.env.HOME || process.env.USERPROFILE || '/tmp';

-        console.warn('[IPC] Initializing Claude profile:', {
+        debugLog('[IPC] Initializing Claude profile:', {
          profileId,
          profileName: profile.name,
          configDir: profile.configDir,
@@ -235,12 +331,14 @@ export function registerTerminalHandlers(
        let loginCommand: string;
        if (!profile.isDefault && profile.configDir) {
          // Use export and run in subshell to ensure CLAUDE_CONFIG_DIR is properly set
-          loginCommand = `export CLAUDE_CONFIG_DIR="${profile.configDir}" && echo "Config dir: $CLAUDE_CONFIG_DIR" && claude setup-token`;
+          // SECURITY: Use escapeShellArg to prevent command injection via configDir
+          const escapedConfigDir = escapeShellArg(profile.configDir);
+          loginCommand = `export CLAUDE_CONFIG_DIR=${escapedConfigDir} && echo "Config dir: $CLAUDE_CONFIG_DIR" && claude setup-token`;
        } else {
          loginCommand = 'claude setup-token';
        }

-        console.warn('[IPC] Sending login command to terminal:', loginCommand);
+        debugLog('[IPC] Sending login command to terminal:', loginCommand);

        // Write the login command to the terminal
        terminalManager.write(terminalId, `${loginCommand}\r`);
@@ -263,7 +361,7 @@ export function registerTerminalHandlers(
          }
        };
      } catch (error) {
-        console.error('[IPC] Failed to initialize Claude profile:', error);
+        debugError('[IPC] Failed to initialize Claude profile:', error);
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Failed to initialize Claude profile'
@@ -284,7 +382,7 @@ export function registerTerminalHandlers(
        }
        return { success: true };
      } catch (error) {
-        console.error('[IPC] Failed to set OAuth token:', error);
+        debugError('[IPC] Failed to set OAuth token:', error);
        return {
          success: false,
          error: error instanceof Error ? error.message : 'Failed to set OAuth token'
@@ -569,5 +667,5 @@ export function initializeUsageMonitorForwarding(mainWindow: BrowserWindow): voi
    mainWindow.webContents.send(IPC_CHANNELS.PROACTIVE_SWAP_NOTIFICATION, notification);
  });

-  console.warn('[terminal-handlers] Usage monitor event forwarding initialized');
+  debugLog('[terminal-handlers] Usage monitor event forwarding initialized');
 }
@@ -0,0 +1,61 @@
+import { execSync } from 'child_process';
+
+/**
+ * Detect and return the best available Python command.
+ * Tries multiple candidates and returns the first one that works with Python 3.
+ *
+ * @returns The Python command to use, or null if none found
+ */
+export function findPythonCommand(): string | null {
+  const isWindows = process.platform === 'win32';
+
+  // On Windows, try py launcher first (most reliable), then python, then python3
+  // On Unix, try python3 first, then python
+  const candidates = isWindows
+    ? ['py -3', 'python', 'python3', 'py']
+    : ['python3', 'python'];
+
+  for (const cmd of candidates) {
+    try {
+      const version = execSync(`${cmd} --version`, {
+        stdio: 'pipe',
+        timeout: 5000,
+        windowsHide: true
+      }).toString();
+
+      if (version.includes('Python 3')) {
+        return cmd;
+      }
+    } catch {
+      // Command not found or errored, try next
+      continue;
+    }
+  }
+
+  // Fallback to platform-specific default
+  return isWindows ? 'python' : 'python3';
+}
+
+/**
+ * Get the default Python command for the current platform.
+ * This is a synchronous fallback that doesn't test if Python actually exists.
+ *
+ * @returns The default Python command for this platform
+ */
+export function getDefaultPythonCommand(): string {
+  return process.platform === 'win32' ? 'python' : 'python3';
+}
+
+/**
+ * Parse a Python command string into command and base arguments.
+ * Handles space-separated commands like "py -3".
+ *
+ * @param pythonPath - The Python command string (e.g., "python3", "py -3")
+ * @returns Tuple of [command, baseArgs] ready for use with spawn()
+ */
+export function parsePythonCommand(pythonPath: string): [string, string[]] {
+  const parts = pythonPath.split(' ');
+  const command = parts[0];
+  const baseArgs = parts.slice(1);
+  return [command, baseArgs];
+}
@@ -37,16 +37,11 @@ export class PythonEnvManager extends EventEmitter {

  /**
   * Get the path to pip in the venv
+   * Returns null - we use python -m pip instead for better compatibility
+   * @deprecated Use getVenvPythonPath() with -m pip instead
   */
  private getVenvPipPath(): string | null {
-    if (!this.autoBuildSourcePath) return null;
-
-    const venvPip =
-      process.platform === 'win32'
-        ? path.join(this.autoBuildSourcePath, '.venv', 'Scripts', 'pip.exe')
-        : path.join(this.autoBuildSourcePath, '.venv', 'bin', 'pip');
-
-    return venvPip;
+    return null; // Not used - we use python -m pip
  }

  /**
@@ -181,16 +176,54 @@ export class PythonEnvManager extends EventEmitter {
  }

  /**
-   * Install dependencies from requirements.txt
+   * Bootstrap pip in the venv using ensurepip
+   */
+  private async bootstrapPip(): Promise<boolean> {
+    const venvPython = this.getVenvPythonPath();
+    if (!venvPython || !existsSync(venvPython)) {
+      return false;
+    }
+
+    console.warn('[PythonEnvManager] Bootstrapping pip...');
+    return new Promise((resolve) => {
+      const proc = spawn(venvPython, ['-m', 'ensurepip'], {
+        cwd: this.autoBuildSourcePath!,
+        stdio: 'pipe'
+      });
+
+      let stderr = '';
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          console.warn('[PythonEnvManager] Pip bootstrapped successfully');
+          resolve(true);
+        } else {
+          console.error('[PythonEnvManager] Failed to bootstrap pip:', stderr);
+          resolve(false);
+        }
+      });
+
+      proc.on('error', (err) => {
+        console.error('[PythonEnvManager] Error bootstrapping pip:', err);
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Install dependencies from requirements.txt using python -m pip
   */
  private async installDeps(): Promise<boolean> {
    if (!this.autoBuildSourcePath) return false;

-    const venvPip = this.getVenvPipPath();
+    const venvPython = this.getVenvPythonPath();
    const requirementsPath = path.join(this.autoBuildSourcePath, 'requirements.txt');

-    if (!venvPip || !existsSync(venvPip)) {
-      this.emit('error', 'Pip not found in virtual environment');
+    if (!venvPython || !existsSync(venvPython)) {
+      this.emit('error', 'Python not found in virtual environment');
      return false;
    }

@@ -199,11 +232,15 @@ export class PythonEnvManager extends EventEmitter {
      return false;
    }

+    // Bootstrap pip first if needed
+    await this.bootstrapPip();
+
    this.emit('status', 'Installing Python dependencies (this may take a minute)...');
    console.warn('[PythonEnvManager] Installing dependencies from:', requirementsPath);

    return new Promise((resolve) => {
-      const proc = spawn(venvPip, ['install', '-r', requirementsPath], {
+      // Use python -m pip for better compatibility across Python versions
+      const proc = spawn(venvPython, ['-m', 'pip', 'install', '-r', requirementsPath], {
        cwd: this.autoBuildSourcePath!,
        stdio: 'pipe'
      });
@@ -22,6 +22,26 @@ const RATE_LIMIT_INDICATORS = [
  /too\s*many\s*requests/i
 ];

+/**
+ * Patterns that indicate authentication failures
+ * These patterns detect when Claude CLI/SDK fails due to missing or invalid auth
+ */
+const AUTH_FAILURE_PATTERNS = [
+  /authentication\s*(is\s*)?required/i,
+  /not\s*(yet\s*)?authenticated/i,
+  /login\s*(is\s*)?required/i,
+  /oauth\s*token\s*(is\s*)?(invalid|expired|missing)/i,
+  /unauthorized/i,
+  /please\s*(log\s*in|login|authenticate)/i,
+  /invalid\s*(credentials|token|api\s*key)/i,
+  /auth(entication)?\s*(failed|error|failure)/i,
+  /session\s*(expired|invalid)/i,
+  /access\s*denied/i,
+  /permission\s*denied/i,
+  /401\s*unauthorized/i,
+  /credentials\s*(are\s*)?(missing|invalid|expired)/i
+];
+
 /**
 * Result of rate limit detection
 */
@@ -43,6 +63,22 @@ export interface RateLimitDetectionResult {
  originalError?: string;
 }

+/**
+ * Result of authentication failure detection
+ */
+export interface AuthFailureDetectionResult {
+  /** Whether an authentication failure was detected */
+  isAuthFailure: boolean;
+  /** The profile ID that failed to authenticate (if known) */
+  profileId?: string;
+  /** The type of auth failure detected */
+  failureType?: 'missing' | 'invalid' | 'expired' | 'unknown';
+  /** User-friendly message describing the failure */
+  message?: string;
+  /** Original error message from the process output */
+  originalError?: string;
+}
+
 /**
 * Classify rate limit type based on reset time string
 */
@@ -132,6 +168,80 @@ export function extractResetTime(output: string): string | null {
  return match ? match[1].trim() : null;
 }

+/**
+ * Classify the type of authentication failure based on the error message
+ */
+function classifyAuthFailureType(output: string): 'missing' | 'invalid' | 'expired' | 'unknown' {
+  const lowerOutput = output.toLowerCase();
+
+  if (/missing|not\s*(yet\s*)?authenticated|required/.test(lowerOutput)) {
+    return 'missing';
+  }
+  if (/expired|session\s*expired/.test(lowerOutput)) {
+    return 'expired';
+  }
+  if (/invalid|unauthorized|denied/.test(lowerOutput)) {
+    return 'invalid';
+  }
+  return 'unknown';
+}
+
+/**
+ * Get a user-friendly message for the authentication failure
+ */
+function getAuthFailureMessage(failureType: 'missing' | 'invalid' | 'expired' | 'unknown'): string {
+  switch (failureType) {
+    case 'missing':
+      return 'Claude authentication required. Please go to Settings > Claude Profiles and authenticate your account.';
+    case 'expired':
+      return 'Your Claude session has expired. Please re-authenticate in Settings > Claude Profiles.';
+    case 'invalid':
+      return 'Invalid Claude credentials. Please check your OAuth token or re-authenticate in Settings > Claude Profiles.';
+    case 'unknown':
+    default:
+      return 'Claude authentication failed. Please verify your authentication in Settings > Claude Profiles.';
+  }
+}
+
+/**
+ * Detect authentication failure from output (stdout + stderr combined)
+ */
+export function detectAuthFailure(
+  output: string,
+  profileId?: string
+): AuthFailureDetectionResult {
+  // First, make sure this isn't a rate limit error (those should be handled separately)
+  if (detectRateLimit(output).isRateLimited) {
+    return { isAuthFailure: false };
+  }
+
+  // Check for authentication failure patterns
+  for (const pattern of AUTH_FAILURE_PATTERNS) {
+    if (pattern.test(output)) {
+      const profileManager = getClaudeProfileManager();
+      const effectiveProfileId = profileId || profileManager.getActiveProfile().id;
+      const failureType = classifyAuthFailureType(output);
+
+      return {
+        isAuthFailure: true,
+        profileId: effectiveProfileId,
+        failureType,
+        message: getAuthFailureMessage(failureType),
+        originalError: output
+      };
+    }
+  }
+
+  return { isAuthFailure: false };
+}
+
+/**
+ * Check if output contains authentication failure error
+ */
+export function isAuthFailureError(output: string): boolean {
+  return detectAuthFailure(output).isAuthFailure;
+}
+
 /**
 * Get environment variables for a specific Claude profile.
 * Uses OAuth token (CLAUDE_CODE_OAUTH_TOKEN) if available, otherwise falls back to CLAUDE_CONFIG_DIR.
@@ -32,6 +32,7 @@ export class TaskLogService extends EventEmitter {

  /**
   * Load task logs from a single spec directory
+   * Returns cached logs if the file is corrupted (e.g., mid-write by Python backend)
   */
  loadLogsFromPath(specDir: string): TaskLogs | null {
    const logFile = path.join(specDir, 'task_logs.json');
@@ -45,6 +46,13 @@ export class TaskLogService extends EventEmitter {
      const logs = JSON.parse(content) as TaskLogs;
      return logs;
    } catch (error) {
+      // JSON parse error - file may be mid-write, return cached version if available
+      const cached = this.logCache.get(specDir);
+      if (cached) {
+        // Silently return cached version - this is expected during concurrent access
+        return cached;
+      }
+      // Only log if we have no cached fallback
      console.error(`[TaskLogService] Failed to load logs from ${logFile}:`, error);
      return null;
    }
@@ -4,6 +4,7 @@ import { spawn } from 'child_process';
 import { app } from 'electron';
 import { EventEmitter } from 'events';
 import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv } from './rate-limit-detector';
+import { findPythonCommand, parsePythonCommand } from './python-detector';

 /**
 * Debug logging - only logs when AUTO_CLAUDE_DEBUG env var is set
@@ -20,7 +21,8 @@ function debug(...args: unknown[]): void {
 * Service for generating terminal names from commands using Claude AI
 */
 export class TerminalNameGenerator extends EventEmitter {
-  private pythonPath: string = 'python3';
+  // Auto-detect Python command on initialization
+  private pythonPath: string = findPythonCommand() || 'python';
  private autoBuildSourcePath: string = '';

  constructor() {
@@ -130,7 +132,9 @@ export class TerminalNameGenerator extends EventEmitter {
    const profileEnv = getProfileEnv();

    return new Promise((resolve) => {
-      const childProcess = spawn(this.pythonPath, ['-c', script], {
+      // Parse Python command to handle space-separated commands like "py -3"
+      const [pythonCommand, pythonBaseArgs] = parsePythonCommand(this.pythonPath);
+      const childProcess = spawn(pythonCommand, [...pythonBaseArgs, '-c', script], {
        cwd: autoBuildSource,
        env: {
          ...process.env,
@@ -10,6 +10,8 @@ import { IPC_CHANNELS } from '../../shared/constants';
 import { getClaudeProfileManager } from '../claude-profile-manager';
 import * as OutputParser from './output-parser';
 import * as SessionHandler from './session-handler';
+import { debugLog, debugError } from '../../shared/utils/debug-logger';
+import { escapeShellArg, buildCdCommand } from '../../shared/utils/shell-escape';
 import type {
  TerminalProcess,
  WindowGetter,
@@ -92,9 +94,11 @@ export function handleOAuthToken(
  console.warn('[ClaudeIntegration] OAuth token detected, length:', token.length);

  const email = OutputParser.extractEmail(terminal.outputBuffer);
-  const profileIdMatch = terminal.id.match(/claude-login-(profile-\d+)-/);
+  // Match both custom profiles (profile-123456) and the default profile
+  const profileIdMatch = terminal.id.match(/claude-login-(profile-\d+|default)-/);

  if (profileIdMatch) {
+    // Save to specific profile (profile login terminal)
    const profileId = profileIdMatch[1];
    const profileManager = getClaudeProfileManager();
    const success = profileManager.setProfileToken(profileId, token, email || undefined);
@@ -116,16 +120,56 @@ export function handleOAuthToken(
      console.error('[ClaudeIntegration] Failed to save OAuth token to profile:', profileId);
    }
  } else {
-    console.warn('[ClaudeIntegration] OAuth token detected but not in a profile login terminal');
-    const win = getWindow();
-    if (win) {
-      win.webContents.send(IPC_CHANNELS.TERMINAL_OAUTH_TOKEN, {
-        terminalId: terminal.id,
-        email,
-        success: false,
-        message: 'Token detected but no profile associated with this terminal',
-        detectedAt: new Date().toISOString()
-      } as OAuthTokenEvent);
+    // No profile-specific terminal, save to active profile (GitHub OAuth flow, etc.)
+    console.warn('[ClaudeIntegration] OAuth token detected in non-profile terminal, saving to active profile');
+    const profileManager = getClaudeProfileManager();
+    const activeProfile = profileManager.getActiveProfile();
+
+    // Defensive null check for active profile
+    if (!activeProfile) {
+      console.error('[ClaudeIntegration] Failed to save OAuth token: no active profile found');
+      const win = getWindow();
+      if (win) {
+        win.webContents.send(IPC_CHANNELS.TERMINAL_OAUTH_TOKEN, {
+          terminalId: terminal.id,
+          profileId: undefined,
+          email,
+          success: false,
+          message: 'No active profile found',
+          detectedAt: new Date().toISOString()
+        } as OAuthTokenEvent);
+      }
+      return;
+    }
+
+    const success = profileManager.setProfileToken(activeProfile.id, token, email || undefined);
+
+    if (success) {
+      console.warn('[ClaudeIntegration] OAuth token auto-saved to active profile:', activeProfile.name);
+
+      const win = getWindow();
+      if (win) {
+        win.webContents.send(IPC_CHANNELS.TERMINAL_OAUTH_TOKEN, {
+          terminalId: terminal.id,
+          profileId: activeProfile.id,
+          email,
+          success: true,
+          detectedAt: new Date().toISOString()
+        } as OAuthTokenEvent);
+      }
+    } else {
+      console.error('[ClaudeIntegration] Failed to save OAuth token to active profile:', activeProfile.name);
+      const win = getWindow();
+      if (win) {
+        win.webContents.send(IPC_CHANNELS.TERMINAL_OAUTH_TOKEN, {
+          terminalId: terminal.id,
+          profileId: activeProfile?.id,
+          email,
+          success: false,
+          message: 'Failed to save token to active profile',
+          detectedAt: new Date().toISOString()
+        } as OAuthTokenEvent);
+      }
    }
  }
 }
@@ -161,6 +205,11 @@ export function invokeClaude(
  getWindow: WindowGetter,
  onSessionCapture: (terminalId: string, projectPath: string, startTime: number) => void
 ): void {
+  debugLog('[ClaudeIntegration:invokeClaude] ========== INVOKE CLAUDE START ==========');
+  debugLog('[ClaudeIntegration:invokeClaude] Terminal ID:', terminal.id);
+  debugLog('[ClaudeIntegration:invokeClaude] Requested profile ID:', profileId);
+  debugLog('[ClaudeIntegration:invokeClaude] CWD:', cwd);
+
  terminal.isClaudeMode = true;
  terminal.claudeSessionId = undefined;

@@ -175,31 +224,70 @@ export function invokeClaude(
  const previousProfileId = terminal.claudeProfileId;
  terminal.claudeProfileId = activeProfile?.id;

-  const cwdCommand = cwd ? `cd "${cwd}" && ` : '';
+  debugLog('[ClaudeIntegration:invokeClaude] Profile resolution:', {
+    previousProfileId,
+    newProfileId: activeProfile?.id,
+    profileName: activeProfile?.name,
+    hasOAuthToken: !!activeProfile?.oauthToken,
+    isDefault: activeProfile?.isDefault
+  });
+
+  // Use safe shell escaping to prevent command injection
+  const cwdCommand = buildCdCommand(cwd);
  const needsEnvOverride = profileId && profileId !== previousProfileId;

+  debugLog('[ClaudeIntegration:invokeClaude] Environment override check:', {
+    profileIdProvided: !!profileId,
+    previousProfileId,
+    needsEnvOverride
+  });
+
  if (needsEnvOverride && activeProfile && !activeProfile.isDefault) {
    const token = profileManager.getProfileToken(activeProfile.id);
+    debugLog('[ClaudeIntegration:invokeClaude] Token retrieval:', {
+      hasToken: !!token,
+      tokenLength: token?.length
+    });

    if (token) {
      const tempFile = path.join(os.tmpdir(), `.claude-token-${Date.now()}`);
+      debugLog('[ClaudeIntegration:invokeClaude] Writing token to temp file:', tempFile);
      fs.writeFileSync(tempFile, `export CLAUDE_CODE_OAUTH_TOKEN="${token}"\n`, { mode: 0o600 });

-      terminal.pty.write(`${cwdCommand}source "${tempFile}" && rm -f "${tempFile}" && claude\r`);
-      console.warn('[ClaudeIntegration] Switching to Claude profile:', activeProfile.name, '(via secure temp file)');
+      // Clear terminal and run command without adding to shell history:
+      // - HISTFILE= disables history file writing for the current command
+      // - HISTCONTROL=ignorespace causes commands starting with space to be ignored
+      // - Leading space ensures the command is ignored even if HISTCONTROL was already set
+      // - Uses subshell (...) to isolate environment changes
+      // This prevents temp file paths from appearing in shell history
+      const command = `clear && ${cwdCommand} HISTFILE= HISTCONTROL=ignorespace bash -c 'source "${tempFile}" && rm -f "${tempFile}" && exec claude'\r`;
+      debugLog('[ClaudeIntegration:invokeClaude] Executing command (temp file method, history-safe)');
+      terminal.pty.write(command);
+      debugLog('[ClaudeIntegration:invokeClaude] ========== INVOKE CLAUDE COMPLETE (temp file) ==========');
      return;
    } else if (activeProfile.configDir) {
-      terminal.pty.write(`${cwdCommand}CLAUDE_CONFIG_DIR="${activeProfile.configDir}" claude\r`);
-      console.warn('[ClaudeIntegration] Using Claude profile:', activeProfile.name, 'config:', activeProfile.configDir);
+      // Clear terminal and run command without adding to shell history:
+      // Same history-disabling technique as temp file method above
+      // SECURITY: Use escapeShellArg for configDir to prevent command injection
+      // Set CLAUDE_CONFIG_DIR as env var before bash -c to avoid embedding user input in the command string
+      const escapedConfigDir = escapeShellArg(activeProfile.configDir);
+      const command = `clear && ${cwdCommand}HISTFILE= HISTCONTROL=ignorespace CLAUDE_CONFIG_DIR=${escapedConfigDir} bash -c 'exec claude'\r`;
+      debugLog('[ClaudeIntegration:invokeClaude] Executing command (configDir method, history-safe)');
+      terminal.pty.write(command);
+      debugLog('[ClaudeIntegration:invokeClaude] ========== INVOKE CLAUDE COMPLETE (configDir) ==========');
      return;
+    } else {
+      debugLog('[ClaudeIntegration:invokeClaude] WARNING: No token or configDir available for non-default profile');
    }
  }

  if (activeProfile && !activeProfile.isDefault) {
-    console.warn('[ClaudeIntegration] Using Claude profile:', activeProfile.name, '(from terminal environment)');
+    debugLog('[ClaudeIntegration:invokeClaude] Using terminal environment for non-default profile:', activeProfile.name);
  }

-  terminal.pty.write(`${cwdCommand}claude\r`);
+  const command = `${cwdCommand}claude\r`;
+  debugLog('[ClaudeIntegration:invokeClaude] Executing command (default method):', command);
+  terminal.pty.write(command);

  if (activeProfile) {
    profileManager.markProfileUsed(activeProfile.id);
@@ -220,6 +308,8 @@ export function invokeClaude(
  if (projectPath) {
    onSessionCapture(terminal.id, projectPath, startTime);
  }
+
+  debugLog('[ClaudeIntegration:invokeClaude] ========== INVOKE CLAUDE COMPLETE (default) ==========');
 }

 /**
@@ -234,7 +324,8 @@ export function resumeClaude(

  let command: string;
  if (sessionId) {
-    command = `claude --resume "${sessionId}"`;
+    // SECURITY: Escape sessionId to prevent command injection
+    command = `claude --resume ${escapeShellArg(sessionId)}`;
    terminal.claudeSessionId = sessionId;
  } else {
    command = 'claude --continue';
@@ -248,6 +339,103 @@ export function resumeClaude(
  }
 }

+/**
+ * Configuration for waiting for Claude to exit
+ */
+interface WaitForExitConfig {
+  /** Maximum time to wait for Claude to exit (ms) */
+  timeout?: number;
+  /** Interval between checks (ms) */
+  pollInterval?: number;
+}
+
+/**
+ * Result of waiting for Claude to exit
+ */
+interface WaitForExitResult {
+  /** Whether Claude exited successfully */
+  success: boolean;
+  /** Error message if failed */
+  error?: string;
+  /** Whether the operation timed out */
+  timedOut?: boolean;
+}
+
+/**
+ * Shell prompt patterns that indicate Claude has exited and shell is ready
+ * These patterns match common shell prompts across bash, zsh, fish, etc.
+ */
+const SHELL_PROMPT_PATTERNS = [
+  /[$%#>❯]\s*$/m,                    // Common prompt endings: $, %, #, >, ❯
+  /\w+@[\w.-]+[:\s]/,                // user@hostname: format
+  /^\s*\S+\s*[$%#>❯]\s*$/m,          // hostname/path followed by prompt char
+  /\(.*\)\s*[$%#>❯]\s*$/m,           // (venv) or (branch) followed by prompt
+];
+
+/**
+ * Wait for Claude to exit by monitoring terminal output for shell prompt
+ *
+ * Instead of using fixed delays, this monitors the terminal's outputBuffer
+ * for patterns indicating that Claude has exited and the shell prompt is visible.
+ */
+async function waitForClaudeExit(
+  terminal: TerminalProcess,
+  config: WaitForExitConfig = {}
+): Promise<WaitForExitResult> {
+  const { timeout = 5000, pollInterval = 100 } = config;
+
+  debugLog('[ClaudeIntegration:waitForClaudeExit] Waiting for Claude to exit...');
+  debugLog('[ClaudeIntegration:waitForClaudeExit] Config:', { timeout, pollInterval });
+
+  // Capture current buffer length to detect new output
+  const initialBufferLength = terminal.outputBuffer.length;
+  const startTime = Date.now();
+
+  return new Promise((resolve) => {
+    const checkForPrompt = () => {
+      const elapsed = Date.now() - startTime;
+
+      // Check for timeout
+      if (elapsed >= timeout) {
+        console.warn('[ClaudeIntegration:waitForClaudeExit] Timeout waiting for Claude to exit after', timeout, 'ms');
+        debugLog('[ClaudeIntegration:waitForClaudeExit] Timeout reached, Claude may not have exited cleanly');
+        resolve({
+          success: false,
+          error: `Timeout waiting for Claude to exit after ${timeout}ms`,
+          timedOut: true
+        });
+        return;
+      }
+
+      // Get new output since we started waiting
+      const newOutput = terminal.outputBuffer.slice(initialBufferLength);
+
+      // Check if we can see a shell prompt in the new output
+      for (const pattern of SHELL_PROMPT_PATTERNS) {
+        if (pattern.test(newOutput)) {
+          debugLog('[ClaudeIntegration:waitForClaudeExit] Shell prompt detected after', elapsed, 'ms');
+          debugLog('[ClaudeIntegration:waitForClaudeExit] Matched pattern:', pattern.toString());
+          resolve({ success: true });
+          return;
+        }
+      }
+
+      // Also check if isClaudeMode was cleared (set by other handlers)
+      if (!terminal.isClaudeMode) {
+        debugLog('[ClaudeIntegration:waitForClaudeExit] isClaudeMode flag cleared after', elapsed, 'ms');
+        resolve({ success: true });
+        return;
+      }
+
+      // Continue polling
+      setTimeout(checkForPrompt, pollInterval);
+    };
+
+    // Start checking
+    checkForPrompt();
+  });
+}
+
 /**
 * Switch terminal to a different Claude profile
 */
@@ -258,27 +446,95 @@ export async function switchClaudeProfile(
  invokeClaudeCallback: (terminalId: string, cwd: string | undefined, profileId: string) => void,
  clearRateLimitCallback: (terminalId: string) => void
 ): Promise<{ success: boolean; error?: string }> {
+  // Always-on tracing
+  console.warn('[ClaudeIntegration:switchClaudeProfile] Called for terminal:', terminal.id, '| profileId:', profileId);
+  console.warn('[ClaudeIntegration:switchClaudeProfile] Terminal state: isClaudeMode=', terminal.isClaudeMode);
+
+  debugLog('[ClaudeIntegration:switchClaudeProfile] ========== SWITCH PROFILE START ==========');
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Terminal ID:', terminal.id);
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Target profile ID:', profileId);
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Terminal state:', {
+    isClaudeMode: terminal.isClaudeMode,
+    currentProfileId: terminal.claudeProfileId,
+    claudeSessionId: terminal.claudeSessionId,
+    projectPath: terminal.projectPath,
+    cwd: terminal.cwd
+  });
+
  const profileManager = getClaudeProfileManager();
  const profile = profileManager.getProfile(profileId);
+
+  console.warn('[ClaudeIntegration:switchClaudeProfile] Profile found:', profile?.name || 'NOT FOUND');
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Target profile:', profile ? {
+    id: profile.id,
+    name: profile.name,
+    hasOAuthToken: !!profile.oauthToken,
+    isDefault: profile.isDefault
+  } : 'NOT FOUND');
+
  if (!profile) {
+    console.error('[ClaudeIntegration:switchClaudeProfile] Profile not found, aborting');
+    debugError('[ClaudeIntegration:switchClaudeProfile] Profile not found, aborting');
    return { success: false, error: 'Profile not found' };
  }

-  console.warn('[ClaudeIntegration] Switching to Claude profile:', profile.name);
+  console.warn('[ClaudeIntegration:switchClaudeProfile] Switching to profile:', profile.name);
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Switching to Claude profile:', profile.name);

  if (terminal.isClaudeMode) {
+    console.warn('[ClaudeIntegration:switchClaudeProfile] Sending exit commands (Ctrl+C, /exit)');
+    debugLog('[ClaudeIntegration:switchClaudeProfile] Terminal is in Claude mode, sending exit commands');
+
+    // Send Ctrl+C to interrupt any ongoing operation
+    debugLog('[ClaudeIntegration:switchClaudeProfile] Sending Ctrl+C (\\x03)');
    terminal.pty.write('\x03');
-    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Wait briefly for Ctrl+C to take effect before sending /exit
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    // Send /exit command
+    debugLog('[ClaudeIntegration:switchClaudeProfile] Sending /exit command');
    terminal.pty.write('/exit\r');
-    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Wait for Claude to actually exit by monitoring for shell prompt
+    const exitResult = await waitForClaudeExit(terminal, { timeout: 5000, pollInterval: 100 });
+
+    if (exitResult.timedOut) {
+      console.warn('[ClaudeIntegration:switchClaudeProfile] Timed out waiting for Claude to exit, proceeding with caution');
+      debugLog('[ClaudeIntegration:switchClaudeProfile] Exit timeout - terminal may be in inconsistent state');
+
+      // Even on timeout, we'll try to proceed but log the warning
+      // The alternative would be to abort, but that could leave users stuck
+      // If this becomes a problem, we could add retry logic or abort option
+    } else if (!exitResult.success) {
+      console.error('[ClaudeIntegration:switchClaudeProfile] Failed to exit Claude:', exitResult.error);
+      debugError('[ClaudeIntegration:switchClaudeProfile] Exit failed:', exitResult.error);
+      // Continue anyway - the /exit command was sent
+    } else {
+      console.warn('[ClaudeIntegration:switchClaudeProfile] Claude exited successfully');
+      debugLog('[ClaudeIntegration:switchClaudeProfile] Claude exited, ready to switch profile');
+    }
+  } else {
+    console.warn('[ClaudeIntegration:switchClaudeProfile] NOT in Claude mode, skipping exit commands');
+    debugLog('[ClaudeIntegration:switchClaudeProfile] Terminal NOT in Claude mode, skipping exit commands');
  }

+  debugLog('[ClaudeIntegration:switchClaudeProfile] Clearing rate limit state for terminal');
  clearRateLimitCallback(terminal.id);

  const projectPath = terminal.projectPath || terminal.cwd;
+  console.warn('[ClaudeIntegration:switchClaudeProfile] Invoking Claude with profile:', profileId, '| cwd:', projectPath);
+  debugLog('[ClaudeIntegration:switchClaudeProfile] Invoking Claude with new profile:', {
+    terminalId: terminal.id,
+    projectPath,
+    profileId
+  });
  invokeClaudeCallback(terminal.id, projectPath, profileId);

+  debugLog('[ClaudeIntegration:switchClaudeProfile] Setting active profile in profile manager');
  profileManager.setActiveProfile(profileId);

+  console.warn('[ClaudeIntegration:switchClaudeProfile] COMPLETE');
+  debugLog('[ClaudeIntegration:switchClaudeProfile] ========== SWITCH PROFILE COMPLETE ==========');
  return { success: true };
 }
@@ -10,7 +10,7 @@

 import * as net from 'net';
 import * as fs from 'fs';
-import * as pty from 'node-pty';
+import * as pty from '@lydell/node-pty';

 const SOCKET_PATH =
  process.platform === 'win32'
@@ -3,7 +3,7 @@
 * Handles low-level PTY process creation and lifecycle
 */

-import * as pty from 'node-pty';
+import * as pty from '@lydell/node-pty';
 import * as os from 'os';
 import type { TerminalProcess, WindowGetter } from './types';
 import { IPC_CHANNELS } from '../../shared/constants';
@@ -1,4 +1,4 @@
-import type * as pty from 'node-pty';
+import type * as pty from '@lydell/node-pty';
 import type { BrowserWindow } from 'electron';

 /**
@@ -4,6 +4,7 @@ import { spawn } from 'child_process';
 import { app } from 'electron';
 import { EventEmitter } from 'events';
 import { detectRateLimit, createSDKRateLimitInfo, getProfileEnv } from './rate-limit-detector';
+import { findPythonCommand, parsePythonCommand } from './python-detector';

 /**
 * Debug logging - only logs when AUTO_CLAUDE_DEBUG env var is set
@@ -20,7 +21,8 @@ function debug(...args: unknown[]): void {
 * Service for generating task titles from descriptions using Claude AI
 */
 export class TitleGenerator extends EventEmitter {
-  private pythonPath: string = 'python3';
+  // Auto-detect Python command on initialization
+  private pythonPath: string = findPythonCommand() || 'python';
  private autoBuildSourcePath: string = '';

  constructor() {
@@ -129,7 +131,9 @@ export class TitleGenerator extends EventEmitter {
    const profileEnv = getProfileEnv();

    return new Promise((resolve) => {
-      const childProcess = spawn(this.pythonPath, ['-c', script], {
+      // Parse Python command to handle space-separated commands like "py -3"
+      const [pythonCommand, pythonBaseArgs] = parsePythonCommand(this.pythonPath);
+      const childProcess = spawn(pythonCommand, [...pythonBaseArgs, '-c', script], {
        cwd: autoBuildSource,
        env: {
          ...process.env,
@@ -74,9 +74,12 @@ export function downloadFile(
  return new Promise((resolve, reject) => {
    const file = createWriteStream(destPath);

+    // GitHub API URLs need the GitHub Accept header to get a redirect to the actual file
+    // Non-API URLs (CDN, direct downloads) use octet-stream
+    const isGitHubApi = url.includes('api.github.com');
    const headers = {
      'User-Agent': 'Auto-Claude-UI',
-      'Accept': 'application/octet-stream'
+      'Accept': isGitHubApi ? 'application/vnd.github+json' : 'application/octet-stream'
    };

    const request = https.get(url, { headers }, (response) => {
@@ -4,8 +4,9 @@

 import { GITHUB_CONFIG } from './config';
 import { fetchJson } from './http-client';
-import { getBundledVersion, parseVersionFromTag, compareVersions } from './version-manager';
+import { getEffectiveVersion, parseVersionFromTag, compareVersions } from './version-manager';
 import { GitHubRelease, AutoBuildUpdateCheck } from './types';
+import { debugLog } from '../../shared/utils/debug-logger';

 // Cache for the latest release info (used by download)
 let cachedLatestRelease: GitHubRelease | null = null;
@@ -35,7 +36,9 @@ export function clearCachedRelease(): void {
 * Check GitHub Releases for the latest version
 */
 export async function checkForUpdates(): Promise<AutoBuildUpdateCheck> {
-  const currentVersion = getBundledVersion();
+  // Use effective version which accounts for source updates
+  const currentVersion = getEffectiveVersion();
+  debugLog('[UpdateCheck] Current effective version:', currentVersion);

  try {
    // Fetch latest release from GitHub Releases API
@@ -47,9 +50,11 @@ export async function checkForUpdates(): Promise<AutoBuildUpdateCheck> {

    // Parse version from tag (e.g., "v1.2.0" -> "1.2.0")
    const latestVersion = parseVersionFromTag(release.tag_name);
+    debugLog('[UpdateCheck] Latest version:', latestVersion);

    // Compare versions
    const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+    debugLog('[UpdateCheck] Update available:', updateAvailable);

    return {
      updateAvailable,
@@ -61,6 +66,7 @@ export async function checkForUpdates(): Promise<AutoBuildUpdateCheck> {
  } catch (error) {
    // Clear cache on error
    clearCachedRelease();
+    debugLog('[UpdateCheck] Error:', error instanceof Error ? error.message : error);

    return {
      updateAvailable: false,
@@ -12,6 +12,7 @@ import { getUpdateCachePath, getUpdateTargetPath } from './path-resolver';
 import { extractTarball, copyDirectoryRecursive, preserveFiles, restoreFiles, cleanTargetDirectory } from './file-operations';
 import { getCachedRelease, setCachedRelease, clearCachedRelease } from './update-checker';
 import { GitHubRelease, AutoBuildUpdateResult, UpdateProgressCallback, UpdateMetadata } from './types';
+import { debugLog } from '../../shared/utils/debug-logger';

 /**
 * Download and apply the latest auto-claude update from GitHub Releases
@@ -25,6 +26,9 @@ export async function downloadAndApplyUpdate(
 ): Promise<AutoBuildUpdateResult> {
  const cachePath = getUpdateCachePath();

+  debugLog('[Update] Starting update process...');
+  debugLog('[Update] Cache path:', cachePath);
+
  try {
    onProgress?.({
      stage: 'checking',
@@ -34,19 +38,25 @@ export async function downloadAndApplyUpdate(
    // Ensure cache directory exists
    if (!existsSync(cachePath)) {
      mkdirSync(cachePath, { recursive: true });
+      debugLog('[Update] Created cache directory');
    }

    // Get release info (use cache or fetch fresh)
    let release = getCachedRelease();
    if (!release) {
      const releaseUrl = `https://api.github.com/repos/${GITHUB_CONFIG.owner}/${GITHUB_CONFIG.repo}/releases/latest`;
+      debugLog('[Update] Fetching release info from:', releaseUrl);
      release = await fetchJson<GitHubRelease>(releaseUrl);
      setCachedRelease(release);
+    } else {
+      debugLog('[Update] Using cached release info');
    }

    // Use the release tarball URL
    const tarballUrl = release.tarball_url;
    const releaseVersion = parseVersionFromTag(release.tag_name);
+    debugLog('[Update] Release version:', releaseVersion);
+    debugLog('[Update] Tarball URL:', tarballUrl);

    const tarballPath = path.join(cachePath, 'auto-claude-update.tar.gz');
    const extractPath = path.join(cachePath, 'extracted');
@@ -63,6 +73,8 @@ export async function downloadAndApplyUpdate(
      message: 'Downloading update...'
    });

+    debugLog('[Update] Starting download to:', tarballPath);
+
    // Download the tarball
    await downloadFile(tarballUrl, tarballPath, (percent) => {
      onProgress?.({
@@ -72,14 +84,20 @@ export async function downloadAndApplyUpdate(
      });
    });

+    debugLog('[Update] Download complete');
+
    onProgress?.({
      stage: 'extracting',
      message: 'Extracting update...'
    });

+    debugLog('[Update] Extracting to:', extractPath);
+
    // Extract the tarball
    await extractTarball(tarballPath, extractPath);

+    debugLog('[Update] Extraction complete');
+
    // Find the auto-claude folder in extracted content
    // GitHub tarballs have a root folder like "owner-repo-hash/"
    const extractedDirs = readdirSync(extractPath);
@@ -96,6 +114,7 @@ export async function downloadAndApplyUpdate(

    // Determine where to install the update
    const targetPath = getUpdateTargetPath();
+    debugLog('[Update] Target install path:', targetPath);

    // Backup existing source (if in dev mode)
    const backupPath = path.join(cachePath, 'backup');
@@ -104,11 +123,14 @@ export async function downloadAndApplyUpdate(
        rmSync(backupPath, { recursive: true, force: true });
      }
      // Simple copy for backup
+      debugLog('[Update] Creating backup at:', backupPath);
      copyDirectoryRecursive(targetPath, backupPath);
    }

    // Apply the update
+    debugLog('[Update] Applying update...');
    await applyUpdate(targetPath, autoBuildSource);
+    debugLog('[Update] Update applied successfully');

    // Write update metadata
    const metadata: UpdateMetadata = {
@@ -132,14 +154,26 @@ export async function downloadAndApplyUpdate(
      message: `Updated to version ${releaseVersion}`
    });

+    debugLog('[Update] ============================================');
+    debugLog('[Update] UPDATE SUCCESSFUL');
+    debugLog('[Update] New version:', releaseVersion);
+    debugLog('[Update] Target path:', targetPath);
+    debugLog('[Update] ============================================');
+
    return {
      success: true,
      version: releaseVersion
    };
  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Update failed';
+    debugLog('[Update] ============================================');
+    debugLog('[Update] UPDATE FAILED');
+    debugLog('[Update] Error:', errorMessage);
+    debugLog('[Update] ============================================');
+
    onProgress?.({
      stage: 'error',
-      message: error instanceof Error ? error.message : 'Update failed'
+      message: errorMessage
    });

    return {
@@ -3,17 +3,85 @@
 */

 import { app } from 'electron';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import type { UpdateMetadata } from './types';

 /**
- * Get the current app/framework version
+ * Get the current app/framework version from package.json
 *
- * Uses app.getVersion() (from package.json) as the single source of truth.
- * Both the Electron app and auto-claude framework share the same version.
+ * Uses app.getVersion() (from package.json) as the base version.
 */
 export function getBundledVersion(): string {
  return app.getVersion();
 }

+/**
+ * Get the effective version - accounts for source updates
+ *
+ * Returns the updated source version if an update has been applied,
+ * otherwise returns the bundled version.
+ */
+export function getEffectiveVersion(): string {
+  const isDebug = process.env.DEBUG === 'true';
+
+  // Build list of paths to check for update metadata
+  const metadataPaths: string[] = [];
+
+  if (app.isPackaged) {
+    // Production: check userData override path
+    metadataPaths.push(
+      path.join(app.getPath('userData'), 'auto-claude-source', '.update-metadata.json')
+    );
+  } else {
+    // Development: check the actual source paths where updates are written
+    const possibleSourcePaths = [
+      path.join(app.getAppPath(), '..', 'auto-claude'),
+      path.join(app.getAppPath(), '..', '..', 'auto-claude'),
+      path.join(process.cwd(), 'auto-claude'),
+      path.join(process.cwd(), '..', 'auto-claude')
+    ];
+
+    for (const sourcePath of possibleSourcePaths) {
+      metadataPaths.push(path.join(sourcePath, '.update-metadata.json'));
+    }
+  }
+
+  if (isDebug) {
+    console.log('[Version] Checking metadata paths:', metadataPaths);
+  }
+
+  // Check each path for metadata
+  for (const metadataPath of metadataPaths) {
+    const exists = existsSync(metadataPath);
+    if (isDebug) {
+      console.log(`[Version] Checking ${metadataPath}: ${exists ? 'EXISTS' : 'not found'}`);
+    }
+    if (exists) {
+      try {
+        const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8')) as UpdateMetadata;
+        if (metadata.version) {
+          if (isDebug) {
+            console.log(`[Version] Found metadata version: ${metadata.version}`);
+          }
+          return metadata.version;
+        }
+      } catch (e) {
+        if (isDebug) {
+          console.log(`[Version] Error reading metadata: ${e}`);
+        }
+        // Continue to next path
+      }
+    }
+  }
+
+  const bundledVersion = app.getVersion();
+  if (isDebug) {
+    console.log(`[Version] No metadata found, using bundled version: ${bundledVersion}`);
+  }
+  return bundledVersion;
+}
+
 /**
 * Parse version from GitHub release tag
 * Handles tags like "v1.2.0", "1.2.0", "v1.2.0-beta"
@@ -5,6 +5,7 @@ import { SettingsAPI, createSettingsAPI } from './settings-api';
 import { FileAPI, createFileAPI } from './file-api';
 import { AgentAPI, createAgentAPI } from './agent-api';
 import { IdeationAPI, createIdeationAPI } from './modules/ideation-api';
+import { InsightsAPI, createInsightsAPI } from './modules/insights-api';
 import { AppUpdateAPI, createAppUpdateAPI } from './app-update-api';

 export interface ElectronAPI extends
@@ -15,6 +16,7 @@ export interface ElectronAPI extends
  FileAPI,
  AgentAPI,
  IdeationAPI,
+  InsightsAPI,
  AppUpdateAPI {}

 export const createElectronAPI = (): ElectronAPI => ({
@@ -25,6 +27,7 @@ export const createElectronAPI = (): ElectronAPI => ({
  ...createFileAPI(),
  ...createAgentAPI(),
  ...createIdeationAPI(),
+  ...createInsightsAPI(),
  ...createAppUpdateAPI()
 });

@@ -37,6 +40,7 @@ export {
  createFileAPI,
  createAgentAPI,
  createIdeationAPI,
+  createInsightsAPI,
  createAppUpdateAPI
 };

@@ -48,5 +52,6 @@ export type {
  FileAPI,
  AgentAPI,
  IdeationAPI,
+  InsightsAPI,
  AppUpdateAPI
 };
@@ -41,6 +41,10 @@ export interface GitHubAPI {
  getGitHubUser: () => Promise<IPCResult<{ username: string; name?: string }>>;
  listGitHubUserRepos: () => Promise<IPCResult<{ repos: Array<{ fullName: string; description: string | null; isPrivate: boolean }> }>>;

+  // Repository detection
+  detectGitHubRepo: (projectPath: string) => Promise<IPCResult<string>>;
+  getGitHubBranches: (repo: string, token: string) => Promise<IPCResult<string[]>>;
+
  // Event Listeners
  onGitHubInvestigationProgress: (
    callback: (projectId: string, status: GitHubInvestigationStatus) => void
@@ -109,6 +113,13 @@ export const createGitHubAPI = (): GitHubAPI => ({
  listGitHubUserRepos: (): Promise<IPCResult<{ repos: Array<{ fullName: string; description: string | null; isPrivate: boolean }> }>> =>
    invokeIpc(IPC_CHANNELS.GITHUB_LIST_USER_REPOS),

+  // Repository detection
+  detectGitHubRepo: (projectPath: string): Promise<IPCResult<string>> =>
+    invokeIpc(IPC_CHANNELS.GITHUB_DETECT_REPO, projectPath),
+
+  getGitHubBranches: (repo: string, token: string): Promise<IPCResult<string[]>> =>
+    invokeIpc(IPC_CHANNELS.GITHUB_GET_BRANCHES, repo, token),
+
  // Event Listeners
  onGitHubInvestigationProgress: (
    callback: (projectId: string, status: GitHubInvestigationStatus) => void
@@ -4,6 +4,7 @@ import type {
  InsightsSessionSummary,
  InsightsChatStatus,
  InsightsStreamChunk,
+  InsightsModelConfig,
  Task,
  TaskMetadata,
  IPCResult
@@ -16,7 +17,7 @@ import { createIpcListener, invokeIpc, sendIpc, IpcListenerCleanup } from './ipc
 export interface InsightsAPI {
  // Operations
  getInsightsSession: (projectId: string) => Promise<IPCResult<InsightsSession | null>>;
-  sendInsightsMessage: (projectId: string, message: string) => void;
+  sendInsightsMessage: (projectId: string, message: string, modelConfig?: InsightsModelConfig) => void;
  clearInsightsSession: (projectId: string) => Promise<IPCResult>;
  createTaskFromInsights: (
    projectId: string,
@@ -29,6 +30,7 @@ export interface InsightsAPI {
  switchInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult<InsightsSession | null>>;
  deleteInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult>;
  renameInsightsSession: (projectId: string, sessionId: string, newTitle: string) => Promise<IPCResult>;
+  updateInsightsModelConfig: (projectId: string, sessionId: string, modelConfig: InsightsModelConfig) => Promise<IPCResult>;

  // Event Listeners
  onInsightsStreamChunk: (
@@ -50,8 +52,8 @@ export const createInsightsAPI = (): InsightsAPI => ({
  getInsightsSession: (projectId: string): Promise<IPCResult<InsightsSession | null>> =>
    invokeIpc(IPC_CHANNELS.INSIGHTS_GET_SESSION, projectId),

-  sendInsightsMessage: (projectId: string, message: string): void =>
-    sendIpc(IPC_CHANNELS.INSIGHTS_SEND_MESSAGE, projectId, message),
+  sendInsightsMessage: (projectId: string, message: string, modelConfig?: InsightsModelConfig): void =>
+    sendIpc(IPC_CHANNELS.INSIGHTS_SEND_MESSAGE, projectId, message, modelConfig),

  clearInsightsSession: (projectId: string): Promise<IPCResult> =>
    invokeIpc(IPC_CHANNELS.INSIGHTS_CLEAR_SESSION, projectId),
@@ -79,6 +81,9 @@ export const createInsightsAPI = (): InsightsAPI => ({
  renameInsightsSession: (projectId: string, sessionId: string, newTitle: string): Promise<IPCResult> =>
    invokeIpc(IPC_CHANNELS.INSIGHTS_RENAME_SESSION, projectId, sessionId, newTitle),

+  updateInsightsModelConfig: (projectId: string, sessionId: string, modelConfig: InsightsModelConfig): Promise<IPCResult> =>
+    invokeIpc(IPC_CHANNELS.INSIGHTS_UPDATE_MODEL_CONFIG, projectId, sessionId, modelConfig),
+
  // Event Listeners
  onInsightsStreamChunk: (
    callback: (projectId: string, chunk: InsightsStreamChunk) => void
@@ -14,6 +14,7 @@ import { createIpcListener, invokeIpc, sendIpc, IpcListenerCleanup } from './ipc
 export interface RoadmapAPI {
  // Operations
  getRoadmap: (projectId: string) => Promise<IPCResult<Roadmap | null>>;
+  getRoadmapStatus: (projectId: string) => Promise<IPCResult<{ isRunning: boolean }>>;
  saveRoadmap: (projectId: string, roadmap: Roadmap) => Promise<IPCResult>;
  generateRoadmap: (projectId: string, enableCompetitorAnalysis?: boolean) => void;
  refreshRoadmap: (projectId: string, enableCompetitorAnalysis?: boolean) => void;
@@ -51,6 +52,9 @@ export const createRoadmapAPI = (): RoadmapAPI => ({
  getRoadmap: (projectId: string): Promise<IPCResult<Roadmap | null>> =>
    invokeIpc(IPC_CHANNELS.ROADMAP_GET, projectId),

+  getRoadmapStatus: (projectId: string): Promise<IPCResult<{ isRunning: boolean }>> =>
+    invokeIpc(IPC_CHANNELS.ROADMAP_GET_STATUS, projectId),
+
  saveRoadmap: (projectId: string, roadmap: Roadmap): Promise<IPCResult> =>
    invokeIpc(IPC_CHANNELS.ROADMAP_SAVE, projectId, roadmap),

@@ -37,6 +37,7 @@ import { OnboardingWizard } from './components/onboarding';
 import { AppUpdateNotification } from './components/AppUpdateNotification';
 import { UsageIndicator } from './components/UsageIndicator';
 import { ProactiveSwapListener } from './components/ProactiveSwapListener';
+import { GitHubSetupModal } from './components/GitHubSetupModal';
 import { useProjectStore, loadProjects, addProject, initializeProject } from './stores/project-store';
 import { useTaskStore, loadTasks } from './stores/task-store';
 import { useSettingsStore, loadSettings } from './stores/settings-store';
@@ -68,8 +69,14 @@ export function App() {
  const [showInitDialog, setShowInitDialog] = useState(false);
  const [pendingProject, setPendingProject] = useState<Project | null>(null);
  const [isInitializing, setIsInitializing] = useState(false);
+  const [initSuccess, setInitSuccess] = useState(false);
+  const [initError, setInitError] = useState<string | null>(null);
  const [skippedInitProjectId, setSkippedInitProjectId] = useState<string | null>(null);

+  // GitHub setup state (shown after Auto Claude init)
+  const [showGitHubSetup, setShowGitHubSetup] = useState(false);
+  const [gitHubSetupProject, setGitHubSetupProject] = useState<Project | null>(null);
+
  // Get selected project
  const selectedProject = projects.find((p) => p.id === selectedProjectId);

@@ -130,12 +137,17 @@ export function App() {

  // Check if selected project needs initialization (e.g., .auto-claude folder was deleted)
  useEffect(() => {
+    // Don't show dialog while initialization is in progress
+    if (isInitializing) return;
+
    if (selectedProject && !selectedProject.autoBuildPath && skippedInitProjectId !== selectedProject.id) {
      // Project exists but isn't initialized - show init dialog
      setPendingProject(selectedProject);
+      setInitError(null); // Clear any previous errors
+      setInitSuccess(false); // Reset success flag
      setShowInitDialog(true);
    }
-  }, [selectedProject, skippedInitProjectId]);
+  }, [selectedProject, skippedInitProjectId, isInitializing]);

  // Load tasks when project changes
  useEffect(() => {
@@ -224,6 +236,8 @@ export function App() {
        if (project && !project.autoBuildPath) {
          // Project doesn't have Auto Claude initialized, show init dialog
          setPendingProject(project);
+          setInitError(null); // Clear any previous errors
+          setInitSuccess(false); // Reset success flag
          setShowInitDialog(true);
        }
      }
@@ -235,31 +249,107 @@ export function App() {
  const handleInitialize = async () => {
    if (!pendingProject) return;

+    const projectId = pendingProject.id;
+    console.log('[InitDialog] Starting initialization for project:', projectId);
    setIsInitializing(true);
+    setInitSuccess(false);
+    setInitError(null); // Clear any previous errors
    try {
-      const result = await initializeProject(pendingProject.id);
+      const result = await initializeProject(projectId);
+      console.log('[InitDialog] Initialization result:', result);
+
      if (result?.success) {
+        console.log('[InitDialog] Initialization successful, closing dialog');
+        // Get the updated project from store
+        const updatedProject = useProjectStore.getState().projects.find(p => p.id === projectId);
+        console.log('[InitDialog] Updated project:', updatedProject);
+
+        // Mark as successful to prevent onOpenChange from treating this as a skip
+        setInitSuccess(true);
+        setIsInitializing(false);
+
+        // Now close the dialog
        setShowInitDialog(false);
        setPendingProject(null);
+
+        // Show GitHub setup modal
+        if (updatedProject) {
+          setGitHubSetupProject(updatedProject);
+          setShowGitHubSetup(true);
+        }
+      } else {
+        // Initialization failed - show error but keep dialog open
+        console.log('[InitDialog] Initialization failed, showing error');
+        const errorMessage = result?.error || 'Failed to initialize Auto Claude. Please try again.';
+        setInitError(errorMessage);
+        setIsInitializing(false);
      }
-    } finally {
+    } catch (error) {
+      // Unexpected error occurred
+      console.error('[InitDialog] Unexpected error during initialization:', error);
+      const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+      setInitError(errorMessage);
      setIsInitializing(false);
    }
  };

+  const handleGitHubSetupComplete = async (settings: {
+    githubToken: string;
+    githubRepo: string;
+    mainBranch: string;
+  }) => {
+    if (!gitHubSetupProject) return;
+
+    try {
+      // NOTE: settings.githubToken is a GitHub access token (from gh CLI),
+      // NOT a Claude Code OAuth token. They are different things:
+      // - GitHub token: for GitHub API access (repo operations)
+      // - Claude token: for Claude AI access (run.py, roadmap, etc.)
+      // The user needs to separately authenticate with Claude using 'claude setup-token'
+
+      // Update project env config with GitHub settings
+      await window.electronAPI.updateProjectEnv(gitHubSetupProject.id, {
+        githubEnabled: true,
+        githubToken: settings.githubToken, // GitHub token for repo access
+        githubRepo: settings.githubRepo
+      });
+
+      // Update project settings with mainBranch
+      await window.electronAPI.updateProjectSettings(gitHubSetupProject.id, {
+        mainBranch: settings.mainBranch
+      });
+
+      // Refresh projects to get updated data
+      await loadProjects();
+    } catch (error) {
+      console.error('Failed to save GitHub settings:', error);
+    }
+
+    setShowGitHubSetup(false);
+    setGitHubSetupProject(null);
+  };
+
+  const handleGitHubSetupSkip = () => {
+    setShowGitHubSetup(false);
+    setGitHubSetupProject(null);
+  };
+
  const handleSkipInit = () => {
+    console.log('[InitDialog] User skipped initialization');
    if (pendingProject) {
      setSkippedInitProjectId(pendingProject.id);
    }
    setShowInitDialog(false);
    setPendingProject(null);
+    setInitError(null); // Clear any error when skipping
+    setInitSuccess(false); // Reset success flag
  };

  const handleGoToTask = (taskId: string) => {
    // Switch to kanban view
    setActiveView('kanban');
-    // Find and select the task
-    const task = tasks.find((t) => t.id === taskId);
+    // Find and select the task (match by id or specId)
+    const task = tasks.find((t) => t.id === taskId || t.specId === taskId);
    if (task) {
      setSelectedTask(task);
    }
@@ -340,10 +430,13 @@ export function App() {
                  <Insights projectId={selectedProjectId} />
                )}
                {activeView === 'github-issues' && selectedProjectId && (
-                  <GitHubIssues onOpenSettings={() => {
-                    setSettingsInitialProjectSection('github');
-                    setIsSettingsDialogOpen(true);
-                  }} />
+                  <GitHubIssues
+                    onOpenSettings={() => {
+                      setSettingsInitialProjectSection('github');
+                      setIsSettingsDialogOpen(true);
+                    }}
+                    onNavigateToTask={handleGoToTask}
+                  />
                )}
                {activeView === 'changelog' && selectedProjectId && (
                  <Changelog />
@@ -414,7 +507,10 @@ export function App() {

        {/* Initialize Auto Claude Dialog */}
        <Dialog open={showInitDialog} onOpenChange={(open) => {
-          if (!open) {
+          console.log('[InitDialog] onOpenChange called', { open, pendingProject: !!pendingProject, isInitializing, initSuccess });
+          // Only trigger skip if user manually closed the dialog
+          // Don't trigger if: successful init, no pending project, or currently initializing
+          if (!open && pendingProject && !isInitializing && !initSuccess) {
            handleSkipInit();
          }
        }}>
@@ -450,6 +546,19 @@ export function App() {
                  </div>
                </div>
              )}
+              {initError && (
+                <div className="mt-4 rounded-lg border border-destructive/50 bg-destructive/10 p-4 text-sm">
+                  <div className="flex items-start gap-2">
+                    <AlertCircle className="h-4 w-4 text-destructive mt-0.5 shrink-0" />
+                    <div>
+                      <p className="font-medium text-destructive">Initialization Failed</p>
+                      <p className="text-muted-foreground mt-1">
+                        {initError}
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              )}
            </div>
            <DialogFooter>
              <Button variant="outline" onClick={handleSkipInit} disabled={isInitializing}>
@@ -475,6 +584,17 @@ export function App() {
          </DialogContent>
        </Dialog>

+        {/* GitHub Setup Modal - shows after Auto Claude init to configure GitHub */}
+        {gitHubSetupProject && (
+          <GitHubSetupModal
+            open={showGitHubSetup}
+            onOpenChange={setShowGitHubSetup}
+            project={gitHubSetupProject}
+            onComplete={handleGitHubSetupComplete}
+            onSkip={handleGitHubSetupSkip}
+          />
+        )}
+
        {/* Rate Limit Modal - shows when Claude Code hits usage limits (terminal) */}
        <RateLimitModal />

@@ -0,0 +1,370 @@
+/**
+ * AgentProfileSelector - Reusable component for selecting agent profile in forms
+ *
+ * Provides a dropdown for quick profile selection (Auto, Complex, Balanced, Quick)
+ * with an inline "Custom" option that reveals model and thinking level selects.
+ * The "Auto" profile shows per-phase model configuration.
+ *
+ * Used in TaskCreationWizard and TaskEditDialog.
+ */
+import { useState } from 'react';
+import { Brain, Scale, Zap, Sliders, Sparkles, ChevronDown, ChevronUp } from 'lucide-react';
+import { Label } from './ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from './ui/select';
+import {
+  DEFAULT_AGENT_PROFILES,
+  AVAILABLE_MODELS,
+  THINKING_LEVELS,
+  DEFAULT_PHASE_MODELS,
+  DEFAULT_PHASE_THINKING
+} from '../../shared/constants';
+import type { ModelType, ThinkingLevel } from '../../shared/types';
+import type { PhaseModelConfig, PhaseThinkingConfig } from '../../shared/types/settings';
+import { cn } from '../lib/utils';
+
+interface AgentProfileSelectorProps {
+  /** Currently selected profile ID ('auto', 'complex', 'balanced', 'quick', or 'custom') */
+  profileId: string;
+  /** Current model value (fallback for non-auto profiles) */
+  model: ModelType | '';
+  /** Current thinking level value (fallback for non-auto profiles) */
+  thinkingLevel: ThinkingLevel | '';
+  /** Phase model configuration (for auto profile) */
+  phaseModels?: PhaseModelConfig;
+  /** Phase thinking configuration (for auto profile) */
+  phaseThinking?: PhaseThinkingConfig;
+  /** Called when profile selection changes */
+  onProfileChange: (profileId: string, model: ModelType, thinkingLevel: ThinkingLevel) => void;
+  /** Called when model changes (in custom mode) */
+  onModelChange: (model: ModelType) => void;
+  /** Called when thinking level changes (in custom mode) */
+  onThinkingLevelChange: (level: ThinkingLevel) => void;
+  /** Called when phase models change (in auto mode) */
+  onPhaseModelsChange?: (phaseModels: PhaseModelConfig) => void;
+  /** Called when phase thinking changes (in auto mode) */
+  onPhaseThinkingChange?: (phaseThinking: PhaseThinkingConfig) => void;
+  /** Whether the selector is disabled */
+  disabled?: boolean;
+}
+
+const iconMap: Record<string, React.ElementType> = {
+  Brain,
+  Scale,
+  Zap,
+  Sparkles
+};
+
+const PHASE_LABELS: Record<keyof PhaseModelConfig, { label: string; description: string }> = {
+  spec: { label: 'Spec Creation', description: 'Discovery, requirements, context gathering' },
+  planning: { label: 'Planning', description: 'Implementation planning and architecture' },
+  coding: { label: 'Coding', description: 'Actual code implementation' },
+  qa: { label: 'QA Review', description: 'Quality assurance and validation' }
+};
+
+export function AgentProfileSelector({
+  profileId,
+  model,
+  thinkingLevel,
+  phaseModels,
+  phaseThinking,
+  onProfileChange,
+  onModelChange,
+  onThinkingLevelChange,
+  onPhaseModelsChange,
+  onPhaseThinkingChange,
+  disabled
+}: AgentProfileSelectorProps) {
+  const [showPhaseDetails, setShowPhaseDetails] = useState(false);
+
+  const isCustom = profileId === 'custom';
+  const isAuto = profileId === 'auto';
+
+  // Use provided phase configs or defaults
+  const currentPhaseModels = phaseModels || DEFAULT_PHASE_MODELS;
+  const currentPhaseThinking = phaseThinking || DEFAULT_PHASE_THINKING;
+
+  const handleProfileSelect = (selectedId: string) => {
+    if (selectedId === 'custom') {
+      // Keep current model/thinking level, just mark as custom
+      onProfileChange('custom', model as ModelType || 'sonnet', thinkingLevel as ThinkingLevel || 'medium');
+    } else if (selectedId === 'auto') {
+      // Auto profile - set defaults
+      const autoProfile = DEFAULT_AGENT_PROFILES.find(p => p.id === 'auto');
+      if (autoProfile) {
+        onProfileChange('auto', autoProfile.model, autoProfile.thinkingLevel);
+        // Initialize phase configs with defaults if callback provided
+        if (onPhaseModelsChange && autoProfile.phaseModels) {
+          onPhaseModelsChange(autoProfile.phaseModels);
+        }
+        if (onPhaseThinkingChange && autoProfile.phaseThinking) {
+          onPhaseThinkingChange(autoProfile.phaseThinking);
+        }
+      }
+    } else {
+      const profile = DEFAULT_AGENT_PROFILES.find(p => p.id === selectedId);
+      if (profile) {
+        onProfileChange(profile.id, profile.model, profile.thinkingLevel);
+      }
+    }
+  };
+
+  const handlePhaseModelChange = (phase: keyof PhaseModelConfig, value: ModelType) => {
+    if (onPhaseModelsChange) {
+      onPhaseModelsChange({
+        ...currentPhaseModels,
+        [phase]: value
+      });
+    }
+  };
+
+  const handlePhaseThinkingChange = (phase: keyof PhaseThinkingConfig, value: ThinkingLevel) => {
+    if (onPhaseThinkingChange) {
+      onPhaseThinkingChange({
+        ...currentPhaseThinking,
+        [phase]: value
+      });
+    }
+  };
+
+  // Get profile display info
+  const getProfileDisplay = () => {
+    if (isCustom) {
+      return {
+        icon: Sliders,
+        label: 'Custom Configuration',
+        description: 'Choose model & thinking level'
+      };
+    }
+    const profile = DEFAULT_AGENT_PROFILES.find(p => p.id === profileId);
+    if (profile) {
+      return {
+        icon: iconMap[profile.icon || 'Scale'] || Scale,
+        label: profile.name,
+        description: profile.description
+      };
+    }
+    // Default to balanced
+    return {
+      icon: Scale,
+      label: 'Balanced',
+      description: 'Good balance of speed and quality'
+    };
+  };
+
+  const display = getProfileDisplay();
+
+  return (
+    <div className="space-y-4">
+      {/* Agent Profile Selection */}
+      <div className="space-y-2">
+        <Label htmlFor="agent-profile" className="text-sm font-medium text-foreground">
+          Agent Profile
+        </Label>
+        <Select
+          value={profileId}
+          onValueChange={handleProfileSelect}
+          disabled={disabled}
+        >
+          <SelectTrigger id="agent-profile" className="h-10">
+            <SelectValue>
+              <div className="flex items-center gap-2">
+                <display.icon className="h-4 w-4" />
+                <span>{display.label}</span>
+              </div>
+            </SelectValue>
+          </SelectTrigger>
+          <SelectContent>
+            {DEFAULT_AGENT_PROFILES.map((profile) => {
+              const ProfileIcon = iconMap[profile.icon || 'Scale'] || Scale;
+              const modelLabel = AVAILABLE_MODELS.find(m => m.value === profile.model)?.label;
+              return (
+                <SelectItem key={profile.id} value={profile.id}>
+                  <div className="flex items-center gap-2">
+                    <ProfileIcon className="h-4 w-4 shrink-0" />
+                    <div>
+                      <span className="font-medium">{profile.name}</span>
+                      <span className="ml-2 text-xs text-muted-foreground">
+                        {profile.isAutoProfile
+                          ? '(per-phase optimization)'
+                          : `(${modelLabel} + ${profile.thinkingLevel})`
+                        }
+                      </span>
+                    </div>
+                  </div>
+                </SelectItem>
+              );
+            })}
+            <SelectItem value="custom">
+              <div className="flex items-center gap-2">
+                <Sliders className="h-4 w-4 shrink-0" />
+                <div>
+                  <span className="font-medium">Custom</span>
+                  <span className="ml-2 text-xs text-muted-foreground">
+                    (Choose model & thinking level)
+                  </span>
+                </div>
+              </div>
+            </SelectItem>
+          </SelectContent>
+        </Select>
+        <p className="text-xs text-muted-foreground">
+          {display.description}
+        </p>
+      </div>
+
+      {/* Auto Profile - Phase Configuration */}
+      {isAuto && (
+        <div className="space-y-3 rounded-lg border border-border bg-muted/30 p-4">
+          {/* Phase Summary */}
+          <div className="space-y-2">
+            <button
+              type="button"
+              onClick={() => setShowPhaseDetails(!showPhaseDetails)}
+              className={cn(
+                'flex w-full items-center justify-between text-sm',
+                'text-muted-foreground hover:text-foreground transition-colors'
+              )}
+              disabled={disabled}
+            >
+              <span className="font-medium text-foreground">Phase Configuration</span>
+              {showPhaseDetails ? (
+                <ChevronUp className="h-4 w-4" />
+              ) : (
+                <ChevronDown className="h-4 w-4" />
+              )}
+            </button>
+
+            {/* Compact summary when collapsed */}
+            {!showPhaseDetails && (
+              <div className="grid grid-cols-2 gap-2 text-xs">
+                {(Object.keys(PHASE_LABELS) as Array<keyof PhaseModelConfig>).map((phase) => {
+                  const modelLabel = AVAILABLE_MODELS.find(m => m.value === currentPhaseModels[phase])?.label?.replace('Claude ', '') || currentPhaseModels[phase];
+                  return (
+                    <div key={phase} className="flex items-center justify-between rounded bg-background/50 px-2 py-1">
+                      <span className="text-muted-foreground">{PHASE_LABELS[phase].label}:</span>
+                      <span className="font-medium">{modelLabel}</span>
+                    </div>
+                  );
+                })}
+              </div>
+            )}
+          </div>
+
+          {/* Detailed Phase Configuration */}
+          {showPhaseDetails && (
+            <div className="space-y-4 pt-2">
+              {(Object.keys(PHASE_LABELS) as Array<keyof PhaseModelConfig>).map((phase) => (
+                <div key={phase} className="space-y-2">
+                  <div className="flex items-center justify-between">
+                    <Label className="text-xs font-medium text-muted-foreground">
+                      {PHASE_LABELS[phase].label}
+                    </Label>
+                    <span className="text-xs text-muted-foreground">
+                      {PHASE_LABELS[phase].description}
+                    </span>
+                  </div>
+                  <div className="grid grid-cols-2 gap-2">
+                    <Select
+                      value={currentPhaseModels[phase]}
+                      onValueChange={(value) => handlePhaseModelChange(phase, value as ModelType)}
+                      disabled={disabled}
+                    >
+                      <SelectTrigger className="h-8 text-xs">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {AVAILABLE_MODELS.map((m) => (
+                          <SelectItem key={m.value} value={m.value}>
+                            {m.label}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    <Select
+                      value={currentPhaseThinking[phase]}
+                      onValueChange={(value) => handlePhaseThinkingChange(phase, value as ThinkingLevel)}
+                      disabled={disabled}
+                    >
+                      <SelectTrigger className="h-8 text-xs">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {THINKING_LEVELS.map((level) => (
+                          <SelectItem key={level.value} value={level.value}>
+                            {level.label}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Custom Configuration (shown only when custom is selected) */}
+      {isCustom && (
+        <div className="space-y-4 rounded-lg border border-border bg-muted/30 p-4">
+          {/* Model Selection */}
+          <div className="space-y-2">
+            <Label htmlFor="custom-model" className="text-xs font-medium text-muted-foreground">
+              Model
+            </Label>
+            <Select
+              value={model}
+              onValueChange={(value) => onModelChange(value as ModelType)}
+              disabled={disabled}
+            >
+              <SelectTrigger id="custom-model" className="h-9">
+                <SelectValue placeholder="Select model" />
+              </SelectTrigger>
+              <SelectContent>
+                {AVAILABLE_MODELS.map((m) => (
+                  <SelectItem key={m.value} value={m.value}>
+                    {m.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          {/* Thinking Level Selection */}
+          <div className="space-y-2">
+            <Label htmlFor="custom-thinking" className="text-xs font-medium text-muted-foreground">
+              Thinking Level
+            </Label>
+            <Select
+              value={thinkingLevel}
+              onValueChange={(value) => onThinkingLevelChange(value as ThinkingLevel)}
+              disabled={disabled}
+            >
+              <SelectTrigger id="custom-thinking" className="h-9">
+                <SelectValue placeholder="Select thinking level" />
+              </SelectTrigger>
+              <SelectContent>
+                {THINKING_LEVELS.map((level) => (
+                  <SelectItem key={level.value} value={level.value}>
+                    <div className="flex items-center gap-2">
+                      <span>{level.label}</span>
+                      <span className="text-xs text-muted-foreground">
+                        - {level.description}
+                      </span>
+                    </div>
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
@@ -0,0 +1,105 @@
+import { useState } from 'react';
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+  DialogDescription
+} from './ui/dialog';
+import { Button } from './ui/button';
+import { Label } from './ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from './ui/select';
+import { AVAILABLE_MODELS, THINKING_LEVELS } from '../../shared/constants';
+import type { InsightsModelConfig } from '../../shared/types';
+import type { ModelType, ThinkingLevel } from '../../shared/types';
+
+interface CustomModelModalProps {
+  currentConfig?: InsightsModelConfig;
+  onSave: (config: InsightsModelConfig) => void;
+  onClose: () => void;
+}
+
+export function CustomModelModal({ currentConfig, onSave, onClose }: CustomModelModalProps) {
+  const [model, setModel] = useState<ModelType>(
+    currentConfig?.model || 'sonnet'
+  );
+  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevel>(
+    currentConfig?.thinkingLevel || 'medium'
+  );
+
+  const handleSave = () => {
+    onSave({
+      profileId: 'custom',
+      model,
+      thinkingLevel
+    });
+  };
+
+  return (
+    <Dialog open onOpenChange={onClose}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>Custom Model Configuration</DialogTitle>
+          <DialogDescription>
+            Configure the model and thinking level for this chat session.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4 py-4">
+          <div className="space-y-2">
+            <Label htmlFor="model-select">Model</Label>
+            <Select value={model} onValueChange={(v) => setModel(v as ModelType)}>
+              <SelectTrigger id="model-select">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {AVAILABLE_MODELS.map((m) => (
+                  <SelectItem key={m.value} value={m.value}>
+                    {m.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="thinking-select">Thinking Level</Label>
+            <Select value={thinkingLevel} onValueChange={(v) => setThinkingLevel(v as ThinkingLevel)}>
+              <SelectTrigger id="thinking-select">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {THINKING_LEVELS.map((level) => (
+                  <SelectItem key={level.value} value={level.value}>
+                    <div className="flex items-center gap-2">
+                      <span className="font-medium">{level.label}</span>
+                      <span className="text-xs text-muted-foreground">
+                        {level.description}
+                      </span>
+                    </div>
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button onClick={handleSave}>
+            Apply
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
@@ -1,4 +1,4 @@
-import { useDraggable } from '@dnd-kit/core';
+import { useState, useRef, useEffect, type DragEvent } from 'react';
 import { ChevronRight, ChevronDown, Folder, File, FileCode, FileJson, FileText, FileImage, Loader2 } from 'lucide-react';
 import { cn } from '../lib/utils';
 import type { FileNode } from '../../shared/types';
@@ -70,15 +70,19 @@ export function FileTreeItem({
  isLoading,
  onToggle,
 }: FileTreeItemProps) {
-  const { attributes, listeners, setNodeRef, isDragging } = useDraggable({
-    id: node.path,
-    data: {
-      type: 'file',
-      path: node.path,
-      name: node.name,
-      isDirectory: node.isDirectory
-    }
-  });
+  const [isDragging, setIsDragging] = useState(false);
+  const dragImageRef = useRef<HTMLDivElement | null>(null);
+
+  // Cleanup drag image on unmount to prevent memory leaks
+  // This handles cases where component unmounts mid-drag or dragend doesn't fire
+  useEffect(() => {
+    return () => {
+      if (dragImageRef.current && dragImageRef.current.parentNode) {
+        dragImageRef.current.parentNode.removeChild(dragImageRef.current);
+        dragImageRef.current = null;
+      }
+    };
+  }, []);

  const handleClick = (e: React.MouseEvent) => {
    e.stopPropagation();
@@ -94,15 +98,62 @@ export function FileTreeItem({
    }
  };

+  const handleDragStart = (e: DragEvent<HTMLDivElement>) => {
+    e.stopPropagation();
+    setIsDragging(true);
+
+    // Set the drag data as JSON
+    const dragData = {
+      type: 'file-reference',
+      path: node.path,
+      name: node.name,
+      isDirectory: node.isDirectory
+    };
+    e.dataTransfer.setData('application/json', JSON.stringify(dragData));
+    e.dataTransfer.setData('text/plain', `@${node.name}`);
+    e.dataTransfer.effectAllowed = 'copy';
+
+    // Create a custom drag image using safe DOM manipulation (no innerHTML)
+    const dragImage = document.createElement('div');
+    dragImage.className = 'flex items-center gap-2 bg-card border border-primary rounded-md px-3 py-2 shadow-lg text-sm';
+    
+    const iconSpan = document.createElement('span');
+    iconSpan.textContent = node.isDirectory ? '📁' : '📄';
+    
+    const nameSpan = document.createElement('span');
+    nameSpan.textContent = node.name;
+    
+    dragImage.appendChild(iconSpan);
+    dragImage.appendChild(nameSpan);
+    dragImage.style.position = 'absolute';
+    dragImage.style.top = '-1000px';
+    dragImage.style.left = '-1000px';
+    document.body.appendChild(dragImage);
+    e.dataTransfer.setDragImage(dragImage, 0, 0);
+
+    // Store reference for cleanup in dragend
+    dragImageRef.current = dragImage;
+  };
+
+  const handleDragEnd = () => {
+    setIsDragging(false);
+
+    // Clean up drag image element
+    if (dragImageRef.current && dragImageRef.current.parentNode) {
+      dragImageRef.current.parentNode.removeChild(dragImageRef.current);
+      dragImageRef.current = null;
+    }
+  };
+
  return (
    <div
-      ref={setNodeRef}
-      {...attributes}
-      {...listeners}
+      draggable
+      onDragStart={handleDragStart}
+      onDragEnd={handleDragEnd}
      className={cn(
        'flex items-center gap-1 py-1 px-2 rounded cursor-grab select-none',
        'hover:bg-accent/50 transition-colors',
-        isDragging && 'opacity-50 bg-accent'
+        isDragging && 'opacity-50 bg-accent ring-2 ring-primary'
      )}
      style={{ paddingLeft: `${depth * 12 + 8}px` }}
      onClick={handleClick}
@@ -1,5 +1,6 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useMemo } from 'react';
 import { useProjectStore } from '../stores/project-store';
+import { useTaskStore } from '../stores/task-store';
 import { useGitHubIssues, useGitHubInvestigation, useIssueFiltering } from './github-issues/hooks';
 import {
  NotConnectedState,
@@ -12,10 +13,11 @@ import {
 import type { GitHubIssue } from '../../shared/types';
 import type { GitHubIssuesProps } from './github-issues/types';

-export function GitHubIssues({ onOpenSettings }: GitHubIssuesProps) {
+export function GitHubIssues({ onOpenSettings, onNavigateToTask }: GitHubIssuesProps) {
  const projects = useProjectStore((state) => state.projects);
  const selectedProjectId = useProjectStore((state) => state.selectedProjectId);
  const selectedProject = projects.find((p) => p.id === selectedProjectId);
+  const tasks = useTaskStore((state) => state.tasks);

  const {
    issues,
@@ -43,6 +45,17 @@ export function GitHubIssues({ onOpenSettings }: GitHubIssuesProps) {
  const [showInvestigateDialog, setShowInvestigateDialog] = useState(false);
  const [selectedIssueForInvestigation, setSelectedIssueForInvestigation] = useState<GitHubIssue | null>(null);

+  // Build a map of GitHub issue numbers to task IDs for quick lookup
+  const issueToTaskMap = useMemo(() => {
+    const map = new Map<number, string>();
+    for (const task of tasks) {
+      if (task.metadata?.githubIssueNumber) {
+        map.set(task.metadata.githubIssueNumber, task.specId || task.id);
+      }
+    }
+    return map;
+  }, [tasks]);
+
  const handleInvestigate = useCallback((issue: GitHubIssue) => {
    setSelectedIssueForInvestigation(issue);
    setShowInvestigateDialog(true);
@@ -110,6 +123,8 @@ export function GitHubIssues({ onOpenSettings }: GitHubIssuesProps) {
                  ? lastInvestigationResult
                  : null
              }
+              linkedTaskId={issueToTaskMap.get(selectedIssue.number)}
+              onViewTask={onNavigateToTask}
            />
          ) : (
            <EmptyState message="Select an issue to view details" />
@@ -0,0 +1,465 @@
+import { useState, useEffect } from 'react';
+import {
+  Github,
+  GitBranch,
+  Key,
+  Loader2,
+  CheckCircle2,
+  AlertCircle,
+  ChevronRight,
+  Sparkles
+} from 'lucide-react';
+import { Button } from './ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from './ui/dialog';
+import { Label } from './ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from './ui/select';
+import { GitHubOAuthFlow } from './project-settings/GitHubOAuthFlow';
+import { ClaudeOAuthFlow } from './project-settings/ClaudeOAuthFlow';
+import type { Project, ProjectSettings } from '../../shared/types';
+
+interface GitHubSetupModalProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  project: Project;
+  onComplete: (settings: { githubToken: string; githubRepo: string; mainBranch: string }) => void;
+  onSkip?: () => void;
+}
+
+type SetupStep = 'github-auth' | 'claude-auth' | 'repo' | 'branch' | 'complete';
+
+/**
+ * Setup Modal - Required setup flow after Auto Claude initialization
+ *
+ * Flow:
+ * 1. Authenticate with GitHub (via gh CLI OAuth) - for repo operations
+ * 2. Authenticate with Claude (via claude CLI OAuth) - for AI features
+ * 3. Detect/confirm repository
+ * 4. Select base branch for tasks (with recommended default)
+ */
+export function GitHubSetupModal({
+  open,
+  onOpenChange,
+  project,
+  onComplete,
+  onSkip
+}: GitHubSetupModalProps) {
+  const [step, setStep] = useState<SetupStep>('github-auth');
+  const [githubToken, setGithubToken] = useState<string | null>(null);
+  const [githubRepo, setGithubRepo] = useState<string | null>(null);
+  const [detectedRepo, setDetectedRepo] = useState<string | null>(null);
+  const [branches, setBranches] = useState<string[]>([]);
+  const [selectedBranch, setSelectedBranch] = useState<string | null>(null);
+  const [recommendedBranch, setRecommendedBranch] = useState<string | null>(null);
+  const [isLoadingBranches, setIsLoadingBranches] = useState(false);
+  const [isLoadingRepo, setIsLoadingRepo] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Reset state when modal opens
+  useEffect(() => {
+    if (open) {
+      setStep('github-auth');
+      setGithubToken(null);
+      setGithubRepo(null);
+      setDetectedRepo(null);
+      setBranches([]);
+      setSelectedBranch(null);
+      setRecommendedBranch(null);
+      setError(null);
+    }
+  }, [open]);
+
+  // Detect repository from git remote when auth succeeds
+  const detectRepository = async () => {
+    setIsLoadingRepo(true);
+    setError(null);
+
+    try {
+      // Try to detect repo from git remote
+      const result = await window.electronAPI.detectGitHubRepo(project.path);
+      if (result.success && result.data) {
+        setDetectedRepo(result.data);
+        setGithubRepo(result.data);
+        setStep('branch');
+        // Immediately load branches
+        await loadBranches(result.data);
+      } else {
+        // No remote detected, show repo input step
+        setStep('repo');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to detect repository');
+      setStep('repo');
+    } finally {
+      setIsLoadingRepo(false);
+    }
+  };
+
+  // Load branches from GitHub
+  const loadBranches = async (repo: string) => {
+    setIsLoadingBranches(true);
+    setError(null);
+
+    try {
+      // Get branches from GitHub API
+      const result = await window.electronAPI.getGitHubBranches(repo, githubToken!);
+      if (result.success && result.data) {
+        setBranches(result.data);
+
+        // Detect recommended branch (main > master > develop > first)
+        const recommended = detectRecommendedBranch(result.data);
+        setRecommendedBranch(recommended);
+        setSelectedBranch(recommended);
+      } else {
+        setError(result.error || 'Failed to load branches');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load branches');
+    } finally {
+      setIsLoadingBranches(false);
+    }
+  };
+
+  // Detect recommended branch from list
+  const detectRecommendedBranch = (branchList: string[]): string | null => {
+    const priorities = ['main', 'master', 'develop', 'dev'];
+    for (const priority of priorities) {
+      if (branchList.includes(priority)) {
+        return priority;
+      }
+    }
+    return branchList[0] || null;
+  };
+
+  // Handle GitHub OAuth success
+  const handleGitHubAuthSuccess = async (token: string) => {
+    setGithubToken(token);
+    // Move to Claude auth step
+    setStep('claude-auth');
+  };
+
+  // Handle Claude OAuth success
+  const handleClaudeAuthSuccess = async () => {
+    // Claude token is already saved to active profile by the OAuth flow
+    // Move to repo detection
+    await detectRepository();
+  };
+
+  // Handle branch selection complete
+  const handleComplete = () => {
+    if (githubToken && githubRepo && selectedBranch) {
+      onComplete({
+        githubToken,
+        githubRepo,
+        mainBranch: selectedBranch
+      });
+    }
+  };
+
+  // Render step content
+  const renderStepContent = () => {
+    switch (step) {
+      case 'github-auth':
+        return (
+          <>
+            <DialogHeader>
+              <DialogTitle className="flex items-center gap-2">
+                <Github className="h-5 w-5" />
+                Connect to GitHub
+              </DialogTitle>
+              <DialogDescription>
+                Auto Claude requires GitHub to manage your code branches and keep tasks up to date.
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4">
+              <GitHubOAuthFlow
+                onSuccess={handleGitHubAuthSuccess}
+                onCancel={onSkip}
+              />
+            </div>
+          </>
+        );
+
+      case 'claude-auth':
+        return (
+          <>
+            <DialogHeader>
+              <DialogTitle className="flex items-center gap-2">
+                <Key className="h-5 w-5" />
+                Connect to Claude AI
+              </DialogTitle>
+              <DialogDescription>
+                Auto Claude uses Claude AI for intelligent features like Roadmap generation, Task automation, and Ideation.
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4">
+              <ClaudeOAuthFlow
+                onSuccess={handleClaudeAuthSuccess}
+                onCancel={onSkip}
+              />
+            </div>
+          </>
+        );
+
+      case 'repo':
+        return (
+          <>
+            <DialogHeader>
+              <DialogTitle className="flex items-center gap-2">
+                <Github className="h-5 w-5" />
+                Repository Not Detected
+              </DialogTitle>
+              <DialogDescription>
+                We couldn't detect a GitHub repository for this project. Please ensure your project has a GitHub remote configured.
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4 space-y-4">
+              <div className="rounded-lg border border-warning/30 bg-warning/10 p-4">
+                <div className="flex items-start gap-3">
+                  <AlertCircle className="h-5 w-5 text-warning mt-0.5" />
+                  <div className="space-y-2">
+                    <p className="text-sm font-medium">No GitHub remote found</p>
+                    <p className="text-xs text-muted-foreground">
+                      To use Auto Claude, your project needs to be connected to a GitHub repository.
+                    </p>
+                    <div className="text-xs font-mono bg-muted p-2 rounded mt-2">
+                      git remote add origin https://github.com/owner/repo.git
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              {error && (
+                <div className="rounded-lg bg-destructive/10 border border-destructive/30 p-3 text-sm text-destructive">
+                  {error}
+                </div>
+              )}
+            </div>
+
+            <DialogFooter>
+              {onSkip && (
+                <Button variant="outline" onClick={onSkip}>
+                  Skip for now
+                </Button>
+              )}
+              <Button onClick={detectRepository} disabled={isLoadingRepo}>
+                {isLoadingRepo ? (
+                  <>
+                    <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                    Checking...
+                  </>
+                ) : (
+                  'Retry Detection'
+                )}
+              </Button>
+            </DialogFooter>
+          </>
+        );
+
+      case 'branch':
+        return (
+          <>
+            <DialogHeader>
+              <DialogTitle className="flex items-center gap-2">
+                <GitBranch className="h-5 w-5" />
+                Select Base Branch
+              </DialogTitle>
+              <DialogDescription>
+                Choose which branch Auto Claude should use as the base for creating task branches.
+              </DialogDescription>
+            </DialogHeader>
+
+            <div className="py-4 space-y-4">
+              {/* Show detected repo */}
+              {detectedRepo && (
+                <div className="flex items-center gap-2 text-sm">
+                  <Github className="h-4 w-4 text-muted-foreground" />
+                  <span className="text-muted-foreground">Repository:</span>
+                  <code className="px-2 py-0.5 bg-muted rounded font-mono text-xs">
+                    {detectedRepo}
+                  </code>
+                  <CheckCircle2 className="h-4 w-4 text-success" />
+                </div>
+              )}
+
+              {/* Branch selector */}
+              <div className="space-y-2">
+                <Label>Base Branch</Label>
+                <Select
+                  value={selectedBranch || ''}
+                  onValueChange={setSelectedBranch}
+                  disabled={isLoadingBranches || branches.length === 0}
+                >
+                  <SelectTrigger>
+                    {isLoadingBranches ? (
+                      <div className="flex items-center gap-2">
+                        <Loader2 className="h-3 w-3 animate-spin" />
+                        <span>Loading branches...</span>
+                      </div>
+                    ) : (
+                      <SelectValue placeholder="Select a branch" />
+                    )}
+                  </SelectTrigger>
+                  <SelectContent>
+                    {branches.map((branch) => (
+                      <SelectItem key={branch} value={branch}>
+                        <div className="flex items-center gap-2">
+                          <span>{branch}</span>
+                          {branch === recommendedBranch && (
+                            <span className="flex items-center gap-1 text-xs text-success">
+                              <Sparkles className="h-3 w-3" />
+                              Recommended
+                            </span>
+                          )}
+                        </div>
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                <p className="text-xs text-muted-foreground">
+                  All tasks will be created from branches like{' '}
+                  <code className="px-1 bg-muted rounded">auto-claude/task-name</code>
+                  {selectedBranch && (
+                    <> based on <code className="px-1 bg-muted rounded">{selectedBranch}</code></>
+                  )}
+                </p>
+              </div>
+
+              {/* Info about branch selection */}
+              <div className="rounded-lg border border-info/30 bg-info/5 p-3">
+                <div className="flex items-start gap-2">
+                  <Sparkles className="h-4 w-4 text-info mt-0.5" />
+                  <div className="text-xs text-muted-foreground">
+                    <p className="font-medium text-foreground">Why select a branch?</p>
+                    <p className="mt-1">
+                      Auto Claude creates isolated workspaces for each task. Selecting the right base branch ensures
+                      your tasks start with the latest code from your main development line.
+                    </p>
+                  </div>
+                </div>
+              </div>
+
+              {error && (
+                <div className="rounded-lg bg-destructive/10 border border-destructive/30 p-3 text-sm text-destructive">
+                  {error}
+                </div>
+              )}
+            </div>
+
+            <DialogFooter>
+              {onSkip && (
+                <Button variant="outline" onClick={onSkip}>
+                  Skip for now
+                </Button>
+              )}
+              <Button
+                onClick={handleComplete}
+                disabled={!selectedBranch || isLoadingBranches}
+              >
+                <CheckCircle2 className="mr-2 h-4 w-4" />
+                Complete Setup
+              </Button>
+            </DialogFooter>
+          </>
+        );
+
+      case 'complete':
+        return (
+          <>
+            <DialogHeader>
+              <DialogTitle className="flex items-center gap-2">
+                <CheckCircle2 className="h-5 w-5 text-success" />
+                Setup Complete
+              </DialogTitle>
+            </DialogHeader>
+
+            <div className="py-8 flex flex-col items-center justify-center">
+              <div className="h-16 w-16 rounded-full bg-success/10 flex items-center justify-center mb-4">
+                <CheckCircle2 className="h-8 w-8 text-success" />
+              </div>
+              <p className="text-sm text-muted-foreground text-center">
+                Auto Claude is ready to use! You can now create tasks that will be
+                automatically based on <code className="px-1 bg-muted rounded">{selectedBranch}</code>.
+              </p>
+            </div>
+          </>
+        );
+    }
+  };
+
+  // Progress indicator
+  const renderProgress = () => {
+    const steps: { label: string }[] = [
+      { label: 'Authenticate' },
+      { label: 'Configure' },
+    ];
+
+    // Don't show progress on complete step
+    if (step === 'complete') return null;
+
+    // Map steps to progress indices
+    // Auth steps (github-auth, claude-auth, repo) = 0
+    // Config steps (branch) = 1
+    const currentIndex =
+      step === 'github-auth' ? 0 :
+      step === 'claude-auth' ? 0 :
+      step === 'repo' ? 0 :
+      1;
+
+    return (
+      <div className="flex items-center justify-center gap-2 mb-4">
+        {steps.map((s, index) => (
+          <div key={index} className="flex items-center">
+            <div
+              className={`flex items-center justify-center w-6 h-6 rounded-full text-xs font-medium ${
+                index < currentIndex
+                  ? 'bg-success text-success-foreground'
+                  : index === currentIndex
+                  ? 'bg-primary text-primary-foreground'
+                  : 'bg-muted text-muted-foreground'
+              }`}
+            >
+              {index < currentIndex ? (
+                <CheckCircle2 className="h-4 w-4" />
+              ) : (
+                index + 1
+              )}
+            </div>
+            <span className={`ml-2 text-xs ${
+              index === currentIndex ? 'text-foreground font-medium' : 'text-muted-foreground'
+            }`}>
+              {s.label}
+            </span>
+            {index < steps.length - 1 && (
+              <ChevronRight className="h-4 w-4 mx-2 text-muted-foreground" />
+            )}
+          </div>
+        ))}
+      </div>
+    );
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        {renderProgress()}
+        {renderStepContent()}
+      </DialogContent>
+    </Dialog>
+  );
+}
@@ -29,12 +29,14 @@ import {
  switchSession,
  deleteSession,
  renameSession,
+  updateModelConfig,
  createTaskFromSuggestion,
  setupInsightsListeners
 } from '../stores/insights-store';
 import { loadTasks } from '../stores/task-store';
 import { ChatHistorySidebar } from './ChatHistorySidebar';
-import type { InsightsChatMessage } from '../../shared/types';
+import { InsightsModelSelector } from './InsightsModelSelector';
+import type { InsightsChatMessage, InsightsModelConfig } from '../../shared/types';
 import {
  TASK_CATEGORY_LABELS,
  TASK_CATEGORY_COLORS,
@@ -141,6 +143,13 @@ export function Insights({ projectId }: InsightsProps) {
    }
  };

+  const handleModelConfigChange = async (config: InsightsModelConfig) => {
+    // If we have a session, persist the config
+    if (session?.id) {
+      await updateModelConfig(projectId, session.id, config);
+    }
+  };
+
  const isLoading = status.phase === 'thinking' || status.phase === 'streaming';
  const messages = session?.messages || [];

@@ -187,14 +196,21 @@ export function Insights({ projectId }: InsightsProps) {
              </p>
            </div>
          </div>
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={handleNewSession}
-          >
-            <Plus className="mr-2 h-4 w-4" />
-            New Chat
-          </Button>
+          <div className="flex items-center gap-2">
+            <InsightsModelSelector
+              currentConfig={session?.modelConfig}
+              onConfigChange={handleModelConfigChange}
+              disabled={isLoading}
+            />
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={handleNewSession}
+            >
+              <Plus className="mr-2 h-4 w-4" />
+              New Chat
+            </Button>
+          </div>
        </div>

      {/* Messages */}
@@ -0,0 +1,144 @@
+import { useState } from 'react';
+import { Brain, Scale, Zap, Sliders, Check } from 'lucide-react';
+import { Button } from './ui/button';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  DropdownMenuLabel
+} from './ui/dropdown-menu';
+import { DEFAULT_AGENT_PROFILES, AVAILABLE_MODELS } from '../../shared/constants';
+import type { InsightsModelConfig } from '../../shared/types';
+import { CustomModelModal } from './CustomModelModal';
+
+interface InsightsModelSelectorProps {
+  currentConfig?: InsightsModelConfig;
+  onConfigChange: (config: InsightsModelConfig) => void;
+  disabled?: boolean;
+}
+
+const iconMap: Record<string, React.ElementType> = {
+  Brain,
+  Scale,
+  Zap
+};
+
+export function InsightsModelSelector({
+  currentConfig,
+  onConfigChange,
+  disabled
+}: InsightsModelSelectorProps) {
+  const [showCustomModal, setShowCustomModal] = useState(false);
+
+  // Default to 'balanced' if no config
+  const selectedProfileId = currentConfig?.profileId || 'balanced';
+  const profile = DEFAULT_AGENT_PROFILES.find(p => p.id === selectedProfileId);
+
+  // Get the appropriate icon
+  const Icon = selectedProfileId === 'custom'
+    ? Sliders
+    : (profile?.icon ? iconMap[profile.icon] : Scale);
+
+  const handleSelectProfile = (profileId: string) => {
+    if (profileId === 'custom') {
+      setShowCustomModal(true);
+      return;
+    }
+
+    const selected = DEFAULT_AGENT_PROFILES.find(p => p.id === profileId);
+    if (selected) {
+      onConfigChange({
+        profileId: selected.id,
+        model: selected.model,
+        thinkingLevel: selected.thinkingLevel
+      });
+    }
+  };
+
+  const handleCustomSave = (config: InsightsModelConfig) => {
+    onConfigChange(config);
+    setShowCustomModal(false);
+  };
+
+  // Build display text for current selection
+  const getDisplayText = () => {
+    if (selectedProfileId === 'custom' && currentConfig) {
+      const modelLabel = AVAILABLE_MODELS.find(m => m.value === currentConfig.model)?.label || currentConfig.model;
+      return `${modelLabel} + ${currentConfig.thinkingLevel}`;
+    }
+    return profile?.name || 'Balanced';
+  };
+
+  return (
+    <>
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-8 gap-2 px-2"
+            disabled={disabled}
+            title={`Model: ${getDisplayText()}`}
+          >
+            <Icon className="h-4 w-4" />
+            <span className="hidden text-xs text-muted-foreground sm:inline">
+              {getDisplayText()}
+            </span>
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent align="end" className="w-64">
+          <DropdownMenuLabel>Agent Profile</DropdownMenuLabel>
+          {DEFAULT_AGENT_PROFILES.map((p) => {
+            const ProfileIcon = iconMap[p.icon || 'Brain'];
+            const isSelected = selectedProfileId === p.id;
+            const modelLabel = AVAILABLE_MODELS.find(m => m.value === p.model)?.label;
+            return (
+              <DropdownMenuItem
+                key={p.id}
+                onClick={() => handleSelectProfile(p.id)}
+                className="flex cursor-pointer items-center gap-2"
+              >
+                <ProfileIcon className="h-4 w-4 shrink-0" />
+                <div className="min-w-0 flex-1">
+                  <div className="font-medium">{p.name}</div>
+                  <div className="truncate text-xs text-muted-foreground">
+                    {modelLabel} + {p.thinkingLevel}
+                  </div>
+                </div>
+                {isSelected && (
+                  <Check className="h-4 w-4 shrink-0 text-primary" />
+                )}
+              </DropdownMenuItem>
+            );
+          })}
+          <DropdownMenuSeparator />
+          <DropdownMenuItem
+            onClick={() => handleSelectProfile('custom')}
+            className="flex cursor-pointer items-center gap-2"
+          >
+            <Sliders className="h-4 w-4 shrink-0" />
+            <div className="flex-1">
+              <div className="font-medium">Custom...</div>
+              <div className="text-xs text-muted-foreground">
+                Choose model & thinking level
+              </div>
+            </div>
+            {selectedProfileId === 'custom' && (
+              <Check className="h-4 w-4 shrink-0 text-primary" />
+            )}
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>
+
+      {showCustomModal && (
+        <CustomModelModal
+          currentConfig={currentConfig}
+          onSave={handleCustomSave}
+          onClose={() => setShowCustomModal(false)}
+        />
+      )}
+    </>
+  );
+}
@@ -238,6 +238,7 @@ export function ProjectSettings({ project, open, onOpenChange }: ProjectSettings
                  onUpdateConfig={updateEnvConfig}
                  gitHubConnectionStatus={gitHubConnectionStatus}
                  isCheckingGitHub={isCheckingGitHub}
+                  projectName={project.name}
                />

                <Separator />
@@ -199,12 +199,15 @@ export function Sidebar({
  const handleInitialize = async () => {
    if (!pendingProject) return;

+    const projectId = pendingProject.id;
    setIsInitializing(true);
    try {
-      const result = await initializeProject(pendingProject.id);
+      const result = await initializeProject(projectId);
      if (result?.success) {
-        setShowInitDialog(false);
+        // Clear pendingProject FIRST before closing dialog
+        // This prevents onOpenChange from triggering skip logic
        setPendingProject(null);
+        setShowInitDialog(false);
      }
    } finally {
      setIsInitializing(false);
@@ -474,7 +477,12 @@ export function Sidebar({
      </div>

      {/* Initialize Auto Claude Dialog */}
-      <Dialog open={showInitDialog} onOpenChange={setShowInitDialog}>
+      <Dialog open={showInitDialog} onOpenChange={(open) => {
+        // Only allow closing if user manually closes (not during initialization)
+        if (!open && !isInitializing) {
+          handleSkipInit();
+        }
+      }}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle className="flex items-center gap-2">
@@ -1,15 +1,5 @@
 import { useState, useEffect, useCallback, useRef, useMemo, type ClipboardEvent, type DragEvent } from 'react';
-import {
-  DndContext,
-  DragOverlay,
-  useDroppable,
-  type DragEndEvent,
-  type DragStartEvent,
-  PointerSensor,
-  useSensor,
-  useSensors
-} from '@dnd-kit/core';
-import { Loader2, ChevronDown, ChevronUp, Image as ImageIcon, X, RotateCcw, File, Folder, FolderTree, FileDown } from 'lucide-react';
+import { Loader2, ChevronDown, ChevronUp, Image as ImageIcon, X, RotateCcw, FolderTree, GitBranch } from 'lucide-react';
 import {
  Dialog,
  DialogContent,
@@ -40,10 +30,12 @@ import {
 } from './ImageUpload';
 import { ReferencedFilesSection } from './ReferencedFilesSection';
 import { TaskFileExplorerDrawer } from './TaskFileExplorerDrawer';
+import { AgentProfileSelector } from './AgentProfileSelector';
 import { createTask, saveDraft, loadDraft, clearDraft, isDraftEmpty } from '../stores/task-store';
 import { useProjectStore } from '../stores/project-store';
 import { cn } from '../lib/utils';
 import type { TaskCategory, TaskPriority, TaskComplexity, TaskImpact, TaskMetadata, ImageAttachment, TaskDraft, ModelType, ThinkingLevel, ReferencedFile } from '../../shared/types';
+import type { PhaseModelConfig, PhaseThinkingConfig } from '../../shared/types/settings';
 import {
  TASK_CATEGORY_LABELS,
  TASK_PRIORITY_LABELS,
@@ -53,8 +45,8 @@ import {
  MAX_REFERENCED_FILES,
  ALLOWED_IMAGE_TYPES_DISPLAY,
  DEFAULT_AGENT_PROFILES,
-  AVAILABLE_MODELS,
-  THINKING_LEVELS
+  DEFAULT_PHASE_MODELS,
+  DEFAULT_PHASE_THINKING
 } from '../../shared/constants';
 import { useSettingsStore } from '../stores/settings-store';

@@ -73,7 +65,7 @@ export function TaskCreationWizard({
  const { settings } = useSettingsStore();
  const selectedProfile = DEFAULT_AGENT_PROFILES.find(
    p => p.id === settings.selectedAgentProfile
-  ) || DEFAULT_AGENT_PROFILES.find(p => p.id === 'balanced')!;
+  ) || DEFAULT_AGENT_PROFILES.find(p => p.id === 'auto')!;

  const [title, setTitle] = useState('');
  const [description, setDescription] = useState('');
@@ -82,6 +74,15 @@ export function TaskCreationWizard({
  const [showAdvanced, setShowAdvanced] = useState(false);
  const [showImages, setShowImages] = useState(false);
  const [showFileExplorer, setShowFileExplorer] = useState(false);
+  const [showGitOptions, setShowGitOptions] = useState(false);
+
+  // Git options state
+  // Use a special value to represent "use project default" since Radix UI Select doesn't allow empty string values
+  const PROJECT_DEFAULT_BRANCH = '__project_default__';
+  const [branches, setBranches] = useState<string[]>([]);
+  const [isLoadingBranches, setIsLoadingBranches] = useState(false);
+  const [baseBranch, setBaseBranch] = useState<string>(PROJECT_DEFAULT_BRANCH);
+  const [projectDefaultBranch, setProjectDefaultBranch] = useState<string>('');

  // Get project path from project store
  const projects = useProjectStore((state) => state.projects);
@@ -97,8 +98,16 @@ export function TaskCreationWizard({
  const [impact, setImpact] = useState<TaskImpact | ''>('');

  // Model configuration (initialized from selected agent profile)
+  const [profileId, setProfileId] = useState<string>(settings.selectedAgentProfile || 'auto');
  const [model, setModel] = useState<ModelType | ''>(selectedProfile.model);
  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevel | ''>(selectedProfile.thinkingLevel);
+  // Auto profile - per-phase configuration
+  const [phaseModels, setPhaseModels] = useState<PhaseModelConfig | undefined>(
+    selectedProfile.phaseModels || DEFAULT_PHASE_MODELS
+  );
+  const [phaseThinking, setPhaseThinking] = useState<PhaseThinkingConfig | undefined>(
+    selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING
+  );

  // Image attachments
  const [images, setImages] = useState<ImageAttachment[]>([]);
@@ -113,43 +122,12 @@ export function TaskCreationWizard({
  const [isDraftRestored, setIsDraftRestored] = useState(false);
  const [pasteSuccess, setPasteSuccess] = useState(false);

-  // Drag-and-drop state for file references
-  const [activeDragData, setActiveDragData] = useState<{
-    path: string;
-    name: string;
-    isDirectory: boolean;
-  } | null>(null);
-
  // Ref for the textarea to handle paste events
  const descriptionRef = useRef<HTMLTextAreaElement>(null);

  // Drag-and-drop state for images over textarea
  const [isDragOverTextarea, setIsDragOverTextarea] = useState(false);

-  // Setup drag sensors with distance constraint to prevent accidental drags
-  const sensors = useSensors(
-    useSensor(PointerSensor, {
-      activationConstraint: {
-        distance: 8, // 8px movement required before drag starts
-      },
-    })
-  );
-
-  // Setup drop zone for file references (entire form)
-  const { setNodeRef: setDropRef, isOver: isOverDropZone } = useDroppable({
-    id: 'file-drop-zone',
-    data: { type: 'file-drop-zone' }
-  });
-
-  // Setup drop zone for description textarea (inline @mentions)
-  const { setNodeRef: setTextareaDropRef, isOver: isOverTextarea } = useDroppable({
-    id: 'description-drop-zone',
-    data: { type: 'description-drop-zone' }
-  });
-
-  // Determine if drop zone is at capacity
-  const isAtMaxFiles = referencedFiles.length >= MAX_REFERENCED_FILES;
-
  // Load draft when dialog opens, or initialize from selected profile
  useEffect(() => {
    if (open && projectId) {
@@ -161,9 +139,12 @@ export function TaskCreationWizard({
        setPriority(draft.priority);
        setComplexity(draft.complexity);
        setImpact(draft.impact);
-        // Load model/thinkingLevel from draft if present, otherwise use profile defaults
+        // Load model/thinkingLevel/profileId from draft if present, otherwise use profile defaults
+        setProfileId(draft.profileId || settings.selectedAgentProfile || 'auto');
        setModel(draft.model || selectedProfile.model);
        setThinkingLevel(draft.thinkingLevel || selectedProfile.thinkingLevel);
+        setPhaseModels(draft.phaseModels || selectedProfile.phaseModels || DEFAULT_PHASE_MODELS);
+        setPhaseThinking(draft.phaseThinking || selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING);
        setImages(draft.images);
        setReferencedFiles(draft.referencedFiles ?? []);
        setRequireReviewBeforeCoding(draft.requireReviewBeforeCoding ?? false);
@@ -178,12 +159,60 @@ export function TaskCreationWizard({
        }
        // Note: Referenced Files section is always visible, no need to expand
      } else {
-        // No draft - initialize model/thinkingLevel from selected profile
+        // No draft - initialize from selected profile
+        setProfileId(settings.selectedAgentProfile || 'auto');
        setModel(selectedProfile.model);
        setThinkingLevel(selectedProfile.thinkingLevel);
+        setPhaseModels(selectedProfile.phaseModels || DEFAULT_PHASE_MODELS);
+        setPhaseThinking(selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING);
      }
    }
-  }, [open, projectId, selectedProfile.model, selectedProfile.thinkingLevel]);
+  }, [open, projectId, settings.selectedAgentProfile, selectedProfile.model, selectedProfile.thinkingLevel]);
+
+  // Fetch branches and project default branch when dialog opens
+  useEffect(() => {
+    if (open && projectPath) {
+      fetchBranches();
+      fetchProjectDefaultBranch();
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open, projectPath]);
+
+  const fetchBranches = async () => {
+    if (!projectPath) return;
+
+    setIsLoadingBranches(true);
+    try {
+      const result = await window.electronAPI.getGitBranches(projectPath);
+      if (result.success && result.data) {
+        setBranches(result.data);
+      }
+    } catch (err) {
+      console.error('Failed to fetch branches:', err);
+    } finally {
+      setIsLoadingBranches(false);
+    }
+  };
+
+  const fetchProjectDefaultBranch = async () => {
+    if (!projectId) return;
+
+    try {
+      // Get env config to check if there's a configured default branch
+      const result = await window.electronAPI.getProjectEnv(projectId);
+      if (result.success && result.data?.defaultBranch) {
+        setProjectDefaultBranch(result.data.defaultBranch);
+      } else if (projectPath) {
+        // Fall back to auto-detect
+        const detectResult = await window.electronAPI.detectMainBranch(projectPath);
+        if (detectResult.success && detectResult.data) {
+          setProjectDefaultBranch(detectResult.data);
+        }
+      }
+    } catch (err) {
+      console.error('Failed to fetch project default branch:', err);
+    }
+  };

  /**
   * Get current form state as a draft
@@ -196,13 +225,16 @@ export function TaskCreationWizard({
    priority,
    complexity,
    impact,
+    profileId,
    model,
    thinkingLevel,
+    phaseModels,
+    phaseThinking,
    images,
    referencedFiles,
    requireReviewBeforeCoding,
    savedAt: new Date()
-  }), [projectId, title, description, category, priority, complexity, impact, model, thinkingLevel, images, referencedFiles, requireReviewBeforeCoding]);
+  }), [projectId, title, description, category, priority, complexity, impact, profileId, model, thinkingLevel, phaseModels, phaseThinking, images, referencedFiles, requireReviewBeforeCoding]);
  /**
   * Handle paste event for screenshot support
   */
@@ -302,7 +334,7 @@ export function TaskCreationWizard({
  }, []);

  /**
-   * Handle drop on textarea for image files
+   * Handle drop on textarea for file references and images
   */
  const handleTextareaDrop = useCallback(
    async (e: DragEvent<HTMLTextAreaElement>) => {
@@ -312,6 +344,40 @@ export function TaskCreationWizard({

      if (isCreating) return;

+      // First, check for file reference drops (from the file explorer)
+      const jsonData = e.dataTransfer?.getData('application/json');
+      if (jsonData) {
+        try {
+          const data = JSON.parse(jsonData);
+          if (data.type === 'file-reference' && data.name) {
+            // Insert @mention at cursor position in the textarea
+            const textarea = descriptionRef.current;
+            if (textarea) {
+              const cursorPos = textarea.selectionStart || 0;
+              const textBefore = description.substring(0, cursorPos);
+              const textAfter = description.substring(cursorPos);
+
+              // Insert @mention at cursor position
+              const mention = `@${data.name}`;
+              const newDescription = textBefore + mention + textAfter;
+              setDescription(newDescription);
+
+              // Set cursor after the inserted mention
+              setTimeout(() => {
+                textarea.focus();
+                const newCursorPos = cursorPos + mention.length;
+                textarea.setSelectionRange(newCursorPos, newCursorPos);
+              }, 0);
+
+              return; // Don't process as image
+            }
+          }
+        } catch {
+          // Not valid JSON, continue to image handling
+        }
+      }
+
+      // Fall back to image file handling
      const files = e.dataTransfer?.files;
      if (!files || files.length === 0) return;

@@ -379,102 +445,9 @@ export function TaskCreationWizard({
        setTimeout(() => setPasteSuccess(false), 2000);
      }
    },
-    [images, isCreating]
+    [images, isCreating, description]
  );

-  /**
-   * Handle drag start - capture file data for overlay
-   */
-  const handleDragStart = useCallback((event: DragStartEvent) => {
-    const data = event.active.data.current as {
-      type: string;
-      path: string;
-      name: string;
-      isDirectory: boolean;
-    } | undefined;
-
-    if (data?.type === 'file') {
-      setActiveDragData({
-        path: data.path,
-        name: data.name,
-        isDirectory: data.isDirectory
-      });
-    }
-  }, []);
-
-  /**
-   * Handle drag end - insert @mention in description or add to referencedFiles
-   */
-  const handleDragEnd = useCallback((event: DragEndEvent) => {
-    const { active, over } = event;
-
-    // Clear drag state
-    setActiveDragData(null);
-
-    // If not dropped on a valid target, do nothing
-    if (!over) return;
-
-    const data = active.data.current as {
-      type?: string;
-      path?: string;
-      name?: string;
-      isDirectory?: boolean;
-    } | undefined;
-
-    // Only process file drops
-    if (data?.type !== 'file' || !data.path || !data.name) return;
-
-    // Handle drop on description textarea - insert inline @mention
-    if (over.id === 'description-drop-zone') {
-      const textarea = descriptionRef.current;
-      if (!textarea) return;
-
-      const cursorPos = textarea.selectionStart || 0;
-      const textBefore = description.substring(0, cursorPos);
-      const textAfter = description.substring(cursorPos);
-
-      // Insert @mention at cursor position
-      const mention = `@${data.name}`;
-      const newDescription = textBefore + mention + textAfter;
-      setDescription(newDescription);
-
-      // Set cursor after the inserted mention
-      setTimeout(() => {
-        textarea.focus();
-        const newCursorPos = cursorPos + mention.length;
-        textarea.setSelectionRange(newCursorPos, newCursorPos);
-      }, 0);
-
-      return;
-    }
-
-    // Handle drop on file-drop-zone - add to referenced files list
-    if (over.id === 'file-drop-zone') {
-      // Check if we're at the max limit
-      if (referencedFiles.length >= MAX_REFERENCED_FILES) {
-        setError(`Maximum of ${MAX_REFERENCED_FILES} referenced files allowed`);
-        return;
-      }
-
-      // Check for duplicates
-      if (referencedFiles.some(f => f.path === data.path)) {
-        // Silently skip duplicates
-        return;
-      }
-
-      // Add the file to referenced files
-      const newFile: ReferencedFile = {
-        id: crypto.randomUUID(),
-        path: data.path,
-        name: data.name,
-        isDirectory: data.isDirectory ?? false,
-        addedAt: new Date()
-      };
-
-      setReferencedFiles(prev => [...prev, newFile]);
-    }
-  }, [referencedFiles, description]);
-
  /**
   * Parse @mentions from description and create ReferencedFile entries
   * Merges with existing referencedFiles, avoiding duplicates
@@ -532,9 +505,17 @@ export function TaskCreationWizard({
      if (impact) metadata.impact = impact;
      if (model) metadata.model = model;
      if (thinkingLevel) metadata.thinkingLevel = thinkingLevel;
+      // Auto profile - per-phase configuration
+      if (profileId === 'auto') {
+        metadata.isAutoProfile = true;
+        if (phaseModels) metadata.phaseModels = phaseModels;
+        if (phaseThinking) metadata.phaseThinking = phaseThinking;
+      }
      if (images.length > 0) metadata.attachedImages = images;
      if (allReferencedFiles.length > 0) metadata.referencedFiles = allReferencedFiles;
      if (requireReviewBeforeCoding) metadata.requireReviewBeforeCoding = true;
+      // Only include baseBranch if it's not the project default placeholder
+      if (baseBranch && baseBranch !== PROJECT_DEFAULT_BRANCH) metadata.baseBranch = baseBranch;

      // Title is optional - if empty, it will be auto-generated by the backend
      const task = await createTask(projectId, title.trim(), description.trim(), metadata);
@@ -561,16 +542,21 @@ export function TaskCreationWizard({
    setPriority('');
    setComplexity('');
    setImpact('');
-    // Reset model/thinkingLevel to selected profile defaults
+    // Reset to selected profile defaults
+    setProfileId(settings.selectedAgentProfile || 'auto');
    setModel(selectedProfile.model);
    setThinkingLevel(selectedProfile.thinkingLevel);
+    setPhaseModels(selectedProfile.phaseModels || DEFAULT_PHASE_MODELS);
+    setPhaseThinking(selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING);
    setImages([]);
    setReferencedFiles([]);
    setRequireReviewBeforeCoding(false);
+    setBaseBranch(PROJECT_DEFAULT_BRANCH);
    setError(null);
    setShowAdvanced(false);
    setShowImages(false);
    setShowFileExplorer(false);
+    setShowGitOptions(false);
    setIsDraftRestored(false);
    setPasteSuccess(false);
  };
@@ -605,53 +591,17 @@ export function TaskCreationWizard({
  };

  return (
-    <DndContext
-      sensors={sensors}
-      onDragStart={handleDragStart}
-      onDragEnd={handleDragEnd}
-    >
-      <Dialog open={open} onOpenChange={handleClose}>
-        <DialogContent
-          className={cn(
-            "max-h-[90vh] p-0 overflow-hidden transition-all duration-300 ease-out",
-            showFileExplorer ? "sm:max-w-[900px]" : "sm:max-w-[550px]"
-          )}
-          hideCloseButton={showFileExplorer}
-        >
-          <div className="flex h-full min-h-0 overflow-hidden">
-            {/* Form content - Drop zone wrapper */}
-            <div
-              ref={setDropRef}
-              className={cn(
-                "flex-1 flex flex-col p-6 min-w-0 min-h-0 overflow-y-auto relative transition-all duration-150 ease-out",
-                // Default state - no border
-                !activeDragData && "",
-                // Subtle visual feedback when dragging - border on the entire form
-                activeDragData && !isOverDropZone && "border-2 border-dashed border-muted-foreground/40 rounded-lg",
-                // Clear drop target feedback when over the form
-                activeDragData && isOverDropZone && !isAtMaxFiles && "border-2 border-solid border-info rounded-lg bg-info/5",
-                // Warning state when at capacity
-                activeDragData && isOverDropZone && isAtMaxFiles && "border-2 border-solid border-warning rounded-lg bg-warning/5"
-              )}
-            >
-              {/* Drop zone indicator overlay - shows when dragging over form */}
-              {activeDragData && isOverDropZone && (
-                <div className="absolute inset-0 z-50 flex items-center justify-center pointer-events-none rounded-lg">
-                  <div className={cn(
-                    "flex items-center gap-2 px-4 py-2 rounded-lg text-sm font-medium shadow-lg",
-                    isAtMaxFiles
-                      ? "bg-warning text-warning-foreground"
-                      : "bg-info text-info-foreground"
-                  )}>
-                    <FileDown className="h-4 w-4" />
-                    <span>
-                      {isAtMaxFiles
-                        ? `Maximum ${MAX_REFERENCED_FILES} files reached`
-                        : 'Drop file to add reference'}
-                    </span>
-                  </div>
-                </div>
-              )}
+    <Dialog open={open} onOpenChange={handleClose}>
+      <DialogContent
+        className={cn(
+          "max-h-[90vh] p-0 overflow-hidden transition-all duration-300 ease-out",
+          showFileExplorer ? "sm:max-w-[900px]" : "sm:max-w-[550px]"
+        )}
+        hideCloseButton={showFileExplorer}
+      >
+        <div className="flex h-full min-h-0 overflow-hidden">
+          {/* Form content */}
+          <div className="flex-1 flex flex-col p-6 min-w-0 min-h-0 overflow-y-auto relative">
        <DialogHeader>
          <div className="flex items-center justify-between">
            <DialogTitle className="text-foreground">Create New Task</DialogTitle>
@@ -684,8 +634,8 @@ export function TaskCreationWizard({
            <Label htmlFor="description" className="text-sm font-medium text-foreground">
              Description <span className="text-destructive">*</span>
            </Label>
-            {/* Wrap textarea in drop zone for file @mentions */}
-            <div ref={setTextareaDropRef} className="relative">
+            {/* Wrap textarea for file @mentions */}
+            <div className="relative">
              {/* Syntax highlight overlay for @mentions */}
              <div
                className="absolute inset-0 pointer-events-none overflow-hidden rounded-md border border-transparent"
@@ -728,20 +678,11 @@ export function TaskCreationWizard({
                disabled={isCreating}
                className={cn(
                  "resize-y min-h-[120px] max-h-[400px] relative bg-transparent",
-                  // Image drop feedback (native drops)
-                  isDragOverTextarea && !isCreating && "border-primary bg-primary/5 ring-2 ring-primary/20",
-                  // File reference drop feedback (dnd-kit drops for @mentions)
-                  activeDragData && isOverTextarea && "border-info bg-info/5 ring-2 ring-info/20"
+                  // Visual feedback when dragging over textarea
+                  isDragOverTextarea && !isCreating && "border-primary bg-primary/5 ring-2 ring-primary/20"
                )}
                style={{ caretColor: 'auto' }}
              />
-              {/* Drop indicator for file references */}
-              {activeDragData && isOverTextarea && (
-                <div className="absolute top-2 right-2 flex items-center gap-1 px-2 py-1 rounded-md bg-info text-info-foreground text-xs font-medium shadow-sm pointer-events-none z-10">
-                  <File className="h-3 w-3" />
-                  <span>Insert @{activeDragData.name}</span>
-                </div>
-              )}
            </div>
            <p className="text-xs text-muted-foreground">
              Tip: Drag files from the explorer to insert @references, or paste screenshots with {navigator.platform.includes('Mac') ? '⌘V' : 'Ctrl+V'}.
@@ -765,57 +706,24 @@ export function TaskCreationWizard({
            </p>
          </div>

-          {/* Model Selection */}
-          <div className="space-y-2">
-            <Label htmlFor="model" className="text-sm font-medium text-foreground">
-              Model
-            </Label>
-            <Select
-              value={model}
-              onValueChange={(value) => setModel(value as ModelType)}
-              disabled={isCreating}
-            >
-              <SelectTrigger id="model" className="h-9">
-                <SelectValue placeholder="Select model" />
-              </SelectTrigger>
-              <SelectContent>
-                {AVAILABLE_MODELS.map((m) => (
-                  <SelectItem key={m.value} value={m.value}>
-                    {m.label}
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
-            <p className="text-xs text-muted-foreground">
-              The Claude model to use for this task. Defaults to your selected agent profile.
-            </p>
-          </div>
-
-          {/* Thinking Level Selection */}
-          <div className="space-y-2">
-            <Label htmlFor="thinking-level" className="text-sm font-medium text-foreground">
-              Thinking Level
-            </Label>
-            <Select
-              value={thinkingLevel}
-              onValueChange={(value) => setThinkingLevel(value as ThinkingLevel)}
-              disabled={isCreating}
-            >
-              <SelectTrigger id="thinking-level" className="h-9">
-                <SelectValue placeholder="Select thinking level" />
-              </SelectTrigger>
-              <SelectContent>
-                {THINKING_LEVELS.map((level) => (
-                  <SelectItem key={level.value} value={level.value}>
-                    {level.label}
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
-            <p className="text-xs text-muted-foreground">
-              Extended thinking depth for complex reasoning. Higher levels use more tokens but provide deeper analysis.
-            </p>
-          </div>
+          {/* Agent Profile Selection */}
+          <AgentProfileSelector
+            profileId={profileId}
+            model={model}
+            thinkingLevel={thinkingLevel}
+            phaseModels={phaseModels}
+            phaseThinking={phaseThinking}
+            onProfileChange={(newProfileId, newModel, newThinkingLevel) => {
+              setProfileId(newProfileId);
+              setModel(newModel);
+              setThinkingLevel(newThinkingLevel);
+            }}
+            onModelChange={setModel}
+            onThinkingLevelChange={setThinkingLevel}
+            onPhaseModelsChange={setPhaseModels}
+            onPhaseThinkingChange={setPhaseThinking}
+            disabled={isCreating}
+          />

          {/* Paste Success Indicator */}
          {pasteSuccess && (
@@ -1041,6 +949,65 @@ export function TaskCreationWizard({
            </div>
          </div>

+          {/* Git Options Toggle */}
+          <button
+            type="button"
+            onClick={() => setShowGitOptions(!showGitOptions)}
+            className={cn(
+              'flex items-center gap-2 text-sm text-muted-foreground hover:text-foreground transition-colors',
+              'w-full justify-between py-2 px-3 rounded-md hover:bg-muted/50'
+            )}
+            disabled={isCreating}
+          >
+            <span className="flex items-center gap-2">
+              <GitBranch className="h-4 w-4" />
+              Git Options (optional)
+              {baseBranch && baseBranch !== PROJECT_DEFAULT_BRANCH && (
+                <span className="text-xs bg-primary/10 text-primary px-1.5 py-0.5 rounded">
+                  {baseBranch}
+                </span>
+              )}
+            </span>
+            {showGitOptions ? (
+              <ChevronUp className="h-4 w-4" />
+            ) : (
+              <ChevronDown className="h-4 w-4" />
+            )}
+          </button>
+
+          {/* Git Options */}
+          {showGitOptions && (
+            <div className="space-y-4 p-4 rounded-lg border border-border bg-muted/30">
+              <div className="space-y-2">
+                <Label htmlFor="base-branch" className="text-sm font-medium text-foreground">
+                  Base Branch (optional)
+                </Label>
+                <Select
+                  value={baseBranch}
+                  onValueChange={setBaseBranch}
+                  disabled={isCreating || isLoadingBranches}
+                >
+                  <SelectTrigger id="base-branch" className="h-9">
+                    <SelectValue placeholder={`Use project default${projectDefaultBranch ? ` (${projectDefaultBranch})` : ''}`} />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value={PROJECT_DEFAULT_BRANCH}>
+                      Use project default{projectDefaultBranch ? ` (${projectDefaultBranch})` : ''}
+                    </SelectItem>
+                    {branches.map((branch) => (
+                      <SelectItem key={branch} value={branch}>
+                        {branch}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                <p className="text-xs text-muted-foreground">
+                  Override the branch this task&apos;s worktree will be created from. Leave empty to use the project&apos;s configured default branch.
+                </p>
+              </div>
+            </div>
+          )}
+
          {/* Error */}
          {error && (
            <div className="flex items-start gap-2 rounded-lg bg-destructive/10 border border-destructive/30 p-3 text-sm text-destructive">
@@ -1083,33 +1050,18 @@ export function TaskCreationWizard({
            </Button>
          </div>
        </DialogFooter>
-            </div>
-
-            {/* File Explorer Drawer */}
-            {projectPath && (
-              <TaskFileExplorerDrawer
-                isOpen={showFileExplorer}
-                onClose={() => setShowFileExplorer(false)}
-                projectPath={projectPath}
-              />
-            )}
          </div>
-        </DialogContent>
-      </Dialog>

-      {/* Drag overlay - shows what's being dragged */}
-      <DragOverlay>
-        {activeDragData && (
-          <div className="flex items-center gap-2 bg-card border border-border rounded-md px-3 py-2 shadow-lg">
-            {activeDragData.isDirectory ? (
-              <Folder className="h-4 w-4 text-warning" />
-            ) : (
-              <File className="h-4 w-4 text-muted-foreground" />
-            )}
-            <span className="text-sm">{activeDragData.name}</span>
-          </div>
-        )}
-      </DragOverlay>
-    </DndContext>
+          {/* File Explorer Drawer */}
+          {projectPath && (
+            <TaskFileExplorerDrawer
+              isOpen={showFileExplorer}
+              onClose={() => setShowFileExplorer(false)}
+              projectPath={projectPath}
+            />
+          )}
+        </div>
+      </DialogContent>
+    </Dialog>
  );
 }
@@ -54,17 +54,23 @@ import {
  isValidImageMimeType,
  resolveFilename
 } from './ImageUpload';
+import { AgentProfileSelector } from './AgentProfileSelector';
 import { persistUpdateTask } from '../stores/task-store';
 import { cn } from '../lib/utils';
-import type { Task, ImageAttachment, TaskCategory, TaskPriority, TaskComplexity, TaskImpact } from '../../shared/types';
+import type { Task, ImageAttachment, TaskCategory, TaskPriority, TaskComplexity, TaskImpact, ModelType, ThinkingLevel } from '../../shared/types';
 import {
  TASK_CATEGORY_LABELS,
  TASK_PRIORITY_LABELS,
  TASK_COMPLEXITY_LABELS,
  TASK_IMPACT_LABELS,
  MAX_IMAGES_PER_TASK,
-  ALLOWED_IMAGE_TYPES_DISPLAY
+  ALLOWED_IMAGE_TYPES_DISPLAY,
+  DEFAULT_AGENT_PROFILES,
+  DEFAULT_PHASE_MODELS,
+  DEFAULT_PHASE_THINKING
 } from '../../shared/constants';
+import type { PhaseModelConfig, PhaseThinkingConfig } from '../../shared/types/settings';
+import { useSettingsStore } from '../stores/settings-store';

 /**
 * Props for the TaskEditDialog component
@@ -81,6 +87,12 @@ interface TaskEditDialogProps {
 }

 export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDialogProps) {
+  // Get selected agent profile from settings for defaults
+  const { settings } = useSettingsStore();
+  const selectedProfile = DEFAULT_AGENT_PROFILES.find(
+    p => p.id === settings.selectedAgentProfile
+  ) || DEFAULT_AGENT_PROFILES.find(p => p.id === 'auto')!;
+
  const [title, setTitle] = useState(task.title);
  const [description, setDescription] = useState(task.description);
  const [isSaving, setIsSaving] = useState(false);
@@ -95,6 +107,36 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
  const [complexity, setComplexity] = useState<TaskComplexity | ''>(task.metadata?.complexity || '');
  const [impact, setImpact] = useState<TaskImpact | ''>(task.metadata?.impact || '');

+  // Agent profile / model configuration
+  const [profileId, setProfileId] = useState<string>(() => {
+    // Check if task uses Auto profile
+    if (task.metadata?.isAutoProfile) {
+      return 'auto';
+    }
+    // Determine profile ID from task metadata or default to 'auto'
+    const taskModel = task.metadata?.model;
+    const taskThinking = task.metadata?.thinkingLevel;
+    if (taskModel && taskThinking) {
+      // Check if it matches a known profile
+      const matchingProfile = DEFAULT_AGENT_PROFILES.find(
+        p => p.model === taskModel && p.thinkingLevel === taskThinking && !p.isAutoProfile
+      );
+      return matchingProfile?.id || 'custom';
+    }
+    return settings.selectedAgentProfile || 'auto';
+  });
+  const [model, setModel] = useState<ModelType | ''>(task.metadata?.model || selectedProfile.model);
+  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevel | ''>(
+    task.metadata?.thinkingLevel || selectedProfile.thinkingLevel
+  );
+  // Auto profile - per-phase configuration
+  const [phaseModels, setPhaseModels] = useState<PhaseModelConfig | undefined>(
+    task.metadata?.phaseModels || selectedProfile.phaseModels || DEFAULT_PHASE_MODELS
+  );
+  const [phaseThinking, setPhaseThinking] = useState<PhaseThinkingConfig | undefined>(
+    task.metadata?.phaseThinking || selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING
+  );
+
  // Image attachments
  const [images, setImages] = useState<ImageAttachment[]>(task.metadata?.attachedImages || []);

@@ -118,6 +160,35 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
      setPriority(task.metadata?.priority || '');
      setComplexity(task.metadata?.complexity || '');
      setImpact(task.metadata?.impact || '');
+
+      // Reset model configuration
+      const taskModel = task.metadata?.model;
+      const taskThinking = task.metadata?.thinkingLevel;
+      const isAutoProfile = task.metadata?.isAutoProfile;
+
+      if (isAutoProfile) {
+        setProfileId('auto');
+        setModel(taskModel || selectedProfile.model);
+        setThinkingLevel(taskThinking || selectedProfile.thinkingLevel);
+        setPhaseModels(task.metadata?.phaseModels || DEFAULT_PHASE_MODELS);
+        setPhaseThinking(task.metadata?.phaseThinking || DEFAULT_PHASE_THINKING);
+      } else if (taskModel && taskThinking) {
+        const matchingProfile = DEFAULT_AGENT_PROFILES.find(
+          p => p.model === taskModel && p.thinkingLevel === taskThinking && !p.isAutoProfile
+        );
+        setProfileId(matchingProfile?.id || 'custom');
+        setModel(taskModel);
+        setThinkingLevel(taskThinking);
+        setPhaseModels(DEFAULT_PHASE_MODELS);
+        setPhaseThinking(DEFAULT_PHASE_THINKING);
+      } else {
+        setProfileId(settings.selectedAgentProfile || 'auto');
+        setModel(selectedProfile.model);
+        setThinkingLevel(selectedProfile.thinkingLevel);
+        setPhaseModels(selectedProfile.phaseModels || DEFAULT_PHASE_MODELS);
+        setPhaseThinking(selectedProfile.phaseThinking || DEFAULT_PHASE_THINKING);
+      }
+
      setImages(task.metadata?.attachedImages || []);
      setRequireReviewBeforeCoding(task.metadata?.requireReviewBeforeCoding ?? false);
      setError(null);
@@ -130,7 +201,7 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
      setShowImages((task.metadata?.attachedImages || []).length > 0);
      setPasteSuccess(false);
    }
-  }, [open, task]);
+  }, [open, task, settings.selectedAgentProfile, selectedProfile.model, selectedProfile.thinkingLevel]);

  /**
   * Handle paste event for screenshot support
@@ -328,6 +399,8 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
      priority !== (task.metadata?.priority || '') ||
      complexity !== (task.metadata?.complexity || '') ||
      impact !== (task.metadata?.impact || '') ||
+      model !== (task.metadata?.model || '') ||
+      thinkingLevel !== (task.metadata?.thinkingLevel || '') ||
      requireReviewBeforeCoding !== (task.metadata?.requireReviewBeforeCoding ?? false) ||
      JSON.stringify(images) !== JSON.stringify(task.metadata?.attachedImages || []);

@@ -346,6 +419,17 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
    if (priority) metadataUpdates.priority = priority;
    if (complexity) metadataUpdates.complexity = complexity;
    if (impact) metadataUpdates.impact = impact;
+    if (model) metadataUpdates.model = model as ModelType;
+    if (thinkingLevel) metadataUpdates.thinkingLevel = thinkingLevel as ThinkingLevel;
+    // Auto profile - per-phase configuration
+    if (profileId === 'auto') {
+      metadataUpdates.isAutoProfile = true;
+      if (phaseModels) metadataUpdates.phaseModels = phaseModels;
+      if (phaseThinking) metadataUpdates.phaseThinking = phaseThinking;
+    } else {
+      // Clear auto profile fields if switching away from auto
+      metadataUpdates.isAutoProfile = false;
+    }
    if (images.length > 0) metadataUpdates.attachedImages = images;
    metadataUpdates.requireReviewBeforeCoding = requireReviewBeforeCoding;

@@ -429,6 +513,25 @@ export function TaskEditDialog({ task, open, onOpenChange, onSaved }: TaskEditDi
            </p>
          </div>

+          {/* Agent Profile Selection */}
+          <AgentProfileSelector
+            profileId={profileId}
+            model={model}
+            thinkingLevel={thinkingLevel}
+            phaseModels={phaseModels}
+            phaseThinking={phaseThinking}
+            onProfileChange={(newProfileId, newModel, newThinkingLevel) => {
+              setProfileId(newProfileId);
+              setModel(newModel);
+              setThinkingLevel(newThinkingLevel);
+            }}
+            onModelChange={setModel}
+            onThinkingLevelChange={setThinkingLevel}
+            onPhaseModelsChange={setPhaseModels}
+            onPhaseThinkingChange={setPhaseThinking}
+            disabled={isSaving}
+          />
+
          {/* Paste Success Indicator */}
          {pasteSuccess && (
            <div className="flex items-center gap-2 text-sm text-success animate-in fade-in slide-in-from-top-1 duration-200">
@@ -1,4 +1,4 @@
-import { ExternalLink, User, Clock, MessageCircle, Sparkles, CheckCircle2 } from 'lucide-react';
+import { ExternalLink, User, Clock, MessageCircle, Sparkles, CheckCircle2, Eye } from 'lucide-react';
 import { Badge } from '../../ui/badge';
 import { Button } from '../../ui/button';
 import { Card, CardContent, CardHeader, CardTitle } from '../../ui/card';
@@ -11,7 +11,17 @@ import {
 import { formatDate } from '../utils';
 import type { IssueDetailProps } from '../types';

-export function IssueDetail({ issue, onInvestigate, investigationResult }: IssueDetailProps) {
+export function IssueDetail({ issue, onInvestigate, investigationResult, linkedTaskId, onViewTask }: IssueDetailProps) {
+  // Determine which task ID to use - either already linked or just created
+  const taskId = linkedTaskId || (investigationResult?.success ? investigationResult.taskId : undefined);
+  const hasLinkedTask = !!taskId;
+
+  const handleViewTask = () => {
+    if (taskId && onViewTask) {
+      onViewTask(taskId);
+    }
+  };
+
  return (
    <ScrollArea className="flex-1">
      <div className="p-4 space-y-4">
@@ -77,31 +87,48 @@ export function IssueDetail({ issue, onInvestigate, investigationResult }: Issue

        {/* Actions */}
        <div className="flex items-center gap-2">
-          <Button onClick={onInvestigate} className="flex-1">
-            <Sparkles className="h-4 w-4 mr-2" />
-            Create Task
-          </Button>
+          {hasLinkedTask ? (
+            <Button onClick={handleViewTask} className="flex-1" variant="secondary">
+              <Eye className="h-4 w-4 mr-2" />
+              View Task
+            </Button>
+          ) : (
+            <Button onClick={onInvestigate} className="flex-1">
+              <Sparkles className="h-4 w-4 mr-2" />
+              Create Task
+            </Button>
+          )}
        </div>

-        {/* Task Created Result */}
-        {investigationResult?.success && (
+        {/* Task Linked Info */}
+        {hasLinkedTask && (
          <Card className="bg-success/5 border-success/30">
            <CardHeader className="pb-2">
              <CardTitle className="text-sm flex items-center gap-2 text-success">
                <CheckCircle2 className="h-4 w-4" />
-                Task Created
+                Task Linked
              </CardTitle>
            </CardHeader>
            <CardContent className="text-sm space-y-2">
-              <p className="text-foreground">{investigationResult.analysis.summary}</p>
-              <div className="flex items-center gap-2">
-                <Badge className={GITHUB_COMPLEXITY_COLORS[investigationResult.analysis.estimatedComplexity]}>
-                  {investigationResult.analysis.estimatedComplexity}
-                </Badge>
-                <span className="text-xs text-muted-foreground">
-                  Task ID: {investigationResult.taskId}
-                </span>
-              </div>
+              {investigationResult?.success ? (
+                <>
+                  <p className="text-foreground">{investigationResult.analysis.summary}</p>
+                  <div className="flex items-center gap-2">
+                    <Badge className={GITHUB_COMPLEXITY_COLORS[investigationResult.analysis.estimatedComplexity]}>
+                      {investigationResult.analysis.estimatedComplexity}
+                    </Badge>
+                    <span className="text-xs text-muted-foreground">
+                      Task ID: {taskId}
+                    </span>
+                  </div>
+                </>
+              ) : (
+                <div className="flex items-center gap-2">
+                  <span className="text-xs text-muted-foreground">
+                    Task ID: {taskId}
+                  </span>
+                </div>
+              )}
            </CardContent>
          </Card>
        )}
@@ -4,6 +4,8 @@ export type FilterState = 'open' | 'closed' | 'all';

 export interface GitHubIssuesProps {
  onOpenSettings?: () => void;
+  /** Navigate to view a task in the kanban board */
+  onNavigateToTask?: (taskId: string) => void;
 }

 export interface IssueListItemProps {
@@ -17,6 +19,10 @@ export interface IssueDetailProps {
  issue: GitHubIssue;
  onInvestigate: () => void;
  investigationResult: GitHubInvestigationResult | null;
+  /** ID of existing task linked to this issue (from metadata.githubIssueNumber) */
+  linkedTaskId?: string;
+  /** Handler to navigate to view the linked task */
+  onViewTask?: (taskId: string) => void;
 }

 export interface InvestigationDialogProps {
@@ -18,12 +18,15 @@ import { Input } from '../ui/input';
 import { Label } from '../ui/label';
 import { Card, CardContent } from '../ui/card';
 import { Switch } from '../ui/switch';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../ui/select';
 import {
  Tooltip,
  TooltipContent,
  TooltipTrigger
 } from '../ui/tooltip';
 import { useSettingsStore } from '../../stores/settings-store';
+import type { GraphitiProviderType } from '../../../shared/types';
+import type { AppSettings } from '../../../shared/types/settings';

 interface GraphitiStepProps {
  onNext: () => void;
@@ -34,12 +37,52 @@ interface GraphitiStepProps {
 interface GraphitiConfig {
  enabled: boolean;
  falkorDbUri: string;
-  openAiApiKey: string;
+  llmProvider: GraphitiProviderType;
+  apiKey: string;
+  ollamaBaseUrl: string;  // For Ollama provider (no API key needed)
+}
+
+// Provider display info
+const PROVIDER_INFO: Record<GraphitiProviderType, {
+  name: string;
+  placeholder: string;
+  link: string;
+  requiresApiKey: boolean;
+  description?: string;
+}> = {
+  openai: { name: 'OpenAI', placeholder: 'sk-...', link: 'https://platform.openai.com/api-keys', requiresApiKey: true },
+  anthropic: { name: 'Anthropic', placeholder: 'sk-ant-...', link: 'https://console.anthropic.com/settings/keys', requiresApiKey: true },
+  google: { name: 'Google (Gemini)', placeholder: 'AIza...', link: 'https://aistudio.google.com/apikey', requiresApiKey: true },
+  groq: { name: 'Groq', placeholder: 'gsk_...', link: 'https://console.groq.com/keys', requiresApiKey: true },
+  ollama: {
+    name: 'Ollama',
+    placeholder: 'http://localhost:11434',
+    link: 'https://ollama.ai',
+    requiresApiKey: false,
+    description: 'Local LLM - no API key required'
+  },
+};
+
+// Helper to get the saved API key for a provider from settings
+function getApiKeyForProvider(provider: GraphitiProviderType, settings: AppSettings): string {
+  switch (provider) {
+    case 'openai': return settings.globalOpenAIApiKey || '';
+    case 'anthropic': return settings.globalAnthropicApiKey || '';
+    case 'google': return settings.globalGoogleApiKey || '';
+    case 'groq': return settings.globalGroqApiKey || '';
+    case 'ollama': return '';  // Ollama doesn't need an API key
+    default: return '';
+  }
+}
+
+// Helper to get the saved Ollama base URL from settings
+function getOllamaBaseUrl(settings: AppSettings): string {
+  return settings.ollamaBaseUrl || 'http://localhost:11434';
 }

 interface ValidationStatus {
  falkordb: { tested: boolean; success: boolean; message: string } | null;
-  openai: { tested: boolean; success: boolean; message: string } | null;
+  llm: { tested: boolean; success: boolean; message: string } | null;
 }

 /**
@@ -49,10 +92,14 @@ interface ValidationStatus {
 */
 export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
  const { settings, updateSettings } = useSettingsStore();
+  // Load saved provider preference, defaulting to 'openai'
+  const savedProvider = settings.graphitiLlmProvider || 'openai';
  const [config, setConfig] = useState<GraphitiConfig>({
    enabled: false,
    falkorDbUri: 'bolt://localhost:6379',  // Standard FalkorDB port, will be auto-detected from Docker
-    openAiApiKey: settings.globalOpenAIApiKey || ''
+    llmProvider: savedProvider,
+    apiKey: getApiKeyForProvider(savedProvider, settings),
+    ollamaBaseUrl: getOllamaBaseUrl(settings)
  });
  const [showApiKey, setShowApiKey] = useState(false);
  const [isSaving, setIsSaving] = useState(false);
@@ -63,7 +110,7 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
  const [isValidating, setIsValidating] = useState(false);
  const [validationStatus, setValidationStatus] = useState<ValidationStatus>({
    falkordb: null,
-    openai: null
+    llm: null
  });

  // Check Docker/Infrastructure availability on mount
@@ -99,23 +146,51 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
    setError(null);
    setSuccess(false);
    // Reset validation status when toggling
-    setValidationStatus({ falkordb: null, openai: null });
+    setValidationStatus({ falkordb: null, llm: null });
+  };
+
+  const handleProviderChange = (provider: GraphitiProviderType) => {
+    // Load saved API key or base URL for the selected provider
+    const savedKey = getApiKeyForProvider(provider, settings);
+    const savedOllamaUrl = getOllamaBaseUrl(settings);
+    setConfig(prev => ({
+      ...prev,
+      llmProvider: provider,
+      apiKey: savedKey,
+      ollamaBaseUrl: savedOllamaUrl
+    }));
+    setValidationStatus(prev => ({ ...prev, llm: null }));
+    setError(null);
  };

  const handleTestConnection = async () => {
-    if (!config.openAiApiKey.trim()) {
-      setError('Please enter an OpenAI API key to test the connection');
+    const providerName = PROVIDER_INFO[config.llmProvider].name;
+    const providerInfo = PROVIDER_INFO[config.llmProvider];
+
+    // Validate input based on provider type
+    if (providerInfo.requiresApiKey && !config.apiKey.trim()) {
+      setError(`Please enter a ${providerName} API key to test the connection`);
+      return;
+    }
+    if (config.llmProvider === 'ollama' && !config.ollamaBaseUrl.trim()) {
+      setError('Please enter the Ollama server URL to test the connection');
      return;
    }

    setIsValidating(true);
    setError(null);
-    setValidationStatus({ falkordb: null, openai: null });
+    setValidationStatus({ falkordb: null, llm: null });

    try {
+      // For now, we still use the OpenAI test endpoint, but pass the provider info
+      // TODO: Add provider-specific validation endpoints
+      // For Ollama, pass the base URL instead of API key
+      const testCredential = config.llmProvider === 'ollama'
+        ? config.ollamaBaseUrl.trim()
+        : config.apiKey.trim();
      const result = await window.electronAPI.testGraphitiConnection(
        config.falkorDbUri,
-        config.openAiApiKey.trim()
+        testCredential
      );

      if (result?.success && result?.data) {
@@ -125,7 +200,7 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
            success: result.data.falkordb.success,
            message: result.data.falkordb.message
          },
-          openai: {
+          llm: {
            tested: true,
            success: result.data.openai.success,
            message: result.data.openai.message
@@ -138,7 +213,7 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
            errors.push(`FalkorDB: ${result.data.falkordb.message}`);
          }
          if (!result.data.openai.success) {
-            errors.push(`OpenAI: ${result.data.openai.message}`);
+            errors.push(`${providerName}: ${result.data.openai.message}`);
          }
          if (errors.length > 0) {
            setError(errors.join('\n'));
@@ -161,8 +236,16 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
      return;
    }

-    if (!config.openAiApiKey.trim()) {
-      setError('OpenAI API key is required for Graphiti embeddings');
+    const providerName = PROVIDER_INFO[config.llmProvider].name;
+    const providerInfo = PROVIDER_INFO[config.llmProvider];
+
+    // Validate input based on provider type
+    if (providerInfo.requiresApiKey && !config.apiKey.trim()) {
+      setError(`${providerName} API key is required for Graphiti`);
+      return;
+    }
+    if (config.llmProvider === 'ollama' && !config.ollamaBaseUrl.trim()) {
+      setError('Ollama server URL is required for Graphiti');
      return;
    }

@@ -170,14 +253,41 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
    setError(null);

    try {
-      // Save OpenAI API key to global settings
-      const result = await window.electronAPI.saveSettings({
-        globalOpenAIApiKey: config.openAiApiKey.trim()
-      });
+      // Build settings update based on selected provider
+      const settingsUpdate: Record<string, string> = {
+        graphitiLlmProvider: config.llmProvider,
+      };
+
+      // Save the API key or base URL for the selected provider
+      if (config.llmProvider === 'openai') {
+        settingsUpdate.globalOpenAIApiKey = config.apiKey.trim();
+      } else if (config.llmProvider === 'anthropic') {
+        settingsUpdate.globalAnthropicApiKey = config.apiKey.trim();
+      } else if (config.llmProvider === 'google') {
+        settingsUpdate.globalGoogleApiKey = config.apiKey.trim();
+      } else if (config.llmProvider === 'groq') {
+        settingsUpdate.globalGroqApiKey = config.apiKey.trim();
+      } else if (config.llmProvider === 'ollama') {
+        settingsUpdate.ollamaBaseUrl = config.ollamaBaseUrl.trim();
+      }
+
+      const result = await window.electronAPI.saveSettings(settingsUpdate);

      if (result?.success) {
-        // Update local settings store
-        updateSettings({ globalOpenAIApiKey: config.openAiApiKey.trim() });
+        // Update local settings store for all providers
+        const storeUpdate: Record<string, string> = {};
+        if (config.llmProvider === 'openai') {
+          storeUpdate.globalOpenAIApiKey = config.apiKey.trim();
+        } else if (config.llmProvider === 'anthropic') {
+          storeUpdate.globalAnthropicApiKey = config.apiKey.trim();
+        } else if (config.llmProvider === 'google') {
+          storeUpdate.globalGoogleApiKey = config.apiKey.trim();
+        } else if (config.llmProvider === 'groq') {
+          storeUpdate.globalGroqApiKey = config.apiKey.trim();
+        } else if (config.llmProvider === 'ollama') {
+          storeUpdate.ollamaBaseUrl = config.ollamaBaseUrl.trim();
+        }
+        updateSettings(storeUpdate);
        // Proceed to next step immediately after successful save
        onNext();
      } else {
@@ -344,7 +454,7 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
                            Enable Graphiti Memory
                          </Label>
                          <p className="text-xs text-muted-foreground mt-0.5">
-                            Requires FalkorDB (Docker) and OpenAI API key
+                            Requires FalkorDB (Docker) and an LLM provider (API key or local Ollama)
                          </p>
                        </div>
                      </div>
@@ -360,6 +470,30 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
                {/* Configuration fields (shown when enabled) */}
                {config.enabled && (
                  <div className="space-y-4 animate-in slide-in-from-top-2 duration-200">
+                    {/* LLM Provider Selection */}
+                    <div className="space-y-2">
+                      <Label className="text-sm font-medium text-foreground">LLM Provider</Label>
+                      <p className="text-xs text-muted-foreground">
+                        Select the AI provider for graph operations
+                      </p>
+                      <Select
+                        value={config.llmProvider}
+                        onValueChange={(value) => handleProviderChange(value as GraphitiProviderType)}
+                        disabled={isSaving || isValidating}
+                      >
+                        <SelectTrigger>
+                          <SelectValue placeholder="Select provider" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="openai">OpenAI (GPT)</SelectItem>
+                          <SelectItem value="anthropic">Anthropic (Claude)</SelectItem>
+                          <SelectItem value="google">Google (Gemini)</SelectItem>
+                          <SelectItem value="groq">Groq (Llama)</SelectItem>
+                          <SelectItem value="ollama">Ollama (Local)</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+
                    {/* FalkorDB URI */}
                    <div className="space-y-2">
                      <div className="flex items-center justify-between">
@@ -399,76 +533,124 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
                      </p>
                    </div>

-                    {/* OpenAI API Key */}
-                    <div className="space-y-2">
-                      <div className="flex items-center justify-between">
-                        <Label htmlFor="openai-key" className="text-sm font-medium text-foreground">
-                          OpenAI API Key
-                        </Label>
-                        {validationStatus.openai && (
-                          <div className="flex items-center gap-1.5">
-                            {validationStatus.openai.success ? (
-                              <CheckCircle2 className="h-4 w-4 text-success" />
-                            ) : (
-                              <XCircle className="h-4 w-4 text-destructive" />
-                            )}
-                            <span className={`text-xs ${validationStatus.openai.success ? 'text-success' : 'text-destructive'}`}>
-                              {validationStatus.openai.success ? 'Valid' : 'Invalid'}
-                            </span>
-                          </div>
-                        )}
-                      </div>
-                      <div className="relative">
+                    {/* Dynamic credential field based on provider */}
+                    {config.llmProvider === 'ollama' ? (
+                      /* Ollama Base URL field */
+                      <div className="space-y-2">
+                        <div className="flex items-center justify-between">
+                          <Label htmlFor="ollama-url" className="text-sm font-medium text-foreground">
+                            Ollama Server URL
+                          </Label>
+                          {validationStatus.llm && (
+                            <div className="flex items-center gap-1.5">
+                              {validationStatus.llm.success ? (
+                                <CheckCircle2 className="h-4 w-4 text-success" />
+                              ) : (
+                                <XCircle className="h-4 w-4 text-destructive" />
+                              )}
+                              <span className={`text-xs ${validationStatus.llm.success ? 'text-success' : 'text-destructive'}`}>
+                                {validationStatus.llm.success ? 'Connected' : 'Failed'}
+                              </span>
+                            </div>
+                          )}
+                        </div>
                        <Input
-                          id="openai-key"
-                          type={showApiKey ? 'text' : 'password'}
-                          value={config.openAiApiKey}
+                          id="ollama-url"
+                          type="text"
+                          value={config.ollamaBaseUrl}
                          onChange={(e) => {
-                            setConfig(prev => ({ ...prev, openAiApiKey: e.target.value }));
-                            setValidationStatus(prev => ({ ...prev, openai: null }));
+                            setConfig(prev => ({ ...prev, ollamaBaseUrl: e.target.value }));
+                            setValidationStatus(prev => ({ ...prev, llm: null }));
                          }}
-                          placeholder="sk-..."
-                          className="pr-10 font-mono text-sm"
+                          placeholder="http://localhost:11434"
+                          className="font-mono text-sm"
                          disabled={isSaving || isValidating}
                        />
-                        <Tooltip>
-                          <TooltipTrigger asChild>
-                            <button
-                              type="button"
-                              onClick={() => setShowApiKey(!showApiKey)}
-                              className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
-                            >
-                              {showApiKey ? (
-                                <EyeOff className="h-4 w-4" />
-                              ) : (
-                                <Eye className="h-4 w-4" />
-                              )}
-                            </button>
-                          </TooltipTrigger>
-                          <TooltipContent>
-                            {showApiKey ? 'Hide API key' : 'Show API key'}
-                          </TooltipContent>
-                        </Tooltip>
+                        <p className="text-xs text-muted-foreground">
+                          No API key required. Make sure{' '}
+                          <a
+                            href="https://ollama.ai"
+                            target="_blank"
+                            rel="noopener noreferrer"
+                            className="text-primary hover:text-primary/80"
+                          >
+                            Ollama
+                          </a>
+                          {' '}is running locally.
+                        </p>
                      </div>
-                      <p className="text-xs text-muted-foreground">
-                        Required for generating embeddings. Get your key from{' '}
-                        <a
-                          href="https://platform.openai.com/api-keys"
-                          target="_blank"
-                          rel="noopener noreferrer"
-                          className="text-primary hover:text-primary/80"
-                        >
-                          OpenAI
-                        </a>
-                      </p>
-                    </div>
+                    ) : (
+                      /* API Key field for other providers */
+                      <div className="space-y-2">
+                        <div className="flex items-center justify-between">
+                          <Label htmlFor="api-key" className="text-sm font-medium text-foreground">
+                            {PROVIDER_INFO[config.llmProvider].name} API Key
+                          </Label>
+                          {validationStatus.llm && (
+                            <div className="flex items-center gap-1.5">
+                              {validationStatus.llm.success ? (
+                                <CheckCircle2 className="h-4 w-4 text-success" />
+                              ) : (
+                                <XCircle className="h-4 w-4 text-destructive" />
+                              )}
+                              <span className={`text-xs ${validationStatus.llm.success ? 'text-success' : 'text-destructive'}`}>
+                                {validationStatus.llm.success ? 'Valid' : 'Invalid'}
+                              </span>
+                            </div>
+                          )}
+                        </div>
+                        <div className="relative">
+                          <Input
+                            id="api-key"
+                            type={showApiKey ? 'text' : 'password'}
+                            value={config.apiKey}
+                            onChange={(e) => {
+                              setConfig(prev => ({ ...prev, apiKey: e.target.value }));
+                              setValidationStatus(prev => ({ ...prev, llm: null }));
+                            }}
+                            placeholder={PROVIDER_INFO[config.llmProvider].placeholder}
+                            className="pr-10 font-mono text-sm"
+                            disabled={isSaving || isValidating}
+                          />
+                          <Tooltip>
+                            <TooltipTrigger asChild>
+                              <button
+                                type="button"
+                                onClick={() => setShowApiKey(!showApiKey)}
+                                className="absolute right-3 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
+                              >
+                                {showApiKey ? (
+                                  <EyeOff className="h-4 w-4" />
+                                ) : (
+                                  <Eye className="h-4 w-4" />
+                                )}
+                              </button>
+                            </TooltipTrigger>
+                            <TooltipContent>
+                              {showApiKey ? 'Hide API key' : 'Show API key'}
+                            </TooltipContent>
+                          </Tooltip>
+                        </div>
+                        <p className="text-xs text-muted-foreground">
+                          Required for graph operations. Get your key from{' '}
+                          <a
+                            href={PROVIDER_INFO[config.llmProvider].link}
+                            target="_blank"
+                            rel="noopener noreferrer"
+                            className="text-primary hover:text-primary/80"
+                          >
+                            {PROVIDER_INFO[config.llmProvider].name}
+                          </a>
+                        </p>
+                      </div>
+                    )}

                    {/* Test Connection Button */}
                    <div className="pt-2">
                      <Button
                        variant="outline"
                        onClick={handleTestConnection}
-                        disabled={!config.openAiApiKey.trim() || isValidating || isSaving}
+                        disabled={(config.llmProvider === 'ollama' ? !config.ollamaBaseUrl.trim() : !config.apiKey.trim()) || isValidating || isSaving}
                        className="w-full"
                      >
                        {isValidating ? (
@@ -483,11 +665,21 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
                          </>
                        )}
                      </Button>
-                      {validationStatus.falkordb?.success && validationStatus.openai?.success && (
+                      {validationStatus.falkordb?.success && validationStatus.llm?.success && (
                        <p className="text-xs text-success text-center mt-2">
                          All connections validated successfully!
                        </p>
                      )}
+                      {config.llmProvider !== 'openai' && config.llmProvider !== 'ollama' && (
+                        <p className="text-xs text-muted-foreground text-center mt-2">
+                          Note: API key validation currently only fully supports OpenAI. Your {PROVIDER_INFO[config.llmProvider].name} key will be saved and used at runtime.
+                        </p>
+                      )}
+                      {config.llmProvider === 'ollama' && (
+                        <p className="text-xs text-muted-foreground text-center mt-2">
+                          Note: Ollama connection will be tested by checking if the server is reachable.
+                        </p>
+                      )}
                    </div>
                  </div>
                )}
@@ -515,7 +707,7 @@ export function GraphitiStep({ onNext, onBack, onSkip }: GraphitiStepProps) {
            </Button>
            <Button
              onClick={handleContinue}
-              disabled={isCheckingDocker || (config.enabled && !config.openAiApiKey.trim() && !success) || isSaving || isValidating}
+              disabled={isCheckingDocker || (config.enabled && !success && (config.llmProvider === 'ollama' ? !config.ollamaBaseUrl.trim() : !config.apiKey.trim())) || isSaving || isValidating}
            >
              {isSaving ? (
                <>
@@ -0,0 +1,252 @@
+import { useState, useEffect, useRef } from 'react';
+import {
+  Key,
+  Loader2,
+  CheckCircle2,
+  AlertCircle,
+  Info,
+  Sparkles
+} from 'lucide-react';
+import { Button } from '../ui/button';
+import { Card, CardContent } from '../ui/card';
+
+interface ClaudeOAuthFlowProps {
+  onSuccess: () => void;
+  onCancel?: () => void;
+}
+
+/**
+ * Claude OAuth flow component for setup wizard
+ * Guides users through authenticating with Claude using claude setup-token
+ */
+export function ClaudeOAuthFlow({ onSuccess, onCancel }: ClaudeOAuthFlowProps) {
+  const [status, setStatus] = useState<'ready' | 'authenticating' | 'success' | 'error'>('ready');
+  const [error, setError] = useState<string | null>(null);
+  const [email, setEmail] = useState<string | undefined>();
+
+  // Track if we've already started auth to prevent double-execution
+  const hasStartedRef = useRef(false);
+  // Track the auto-advance timeout so we can cancel it on unmount/re-render
+  const successTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Listen for OAuth token detection
+  useEffect(() => {
+    // Clear any pending timeout from previous effect run
+    if (successTimeoutRef.current) {
+      clearTimeout(successTimeoutRef.current);
+      successTimeoutRef.current = null;
+    }
+
+    const unsubscribe = window.electronAPI.onTerminalOAuthToken((info) => {
+      console.warn('[ClaudeOAuth] Token event received:', {
+        success: info.success,
+        hasEmail: !!info.email,
+        profileId: info.profileId
+      });
+
+      if (info.success) {
+        setEmail(info.email);
+        setStatus('success');
+        // Auto-advance after a short delay to show success message
+        // Store the timeout ID so cleanup can cancel it if needed
+        successTimeoutRef.current = setTimeout(() => {
+          successTimeoutRef.current = null; // Clear ref since timeout fired
+          onSuccess();
+        }, 1500);
+      } else {
+        setError(info.message || 'Failed to save OAuth token');
+        setStatus('error');
+      }
+    });
+
+    return () => {
+      unsubscribe?.();
+      // Clear timeout on cleanup to prevent calling onSuccess after unmount
+      if (successTimeoutRef.current) {
+        clearTimeout(successTimeoutRef.current);
+        successTimeoutRef.current = null;
+      }
+    };
+  }, [onSuccess]);
+
+  const handleStartAuth = async () => {
+    if (hasStartedRef.current) {
+      console.warn('[ClaudeOAuth] Auth already started, ignoring duplicate call');
+      return;
+    }
+    hasStartedRef.current = true;
+
+    console.warn('[ClaudeOAuth] Starting Claude authentication');
+    setStatus('authenticating');
+    setError(null);
+
+    try {
+      // Get the active profile ID
+      const profilesResult = await window.electronAPI.getClaudeProfiles();
+
+      if (!profilesResult.success || !profilesResult.data) {
+        throw new Error('Failed to get Claude profiles');
+      }
+
+      const activeProfileId = profilesResult.data.activeProfileId;
+      console.warn('[ClaudeOAuth] Initializing profile:', activeProfileId);
+
+      // Initialize the profile - this opens a terminal and runs 'claude setup-token'
+      const result = await window.electronAPI.initializeClaudeProfile(activeProfileId);
+
+      if (!result.success) {
+        throw new Error(result.error || 'Failed to start authentication');
+      }
+
+      console.warn('[ClaudeOAuth] Authentication started, waiting for token...');
+      // Status will be updated by the event listener when token is detected
+    } catch (err) {
+      console.error('[ClaudeOAuth] Authentication failed:', err);
+      setError(err instanceof Error ? err.message : 'Authentication failed');
+      setStatus('error');
+      hasStartedRef.current = false;
+    }
+  };
+
+  const handleRetry = () => {
+    hasStartedRef.current = false;
+    setStatus('ready');
+    setError(null);
+  };
+
+  return (
+    <div className="space-y-4">
+      {/* Ready to authenticate */}
+      {status === 'ready' && (
+        <div className="space-y-4">
+          <Card className="border border-info/30 bg-info/10">
+            <CardContent className="p-5">
+              <div className="flex items-start gap-4">
+                <Key className="h-6 w-6 text-info shrink-0 mt-0.5" />
+                <div className="flex-1 space-y-3">
+                  <h3 className="text-lg font-medium text-foreground">
+                    Authenticate with Claude
+                  </h3>
+                  <p className="text-sm text-muted-foreground">
+                    Auto Claude requires Claude AI authentication for AI-powered features like
+                    Roadmap generation, Task automation, and Ideation.
+                  </p>
+                  <p className="text-sm text-muted-foreground">
+                    This will open a browser window to authenticate with your Claude account.
+                    Your credentials are stored securely and are valid for 1 year.
+                  </p>
+                </div>
+              </div>
+            </CardContent>
+          </Card>
+
+          <div className="flex justify-center">
+            <Button onClick={handleStartAuth} size="lg" className="gap-2">
+              <Key className="h-5 w-5" />
+              Authenticate with Claude
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {/* Authenticating */}
+      {status === 'authenticating' && (
+        <Card className="border border-info/30 bg-info/10">
+          <CardContent className="p-6">
+            <div className="space-y-4">
+              <div className="flex items-center gap-4">
+                <Loader2 className="h-6 w-6 animate-spin text-info shrink-0" />
+                <div className="flex-1">
+                  <h3 className="text-lg font-medium text-foreground">
+                    Authenticating...
+                  </h3>
+                  <p className="text-sm text-muted-foreground mt-1">
+                    A terminal window has opened. Please complete the authentication in your browser.
+                  </p>
+                </div>
+              </div>
+
+              <div className="rounded-lg bg-background/50 p-3 space-y-2">
+                <div className="flex items-start gap-2">
+                  <Info className="h-4 w-4 text-muted-foreground shrink-0 mt-0.5" />
+                  <div className="text-xs text-muted-foreground space-y-1">
+                    <p className="font-medium">What's happening:</p>
+                    <ol className="list-decimal list-inside space-y-1 ml-2">
+                      <li>A terminal opened and ran <code className="px-1 bg-muted rounded">claude setup-token</code></li>
+                      <li>Your browser should open to authenticate with Claude</li>
+                      <li>Complete the OAuth flow in your browser</li>
+                      <li>The terminal will display your token (starts with sk-ant-oat01-...)</li>
+                      <li>Auto Claude will automatically detect and save it</li>
+                    </ol>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Success */}
+      {status === 'success' && (
+        <Card className="border border-success/30 bg-success/10">
+          <CardContent className="p-6">
+            <div className="flex items-start gap-4">
+              <CheckCircle2 className="h-6 w-6 text-success shrink-0 mt-0.5" />
+              <div className="flex-1">
+                <h3 className="text-lg font-medium text-success">
+                  Successfully Authenticated!
+                </h3>
+                <p className="text-sm text-success/80 mt-1">
+                  {email ? `Connected as ${email}` : 'Your Claude credentials have been saved'}
+                </p>
+                <div className="flex items-center gap-2 mt-3 text-xs text-success/70">
+                  <Sparkles className="h-3 w-3" />
+                  <span>You can now use all Auto Claude AI features</span>
+                </div>
+              </div>
+            </div>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Error */}
+      {status === 'error' && error && (
+        <div className="space-y-4">
+          <Card className="border border-destructive/30 bg-destructive/10">
+            <CardContent className="p-5">
+              <div className="flex items-start gap-3">
+                <AlertCircle className="h-5 w-5 text-destructive shrink-0 mt-0.5" />
+                <div className="flex-1">
+                  <h3 className="text-lg font-medium text-destructive">
+                    Authentication Failed
+                  </h3>
+                  <p className="text-sm text-destructive/80 mt-1">{error}</p>
+                </div>
+              </div>
+            </CardContent>
+          </Card>
+
+          <div className="flex justify-center gap-3">
+            <Button onClick={handleRetry} variant="outline">
+              Retry
+            </Button>
+            {onCancel && (
+              <Button onClick={onCancel} variant="ghost">
+                Cancel
+              </Button>
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* Cancel button for ready/authenticating states */}
+      {(status === 'ready' || status === 'authenticating') && onCancel && (
+        <div className="flex justify-center pt-2">
+          <Button onClick={onCancel} variant="ghost" size="sm">
+            Skip for now
+          </Button>
+        </div>
+      )}
+    </div>
+  );
+}
@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { Github, RefreshCw, KeyRound } from 'lucide-react';
+import { Github, RefreshCw, KeyRound, Info } from 'lucide-react';
 import { CollapsibleSection } from './CollapsibleSection';
 import { StatusBadge } from './StatusBadge';
 import { PasswordInput } from './PasswordInput';
@@ -19,6 +19,7 @@ interface GitHubIntegrationSectionProps {
  onUpdateConfig: (updates: Partial<ProjectEnvConfig>) => void;
  gitHubConnectionStatus: GitHubSyncStatus | null;
  isCheckingGitHub: boolean;
+  projectName?: string;
 }

 export function GitHubIntegrationSection({
@@ -28,6 +29,7 @@ export function GitHubIntegrationSection({
  onUpdateConfig,
  gitHubConnectionStatus,
  isCheckingGitHub,
+  projectName,
 }: GitHubIntegrationSectionProps) {
  const [showOAuthFlow, setShowOAuthFlow] = useState(false);

@@ -48,6 +50,22 @@ export function GitHubIntegrationSection({
      onToggle={onToggle}
      badge={badge}
    >
+      {/* Project-Specific Configuration Notice */}
+      {projectName && (
+        <div className="rounded-lg border border-info/30 bg-info/5 p-3 mb-4">
+          <div className="flex items-start gap-2">
+            <Info className="h-4 w-4 text-info mt-0.5 shrink-0" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-foreground">Project-Specific Configuration</p>
+              <p className="text-xs text-muted-foreground mt-1">
+                This GitHub repository is configured only for <span className="font-semibold text-foreground">{projectName}</span>.
+                Each project can have its own GitHub repository.
+              </p>
+            </div>
+          </div>
+        </div>
+      )}
+
      <div className="flex items-center justify-between">
        <div className="space-y-0.5">
          <Label className="font-normal text-foreground">Enable GitHub Issues</Label>
@@ -1,9 +1,18 @@
 import { useEffect, useState } from 'react';
 import { useRoadmapStore, loadRoadmap, generateRoadmap, refreshRoadmap, stopRoadmap } from '../../stores/roadmap-store';
+import { useTaskStore } from '../../stores/task-store';
 import type { RoadmapFeature } from '../../../shared/types';

 /**
 * Hook to manage roadmap data and loading
+ *
+ * When the projectId changes, this hook:
+ * 1. Loads the new project's roadmap data
+ * 2. Queries the backend to check if generation is running for this project
+ * 3. Restores the generation status UI state accordingly
+ *
+ * NOTE: Generation continues in the background when switching projects.
+ * The loadRoadmap function queries the backend to restore the correct UI state.
 */
 export function useRoadmapData(projectId: string) {
  const roadmap = useRoadmapStore((state) => state.roadmap);
@@ -11,6 +20,9 @@ export function useRoadmapData(projectId: string) {
  const generationStatus = useRoadmapStore((state) => state.generationStatus);

  useEffect(() => {
+    // Load roadmap data and query generation status for this project
+    // The loadRoadmap function handles checking if generation is running
+    // and restores the UI state accordingly
    loadRoadmap(projectId);
  }, [projectId]);

@@ -26,6 +38,7 @@ export function useRoadmapData(projectId: string) {
 */
 export function useFeatureActions() {
  const updateFeatureLinkedSpec = useRoadmapStore((state) => state.updateFeatureLinkedSpec);
+  const addTask = useTaskStore((state) => state.addTask);

  const convertFeatureToSpec = async (
    projectId: string,
@@ -35,6 +48,10 @@ export function useFeatureActions() {
  ) => {
    const result = await window.electronAPI.convertFeatureToSpec(projectId, feature.id);
    if (result.success && result.data) {
+      // Add the created task to the task store so it appears in the kanban immediately
+      addTask(result.data);
+
+      // Update the roadmap feature with the linked spec
      updateFeatureLinkedSpec(feature.id, result.data.specId);
      if (selectedFeature?.id === feature.id) {
        setSelectedFeature({
@@ -76,6 +76,8 @@ export function AdvancedSettings({ settings, onSettingsChange, section, version
  const [isCheckingSourceUpdate, setIsCheckingSourceUpdate] = useState(false);
  const [isDownloadingUpdate, setIsDownloadingUpdate] = useState(false);
  const [downloadProgress, setDownloadProgress] = useState<AutoBuildSourceUpdateProgress | null>(null);
+  // Local version state that can be updated after successful update
+  const [displayVersion, setDisplayVersion] = useState<string>(version);

  // Electron app update state
  const [appUpdateInfo, setAppUpdateInfo] = useState<AppUpdateAvailableEvent | null>(null);
@@ -84,6 +86,11 @@ export function AdvancedSettings({ settings, onSettingsChange, section, version
  const [appDownloadProgress, setAppDownloadProgress] = useState<AppUpdateProgress | null>(null);
  const [isAppUpdateDownloaded, setIsAppUpdateDownloaded] = useState(false);

+  // Sync displayVersion with prop when it changes
+  useEffect(() => {
+    setDisplayVersion(version);
+  }, [version]);
+
  // Check for updates on mount
  useEffect(() => {
    if (section === 'updates') {
@@ -98,6 +105,10 @@ export function AdvancedSettings({ settings, onSettingsChange, section, version
      setDownloadProgress(progress);
      if (progress.stage === 'complete') {
        setIsDownloadingUpdate(false);
+        // Update the displayed version if a new version was provided
+        if (progress.newVersion) {
+          setDisplayVersion(progress.newVersion);
+        }
        checkForSourceUpdates();
      } else if (progress.stage === 'error') {
        setIsDownloadingUpdate(false);
@@ -164,14 +175,20 @@ export function AdvancedSettings({ settings, onSettingsChange, section, version
  };

  const checkForSourceUpdates = async () => {
+    console.log('[AdvancedSettings] Checking for source updates...');
    setIsCheckingSourceUpdate(true);
    try {
      const result = await window.electronAPI.checkAutoBuildSourceUpdate();
+      console.log('[AdvancedSettings] Check result:', result);
      if (result.success && result.data) {
        setSourceUpdateCheck(result.data);
+        // Update displayed version from the check result (most accurate)
+        if (result.data.currentVersion) {
+          setDisplayVersion(result.data.currentVersion);
+        }
      }
    } catch (err) {
-      // Silent fail - user can retry via button
+      console.error('[AdvancedSettings] Check error:', err);
    } finally {
      setIsCheckingSourceUpdate(false);
    }
@@ -287,7 +304,7 @@ export function AdvancedSettings({ settings, onSettingsChange, section, version
              <div>
                <p className="text-xs text-muted-foreground uppercase tracking-wider mb-1">Version</p>
                <p className="text-base font-medium text-foreground">
-                  {version || 'Loading...'}
+                  {displayVersion || 'Loading...'}
                </p>
              </div>
              {isCheckingSourceUpdate ? (
@@ -404,8 +404,9 @@ export function IntegrationSettings({ settings, onSettingsChange, isOpen }: Inte
                      </div>
                      {editingProfileId !== profile.id && (
                        <div className="flex items-center gap-1">
-                          {/* Authenticate button - show if not authenticated */}
-                          {!profile.oauthToken && (
+                          {/* Authenticate button - show only if NOT authenticated */}
+                          {/* A profile is authenticated if: has OAuth token OR (is default AND has configDir) */}
+                          {!(profile.oauthToken || (profile.isDefault && profile.configDir)) ? (
                            <Button
                              variant="outline"
                              size="sm"
@@ -420,6 +421,22 @@ export function IntegrationSettings({ settings, onSettingsChange, isOpen }: Inte
                              )}
                              Authenticate
                            </Button>
+                          ) : (
+                            /* Re-authenticate button for already authenticated profiles */
+                            <Button
+                              variant="ghost"
+                              size="icon"
+                              onClick={() => handleAuthenticateProfile(profile.id)}
+                              disabled={authenticatingProfileId === profile.id}
+                              className="h-7 w-7 text-muted-foreground hover:text-foreground"
+                              title="Re-authenticate profile"
+                            >
+                              {authenticatingProfileId === profile.id ? (
+                                <Loader2 className="h-3 w-3 animate-spin" />
+                              ) : (
+                                <RefreshCw className="h-3 w-3" />
+                              )}
+                            </Button>
                          )}
                          {profile.id !== activeProfileId && (
                            <Button
@@ -1,5 +1,5 @@
 import { useState, useEffect } from 'react';
-import { Github, RefreshCw, KeyRound, Loader2, CheckCircle2, AlertCircle, User, Lock, Globe, ChevronDown } from 'lucide-react';
+import { Github, RefreshCw, KeyRound, Loader2, CheckCircle2, AlertCircle, User, Lock, Globe, ChevronDown, GitBranch } from 'lucide-react';
 import { Input } from '../../ui/input';
 import { Label } from '../../ui/label';
 import { Switch } from '../../ui/switch';
@@ -34,6 +34,7 @@ interface GitHubIntegrationProps {
  setShowGitHubToken: React.Dispatch<React.SetStateAction<boolean>>;
  gitHubConnectionStatus: GitHubSyncStatus | null;
  isCheckingGitHub: boolean;
+  projectPath?: string; // Project path for fetching git branches
 }

 /**
@@ -46,7 +47,8 @@ export function GitHubIntegration({
  showGitHubToken: _showGitHubToken,
  setShowGitHubToken: _setShowGitHubToken,
  gitHubConnectionStatus,
-  isCheckingGitHub
+  isCheckingGitHub,
+  projectPath
 }: GitHubIntegrationProps) {
  const [authMode, setAuthMode] = useState<'manual' | 'oauth' | 'oauth-success'>('manual');
  const [oauthUsername, setOauthUsername] = useState<string | null>(null);
@@ -54,8 +56,14 @@ export function GitHubIntegration({
  const [isLoadingRepos, setIsLoadingRepos] = useState(false);
  const [reposError, setReposError] = useState<string | null>(null);

+  // Branch selection state
+  const [branches, setBranches] = useState<string[]>([]);
+  const [isLoadingBranches, setIsLoadingBranches] = useState(false);
+  const [branchesError, setBranchesError] = useState<string | null>(null);
+
  debugLog('Render - authMode:', authMode);
-  debugLog('Render - envConfig:', envConfig ? { githubEnabled: envConfig.githubEnabled, hasToken: !!envConfig.githubToken } : null);
+  debugLog('Render - projectPath:', projectPath);
+  debugLog('Render - envConfig:', envConfig ? { githubEnabled: envConfig.githubEnabled, hasToken: !!envConfig.githubToken, defaultBranch: envConfig.defaultBranch } : null);

  // Fetch repos when entering oauth-success mode
  useEffect(() => {
@@ -64,6 +72,60 @@ export function GitHubIntegration({
    }
  }, [authMode]);

+  // Fetch branches when GitHub is enabled and project path is available
+  useEffect(() => {
+    debugLog(`useEffect[branches] - githubEnabled: ${envConfig?.githubEnabled}, projectPath: ${projectPath}`);
+    if (envConfig?.githubEnabled && projectPath) {
+      debugLog('useEffect[branches] - Triggering fetchBranches');
+      fetchBranches();
+    } else {
+      debugLog('useEffect[branches] - Skipping fetchBranches (conditions not met)');
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [envConfig?.githubEnabled, projectPath]);
+
+  const fetchBranches = async () => {
+    if (!projectPath) {
+      debugLog('fetchBranches: No projectPath, skipping');
+      return;
+    }
+
+    debugLog('fetchBranches: Starting with projectPath:', projectPath);
+    setIsLoadingBranches(true);
+    setBranchesError(null);
+
+    try {
+      debugLog('fetchBranches: Calling getGitBranches...');
+      const result = await window.electronAPI.getGitBranches(projectPath);
+      debugLog('fetchBranches: getGitBranches result:', { success: result.success, dataType: typeof result.data, dataLength: Array.isArray(result.data) ? result.data.length : 'N/A', error: result.error });
+
+      // result.data is the array directly (not { branches: [] })
+      if (result.success && result.data) {
+        setBranches(result.data);
+        debugLog('fetchBranches: Loaded branches:', result.data.length);
+
+        // Auto-detect default branch if not set
+        if (!envConfig?.defaultBranch) {
+          debugLog('fetchBranches: No defaultBranch set, auto-detecting...');
+          const detectResult = await window.electronAPI.detectMainBranch(projectPath);
+          debugLog('fetchBranches: detectMainBranch result:', detectResult);
+          if (detectResult.success && detectResult.data) {
+            debugLog('fetchBranches: Auto-detected default branch:', detectResult.data);
+            updateEnvConfig({ defaultBranch: detectResult.data });
+          }
+        }
+      } else {
+        debugLog('fetchBranches: Failed -', result.error || 'No data returned');
+        setBranchesError(result.error || 'Failed to load branches');
+      }
+    } catch (err) {
+      debugLog('fetchBranches: Exception:', err);
+      setBranchesError(err instanceof Error ? err.message : 'Failed to load branches');
+    } finally {
+      setIsLoadingBranches(false);
+    }
+  };
+
  const fetchUserRepos = async () => {
    debugLog('Fetching user repositories...');
    setIsLoadingRepos(true);
@@ -248,6 +310,20 @@ export function GitHubIntegration({

          <Separator />

+          {/* Default Branch Selector */}
+          {projectPath && (
+            <BranchSelector
+              branches={branches}
+              selectedBranch={envConfig.defaultBranch || ''}
+              isLoading={isLoadingBranches}
+              error={branchesError}
+              onSelect={(branch) => updateEnvConfig({ defaultBranch: branch })}
+              onRefresh={fetchBranches}
+            />
+          )}
+
+          <Separator />
+
          <AutoSyncToggle
            enabled={envConfig.githubAutoSync || false}
            onToggle={(checked) => updateEnvConfig({ githubAutoSync: checked })}
@@ -500,3 +576,147 @@ function AutoSyncToggle({ enabled, onToggle }: AutoSyncToggleProps) {
    </div>
  );
 }
+
+interface BranchSelectorProps {
+  branches: string[];
+  selectedBranch: string;
+  isLoading: boolean;
+  error: string | null;
+  onSelect: (branch: string) => void;
+  onRefresh: () => void;
+}
+
+function BranchSelector({
+  branches,
+  selectedBranch,
+  isLoading,
+  error,
+  onSelect,
+  onRefresh
+}: BranchSelectorProps) {
+  const [isOpen, setIsOpen] = useState(false);
+  const [filter, setFilter] = useState('');
+
+  const filteredBranches = branches.filter(branch =>
+    branch.toLowerCase().includes(filter.toLowerCase())
+  );
+
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center justify-between">
+        <div className="space-y-0.5">
+          <div className="flex items-center gap-2">
+            <GitBranch className="h-4 w-4 text-info" />
+            <Label className="text-sm font-medium text-foreground">Default Branch</Label>
+          </div>
+          <p className="text-xs text-muted-foreground pl-6">
+            Base branch for creating task worktrees
+          </p>
+        </div>
+        <Button
+          variant="ghost"
+          size="sm"
+          onClick={onRefresh}
+          disabled={isLoading}
+          className="h-7 px-2"
+        >
+          <RefreshCw className={`h-3 w-3 ${isLoading ? 'animate-spin' : ''}`} />
+        </Button>
+      </div>
+
+      {error && (
+        <div className="flex items-center gap-2 text-xs text-destructive pl-6">
+          <AlertCircle className="h-3 w-3" />
+          {error}
+        </div>
+      )}
+
+      <div className="relative pl-6">
+        <button
+          type="button"
+          onClick={() => setIsOpen(!isOpen)}
+          disabled={isLoading}
+          className="w-full flex items-center justify-between px-3 py-2 text-sm border border-input rounded-md bg-background hover:bg-accent hover:text-accent-foreground disabled:opacity-50"
+        >
+          {isLoading ? (
+            <span className="flex items-center gap-2 text-muted-foreground">
+              <Loader2 className="h-4 w-4 animate-spin" />
+              Loading branches...
+            </span>
+          ) : selectedBranch ? (
+            <span className="flex items-center gap-2">
+              <GitBranch className="h-3 w-3 text-muted-foreground" />
+              {selectedBranch}
+            </span>
+          ) : (
+            <span className="text-muted-foreground">Auto-detect (main/master)</span>
+          )}
+          <ChevronDown className={`h-4 w-4 text-muted-foreground transition-transform ${isOpen ? 'rotate-180' : ''}`} />
+        </button>
+
+        {isOpen && !isLoading && (
+          <div className="absolute z-50 w-full mt-1 bg-popover border border-border rounded-md shadow-lg max-h-64 overflow-hidden">
+            {/* Search filter */}
+            <div className="p-2 border-b border-border">
+              <Input
+                placeholder="Search branches..."
+                value={filter}
+                onChange={(e) => setFilter(e.target.value)}
+                className="h-8 text-sm"
+                autoFocus
+              />
+            </div>
+
+            {/* Auto-detect option */}
+            <button
+              type="button"
+              onClick={() => {
+                onSelect('');
+                setIsOpen(false);
+                setFilter('');
+              }}
+              className={`w-full px-3 py-2 text-left hover:bg-accent flex items-center gap-2 ${
+                !selectedBranch ? 'bg-accent' : ''
+              }`}
+            >
+              <span className="text-sm text-muted-foreground italic">Auto-detect (main/master)</span>
+            </button>
+
+            {/* Branch list */}
+            <div className="max-h-40 overflow-y-auto border-t border-border">
+              {filteredBranches.length === 0 ? (
+                <div className="px-3 py-4 text-sm text-muted-foreground text-center">
+                  {filter ? 'No matching branches' : 'No branches found'}
+                </div>
+              ) : (
+                filteredBranches.map((branch) => (
+                  <button
+                    key={branch}
+                    type="button"
+                    onClick={() => {
+                      onSelect(branch);
+                      setIsOpen(false);
+                      setFilter('');
+                    }}
+                    className={`w-full px-3 py-2 text-left hover:bg-accent flex items-center gap-2 ${
+                      branch === selectedBranch ? 'bg-accent' : ''
+                    }`}
+                  >
+                    <GitBranch className="h-3 w-3 text-muted-foreground" />
+                    <span className="text-sm">{branch}</span>
+                  </button>
+                ))
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+
+      {selectedBranch && (
+        <p className="text-xs text-muted-foreground pl-6">
+          All new tasks will branch from <code className="px-1 bg-muted rounded">{selectedBranch}</code>
+        </p>
+      )}
+    </div>
+  );
+}
@@ -169,6 +169,7 @@ export function SectionRouter({
              setShowGitHubToken={setShowGitHubToken}
              gitHubConnectionStatus={gitHubConnectionStatus}
              isCheckingGitHub={isCheckingGitHub}
+              projectPath={project.path}
            />
          </InitializationGuard>
        </SettingsSection>
@@ -14,12 +14,15 @@ import {
  Search,
  FolderSearch,
  Wrench,
-  Info
+  Info,
+  Brain,
+  Cpu
 } from 'lucide-react';
 import { Badge } from '../ui/badge';
 import { Collapsible, CollapsibleTrigger, CollapsibleContent } from '../ui/collapsible';
 import { cn } from '../../lib/utils';
-import type { Task, TaskLogs, TaskLogPhase, TaskPhaseLog, TaskLogEntry } from '../../../shared/types';
+import type { Task, TaskLogs, TaskLogPhase, TaskPhaseLog, TaskLogEntry, TaskMetadata } from '../../../shared/types';
+import type { PhaseModelConfig, PhaseThinkingConfig, ThinkingLevel, ModelTypeShort } from '../../../shared/types/settings';

 interface TaskLogsProps {
  task: Task;
@@ -51,6 +54,60 @@ const PHASE_COLORS: Record<TaskLogPhase, string> = {
  validation: 'text-purple-500 bg-purple-500/10 border-purple-500/30'
 };

+// Map log phases to config phase keys
+// Note: 'planning' log phase covers both spec creation and implementation planning
+const LOG_PHASE_TO_CONFIG_PHASE: Record<TaskLogPhase, keyof PhaseModelConfig> = {
+  planning: 'spec',  // Planning log phase primarily shows spec creation
+  coding: 'coding',
+  validation: 'qa'
+};
+
+// Short labels for models
+const MODEL_SHORT_LABELS: Record<ModelTypeShort, string> = {
+  opus: 'Opus',
+  sonnet: 'Sonnet',
+  haiku: 'Haiku'
+};
+
+// Short labels for thinking levels
+const THINKING_SHORT_LABELS: Record<ThinkingLevel, string> = {
+  none: 'None',
+  low: 'Low',
+  medium: 'Med',
+  high: 'High',
+  ultrathink: 'Ultra'
+};
+
+// Helper to get model and thinking info for a log phase
+function getPhaseConfig(
+  metadata: TaskMetadata | undefined,
+  logPhase: TaskLogPhase
+): { model: string; thinking: string } | null {
+  if (!metadata) return null;
+
+  const configPhase = LOG_PHASE_TO_CONFIG_PHASE[logPhase];
+
+  // Auto profile with per-phase config
+  if (metadata.isAutoProfile && metadata.phaseModels && metadata.phaseThinking) {
+    const model = metadata.phaseModels[configPhase];
+    const thinking = metadata.phaseThinking[configPhase];
+    return {
+      model: MODEL_SHORT_LABELS[model] || model,
+      thinking: THINKING_SHORT_LABELS[thinking] || thinking
+    };
+  }
+
+  // Non-auto profile with single model/thinking
+  if (metadata.model && metadata.thinkingLevel) {
+    return {
+      model: MODEL_SHORT_LABELS[metadata.model] || metadata.model,
+      thinking: THINKING_SHORT_LABELS[metadata.thinkingLevel] || metadata.thinkingLevel
+    };
+  }
+
+  return null;
+}
+
 export function TaskLogs({
  task,
  phaseLogs,
@@ -84,6 +141,7 @@ export function TaskLogs({
                isExpanded={expandedPhases.has(phase)}
                onToggle={() => onTogglePhase(phase)}
                isTaskStuck={isStuck}
+                phaseConfig={getPhaseConfig(task.metadata, phase)}
              />
            ))}
            <div ref={logsEndRef} />
@@ -113,9 +171,10 @@ interface PhaseLogSectionProps {
  isExpanded: boolean;
  onToggle: () => void;
  isTaskStuck?: boolean;
+  phaseConfig?: { model: string; thinking: string } | null;
 }

-function PhaseLogSection({ phase, phaseLog, isExpanded, onToggle, isTaskStuck }: PhaseLogSectionProps) {
+function PhaseLogSection({ phase, phaseLog, isExpanded, onToggle, isTaskStuck, phaseConfig }: PhaseLogSectionProps) {
  const Icon = PHASE_ICONS[phase];
  const status = phaseLog?.status || 'pending';
  const hasEntries = (phaseLog?.entries.length || 0) > 0;
@@ -190,7 +249,23 @@ function PhaseLogSection({ phase, phaseLog, isExpanded, onToggle, isTaskStuck }:
              </span>
            )}
          </div>
-          {getStatusBadge()}
+          <div className="flex items-center gap-2">
+            {/* Model and thinking level indicator */}
+            {phaseConfig && (
+              <div className="flex items-center gap-1.5 text-[10px] text-muted-foreground">
+                <div className="flex items-center gap-0.5" title={`Model: ${phaseConfig.model}`}>
+                  <Cpu className="h-3 w-3" />
+                  <span>{phaseConfig.model}</span>
+                </div>
+                <span className="text-muted-foreground/50">|</span>
+                <div className="flex items-center gap-0.5" title={`Thinking: ${phaseConfig.thinking}`}>
+                  <Brain className="h-3 w-3" />
+                  <span>{phaseConfig.thinking}</span>
+                </div>
+              </div>
+            )}
+            {getStatusBadge()}
+          </div>
        </button>
      </CollapsibleTrigger>
      <CollapsibleContent>
@@ -48,69 +48,93 @@ export function useIpcListeners(): void {
    );

    // Roadmap event listeners
-    const setGenerationStatus = useRoadmapStore.getState().setGenerationStatus;
-    const setRoadmap = useRoadmapStore.getState().setRoadmap;
+    // Helper to check if event is for the currently viewed project
+    const isCurrentProject = (eventProjectId: string): boolean => {
+      const currentProjectId = useRoadmapStore.getState().currentProjectId;
+      return currentProjectId === eventProjectId;
+    };

    const cleanupRoadmapProgress = window.electronAPI.onRoadmapProgress(
-      (_projectId: string, status: RoadmapGenerationStatus) => {
+      (projectId: string, status: RoadmapGenerationStatus) => {
        // Debug logging
        if (window.DEBUG) {
          console.log('[Roadmap] Progress update:', {
-            projectId: _projectId,
+            projectId,
+            currentProjectId: useRoadmapStore.getState().currentProjectId,
            phase: status.phase,
            progress: status.progress,
            message: status.message
          });
        }
-        setGenerationStatus(status);
+        // Only update if this is for the currently viewed project
+        if (isCurrentProject(projectId)) {
+          useRoadmapStore.getState().setGenerationStatus(status);
+        }
      }
    );

    const cleanupRoadmapComplete = window.electronAPI.onRoadmapComplete(
-      (_projectId: string, roadmap: Roadmap) => {
+      (projectId: string, roadmap: Roadmap) => {
        // Debug logging
        if (window.DEBUG) {
          console.log('[Roadmap] Generation complete:', {
-            projectId: _projectId,
+            projectId,
+            currentProjectId: useRoadmapStore.getState().currentProjectId,
            featuresCount: roadmap.features?.length || 0,
            phasesCount: roadmap.phases?.length || 0
          });
        }
-        setRoadmap(roadmap);
-        setGenerationStatus({
-          phase: 'complete',
-          progress: 100,
-          message: 'Roadmap ready'
-        });
+        // Only update if this is for the currently viewed project
+        if (isCurrentProject(projectId)) {
+          useRoadmapStore.getState().setRoadmap(roadmap);
+          useRoadmapStore.getState().setGenerationStatus({
+            phase: 'complete',
+            progress: 100,
+            message: 'Roadmap ready'
+          });
+        }
      }
    );

    const cleanupRoadmapError = window.electronAPI.onRoadmapError(
-      (_projectId: string, error: string) => {
+      (projectId: string, error: string) => {
        // Debug logging
        if (window.DEBUG) {
-          console.error('[Roadmap] Error received:', { projectId: _projectId, error });
+          console.error('[Roadmap] Error received:', {
+            projectId,
+            currentProjectId: useRoadmapStore.getState().currentProjectId,
+            error
+          });
+        }
+        // Only update if this is for the currently viewed project
+        if (isCurrentProject(projectId)) {
+          useRoadmapStore.getState().setGenerationStatus({
+            phase: 'error',
+            progress: 0,
+            message: 'Generation failed',
+            error
+          });
        }
-        setGenerationStatus({
-          phase: 'error',
-          progress: 0,
-          message: 'Generation failed',
-          error
-        });
      }
    );

    const cleanupRoadmapStopped = window.electronAPI.onRoadmapStopped(
-      (_projectId: string) => {
+      (projectId: string) => {
        // Debug logging
        if (window.DEBUG) {
-          console.log('[Roadmap] Generation stopped:', { projectId: _projectId });
+          console.log('[Roadmap] Generation stopped:', {
+            projectId,
+            currentProjectId: useRoadmapStore.getState().currentProjectId
+          });
+        }
+        // Only update if this is for the currently viewed project
+        if (isCurrentProject(projectId)) {
+          useRoadmapStore.getState().setGenerationStatus({
+            phase: 'idle',
+            progress: 0,
+            message: 'Generation stopped'
+          });
        }
-        setGenerationStatus({
-          phase: 'idle',
-          progress: 0,
-          message: 'Generation stopped'
-        });
      }
    );

@@ -53,6 +53,11 @@ const browserMockAPI: ElectronAPI = {
    data: null
  }),

+  getRoadmapStatus: async () => ({
+    success: true,
+    data: { isRunning: false }
+  }),
+
  saveRoadmap: async () => ({
    success: true
  }),
@@ -78,6 +78,11 @@ export const insightsMock = {
    return { success: true };
  },

+  updateInsightsModelConfig: async (_projectId: string, _sessionId: string, _modelConfig: unknown) => {
+    console.warn('[Browser Mock] updateInsightsModelConfig called');
+    return { success: true };
+  },
+
  sendInsightsMessage: () => {
    console.warn('[Browser Mock] sendInsightsMessage called');
  },
@@ -178,5 +178,15 @@ export const integrationMock = {
        { fullName: 'user/private-repo', description: 'A private repository', isPrivate: true }
      ]
    }
+  }),
+
+  detectGitHubRepo: async () => ({
+    success: true,
+    data: 'user/example-repo'
+  }),
+
+  getGitHubBranches: async () => ({
+    success: true,
+    data: ['main', 'develop', 'feature/example']
  })
 };
@@ -6,6 +6,7 @@ import type {
  InsightsChatStatus,
  InsightsStreamChunk,
  InsightsToolUsage,
+  InsightsModelConfig,
  TaskMetadata,
  Task
 } from '../../shared/types';
@@ -221,8 +222,9 @@ export async function loadInsightsSession(projectId: string): Promise<void> {
  await loadInsightsSessions(projectId);
 }

-export function sendMessage(projectId: string, message: string): void {
+export function sendMessage(projectId: string, message: string, modelConfig?: InsightsModelConfig): void {
  const store = useInsightsStore.getState();
+  const session = store.session;

  // Add user message to session
  const userMessage: InsightsChatMessage = {
@@ -242,8 +244,11 @@ export function sendMessage(projectId: string, message: string): void {
    message: 'Processing your message...'
  });

+  // Use provided modelConfig, or fall back to session's config
+  const configToUse = modelConfig || session?.modelConfig;
+
  // Send to main process
-  window.electronAPI.sendInsightsMessage(projectId, message);
+  window.electronAPI.sendInsightsMessage(projectId, message, configToUse);
 }

 export async function clearSession(projectId: string): Promise<void> {
@@ -296,6 +301,25 @@ export async function renameSession(projectId: string, sessionId: string, newTit
  return false;
 }

+export async function updateModelConfig(projectId: string, sessionId: string, modelConfig: InsightsModelConfig): Promise<boolean> {
+  const result = await window.electronAPI.updateInsightsModelConfig(projectId, sessionId, modelConfig);
+  if (result.success) {
+    // Update local session state
+    const store = useInsightsStore.getState();
+    if (store.session?.id === sessionId) {
+      store.setSession({
+        ...store.session,
+        modelConfig,
+        updatedAt: new Date()
+      });
+    }
+    // Reload sessions list to reflect the change
+    await loadInsightsSessions(projectId);
+    return true;
+  }
+  return false;
+}
+
 export async function createTaskFromSuggestion(
  projectId: string,
  title: string,
@@ -205,17 +205,26 @@ export async function initializeProject(
  const store = useProjectStore.getState();

  try {
+    console.log('[ProjectStore] initializeProject called for:', projectId);
    const result = await window.electronAPI.initializeProject(projectId);
+    console.log('[ProjectStore] IPC result:', result);
+
    if (result.success && result.data) {
+      console.log('[ProjectStore] IPC succeeded, result.data:', result.data);
      // Update the project's autoBuildPath in local state
      if (result.data.success) {
+        console.log('[ProjectStore] Updating project autoBuildPath to .auto-claude');
        store.updateProject(projectId, { autoBuildPath: '.auto-claude' });
+      } else {
+        console.log('[ProjectStore] result.data.success is false, not updating project');
      }
      return result.data;
    }
+    console.log('[ProjectStore] IPC failed or no data, setting error');
    store.setError(result.error || 'Failed to initialize project');
    return null;
  } catch (error) {
+    console.error('[ProjectStore] Exception during initializeProject:', error);
    store.setError(error instanceof Error ? error.message : 'Unknown error');
    return null;
  }
@@ -212,3 +212,4 @@ export function canCreateRelease(): boolean {
  );
 }

+
@@ -12,11 +12,13 @@ interface RoadmapState {
  roadmap: Roadmap | null;
  competitorAnalysis: CompetitorAnalysis | null;
  generationStatus: RoadmapGenerationStatus;
+  currentProjectId: string | null;  // Track which project we're viewing/generating for

  // Actions
  setRoadmap: (roadmap: Roadmap | null) => void;
  setCompetitorAnalysis: (analysis: CompetitorAnalysis | null) => void;
  setGenerationStatus: (status: RoadmapGenerationStatus) => void;
+  setCurrentProjectId: (projectId: string | null) => void;
  updateFeatureStatus: (featureId: string, status: RoadmapFeatureStatus) => void;
  updateFeatureLinkedSpec: (featureId: string, specId: string) => void;
  clearRoadmap: () => void;
@@ -37,6 +39,7 @@ export const useRoadmapStore = create<RoadmapState>((set) => ({
  roadmap: null,
  competitorAnalysis: null,
  generationStatus: initialGenerationStatus,
+  currentProjectId: null,

  // Actions
  setRoadmap: (roadmap) => set({ roadmap }),
@@ -45,6 +48,8 @@ export const useRoadmapStore = create<RoadmapState>((set) => ({

  setGenerationStatus: (status) => set({ generationStatus: status }),

+  setCurrentProjectId: (projectId) => set({ currentProjectId: projectId }),
+
  updateFeatureStatus: (featureId, status) =>
    set((state) => {
      if (!state.roadmap) return state;
@@ -85,7 +90,8 @@ export const useRoadmapStore = create<RoadmapState>((set) => ({
    set({
      roadmap: null,
      competitorAnalysis: null,
-      generationStatus: initialGenerationStatus
+      generationStatus: initialGenerationStatus,
+      currentProjectId: null
    }),

  // Reorder features within a phase
@@ -159,9 +165,34 @@ export const useRoadmapStore = create<RoadmapState>((set) => ({

 // Helper functions for loading roadmap
 export async function loadRoadmap(projectId: string): Promise<void> {
+  const store = useRoadmapStore.getState();
+
+  // Always set current project ID first - this ensures event handlers
+  // only process events for the currently viewed project
+  store.setCurrentProjectId(projectId);
+
+  // Query if roadmap generation is currently running for this project
+  // This restores the generation status when switching back to a project
+  const statusResult = await window.electronAPI.getRoadmapStatus(projectId);
+  if (statusResult.success && statusResult.data?.isRunning) {
+    // Generation is running - restore the UI state to show progress
+    // The actual progress will be updated by incoming events
+    store.setGenerationStatus({
+      phase: 'analyzing',
+      progress: 0,
+      message: 'Roadmap generation in progress...'
+    });
+  } else {
+    // Generation is not running - reset to idle
+    store.setGenerationStatus({
+      phase: 'idle',
+      progress: 0,
+      message: ''
+    });
+  }
+
  const result = await window.electronAPI.getRoadmap(projectId);
  if (result.success && result.data) {
-    const store = useRoadmapStore.getState();
    store.setRoadmap(result.data);
    // Extract and set competitor analysis separately if present
    if (result.data.competitorAnalysis) {
@@ -170,7 +201,6 @@ export async function loadRoadmap(projectId: string): Promise<void> {
      store.setCompetitorAnalysis(null);
    }
  } else {
-    const store = useRoadmapStore.getState();
    store.setRoadmap(null);
    store.setCompetitorAnalysis(null);
  }
@@ -514,6 +514,19 @@ export function isDraftEmpty(draft: TaskDraft | null): boolean {
  );
 }

+// ============================================
+// GitHub Issue Linking Helpers
+// ============================================
+
+/**
+ * Find a task by GitHub issue number
+ * Used to check if a task already exists for a GitHub issue
+ */
+export function getTaskByGitHubIssue(issueNumber: number): Task | undefined {
+  const store = useTaskStore.getState();
+  return store.tasks.find(t => t.metadata?.githubIssueNumber === issueNumber);
+}
+
 // ============================================
 // Task State Detection Helpers
 // ============================================
@@ -25,8 +25,8 @@ export const DEFAULT_APP_SETTINGS = {
  // Global API keys (used as defaults for all projects)
  globalClaudeOAuthToken: undefined as string | undefined,
  globalOpenAIApiKey: undefined as string | undefined,
-  // Selected agent profile - defaults to 'balanced' for good speed/quality balance
-  selectedAgentProfile: 'balanced',
+  // Selected agent profile - defaults to 'auto' for per-phase optimized model selection
+  selectedAgentProfile: 'auto',
  // Changelog preferences (persisted between sessions)
  changelogFormat: 'keep-a-changelog' as const,
  changelogAudience: 'user-facing' as const,
@@ -116,6 +116,7 @@ export const IPC_CHANNELS = {

  // Roadmap operations
  ROADMAP_GET: 'roadmap:get',
+  ROADMAP_GET_STATUS: 'roadmap:getStatus',
  ROADMAP_SAVE: 'roadmap:save',
  ROADMAP_GENERATE: 'roadmap:generate',
  ROADMAP_GENERATE_WITH_COMPETITOR: 'roadmap:generateWithCompetitor',
@@ -189,6 +190,8 @@ export const IPC_CHANNELS = {
  GITHUB_GET_TOKEN: 'github:getToken',
  GITHUB_GET_USER: 'github:getUser',
  GITHUB_LIST_USER_REPOS: 'github:listUserRepos',
+  GITHUB_DETECT_REPO: 'github:detectRepo',
+  GITHUB_GET_BRANCHES: 'github:getBranches',

  // GitHub events (main -> renderer)
  GITHUB_INVESTIGATION_PROGRESS: 'github:investigationProgress',
@@ -248,6 +251,7 @@ export const IPC_CHANNELS = {
  INSIGHTS_SWITCH_SESSION: 'insights:switchSession',
  INSIGHTS_DELETE_SESSION: 'insights:deleteSession',
  INSIGHTS_RENAME_SESSION: 'insights:renameSession',
+  INSIGHTS_UPDATE_MODEL_CONFIG: 'insights:updateModelConfig',

  // Insights events (main -> renderer)
  INSIGHTS_STREAM_CHUNK: 'insights:streamChunk',
@@ -3,7 +3,7 @@
 * Claude models, thinking levels, memory backends, and agent profiles
 */

-import type { AgentProfile } from '../types/settings';
+import type { AgentProfile, PhaseModelConfig } from '../types/settings';

 // ============================================
 // Available Models
@@ -15,6 +15,22 @@ export const AVAILABLE_MODELS = [
  { value: 'haiku', label: 'Claude Haiku 4.5' }
 ] as const;

+// Maps model shorthand to actual Claude model IDs
+export const MODEL_ID_MAP: Record<string, string> = {
+  opus: 'claude-opus-4-5-20251101',
+  sonnet: 'claude-sonnet-4-5-20250929',
+  haiku: 'claude-haiku-4-5-20251001'
+} as const;
+
+// Maps thinking levels to budget tokens (null = no extended thinking)
+export const THINKING_BUDGET_MAP: Record<string, number | null> = {
+  none: null,
+  low: 1024,
+  medium: 4096,
+  high: 16384,
+  ultrathink: 65536
+} as const;
+
 // ============================================
 // Thinking Levels
 // ============================================
@@ -32,8 +48,36 @@ export const THINKING_LEVELS = [
 // Agent Profiles
 // ============================================

+// Default phase model configuration for Auto profile
+// Optimized for each phase: fast discovery, quality planning, balanced coding, thorough QA
+export const DEFAULT_PHASE_MODELS: PhaseModelConfig = {
+  spec: 'sonnet',     // Good quality specs without being too slow
+  planning: 'opus',   // Complex architecture decisions benefit from Opus
+  coding: 'sonnet',   // Good balance of speed and quality for implementation
+  qa: 'sonnet'        // Thorough but not overly slow QA
+};
+
+// Default phase thinking configuration for Auto profile
+export const DEFAULT_PHASE_THINKING: import('../types/settings').PhaseThinkingConfig = {
+  spec: 'medium',       // Moderate thinking for spec creation
+  planning: 'high',     // Deep thinking for planning complex features
+  coding: 'medium',     // Standard thinking for coding
+  qa: 'high'            // Thorough analysis for QA review
+};
+
 // Default agent profiles for preset model/thinking configurations
 export const DEFAULT_AGENT_PROFILES: AgentProfile[] = [
+  {
+    id: 'auto',
+    name: 'Auto (Optimized)',
+    description: 'Uses different models per phase for optimal speed & quality',
+    model: 'sonnet',  // Fallback/default model
+    thinkingLevel: 'medium',
+    icon: 'Sparkles',
+    isAutoProfile: true,
+    phaseModels: DEFAULT_PHASE_MODELS,
+    phaseThinking: DEFAULT_PHASE_THINKING
+  },
  {
    id: 'complex',
    name: 'Complex Tasks',
@@ -154,6 +154,16 @@ export interface IdeationSummary {
 // Insights Chat Types
 // ============================================

+import type { ThinkingLevel } from './settings';
+import type { ModelType } from './task';
+
+// Model configuration for insights sessions
+export interface InsightsModelConfig {
+  profileId: string;           // 'complex' | 'balanced' | 'quick' | 'custom'
+  model: ModelType;            // 'haiku' | 'sonnet' | 'opus'
+  thinkingLevel: ThinkingLevel;
+}
+
 export type InsightsChatRole = 'user' | 'assistant';

 // Tool usage record for showing what tools the AI used
@@ -183,6 +193,7 @@ export interface InsightsSession {
  projectId: string;
  title?: string; // Auto-generated from first message or user-set
  messages: InsightsChatMessage[];
+  modelConfig?: InsightsModelConfig; // Per-session model configuration
  createdAt: Date;
  updatedAt: Date;
 }
@@ -193,6 +204,7 @@ export interface InsightsSessionSummary {
  projectId: string;
  title: string;
  messageCount: number;
+  modelConfig?: InsightsModelConfig; // For displaying model indicator in sidebar
  createdAt: Date;
  updatedAt: Date;
 }
@@ -86,7 +86,8 @@ import type {
  InsightsSession,
  InsightsSessionSummary,
  InsightsChatStatus,
-  InsightsStreamChunk
+  InsightsStreamChunk,
+  InsightsModelConfig
 } from './insights';
 import type {
  Roadmap,
@@ -236,6 +237,7 @@ export interface ElectronAPI {

  // Roadmap operations
  getRoadmap: (projectId: string) => Promise<IPCResult<Roadmap | null>>;
+  getRoadmapStatus: (projectId: string) => Promise<IPCResult<{ isRunning: boolean }>>;
  saveRoadmap: (projectId: string, roadmap: Roadmap) => Promise<IPCResult>;
  generateRoadmap: (projectId: string, enableCompetitorAnalysis?: boolean) => void;
  refreshRoadmap: (projectId: string, enableCompetitorAnalysis?: boolean) => void;
@@ -321,6 +323,8 @@ export interface ElectronAPI {
  getGitHubToken: () => Promise<IPCResult<{ token: string }>>;
  getGitHubUser: () => Promise<IPCResult<{ username: string; name?: string }>>;
  listGitHubUserRepos: () => Promise<IPCResult<{ repos: Array<{ fullName: string; description: string | null; isPrivate: boolean }> }>>;
+  detectGitHubRepo: (projectPath: string) => Promise<IPCResult<string>>;
+  getGitHubBranches: (repo: string, token: string) => Promise<IPCResult<string[]>>;

  // GitHub event listeners
  onGitHubInvestigationProgress: (
@@ -461,7 +465,7 @@ export interface ElectronAPI {

  // Insights operations
  getInsightsSession: (projectId: string) => Promise<IPCResult<InsightsSession | null>>;
-  sendInsightsMessage: (projectId: string, message: string) => void;
+  sendInsightsMessage: (projectId: string, message: string, modelConfig?: InsightsModelConfig) => void;
  clearInsightsSession: (projectId: string) => Promise<IPCResult>;
  createTaskFromInsights: (
    projectId: string,
@@ -474,6 +478,7 @@ export interface ElectronAPI {
  switchInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult<InsightsSession | null>>;
  deleteInsightsSession: (projectId: string, sessionId: string) => Promise<IPCResult>;
  renameInsightsSession: (projectId: string, sessionId: string, newTitle: string) => Promise<IPCResult>;
+  updateInsightsModelConfig: (projectId: string, sessionId: string, modelConfig: InsightsModelConfig) => Promise<IPCResult>;

  // Insights event listeners
  onInsightsStreamChunk: (
@@ -186,8 +186,8 @@ export interface GraphitiConnectionTestResult {
 }

 // Graphiti Provider Types (Memory System V2)
-export type GraphitiProviderType = 'openai' | 'anthropic' | 'google' | 'groq';
-export type GraphitiEmbeddingProvider = 'openai' | 'voyage' | 'google' | 'huggingface';
+export type GraphitiProviderType = 'openai' | 'anthropic' | 'google' | 'groq' | 'ollama';
+export type GraphitiEmbeddingProvider = 'openai' | 'voyage' | 'google' | 'huggingface' | 'ollama';

 export interface GraphitiProviderConfig {
  // LLM Provider
@@ -205,6 +205,12 @@ export interface GraphitiProviderConfig {
  groqApiKey?: string;
  voyageApiKey?: string;

+  // Ollama-specific config (local LLM, no API key required)
+  ollamaBaseUrl?: string;  // Default: http://localhost:11434
+  ollamaLlmModel?: string;
+  ollamaEmbeddingModel?: string;
+  ollamaEmbeddingDim?: number;
+
  // FalkorDB connection (required for all providers)
  falkorDbHost?: string;
  falkorDbPort?: number;
@@ -278,6 +284,9 @@ export interface ProjectEnvConfig {
  githubRepo?: string; // Format: owner/repo
  githubAutoSync?: boolean; // Auto-sync issues on project load

+  // Git/Worktree Settings
+  defaultBranch?: string; // Base branch for worktree creation (e.g., 'main', 'develop')
+
  // Graphiti Memory Integration (V2 - Multi-provider support)
  graphitiEnabled: boolean;
  graphitiProviderConfig?: GraphitiProviderConfig;  // New V2 provider configuration
@@ -8,14 +8,38 @@ import type { ChangelogFormat, ChangelogAudience, ChangelogEmojiLevel } from './
 // Thinking level for Claude model (budget token allocation)
 export type ThinkingLevel = 'none' | 'low' | 'medium' | 'high' | 'ultrathink';

+// Model type shorthand
+export type ModelTypeShort = 'haiku' | 'sonnet' | 'opus';
+
+// Phase-based model configuration for Auto profile
+// Each phase can use a different model optimized for that task type
+export interface PhaseModelConfig {
+  spec: ModelTypeShort;       // Spec creation (discovery, requirements, context)
+  planning: ModelTypeShort;   // Implementation planning
+  coding: ModelTypeShort;     // Actual coding implementation
+  qa: ModelTypeShort;         // QA review and fixing
+}
+
+// Thinking level configuration per phase
+export interface PhaseThinkingConfig {
+  spec: ThinkingLevel;
+  planning: ThinkingLevel;
+  coding: ThinkingLevel;
+  qa: ThinkingLevel;
+}
+
 // Agent profile for preset model/thinking configurations
 export interface AgentProfile {
  id: string;
  name: string;
  description: string;
-  model: 'haiku' | 'sonnet' | 'opus';
+  model: ModelTypeShort;
  thinkingLevel: ThinkingLevel;
  icon?: string;  // Lucide icon name
+  // Auto profile specific - per-phase configuration
+  isAutoProfile?: boolean;
+  phaseModels?: PhaseModelConfig;
+  phaseThinking?: PhaseThinkingConfig;
 }

 export interface AppSettings {
@@ -30,6 +54,12 @@ export interface AppSettings {
  // Global API keys (used as defaults for all projects)
  globalClaudeOAuthToken?: string;
  globalOpenAIApiKey?: string;
+  globalAnthropicApiKey?: string;
+  globalGoogleApiKey?: string;
+  globalGroqApiKey?: string;
+  // Graphiti LLM provider settings
+  graphitiLlmProvider?: 'openai' | 'anthropic' | 'google' | 'groq' | 'ollama';
+  ollamaBaseUrl?: string;
  // Onboarding wizard completion state
  onboardingCompleted?: boolean;
  // Selected agent profile for preset model/thinking configurations
@@ -77,4 +107,6 @@ export interface AutoBuildSourceUpdateProgress {
  stage: 'checking' | 'downloading' | 'extracting' | 'complete' | 'error';
  percent?: number;
  message: string;
+  /** New version after successful update - used to refresh UI */
+  newVersion?: string;
 }
@@ -2,7 +2,7 @@
 * Task-related types
 */

-import type { ThinkingLevel } from './settings';
+import type { ThinkingLevel, PhaseModelConfig, PhaseThinkingConfig } from './settings';

 export type TaskStatus = 'backlog' | 'in_progress' | 'ai_review' | 'human_review' | 'done';

@@ -136,8 +136,12 @@ export interface TaskDraft {
  priority: TaskPriority | '';
  complexity: TaskComplexity | '';
  impact: TaskImpact | '';
+  profileId?: string;  // Agent profile ID ('auto', 'complex', 'balanced', 'quick', 'custom')
  model: ModelType | '';
  thinkingLevel: ThinkingLevel | '';
+  // Auto profile - per-phase configuration
+  phaseModels?: PhaseModelConfig;
+  phaseThinking?: PhaseThinkingConfig;
  images: ImageAttachment[];
  referencedFiles: ReferencedFile[];
  requireReviewBeforeCoding?: boolean;
@@ -209,8 +213,15 @@ export interface TaskMetadata {
  requireReviewBeforeCoding?: boolean;  // Require human review of spec/plan before coding starts

  // Agent configuration (from agent profile or manual selection)
-  model?: ModelType;  // Claude model to use (haiku, sonnet, opus)
+  model?: ModelType;  // Claude model to use (haiku, sonnet, opus) - used when not auto profile
  thinkingLevel?: ThinkingLevel;  // Thinking budget level (none, low, medium, high, ultrathink)
+  // Auto profile - per-phase model configuration
+  isAutoProfile?: boolean;  // True when using Auto (Optimized) profile
+  phaseModels?: PhaseModelConfig;  // Per-phase model configuration
+  phaseThinking?: PhaseThinkingConfig;  // Per-phase thinking configuration
+
+  // Git/Worktree configuration
+  baseBranch?: string;  // Override base branch for this task's worktree

  // Archive status
  archivedAt?: string;  // ISO date when task was archived
@@ -340,8 +351,10 @@ export interface MergeStats {
 export interface WorktreeMergeResult {
  success: boolean;
  message: string;
+  merged?: boolean;
  conflictFiles?: string[];
  staged?: boolean;
+  alreadyStaged?: boolean;
  projectPath?: string;
  // New conflict info from smart merge
  conflicts?: MergeConflict[];
@@ -422,4 +435,5 @@ export interface TaskStartOptions {
  parallel?: boolean;
  workers?: number;
  model?: string;
+  baseBranch?: string; // Override base branch for worktree creation
 }
@@ -0,0 +1,79 @@
+/**
+ * Shell Escape Utilities
+ *
+ * Provides safe escaping for shell command arguments to prevent command injection.
+ * IMPORTANT: Always use these utilities when interpolating user-controlled values into shell commands.
+ */
+
+/**
+ * Escape a string for safe use as a shell argument.
+ *
+ * Uses single quotes which prevent all shell expansion (variables, command substitution, etc.)
+ * except for single quotes themselves, which are escaped as '\''
+ *
+ * Examples:
+ * - "hello" → 'hello'
+ * - "hello world" → 'hello world'
+ * - "it's" → 'it'\''s'
+ * - "$(rm -rf /)" → '$(rm -rf /)'
+ * - 'test"; rm -rf / #' → 'test"; rm -rf / #'
+ *
+ * @param arg - The argument to escape
+ * @returns The escaped argument wrapped in single quotes
+ */
+export function escapeShellArg(arg: string): string {
+  // Replace single quotes with: end quote, escaped quote, start quote
+  // This is the standard POSIX-safe way to handle single quotes
+  const escaped = arg.replace(/'/g, "'\\''");
+  return `'${escaped}'`;
+}
+
+/**
+ * Escape a path for use in a cd command.
+ *
+ * @param path - The path to escape
+ * @returns The escaped path safe for use in shell commands
+ */
+export function escapeShellPath(path: string): string {
+  return escapeShellArg(path);
+}
+
+/**
+ * Build a safe cd command from a path.
+ *
+ * @param path - The directory path
+ * @returns A safe "cd '<path>' && " string, or empty string if path is undefined
+ */
+export function buildCdCommand(path: string | undefined): string {
+  if (!path) {
+    return '';
+  }
+  return `cd ${escapeShellPath(path)} && `;
+}
+
+/**
+ * Validate that a path doesn't contain obviously malicious patterns.
+ * This is a defense-in-depth measure - escaping should handle all cases,
+ * but this can catch obvious attack attempts early.
+ *
+ * @param path - The path to validate
+ * @returns true if the path appears safe, false if it contains suspicious patterns
+ */
+export function isPathSafe(path: string): boolean {
+  // Check for obvious shell metacharacters that shouldn't appear in paths
+  // Note: This is defense-in-depth; escaping handles these, but we can log/reject
+  const suspiciousPatterns = [
+    /\$\(/, // Command substitution $(...)
+    /`/,   // Backtick command substitution
+    /\|/,  // Pipe
+    /;/,   // Command separator
+    /&&/,  // AND operator
+    /\|\|/, // OR operator
+    />/,   // Output redirection
+    /</,   // Input redirection
+    /\n/,  // Newlines
+    /\r/,  // Carriage returns
+  ];
+
+  return !suspiciousPatterns.some(pattern => pattern.test(path));
+}
@@ -1,14 +1,39 @@
 # Auto Claude Environment Variables
 # Copy this file to .env and fill in your values

-# Claude Code OAuth Token (REQUIRED)
-# Get this by running: claude setup-token
-CLAUDE_CODE_OAUTH_TOKEN=your-oauth-token-here
+# =============================================================================
+# AUTHENTICATION (REQUIRED - set ONE of the following)
+# =============================================================================
+# The framework checks these in order of priority:
+#   1. CLAUDE_CODE_OAUTH_TOKEN - Original (from `claude setup-token`)
+#   2. ANTHROPIC_AUTH_TOKEN   - For proxies like CCR
+#   3. ANTHROPIC_API_KEY      - Direct Anthropic API key
+#
+# CLAUDE_CODE_OAUTH_TOKEN=your-oauth-token-here
+# ANTHROPIC_AUTH_TOKEN=sk-zcf-x-ccr
+# ANTHROPIC_API_KEY=sk-ant-...
+
+# =============================================================================
+# CUSTOM API ENDPOINT (OPTIONAL)
+# =============================================================================
+# Override the default Anthropic API endpoint. Useful for:
+#   - Local proxies (ccr, litellm)
+#   - API gateways
+#   - Self-hosted Claude instances
+#
+# ANTHROPIC_BASE_URL=http://127.0.0.1:3456
+#
+# Related settings (usually set together with ANTHROPIC_BASE_URL):
+# NO_PROXY=127.0.0.1
+# DISABLE_TELEMETRY=true
+# DISABLE_COST_WARNINGS=true
+# API_TIMEOUT_MS=600000

 # Model override (OPTIONAL)
 # Default: claude-opus-4-5-20251101
 # AUTO_BUILD_MODEL=claude-opus-4-5-20251101

+
 # =============================================================================
 # GIT/WORKTREE SETTINGS (OPTIONAL)
 # =============================================================================
--- a/Show More
+++ b/Show More