Merge main into develop (sync after v2.7.3 release fixes)

Merge main into develop after squash merge of v2.7.3
fix(ci): fix semver comparison and changelog formatting
2026-01-12 15:44:56 +01:00 · 2026-01-12 15:42:15 +01:00 · 2026-01-12 15:40:04 +01:00 · 2026-01-12 15:26:08 +01:00 · 2026-01-12 15:06:09 +01:00 · 2026-01-12 14:47:30 +01:00
956 changed files with 44145 additions and 171701 deletions
@@ -33,21 +33,6 @@ Follow conventional commits: `<type>: <subject>`

 **Example:** `feat: add user authentication system`

-## AI Disclosure
-
-<!-- Check the box below if any part of this PR was written with AI assistance. -->
-
- [ ] This PR includes AI-generated code (Claude, Codex, Copilot, etc.)
-
-<!-- If checked, please also fill in: -->
-**Tool(s) used:** <!-- e.g., Claude Code, GitHub Copilot, ChatGPT -->
-**Testing level:**
- [ ] Untested -- AI output not yet verified
- [ ] Lightly tested -- ran the app / spot-checked key paths
- [ ] Fully tested -- all tests pass, manually verified behavior
-
- [ ] I understand what this PR does and how the underlying code works
-
 ## Checklist

 - [ ] I've synced with `develop` branch
@@ -55,21 +40,9 @@ Follow conventional commits: `<type>: <subject>`
 - [ ] I've followed the code principles (SOLID, DRY, KISS)
 - [ ] My PR is small and focused (< 400 lines ideally)

-## Platform Testing Checklist
-
-**CRITICAL:** This project supports Windows, macOS, and Linux. Platform-specific bugs are a common source of breakage.
-
- [ ] **Windows tested** (either on Windows or via CI)
- [ ] **macOS tested** (either on macOS or via CI)
- [ ] **Linux tested** (CI covers this)
- [ ] Used centralized `platform/` module instead of direct `process.platform` checks
- [ ] No hardcoded paths (used `findExecutable()` or platform abstractions)
-
-**If you only have access to one OS:** CI now tests on all platforms. Ensure all checks pass before submitting.
-
 ## CI/Testing Requirements

- [ ] All CI checks pass on **all platforms** (Windows, macOS, Linux)
+- [ ] All CI checks pass
 - [ ] All existing tests pass
 - [ ] New features include test coverage
 - [ ] Bug fixes include regression tests
@@ -1,160 +0,0 @@
-name: 'Finalize macOS Notarization'
-description: 'Wait for Apple notarization to complete and staple tickets to DMG files'
-
-inputs:
-  apple-id:
-    description: 'Apple ID for notarization'
-    required: true
-  apple-app-specific-password:
-    description: 'Apple app-specific password'
-    required: true
-  apple-team-id:
-    description: 'Apple Team ID'
-    required: true
-  intel-notarization-id:
-    description: 'Notarization request ID for Intel build'
-    required: false
-    default: ''
-  arm64-notarization-id:
-    description: 'Notarization request ID for ARM64 build'
-    required: false
-    default: ''
-  intel-dmg-file:
-    description: 'Filename of the Intel DMG'
-    required: false
-    default: ''
-  arm64-dmg-file:
-    description: 'Filename of the ARM64 DMG'
-    required: false
-    default: ''
-  intel-artifact-path:
-    description: 'Path to Intel build artifacts'
-    required: false
-    default: 'intel'
-  arm64-artifact-path:
-    description: 'Path to ARM64 build artifacts'
-    required: false
-    default: 'arm64'
-  timeout:
-    description: 'Timeout in seconds for notarization wait'
-    required: false
-    default: '3600'
-
-outputs:
-  intel-stapled:
-    description: 'Whether Intel DMG was successfully stapled'
-    value: ${{ steps.staple.outputs.intel_stapled }}
-  arm64-stapled:
-    description: 'Whether ARM64 DMG was successfully stapled'
-    value: ${{ steps.staple.outputs.arm64_stapled }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Wait for notarization and staple
-      id: staple
-      shell: bash
-      env:
-        APPLE_ID: ${{ inputs.apple-id }}
-        APPLE_APP_SPECIFIC_PASSWORD: ${{ inputs.apple-app-specific-password }}
-        APPLE_TEAM_ID: ${{ inputs.apple-team-id }}
-        INTEL_NOTARIZATION_ID: ${{ inputs.intel-notarization-id }}
-        ARM64_NOTARIZATION_ID: ${{ inputs.arm64-notarization-id }}
-        INTEL_DMG: ${{ inputs.intel-dmg-file }}
-        ARM64_DMG: ${{ inputs.arm64-dmg-file }}
-        INTEL_PATH: ${{ inputs.intel-artifact-path }}
-        ARM64_PATH: ${{ inputs.arm64-artifact-path }}
-        TIMEOUT: ${{ inputs.timeout }}
-      run: |
-        intel_stapled=false
-        arm64_stapled=false
-
-        if [ -z "$APPLE_ID" ]; then
-          echo "Skipping notarization wait: APPLE_ID not configured"
-          echo "intel_stapled=false" >> "$GITHUB_OUTPUT"
-          echo "arm64_stapled=false" >> "$GITHUB_OUTPUT"
-          exit 0
-        fi
-
-        # Warn if no notarization IDs provided (could indicate submission failure)
-        if [ -z "$INTEL_NOTARIZATION_ID" ] && [ -z "$ARM64_NOTARIZATION_ID" ]; then
-          echo "::warning::No notarization IDs provided - nothing to finalize. Check if notarization submission succeeded."
-          echo "intel_stapled=false" >> "$GITHUB_OUTPUT"
-          echo "arm64_stapled=false" >> "$GITHUB_OUTPUT"
-          exit 0
-        fi
-
-        # Wait for Intel notarization
-        if [ -n "$INTEL_NOTARIZATION_ID" ]; then
-          echo "Waiting for Intel notarization: $INTEL_NOTARIZATION_ID"
-          if ! xcrun notarytool wait "$INTEL_NOTARIZATION_ID" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --timeout "$TIMEOUT"; then
-            echo "::error::Intel notarization failed or timed out"
-            exit 1
-          fi
-          # Verify notarization was accepted (not just processed)
-          INTEL_STATUS=$(xcrun notarytool info "$INTEL_NOTARIZATION_ID" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --output-format json | jq -r '.status // "Unknown"')
-          if [ "$INTEL_STATUS" != "Accepted" ]; then
-            echo "::error::Intel notarization status is '$INTEL_STATUS', expected 'Accepted'"
-            exit 1
-          fi
-          echo "Intel notarization status: $INTEL_STATUS"
-          # Verify DMG file exists before stapling
-          if [ ! -f "$INTEL_PATH/$INTEL_DMG" ]; then
-            echo "::error::Intel DMG not found at $INTEL_PATH/$INTEL_DMG"
-            exit 1
-          fi
-          echo "Stapling Intel DMG: $INTEL_PATH/$INTEL_DMG"
-          if ! xcrun stapler staple "$INTEL_PATH/$INTEL_DMG"; then
-            echo "::error::Failed to staple Intel DMG"
-            exit 1
-          fi
-          echo "Successfully stapled Intel DMG"
-          intel_stapled=true
-        fi
-
-        # Wait for ARM64 notarization
-        if [ -n "$ARM64_NOTARIZATION_ID" ]; then
-          echo "Waiting for ARM64 notarization: $ARM64_NOTARIZATION_ID"
-          if ! xcrun notarytool wait "$ARM64_NOTARIZATION_ID" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --timeout "$TIMEOUT"; then
-            echo "::error::ARM64 notarization failed or timed out"
-            exit 1
-          fi
-          # Verify notarization was accepted (not just processed)
-          ARM64_STATUS=$(xcrun notarytool info "$ARM64_NOTARIZATION_ID" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --output-format json | jq -r '.status // "Unknown"')
-          if [ "$ARM64_STATUS" != "Accepted" ]; then
-            echo "::error::ARM64 notarization status is '$ARM64_STATUS', expected 'Accepted'"
-            exit 1
-          fi
-          echo "ARM64 notarization status: $ARM64_STATUS"
-          # Verify DMG file exists before stapling
-          if [ ! -f "$ARM64_PATH/$ARM64_DMG" ]; then
-            echo "::error::ARM64 DMG not found at $ARM64_PATH/$ARM64_DMG"
-            exit 1
-          fi
-          echo "Stapling ARM64 DMG: $ARM64_PATH/$ARM64_DMG"
-          if ! xcrun stapler staple "$ARM64_PATH/$ARM64_DMG"; then
-            echo "::error::Failed to staple ARM64 DMG"
-            exit 1
-          fi
-          echo "Successfully stapled ARM64 DMG"
-          arm64_stapled=true
-        fi
-
-        echo "intel_stapled=$intel_stapled" >> "$GITHUB_OUTPUT"
-        echo "arm64_stapled=$arm64_stapled" >> "$GITHUB_OUTPUT"
@@ -1,194 +0,0 @@
-name: 'Merge macOS Manifests'
-description: 'Merge Intel and ARM64 macOS manifests for electron-updater'
-
-inputs:
-  dist-path:
-    description: 'Path to the dist directory containing build artifacts'
-    required: false
-    default: 'dist'
-  output-path:
-    description: 'Path to output the merged manifest'
-    required: false
-    default: 'release-assets'
-  copy-other-manifests:
-    description: 'Whether to copy Windows/Linux manifests as well'
-    required: false
-    default: 'true'
-  yq-version:
-    description: 'Version of yq to use for YAML merging'
-    required: false
-    default: 'v4.44.3'
-
-outputs:
-  merged:
-    description: 'Whether manifests were merged (true) or single architecture used (false)'
-    value: ${{ steps.merge.outputs.merged }}
-  file-count:
-    description: 'Number of files in the merged manifest'
-    value: ${{ steps.validate.outputs.file_count }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Merge macOS manifests
-      id: merge
-      shell: bash
-      env:
-        # yq SHA256 checksum for v4.44.3 linux_amd64
-        # When updating yq-version, update this checksum and the one in validate step
-        YQ_SHA256: "a2c097180dd884a8d50c956ee16a9cec070f30a7947cf4ebf87d5f36213e9ed7"
-      run: |
-        echo "=== Merging macOS update manifests ==="
-
-        # Find all latest-mac.yml files from different build artifacts
-        intel_manifest=$(find "${{ inputs.dist-path }}" -path "*/macos-intel-builds/latest-mac.yml" -type f 2>/dev/null | head -1)
-        arm64_manifest=$(find "${{ inputs.dist-path }}" -path "*/macos-arm64-builds/latest-mac.yml" -type f 2>/dev/null | head -1)
-
-        echo "Intel manifest: ${intel_manifest:-not found}"
-        echo "ARM64 manifest: ${arm64_manifest:-not found}"
-
-        mkdir -p "${{ inputs.output-path }}"
-
-        if [ -n "$intel_manifest" ] && [ -n "$arm64_manifest" ]; then
-          echo "Both architectures found - merging manifests..."
-          echo "merged=true" >> "$GITHUB_OUTPUT"
-
-          # Install yq for YAML merging (pinned version with checksum verification)
-          YQ_VERSION="${{ inputs.yq-version }}"
-          YQ_URL="https://github.com/mikefarah/yq/releases/download/${YQ_VERSION}/yq_linux_amd64"
-
-          echo "Downloading yq ${YQ_VERSION}..."
-          if ! wget -qO /tmp/yq "$YQ_URL"; then
-            echo "::error::Failed to download yq ${YQ_VERSION}"
-            exit 1
-          fi
-
-          # Verify checksum
-          echo "Verifying yq checksum..."
-          ACTUAL_SHA256=$(sha256sum /tmp/yq | cut -d' ' -f1)
-          if [ "$ACTUAL_SHA256" != "$YQ_SHA256" ]; then
-            echo "::error::yq checksum verification failed!"
-            echo "Expected: $YQ_SHA256"
-            echo "Actual:   $ACTUAL_SHA256"
-            rm -f /tmp/yq
-            exit 1
-          fi
-          echo "Checksum verified successfully"
-
-          sudo mv /tmp/yq /usr/local/bin/yq
-          sudo chmod +x /usr/local/bin/yq
-          echo "Installed yq version:"
-          yq --version
-
-          # Merge the files arrays from both manifests using two-step approach
-          # Step 1: Collect all files from both manifests into a temp file
-          yq eval-all '[.files] | flatten' "$intel_manifest" "$arm64_manifest" > /tmp/merged-files.yml
-
-          # Step 2: Replace files array in first manifest with merged files
-          yq eval '.files = load("/tmp/merged-files.yml")' "$intel_manifest" > "${{ inputs.output-path }}/latest-mac.yml"
-
-          echo "Merged manifest contents:"
-          cat "${{ inputs.output-path }}/latest-mac.yml"
-
-        elif [ -n "$intel_manifest" ]; then
-          echo "Only Intel manifest found - using as-is"
-          echo "merged=false" >> "$GITHUB_OUTPUT"
-          cp "$intel_manifest" "${{ inputs.output-path }}/latest-mac.yml"
-        elif [ -n "$arm64_manifest" ]; then
-          echo "Only ARM64 manifest found - using as-is"
-          echo "merged=false" >> "$GITHUB_OUTPUT"
-          cp "$arm64_manifest" "${{ inputs.output-path }}/latest-mac.yml"
-        else
-          echo "::error::No macOS manifests found - this will cause auto-update to fail"
-          exit 1
-        fi
-
-    - name: Validate merged manifest
-      id: validate
-      shell: bash
-      env:
-        # Single source of truth for yq checksum - must match merge step
-        YQ_SHA256: "a2c097180dd884a8d50c956ee16a9cec070f30a7947cf4ebf87d5f36213e9ed7"
-      run: |
-        manifest_file="${{ inputs.output-path }}/latest-mac.yml"
-
-        echo "=== Validating merged manifest ==="
-
-        # Check file exists
-        if [ ! -f "$manifest_file" ]; then
-          echo "::error::Merged manifest file not found at $manifest_file"
-          exit 1
-        fi
-
-        # Install yq if not already installed (for single-arch case)
-        if ! command -v yq &> /dev/null; then
-          YQ_VERSION="${{ inputs.yq-version }}"
-          YQ_URL="https://github.com/mikefarah/yq/releases/download/${YQ_VERSION}/yq_linux_amd64"
-
-          echo "Downloading yq ${YQ_VERSION}..."
-          wget -qO /tmp/yq "$YQ_URL"
-
-          # Verify checksum (YQ_SHA256 from env)
-          ACTUAL_SHA256=$(sha256sum /tmp/yq | cut -d' ' -f1)
-          if [ "$ACTUAL_SHA256" != "$YQ_SHA256" ]; then
-            echo "::error::yq checksum verification failed!"
-            echo "Expected: $YQ_SHA256"
-            echo "Actual:   $ACTUAL_SHA256"
-            exit 1
-          fi
-
-          sudo mv /tmp/yq /usr/local/bin/yq
-          sudo chmod +x /usr/local/bin/yq
-        fi
-
-        # Validate YAML is parseable
-        if ! yq eval '.' "$manifest_file" > /dev/null 2>&1; then
-          echo "::error::Merged manifest is not valid YAML"
-          cat "$manifest_file"
-          exit 1
-        fi
-        echo "YAML syntax is valid"
-
-        # Count files in manifest
-        file_count=$(yq eval '.files | length' "$manifest_file")
-        echo "file_count=$file_count" >> "$GITHUB_OUTPUT"
-        echo "Manifest contains $file_count file entries"
-
-        # Validate file count
-        if [ "$file_count" -eq 0 ]; then
-          echo "::error::Merged manifest contains no files"
-          exit 1
-        fi
-
-        # If we merged both architectures, expect at least 2 files (one per arch)
-        if [ "${{ steps.merge.outputs.merged }}" = "true" ] && [ "$file_count" -lt 2 ]; then
-          echo "::warning::Merged manifest has fewer than 2 files - merge may have failed"
-        fi
-
-        # Validate required fields exist
-        if ! yq eval '.version' "$manifest_file" | grep -q .; then
-          echo "::error::Manifest missing 'version' field"
-          exit 1
-        fi
-        echo "Version field present: $(yq eval '.version' "$manifest_file")"
-
-        echo "Manifest validation passed"
-
-    - name: Copy other manifests
-      if: inputs.copy-other-manifests == 'true'
-      shell: bash
-      run: |
-        echo "=== Copying other update manifests ==="
-
-        # Copy other manifests (Windows, Linux) - these don't have the duplicate issue
-        for manifest in latest.yml latest-linux.yml latest-linux-arm64.yml; do
-          found=$(find "${{ inputs.dist-path }}" -name "$manifest" -type f 2>/dev/null | head -1)
-          if [ -n "$found" ]; then
-            echo "Copying $manifest"
-            cp "$found" "${{ inputs.output-path }}/"
-          fi
-        done
-
-        echo ""
-        echo "=== Manifest files in ${{ inputs.output-path }} ==="
-        ls -la "${{ inputs.output-path }}"/*.yml 2>/dev/null || echo "No manifest files found"
@@ -1,126 +0,0 @@
-name: 'Setup Node.js Frontend'
-description: 'Set up Node.js with npm and cached dependencies for the frontend'
-
-inputs:
-  node-version:
-    description: 'Node.js version to use'
-    required: false
-    default: '24'
-  ignore-scripts:
-    description: 'Whether to use --ignore-scripts flag during npm ci'
-    required: false
-    default: 'false'
-
-outputs:
-  cache-hit:
-    description: 'Whether npm cache was hit'
-    value: ${{ steps.cache.outputs.cache-hit }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Setup Node.js ${{ inputs.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ inputs.node-version }}
-
-    - name: Get npm cache directory
-      id: npm-cache-dir
-      shell: bash
-      run: echo "dir=$(npm config get cache)" >> "$GITHUB_OUTPUT"
-
-    - name: Cache npm dependencies
-      id: cache
-      uses: actions/cache@v4
-      with:
-        path: ${{ steps.npm-cache-dir.outputs.dir }}
-        key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-        restore-keys: ${{ runner.os }}-npm-
-
-    - name: Install dependencies
-      shell: bash
-      # Run npm ci from root to properly handle workspace dependencies.
-      # With npm workspaces, the lock file is at root and dependencies are hoisted there.
-      # Running npm ci in apps/frontend would fail to populate node_modules correctly.
-      run: |
-        if [ "${{ inputs.ignore-scripts }}" == "true" ]; then
-          npm ci --ignore-scripts
-        else
-          npm ci
-        fi
-
-    - name: Link node_modules for electron-builder
-      shell: bash
-      # electron-builder expects node_modules in apps/frontend for native module rebuilding.
-      # With npm workspaces, packages are hoisted to root. Create a link so electron-builder
-      # can find the modules during packaging and code signing.
-      # Uses symlink on Unix, directory junction on Windows (works without admin privileges).
-      #
-      # IMPORTANT: npm workspaces may create a partial node_modules in apps/frontend for
-      # packages that couldn't be hoisted. We must remove it and create a proper link to root.
-      run: |
-        # Verify npm ci succeeded
-        if [ ! -d "node_modules" ]; then
-          echo "::error::Root node_modules does not exist. npm ci may have failed."
-          exit 1
-        fi
-
-        # Remove any existing node_modules in apps/frontend
-        # This handles: partial directories from npm workspaces, AND broken symlinks
-        if [ -e "apps/frontend/node_modules" ] || [ -L "apps/frontend/node_modules" ]; then
-          # Check if it's a valid symlink pointing to root node_modules
-          if [ -L "apps/frontend/node_modules" ]; then
-            target=$(readlink apps/frontend/node_modules 2>/dev/null || echo "")
-            if [ "$target" = "../../node_modules" ] && [ -d "apps/frontend/node_modules" ]; then
-              echo "Correct symlink already exists: apps/frontend/node_modules -> ../../node_modules"
-            else
-              echo "Removing incorrect/broken symlink (was: $target)..."
-              rm -f "apps/frontend/node_modules"
-            fi
-          else
-            echo "Removing partial node_modules directory created by npm workspaces..."
-            rm -rf "apps/frontend/node_modules"
-          fi
-        fi
-
-        # Create link if it doesn't exist or was removed
-        if [ ! -L "apps/frontend/node_modules" ]; then
-          if [ "$RUNNER_OS" == "Windows" ]; then
-            # Use directory junction on Windows (works without admin privileges)
-            # Use PowerShell's New-Item -ItemType Junction for reliable path handling
-            abs_target=$(cygpath -w "$(pwd)/node_modules")
-            link_path=$(cygpath -w "$(pwd)/apps/frontend/node_modules")
-            powershell -Command "New-Item -ItemType Junction -Path '$link_path' -Target '$abs_target'" > /dev/null
-            if [ $? -eq 0 ]; then
-              echo "Created junction: apps/frontend/node_modules -> $abs_target"
-            else
-              echo "::error::Failed to create directory junction on Windows"
-              exit 1
-            fi
-          else
-            # Use symlink on Unix (macOS/Linux)
-            if ln -s ../../node_modules apps/frontend/node_modules; then
-              echo "Created symlink: apps/frontend/node_modules -> ../../node_modules"
-            else
-              echo "::error::Failed to create symlink"
-              exit 1
-            fi
-          fi
-        fi
-
-        # Final verification - the link must exist and resolve correctly
-        # Note: On Windows, junctions don't show as symlinks (-L), so we check if the directory exists
-        # and can be listed. On Unix, we also verify it's a symlink.
-        if [ "$RUNNER_OS" != "Windows" ] && [ ! -L "apps/frontend/node_modules" ]; then
-          echo "::error::apps/frontend/node_modules symlink was not created"
-          exit 1
-        fi
-        # Verify the link resolves to a valid directory with content
-        if ! ls apps/frontend/node_modules/electron >/dev/null 2>&1; then
-          echo "::error::apps/frontend/node_modules does not resolve correctly (electron not found)"
-          ls -la apps/frontend/ || true
-          ls apps/frontend/node_modules 2>&1 | head -5 || true
-          exit 1
-        fi
-        count=$(ls apps/frontend/node_modules 2>/dev/null | wc -l)
-        echo "Verified: apps/frontend/node_modules resolves correctly ($count entries)"
@@ -1,52 +0,0 @@
-name: 'Setup Python Backend'
-description: 'Set up Python with uv package manager and cached dependencies for the backend'
-
-inputs:
-  python-version:
-    description: 'Python version to use'
-    required: false
-    default: '3.12'
-  install-test-deps:
-    description: 'Whether to install test dependencies'
-    required: false
-    default: 'false'
-
-outputs:
-  cache-hit:
-    description: 'Whether cache was hit'
-    value: ${{ steps.cache.outputs.cache-hit }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Set up Python ${{ inputs.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ inputs.python-version }}
-
-    - name: Install uv package manager
-      uses: astral-sh/setup-uv@v4
-      with:
-        version: "latest"
-
-    - name: Cache uv dependencies
-      id: cache
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.cache/uv
-          ~/AppData/Local/uv/cache
-          ~/Library/Caches/uv
-        key: uv-${{ runner.os }}-${{ runner.arch }}-${{ inputs.python-version }}-${{ hashFiles('apps/backend/requirements.txt', 'tests/requirements-test.txt') }}
-        restore-keys: |
-          uv-${{ runner.os }}-${{ runner.arch }}-${{ inputs.python-version }}-
-
-    - name: Install dependencies
-      working-directory: apps/backend
-      shell: bash
-      run: |
-        uv venv
-        uv pip install -r requirements.txt
-        if [ "${{ inputs.install-test-deps }}" == "true" ]; then
-          uv pip install -r ../../tests/requirements-test.txt
-        fi
@@ -1,87 +0,0 @@
-name: 'Submit macOS Notarization'
-description: 'Submit a macOS DMG file for Apple notarization asynchronously'
-
-inputs:
-  apple-id:
-    description: 'Apple ID for notarization'
-    required: true
-  apple-app-specific-password:
-    description: 'Apple app-specific password'
-    required: true
-  apple-team-id:
-    description: 'Apple Team ID'
-    required: true
-  dmg-path:
-    description: 'Path to the dist directory containing the DMG file'
-    required: false
-    default: 'apps/frontend/dist'
-
-outputs:
-  notarization-id:
-    description: 'The notarization request ID'
-    value: ${{ steps.submit.outputs.notarization_id }}
-  dmg-file:
-    description: 'The DMG filename that was submitted'
-    value: ${{ steps.submit.outputs.dmg_file }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Submit notarization (async)
-      id: submit
-      shell: bash
-      env:
-        APPLE_ID: ${{ inputs.apple-id }}
-        APPLE_APP_SPECIFIC_PASSWORD: ${{ inputs.apple-app-specific-password }}
-        APPLE_TEAM_ID: ${{ inputs.apple-team-id }}
-        DMG_PATH: ${{ inputs.dmg-path }}
-      run: |
-        if [ -z "$APPLE_ID" ]; then
-          echo "Skipping notarization: APPLE_ID not configured"
-          echo "notarization_id=" >> "$GITHUB_OUTPUT"
-          echo "dmg_file=" >> "$GITHUB_OUTPUT"
-          exit 0
-        fi
-
-        # Find the DMG file
-        DMG_FILE=$(find "$DMG_PATH" -name "*.dmg" -type f | head -1)
-        if [ -z "$DMG_FILE" ]; then
-          echo "::error::No DMG file found in $DMG_PATH"
-          exit 1
-        fi
-
-        echo "Submitting $DMG_FILE for notarization (async)..."
-
-        # Submit for notarization without waiting
-        # Capture both stdout and exit code
-        set +e
-        RESULT=$(xcrun notarytool submit "$DMG_FILE" \
-          --apple-id "$APPLE_ID" \
-          --password "$APPLE_APP_SPECIFIC_PASSWORD" \
-          --team-id "$APPLE_TEAM_ID" \
-          --no-wait \
-          --output-format json 2>&1)
-        SUBMIT_EXIT_CODE=$?
-        set -e
-
-        echo "$RESULT"
-
-        # Check if submission command itself failed (not just missing ID)
-        if [ $SUBMIT_EXIT_CODE -ne 0 ]; then
-          echo "::error::notarytool submit failed with exit code $SUBMIT_EXIT_CODE"
-          exit 1
-        fi
-
-        # Extract the notarization ID from JSON response
-        # jq is always available on macOS runners
-        NOTARIZATION_ID=$(echo "$RESULT" | jq -r '.id // empty' 2>/dev/null)
-
-        if [ -z "$NOTARIZATION_ID" ]; then
-          echo "::error::Failed to get notarization ID from response"
-          echo "Response was: $RESULT"
-          exit 1
-        fi
-
-        echo "Notarization submitted with ID: $NOTARIZATION_ID"
-        echo "notarization_id=$NOTARIZATION_ID" >> "$GITHUB_OUTPUT"
-        echo "dmg_file=$(basename "$DMG_FILE")" >> "$GITHUB_OUTPUT"
@@ -65,9 +65,6 @@ jobs:
  build-macos-intel:
    needs: create-tag
    runs-on: macos-15-intel
-    outputs:
-      notarization_id: ${{ steps.notarize.outputs.notarization-id }}
-      dmg_file: ${{ steps.notarize.outputs.dmg-file }}
    steps:
      - uses: actions/checkout@v4
        with:
@@ -75,18 +72,33 @@ jobs:
          ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Install Rust toolchain (for building native Python packages)
        uses: dtolnay/rust-toolchain@stable

      - name: Cache pip wheel cache (for compiled packages like real_ladybug)
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/Library/Caches/pip
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -94,7 +106,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-rust-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -120,13 +132,27 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Submit notarization (async)
-        id: notarize
-        uses: ./.github/actions/submit-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
+      - name: Notarize macOS Intel app
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          if [ -z "$APPLE_ID" ]; then
+            echo "Skipping notarization: APPLE_ID not configured"
+            exit 0
+          fi
+          cd apps/frontend
+          for dmg in dist/*.dmg; do
+            echo "Notarizing $dmg..."
+            xcrun notarytool submit "$dmg" \
+              --apple-id "$APPLE_ID" \
+              --password "$APPLE_APP_SPECIFIC_PASSWORD" \
+              --team-id "$APPLE_TEAM_ID" \
+              --wait
+            xcrun stapler staple "$dmg"
+            echo "Successfully notarized and stapled $dmg"
+          done

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
@@ -141,9 +167,6 @@ jobs:
  build-macos-arm64:
    needs: create-tag
    runs-on: macos-15
-    outputs:
-      notarization_id: ${{ steps.notarize.outputs.notarization-id }}
-      dmg_file: ${{ steps.notarize.outputs.dmg-file }}
    steps:
      - uses: actions/checkout@v4
        with:
@@ -151,15 +174,30 @@ jobs:
          ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/Library/Caches/pip
          key: pip-wheel-${{ runner.os }}-arm64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -167,7 +205,7 @@ jobs:
            pip-wheel-${{ runner.os }}-arm64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-arm64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -193,13 +231,27 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Submit notarization (async)
-        id: notarize
-        uses: ./.github/actions/submit-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
+      - name: Notarize macOS ARM64 app
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          if [ -z "$APPLE_ID" ]; then
+            echo "Skipping notarization: APPLE_ID not configured"
+            exit 0
+          fi
+          cd apps/frontend
+          for dmg in dist/*.dmg; do
+            echo "Notarizing $dmg..."
+            xcrun notarytool submit "$dmg" \
+              --apple-id "$APPLE_ID" \
+              --password "$APPLE_APP_SPECIFIC_PASSWORD" \
+              --team-id "$APPLE_TEAM_ID" \
+              --wait
+            xcrun stapler staple "$dmg"
+            echo "Successfully notarized and stapled $dmg"
+          done

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
@@ -226,15 +278,31 @@ jobs:
          ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        shell: bash
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~\AppData\Local\pip\Cache
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -242,7 +310,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -398,24 +466,39 @@ jobs:
          ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'

-      - name: Setup Flatpak and verification tools
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci
+
+      - name: Setup Flatpak
        run: |
          set -e
          sudo apt-get update
-          sudo apt-get install -y flatpak flatpak-builder libarchive-tools
+          sudo apt-get install -y flatpak flatpak-builder
          flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
          flatpak install -y --user flathub org.freedesktop.Platform//25.08 org.freedesktop.Sdk//25.08
          flatpak install -y --user flathub org.electronjs.Electron2.BaseApp//25.08

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/.cache/pip
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -423,7 +506,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -447,9 +530,6 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Verify Linux packages
-        run: cd apps/frontend && npm run verify:linux
-
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
@@ -460,50 +540,8 @@ jobs:
            apps/frontend/dist/*.flatpak
            apps/frontend/dist/*.yml

-  # Finalize macOS notarization (runs in parallel with Windows/Linux builds)
-  finalize-notarization:
-    needs: [build-macos-intel, build-macos-arm64]
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Download Intel DMG
-        uses: actions/download-artifact@v7
-        with:
-          name: macos-intel-builds
-          path: intel
-
-      - name: Download ARM64 DMG
-        uses: actions/download-artifact@v7
-        with:
-          name: macos-arm64-builds
-          path: arm64
-
-      - name: Wait for notarization and staple
-        uses: ./.github/actions/finalize-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
-          intel-notarization-id: ${{ needs.build-macos-intel.outputs.notarization_id }}
-          arm64-notarization-id: ${{ needs.build-macos-arm64.outputs.notarization_id }}
-          intel-dmg-file: ${{ needs.build-macos-intel.outputs.dmg_file }}
-          arm64-dmg-file: ${{ needs.build-macos-arm64.outputs.dmg_file }}
-
-      - name: Upload stapled Intel DMG
-        uses: actions/upload-artifact@v4
-        with:
-          name: macos-intel-stapled
-          path: intel/*.dmg
-
-      - name: Upload stapled ARM64 DMG
-        uses: actions/upload-artifact@v4
-        with:
-          name: macos-arm64-stapled
-          path: arm64/*.dmg
-
  create-release:
-    needs: [create-tag, finalize-notarization, build-windows, build-linux]
+    needs: [create-tag, build-macos-intel, build-macos-arm64, build-windows, build-linux]
    runs-on: ubuntu-latest
    if: ${{ github.event.inputs.dry_run != 'true' }}
    permissions:
@@ -515,28 +553,14 @@ jobs:
          fetch-depth: 0

      - name: Download all artifacts
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          path: dist

-      - name: Flatten binary artifacts
+      - name: Flatten and validate artifacts
        run: |
          mkdir -p release-assets
-
-          # Copy stapled macOS DMGs (from finalize-notarization job)
-          # Validate that stapled DMGs exist before copying
-          if ! find dist/macos-intel-stapled dist/macos-arm64-stapled -type f -name "*.dmg" 2>/dev/null | grep -q .; then
-            echo "::warning::No stapled DMGs found. Using un-stapled DMGs from build artifacts."
-            find dist/macos-intel-builds dist/macos-arm64-builds -type f -name "*.dmg" -exec cp {} release-assets/ \; 2>/dev/null || true
-          else
-            find dist/macos-intel-stapled dist/macos-arm64-stapled -type f -name "*.dmg" -exec cp {} release-assets/ \; 2>/dev/null || true
-          fi
-
-          # Copy other macOS artifacts (zip, yml, blockmap for delta updates) from original build
-          find dist/macos-intel-builds dist/macos-arm64-builds -type f \( -name "*.zip" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
-
-          # Copy Windows and Linux artifacts (including blockmap for delta updates)
-          find dist/windows-builds dist/linux-builds -type f \( -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
+          find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" -o -name "*.yml" \) -exec cp {} release-assets/ \;

          # Validate that at least one artifact was copied
          artifact_count=$(find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) | wc -l)
@@ -545,84 +569,9 @@ jobs:
            exit 1
          fi

-          echo "Found $artifact_count binary artifact(s):"
+          echo "Found $artifact_count artifact(s):"
          ls -la release-assets/

-      # Merge macOS manifests from Intel and ARM64 builds
-      # See: https://github.com/electron-userland/electron-builder/issues/5592
-      - name: Merge macOS manifests
-        uses: ./.github/actions/merge-macos-manifests
-        with:
-          dist-path: dist
-          output-path: release-assets
-          copy-other-manifests: 'true'
-
-      - name: Rename and validate beta manifests
-        run: |
-          cd release-assets
-
-          echo "=== Current manifest files ==="
-          ls -la *.yml 2>/dev/null || echo "No yml files found yet"
-
-          # electron-builder generates latest*.yml files by default
-          # For beta channel, electron-updater expects beta*.yml files
-          # Rename: latest.yml -> beta.yml, latest-mac.yml -> beta-mac.yml, latest-linux.yml -> beta-linux.yml
-
-          # Windows: latest.yml -> beta.yml
-          if [ -f "latest.yml" ]; then
-            echo "Renaming latest.yml -> beta.yml (Windows)"
-            mv latest.yml beta.yml
-          fi
-
-          # macOS: latest-mac.yml -> beta-mac.yml
-          if [ -f "latest-mac.yml" ]; then
-            echo "Renaming latest-mac.yml -> beta-mac.yml (macOS)"
-            mv latest-mac.yml beta-mac.yml
-          fi
-
-          # Linux: latest-linux.yml -> beta-linux.yml
-          if [ -f "latest-linux.yml" ]; then
-            echo "Renaming latest-linux.yml -> beta-linux.yml (Linux)"
-            mv latest-linux.yml beta-linux.yml
-          fi
-
-          # Linux ARM64: latest-linux-arm64.yml -> beta-linux-arm64.yml (if exists)
-          if [ -f "latest-linux-arm64.yml" ]; then
-            echo "Renaming latest-linux-arm64.yml -> beta-linux-arm64.yml (Linux ARM64)"
-            mv latest-linux-arm64.yml beta-linux-arm64.yml
-          fi
-
-          echo ""
-          echo "=== Beta manifest files after rename ==="
-          ls -la *.yml 2>/dev/null || echo "No yml files found"
-
-          # Validate required beta manifests exist
-          missing_manifests=""
-
-          if [ ! -f "beta-mac.yml" ]; then
-            missing_manifests="$missing_manifests beta-mac.yml"
-          fi
-
-          if [ ! -f "beta.yml" ]; then
-            missing_manifests="$missing_manifests beta.yml"
-          fi
-
-          if [ ! -f "beta-linux.yml" ]; then
-            missing_manifests="$missing_manifests beta-linux.yml"
-          fi
-
-          if [ -n "$missing_manifests" ]; then
-            echo "::error::Missing required beta manifests:$missing_manifests"
-            echo "::error::Auto-update will fail on affected platforms without these files!"
-            exit 1
-          fi
-
-          echo ""
-          echo "All required beta manifests present:"
-          echo "  - beta-mac.yml (macOS)"
-          echo "  - beta.yml (Windows)"
-          echo "  - beta-linux.yml (Linux)"
-
      - name: Generate checksums
        run: |
          cd release-assets
@@ -657,89 +606,24 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  dry-run-summary:
-    needs: [create-tag, finalize-notarization, build-windows, build-linux]
+    needs: [create-tag, build-macos-intel, build-macos-arm64, build-windows, build-linux]
    runs-on: ubuntu-latest
    if: ${{ github.event.inputs.dry_run == 'true' }}
    steps:
-      - uses: actions/checkout@v4
-
      - name: Download all artifacts
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          path: dist

-      - name: Flatten binary artifacts
-        run: |
-          mkdir -p release-assets
-
-          # Copy stapled macOS DMGs (from finalize-notarization job)
-          find dist/macos-intel-stapled dist/macos-arm64-stapled -type f -name "*.dmg" -exec cp {} release-assets/ \; 2>/dev/null || true
-
-          # Copy other macOS artifacts (zip, yml, blockmap for delta updates) from original build
-          find dist/macos-intel-builds dist/macos-arm64-builds -type f \( -name "*.zip" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
-
-          # Copy Windows and Linux artifacts (including blockmap for delta updates)
-          find dist/windows-builds dist/linux-builds -type f \( -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
-
-      # Merge macOS manifests (same logic as real release)
-      - name: Merge macOS manifests
-        uses: ./.github/actions/merge-macos-manifests
-        with:
-          dist-path: dist
-          output-path: release-assets
-          copy-other-manifests: 'true'
-
-      - name: Validate and rename beta manifests
-        run: |
-          cd release-assets
-
-          # Rename latest*.yml to beta*.yml
-          [ -f "latest.yml" ] && mv latest.yml beta.yml
-          [ -f "latest-mac.yml" ] && mv latest-mac.yml beta-mac.yml
-          [ -f "latest-linux.yml" ] && mv latest-linux.yml beta-linux.yml
-          [ -f "latest-linux-arm64.yml" ] && mv latest-linux-arm64.yml beta-linux-arm64.yml
-
-          # Validate required manifests
-          missing=""
-          [ ! -f "beta-mac.yml" ] && missing="$missing beta-mac.yml"
-          [ ! -f "beta.yml" ] && missing="$missing beta.yml"
-          [ ! -f "beta-linux.yml" ] && missing="$missing beta-linux.yml"
-
-          if [ -n "$missing" ]; then
-            echo "::warning::DRY RUN: Missing required beta manifests:$missing"
-            echo "MANIFEST_STATUS=FAILED" >> $GITHUB_ENV
-          else
-            echo "MANIFEST_STATUS=PASSED" >> $GITHUB_ENV
-
-            # Show merged manifest content for verification
-            echo ""
-            echo "=== beta-mac.yml content (should have both architectures) ==="
-            cat beta-mac.yml
-          fi
-
      - name: Dry run summary
        run: |
          echo "## Beta Release Dry Run Complete" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "**Version:** ${{ needs.create-tag.outputs.version }}" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
-
-          echo "### Build Artifacts" >> $GITHUB_STEP_SUMMARY
+          echo "Build artifacts created successfully:" >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
          find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
-
-          echo "### Update Manifests (Required for Auto-Update)" >> $GITHUB_STEP_SUMMARY
-          if [ "$MANIFEST_STATUS" = "PASSED" ]; then
-            echo "All required beta manifests present:" >> $GITHUB_STEP_SUMMARY
-            echo "- beta-mac.yml (macOS)" >> $GITHUB_STEP_SUMMARY
-            echo "- beta.yml (Windows)" >> $GITHUB_STEP_SUMMARY
-            echo "- beta-linux.yml (Linux)" >> $GITHUB_STEP_SUMMARY
-          else
-            echo "**WARNING: Missing required manifests! Auto-update will fail.**" >> $GITHUB_STEP_SUMMARY
-            echo "Check build logs for details." >> $GITHUB_STEP_SUMMARY
-          fi
-          echo "" >> $GITHUB_STEP_SUMMARY
-
          echo "To create a real release, run this workflow again with dry_run unchecked." >> $GITHUB_STEP_SUMMARY
@@ -10,11 +10,11 @@ on:
      electron_version:
        description: 'Electron version to build for'
        required: false
-        default: '40.0.0'
+        default: '39.2.6'

 env:
  # Default Electron version - update when upgrading Electron in package.json
-  ELECTRON_VERSION: ${{ github.event.inputs.electron_version || '40.0.0' }}
+  ELECTRON_VERSION: ${{ github.event.inputs.electron_version || '39.2.6' }}

 jobs:
  build-windows:
@@ -30,7 +30,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Setup Node.js
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v4
        with:
          node-version: '24'

@@ -110,7 +110,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Download all artifacts
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          path: artifacts

@@ -1,38 +1,10 @@
-# Cross-Platform CI Pipeline
-#
-# Tests on all target platforms (Linux, Windows, macOS) to catch
-# platform-specific bugs before they merge. ALL platforms must pass.
-#
-# Optimized: Reduced matrix (4 jobs vs 6), merged integration tests,
-# coverage on Linux only, path filters to skip on docs-only changes.
-
 name: CI

 on:
  push:
    branches: [main, develop]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - 'package*.json'
-      - 'requirements*.txt'
-      - 'pyproject.toml'
-      - 'tsconfig*.json'
-      - 'biome.jsonc'
-      - '.github/workflows/ci.yml'
-      - '.github/actions/**'
  pull_request:
    branches: [main, develop]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - 'package*.json'
-      - 'requirements*.txt'
-      - 'pyproject.toml'
-      - 'tsconfig*.json'
-      - 'biome.jsonc'
-      - '.github/workflows/ci.yml'
-      - '.github/actions/**'

 concurrency:
  group: ci-${{ github.event.pull_request.number || github.ref }}
@@ -43,63 +15,53 @@ permissions:
  actions: read

 jobs:
-  # --------------------------------------------------------------------------
-  # Python Backend Tests - Optimized Matrix (4 jobs instead of 6)
-  # --------------------------------------------------------------------------
+  # Python tests
  test-python:
-    name: test-python (${{ matrix.python-version }}, ${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-
+    runs-on: ubuntu-latest
    strategy:
-      fail-fast: false
      matrix:
-        # 3.12 on all OS for cross-platform coverage
-        # 3.13 on Linux only for compatibility check (saves 2 jobs)
-        include:
-          - os: ubuntu-latest
-            python-version: '3.12'
-          - os: ubuntu-latest
-            python-version: '3.13'
-          - os: windows-latest
-            python-version: '3.12'
-          - os: macos-latest
-            python-version: '3.12'
+        python-version: ['3.12', '3.13']

    steps:
-      - name: Checkout repository
+      - name: Checkout
        uses: actions/checkout@v4

-      - name: Setup Python backend
-        uses: ./.github/actions/setup-python-backend
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
-          install-test-deps: 'true'

-      - name: Run all tests (including platform-specific)
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Install dependencies
        working-directory: apps/backend
-        shell: bash
-        env:
-          PYTHONPATH: ${{ github.workspace }}/apps/backend
        run: |
-          if [ "$RUNNER_OS" == "Windows" ]; then
-            source .venv/Scripts/activate
-          else
-            source .venv/bin/activate
-          fi
-          pytest ../../tests/ -v --tb=short -x
+          uv venv
+          uv pip install -r requirements.txt
+          uv pip install -r ../../tests/requirements-test.txt

-      - name: Run coverage (Linux + Python 3.12 only)
-        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
+      - name: Run tests
        working-directory: apps/backend
-        shell: bash
        env:
          PYTHONPATH: ${{ github.workspace }}/apps/backend
        run: |
          source .venv/bin/activate
-          pytest ../../tests/ -v --cov=. --cov-report=xml --cov-report=term-missing --cov-fail-under=10
+          pytest ../../tests/ -v --tb=short -x

-      - name: Upload coverage to Codecov
-        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
+      - name: Run tests with coverage
+        if: matrix.python-version == '3.12'
+        working-directory: apps/backend
+        env:
+          PYTHONPATH: ${{ github.workspace }}/apps/backend
+        run: |
+          source .venv/bin/activate
+          pytest ../../tests/ -v --cov=. --cov-report=xml --cov-report=term-missing --cov-fail-under=20
+
+      - name: Upload coverage reports
+        if: matrix.python-version == '3.12'
        uses: codecov/codecov-action@v4
        with:
          file: ./apps/backend/coverage.xml
@@ -107,59 +69,44 @@ jobs:
        env:
          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

-  # --------------------------------------------------------------------------
-  # Frontend Tests - All Platforms
-  # --------------------------------------------------------------------------
+  # Frontend lint, typecheck, test, and build
  test-frontend:
-    name: test-frontend (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-
+    runs-on: ubuntu-latest
    steps:
-      - name: Checkout repository
+      - name: Checkout
        uses: actions/checkout@v4

-      - name: Setup Node.js frontend
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
        with:
-          ignore-scripts: 'true'
+          node-version: '24'

-      - name: Run TypeScript type check
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        working-directory: apps/frontend
+        run: npm ci --ignore-scripts
+
+      - name: Lint
+        working-directory: apps/frontend
+        run: npm run lint
+
+      - name: Type check
        working-directory: apps/frontend
        run: npm run typecheck

-      - name: Run unit tests
+      - name: Run tests
        working-directory: apps/frontend
        run: npm run test

-      - name: Build application
+      - name: Build
        working-directory: apps/frontend
        run: npm run build
-
-  # --------------------------------------------------------------------------
-  # Gate Job - Single check for branch protection
-  # --------------------------------------------------------------------------
-  ci-complete:
-    name: CI Complete
-    runs-on: ubuntu-latest
-    needs: [test-python, test-frontend]
-    if: always()
-    steps:
-      - name: Check all CI jobs passed
-        run: |
-          echo "CI Job Results:"
-          echo "  test-python:   ${{ needs.test-python.result }}"
-          echo "  test-frontend: ${{ needs.test-frontend.result }}"
-          echo ""
-
-          if [[ "${{ needs.test-python.result }}" != "success" ]] || \
-             [[ "${{ needs.test-frontend.result }}" != "success" ]]; then
-            echo "❌ One or more CI jobs failed"
-            exit 1
-          fi
-
-          echo "✅ All CI checks passed"
@@ -11,7 +11,7 @@ jobs:
      issues: write
    steps:
      - name: Add area label from form
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
        with:
          script: |
            const issue = context.payload.issue;
@@ -3,42 +3,27 @@ name: Lint
 on:
  push:
    branches: [main, develop]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - '.github/workflows/lint.yml'
-      - '.github/actions/**'
-      - 'apps/frontend/biome.jsonc'
-      - '.pre-commit-config.yaml'
  pull_request:
    branches: [main, develop]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - '.github/workflows/lint.yml'
-      - '.github/actions/**'
-      - 'apps/frontend/biome.jsonc'
-      - '.pre-commit-config.yaml'

 concurrency:
  group: lint-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: true

 jobs:
-  # Python linting (Ruff) - already fast, no changes needed
+  # Python linting
  python:
-    name: Python (Ruff)
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

-      # Pin ruff version to match .pre-commit-config.yaml
+      # Pin ruff version to match .pre-commit-config.yaml (astral-sh/ruff-pre-commit rev)
      - name: Install ruff
        run: pip install ruff==0.14.10

@@ -47,43 +32,3 @@ jobs:

      - name: Run ruff format check
        run: ruff format apps/backend/ --check --diff
-
-  # TypeScript/JavaScript linting (Biome) - 15-25x faster than ESLint
-  typescript:
-    name: TypeScript (Biome)
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      # Pin version to match package.json for consistent behavior
-      - name: Setup Biome
-        uses: biomejs/setup-biome@v2
-        with:
-          version: 2.3.11
-
-      - name: Run Biome
-        working-directory: apps/frontend
-        # biome ci fails on errors by default; warnings are reported but don't block
-        # Use --error-on-warnings when ready to enforce all rules
-        run: biome ci .
-
-  # --------------------------------------------------------------------------
-  # Gate Job - Single check for branch protection
-  # --------------------------------------------------------------------------
-  lint-complete:
-    name: Lint Complete
-    runs-on: ubuntu-latest
-    needs: [python, typescript]
-    if: always()
-    steps:
-      - name: Check lint results
-        run: |
-          if [[ "${{ needs.python.result }}" != "success" ]] || \
-             [[ "${{ needs.typescript.result }}" != "success" ]]; then
-            echo "❌ Linting failed"
-            echo "  Python:     ${{ needs.python.result }}"
-            echo "  TypeScript: ${{ needs.typescript.result }}"
-            exit 1
-          fi
-          echo "✅ All linting passed"
@@ -22,7 +22,7 @@ jobs:

    steps:
      - name: Label PR
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
        with:
          retries: 3
          retry-exempt-status-codes: 400,401,403,404,422
@@ -64,7 +64,9 @@ jobs:
              // Label definitions
              LABELS: Object.freeze({
                SIZE: ['size/XS', 'size/S', 'size/M', 'size/L', 'size/XL'],
-                AREA: ['area/frontend', 'area/backend', 'area/fullstack', 'area/ci']
+                AREA: ['area/frontend', 'area/backend', 'area/fullstack', 'area/ci'],
+                STATUS: ['🔄 Checking', '✅ Ready for Review', '❌ Checks Failed'],
+                REVIEW: ['Missing AC Approval', 'AC: Approved', 'AC: Changes Requested', 'AC: Needs Re-review']
              }),

              // Pagination
@@ -228,6 +230,7 @@ jobs:
            const pr = context.payload.pull_request;
            const prNumber = pr.number;
            const title = pr.title || '';
+            const isNewPR = context.payload.action === 'opened' || context.payload.action === 'reopened';

            console.log(`::group::PR #${prNumber} - Auto-labeling`);
            console.log(`Title: ${title.slice(0, 100)}${title.length > 100 ? '...' : ''}`);
@@ -268,9 +271,25 @@ jobs:
            CONFIG.LABELS.SIZE.filter(l => l !== sizeLabel).forEach(l => labelsToRemove.add(l));
            console.log(`  📏 Size: ${sizeLabel} (${totalLines} lines)`);

+            // 4. Set status label (only on new PRs - let pr-status-gate handle updates on pushes)
+            // Note: On synchronize events, CI workflows will trigger pr-status-gate when they complete
+            if (isNewPR) {
+              labelsToAdd.add('🔄 Checking');
+              CONFIG.LABELS.STATUS.filter(l => l !== '🔄 Checking').forEach(l => labelsToRemove.add(l));
+              console.log(`  🔄 Status: Checking`);
+            } else {
+              console.log(`  ℹ️ Status: Unchanged (will be updated by pr-status-gate)`);
+            }
+
+            // 5. Add review label for new PRs only
+            if (isNewPR) {
+              labelsToAdd.add('Missing AC Approval');
+              console.log(`  ⏳ Review: Missing AC Approval`);
+            }
+
            console.log('::endgroup::');

-            // 4. Apply label changes
+            // 6. Apply label changes
            console.log(`::group::Applying labels`);

            // Remove labels that should be replaced (exclude ones we're adding)
@@ -283,7 +302,7 @@ jobs:
            console.log('::endgroup::');
            console.log(`✅ PR #${prNumber} labeled successfully`);

-            // 5. Write job summary
+            // 7. Write job summary
            const summaryType = type ? CONFIG.TYPE_MAP[type] || 'unknown' : 'none';
            const summaryArea = areaLabel ? areaLabel.replace('area/', '') : 'other';

@@ -293,7 +312,9 @@ jobs:
                [{ data: 'Category', header: true }, { data: 'Label', header: true }],
                ['Type', summaryType],
                ['Area', summaryArea],
-                ['Size', sizeLabel]
+                ['Size', sizeLabel],
+                ['Status', isNewPR ? '🔄 Checking' : '(unchanged)'],
+                ['Review', isNewPR ? 'Missing AC Approval' : '(unchanged)']
              ])
              .addRaw(`\n**Files:** ${files.length} | **Lines:** +${pr.additions || 0} / -${pr.deletions || 0}\n`)
              .write();
@@ -0,0 +1,585 @@
+name: PR Status Gate
+
+on:
+  workflow_run:
+    workflows: [CI, Lint, Quality Security]
+    types: [completed]
+
+  issue_comment:
+    types: [created, edited]
+
+  pull_request:
+    types: [synchronize]
+
+concurrency:
+  group: pr-status-gate-${{ github.event.workflow_run.pull_requests[0].number || github.event.issue.number || github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: true
+
+permissions:
+  pull-requests: write
+  checks: read
+
+env:
+  # Shared configuration - single source of truth
+  REQUIRED_CHECKS: |
+    CI / test-frontend
+    CI / test-python (3.12)
+    CI / test-python (3.13)
+    Lint / python
+    Quality Security / CodeQL (javascript-typescript)
+    Quality Security / CodeQL (python)
+    Quality Security / Python Security (Bandit)
+    Quality Security / Security Summary
+
+jobs:
+  # ═══════════════════════════════════════════════════════════════════════════
+  # JOB 1: CI STATUS (triggered by workflow_run)
+  # Updates CI status labels when monitored workflows complete
+  # ═══════════════════════════════════════════════════════════════════════════
+  update-ci-status:
+    name: Update CI Status
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_run' && github.event.workflow_run.pull_requests[0] != null
+    timeout-minutes: 5
+
+    steps:
+      - name: Check all required checks and update label
+        uses: actions/github-script@v7
+        env:
+          REQUIRED_CHECKS: ${{ env.REQUIRED_CHECKS }}
+        with:
+          retries: 3
+          retry-exempt-status-codes: 400,401,403,404,422
+          script: |
+            // NOTE: STATUS_LABELS is intentionally duplicated across jobs.
+            // GitHub Actions jobs run in isolated contexts and cannot share runtime constants.
+            // If label values change, update ALL occurrences: update-ci-status, check-status-command
+            const STATUS_LABELS = Object.freeze({
+              CHECKING: '🔄 Checking',
+              PASSED: '✅ Ready for Review',
+              FAILED: '❌ Checks Failed'
+            });
+
+            const REQUIRED_CHECKS = process.env.REQUIRED_CHECKS
+              .split('\n')
+              .map(s => s.trim())
+              .filter(Boolean);
+
+            async function fetchCheckRuns(sha) {
+              const { owner, repo } = context.repo;
+              // Let the configured retries (retries: 3) handle transient failures
+              // Don't catch errors - allow them to propagate for retry logic
+              const checkRuns = await github.paginate(
+                github.rest.checks.listForRef,
+                { owner, repo, ref: sha, per_page: 100 },
+                (response) => response.data
+              );
+              return checkRuns;
+            }
+
+            function analyzeChecks(checkRuns) {
+              const results = [];
+              let allComplete = true;
+              let anyFailed = false;
+
+              for (const checkName of REQUIRED_CHECKS) {
+                const check = checkRuns.find(c => c.name === checkName);
+
+                if (!check) {
+                  results.push({ name: checkName, status: '⏳ Pending', complete: false });
+                  allComplete = false;
+                } else if (check.status !== 'completed') {
+                  results.push({ name: checkName, status: '🔄 Running', complete: false });
+                  allComplete = false;
+                } else if (check.conclusion === 'success') {
+                  results.push({ name: checkName, status: '✅ Passed', complete: true });
+                } else if (check.conclusion === 'skipped') {
+                  results.push({ name: checkName, status: '⏭️ Skipped', complete: true, skipped: true });
+                } else {
+                  results.push({ name: checkName, status: '❌ Failed', complete: true, failed: true });
+                  anyFailed = true;
+                }
+              }
+              return { allComplete, anyFailed, results };
+            }
+
+            async function updateStatusLabels(prNumber, newLabel) {
+              const { owner, repo } = context.repo;
+              const allLabels = Object.values(STATUS_LABELS);
+
+              // Remove all status labels first - throw on non-404 errors to prevent conflicting labels
+              for (const label of allLabels) {
+                try {
+                  await github.rest.issues.removeLabel({ owner, repo, issue_number: prNumber, name: label });
+                } catch (e) {
+                  if (e && e.status !== 404) {
+                    // Throw to prevent adding new label if removal failed (could cause conflicting labels)
+                    throw new Error(`Failed to remove label '${label}': ${e.message}`);
+                  }
+                }
+              }
+
+              try {
+                await github.rest.issues.addLabels({ owner, repo, issue_number: prNumber, labels: [newLabel] });
+              } catch (e) {
+                if (e && e.status === 404) {
+                  core.warning(`Label '${newLabel}' does not exist`);
+                } else {
+                  throw e;
+                }
+              }
+            }
+
+            // Main logic
+            const prNumber = context.payload.workflow_run.pull_requests[0].number;
+            const headSha = context.payload.workflow_run.head_sha;
+            const triggerWorkflow = context.payload.workflow_run.name;
+
+            console.log(`PR #${prNumber} - Triggered by: ${triggerWorkflow}, SHA: ${headSha.slice(0, 8)}`);
+
+            const checkRuns = await fetchCheckRuns(headSha);
+            console.log(`Found ${checkRuns.length} check runs`);
+            const { allComplete, anyFailed, results } = analyzeChecks(checkRuns);
+
+            for (const r of results) {
+              console.log(`  ${r.status} ${r.name}`);
+            }
+
+            if (!allComplete) {
+              const pending = results.filter(r => !r.complete).length;
+              console.log(`⏳ ${pending}/${REQUIRED_CHECKS.length} checks pending`);
+              // Update to CHECKING status if checks are still running (prevents stale Ready/Failed status)
+              await updateStatusLabels(prNumber, STATUS_LABELS.CHECKING);
+              return;
+            }
+
+            const newLabel = anyFailed ? STATUS_LABELS.FAILED : STATUS_LABELS.PASSED;
+            await updateStatusLabels(prNumber, newLabel);
+
+            const passedCount = results.filter(r => r.status === '✅ Passed').length;
+            const failedCount = results.filter(r => r.failed).length;
+
+            if (anyFailed) {
+              console.log(`❌ PR #${prNumber}: ${failedCount} check(s) failed`);
+            } else {
+              console.log(`✅ PR #${prNumber}: Ready for review (${passedCount}/${REQUIRED_CHECKS.length} passed)`);
+            }
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # JOB 2: /check-status COMMAND
+  # Manual status check - anyone can trigger by commenting /check-status
+  # ═══════════════════════════════════════════════════════════════════════════
+  check-status-command:
+    name: Check Status Command
+    runs-on: ubuntu-latest
+    if: |
+      github.event_name == 'issue_comment' &&
+      github.event.issue.pull_request &&
+      contains(github.event.comment.body, '/check-status')
+    timeout-minutes: 5
+
+    steps:
+      - name: Run status check and post report
+        uses: actions/github-script@v7
+        env:
+          REQUIRED_CHECKS: ${{ env.REQUIRED_CHECKS }}
+        with:
+          retries: 3
+          retry-exempt-status-codes: 400,401,403,404,422
+          script: |
+            // NOTE: STATUS_LABELS is intentionally duplicated across jobs.
+            // GitHub Actions jobs run in isolated contexts and cannot share runtime constants.
+            // If label values change, update ALL occurrences: update-ci-status, check-status-command
+            const STATUS_LABELS = Object.freeze({
+              CHECKING: '🔄 Checking',
+              PASSED: '✅ Ready for Review',
+              FAILED: '❌ Checks Failed'
+            });
+
+            // NOTE: REVIEW_LABELS is intentionally duplicated across jobs.
+            // If label values change, update ALL occurrences: check-status-command, update-review-status
+            const REVIEW_LABELS = Object.freeze([
+              'Missing AC Approval',
+              'AC: Approved',
+              'AC: Changes Requested',
+              'AC: Blocked',
+              'AC: Needs Re-review',
+              'AC: Reviewed'
+            ]);
+
+            const REQUIRED_CHECKS = process.env.REQUIRED_CHECKS
+              .split('\n')
+              .map(s => s.trim())
+              .filter(Boolean);
+
+            const { owner, repo } = context.repo;
+            const prNumber = context.payload.issue.number;
+            const requestedBy = context.payload.comment.user.login;
+
+            // Get PR details
+            const { data: pr } = await github.rest.pulls.get({
+              owner, repo, pull_number: prNumber
+            });
+            const headSha = pr.head.sha;
+
+            console.log(`PR #${prNumber} - /check-status by @${requestedBy}, SHA: ${headSha.slice(0, 8)}`);
+
+            // Fetch check runs with pagination to handle >100 checks
+            const checkRuns = await github.paginate(
+              github.rest.checks.listForRef,
+              { owner, repo, ref: headSha, per_page: 100 },
+              (response) => response.data
+            );
+            console.log(`Found ${checkRuns.length} check runs`);
+
+            // Analyze results
+            const results = [];
+            let allComplete = true;
+            let anyFailed = false;
+
+            for (const checkName of REQUIRED_CHECKS) {
+              const check = checkRuns.find(c => c.name === checkName);
+
+              if (!check) {
+                results.push({ name: checkName, emoji: '⏳', complete: false });
+                allComplete = false;
+              } else if (check.status !== 'completed') {
+                results.push({ name: checkName, emoji: '🔄', complete: false });
+                allComplete = false;
+              } else if (check.conclusion === 'success') {
+                results.push({ name: checkName, emoji: '✅', complete: true });
+              } else if (check.conclusion === 'skipped') {
+                results.push({ name: checkName, emoji: '⏭️', complete: true, skipped: true });
+              } else {
+                results.push({ name: checkName, emoji: '❌', complete: true, failed: true });
+                anyFailed = true;
+              }
+            }
+
+            // Get current labels
+            const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
+              owner, repo, issue_number: prNumber
+            });
+            const labelNames = currentLabels.map(l => l.name);
+            const currentStatusLabel = Object.values(STATUS_LABELS).find(l => labelNames.includes(l)) || 'None';
+            const currentReviewLabel = REVIEW_LABELS.find(l => labelNames.includes(l)) || 'None';
+
+            // Update label if all checks complete
+            let newStatusLabel = STATUS_LABELS.CHECKING;
+            let statusChanged = false;
+
+            if (allComplete) {
+              newStatusLabel = anyFailed ? STATUS_LABELS.FAILED : STATUS_LABELS.PASSED;
+
+              if (newStatusLabel !== currentStatusLabel) {
+                statusChanged = true;
+                // Remove all status labels first - throw on non-404 errors to prevent conflicting labels
+                for (const label of Object.values(STATUS_LABELS)) {
+                  try {
+                    await github.rest.issues.removeLabel({ owner, repo, issue_number: prNumber, name: label });
+                  } catch (e) {
+                    if (e && e.status !== 404) {
+                      throw new Error(`Failed to remove label '${label}': ${e.message}`);
+                    }
+                  }
+                }
+                await github.rest.issues.addLabels({ owner, repo, issue_number: prNumber, labels: [newStatusLabel] });
+              }
+            }
+
+            // Build status report
+            const passedCount = results.filter(r => r.emoji === '✅').length;
+            let statusEmoji = '🔄';
+            if (allComplete && !anyFailed) statusEmoji = '✅';
+            else if (allComplete && anyFailed) statusEmoji = '❌';
+
+            const checksTable = results.map(r => `| ${r.emoji} | ${r.name} |`).join('\n');
+
+            const lines = [
+              `## ${statusEmoji} PR Status Report`,
+              '',
+              `| Label | Value |`,
+              `|-------|-------|`,
+              `| CI Status | ${newStatusLabel} |`,
+              `| AC Review | ${currentReviewLabel} |`,
+              ''
+            ];
+
+            if (statusChanged) {
+              lines.push(`> Status updated: \`${currentStatusLabel}\` → \`${newStatusLabel}\``);
+              lines.push('');
+            }
+
+            lines.push(`### CI Checks (${passedCount}/${REQUIRED_CHECKS.length} passed)`);
+            lines.push('');
+            lines.push('| Status | Check |');
+            lines.push('|--------|-------|');
+            lines.push(checksTable);
+            lines.push('');
+            lines.push('---');
+            lines.push(`<sub>Triggered by \`/check-status\` from @${requestedBy}</sub>`);
+
+            await github.rest.issues.createComment({
+              owner, repo, issue_number: prNumber, body: lines.join('\n')
+            });
+
+            console.log(`✅ Posted status report to PR #${prNumber}`);
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # JOB 3: AUTO-CLAUDE REVIEW
+  # Processes Auto-Claude review comments from trusted sources
+  # Security: Only bots and collaborators can update labels
+  # ═══════════════════════════════════════════════════════════════════════════
+  update-review-status:
+    name: Update Review Status
+    runs-on: ubuntu-latest
+    if: |
+      github.event_name == 'issue_comment' &&
+      github.event.issue.pull_request &&
+      !contains(github.event.comment.body, '/check-status')
+    timeout-minutes: 5
+
+    steps:
+      - name: Check for Auto-Claude review
+        uses: actions/github-script@v7
+        with:
+          retries: 3
+          retry-exempt-status-codes: 400,401,403,404,422
+          script: |
+            // Security configuration
+            // SECURITY: Only [bot] suffixed accounts are protected by GitHub.
+            // Regular usernames can be registered by anyone and are NOT trusted.
+            const TRUSTED_BOT_ACCOUNTS = Object.freeze([
+              'github-actions[bot]',
+              'auto-claude[bot]'
+            ]);
+
+            const TRUSTED_AUTHOR_ASSOCIATIONS = Object.freeze([
+              'COLLABORATOR',
+              'MEMBER',
+              'OWNER'
+            ]);
+
+            const IDENTIFIER_PATTERNS = Object.freeze([
+              '🤖 Auto Claude PR Review',
+              'Auto Claude Review',
+              'Auto-Claude Review'
+            ]);
+
+            // SECURITY: Regex patterns are tightened to prevent false matches
+            // Using \s* instead of .* and requiring specific emoji + verdict format
+            const VERDICTS = Object.freeze({
+              APPROVED: {
+                patterns: ['Auto Claude Review - APPROVED', '✅ Auto Claude Review - APPROVED'],
+                // Match: "Merge Verdict:" followed by whitespace/emoji, then ✅, then APPROVED/READY TO MERGE
+                regex: /Merge Verdict:\s*✅\s*(?:APPROVED|READY TO MERGE)/i,
+                label: 'AC: Approved'
+              },
+              CHANGES_REQUESTED: {
+                patterns: ['NEEDS REVISION', 'Needs Revision'],
+                // Match: "Merge Verdict:" followed by whitespace/emoji, then 🟠
+                regex: /Merge Verdict:\s*🟠/,
+                label: 'AC: Changes Requested'
+              },
+              BLOCKED: {
+                patterns: ['BLOCKED'],
+                // Match: "Merge Verdict:" followed by whitespace/emoji, then 🔴
+                regex: /Merge Verdict:\s*🔴/,
+                label: 'AC: Blocked'
+              }
+            });
+
+            // NOTE: REVIEW_LABELS is intentionally duplicated across jobs.
+            // GitHub Actions jobs run in isolated contexts and cannot share runtime constants.
+            // If label values change, update ALL occurrences: check-status-command, update-review-status
+            const REVIEW_LABELS = Object.freeze([
+              'Missing AC Approval',
+              'AC: Approved',
+              'AC: Changes Requested',
+              'AC: Blocked',
+              'AC: Needs Re-review',
+              'AC: Reviewed'
+            ]);
+
+            // Helper functions
+            // SECURITY: Verify both username AND account type to prevent spoofing
+            function isTrustedBot(username, userType) {
+              const isKnownBot = TRUSTED_BOT_ACCOUNTS.some(t => username.toLowerCase() === t.toLowerCase());
+              // Only trust if it's a known bot account AND GitHub confirms it's a Bot type
+              return isKnownBot && userType === 'Bot';
+            }
+
+            function isTrustedAssociation(assoc) {
+              return TRUSTED_AUTHOR_ASSOCIATIONS.includes(assoc);
+            }
+
+            function isAutoClaudeComment(body) {
+              return IDENTIFIER_PATTERNS.some(p => body.includes(p));
+            }
+
+            function parseVerdict(body) {
+              const safeBody = body.slice(0, 5000);
+              for (const [key, config] of Object.entries(VERDICTS)) {
+                const patternMatch = config.patterns.some(p => safeBody.includes(p));
+                const regexMatch = config.regex && config.regex.test(safeBody);
+                if (patternMatch || regexMatch) {
+                  return { verdict: key, label: config.label };
+                }
+              }
+              return null;
+            }
+
+            async function updateReviewLabels(prNumber, newLabel) {
+              const { owner, repo } = context.repo;
+
+              // Remove all review labels first - throw on non-404 errors to prevent conflicting labels
+              for (const label of REVIEW_LABELS) {
+                try {
+                  await github.rest.issues.removeLabel({ owner, repo, issue_number: prNumber, name: label });
+                  console.log(`  Removed: ${label}`);
+                } catch (e) {
+                  if (e && e.status !== 404) {
+                    // Throw to prevent adding new label if removal failed (could cause conflicting labels)
+                    throw new Error(`Failed to remove label '${label}': ${e.message}`);
+                  }
+                }
+              }
+
+              try {
+                await github.rest.issues.addLabels({ owner, repo, issue_number: prNumber, labels: [newLabel] });
+                console.log(`  Added: ${newLabel}`);
+              } catch (e) {
+                if (e && e.status === 404) {
+                  core.warning(`Label '${newLabel}' does not exist`);
+                } else {
+                  throw e;
+                }
+              }
+            }
+
+            // Main logic
+            const prNumber = context.payload.issue.number;
+            const comment = context.payload.comment;
+            const commenter = comment.user.login;
+            const commenterType = comment.user.type;
+            const authorAssociation = comment.author_association;
+            const body = comment.body || '';
+
+            console.log(`PR #${prNumber} - Comment by: ${commenter} (type: ${commenterType}, assoc: ${authorAssociation})`);
+
+            // Security checks
+            // SECURITY: Bot status requires BOTH username match AND verified Bot type
+            const isBot = isTrustedBot(commenter, commenterType);
+            const isCollaborator = isTrustedAssociation(authorAssociation);
+            const isACComment = isAutoClaudeComment(body);
+
+            console.log(`  Trusted bot: ${isBot}, Collaborator: ${isCollaborator}, AC comment: ${isACComment}`);
+
+            if (!isBot && !isCollaborator) {
+              console.log('Skipping: Not a trusted bot or collaborator');
+              return;
+            }
+
+            if (!isACComment) {
+              console.log('Skipping: Not an Auto-Claude comment');
+              return;
+            }
+
+            const verdictResult = parseVerdict(body);
+            if (!verdictResult) {
+              console.log('Skipping: Could not parse verdict');
+              return;
+            }
+
+            console.log(`Verdict: ${verdictResult.verdict} → ${verdictResult.label}`);
+            await updateReviewLabels(prNumber, verdictResult.label);
+            console.log(`✅ PR #${prNumber} review status updated`);
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # JOB 4: RE-REVIEW ON PUSH
+  # When new commits pushed after AC approval, require re-review
+  # ═══════════════════════════════════════════════════════════════════════════
+  require-re-review:
+    name: Require Re-review on Push
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request' && github.event.action == 'synchronize'
+    timeout-minutes: 5
+
+    steps:
+      - name: Check and reset AC approval if needed
+        uses: actions/github-script@v7
+        with:
+          retries: 3
+          retry-exempt-status-codes: 400,401,403,404,422
+          script: |
+            const { owner, repo } = context.repo;
+            const prNumber = context.payload.pull_request.number;
+            const pusher = context.payload.sender.login;
+
+            console.log(`PR #${prNumber} - New commits by: ${pusher}`);
+
+            // Get current labels
+            const { data: labels } = await github.rest.issues.listLabelsOnIssue({
+              owner, repo, issue_number: prNumber
+            });
+            const labelNames = labels.map(l => l.name);
+
+            // Check if PR was approved
+            const wasApproved = labelNames.includes('AC: Approved');
+
+            if (!wasApproved) {
+              console.log('PR was not AC-approved, no action needed');
+              return;
+            }
+
+            console.log('PR was AC-approved, resetting to require re-review');
+
+            // Remove AC: Approved - throw on non-404 errors to prevent conflicting labels
+            try {
+              await github.rest.issues.removeLabel({
+                owner, repo, issue_number: prNumber, name: 'AC: Approved'
+              });
+              console.log('  Removed: AC: Approved');
+            } catch (e) {
+              if (e && e.status !== 404) {
+                // Throw to prevent adding 'AC: Needs Re-review' if removal failed (could cause conflicting labels)
+                core.error(`Failed to remove 'AC: Approved' label: ${e.message}`);
+                throw e;
+              }
+            }
+
+            // Add AC: Needs Re-review
+            try {
+              await github.rest.issues.addLabels({
+                owner, repo, issue_number: prNumber, labels: ['AC: Needs Re-review']
+              });
+              console.log('  Added: AC: Needs Re-review');
+            } catch (e) {
+              if (e && e.status === 404) {
+                core.warning("Label 'AC: Needs Re-review' does not exist");
+              } else {
+                throw e;
+              }
+            }
+
+            // Post notification comment
+            const commentLines = [
+              '## 🔄 Re-review Required',
+              '',
+              'New commits were pushed after Auto-Claude approval.',
+              '',
+              '| Previous | Current |',
+              '|----------|---------|',
+              '| `AC: Approved` | `AC: Needs Re-review` |',
+              '',
+              'Please run Auto-Claude review again or request a manual review.',
+              '',
+              '---',
+              `<sub>Triggered by push from @${pusher}</sub>`
+            ];
+
+            await github.rest.issues.createComment({
+              owner, repo, issue_number: prNumber, body: commentLines.join('\n')
+            });
+
+            console.log(`✅ Posted re-review notification to PR #${prNumber}`);
@@ -29,23 +29,10 @@ jobs:
      should_release: ${{ steps.check.outputs.should_release }}
      new_version: ${{ steps.check.outputs.new_version }}
    steps:
-      # Fail fast with clear error if PAT_TOKEN is not configured
-      - name: Validate PAT_TOKEN is configured
-        run: |
-          if [ -z "${{ secrets.PAT_TOKEN }}" ]; then
-            echo "::error::PAT_TOKEN secret is not configured."
-            echo "::error::This secret is required for automatic release triggering."
-            echo "::error::See https://github.com/AndyMik90/Auto-Claude/pull/1043 for setup instructions."
-            exit 1
-          fi
-
-      # IMPORTANT: Use PAT_TOKEN instead of GITHUB_TOKEN
-      # When GITHUB_TOKEN pushes a tag, it does NOT trigger other workflows (GitHub security feature)
-      # PAT_TOKEN allows the tag push to trigger release.yml automatically
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-          token: ${{ secrets.PAT_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}

      - name: Get package version
        id: package
@@ -1,29 +1,14 @@
 name: Quality Security

-# CodeQL runs on all PRs, pushes to main, and weekly schedule
-# Note: CodeQL takes 20-30 min per language (40-60 min total)
-# Bandit is fast (5-10 min)
-
 on:
  push:
-    branches: [main]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - 'pyproject.toml'
-      - 'package.json'
-      - '.github/workflows/quality-security.yml'
+    branches: [main, develop]
  pull_request:
    branches: [main, develop]
-    paths:
-      - 'apps/**'
-      - 'tests/**'
-      - 'pyproject.toml'
-      - 'package.json'
-      - '.github/workflows/quality-security.yml'
  schedule:
    - cron: '0 0 * * 1' # Weekly on Monday at midnight UTC

+# Cancel in-progress runs for the same branch/PR
 concurrency:
  group: security-${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true
@@ -60,7 +45,6 @@ jobs:
        with:
          category: "/language:${{ matrix.language }}"

-  # Bandit runs on all PRs - it's fast (5-10 min)
  python-security:
    name: Python Security (Bandit)
    runs-on: ubuntu-latest
@@ -70,7 +54,7 @@ jobs:
        uses: actions/checkout@v4

      - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

@@ -81,6 +65,8 @@ jobs:
        id: bandit
        run: |
          echo "::group::Running Bandit security scan"
+          # Run Bandit; exit code 1 means issues found (expected), other codes are errors
+          # Flags: -r=recursive, -ll=severity LOW+, -ii=confidence LOW+, -f=format, -o=output
          bandit -r apps/backend/ -ll -ii -f json -o bandit-report.json || BANDIT_EXIT=$?
          if [ "${BANDIT_EXIT:-0}" -gt 1 ]; then
            echo "::error::Bandit scan failed with exit code $BANDIT_EXIT"
@@ -89,11 +75,12 @@ jobs:
          echo "::endgroup::"

      - name: Analyze Bandit results
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');

+            // Check if report exists
            if (!fs.existsSync('bandit-report.json')) {
              core.setFailed('Bandit report not found - scan may have failed');
              return;
@@ -102,23 +89,38 @@ jobs:
            const report = JSON.parse(fs.readFileSync('bandit-report.json', 'utf8'));
            const results = report.results || [];

+            // Categorize by severity
            const high = results.filter(r => r.issue_severity === 'HIGH');
            const medium = results.filter(r => r.issue_severity === 'MEDIUM');
            const low = results.filter(r => r.issue_severity === 'LOW');

            console.log(`::group::Bandit Security Scan Results`);
            console.log(`Found ${results.length} issues:`);
-            console.log(`  HIGH:   ${high.length}`);
-            console.log(`  MEDIUM: ${medium.length}`);
-            console.log(`  LOW:    ${low.length}`);
+            console.log(`  🔴 HIGH:   ${high.length}`);
+            console.log(`  🟡 MEDIUM: ${medium.length}`);
+            console.log(`  🟢 LOW:    ${low.length}`);
+            console.log('');
+
+            // Print high severity issues
+            if (high.length > 0) {
+              console.log('High Severity Issues:');
+              console.log('─'.repeat(60));
+              for (const issue of high) {
+                console.log(`  ${issue.filename}:${issue.line_number}`);
+                console.log(`    ${issue.issue_text}`);
+                console.log(`    Test: ${issue.test_id} (${issue.test_name})`);
+                console.log('');
+              }
+            }
            console.log('::endgroup::');

-            let summary = `## Python Security Scan (Bandit)\n\n`;
+            // Build summary
+            let summary = `## 🔒 Python Security Scan (Bandit)\n\n`;
            summary += `| Severity | Count |\n`;
            summary += `|----------|-------|\n`;
-            summary += `| High | ${high.length} |\n`;
-            summary += `| Medium | ${medium.length} |\n`;
-            summary += `| Low | ${low.length} |\n\n`;
+            summary += `| 🔴 High | ${high.length} |\n`;
+            summary += `| 🟡 Medium | ${medium.length} |\n`;
+            summary += `| 🟢 Low | ${low.length} |\n\n`;

            if (high.length > 0) {
              summary += `### High Severity Issues\n\n`;
@@ -132,15 +134,14 @@ jobs:
            core.summary.addRaw(summary);
            await core.summary.write();

+            // Fail if high severity issues found
            if (high.length > 0) {
              core.setFailed(`Found ${high.length} high severity security issue(s)`);
            } else {
-              console.log('No high severity security issues found');
+              console.log('✅ No high severity security issues found');
            }

-  # --------------------------------------------------------------------------
-  # Gate Job - Single check for branch protection
-  # --------------------------------------------------------------------------
+  # Summary job that waits for all security checks
  security-summary:
    name: Security Summary
    runs-on: ubuntu-latest
@@ -149,7 +150,7 @@ jobs:
    timeout-minutes: 5
    steps:
      - name: Check security results
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
        with:
          script: |
            const codeql = '${{ needs.codeql.result }}';
@@ -159,7 +160,7 @@ jobs:
            console.log(`  CodeQL:        ${codeql}`);
            console.log(`  Bandit:        ${bandit}`);

-            // Only 'failure' is a real failure; 'skipped' is acceptable (e.g., path filters, PR skipping CodeQL)
+            // Only 'failure' is a real failure; 'skipped' is acceptable (e.g., path filters)
            const acceptable = ['success', 'skipped'];
            const codeqlOk = acceptable.includes(codeql);
            const banditOk = acceptable.includes(bandit);
@@ -1,10 +1,5 @@
 name: Release
 # Triggers on version tags (v*) to build and publish releases
-#
-# IMPORTANT: If branch protection is enabled on 'main', the update-readme job
-# requires a PAT or GitHub App token with bypass permissions to push directly.
-# Currently uses GITHUB_TOKEN which works if "Allow GitHub Actions to create
-# and approve pull requests" is enabled OR branch protection is not configured.

 on:
  push:
@@ -15,7 +10,7 @@ on:
      dry_run:
        description: 'Test build without creating release'
        required: false
-        default: false
+        default: true
        type: boolean

 jobs:
@@ -23,25 +18,37 @@ jobs:
  # Note: macos-15-intel is the last Intel runner, supported until Fall 2027
  build-macos-intel:
    runs-on: macos-15-intel
-    outputs:
-      notarization_id: ${{ steps.notarize.outputs.notarization-id }}
-      dmg_file: ${{ steps.notarize.outputs.dmg-file }}
    steps:
      - uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Install Rust toolchain (for building native Python packages)
        uses: dtolnay/rust-toolchain@stable

      - name: Cache pip wheel cache (for compiled packages like real_ladybug)
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/Library/Caches/pip
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -49,7 +56,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-rust-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -73,13 +80,27 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Submit notarization (async)
-        id: notarize
-        uses: ./.github/actions/submit-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
+      - name: Notarize macOS Intel app
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          if [ -z "$APPLE_ID" ]; then
+            echo "Skipping notarization: APPLE_ID not configured"
+            exit 0
+          fi
+          cd apps/frontend
+          for dmg in dist/*.dmg; do
+            echo "Notarizing $dmg..."
+            xcrun notarytool submit "$dmg" \
+              --apple-id "$APPLE_ID" \
+              --password "$APPLE_APP_SPECIFIC_PASSWORD" \
+              --team-id "$APPLE_TEAM_ID" \
+              --wait
+            xcrun stapler staple "$dmg"
+            echo "Successfully notarized and stapled $dmg"
+          done

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
@@ -94,22 +115,34 @@ jobs:
  # Apple Silicon build on ARM64 runner for native compilation
  build-macos-arm64:
    runs-on: macos-15
-    outputs:
-      notarization_id: ${{ steps.notarize.outputs.notarization-id }}
-      dmg_file: ${{ steps.notarize.outputs.dmg-file }}
    steps:
      - uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/Library/Caches/pip
          key: pip-wheel-${{ runner.os }}-arm64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -117,7 +150,7 @@ jobs:
            pip-wheel-${{ runner.os }}-arm64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-arm64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -141,13 +174,27 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Submit notarization (async)
-        id: notarize
-        uses: ./.github/actions/submit-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
+      - name: Notarize macOS ARM64 app
+        env:
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          if [ -z "$APPLE_ID" ]; then
+            echo "Skipping notarization: APPLE_ID not configured"
+            exit 0
+          fi
+          cd apps/frontend
+          for dmg in dist/*.dmg; do
+            echo "Notarizing $dmg..."
+            xcrun notarytool submit "$dmg" \
+              --apple-id "$APPLE_ID" \
+              --password "$APPLE_APP_SPECIFIC_PASSWORD" \
+              --team-id "$APPLE_TEAM_ID" \
+              --wait
+            xcrun stapler staple "$dmg"
+            echo "Successfully notarized and stapled $dmg"
+          done

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
@@ -171,15 +218,31 @@ jobs:
      - uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Get npm cache directory
+        id: npm-cache
+        shell: bash
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~\AppData\Local\pip\Cache
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -187,7 +250,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -337,23 +400,38 @@ jobs:
      - uses: actions/checkout@v4

      - name: Setup Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

-      - name: Setup Node.js and install dependencies
-        uses: ./.github/actions/setup-node-frontend
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'

-      - name: Setup Flatpak and verification tools
+      - name: Get npm cache directory
+        id: npm-cache
+        run: echo "dir=$(npm config get cache)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v4
+        with:
+          path: ${{ steps.npm-cache.outputs.dir }}
+          key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: ${{ runner.os }}-npm-
+
+      - name: Install dependencies
+        run: cd apps/frontend && npm ci
+
+      - name: Setup Flatpak
        run: |
          sudo apt-get update
-          sudo apt-get install -y flatpak flatpak-builder libarchive-tools
+          sudo apt-get install -y flatpak flatpak-builder
          flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
          flatpak install -y --user flathub org.freedesktop.Platform//25.08 org.freedesktop.Sdk//25.08
          flatpak install -y --user flathub org.electronjs.Electron2.BaseApp//25.08

      - name: Cache pip wheel cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: ~/.cache/pip
          key: pip-wheel-${{ runner.os }}-x64-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -361,7 +439,7 @@ jobs:
            pip-wheel-${{ runner.os }}-x64-

      - name: Cache bundled Python
-        uses: actions/cache@v5
+        uses: actions/cache@v4
        with:
          path: apps/frontend/python-runtime
          key: python-bundle-${{ runner.os }}-x64-3.12.8-${{ hashFiles('apps/backend/requirements.txt') }}
@@ -383,9 +461,6 @@ jobs:
          SENTRY_TRACES_SAMPLE_RATE: ${{ secrets.SENTRY_TRACES_SAMPLE_RATE }}
          SENTRY_PROFILES_SAMPLE_RATE: ${{ secrets.SENTRY_PROFILES_SAMPLE_RATE }}

-      - name: Verify Linux packages
-        run: cd apps/frontend && npm run verify:linux
-
      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
@@ -397,50 +472,8 @@ jobs:
            apps/frontend/dist/*.yml
            apps/frontend/dist/*.blockmap

-  # Finalize macOS notarization (runs in parallel with Windows/Linux builds)
-  finalize-notarization:
-    needs: [build-macos-intel, build-macos-arm64]
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Download Intel DMG
-        uses: actions/download-artifact@v7
-        with:
-          name: macos-intel-builds
-          path: intel
-
-      - name: Download ARM64 DMG
-        uses: actions/download-artifact@v7
-        with:
-          name: macos-arm64-builds
-          path: arm64
-
-      - name: Wait for notarization and staple
-        uses: ./.github/actions/finalize-macos-notarization
-        with:
-          apple-id: ${{ secrets.APPLE_ID }}
-          apple-app-specific-password: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
-          apple-team-id: ${{ secrets.APPLE_TEAM_ID }}
-          intel-notarization-id: ${{ needs.build-macos-intel.outputs.notarization_id }}
-          arm64-notarization-id: ${{ needs.build-macos-arm64.outputs.notarization_id }}
-          intel-dmg-file: ${{ needs.build-macos-intel.outputs.dmg_file }}
-          arm64-dmg-file: ${{ needs.build-macos-arm64.outputs.dmg_file }}
-
-      - name: Upload stapled Intel DMG
-        uses: actions/upload-artifact@v4
-        with:
-          name: macos-intel-stapled
-          path: intel/*.dmg
-
-      - name: Upload stapled ARM64 DMG
-        uses: actions/upload-artifact@v4
-        with:
-          name: macos-arm64-stapled
-          path: arm64/*.dmg
-
  create-release:
-    needs: [build-macos-intel, build-macos-arm64, finalize-notarization, build-windows, build-linux]
+    needs: [build-macos-intel, build-macos-arm64, build-windows, build-linux]
    runs-on: ubuntu-latest
    permissions:
      contents: write
@@ -450,78 +483,35 @@ jobs:
          fetch-depth: 0

      - name: Download all artifacts
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v4
        with:
          path: dist

-      - name: Flatten binary artifacts
+      - name: Flatten and validate artifacts
        run: |
          mkdir -p release-assets
+          find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \;

-          # Copy stapled macOS DMGs (from finalize-notarization job)
-          # Validate that stapled DMGs exist before copying
-          if ! find dist/macos-intel-stapled dist/macos-arm64-stapled -type f -name "*.dmg" 2>/dev/null | grep -q .; then
-            echo "::warning::No stapled DMGs found. Using un-stapled DMGs from build artifacts."
-            find dist/macos-intel-builds dist/macos-arm64-builds -type f -name "*.dmg" -exec cp {} release-assets/ \; 2>/dev/null || true
-          else
-            find dist/macos-intel-stapled dist/macos-arm64-stapled -type f -name "*.dmg" -exec cp {} release-assets/ \; 2>/dev/null || true
-          fi
-
-          # Copy other macOS artifacts (zip, yml, blockmap) from original build
-          find dist/macos-intel-builds dist/macos-arm64-builds -type f \( -name "*.zip" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
-
-          # Copy Windows and Linux artifacts
-          find dist/windows-builds dist/linux-builds -type f \( -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" -o -name "*.yml" -o -name "*.blockmap" \) -exec cp {} release-assets/ \; 2>/dev/null || true
-
-          # Validate that installer files exist
+          # Validate that installer files exist (not just manifests)
          installer_count=$(find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) | wc -l)
          if [ "$installer_count" -eq 0 ]; then
            echo "::error::No installer artifacts found! Expected .dmg, .zip, .exe, .AppImage, .deb, or .flatpak files."
            exit 1
          fi

-          echo "Found $installer_count binary artifact(s):"
+          echo "Found $installer_count installer(s):"
          find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) -exec basename {} \;

-      # Merge macOS manifests from Intel and ARM64 builds
-      # See: https://github.com/electron-userland/electron-builder/issues/5592
-      - name: Merge macOS manifests
-        uses: ./.github/actions/merge-macos-manifests
-        with:
-          dist-path: dist
-          output-path: release-assets
-          copy-other-manifests: 'true'
-
-      - name: Validate manifests
-        run: |
          # Validate that electron-updater manifest files are present (required for auto-updates)
          yml_count=$(find release-assets -type f -name "*.yml" | wc -l)
          if [ "$yml_count" -eq 0 ]; then
-            echo "::error::No update manifest (.yml) files found! Auto-update will not work."
+            echo "::error::No update manifest (.yml) files found! Auto-update architecture detection will not work."
            exit 1
          fi

          echo "Found $yml_count manifest file(s):"
          find release-assets -type f -name "*.yml" -exec basename {} \;

-          # Validate required manifests exist
-          missing=""
-          [ ! -f "release-assets/latest-mac.yml" ] && missing="$missing latest-mac.yml"
-          [ ! -f "release-assets/latest.yml" ] && missing="$missing latest.yml"
-          [ ! -f "release-assets/latest-linux.yml" ] && missing="$missing latest-linux.yml"
-
-          if [ -n "$missing" ]; then
-            echo "::error::Missing required manifests:$missing"
-            echo "::error::Auto-update will fail on affected platforms!"
-            exit 1
-          fi
-
-          echo ""
-          echo "All required manifests present:"
-          echo "  - latest-mac.yml (macOS)"
-          echo "  - latest.yml (Windows)"
-          echo "  - latest-linux.yml (Linux)"
-
          echo ""
          echo "All release assets:"
          ls -la release-assets/
@@ -532,6 +522,144 @@ jobs:
          sha256sum ./* > checksums.sha256
          cat checksums.sha256

+      - name: Scan with VirusTotal
+        id: virustotal
+        continue-on-error: true
+        if: ${{ github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.dry_run != true) }}
+        env:
+          VT_API_KEY: ${{ secrets.VIRUSTOTAL_API_KEY }}
+        run: |
+          if [ -z "$VT_API_KEY" ]; then
+            echo "::warning::VIRUSTOTAL_API_KEY not configured, skipping scan"
+            echo "vt_results=" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          echo "## VirusTotal Scan Results" > vt_results.md
+          echo "" >> vt_results.md
+
+          for file in release-assets/*.{exe,dmg,AppImage,deb,flatpak}; do
+            [ -f "$file" ] || continue
+            filename=$(basename "$file")
+            filesize=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file")
+            echo "Scanning $filename (${filesize} bytes)..."
+
+            # For files > 32MB, get a special upload URL first
+            if [ "$filesize" -gt 33554432 ]; then
+              echo "  Large file detected, requesting upload URL..."
+              upload_url_response=$(curl -s --request GET \
+                --url "https://www.virustotal.com/api/v3/files/upload_url" \
+                --header "x-apikey: $VT_API_KEY")
+
+              upload_url=$(echo "$upload_url_response" | jq -r '.data // empty')
+              if [ -z "$upload_url" ]; then
+                echo "::warning::Failed to get upload URL for large file $filename"
+                echo "Response: $upload_url_response"
+                echo "- $filename - ⚠️ Upload failed (large file)" >> vt_results.md
+                continue
+              fi
+              api_url="$upload_url"
+            else
+              api_url="https://www.virustotal.com/api/v3/files"
+            fi
+
+            # Upload file to VirusTotal
+            response=$(curl -s --request POST \
+              --url "$api_url" \
+              --header "x-apikey: $VT_API_KEY" \
+              --form "file=@$file")
+
+            # Check if response is valid JSON before parsing
+            if ! echo "$response" | jq -e . >/dev/null 2>&1; then
+              echo "::warning::VirusTotal returned invalid JSON for $filename"
+              echo "Response (first 500 chars): ${response:0:500}"
+              echo "- $filename - ⚠️ Scan failed (invalid response)" >> vt_results.md
+              continue
+            fi
+
+            # Check for API error response
+            error_code=$(echo "$response" | jq -r '.error.code // empty')
+            if [ -n "$error_code" ]; then
+              error_msg=$(echo "$response" | jq -r '.error.message // "Unknown error"')
+              echo "::warning::VirusTotal API error for $filename: $error_code - $error_msg"
+              echo "- $filename - ⚠️ Scan failed ($error_code)" >> vt_results.md
+              continue
+            fi
+
+            # Extract analysis ID
+            analysis_id=$(echo "$response" | jq -r '.data.id // empty')
+
+            if [ -z "$analysis_id" ]; then
+              echo "::warning::Failed to upload $filename to VirusTotal"
+              echo "Response: $response"
+              echo "- $filename - ⚠️ Upload failed" >> vt_results.md
+              continue
+            fi
+
+            echo "Uploaded $filename, analysis ID: $analysis_id"
+
+            # Wait for analysis to complete (max 5 minutes per file)
+            analysis=""
+            for i in {1..30}; do
+              sleep 10
+              analysis=$(curl -s --request GET \
+                --url "https://www.virustotal.com/api/v3/analyses/$analysis_id" \
+                --header "x-apikey: $VT_API_KEY")
+
+              # Validate JSON response
+              if ! echo "$analysis" | jq -e . >/dev/null 2>&1; then
+                echo "  Warning: Invalid JSON response on attempt $i, retrying..."
+                continue
+              fi
+
+              status=$(echo "$analysis" | jq -r '.data.attributes.status // "unknown"')
+              echo "  Status: $status (attempt $i/30)"
+
+              if [ "$status" = "completed" ]; then
+                break
+              fi
+            done
+
+            # Final validation that we have valid analysis data
+            if ! echo "$analysis" | jq -e '.data.attributes.stats' >/dev/null 2>&1; then
+              echo "::warning::Could not get complete analysis for $filename, using local hash"
+              file_hash=$(sha256sum "$file" | cut -d' ' -f1)
+              echo "- [$filename](https://www.virustotal.com/gui/file/$file_hash) - ⚠️ Analysis incomplete" >> vt_results.md
+              continue
+            fi
+
+            # Get file hash for permanent URL
+            file_hash=$(echo "$analysis" | jq -r '.meta.file_info.sha256 // empty')
+
+            if [ -z "$file_hash" ]; then
+              # Fallback: calculate hash locally
+              file_hash=$(sha256sum "$file" | cut -d' ' -f1)
+            fi
+
+            # Get detection stats
+            malicious=$(echo "$analysis" | jq -r '.data.attributes.stats.malicious // 0')
+            suspicious=$(echo "$analysis" | jq -r '.data.attributes.stats.suspicious // 0')
+            undetected=$(echo "$analysis" | jq -r '.data.attributes.stats.undetected // 0')
+
+            vt_url="https://www.virustotal.com/gui/file/$file_hash"
+
+            if [ "$malicious" -gt 0 ] || [ "$suspicious" -gt 0 ]; then
+              echo "::warning::$filename has $malicious malicious and $suspicious suspicious detections (likely false positives)"
+              echo "- [$filename]($vt_url) - ⚠️ **$malicious malicious, $suspicious suspicious** detections (review recommended)" >> vt_results.md
+            else
+              echo "$filename is clean ($undetected engines, 0 detections)"
+              echo "- [$filename]($vt_url) - ✅ Clean ($undetected engines, 0 detections)" >> vt_results.md
+            fi
+          done
+
+          echo "" >> vt_results.md
+
+          # Save results for release notes
+          cat vt_results.md
+          echo "vt_results<<EOF" >> $GITHUB_OUTPUT
+          cat vt_results.md >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
      - name: Dry run summary
        if: ${{ github.event_name == 'workflow_dispatch' && inputs.dry_run == true }}
        run: |
@@ -613,9 +741,9 @@ jobs:

            ---

-            **Full Changelog**: https://github.com/${{ github.repository }}/blob/main/CHANGELOG.md
+            ${{ steps.virustotal.outputs.vt_results }}

-            _VirusTotal scan results will be added automatically after release._
+            **Full Changelog**: https://github.com/${{ github.repository }}/blob/main/CHANGELOG.md
          files: release-assets/*
          draft: false
          prerelease: ${{ contains(github.ref, 'beta') || contains(github.ref, 'alpha') }}
@@ -634,8 +762,7 @@ jobs:
      - uses: actions/checkout@v4
        with:
          ref: main
-          # Use PAT_TOKEN to bypass branch protection rules on main
-          token: ${{ secrets.PAT_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract version and detect release type
        id: version
@@ -655,14 +782,95 @@ jobs:

      - name: Update README.md
        run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          IS_PRERELEASE="${{ steps.version.outputs.is_prerelease }}"
+          python3 << 'EOF'
+          import re
+          import sys

-          if [ "$IS_PRERELEASE" = "true" ]; then
-            python3 scripts/update-readme.py "$VERSION" --prerelease
-          else
-            python3 scripts/update-readme.py "$VERSION"
-          fi
+          version = "${{ steps.version.outputs.version }}"
+          is_prerelease = "${{ steps.version.outputs.is_prerelease }}" == "true"
+
+          # Shields.io escapes hyphens as --
+          version_badge = version.replace("-", "--")
+
+          # Read README
+          with open("README.md", "r") as f:
+              content = f.read()
+
+          # Semver pattern: matches X.Y.Z or X.Y.Z-prerelease (e.g., 2.7.2, 2.7.2-beta.10)
+          # Prerelease MUST contain a dot (beta.10, alpha.1, rc.1) to avoid matching platform suffixes (win32, darwin)
+          semver = r'\d+\.\d+\.\d+(?:-[a-zA-Z]+\.[a-zA-Z0-9.]+)?'
+          # Shields.io escaped pattern (hyphens as --)
+          semver_badge = r'\d+\.\d+\.\d+(?:--[a-zA-Z]+\.[a-zA-Z0-9.]+)?'
+
+          def update_section(text, start_marker, end_marker, replacements):
+              """Update content between markers with given replacements."""
+              pattern = f'({re.escape(start_marker)})(.*?)({re.escape(end_marker)})'
+              def replace_section(match):
+                  section = match.group(2)
+                  for old_pattern, new_value in replacements:
+                      section = re.sub(old_pattern, new_value, section)
+                  return match.group(1) + section + match.group(3)
+              return re.sub(pattern, replace_section, text, flags=re.DOTALL)
+
+          if is_prerelease:
+              print(f"Updating BETA section to {version} (badge: {version_badge})")
+
+              # Update beta badge
+              content = re.sub(
+                  rf'beta-{semver_badge}-orange',
+                  f'beta-{version_badge}-orange',
+                  content
+              )
+
+              # Update beta version badge link
+              content = update_section(content,
+                  '<!-- BETA_VERSION_BADGE -->', '<!-- BETA_VERSION_BADGE_END -->',
+                  [(rf'tag/v{semver}\)', f'tag/v{version})')])
+
+              # Update beta downloads
+              content = update_section(content,
+                  '<!-- BETA_DOWNLOADS -->', '<!-- BETA_DOWNLOADS_END -->',
+                  [
+                      (rf'Auto-Claude-{semver}', f'Auto-Claude-{version}'),
+                      (rf'download/v{semver}/', f'download/v{version}/'),
+                  ])
+          else:
+              print(f"Updating STABLE section to {version} (badge: {version_badge})")
+
+              # Update top version badge
+              content = update_section(content,
+                  '<!-- TOP_VERSION_BADGE -->', '<!-- TOP_VERSION_BADGE_END -->',
+                  [
+                      (rf'version-{semver_badge}-blue', f'version-{version_badge}-blue'),
+                      (rf'tag/v{semver}\)', f'tag/v{version})'),
+                  ])
+
+              # Update stable badge
+              content = re.sub(
+                  rf'stable-{semver_badge}-blue',
+                  f'stable-{version_badge}-blue',
+                  content
+              )
+
+              # Update stable version badge link
+              content = update_section(content,
+                  '<!-- STABLE_VERSION_BADGE -->', '<!-- STABLE_VERSION_BADGE_END -->',
+                  [(rf'tag/v{semver}\)', f'tag/v{version})')])
+
+              # Update stable downloads
+              content = update_section(content,
+                  '<!-- STABLE_DOWNLOADS -->', '<!-- STABLE_DOWNLOADS_END -->',
+                  [
+                      (rf'Auto-Claude-{semver}', f'Auto-Claude-{version}'),
+                      (rf'download/v{semver}/', f'download/v{version}/'),
+                  ])
+
+          # Write updated README
+          with open("README.md", "w") as f:
+              f.write(content)
+
+          print(f"README.md updated for {version} (prerelease={is_prerelease})")
+          EOF

          echo "--- Verifying update ---"
          grep -E "(stable-|beta-|version-)[0-9]" README.md | head -5
@@ -1,21 +0,0 @@
-name: Test Azure Auth
-
-on:
-  workflow_dispatch:
-
-jobs:
-  test-auth:
-    runs-on: windows-latest
-    permissions:
-      id-token: write
-      contents: read
-    steps:
-      - name: Azure Login (OIDC)
-        uses: azure/login@v2
-        with:
-          client-id: ${{ secrets.AZURE_CLIENT_ID }}
-          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
-          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-
-      - name: Success
-        run: echo "Azure authentication successful!"
@@ -0,0 +1,63 @@
+name: Test on Tag
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  # Python tests
+  test-python:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.12', '3.13']
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Install dependencies
+        working-directory: apps/backend
+        run: |
+          uv venv
+          uv pip install -r requirements.txt
+          uv pip install -r ../../tests/requirements-test.txt
+
+      - name: Run tests
+        working-directory: apps/backend
+        env:
+          PYTHONPATH: ${{ github.workspace }}/apps/backend
+        run: |
+          source .venv/bin/activate
+          pytest ../../tests/ -v --tb=short
+
+  # Frontend tests
+  test-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Install dependencies
+        working-directory: apps/frontend
+        run: npm ci --ignore-scripts
+
+      - name: Run tests
+        working-directory: apps/frontend
+        run: npm run test
@@ -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('./apps/frontend/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,343 +0,0 @@
-name: VirusTotal Scan
-
-# Runs AFTER release is published to avoid blocking release creation
-# VirusTotal scans can take 5+ minutes per file, which delays releases
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Release tag to scan (e.g., v2.8.0)'
-        required: true
-        type: string
-
-# Prevent TOCTOU race condition when updating release notes
-# If two runs target the same tag, queue them instead of running in parallel
-concurrency:
-  group: virustotal-${{ github.event.inputs.tag || github.event.release.tag_name }}
-  cancel-in-progress: false
-
-jobs:
-  scan:
-    name: Scan release assets
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write  # Required to update release notes
-    steps:
-      - name: Determine release tag
-        id: tag
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "tag=${{ github.event.inputs.tag }}" >> $GITHUB_OUTPUT
-          else
-            echo "tag=${{ github.event.release.tag_name }}" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Check for API key
-        id: check-key
-        env:
-          VT_KEY: ${{ secrets.VIRUSTOTAL_API_KEY }}
-        run: |
-          if [ -z "$VT_KEY" ]; then
-            echo "::warning::VIRUSTOTAL_API_KEY not configured, skipping scan"
-            echo "has_key=false" >> $GITHUB_OUTPUT
-          else
-            echo "has_key=true" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Download release assets
-        if: steps.check-key.outputs.has_key == 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          TAG="${{ steps.tag.outputs.tag }}"
-          echo "Downloading assets for release $TAG..."
-
-          mkdir -p release-assets
-
-          # First verify the release exists
-          if ! gh release view "$TAG" --repo "${{ github.repository }}" >/dev/null 2>&1; then
-            echo "::error::Release $TAG not found"
-            exit 1
-          fi
-
-          # Download assets, distinguishing between "no matching assets" and real errors
-          set +e
-          gh release download "$TAG" \
-            --repo "${{ github.repository }}" \
-            --pattern "*.exe" \
-            --pattern "*.dmg" \
-            --pattern "*.AppImage" \
-            --pattern "*.deb" \
-            --pattern "*.flatpak" \
-            --dir release-assets 2>&1
-          exit_code=$?
-          set -e
-
-          if [ $exit_code -ne 0 ]; then
-            # Check if it's just "no assets matched" vs a real error
-            asset_count=$(gh release view "$TAG" --repo "${{ github.repository }}" --json assets -q '.assets | length')
-            if [ "$asset_count" -eq 0 ]; then
-              echo "Release has no assets yet (this is OK for new releases)"
-            else
-              # Check if any scannable assets exist that should have been downloaded
-              scannable_assets=$(gh release view "$TAG" --repo "${{ github.repository }}" --json assets \
-                -q '.assets[].name | select(test("\\.(exe|dmg|AppImage|deb|flatpak)$"))' | wc -l)
-              if [ "$scannable_assets" -gt 0 ]; then
-                echo "::error::Download failed - $scannable_assets scannable asset(s) exist but download failed"
-                exit 1
-              fi
-              echo "No assets matched the patterns (exe, dmg, AppImage, deb, flatpak)"
-            fi
-          fi
-
-          echo "Downloaded assets:"
-          ls -la release-assets/ || echo "No assets found"
-
-      - name: Scan with VirusTotal
-        if: steps.check-key.outputs.has_key == 'true'
-        id: virustotal
-        env:
-          VT_API_KEY: ${{ secrets.VIRUSTOTAL_API_KEY }}
-        run: |
-          echo "## VirusTotal Scan Results" > vt_results.md
-          echo "" >> vt_results.md
-
-          # Check if there are any files to scan
-          shopt -s nullglob
-          files=(release-assets/*.{exe,dmg,AppImage,deb,flatpak})
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "No scannable files found in release assets"
-            echo "- No executable files found in release" >> vt_results.md
-            echo "vt_results<<EOF" >> $GITHUB_OUTPUT
-            cat vt_results.md >> $GITHUB_OUTPUT
-            echo "EOF" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          for file in "${files[@]}"; do
-            [ -f "$file" ] || continue
-            filename=$(basename "$file")
-            filesize=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file")
-            echo "Scanning $filename (${filesize} bytes)..."
-
-            # VirusTotal requires special upload URL for files > 32MB
-            LARGE_FILE_THRESHOLD=33554432  # 32 MB in bytes
-            if [ "$filesize" -gt "$LARGE_FILE_THRESHOLD" ]; then
-              echo "  Large file detected, requesting upload URL..."
-              upload_http_response=$(curl -s -w '\n%{http_code}' --request GET \
-                --url "https://www.virustotal.com/api/v3/files/upload_url" \
-                --header "x-apikey: $VT_API_KEY")
-              upload_http_code=$(echo "$upload_http_response" | tail -1)
-              upload_url_response=$(echo "$upload_http_response" | sed '$d')
-
-              if [ "$upload_http_code" != "200" ]; then
-                echo "::warning::Failed to get upload URL for large file $filename (HTTP $upload_http_code)"
-                echo "- $filename - ⚠️ Upload failed (large file, HTTP $upload_http_code)" >> vt_results.md
-                continue
-              fi
-
-              upload_url=$(echo "$upload_url_response" | jq -r '.data // empty')
-              if [ -z "$upload_url" ]; then
-                echo "::warning::Failed to get upload URL for large file $filename"
-                echo "Response: $upload_url_response"
-                echo "- $filename - ⚠️ Upload failed (large file)" >> vt_results.md
-                continue
-              fi
-              api_url="$upload_url"
-            else
-              api_url="https://www.virustotal.com/api/v3/files"
-            fi
-
-            # Upload file to VirusTotal (capture HTTP status code)
-            http_response=$(curl -s -w '\n%{http_code}' --request POST \
-              --url "$api_url" \
-              --header "x-apikey: $VT_API_KEY" \
-              --form "file=@$file")
-            http_code=$(echo "$http_response" | tail -1)
-            response=$(echo "$http_response" | sed '$d')
-
-            # Check HTTP status code first
-            if [ "$http_code" != "200" ]; then
-              echo "::warning::VirusTotal returned HTTP $http_code for $filename"
-              if [ "$http_code" = "429" ]; then
-                echo "- $filename - ⚠️ Scan failed (rate limited)" >> vt_results.md
-              elif [ "$http_code" = "403" ]; then
-                echo "- $filename - ⚠️ Scan failed (forbidden - check API key)" >> vt_results.md
-              else
-                echo "- $filename - ⚠️ Scan failed (HTTP $http_code)" >> vt_results.md
-              fi
-              continue
-            fi
-
-            # Check if response is valid JSON before parsing
-            if ! echo "$response" | jq -e . >/dev/null 2>&1; then
-              echo "::warning::VirusTotal returned invalid JSON for $filename"
-              echo "Response (first 500 chars): ${response:0:500}"
-              echo "- $filename - ⚠️ Scan failed (invalid response)" >> vt_results.md
-              continue
-            fi
-
-            # Check for API error response
-            error_code=$(echo "$response" | jq -r '.error.code // empty')
-            if [ -n "$error_code" ]; then
-              error_msg=$(echo "$response" | jq -r '.error.message // "Unknown error"')
-              echo "::warning::VirusTotal API error for $filename: $error_code - $error_msg"
-              echo "- $filename - ⚠️ Scan failed ($error_code)" >> vt_results.md
-              continue
-            fi
-
-            # Extract analysis ID
-            analysis_id=$(echo "$response" | jq -r '.data.id // empty')
-
-            if [ -z "$analysis_id" ]; then
-              echo "::warning::Failed to upload $filename to VirusTotal"
-              echo "Response: $response"
-              echo "- $filename - ⚠️ Upload failed" >> vt_results.md
-              continue
-            fi
-
-            echo "Uploaded $filename, analysis ID: $analysis_id"
-
-            # Wait for analysis to complete (max 5 minutes per file)
-            analysis=""
-            for i in {1..30}; do
-              sleep 10
-              analysis_http_response=$(curl -s -w '\n%{http_code}' --request GET \
-                --url "https://www.virustotal.com/api/v3/analyses/$analysis_id" \
-                --header "x-apikey: $VT_API_KEY")
-              analysis_http_code=$(echo "$analysis_http_response" | tail -1)
-              analysis=$(echo "$analysis_http_response" | sed '$d')
-
-              # Check HTTP status code
-              if [ "$analysis_http_code" != "200" ]; then
-                echo "  Warning: HTTP $analysis_http_code on attempt $i, retrying..."
-                if [ "$analysis_http_code" = "429" ]; then
-                  echo "  Rate limited, waiting longer..."
-                  sleep 30
-                fi
-                continue
-              fi
-
-              # Validate JSON response
-              if ! echo "$analysis" | jq -e . >/dev/null 2>&1; then
-                echo "  Warning: Invalid JSON response on attempt $i, retrying..."
-                continue
-              fi
-
-              status=$(echo "$analysis" | jq -r '.data.attributes.status // "unknown"')
-              echo "  Status: $status (attempt $i/30)"
-
-              if [ "$status" = "completed" ]; then
-                break
-              fi
-            done
-
-            # Handle analysis timeout - if loop completed without status=completed
-            if [ "$status" != "completed" ]; then
-              echo "::warning::Analysis timed out for $filename (status: $status after 5 minutes)"
-              file_hash=$(sha256sum "$file" | cut -d' ' -f1)
-              echo "- [$filename](https://www.virustotal.com/gui/file/$file_hash) - ⚠️ Analysis timed out" >> vt_results.md
-              continue
-            fi
-
-            # Final validation that we have valid analysis data
-            if ! echo "$analysis" | jq -e '.data.attributes.stats' >/dev/null 2>&1; then
-              echo "::warning::Could not get complete analysis for $filename, using local hash"
-              file_hash=$(sha256sum "$file" | cut -d' ' -f1)
-              echo "- [$filename](https://www.virustotal.com/gui/file/$file_hash) - ⚠️ Analysis incomplete" >> vt_results.md
-              continue
-            fi
-
-            # Get file hash for permanent URL
-            file_hash=$(echo "$analysis" | jq -r '.meta.file_info.sha256 // empty')
-
-            if [ -z "$file_hash" ]; then
-              # Fallback: calculate hash locally
-              file_hash=$(sha256sum "$file" | cut -d' ' -f1)
-            fi
-
-            # Get detection stats
-            malicious=$(echo "$analysis" | jq -r '.data.attributes.stats.malicious // 0')
-            suspicious=$(echo "$analysis" | jq -r '.data.attributes.stats.suspicious // 0')
-            undetected=$(echo "$analysis" | jq -r '.data.attributes.stats.undetected // 0')
-
-            vt_url="https://www.virustotal.com/gui/file/$file_hash"
-
-            if [ "$malicious" -gt 0 ] || [ "$suspicious" -gt 0 ]; then
-              echo "::warning::$filename has $malicious malicious and $suspicious suspicious detections (likely false positives)"
-              echo "- [$filename]($vt_url) - ⚠️ **$malicious malicious, $suspicious suspicious** detections (review recommended)" >> vt_results.md
-            else
-              echo "$filename is clean ($undetected engines, 0 detections)"
-              echo "- [$filename]($vt_url) - ✅ Clean ($undetected engines, 0 detections)" >> vt_results.md
-            fi
-          done
-
-          echo "" >> vt_results.md
-
-          # Save results for next step
-          cat vt_results.md
-          echo "vt_results<<EOF" >> $GITHUB_OUTPUT
-          cat vt_results.md >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
-
-      - name: Update release notes with scan results
-        if: steps.check-key.outputs.has_key == 'true' && steps.virustotal.outputs.vt_results != ''
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          TAG="${{ steps.tag.outputs.tag }}"
-
-          # Get current release body with error checking
-          if ! current_body=$(gh release view "$TAG" --repo "${{ github.repository }}" --json body -q '.body'); then
-            echo "::error::Failed to fetch current release body for $TAG"
-            exit 1
-          fi
-
-          # Additional safeguard for empty body
-          if [ -z "$current_body" ]; then
-            echo "::warning::Release body is empty, this may indicate a problem"
-          fi
-
-          # Check if VirusTotal results already exist in the body
-          if echo "$current_body" | grep -q "## VirusTotal Scan Results"; then
-            echo "VirusTotal results already in release notes, skipping update"
-            exit 0
-          fi
-
-          # Use file-based approach to avoid shell expansion issues
-          # First, write current body to file
-          echo "$current_body" > release-body.md
-
-          # Remove placeholder text if present (portable sed approach)
-          sed '/_VirusTotal scan results will be added automatically after release\./d' release-body.md > release-body.tmp && mv release-body.tmp release-body.md
-
-          # Append separator and VT results
-          echo "" >> release-body.md
-          echo "---" >> release-body.md
-          echo "" >> release-body.md
-          cat vt_results.md >> release-body.md
-
-          # Update release using --notes-file to avoid shell quoting issues
-          gh release edit "$TAG" \
-            --repo "${{ github.repository }}" \
-            --notes-file release-body.md
-
-          echo "✅ Updated release notes with VirusTotal scan results"
-
-      - name: Summary
-        if: always()
-        run: |
-          echo "## VirusTotal Scan Summary" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "**Release:** ${{ steps.tag.outputs.tag }}" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          if [ "${{ steps.check-key.outputs.has_key }}" = "false" ]; then
-            echo "⚠️ Scan skipped: VIRUSTOTAL_API_KEY not configured" >> $GITHUB_STEP_SUMMARY
-          elif [ -f vt_results.md ]; then
-            cat vt_results.md >> $GITHUB_STEP_SUMMARY
-          else
-            echo "No scan results available" >> $GITHUB_STEP_SUMMARY
-          fi
@@ -7,7 +7,6 @@
 Thumbs.db
 ehthumbs.db
 Desktop.ini
-nul

 # ===========================
 # Security - Environment & Secrets
@@ -57,8 +56,6 @@ lerna-debug.log*
 # Auto Claude Generated
 # ===========================
 .auto-claude/
-.planning/
-.planning-archive/
 .auto-build-security.json
 .auto-claude-security.json
 .auto-claude-status
@@ -110,8 +107,7 @@ dmypy.json
 # ===========================
 # Node.js (apps/frontend)
 # ===========================
-node_modules
-apps/frontend/node_modules
+node_modules/
 .npm
 .yarn/
 .pnp.*
@@ -172,6 +168,3 @@ OPUS_ANALYSIS_AND_IDEAS.md

 # Auto Claude generated files
 .security-key
-/shared_docs
-logs/security/
-Agents.md
@@ -1,36 +1,11 @@
 #!/bin/sh

-# =============================================================================
-# GIT WORKTREE ENVIRONMENT CLEANUP
-# =============================================================================
-# Git automatically sets GIT_DIR (and CWD to the working tree root) before
-# running hooks -- even in worktrees. We do NOT need to manually parse .git
-# files or export GIT_DIR/GIT_WORK_TREE.
-#
-# However, external tools (IDEs, agents, parent shells) may leave stale
-# GIT_DIR/GIT_WORK_TREE values in the environment. If these point to a
-# different repo or worktree, git commands in this hook would target the
-# wrong repository. Unsetting them lets git re-resolve the correct values
-# from the working directory.
-# =============================================================================
-unset GIT_DIR
-unset GIT_WORK_TREE
-
-# =============================================================================
-# SAFETY CHECK: Detect and fix corrupted core.worktree configuration
-# =============================================================================
-# core.worktree lives in the SHARED .git/config (not per-worktree). If any
-# process accidentally writes it (e.g., running `git init` with a leaked
-# GIT_WORK_TREE), ALL repos and worktrees see the wrong working tree root,
-# causing files from one worktree to "leak" into others.
-#
-# This check runs from both main repo and worktree contexts since the config
-# is shared and corruption can happen from either.
-CORE_WORKTREE=$(git config --get core.worktree 2>/dev/null || true)
-if [ -n "$CORE_WORKTREE" ]; then
-  echo "Warning: Detected corrupted core.worktree setting ('$CORE_WORKTREE'), removing it..."
-  if ! git config --unset core.worktree 2>/dev/null; then
-    echo "Warning: Failed to unset core.worktree. Manual intervention may be needed."
+# Preserve git worktree context - prevent HEAD corruption in worktrees
+if [ -f ".git" ]; then
+  WORKTREE_GIT_DIR=$(cat .git | sed 's/gitdir: //')
+  if [ -n "$WORKTREE_GIT_DIR" ]; then
+    export GIT_DIR="$WORKTREE_GIT_DIR"
+    export GIT_WORK_TREE="$(pwd)"
  fi
 fi

@@ -87,9 +62,8 @@ if git diff --cached --name-only | grep -q "^package.json$"; then
        sed -i.bak '/<!-- BETA_VERSION_BADGE -->/,/<!-- BETA_VERSION_BADGE_END -->/s|releases/tag/v[0-9.a-z-]*)|releases/tag/v'"$VERSION"')|g' README.md

        # Update beta download links (within BETA_DOWNLOADS section only)
-        # Use perl for cross-platform compatibility (BSD sed doesn't support {block} syntax)
        for SUFFIX in "win32-x64.exe" "darwin-arm64.dmg" "darwin-x64.dmg" "linux-x86_64.AppImage" "linux-amd64.deb" "linux-x86_64.flatpak"; do
-          perl -i -pe 'if (/<!-- BETA_DOWNLOADS -->/ .. /<!-- BETA_DOWNLOADS_END -->/) { s|Auto-Claude-[0-9.a-z-]*-'"$SUFFIX"'\]\(https://github.com/AndyMik90/Auto-Claude/releases/download/v[^/]*/Auto-Claude-[^)]*-'"$SUFFIX"'\)|Auto-Claude-'"$VERSION"'-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v'"$VERSION"'/Auto-Claude-'"$VERSION"'-'"$SUFFIX"')|g }' README.md
+          sed -i.bak '/<!-- BETA_DOWNLOADS -->/,/<!-- BETA_DOWNLOADS_END -->/{s|Auto-Claude-[0-9.a-z-]*-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v[^/]*/Auto-Claude-[^)]*-'"$SUFFIX"')|Auto-Claude-'"$VERSION"'-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v'"$VERSION"'/Auto-Claude-'"$VERSION"'-'"$SUFFIX"')|g}' README.md
        done
      else
        # STABLE: Update stable sections and top badge
@@ -104,9 +78,8 @@ if git diff --cached --name-only | grep -q "^package.json$"; then
        sed -i.bak '/<!-- STABLE_VERSION_BADGE -->/,/<!-- STABLE_VERSION_BADGE_END -->/s|releases/tag/v[0-9.a-z-]*)|releases/tag/v'"$VERSION"')|g' README.md

        # Update stable download links (within STABLE_DOWNLOADS section only)
-        # Use perl for cross-platform compatibility (BSD sed doesn't support {block} syntax)
        for SUFFIX in "win32-x64.exe" "darwin-arm64.dmg" "darwin-x64.dmg" "linux-x86_64.AppImage" "linux-amd64.deb"; do
-          perl -i -pe 'if (/<!-- STABLE_DOWNLOADS -->/ .. /<!-- STABLE_DOWNLOADS_END -->/) { s|Auto-Claude-[0-9.a-z-]*-'"$SUFFIX"'\]\(https://github.com/AndyMik90/Auto-Claude/releases/download/v[^/]*/Auto-Claude-[^)]*-'"$SUFFIX"'\)|Auto-Claude-'"$VERSION"'-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v'"$VERSION"'/Auto-Claude-'"$VERSION"'-'"$SUFFIX"')|g }' README.md
+          sed -i.bak '/<!-- STABLE_DOWNLOADS -->/,/<!-- STABLE_DOWNLOADS_END -->/{s|Auto-Claude-[0-9.a-z-]*-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v[^/]*/Auto-Claude-[^)]*-'"$SUFFIX"')|Auto-Claude-'"$VERSION"'-'"$SUFFIX"'](https://github.com/AndyMik90/Auto-Claude/releases/download/v'"$VERSION"'/Auto-Claude-'"$VERSION"'-'"$SUFFIX"')|g}' README.md
        done
      fi

@@ -127,13 +100,6 @@ fi
 if git diff --cached --name-only | grep -q "^apps/backend/.*\.py$"; then
  echo "Python changes detected, running backend checks..."

-  # Detect if we're in a worktree
-  IS_WORKTREE=false
-  if [ -f ".git" ]; then
-    # .git is a file (not directory) in worktrees
-    IS_WORKTREE=true
-  fi
-
  # Determine ruff command (venv or global)
  RUFF=""
  if [ -f "apps/backend/.venv/bin/ruff" ]; then
@@ -165,71 +131,36 @@ if git diff --cached --name-only | grep -q "^apps/backend/.*\.py$"; then
      echo "$STAGED_PY_FILES" | xargs git add
    fi
  else
-    if [ "$IS_WORKTREE" = true ]; then
-      echo ""
-      echo "⚠️  WARNING: ruff not available in this worktree."
-      echo "   Python linting checks will be skipped."
-      echo "   This is expected for auto-claude worktrees."
-      echo "   Full validation will occur when PR is created/merged."
-      echo ""
-    else
-      echo "Warning: ruff not found, skipping Python linting. Install with: uv pip install ruff"
-    fi
+    echo "Warning: ruff not found, skipping Python linting. Install with: uv pip install ruff"
  fi

  # Run pytest (skip slow/integration tests and Windows-incompatible tests for pre-commit speed)
-  # Run from repo root (not apps/backend) so tests that use Path.resolve() get correct CWD.
-  # PYTHONPATH includes apps/backend so imports resolve correctly.
+  # Use subshell to isolate directory changes and prevent worktree corruption
  echo "Running Python tests..."
  (
+    cd apps/backend
    # Tests to skip: graphiti (external deps), merge_file_tracker/service_orchestrator/worktree/workspace (Windows path/git issues)
-    # Also skip tests that require optional dependencies (pydantic structured outputs)
-    # Also skip gitlab_e2e (e2e test sensitive to test-ordering env contamination, validated by CI)
-    IGNORE_TESTS="--ignore=tests/test_graphiti.py --ignore=tests/test_merge_file_tracker.py --ignore=tests/test_service_orchestrator.py --ignore=tests/test_worktree.py --ignore=tests/test_workspace.py --ignore=tests/test_finding_validation.py --ignore=tests/test_sdk_structured_output.py --ignore=tests/test_structured_outputs.py --ignore=tests/test_gitlab_e2e.py"
-    # Determine Python executable from venv
-    VENV_PYTHON=""
-    if [ -f "apps/backend/.venv/bin/python" ]; then
-      VENV_PYTHON="apps/backend/.venv/bin/python"
-    elif [ -f "apps/backend/.venv/Scripts/python.exe" ]; then
-      VENV_PYTHON="apps/backend/.venv/Scripts/python.exe"
-    fi
-
-    # -k "not windows_path": skip tests using fake Windows paths that break
-    # Path.resolve() on macOS/Linux. These are validated by CI on all platforms.
-    if [ -n "$VENV_PYTHON" ]; then
-      # Check if pytest is installed in venv
-      if $VENV_PYTHON -c "import pytest" 2>/dev/null; then
-        PYTHONPATH=apps/backend $VENV_PYTHON -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
+    IGNORE_TESTS="--ignore=../../tests/test_graphiti.py --ignore=../../tests/test_merge_file_tracker.py --ignore=../../tests/test_service_orchestrator.py --ignore=../../tests/test_worktree.py --ignore=../../tests/test_workspace.py"
+    if [ -d ".venv" ]; then
+      # Use venv if it exists
+      if [ -f ".venv/bin/pytest" ]; then
+        PYTHONPATH=. .venv/bin/pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
+      elif [ -f ".venv/Scripts/pytest.exe" ]; then
+        # Windows
+        PYTHONPATH=. .venv/Scripts/pytest.exe ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
      else
-        echo "Warning: pytest not installed in venv. Installing test dependencies..."
-        $VENV_PYTHON -m pip install -q -r tests/requirements-test.txt
-        PYTHONPATH=apps/backend $VENV_PYTHON -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
+        PYTHONPATH=. python -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
      fi
-    elif [ -d "apps/backend/.venv" ]; then
-      echo "Warning: venv exists but Python not found in it, using system Python"
-      PYTHONPATH=apps/backend python -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
-    elif [ "$IS_WORKTREE" = true ]; then
-      echo ""
-      echo "⚠️  WARNING: Python venv not available in this worktree."
-      echo "   Python tests will be skipped."
-      echo "   This is expected for auto-claude worktrees."
-      echo "   Full validation will occur when PR is created/merged."
-      echo ""
-      exit 77  # GNU convention for 'test skipped' (avoids pytest exit-code collision)
    else
-      echo "Warning: No .venv found in apps/backend, using system Python"
-      PYTHONPATH=apps/backend python -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
+      PYTHONPATH=. python -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
    fi
  )
-  PYTHON_EXIT=$?
-  if [ $PYTHON_EXIT -eq 77 ]; then
-    echo "Backend checks passed! (Python tests skipped — worktree)"
-  elif [ $PYTHON_EXIT -ne 0 ]; then
+  if [ $? -ne 0 ]; then
    echo "Python tests failed. Please fix failing tests before committing."
    exit 1
-  else
-    echo "Backend checks passed!"
  fi
+
+  echo "Backend checks passed!"
 fi

 # =============================================================================
@@ -239,86 +170,45 @@ fi
 # Check if there are staged files in apps/frontend
 if git diff --cached --name-only | grep -q "^apps/frontend/"; then
  echo "Frontend changes detected, running frontend checks..."
+  # Use subshell to isolate directory changes and prevent worktree corruption
+  (
+    cd apps/frontend

-  # Detect if we're in a worktree and check if dependencies are available
-  IS_WORKTREE=false
-  DEPS_AVAILABLE=true
-
-  if [ -f ".git" ]; then
-    # .git is a file (not directory) in worktrees
-    IS_WORKTREE=true
-    echo "Detected git worktree environment"
-  fi
-
-  # Check if node_modules has actual dependencies by looking for a known package
-  # @lydell/node-pty is required for terminal code and is a common source of TypeScript errors
-  # It may be in root node_modules (hoisted) or apps/frontend/node_modules
-  # Note: -d follows symlinks automatically, so this works for both real dirs and symlinks
-  # We check for the full package path (@lydell/node-pty) rather than just the namespace
-  # for precise detection - ensures the actual dependency is installed, not just any @lydell package
-  if [ ! -d "node_modules/@lydell/node-pty" ] && [ ! -d "apps/frontend/node_modules/@lydell/node-pty" ]; then
-    DEPS_AVAILABLE=false
-  fi
-
-  if [ "$DEPS_AVAILABLE" = false ]; then
-    if [ "$IS_WORKTREE" = true ]; then
-      # In worktree without dependencies - warn but allow commit
-      echo ""
-      echo "⚠️  WARNING: node_modules not available in this worktree."
-      echo "   TypeScript and lint checks will be skipped."
-      echo "   This is expected for auto-claude worktrees."
-      echo "   Full validation will occur when PR is created/merged."
-      echo ""
-    else
-      # Main repo without dependencies - this is an error
-      echo "Error: node_modules not found. Run 'npm install' first."
-      exit 1
-    fi
-  else
-    # Dependencies available - run full frontend checks
-    # Use subshell to isolate directory changes and prevent worktree corruption
-    (
-      cd apps/frontend
-
-      # Run lint-staged (handles staged .ts/.tsx files)
-      npm exec lint-staged
-      if [ $? -ne 0 ]; then
-        echo "lint-staged failed. Please fix linting errors before committing."
-        exit 1
-      fi
-
-      # Run TypeScript type check
-      echo "Running type check..."
-      npm run typecheck
-      if [ $? -ne 0 ]; then
-        echo "Type check failed. Please fix TypeScript errors before committing."
-        exit 1
-      fi
-
-      # Run linting
-      echo "Running lint..."
-      npm run lint
-      if [ $? -ne 0 ]; then
-        echo "Lint failed. Run 'npm run lint:fix' to auto-fix issues."
-        exit 1
-      fi
-
-      # Check for vulnerabilities (only critical severity)
-      # Note: Using critical level because electron-builder has a known high-severity
-      # tar vulnerability (CVE-2026-23745) that cannot be fixed until electron-builder
-      # releases an update with tar@7.x support. This is a build dependency, not runtime.
-      echo "Checking for vulnerabilities..."
-      npm audit --audit-level=critical
-      if [ $? -ne 0 ]; then
-        echo "Critical severity vulnerabilities found. Run 'npm audit fix' to resolve."
-        exit 1
-      fi
-    )
+    # Run lint-staged (handles staged .ts/.tsx files)
+    npm exec lint-staged
    if [ $? -ne 0 ]; then
+      echo "lint-staged failed. Please fix linting errors before committing."
      exit 1
    fi
-    echo "Frontend checks passed!"
+
+    # Run TypeScript type check
+    echo "Running type check..."
+    npm run typecheck
+    if [ $? -ne 0 ]; then
+      echo "Type check failed. Please fix TypeScript errors before committing."
+      exit 1
+    fi
+
+    # Run linting
+    echo "Running lint..."
+    npm run lint
+    if [ $? -ne 0 ]; then
+      echo "Lint failed. Run 'npm run lint:fix' to auto-fix issues."
+      exit 1
+    fi
+
+    # Check for vulnerabilities (only high severity)
+    echo "Checking for vulnerabilities..."
+    npm audit --audit-level=high
+    if [ $? -ne 0 ]; then
+      echo "High severity vulnerabilities found. Run 'npm audit fix' to resolve."
+      exit 1
+    fi
+  )
+  if [ $? -ne 0 ]; then
+    exit 1
  fi
+  echo "Frontend checks passed!"
 fi

 echo "All pre-commit checks passed!"
@@ -76,17 +76,6 @@ repos:
        files: ^package\.json$
        pass_filenames: false

-  # Python encoding check - prevent regression of UTF-8 encoding fixes (PR #782)
-  - repo: local
-    hooks:
-      - id: check-file-encoding
-        name: Check file encoding parameters
-        entry: python scripts/check_encoding.py
-        language: system
-        types: [python]
-        files: ^apps/backend/
-        description: Ensures all file operations specify encoding="utf-8"
-
  # Python linting (apps/backend/)
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.14.10
@@ -97,8 +86,9 @@ repos:
      - id: ruff-format
        files: ^apps/backend/

-  # Python tests (apps/backend/) - run full test suite from project root
+  # Python tests (apps/backend/) - skip slow/integration tests for pre-commit speed
  # Tests to skip: graphiti (external deps), merge_file_tracker/service_orchestrator/worktree/workspace (Windows path/git issues)
+  # NOTE: Skip this hook in worktrees (where .git is a file, not a directory)
  - repo: local
    hooks:
      - id: pytest
@@ -107,46 +97,53 @@ repos:
        args:
          - -c
          - |
-            # Run pytest directly from project root
-            if [ -f "apps/backend/.venv/bin/pytest" ]; then
-              PYTEST_CMD="apps/backend/.venv/bin/pytest"
-            elif [ -f "apps/backend/.venv/Scripts/pytest.exe" ]; then
-              PYTEST_CMD="apps/backend/.venv/Scripts/pytest.exe"
+            # Skip in worktrees - .git is a file pointing to main repo, not a directory
+            # This prevents path resolution issues with ../../tests/ in worktree context
+            if [ -f ".git" ]; then
+              echo "Skipping pytest in worktree (path resolution would fail)"
+              exit 0
+            fi
+            cd apps/backend
+            if [ -f ".venv/bin/pytest" ]; then
+              PYTEST_CMD=".venv/bin/pytest"
+            elif [ -f ".venv/Scripts/pytest.exe" ]; then
+              PYTEST_CMD=".venv/Scripts/pytest.exe"
            else
              PYTEST_CMD="python -m pytest"
            fi
-            $PYTEST_CMD tests/ \
+            PYTHONPATH=. $PYTEST_CMD \
+              ../../tests/ \
              -v \
              --tb=short \
              -x \
              -m "not slow and not integration" \
-              --ignore=tests/test_graphiti.py \
-              --ignore=tests/test_merge_file_tracker.py \
-              --ignore=tests/test_service_orchestrator.py \
-              --ignore=tests/test_worktree.py \
-              --ignore=tests/test_workspace.py
+              --ignore=../../tests/test_graphiti.py \
+              --ignore=../../tests/test_merge_file_tracker.py \
+              --ignore=../../tests/test_service_orchestrator.py \
+              --ignore=../../tests/test_worktree.py \
+              --ignore=../../tests/test_workspace.py
        language: system
        files: ^(apps/backend/.*\.py$|tests/.*\.py$)
        pass_filenames: false

-  # Frontend linting (apps/frontend/) - Biome is 15-25x faster than ESLint
+  # Frontend linting (apps/frontend/)
  # NOTE: These hooks check for worktree context to avoid npm/node_modules issues
  - repo: local
    hooks:
-      - id: biome
-        name: Biome (lint + format)
+      - id: eslint
+        name: ESLint
        entry: bash
        args:
          - -c
          - |
-            # Skip in worktrees if node_modules doesn't exist (Biome not installed)
+            # Skip in worktrees if node_modules doesn't exist (dependencies not installed)
            if [ -f ".git" ] && [ ! -d "apps/frontend/node_modules" ]; then
-              echo "Skipping Biome in worktree (node_modules not found)"
+              echo "Skipping ESLint in worktree (node_modules not found)"
              exit 0
            fi
-            cd apps/frontend && npx biome check --write --no-errors-on-unmatched .
+            cd apps/frontend && npm run lint
        language: system
-        files: ^apps/frontend/.*\.(ts|tsx|js|jsx|json)$
+        files: ^apps/frontend/.*\.(ts|tsx|js|jsx)$
        pass_filenames: false

      - id: typecheck
@@ -1,718 +1,3 @@
-## 2.7.6 - Stability & Feature Enhancements
-
-### ✨ New Features
-
- **Multi-profile account management** — Unified profile swapping with automatic token refresh and rate limit recovery for both OAuth and API-compatible providers
-
- **Enhanced terminal experience** — Customizable terminal fonts with OS-specific defaults, Claude Code CLI settings injection, and improved worktree integration
-
- **Advanced roadmap management** — Expand/collapse functionality for phase features and real-time sync with task lifecycle
-
- **Queue System v2** — Smart task prioritization with auto-promotion and intelligent rate limit recovery
-
- **GitHub integration enhancements** — AI-powered PR template generation, user-friendly API error handling, and improved review visibility
-
- **UI/UX improvements** — Spell check support for text inputs, collapsible sidebar toggle, task screenshot capture, expandable task descriptions, and bulk worktree operations
-
- **Evidence-based PR validation** — Advanced review system with trigger-driven exploration and enhanced recovery mechanisms
-
-### 🛠️ Improvements
-
- **Performance optimizations** — Async parallel worktree listing prevents UI freezes and improves responsiveness
-
- **Robustness enhancements** — Atomic file writes, better error detection in AI responses, and improved OOM/orphaned agent management for overnight builds
-
- **Terminal stability** — Fixed GPU context exhaustion from large pastes, SIGABRT crashes on macOS shutdown, and session restoration on app restart
-
- **Build & packaging** — XState bundling for packaged apps, aligned Linux package builds, and improved auto-updater for beta releases and DMG installations
-
- **Diagnostic improvements** — Sentry instrumentation for Python subprocesses and better error tracking across the system
-
-### 🐛 Bug Fixes
-
- **Terminal & PTY** — Fixed paste size limits, race conditions, rendering issues, text alignment, worktree crashes, and terminal content resizing on expansion
-
- **PR review system** — Resolved error visibility in bundled apps, improved structured output validation with three-tier recovery, preserved findings during crashes, and fixed UTC timestamp detection for comment tracking
-
- **Planning & task execution** — Fixed handling of empty/greenfield projects, atomic writes to prevent 0-byte file corruption, planning phase crashes, and implementation plan file watching
-
- **Authentication & profiles** — Resolved OAuth token revocation loops, API profile mode support without OAuth requirement, subscription type preservation during token refresh, and Linux credential file detection
-
- **Windows/cross-platform** — Complete System32 executable path fixes for where.exe and taskkill.exe, Windows credential normalization, and proper shell detection for Windows terminals
-
- **Agent management** — Fixed infinite retry loops for tool concurrency errors, auth error detection, and title generator production path resolution
-
- **UI/UX fixes** — Resolved Insights scroll-to-blank-space issues, infinite re-render loops in terminal font settings, kanban board scaling collisions, ideation stuck states, and panel constraint errors during terminal exit
-
- **Worktree & Git** — Improved branch pattern validation, removed auto-commit on deletion, support for detached HEAD state during PR creation, and better merge conflict resolution with progress tracking
-
- **Integrations** — Fixed Ollama infinite subprocess spawning, Graphiti import paths, OpenRouter API URL suffix, and GitLab authentication bugs
-
- **Settings & configuration** — Corrected .auto-claude path discovery timeout, z.AI China preset URL, log order sorting, and onboarding completion state persistence
-
-### 📚 Documentation
-
- Added Awesome Claude Code badge to README
-
- Added instructions for resetting PR review state in CLAUDE.md
-
---
-
-## What's Changed
-
- fix: handle unknown SDK message types (rate_limit_event) to prevent session crashes by @AndyMik90 in 4a75ea9f9
- fix: PR review error visibility and gh CLI resolution in bundled apps by @AndyMik90 in 732fc1cd3
- fix: handle empty/greenfield projects in spec creation (#1426) (#1841) by @Andy in 819f98d9f
- fix: clear terminalEventSeen on task restart to prevent stuck-after-planning (#1828) (#1840) by @Andy in 28a620079
- fix: watch worktree path for implementation_plan.json changes (#1805) (#1842) by @Andy in fb3a3fbda
- fix: resolve Claude CLI not found on Windows - PATH, prompt size, cwd (#1661) (#1843) by @Andy in 76d1d3b03
- fix: handle planning phase crash and resume recovery (#1562) (#1844) by @Andy in 3cb05781f
- fix: show dismissed PR review findings in UI instead of silently dropping them (#1852) by @Andy in d98ff7d19
- fix: preserve file/line info in PR review extraction recovery (#1857) by @Andy in 635b53eea
- docs: add Awesome Claude Code badge to README (#1838) by @Andy in 2e4b5ac65
- test: achieve 100% test coverage for backend CLI commands (#1772) by @StillKnotKnown in 385f04414
- fix: cap terminal paste size to 1MB to prevent GPU context exhaustion by @AndyMik90 in 7b0f3a2c0
- fix: prevent OOM, orphaned agents, and unbounded growth during overnight builds (#1813) by @Andy in 4091d1d4b
- docs: add instructions for resetting PR review state in CLAUDE.md by @AndyMik90 in ecb615802
- auto-claude: 217-investigate-symlink-issues-in-work-tree-creation-f (#1808) by @Andy in ae13ce14c
- auto-claude: 218-enable-claude-code-features-in-worktree-terminals (#1809) by @Andy in e3b219288
- auto-claude: 219-investigate-and-fix-authentication-subscription-sy (#1810) by @Andy in 6204d5fc2
- feat(roadmap): add expand/collapse functionality for phase features (#1796) by @Burak in f735f0b49
- auto-claude: 216-display-ongoing-pr-review-logs-in-progress (#1807) by @Andy in a4870fa0c
- fix(pr-review): reduce structured output failures and preserve findings in recovery (#1806) by @Andy in f1b8cd3a7
- fix(sentry): enable Sentry for Python subprocesses and add diagnostic instrumentation (#1804) by @Andy in 4d4234378
- fix(pr-review): add three-tier recovery for structured output validation failure (#1797) by @Andy in d1fbccde3
- test: improve backend agent test coverage to 94% (#1779) by @StillKnotKnown in ed93df698
- fix(github): use UTC timestamps for reviewed_at to fix comment detection (#1795) by @Andy in 8872d33e3
- feat: add user-friendly GitHub API error handling (#1790) by @StillKnotKnown in 8ece0009e
- fix(roadmap): sync roadmap features with task lifecycle (#1791) by @Andy in 115576e85
- fix(github): resolve PR review hanging in bundled app (#1793) by @Andy in 3791b37bb
- feat(profiles): implement unified profile swapping across OAuth and API accounts (#1794) by @StillKnotKnown in 282387356
- test: improve backend memory system test coverage to 100% (#1780) by @StillKnotKnown in 4f1b7b2a9
- fix(ideation): guard against non-string properties in IdeaCard badges by @AndyMik90 in 5e78d748e
- fix(updater): convert HTML release notes to markdown before rendering by @AndyMik90 in aa5fc7f95
- fix(pr-review): simplify structured output schema to reduce validation failures (#1787) by @Andy in cd8914700
- fix(qa): enforce visual verification for UI changes and inject startup commands (#1784) by @Andy in f149a7fbd
- fix(plan-files): use atomic writes to prevent 0-byte corruption (#1785) by @Andy in c2245b812
- fix(terminal): make worktree dropdown scrollable and show all items by @AndyMik90 in 950da45e4
- auto-claude: subtask-1-1 - Add adaptive thinking badge to thinking level label (#1782) by @Andy in 25acf2826
- auto-claude: subtask-1-1 - Add overflow-hidden and break-words to subtask cards by @AndyMik90 in 39aa08872
- refactor(app-updater): disable automatic downloads and allow intentional downgrades by @AndyMik90 in 8de8039db
- fix(auth): detect auth errors in AI response text and prevent retry loops (#1776) by @Andy in f4788e4af
- test: achieve 100% coverage for backend core workspace module (#1774) by @StillKnotKnown in 3f95765cf
- fix(title-generator): add production path resolution for backend source (#1778) by @Andy in 923880f5b
- fix(fast-mode): use setting_sources instead of env var for CLI fast mode (#1771) by @Andy in 390ba6a58
- fix(windows): complete System32 executable path fixes for where.exe and taskkill.exe (#1715) by @VDT-91 in aa7f56e5d
- fix(worktree): remove auto-commit on deletion and add uncommitted changes warning by @AndyMik90 in cec8e65ee
- Smart PR Status Polling System (#1766) by @Andy in 48d5f7a32
- feat: simplify thinking system and remove opus-1m model variant (#1760) by @Andy in bb7e18937
- auto-claude: 203-fix-pr-review-ui-update-issue (#1732) by @Andy in 7589f8e4f
- auto-claude: subtask-2-1 - Create isAPIProfileAuthenticated() function to val (#1745) by @Andy in 57e38a692
- auto-claude: 202-fix-kanban-board-scaling-collisions (#1731) by @Andy in d09ebb850
- auto-claude: 204-fix-pr-review-ui-not-updating-without-manual-navig (#1734) by @Andy in 087091cef
- auto-claude: 203-fix-ui-not-updating-during-pr-review-operations (#1733) by @Andy in f085c08bd
- auto-claude: 205-fix-insights-chat-only-shows-last-task-suggestion- (#1735) by @Andy in f121f9cdd
- auto-claude: 197-roadmap-generation-stuck-at-50-file-locking-race-c (#1746) by @Andy in f41f15e59
- auto-claude: 193-fix-update-context7-mcp-tool-name-from-get-library (#1744) by @Andy in bdff9141a
- auto-claude: 192-changelog-generation-multiple-critical-bugs-tasks- (#1725) by @Andy in 8c9a504df
- auto-claude: 194-bug-rate-limit-during-task-execution-causes-subtas (#1726) by @Andy in 8a7443d24
- auto-claude: 201-bug-pr-review-logs-and-analysis (#1730) by @Andy in e0d53adb4
- auto-claude: 196-fix-worktrees-dialog-auto-close-race-condition-and (#1727) by @Andy in 323b0d3be
- auto-claude: 199-bug-logs-disappear-after-restart (#1728) by @Andy in d639f6ef8
- auto-claude: 198-critical-oauth-token-revocation-causes-infinite-40 (#1747) by @Andy in 4438c0b10
- Fix Panel Constraints Error During Terminal Exit (#1757) by @Andy in 32bf353da
- auto-claude: 190-bug-context-page-crash-multiple-root-causes-when-v (#1724) by @Andy in 2db36982f
- feat: add search/filter to WorktreeSelector dropdown (#1754) by @Andy in 09f059ca3
- fix(terminal): push worktree branch to remote with tracking on creation (#1753) by @Andy in b5de0d9ff
- auto-claude: 189-subtask-execution-stuck-in-infinite-retry-loop-whe (#1723) by @Andy in 445da186c
- auto-claude: 188-terminal-claude-sessions-require-manual-click-to-r (#1743) by @Andy in f8499e965
- auto-claude: 200-bug-changelog-and-release-generation (#1729) by @Andy in 826583b82
- fix(terminal): use each terminal's cwd for invoke Claude all button (#1756) by @Andy in ac4fe4f42
- feat(terminal): read Claude Code CLI settings and inject env vars into PTY sessions (#1750) by @Andy in 152e54093
- fix: correct .auto-claude path mismatch causing discovery phase timeout (#1748) by @VDT-91 in 2c2a8a754
- fix: remove incorrect /v1 suffix from OpenRouter API URL (#1749) by @StillKnotKnown in 7e799ee57
- fix: prevent terminal worktree crash with race condition fixes (#1586) (#1658) by @VDT-91 in 216b58bcf
- fix: correct log order sorting and add configurable log order setting (#1720) by @Burak in 2e2b82365
- fix(ollama): stop infinite subprocess spawning from useEffect re-render loop (#1716) by @Quentin Veys in acb131b72
- fix(graphiti): migrate graphiti_memory imports to canonical paths (#1714) by @Quentin Veys in df528f065
- fix: improve auto-updater for beta releases and DMG installs (#1681) by @Andy in ff91a1af0
- feat: unified operation registry for intelligent auth/rate limit recovery (#1698) by @Andy in 6d0222fa9
- fix: Prevent stale worktree data from overriding correct task status (#1710) by @Burak in fe08c644c
- feat: add subscriptionType and rateLimitTier to ClaudeProfile (#1688) by @Andy in a5e3cc9a2
- auto-claude: subtask-1-1 - Add useTaskStore import and update task state after successful PR creation (#1683) by @Andy in 4587162e4
- auto-claude: 182-implement-pagination-and-filtering-for-github-pr-l (#1654) by @Andy in b4e6b2fe4
- auto-claude: 181-add-expand-button-for-long-task-descriptions (#1653) by @Andy in d9cd300fe
- fix(terminal): resolve text alignment issues on expand/minimize (#1650) by @VDT-91 in f5a7e26d9
- fix(windows): use full path to where.exe for reliable executable lookup (#1659) by @VDT-91 in 5f63daa3c
- fix: resolve ideation stuck at 3/6 types bug (#1660) by @VDT-91 in e6e8da17c
- Clarify Local and Origin Branch Distinction (#1652) by @Andy in 9317148b6
- auto-claude: 186-set-default-dark-mode-on-startup (#1656) by @Andy in 473020621
- auto-claude: subtask-1-1 - Add min-h-0 to enable scrolling in Roadmap tabs (#1655) by @Andy in ae703be9f
- fix: XState status lifecycle & cross-project contamination fixes (#1647) by @kaigler in 5293fb399
- refactor(frontend): complete XState task state machine migration (#1338) (#1575) by @kaigler in e2f9abadb
- Merge conflict resolution progress bar and log viewer (#1620) by @Andy in d16be3077
- fix: align Linux package builds (AppImage/deb/Flatpak) with target-specific extraResources (#1623) by @StillKnotKnown in bad1a9b2c
- Fix/gitlab bugs (#1519 and #1521) (#1544) by @bu5hm4nn in cd423c65c
- feat(kanban): add bulk task delete and worktree cleanup improvements (#1588) by @kaigler in 02ed91c91
- fix: add worktree isolation warning to prevent agent escape (#1528) by @kaigler in fe5cc582b
- feat(ui): add spell check support for text inputs (#1304) by @kaigler in 8f02a5129
- fix(windows): complete Windows credential fixes with path normalization (#1585) by @kaigler in 1e1997167
- AI-Powered GitHub PR Template Generation (#1618) by @Andy in 900dd4360
- Fix pty.node SIGABRT crash on macOS shutdown (#1619) by @Andy in f355e09d7
- fix(merge): use git merge for diverged branches with progress tracking (#1605) by @Andy in bde2ca4b2
- Surface Billing/Credit Exhaustion Errors to UI (Issue #1580) (#1617) by @Andy in 7bf12e856
- auto-claude: subtask-1-1 - Change $teamId type from ID! to String! in the team query (#1627) by @Andy in 54d0cd2f4
- fix(auth): support API profile mode without OAuth requirement (#1616) by @StillKnotKnown in f8cc63af4
- fix: agent retry loop for tool concurrency errors (#1546) [v3] (#1606) by @Michael Ludlow in 0aea4fb5e
- fix(queue): enforce max parallel tasks and auto-refresh UI (#1594) by @Andy in 4070a4c29
- Persist Kanban column collapse state per project via main process (#1579) by @Andy in a1114664e
- feat(pr-review): evidence-based validation and trigger-driven exploration (#1593) by @Andy in bfc232825
- fix(ui): smart auto-scroll for Insights streaming responses (#1591) by @kaigler in eee97e7ea
- fix(changelog): validate Claude CLI exists before generation (#1305) by @kaigler in c1f24c07f
- auto-claude: subtask-1-1 - Add min-w-0 class to subtask title row flex container (#1578) by @Andy in 286591c02
- auto-claude: subtask-1-1 - Remove Popover wrapper and related functionality from ClaudeCodeStatusBadge (#1566) by @Andy in 8d18cc81a
- fix(claude-profile): preserve subscriptionType and rateLimitTier during token refresh (#1556) by @Andy in 52e426a48
- auto-claude: subtask-1-1 - Update cancelReview callback to handle both success and failure cases (#1551) by @Andy in d8f00fe5a
- fix(backend): prioritize git remote detection over env var for repo (#1555) by @Andy in 9b07ed464
- fix(backend): handle detached HEAD state when pushing branch for PR creation (#1560) by @Andy in 2b72694d0
- fix: add explicit UTF-8 encoding across all Electron main process I/O (#1554) by @Andy in 4243530e9
- fix(backend): pass OAuth token to Python subprocess for authentication by @AndyMik90 in 6f1002dd7
- perf(frontend): async parallel worktree listing to prevent UI freezes (#1553) by @Andy in 399a7e736
- auto-claude: subtask-1-1 - Remove amber lock indicator line from kanban resize handle (#1557) by @Andy in 83a64b88e
- fix(frontend): resolve TerminalFontSettings infinite re-render loop (#1536) by @StillKnotKnown in 1c6266025
- fix(frontend): respect hasCompletedOnboarding from ~/.claude.json (#1537) by @StillKnotKnown in 1860c2c43
- fix: prevent planner from generating invalid verification types (#1388) (#1529) by @kaigler in 94d941333
- fix(frontend): resolve Insights scroll-to-blank-space issue on macOS (ACS-382) (#1535) by @StillKnotKnown in 496b2b96a
- feat: add customizable terminal fonts with OS-specific defaults (#1412) by @StillKnotKnown in f289107b8
- Add dev mode screenshot capture warning (#1516) by @Andy in 16eeb301a
- fix: add worktree isolation warnings to prevent agent escape (ACS-394) (#1495) by @StillKnotKnown in 1e453653b
- fix: resolve flaky subprocess-spawn test on Windows CI (ACS-392) (#1494) by @StillKnotKnown in f6b264d56
- feat(task-logger): strip ANSI escape codes from logs and extend coverage (#1411) by @StillKnotKnown in 988ec0c25
- fix(frontend): use spawn() instead of exec() for Windows terminal launching (#1498) by @StillKnotKnown in 26c9083d3
- fix(api-profiles): correct z.AI China preset URL and rename provider presets (#1500) by @StillKnotKnown in 05cf0a516
- fix: validate branch pattern before worktree cleanup to prevent deleting wrong branch (#1493) by @StillKnotKnown in 8576754a1
- Real-Time Updates for Insights Chat (#1511) by @Andy in d940b6ade
- Fix Terminal UI Rendering Issues (#1514) by @Andy in 8d8306b8e
- Fix terminal content resizing on expansion (#1512) by @Andy in 9f6c0026b
- Restore Terminal Session History on App Restart (#1515) by @Andy in 63e2847fc
- Move Reference Images Above Task Title & Fix Image Display Issues (#1513) by @Andy in b269ac305
- auto-claude: 143-fix-github-integration-ui-refresh-issues (#1467) by @Andy in aa2cb4fa6
- feat: Multi-profile account swapping with token refresh and queue routing (#1496) by @Andy in 1e72c8d77
- Simplified Testing Strategy for Regression Prevention (#1379) by @Andy in ae4e48e8b
- auto-claude: 152-persist-tasks-during-roadmap-regeneration (#1463) by @Andy in 9bd3d7e3b
- Debug Kanban Memory & Add Sentry Monitoring (#1380) by @Andy in bc5f550ee
- auto-claude: 147-remove-outdated-compatibility-shims (#1465) by @Andy in 53111dbb9
- auto-claude: 162-fix-worktree-error-on-repeated-task-starts (#1453) by @Andy in b955badf7
- auto-claude: 155-fix-pr-list-diff-display-metrics (#1458) by @Andy in 31f116db5
- auto-claude: 151-fix-pr-review-agent-token-refresh-on-account-swap (#1456) by @Andy in d081af042
- auto-claude: 148-add-progress-persistence-and-status-indicators (#1464) by @Andy in 4937d5745
- auto-claude: 154-fix-task-modal-conflict-check-status-refresh (#1462) by @Andy in 0299009df
- auto-claude: 153-widen-kanban-columns-and-add-collapse-feature (#1457) by @Andy in d65973075
- auto-claude: subtask-1-1 - Add filter after map operation to remove empty str (#1466) by @Andy in 783f0fe0e
- fix: add formatReleaseNotes helper for markdown changelog rendering (#1468) by @Andy in 43a97e1b3
- feat(sidebar): add collapsible sidebar toggle (#1501) by @Michael Ludlow in d17c17887
- fix(auth): check .credentials.json for Linux profile authentication (#1492) by @StillKnotKnown in 8d2f66291
- auto-claude: subtask-1-1 - Replace ReleaseNotesRenderer with ReactMarkdown (#1454) by @Andy in 1185a558c
- auto-claude: 156-fix-electron-app-version-detection-bug (#1459) by @Andy in 9a3b48c25
- auto-claude: subtask-1-1 - Add --no-track flag to git worktree add command (#1455) by @Andy in 0c2990815
- auto-claude: subtask-1-1 - Change task.specId to taskId in 3 startSpecCreation calls (#1461) by @Andy in 91edc0e14
- fix(onboarding): align MemoryStep layout with Settings MemoryBackendSection (#1445) by @Michael Ludlow in e9de26d59
- auto-claude: subtask-1-1 - Add metadata?.requireReviewBeforeCoding check (#1460) by @Andy in 426d56571
- fix: use API profile environment variables for task title generation (#1471) by @JoshuaRileyDev in c5a0f042d
- fix(auth): Long-lived OAuth authentication with multi-profile usage display (#1443) by @Andy in 12e788417
- feat: Add screenshot capture to task creation modal (#1429) by @JoshuaRileyDev in 1a2a1b1fc
- fix: prevent queue settings modal from disappearing when tasks change (#1430) by @JoshuaRileyDev in 33acc1430
- feat: Queue System v2 with Auto-Promotion and Smart Task Management (#1203) by @JoshuaRileyDev in 3b87e24d7
- feat: Add API profile providers usage endpoints support (#1279) by @StillKnotKnown in cfe7dedd0
-
-## Thanks to all contributors
-
-@AndyMik90, @Andy, @Burak, @StillKnotKnown, @VDT-91, @kaigler, @Michael Ludlow, @JoshuaRileyDev, @Quentin Veys, @bu5hm4nn
-
-## 2.7.5 - Security & Platform Improvements
-
-### ✨ New Features
-
- One-time version 2.7.5 reauthentication warning modal for improved security awareness
-
- Enhanced authentication failure detection and handling with improved error recovery
-
- PR review validation pipeline with context enrichment and cross-validation support
-
- Terminal "Others" section in worktree dropdown for better organization
-
- Keyboard shortcut to toggle terminal expand/collapse for improved usability
-
- Searchable branch combobox in worktree creation dialog for easier branch selection
-
- Update Branch button in PR detail view for streamlined workflow
-
- Bulk select and create PR functionality for human review column
-
- Draggable Kanban task reordering for flexible task management
-
- YOLO mode to invoke Claude with --dangerously-skip-permissions for advanced users
-
- File and screenshot upload to QA feedback interface for better feedback submission
-
- Task worktrees section with terminal limit removal for expanded parallel work
-
- Claude Code version rollback feature for version management
-
- Linux secret-service support for OAuth token storage (ACS-293)
-
-### 🛠️ Improvements
-
- Replace setup-token with embedded /login terminal flow for streamlined authentication
-
- Refactored authentication using platform abstraction for cross-platform reliability
-
- Removed redundant backend CLI detection (~230 lines) for cleaner codebase
-
- Replaced Select with Combobox for branch selection UI improvements
-
- Replace dangerouslySetInnerHTML with Trans component for better security practice
-
- Wait for CI checks before starting AI PR review for more accurate results
-
- Improved Claude CLI detection with installation selector
-
- Terminal rendering, persistence, and link handling improvements
-
- Enhanced terminal recreation logic with retry mechanism for reliability
-
- Improved worktree name input UX with better validation
-
- Made worktree isolation prominent in UI for user awareness
-
- Reduce ultrathink value from 65536 to 60000 for Opus 4.5 compatibility
-
- Standardized workflow naming and consolidated linting workflow
-
- Added gate jobs to CI/CD pipeline for better quality control
-
- Fast-path detection for merge commits without finding overlap in PR review
-
- Show progress percentage during planning phase on task cards
-
- PTY write improvements using PtyManager.writeToPty for safer terminal operations
-
- Consolidated package-lock.json to root level for simpler dependency management
-
- Graphiti memory feature fixes on macOS
-
- Model versions updated to Claude 4.5 with connected insights to frontend settings
-
-### 🐛 Bug Fixes
-
- Fixed task logs disappearing after app restart in development mode (issue #1657)
-
- Fixed Kanban board status flip-flopping and multi-location task deletion
-
- Fixed Windows CLI detection and version selection UX issues
-
- Fixed Windows coding phase not starting after spec/planning
-
- Fixed Windows UTF-8 encoding errors across entire backend (251 instances)
-
- Fixed 401 authentication errors by reading tokens from profile configDir
-
- Fixed Windows packaging by using SDK bundled Claude CLI
-
- Fixed false stuck detection during planning phase
-
- Fixed PR list update on post status click
-
- Fixed screenshot state persistence bug in task modals
-
- Fixed non-functional '+ Add' button for multiple Claude accounts
-
- Fixed GitHub Issues/PRs infinite scroll auto-fetch behavior
-
- Fixed GitHub PR state management and follow-up review trigger bug
-
- Fixed terminal output freezing on project switch
-
- Fixed terminal rendering on app close to prevent zombie processes
-
- Fixed stale terminal metadata filtering with auto-cleanup
-
- Fixed worktree configuration sync after PTY creation
-
- Fixed cross-worktree file leakage via environment variables
-
- Fixed .gitignore auto-commit during project initialization
-
- Fixed PR review verdict message contradiction and blocked status limbo
-
- Fixed re-review functionality when previous review failed
-
- Fixed agent profile resolution before falling back to defaults
-
- Fixed Windows shell command support in Claude CLI invocation
-
- Fixed model resolution using resolve_model_id() instead of hardcoded fallbacks
-
- Fixed ultrathink token budget correction from 64000 to 63999
-
- Fixed Windows pywin32 DLL loading failure on Python 3.8+
-
- Fixed circular import between spec.pipeline and core.client
-
- Fixed pywin32 bundling in Windows binary
-
- Fixed secretstorage bundling in Linux binary
-
- Fixed gh CLI detection for PR creation
-
- Fixed PYTHONPATH isolation to prevent pollution of external projects
-
- Fixed structured output capture from SDK ResultMessage in PR review
-
- Fixed CI status refresh before returning cached verdict
-
- Fixed Python environment readiness before spawning tasks
-
- Fixed pywintypes import errors during dependency validation
-
- Fixed Node.js and npm path detection on Windows packaged apps
-
- Fixed Windows PowerShell command separator usage
-
- Fixed require is not defined error in terminal handler
-
- Fixed Sentry DSN initialization error handling
-
- Fixed requestAnimationFrame fallback for flaky Ubuntu CI tests
-
- Fixed file drag-and-drop to terminals and task modals with branch status refresh
-
- Fixed GitHub issues pagination and infinite scroll
-
- Fixed delete worktree status regression
-
- Fixed Mac crash on Invoke Claude button
-
- Fixed worktree symlink for node_modules to enable TypeScript support
-
- Fixed PTY wait on Windows before recreating terminal
-
- Fixed terminal aggressive renaming on Claude invocation
-
- Fixed worktree dropdown scroll area to prevent overflow
-
- Fixed GitHub PR preloading currently under review
-
- Fixed actual base branch name display instead of hardcoded main
-
- Fixed Claude CLI detection with improved installation selector
-
- Fixed broken pipe errors with Sentry integration
-
- Fixed app update persistence for Install button visibility
-
- Fixed Claude exit detection and label reset
-
- Fixed file merging to include files with content changes
-
- Fixed worktree config sync on terminal restoration
-
- Fixed security profile inheritance in worktrees and shell -c validation
-
- Fixed terminal drag and drop reordering collision detection
-
- Fixed "already up to date" case handling in worktree operations
-
- Fixed Windows UTF-8 encoding and path handling issues
-
- Fixed Terminal label persistence after app restart
-
- Fixed worktree dropdown enhancement with scrolling support
-
- Fixed enforcement of 12 terminal limit per project
-
- Fixed macOS UTF-8 encoding errors (251 instances)
-
-### 📚 Documentation
-
- Added fork configuration guidance to CONTRIBUTING.md
-
- Updated README download links to v2.7.4
-
-### 🔧 Other Changes
-
- Removed node_modules symlink and cleaned up package-lock.json
-
- Added .planning/ to gitignore
-
- Migrated ESLint to Biome with optimized workflows
-
- Fixed tar vulnerability in dependencies
-
- Added minimatch to externalized dependencies
-
- Added exception handling for malformed DSN during Sentry initialization
-
- Corrected roadmap import path in roadmap_runner.py
-
- Added require polyfill for ESM/Sentry compatibility
-
- Addressed CodeQL security alerts and code quality issues
-
- Added shell: true and argument sanitization for Windows packaging
-
- Packaged runtime dependencies with pydantic_core validation
-
---
-
-## What's Changed
-
- test(subprocess): add comprehensive auth failure detection tests by @AndyMik90 in ccaf82db
- fix(security): replace dangerouslySetInnerHTML with Trans component and persist version warning by @AndyMik90 in 7aec35c3
- chore: remove node_modules symlink and clean up package-lock.json by @AndyMik90 in 9768af8e
- fix: address PR review issues and improve code quality by @AndyMik90 in 23a7e5a2
- fix(auth): read tokens from profile configDir to fix 401 errors (#1385) by @Andy in 55857d6d
- fix: Kanban board status flip-flopping and multi-location task deletion (#1387) by @Adam Slaker in 7dcb7bbe
- fix(windows): use SDK bundled Claude CLI for Windows packaged apps (#1382) by @Andy in cd4e2d38
- feat(auth): enhance authentication failure detection and handling by @AndyMik90 in 7ab10cd5
- refactor(subprocess): use platform abstraction for auth failure process killing by @AndyMik90 in 17cffecc
- feat(ui): add one-time version 2.7.5 reauthentication warning modal by @AndyMik90 in f49ef92a
- refactor: remove redundant backend CLI detection (~230 lines) (#1367) by @Andy in c7bc01d5
- feat(pr-review): add validation pipeline, context enrichment, and cross-validation (#1354) by @Andy in d8f4de9a
- fix(terminal): rename Claude terminals only once on initial message (#1366) by @Andy in b2d2d7e9
- feat(auth): add auth failure detection modal for Claude CLI 401 errors (#1361) by @Andy in 317d5e94
- docs: add fork configuration guidance to CONTRIBUTING.md (#1364) by @Andy in c57534c3
- Fix #609: Windows coding phase not starting after spec/planning (#1347) by @TamerineSky in 6da1b170
- Fix Windows UTF-8 encoding errors across entire backend (251 instances) (#782) by @TamerineSky in 6a6247bb
- chore: add .planning/ to gitignore by @AndyMik90 in 8df66245
- feat(auth): replace setup-token with embedded /login terminal flow (#1321) by @Andy in 11f8d572
- fix: Windows CLI detection and version selection UX improvements (#1341) by @StillKnotKnown in 8a2f3acd
- fix: add shell: true and argument sanitization for Windows packaging (#1340) by @StillKnotKnown in e482fdf1
- fix: package runtime deps and validate pydantic_core (#1336) by @StillKnotKnown in 141f44f6
- fix(test): update mock profile manager and relax audit level by @Test User in 86ba0246
- 2.7.4 release stable by @Test User in 3e2d6ef4
- fix(tests): update claude-integration-handler tests for PtyManager.writeToPty by @Test User in 56743ff7
- chore: consolidate package-lock.json to root level by @Test User in d4044d26
- build: add minimatch to externalized dependencies by @Test User in 95f7f222
- refactor(terminal): use PtyManager.writeToPty for safer PTY writes by @Test User in 4637a1a9
- fix: correct ultrathink token budget from 64000 to 63999 by @Test User in efdb8c71
- ci: migrate ESLint to Biome, optimize workflows, fix tar vulnerability (#1289) by @Andy in 0b2cf9b0
- Fix API 401 - Token Decryption Before SDK Initialization (#1283) by @Andy in 4b740928
- Fix Ultrathink Token Limit Bug (#1284) by @Andy in e989300b
- fix(security): address CodeQL security alerts and code quality issues (#1286) by @Andy in f700b18d
- fix(ui): make prose-invert conditional on dark mode for light theme support (#1160) by @youngmrz in 439ed86a
- fix(terminal): add require polyfill for ESM/Sentry compatibility (#1275) by @VDT-91 in eb739afe
- fix: add retry logic for planning-to-coding transition (#1276) by @kaigler in b8655904
- fix(worktree): prevent cross-worktree file leakage via environment variables (#1267) by @Andy in 7cb9e0a3
- Fix/cleanup 2.7.5 (#1271) by @Andy in f0c3e508
- Fix False Stuck Detection During Planning Phase (#1236) by @Andy in 44304a61
- fix(pr-review): allow re-review when previous review failed (#1268) by @Andy in 4cc8f4db
- fix: enforce 12 terminal limit per project (#1264) by @Andy in d7ed770e
- Draggable Kanban Task Reordering (#1217) by @Andy in 3606a632
- fix(terminal): sync worktree config after PTY creation to fix first-attempt failure (#1213) by @Andy in 39236f18
- fix: auto-commit .gitignore changes during project initialization (#1087) (#1124) by @youngmrz in ba089c5b
- Fix terminal rendering, persistence, and link handling (#1215) by @Andy in 75a3684c
- fix(windows): prevent zombie process accumulation on app close (#1259) by @VDT-91 in 90204469
- update gitignore by @AndyMik90 in c13d9a40
- Fix PR List Update on Post Status Click (#1207) by @Andy in 3085e392
- Fix screenshot state persistence bug in task modals (#1235) by @Andy in 3024d547
- Fix non-functional '+ Add' button for multiple Claude accounts (#1216) by @Andy in e27ff344
- Fix GitHub Issues/PRs Infinite Scroll Auto-Fetch (#1239) by @Andy in b74b628b
- Add bulk delete functionality to worktree overview (#1208) by @Andy in 8833feb2
- Fix GitHub PR State Management - Follow-up Review Trigger Bug (#1238) by @Andy in 76f07720
- auto-claude: subtask-1-1 - Add useEffect hook to reset expandedTerminalId when projectPath changes (#1240) by @Andy in d1131080
- Fix Terminal Output Freezing on Project Switch (#1241) by @Andy in 193d2ed9
- Add Update Branch Button to PR Detail View (#1242) by @Andy in 87c84073
- Bulk Select All & Create PR for Human Review Column (#1248) by @Andy in 715202b8
- fix(windows): resolve pywin32 DLL loading failure on Python 3.8+ (#1244) by @VDT-91 in cb786cac
- fix(gh-cli): use get_gh_executable() and pass GITHUB_CLI_PATH from GUI (ACS-321) (#1232) by @StillKnotKnown in 14fbc2eb
- auto-claude: subtask-1-1 - Replace Select with Combobox for branch selection (#1250) by @Andy in ed45ece5
- fix(sentry): add exception handling for malformed DSN during Sentry initialization by @AndyMik90 in 4f86742b
- dev dependecnies using npm install all by @AndyMik90 in e52a1ba4
- hotfix/dev-dependency-missing by @AndyMik90 in a0033b1e
- fix(frontend): resolve require is not defined error in terminal handler (#1243) by @Antti in 9117b59e
- hotfix/node by @AndyMik90 in bb620044
- fix(windows): add Node.js and npm paths to COMMON_BIN_PATHS for packaged apps (#1158) by @youngmrz in f0319bc8
- fix/stale-task-creation by @AndyMik90 in 9612cf8d
- fix/sentry-local-build by @AndyMik90 in b822797f
- hotfix/tar-vurnability by @AndyMik90 in 2096b0e2
- fix(tests): add requestAnimationFrame fallback for flaky Ubuntu CI tests by @AndyMik90 in 9739b338
- fix(windows): use correct command separator for PowerShell terminals (#1159) by @youngmrz in cb8e46ca
- fix(ui): show progress percentage during planning phase on task cards (#1162) by @youngmrz in 515aada1
- fix(tests): isolate git operations in test fixtures from parent repository (#1205) by @Andy in 596b1e0c
- feat(terminal): add "Others" section to worktree dropdown (#1209) by @Andy in 219cc068
- fix(linux): ensure secretstorage is bundled in Linux binary (ACS-310) (#1211) by @StillKnotKnown in 48bd4a9c
- fix(terminal): persist worktree label after app restart (#1210) by @Andy in ba7358af
- fix: Graphiti memory feature on macOS (#1174) by @Alexander Penzin in c2e53d58
- fix(windows): ensure pywin32 is bundled in Windows binary (ACS-306) (#1197) by @StillKnotKnown in 76af0aaa
- fix(spec): resolve circular import between spec.pipeline and core.client (ACS-302) (#1192) by @StillKnotKnown in 648cf3fc
- Fix Mac Crash on Invoke Claude Button (#1185) by @Andy in ae40f819
- fix(worktree): symlink node_modules to worktrees for TypeScript support (#1148) by @Andy in d7c7ce8e
- fix(terminal): wait for PTY exit on Windows before recreating terminal (#1184) by @Andy in d5d56975
- fix(runners): use resolve_model_id() for model resolution instead of hardcoded fallbacks (ACS-294) (#1170) by @StillKnotKnown in 5199fdbf
- fix(frontend): support Windows shell commands in Claude CLI invocation (ACS-261) (#1152) by @StillKnotKnown in 3a1966bd
- feat(terminal): add keyboard shortcut to toggle expand/collapse (#1180) by @Andy in 1edfe333
- fix(kanban): remove error column and add backend JSON repair (#1143) by @Andy in 51f67c5d
- fix(ci): add gate jobs and consolidate linting workflow (#1182) by @Andy in 4b43f074
- fix(ci): standardize workflow naming and remove redundant workflows (#1178) by @Andy in 4a3391b2
- fix(terminal): enable scrolling in worktree dropdown when many items exist (#1175) by @Andy in 5525f36d
- fix: windows (#1056) by @Alex in d6234f52
- fix(backend): reduce ultrathink value from 65536 to 60000 for Opus 4.5 compatibility (#1173) by @StillKnotKnown in 30638c2f
- feat(backend): add Linux secret-service support for OAuth token storage (ACS-293) (#1168) by @StillKnotKnown in a6934a8e
- fix(terminal): prevent aggressive renaming on Claude invocation (#1147) by @Andy in 10bceac9
- fix(pr-review): resolve verdict message contradiction and blocked status limbo (#1151) by @Andy in 8b269fea
- feat(pr-review): add fast-path detection for merge commits without finding overlap (#1145) by @Andy in 32811142
- fix(frontend): resolve agent profile before falling back to defaults (ACS-255) (#1068) by @StillKnotKnown in 33014682
- fix(terminal): add scroll area to worktree dropdown to prevent overflow (#1146) by @Andy in 200bb3bc
- fix(frontend): add windowsVerbatimArguments for Windows .cmd validation (ACS-252) (#1075) by @StillKnotKnown in 658f26cb
- fix(backend): improve gh CLI detection for PR creation (ACS-247) (#1071) by @StillKnotKnown in 2eef82bf
- fix(terminal): filter stale worktree metadata and auto-cleanup (#1038) by @Andy in 16bc37ce
- Fix Delete Worktree Status Regression (#1076) by @Andy in 97f98ed7
- 117-sidebar-update-banner (#1078) by @Andy in 4fd25b01
- fix(ci): add beta manifest renaming and validation (#1002) (#1080) by @Andy in c6c6525b
- fix: update all model versions to Claude 4.5 and connect insights to frontend settings (#1082) by @Andy in 58f4f30b
- fix: file drag-and-drop to terminals and task modals + branch status refresh (#1092) by @Andy in b5c0e631
- fix(github-issues): add pagination and infinite scroll for issues tab (#1042) by @Andy in f1674923
- fix(ci): enable automatic release workflow triggering (#1043) by @Andy in 2ff9ccab
- fix(backend): isolate PYTHONPATH to prevent pollution of external projects (ACS-251) (#1065) by @StillKnotKnown in 18d9b6cf
- add time sensitive AI review logic (#1137) by @Andy in 5fb7574b
- fix(pr-review): use list instead of tuple for line_range to fix SDK structured output (#1140) by @Andy in 45060ca3
- feat(github-review): wait for CI checks before starting AI PR review (#1131) by @Andy in a55e4f68
- fix(frontend): pass CLAUDE_CLI_PATH to Python backend subprocess (ACS-230) (#1081) by @StillKnotKnown in 5e91c3a7
- fix(runners): correct roadmap import path in roadmap_runner.py (ACS-264) (#1091) by @StillKnotKnown in 767dd5c3
- fix(pr-review): properly capture structured output from SDK ResultMessage (#1133) by @Andy in f28d2298
- fix(github-review): refresh CI status before returning cached verdict (#1083) by @Andy in c3bdd4f8
- fix(agent): ensure Python env is ready before spawning tasks (ACS-254) (#1061) by @StillKnotKnown in 7dc54f23
- fix(windows): prevent pywintypes import errors before dependency validation (ACS-253) (#1057) by @StillKnotKnown in 71a9fc84
- fix(docs): update README download links to v2.7.4 by @Test User in 67b39e52
- fix readme for 2.7.4 by @Test User in a0800646
- changelog 2.7.4 by @AndyMik90 in 1b5aecdd
- 2.7.4 release by @AndyMik90 in 72797ac0
- fix(frontend): validate Windows claude.cmd reliably in GUI (#1023) by @Umaru in 1ae3359b
- fix(auth): await profile manager initialization before auth check (#1010) by @StillKnotKnown in c8374bc1
- Add file/screenshot upload to QA feedback interface (#1018) by @Andy in 88277f84
- feat(terminal): add task worktrees section and remove terminal limit (#1033) by @Andy in 17118b07
- fix(terminal): enhance terminal recreation logic with retry mechanism (#1013) by @Andy in df1b8a3f
- fix(terminal): improve worktree name input UX (#1012) by @Andy in 54e9f228
- Make worktree isolation prominent in UI (#1020) by @Andy in 4dbb7ee4
- feat(terminal): add YOLO mode to invoke Claude with --dangerously-skip-permissions (#1016) by @Andy in d48e5f68
- Fix Duplicate Kanban Task Creation on Rapid Button Clicks (#1021) by @Andy in 2d1d3ef1
- feat(sentry): embed Sentry DSN at build time for packaged apps (#1025) by @Andy in aed28c5f
- fix(github): resolve circular import issues in context_gatherer and services (#1026) by @Andy in 0307a4a9
- hotfix/sentry-backend-build by @AndyMik90 in e7b38d49
- chore: bump version to 2.7.4 by @AndyMik90 in 432e985b
- fix(github-prs): prevent preloading of PRs currently under review (#1006) by @Andy in 1babcc86
- fix(ui): display actual base branch name instead of hardcoded main (#969) by @Andy in 5d07d5f1
- ci(release): move VirusTotal scan to separate post-release workflow (#980) by @Andy in 553d1e8d
- fix: improve Claude CLI detection and add installation selector (#1004) by @Andy in e07a0dbd
- fix(backend): add Sentry integration and fix broken pipe errors (#991) by @Andy in aa9fbe9d
- fix(app-update): persist downloaded update state for Install button visibility (#992) by @Andy in 6f059bb5
- fix(terminal): detect Claude exit and reset label when user closes Claude (#990) by @Andy in 14982e66
- fix(merge): include files with content changes even when semantic analysis is empty (#986) by @Andy in 4736b6b6
- fix(frontend): sync worktree config to renderer on terminal restoration (#982) by @Andy in 68fe0860
- feat(frontend): add searchable branch combobox to worktree creation dialog (#979) by @Andy in 2a2dc3b8
- fix(security): inherit security profiles in worktrees and validate shell -c commands (#971) by @Andy in 750ea8d1
- feat(frontend): add Claude Code version rollback feature (#983) by @Andy in 8d21978f
- fix(ACS-181): enable auto-switch on 401 auth errors & OAuth-only profiles (#900) by @Michael Ludlow in e7427321
- fix(terminal): add collision detection for terminal drag and drop reordering (#985) by @Andy in 1701160b
- fix(worktree): handle "already up to date" case correctly (ACS-226) (#961) by @StillKnotKnown in 74ed4320
- ci: add Azure auth test workflow by @AndyMik90 in d12eb523
-
-## Thanks to all contributors
-
-@AndyMik90, @Andy, @Adam Slaker, @TamerineSky, @StillKnotKnown, @Test User, @youngmrz, @VDT-91, @kaigler, @Alexander Penzin, @Antti, @Alex, @Michael Ludlow, @Umaru
-
-## 2.7.4 - Terminal & Workflow Enhancements
-
-### ✨ New Features
-
- Added task worktrees section in terminal with ability to invoke Claude with YOLO mode (--dangerously-skip-permissions)
-
- Added searchable branch combobox to worktree creation dialog for easier branch selection
-
- Added Claude Code version rollback feature to switch between installed versions
-
- Embedded Sentry DSN at build time for better error tracking in packaged apps
-
-### 🛠️ Improvements
-
- Made worktree isolation prominent in UI to help users understand workspace isolation
-
- Enhanced terminal recreation logic with retry mechanism for more reliable terminal recovery
-
- Improved worktree name input UX for better user experience
-
- Improved Claude CLI detection with installation selector when multiple versions found
-
- Enhanced terminal drag and drop reordering with collision detection
-
- Synced worktree config to renderer on terminal restoration for consistency
-
-### 🐛 Bug Fixes
-
- Fixed Windows claude.cmd validation in GUI to work reliably across different setups
-
- Fixed profile manager initialization timing issue before auth checks
-
- Fixed terminal recreation and label reset when user closes Claude
-
- Fixed duplicate Kanban task creation that occurred on rapid button clicks
-
- Fixed GitHub PR preloading to prevent loading PRs currently under review
-
- Fixed UI to display actual base branch name instead of hardcoded "main"
-
- Fixed Claude CLI detection to properly identify available installations
-
- Fixed broken pipe errors in backend with Sentry integration
-
- Fixed app update state persistence for Install button visibility
-
- Fixed merge logic to include files with content changes even when semantic analysis is empty
-
- Fixed security profile inheritance in worktrees and shell -c command validation
-
- Fixed auth auto-switch on 401 errors and improved OAuth-only profile handling
-
- Fixed "already up to date" case handling in worktree operations
-
- Resolved circular import issues in GitHub context gatherer and services
-
---
-
-## What's Changed
-
- fix: validate Windows claude.cmd reliably in GUI by @Umaru in 1ae3359b
- fix: await profile manager initialization before auth check by @StillKnotKnown in c8374bc1
- feat: add file/screenshot upload to QA feedback interface by @Andy in 88277f84
- feat(terminal): add task worktrees section and remove terminal limit by @Andy in 17118b07
- fix(terminal): enhance terminal recreation logic with retry mechanism by @Andy in df1b8a3f
- fix(terminal): improve worktree name input UX by @Andy in 54e9f228
- feat(ui): make worktree isolation prominent in UI by @Andy in 4dbb7ee4
- feat(terminal): add YOLO mode to invoke Claude with --dangerously-skip-permissions by @Andy in d48e5f68
- fix(ui): prevent duplicate Kanban task creation on rapid button clicks by @Andy in 2d1d3ef1
- feat(sentry): embed Sentry DSN at build time for packaged apps by @Andy in aed28c5f
- fix(github): resolve circular import issues in context_gatherer and services by @Andy in 0307a4a9
- fix(github-prs): prevent preloading of PRs currently under review by @Andy in 1babcc86
- fix(ui): display actual base branch name instead of hardcoded main by @Andy in 5d07d5f1
- ci(release): move VirusTotal scan to separate post-release workflow by @Andy in 553d1e8d
- fix: improve Claude CLI detection and add installation selector by @Andy in e07a0dbd
- fix(backend): add Sentry integration and fix broken pipe errors by @Andy in aa9fbe9d
- fix(app-update): persist downloaded update state for Install button visibility by @Andy in 6f059bb5
- fix(terminal): detect Claude exit and reset label when user closes Claude by @Andy in 14982e66
- fix(merge): include files with content changes even when semantic analysis is empty by @Andy in 4736b6b6
- fix(frontend): sync worktree config to renderer on terminal restoration by @Andy in 68fe0860
- feat(frontend): add searchable branch combobox to worktree creation dialog by @Andy in 2a2dc3b8
- fix(security): inherit security profiles in worktrees and validate shell -c commands by @Andy in 750ea8d1
- feat(frontend): add Claude Code version rollback feature by @Andy in 8d21978f
- fix(ACS-181): enable auto-switch on 401 auth errors & OAuth-only profiles by @Michael Ludlow in e7427321
- fix(terminal): add collision detection for terminal drag and drop reordering by @Andy in 1701160b
- fix(worktree): handle "already up to date" case correctly by @StillKnotKnown in 74ed4320
-
-## Thanks to all contributors
-
-@Umaru, @StillKnotKnown, @Andy, @Michael Ludlow, @AndyMik90
-
 ## 2.7.3 - Reliability & Stability Focus

 ### ✨ New Features
@@ -1,306 +1,509 @@
 # CLAUDE.md

-This file provides guidance to Claude Code when working with this repository.
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

-Auto Claude is an autonomous multi-agent coding framework that plans, builds, and validates software for you. It's a monorepo with a Python backend (CLI + agent logic) and an Electron/React frontend (desktop UI).
+## Project Overview

-> **Deep-dive reference:** [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md) | **Frontend contributing:** [apps/frontend/CONTRIBUTING.md](apps/frontend/CONTRIBUTING.md)
+Auto Claude is a multi-agent autonomous coding framework that builds software through coordinated AI agent sessions. It uses the Claude Agent SDK to run agents in isolated workspaces with security controls.

-## Product Overview
-
-Auto Claude is a desktop application (+ CLI) where users describe a goal and AI agents autonomously handle planning, implementation, and QA validation. All work happens in isolated git worktrees so the main branch stays safe.
-
-**Core workflow:** User creates a task → Spec creation pipeline assesses complexity and writes a specification → Planner agent breaks it into subtasks → Coder agent implements (can spawn parallel subagents) → QA reviewer validates → QA fixer resolves issues → User reviews and merges.
-
-**Main features:**
-
- **Autonomous Tasks** — Multi-agent pipeline (planner, coder, QA) that builds features end-to-end
- **Kanban Board** — Visual task management from planning through completion
- **Agent Terminals** — Up to 12 parallel AI-powered terminals with task context injection
- **Insights** — AI chat interface for exploring and understanding your codebase
- **Roadmap** — AI-assisted feature planning with strategic roadmap generation
- **Ideation** — Discover improvements, performance issues, and security vulnerabilities
- **GitHub/GitLab Integration** — Import issues, AI-powered investigation, PR/MR review and creation
- **Changelog** — Generate release notes from completed tasks
- **Memory System** — Graphiti-based knowledge graph retains insights across sessions
- **Isolated Workspaces** — Git worktree isolation for every build; AI-powered semantic merge
- **Flexible Authentication** — Use a Claude Code subscription (OAuth) or API profiles with any Anthropic-compatible endpoint (e.g., Anthropic API, z.ai for GLM models)
- **Multi-Account Swapping** — Register multiple Claude accounts; when one hits a rate limit, Auto Claude automatically switches to an available account
- **Cross-Platform** — Native desktop app for Windows, macOS, and Linux with auto-updates
-
-## Critical Rules
-
-**Claude Agent SDK only** — All AI interactions use `claude-agent-sdk`. NEVER use `anthropic.Anthropic()` directly. Always use `create_client()` from `core.client`.
-
-**i18n required** — All frontend user-facing text MUST use `react-i18next` translation keys. Never hardcode strings in JSX/TSX. Add keys to both `en/*.json` and `fr/*.json`.
-
-**Platform abstraction** — Never use `process.platform` directly. Import from `apps/frontend/src/main/platform/` or `apps/backend/core/platform/`. CI tests all three platforms.
-
-**No time estimates** — Never provide duration predictions. Use priority-based ordering instead.
-
-**PR target** — Always target the `develop` branch for PRs to AndyMik90/Auto-Claude, NOT `main`.
-
-**No console.log for debugging production issues** — `console.log` output is not visible in bundled/packaged versions of the Electron app. Use Sentry for error tracking and diagnostics in production. Reserve `console.log` for development only.
-
-## Work Approach
-
-**Investigate before speculating** — Always read the actual code before proposing root causes. Spawn agents to grep and read relevant source files before forming any hypothesis. Never guess at causes without evidence from the codebase.
-
-**Spawn agents for complex tasks** — When tackling complex tasks, spawn sub-agents/agent teams immediately rather than trying to handle everything in a single context window. Never attempt to analyze large codebases or multiple features monolithically.
-
-**Minimal fixes only** — Prefer the simplest approach (e.g., prompt-only changes, single guard clause) before suggesting multi-component solutions. If the user asks for X, implement X — don't bundle additional fixes they didn't request.
-
-## Known Gotchas
-
-**Electron path resolution** — For bug fixes in the Electron app, always check path resolution differences between dev and production builds (`app.isPackaged`, `process.resourcesPath`). Paths that work in dev often break when Electron is bundled for production — verify both contexts.
-
-### Resetting PR Review State
-
-To fully clear all PR review data so reviews run fresh, delete/reset these three things in `.auto-claude/github/`:
-
-1. `rm .auto-claude/github/pr/logs_*.json` — review log files
-2. `rm .auto-claude/github/pr/review_*.json` — review result files
-3. Reset `pr/index.json` to `{"reviews": [], "last_updated": null}`
-4. Reset `bot_detection_state.json` to `{"reviewed_commits": {}}` — this is the gatekeeper; without clearing it, the bot detector skips already-seen commits
+**CRITICAL: All AI interactions use the Claude Agent SDK (`claude-agent-sdk` package), NOT the Anthropic API directly.**

 ## Project Structure

 ```
 autonomous-coding/
 ├── apps/
-│   ├── backend/                 # Python backend/CLI — ALL agent logic
-│   │   ├── core/                # client.py, auth.py, worktree.py, platform/
-│   │   ├── security/            # Command allowlisting, validators, hooks
-│   │   ├── agents/              # planner, coder, session management
-│   │   ├── qa/                  # reviewer, fixer, loop, criteria
-│   │   ├── spec/                # Spec creation pipeline
-│   │   ├── cli/                 # CLI commands (spec, build, workspace, QA)
-│   │   ├── context/             # Task context building, semantic search
-│   │   ├── runners/             # Standalone runners (spec, roadmap, insights, github)
-│   │   ├── services/            # Background services, recovery orchestration
-│   │   ├── integrations/        # graphiti/, linear, github
-│   │   ├── project/             # Project analysis, security profiles
-│   │   ├── merge/               # Intent-aware semantic merge for parallel agents
-│   │   └── prompts/             # Agent system prompts (.md)
-│   └── frontend/                # Electron desktop UI
-│       └── src/
-│           ├── main/            # Electron main process
-│           │   ├── agent/       # Agent queue, process, state, events
-│           │   ├── claude-profile/ # Multi-profile credentials, token refresh, usage
-│           │   ├── terminal/    # PTY daemon, lifecycle, Claude integration
-│           │   ├── platform/    # Cross-platform abstraction
-│           │   ├── ipc-handlers/# 40+ handler modules by domain
-│           │   ├── services/    # SDK session recovery, profile service
-│           │   └── changelog/   # Changelog generation and formatting
-│           ├── preload/         # Electron preload scripts (electronAPI bridge)
-│           ├── renderer/        # React UI
-│           │   ├── components/  # UI components (onboarding, settings, task, terminal, github, etc.)
-│           │   ├── stores/      # 24+ Zustand state stores
-│           │   ├── contexts/    # React contexts (ViewStateContext)
-│           │   ├── hooks/       # Custom hooks (useIpc, useTerminal, etc.)
-│           │   ├── styles/      # CSS / Tailwind styles
-│           │   └── App.tsx      # Root component
-│           ├── shared/          # Shared types, i18n, constants, utils
-│           │   ├── i18n/locales/# en/*.json, fr/*.json
-│           │   ├── constants/   # themes.ts, etc.
-│           │   ├── types/       # 19+ type definition files
-│           │   └── utils/       # ANSI sanitizer, shell escape, provider detection
-│           └── types/           # TypeScript type definitions
-├── guides/                      # Documentation
-├── tests/                       # Backend test suite
-└── scripts/                     # Build and utility scripts
+│   ├── backend/           # Python backend/CLI - ALL agent logic lives here
+│   │   ├── core/          # Client, auth, security
+│   │   ├── agents/        # Agent implementations
+│   │   ├── spec_agents/   # Spec creation agents
+│   │   ├── integrations/  # Graphiti, Linear, GitHub
+│   │   └── prompts/       # Agent system prompts
+│   └── frontend/          # Electron desktop UI
+├── guides/                # Documentation
+├── tests/                 # Test suite
+└── scripts/               # Build and utility scripts
 ```

-## Commands Quick Reference
+**When working with AI/LLM code:**
+- Look in `apps/backend/core/client.py` for the Claude SDK client setup
+- Reference `apps/backend/agents/` for working agent implementations
+- Check `apps/backend/spec_agents/` for spec creation agent examples
+- NEVER use `anthropic.Anthropic()` directly - always use `create_client()` from `core.client`
+
+**Frontend (Electron Desktop App):**
+- Built with Electron, React, TypeScript
+- AI agents can perform E2E testing using the Electron MCP server
+- When bug fixing or implementing features, use the Electron MCP server for automated testing
+- See "End-to-End Testing" section below for details
+
+## Commands

 ### Setup
+
+**Requirements:**
+- Python 3.12+ (required for backend)
+- Node.js (for frontend)
+
 ```bash
-npm run install:all              # Install all dependencies from root
-# Or separately:
+# Install all dependencies from root
+npm run install:all
+
+# Or install separately:
+# Backend (from apps/backend/)
 cd apps/backend && uv venv && uv pip install -r requirements.txt
+
+# Frontend (from apps/frontend/)
 cd apps/frontend && npm install
+
+# Set up OAuth token
+claude setup-token
+# Add to apps/backend/.env: CLAUDE_CODE_OAUTH_TOKEN=your-token
+```
+
+### Creating and Running Specs
+```bash
+cd apps/backend
+
+# Create a spec interactively
+python spec_runner.py --interactive
+
+# Create spec from task description
+python spec_runner.py --task "Add user authentication"
+
+# Force complexity level (simple/standard/complex)
+python spec_runner.py --task "Fix button" --complexity simple
+
+# Run autonomous build
+python run.py --spec 001
+
+# List all specs
+python run.py --list
+```
+
+### Workspace Management
+```bash
+cd apps/backend
+
+# Review changes in isolated worktree
+python run.py --spec 001 --review
+
+# Merge completed build into project
+python run.py --spec 001 --merge
+
+# Discard build
+python run.py --spec 001 --discard
+```
+
+### QA Validation
+```bash
+cd apps/backend
+
+# Run QA manually
+python run.py --spec 001 --qa
+
+# Check QA status
+python run.py --spec 001 --qa-status
 ```

 ### Testing
+```bash
+# Install test dependencies (required first time)
+cd apps/backend && uv pip install -r ../../tests/requirements-test.txt

-| Stack | Command | Tool |
-|-------|---------|------|
-| Backend | `apps/backend/.venv/bin/pytest tests/ -v` | pytest |
-| Frontend unit | `cd apps/frontend && npm test` | Vitest |
-| Frontend E2E | `cd apps/frontend && npm run test:e2e` | Playwright |
-| All backend | `npm run test:backend` (from root) | pytest |
+# Run all tests (use virtual environment pytest)
+apps/backend/.venv/bin/pytest tests/ -v
+
+# Run single test file
+apps/backend/.venv/bin/pytest tests/test_security.py -v
+
+# Run specific test
+apps/backend/.venv/bin/pytest tests/test_security.py::test_bash_command_validation -v
+
+# Skip slow tests
+apps/backend/.venv/bin/pytest tests/ -m "not slow"
+
+# Or from root
+npm run test:backend
+```
+
+### Spec Validation
+```bash
+python apps/backend/validate_spec.py --spec-dir apps/backend/specs/001-feature --checkpoint all
+```

 ### Releases
 ```bash
-node scripts/bump-version.js patch|minor|major  # Bump version
-git push && gh pr create --base main             # PR to main triggers release
+# 1. Bump version on your branch (creates commit, no tag)
+node scripts/bump-version.js patch   # 2.8.0 -> 2.8.1
+node scripts/bump-version.js minor   # 2.8.0 -> 2.9.0
+node scripts/bump-version.js major   # 2.8.0 -> 3.0.0
+
+# 2. Push and create PR to main
+git push origin your-branch
+gh pr create --base main
+
+# 3. Merge PR → GitHub Actions automatically:
+#    - Creates tag
+#    - Builds all platforms
+#    - Creates release with changelog
+#    - Updates README
 ```

-See [RELEASE.md](RELEASE.md) for full release process.
+See [RELEASE.md](RELEASE.md) for detailed release process documentation.

-## Backend Development
+## Architecture

-### Claude Agent SDK Usage
+### Core Pipeline

-Client: `apps/backend/core/client.py` — `create_client()` returns a configured `ClaudeSDKClient` with security hooks, tool permissions, and MCP server integration.
+**Spec Creation (spec_runner.py)** - Dynamic 3-8 phase pipeline based on task complexity:
+- SIMPLE (3 phases): Discovery → Quick Spec → Validate
+- STANDARD (6-7 phases): Discovery → Requirements → [Research] → Context → Spec → Plan → Validate
+- COMPLEX (8 phases): Full pipeline with Research and Self-Critique phases

-Model and thinking level are user-configurable (via the Electron UI settings or CLI override). Use `phase_config.py` helpers to resolve the correct values
+**Implementation (run.py → agent.py)** - Multi-session build:
+1. Planner Agent creates subtask-based implementation plan
+2. Coder Agent implements subtasks (can spawn subagents for parallel work)
+3. QA Reviewer validates acceptance criteria (can perform E2E testing via Electron MCP for frontend changes)
+4. QA Fixer resolves issues in a loop (with E2E testing to verify fixes)

-### Agent Prompts (`apps/backend/prompts/`)
+### Key Components (apps/backend/)
+
+**Core Infrastructure:**
+- **core/client.py** - Claude Agent SDK client factory with security hooks and tool permissions
+- **core/security.py** - Dynamic command allowlisting based on detected project stack
+- **core/auth.py** - OAuth token management for Claude SDK authentication
+- **agents/** - Agent implementations (planner, coder, qa_reviewer, qa_fixer)
+- **spec_agents/** - Spec creation agents (gatherer, researcher, writer, critic)
+
+**Memory & Context:**
+- **integrations/graphiti/** - Graphiti memory system (mandatory)
+  - `queries_pkg/graphiti.py` - Main GraphitiMemory class
+  - `queries_pkg/client.py` - LadybugDB client wrapper
+  - `queries_pkg/queries.py` - Graph query operations
+  - `queries_pkg/search.py` - Semantic search logic
+  - `queries_pkg/schema.py` - Graph schema definitions
+- **graphiti_config.py** - Configuration and validation for Graphiti integration
+- **graphiti_providers.py** - Multi-provider factory (OpenAI, Anthropic, Azure, Ollama, Google AI)
+- **agents/memory_manager.py** - Session memory orchestration
+
+**Workspace & Security:**
+- **cli/worktree.py** - Git worktree isolation for safe feature development
+- **context/project_analyzer.py** - Project stack detection for dynamic tooling
+- **auto_claude_tools.py** - Custom MCP tools integration
+
+**Integrations:**
+- **linear_updater.py** - Optional Linear integration for progress tracking
+- **runners/github/** - GitHub Issues & PRs automation
+- **Electron MCP** - E2E testing integration for QA agents (Chrome DevTools Protocol)
+  - Enabled with `ELECTRON_MCP_ENABLED=true` in `.env`
+  - Allows QA agents to interact with running Electron app
+  - See "End-to-End Testing" section for details
+
+### Agent Prompts (apps/backend/prompts/)

 | Prompt | Purpose |
 |--------|---------|
-| planner.md | Implementation plan with subtasks |
-| coder.md / coder_recovery.md | Subtask implementation / recovery |
-| qa_reviewer.md / qa_fixer.md | Acceptance validation / issue fixes |
-| spec_gatherer/researcher/writer/critic.md | Spec creation pipeline |
+| planner.md | Creates implementation plan with subtasks |
+| coder.md | Implements individual subtasks |
+| coder_recovery.md | Recovers from stuck/failed subtasks |
+| qa_reviewer.md | Validates acceptance criteria |
+| qa_fixer.md | Fixes QA-reported issues |
+| spec_gatherer.md | Collects user requirements |
+| spec_researcher.md | Validates external integrations |
+| spec_writer.md | Creates spec.md document |
+| spec_critic.md | Self-critique using ultrathink |
 | complexity_assessor.md | AI-based complexity assessment |

 ### Spec Directory Structure

-Each spec in `.auto-claude/specs/XXX-name/` contains: `spec.md`, `requirements.json`, `context.json`, `implementation_plan.json`, `qa_report.md`, `QA_FIX_REQUEST.md`
+Each spec in `.auto-claude/specs/XXX-name/` contains:
+- `spec.md` - Feature specification
+- `requirements.json` - Structured user requirements
+- `context.json` - Discovered codebase context
+- `implementation_plan.json` - Subtask-based plan with status tracking
+- `qa_report.md` - QA validation results
+- `QA_FIX_REQUEST.md` - Issues to fix (when rejected)

-### Memory System (Graphiti)
+### Branching & Worktree Strategy

-Graph-based semantic memory in `integrations/graphiti/`. Configured through the Electron app's onboarding/settings UI (CLI users can alternatively set `GRAPHITI_ENABLED=true` in `.env`). See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#memory-system) for details.
+Auto Claude uses git worktrees for isolated builds. All branches stay LOCAL until user explicitly pushes:

-## Frontend Development
-
-### Tech Stack
-
-React 19, TypeScript (strict), Electron 39, Zustand 5, Tailwind CSS v4, Radix UI, xterm.js 6, Vite 7, Vitest 4, Biome 2, Motion (Framer Motion)
-
-### Path Aliases (tsconfig.json)
-
-| Alias | Maps to |
-|-------|---------|
-| `@/*` | `src/renderer/*` |
-| `@shared/*` | `src/shared/*` |
-| `@preload/*` | `src/preload/*` |
-| `@features/*` | `src/renderer/features/*` |
-| `@components/*` | `src/renderer/shared/components/*` |
-| `@hooks/*` | `src/renderer/shared/hooks/*` |
-| `@lib/*` | `src/renderer/shared/lib/*` |
-
-### State Management (Zustand)
-
-All state lives in `src/renderer/stores/`. Key stores:
-
- `project-store.ts` — Active project, project list
- `task-store.ts` — Tasks/specs management
- `terminal-store.ts` — Terminal sessions and state
- `settings-store.ts` — User preferences
- `github/issues-store.ts`, `github/pr-review-store.ts` — GitHub integration
- `insights-store.ts`, `roadmap-store.ts`, `kanban-settings-store.ts`
-
-Main process also has stores: `src/main/project-store.ts`, `src/main/terminal-session-store.ts`
-
-### Styling
-
- **Tailwind CSS v4** with `@tailwindcss/postcss` plugin
- **7 color themes** (Default, Dusk, Lime, Ocean, Retro, Neo + more) defined in `src/shared/constants/themes.ts`
- Each theme has light/dark mode variants via CSS custom properties
- Utility: `clsx` + `tailwind-merge` via `cn()` helper
- Component variants: `class-variance-authority` (CVA)
-
-### IPC Communication
-
-Main ↔ Renderer communication via Electron IPC:
- **Handlers:** `src/main/ipc-handlers/` — organized by domain (github, gitlab, ideation, context, etc.)
- **Preload:** `src/preload/` — exposes safe APIs to renderer
- Pattern: renderer calls via `window.electronAPI.*`, main handles in IPC handler modules
-
-### Agent Management (`src/main/agent/`)
-
-The frontend manages agent lifecycle end-to-end:
- **`agent-queue.ts`** — Queue routing, prioritization, spec number locking
- **`agent-process.ts`** — Spawns and manages agent subprocess communication
- **`agent-state.ts`** — Tracks running agent state and status
- **`agent-events.ts`** — Agent lifecycle events and state transitions
-
-### Claude Profile System (`src/main/claude-profile/`)
-
-Multi-profile credential management for switching between Claude accounts:
- **`credential-utils.ts`** — OS credential storage (Keychain/Windows Credential Manager)
- **`token-refresh.ts`** — OAuth token lifecycle and automatic refresh
- **`usage-monitor.ts`** — API usage tracking and rate limiting per profile
- **`profile-scorer.ts`** — Scores profiles by usage and availability
-
-### Terminal System (`src/main/terminal/`)
-
-Full PTY-based terminal integration:
- **`pty-daemon.ts`** / **`pty-manager.ts`** — Background PTY process management
- **`terminal-lifecycle.ts`** — Session creation, cleanup, event handling
- **`claude-integration-handler.ts`** — Claude SDK integration within terminals
- Renderer: xterm.js 6 with WebGL, fit, web-links, serialize addons. Store: `terminal-store.ts`
-
-## Code Quality
-
-### Frontend
- **Linting:** Biome (`npm run lint` / `npm run lint:fix`)
- **Type checking:** `npm run typecheck` (strict mode)
- **Pre-commit:** Husky + lint-staged runs Biome on staged `.ts/.tsx/.js/.jsx/.json`
- **Testing:** Vitest + React Testing Library + jsdom
-
-### Backend
- **Linting:** Ruff
- **Testing:** pytest (`apps/backend/.venv/bin/pytest tests/ -v`)
-
-## i18n Guidelines
-
-All frontend UI text uses `react-i18next`. Translation files: `apps/frontend/src/shared/i18n/locales/{en,fr}/*.json`
-
-**Namespaces:** `common`, `navigation`, `settings`, `dialogs`, `tasks`, `errors`, `onboarding`, `welcome`
-
-```tsx
-import { useTranslation } from 'react-i18next';
-const { t } = useTranslation(['navigation', 'common']);
-
-<span>{t('navigation:items.githubPRs')}</span>     // CORRECT
-<span>GitHub PRs</span>                             // WRONG
-
-// With interpolation:
-<span>{t('errors:task.parseError', { error })}</span>
+```
+main (user's branch)
+└── auto-claude/{spec-name}  ← spec branch (isolated worktree)
 ```

-When adding new UI text: add keys to ALL language files, use `namespace:section.key` format.
+**Key principles:**
+- ONE branch per spec (`auto-claude/{spec-name}`)
+- Parallel work uses subagents (agent decides when to spawn)
+- NO automatic pushes to GitHub - user controls when to push
+- User reviews in spec worktree (`.worktrees/{spec-name}/`)
+- Final merge: spec branch → main (after user approval)

-## Cross-Platform
+**Workflow:**
+1. Build runs in isolated worktree on spec branch
+2. Agent implements subtasks (can spawn subagents for parallel work)
+3. User tests feature in `.worktrees/{spec-name}/`
+4. User runs `--merge` to add to their project
+5. User pushes to remote when ready

-Supports Windows, macOS, Linux. CI tests all three.
+### Contributing to Upstream

-**Platform modules:** `apps/frontend/src/main/platform/` and `apps/backend/core/platform/`
+**CRITICAL: When submitting PRs to AndyMik90/Auto-Claude, always target the `develop` branch, NOT `main`.**

-| Function | Purpose |
-|----------|---------|
-| `isWindows()` / `isMacOS()` / `isLinux()` | OS detection |
-| `getPathDelimiter()` | `;` (Win) or `:` (Unix) |
-| `findExecutable(name)` | Cross-platform executable lookup |
-| `requiresShell(command)` | `.cmd/.bat` shell detection (Win) |
+**Correct workflow for contributions:**
+1. Fetch upstream: `git fetch upstream`
+2. Create feature branch from upstream/develop: `git checkout -b fix/my-fix upstream/develop`
+3. Make changes and commit with sign-off: `git commit -s -m "fix: description"`
+4. Push to your fork: `git push origin fix/my-fix`
+5. Create PR targeting `develop`: `gh pr create --repo AndyMik90/Auto-Claude --base develop`

-Never hardcode paths. Use `findExecutable()` and `joinPaths()`. See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#cross-platform-development) for extended guide.
+**Verify before PR:**
+```bash
+# Ensure only your commits are included
+git log --oneline upstream/develop..HEAD
+```

-## E2E Testing (Electron MCP)
+### Security Model

-QA agents can interact with the running Electron app via Chrome DevTools Protocol:
+Three-layer defense:
+1. **OS Sandbox** - Bash command isolation
+2. **Filesystem Permissions** - Operations restricted to project directory
+3. **Command Allowlist** - Dynamic allowlist from project analysis (security.py + project_analyzer.py)

-1. Start app: `npm run dev:debug` (debug mode for AI self-validation via Electron MCP)
-2. Set `ELECTRON_MCP_ENABLED=true` in `apps/backend/.env`
-3. Run QA: `python run.py --spec 001 --qa`
+Security profile cached in `.auto-claude-security.json`.

-Tools: `take_screenshot`, `click_by_text`, `fill_input`, `get_page_structure`, `send_keyboard_shortcut`, `eval`. See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#end-to-end-testing) for full capabilities.
+### Claude Agent SDK Integration
+
+**CRITICAL: Auto Claude uses the Claude Agent SDK for ALL AI interactions. Never use the Anthropic API directly.**
+
+**Client Location:** `apps/backend/core/client.py`
+
+The `create_client()` function creates a configured `ClaudeSDKClient` instance with:
+- Multi-layered security (sandbox, permissions, security hooks)
+- Agent-specific tool permissions (planner, coder, qa_reviewer, qa_fixer)
+- Dynamic MCP server integration based on project capabilities
+- Extended thinking token budget control
+
+**Example usage in agents:**
+```python
+from core.client import create_client
+
+# Create SDK client (NOT raw Anthropic API client)
+client = create_client(
+    project_dir=project_dir,
+    spec_dir=spec_dir,
+    model="claude-sonnet-4-5-20250929",
+    agent_type="coder",
+    max_thinking_tokens=None  # or 5000/10000/16000
+)
+
+# Run agent session
+response = client.create_agent_session(
+    name="coder-agent-session",
+    starting_message="Implement the authentication feature"
+)
+```
+
+**Why use the SDK:**
+- Pre-configured security (sandbox, allowlists, hooks)
+- Automatic MCP server integration (Context7, Linear, Graphiti, Electron, Puppeteer)
+- Tool permissions based on agent role
+- Session management and recovery
+- Unified API across all agent types
+
+**Where to find working examples:**
+- `apps/backend/agents/planner.py` - Planner agent
+- `apps/backend/agents/coder.py` - Coder agent
+- `apps/backend/agents/qa_reviewer.py` - QA reviewer
+- `apps/backend/agents/qa_fixer.py` - QA fixer
+- `apps/backend/spec_agents/` - Spec creation agents
+
+### Memory System
+
+**Graphiti Memory (Mandatory)** - `integrations/graphiti/`
+
+Auto Claude uses Graphiti as its primary memory system with embedded LadybugDB (no Docker required):
+
+- **Graph database with semantic search** - Knowledge graph for cross-session context
+- **Session insights** - Patterns, gotchas, discoveries automatically extracted
+- **Multi-provider support:**
+  - LLM: OpenAI, Anthropic, Azure OpenAI, Ollama, Google AI (Gemini)
+  - Embedders: OpenAI, Voyage AI, Azure OpenAI, Ollama, Google AI
+- **Modular architecture:** (`integrations/graphiti/queries_pkg/`)
+  - `graphiti.py` - Main GraphitiMemory class
+  - `client.py` - LadybugDB client wrapper
+  - `queries.py` - Graph query operations
+  - `search.py` - Semantic search logic
+  - `schema.py` - Graph schema definitions
+
+**Configuration:**
+- Set provider credentials in `apps/backend/.env` (see `.env.example`)
+- Required env vars: `GRAPHITI_ENABLED=true`, `ANTHROPIC_API_KEY` or other provider keys
+- Memory data stored in `.auto-claude/specs/XXX/graphiti/`
+
+**Usage in agents:**
+```python
+from integrations.graphiti.memory import get_graphiti_memory
+
+memory = get_graphiti_memory(spec_dir, project_dir)
+context = memory.get_context_for_session("Implementing feature X")
+memory.add_session_insight("Pattern: use React hooks for state")
+```
+
+## Development Guidelines
+
+### Frontend Internationalization (i18n)
+
+**CRITICAL: Always use i18n translation keys for all user-facing text in the frontend.**
+
+The frontend uses `react-i18next` for internationalization. All labels, buttons, messages, and user-facing text MUST use translation keys.
+
+**Translation file locations:**
+- `apps/frontend/src/shared/i18n/locales/en/*.json` - English translations
+- `apps/frontend/src/shared/i18n/locales/fr/*.json` - French translations
+
+**Translation namespaces:**
+- `common.json` - Shared labels, buttons, common terms
+- `navigation.json` - Sidebar navigation items, sections
+- `settings.json` - Settings page content
+- `dialogs.json` - Dialog boxes and modals
+- `tasks.json` - Task/spec related content
+- `errors.json` - Error messages (structured error information with substitution support)
+- `onboarding.json` - Onboarding wizard content
+- `welcome.json` - Welcome screen content
+
+**Usage pattern:**
+```tsx
+import { useTranslation } from 'react-i18next';
+
+// In component
+const { t } = useTranslation(['navigation', 'common']);
+
+// Use translation keys, NOT hardcoded strings
+<span>{t('navigation:items.githubPRs')}</span>  // ✅ CORRECT
+<span>GitHub PRs</span>                          // ❌ WRONG
+```
+
+**Error messages with substitution:**
+
+```tsx
+// For error messages with dynamic content, use interpolation
+const { t } = useTranslation(['errors']);
+
+// errors.json: { "task": { "parseError": "Failed to parse: {{error}}" } }
+<span>{t('errors:task.parseError', { error: errorMessage })}</span>
+```
+
+**When adding new UI text:**
+1. Add the translation key to ALL language files (at minimum: `en/*.json` and `fr/*.json`)
+2. Use `namespace:section.key` format (e.g., `navigation:items.githubPRs`)
+3. Never use hardcoded strings in JSX/TSX files
+
+### End-to-End Testing (Electron App)
+
+**IMPORTANT: When bug fixing or implementing new features in the frontend, AI agents can perform automated E2E testing using the Electron MCP server.**
+
+The Electron MCP server allows QA agents to interact with the running Electron app via Chrome DevTools Protocol:
+
+**Setup:**
+1. Start the Electron app with remote debugging enabled:
+   ```bash
+   npm run dev  # Already configured with --remote-debugging-port=9222
+   ```
+
+2. Enable Electron MCP in `apps/backend/.env`:
+   ```bash
+   ELECTRON_MCP_ENABLED=true
+   ELECTRON_DEBUG_PORT=9222  # Default port
+   ```
+
+**Available Testing Capabilities:**
+
+QA agents (`qa_reviewer` and `qa_fixer`) automatically get access to Electron MCP tools:
+
+1. **Window Management**
+   - `mcp__electron__get_electron_window_info` - Get info about running windows
+   - `mcp__electron__take_screenshot` - Capture screenshots for visual verification
+
+2. **UI Interaction**
+   - `mcp__electron__send_command_to_electron` with commands:
+     - `click_by_text` - Click buttons/links by visible text
+     - `click_by_selector` - Click elements by CSS selector
+     - `fill_input` - Fill form fields by placeholder or selector
+     - `select_option` - Select dropdown options
+     - `send_keyboard_shortcut` - Send keyboard shortcuts (Enter, Ctrl+N, etc.)
+     - `navigate_to_hash` - Navigate to hash routes (#settings, #create, etc.)
+
+3. **Page Inspection**
+   - `get_page_structure` - Get organized overview of page elements
+   - `debug_elements` - Get debugging info about buttons and forms
+   - `verify_form_state` - Check form state and validation
+   - `eval` - Execute custom JavaScript code
+
+4. **Logging**
+   - `mcp__electron__read_electron_logs` - Read console logs for debugging
+
+**Example E2E Test Flow:**
+
+```python
+# 1. Agent takes screenshot to see current state
+agent: "Take a screenshot to see the current UI"
+# Uses: mcp__electron__take_screenshot
+
+# 2. Agent inspects page structure
+agent: "Get page structure to find available buttons"
+# Uses: mcp__electron__send_command_to_electron (command: "get_page_structure")
+
+# 3. Agent clicks a button to navigate
+agent: "Click the 'Create New Spec' button"
+# Uses: mcp__electron__send_command_to_electron (command: "click_by_text", args: {text: "Create New Spec"})
+
+# 4. Agent fills out a form
+agent: "Fill the task description field"
+# Uses: mcp__electron__send_command_to_electron (command: "fill_input", args: {placeholder: "Describe your task", value: "Add login feature"})
+
+# 5. Agent submits and verifies
+agent: "Click Submit and verify success"
+# Uses: click_by_text → take_screenshot → verify result
+```
+
+**When to Use E2E Testing:**
+
+- **Bug Fixes**: Reproduce the bug, apply fix, verify it's resolved
+- **New Features**: Implement feature, test the UI flow end-to-end
+- **UI Changes**: Verify visual changes and interactions work correctly
+- **Form Validation**: Test form submission, validation, error handling
+
+**Configuration in `core/client.py`:**
+
+The client automatically enables Electron MCP tools for QA agents when:
+- Project is detected as Electron (`is_electron` capability)
+- `ELECTRON_MCP_ENABLED=true` is set
+- Agent type is `qa_reviewer` or `qa_fixer`
+
+**Note:** Screenshots are automatically compressed (1280x720, quality 60, JPEG) to stay under Claude SDK's 1MB JSON message buffer limit.

 ## Running the Application

+**As a standalone CLI tool**:
 ```bash
-# CLI only
-cd apps/backend && python run.py --spec 001
-
-# Desktop app
-npm start          # Production build + run
-npm run dev        # Development mode with HMR
-npm run dev:debug  # Debug mode with verbose output
-npm run dev:mcp    # Electron MCP server for AI debugging
-
-# Project data: .auto-claude/specs/ (gitignored)
+cd apps/backend
+python run.py --spec 001
 ```
+
+**With the Electron frontend**:
+```bash
+npm start        # Build and run desktop app
+npm run dev      # Run in development mode (includes --remote-debugging-port=9222 for E2E testing)
+```
+
+**For E2E Testing with QA Agents:**
+1. Start the Electron app: `npm run dev`
+2. Enable Electron MCP in `apps/backend/.env`: `ELECTRON_MCP_ENABLED=true`
+3. Run QA: `python run.py --spec 001 --qa`
+4. QA agents will automatically interact with the running app for testing
+
+**Project data storage:**
+- `.auto-claude/specs/` - Per-project data (specs, plans, QA reports, memory) - gitignored
@@ -2,41 +2,20 @@

 Thank you for your interest in contributing to Auto Claude! This document provides guidelines and instructions for contributing to the project.

-## How to Contribute
-
-| What you want to do | Where to start |
-|----------------------|----------------|
-| Bug fixes & small improvements | Open a PR directly |
-| New features / architecture changes | Start a [GitHub Discussion](https://github.com/AndyMik90/Auto-Claude/discussions) or ask in [Discord](https://discord.com/channels/1448614759996854284/1451298184612548779) first |
-| Questions & setup help | [Discord #setup-help](https://discord.com/channels/1448614759996854284/1451298184612548779) |
-
-## AI-Assisted Contributions
-
-PRs built with AI tools (Claude, Codex, Copilot, etc.) are welcome here -- given what this project does, it would be odd if they weren't.
-
-That said, we've seen AI-generated PRs that introduce regressions because the contributor didn't verify what the code actually does. To keep quality high, we ask that AI-assisted PRs include the following:
-
- **Flag it** -- mention AI assistance in the PR description (the PR template has a section for this)
- **State your testing level** -- untested, lightly tested, or fully tested
- **Share context if you can** -- prompts or session logs help reviewers understand intent
- **Confirm you understand the code** -- you should be able to describe what the PR does and how the underlying code works
-
-AI-assisted PRs go through the same review process as any other contribution. Transparency just helps reviewers know where to look more carefully.
-
 ## Table of Contents

- [How to Contribute](#how-to-contribute)
- [AI-Assisted Contributions](#ai-assisted-contributions)
 - [Contributor License Agreement (CLA)](#contributor-license-agreement-cla)
 - [Prerequisites](#prerequisites)
 - [Quick Start](#quick-start)
 - [Development Setup](#development-setup)
+  - [Python Backend](#python-backend)
+  - [Electron Frontend](#electron-frontend)
+- [Running from Source](#running-from-source)
 - [Pre-commit Hooks](#pre-commit-hooks)
 - [Code Style](#code-style)
 - [Testing](#testing)
 - [Continuous Integration](#continuous-integration)
 - [Git Workflow](#git-workflow)
-  - [Working with Forks](#working-with-forks)
  - [Branch Overview](#branch-overview)
  - [Main Branches](#main-branches)
  - [Supporting Branches](#supporting-branches)
@@ -171,40 +150,92 @@ npm start
 The project consists of two main components:

 1. **Python Backend** (`apps/backend/`) - The core autonomous coding framework
-2. **Electron Frontend** (`apps/frontend/`) - Desktop UI
+2. **Electron Frontend** (`apps/frontend/`) - Optional desktop UI

-From the repository root, two commands handle everything:
+### Python Backend
+
+The recommended way is to use `npm run install:backend`, but you can also set up manually:

 ```bash
-# Install all dependencies (Python backend + Electron frontend)
-npm run install:all
+# Navigate to the backend directory
+cd apps/backend

-# Start development mode (hot reload)
+# Create virtual environment
+# Windows:
+py -3.12 -m venv .venv
+.venv\Scripts\activate
+
+# macOS/Linux:
+python3.12 -m venv .venv
+source .venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Install test dependencies
+pip install -r ../../tests/requirements-test.txt
+
+# Set up environment
+cp .env.example .env
+# Edit .env and add your CLAUDE_CODE_OAUTH_TOKEN (get it via: claude setup-token)
+```
+
+### Electron Frontend
+
+```bash
+# Navigate to the frontend directory
+cd apps/frontend
+
+# Install dependencies
+npm install
+
+# Start development server
 npm run dev
+
+# Build for production
+npm run build
+
+# Package for distribution
+npm run package
 ```

-`npm run install:all` automatically:
- Detects Python 3.12+ on your system
- Creates a virtual environment (`apps/backend/.venv`)
- Installs backend runtime and test dependencies
- Copies `.env.example` to `.env` (if not already present)
- Installs frontend npm dependencies
+## Running from Source
+
+If you want to run Auto Claude from source (for development or testing unreleased features), follow these steps:
+
+### Step 1: Clone and Set Up

-After install, configure your credentials in `apps/backend/.env`:
 ```bash
-# Get your Claude Code OAuth token
-claude setup-token
+git clone https://github.com/AndyMik90/Auto-Claude.git
+cd Auto-Claude/apps/backend

-# Then edit apps/backend/.env with your token and any other provider keys
+# Using uv (recommended)
+uv venv && uv pip install -r requirements.txt
+
+# Or using standard Python
+python3 -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+
+# Set up environment
+cd apps/backend
+cp .env.example .env
+# Edit .env and add your CLAUDE_CODE_OAUTH_TOKEN (get it via: claude setup-token)
 ```

-### Other Useful Commands
+### Step 2: Run the Desktop UI

 ```bash
-npm start              # Build and run production
-npm run build          # Build frontend for production
-npm run package        # Package for distribution
-npm run test:backend   # Run Python tests
+cd ../frontend
+
+# Install dependencies
+npm install
+
+# Development mode (hot reload)
+npm run dev
+
+# Or production build
+npm run build && npm run start
 ```

 <details>
@@ -326,64 +357,6 @@ export default function(props) {
 - End files with a newline
 - Keep line length under 100 characters when practical

-### File Encoding (Python)
-
-**Always specify `encoding="utf-8"` for text file operations** to ensure Windows compatibility.
-
-Windows Python defaults to `cp1252` encoding instead of UTF-8, causing errors with:
- Emoji (🚀, ✅, ❌)
- International characters (ñ, é, 中文, العربية)
- Special symbols (™, ©, ®)
-
-**DO:**
-
-```python
-# Reading files
-with open(path, encoding="utf-8") as f:
-    content = f.read()
-
-# Writing files
-with open(path, "w", encoding="utf-8") as f:
-    f.write(content)
-
-# Path methods
-from pathlib import Path
-content = Path(file).read_text(encoding="utf-8")
-Path(file).write_text(content, encoding="utf-8")
-
-# JSON files - reading
-import json
-with open(path, encoding="utf-8") as f:
-    data = json.load(f)
-
-# JSON files - writing
-with open(path, "w", encoding="utf-8") as f:
-    json.dump(data, f, ensure_ascii=False, indent=2)
-```
-
-**DON'T:**
-
-```python
-# Wrong - platform-dependent encoding
-with open(path) as f:
-    content = f.read()
-
-# Wrong - Path methods without encoding
-content = Path(file).read_text()
-
-# Wrong - encoding on json.dump (not open!)
-json.dump(data, f, encoding="utf-8")  # ERROR
-```
-
-**Binary files - NO encoding:**
-
-```python
-with open(path, "rb") as f:  # Correct
-    data = f.read()
-```
-
-Our pre-commit hooks automatically check for missing encoding parameters. See [PR #782](https://github.com/AndyMik90/Auto-Claude/pull/782) for the comprehensive encoding fix and [guides/windows-development.md](guides/windows-development.md) for Windows-specific development guidance.
-
 ## Testing

 ### Python Tests
@@ -456,6 +429,7 @@ All pull requests and pushes to `main` trigger automated CI checks via GitHub Ac
 |----------|---------|----------------|
 | **CI** | Push to `main`, PRs | Python tests (3.11 & 3.12), Frontend tests |
 | **Lint** | Push to `main`, PRs | Ruff (Python), ESLint + TypeScript (Frontend) |
+| **Test on Tag** | Version tags (`v*`) | Full test suite before release |

 ### PR Requirements

@@ -486,72 +460,6 @@ npm run typecheck

 We use a **Git Flow** branching strategy to manage releases and parallel development.

-### Working with Forks
-
-When contributing to Auto Claude, you'll typically fork the repository first. Proper fork configuration is essential to avoid sync issues.
-
-#### Initial Fork Setup
-
-```bash
-# 1. Fork on GitHub (click the Fork button on the repo page)
-
-# 2. Clone YOUR fork (not the original repo)
-git clone https://github.com/YOUR-USERNAME/Auto-Claude.git
-cd Auto-Claude
-
-# 3. Verify your remotes point to YOUR fork
-git remote -v
-# Should show:
-# origin  https://github.com/YOUR-USERNAME/Auto-Claude.git (fetch)
-# origin  https://github.com/YOUR-USERNAME/Auto-Claude.git (push)
-
-# 4. Add upstream remote to sync with the original repo
-git remote add upstream https://github.com/AndyMik90/Auto-Claude.git
-```
-
-#### Keeping Your Fork Updated
-
-```bash
-# Fetch latest changes from upstream
-git fetch upstream
-
-# Sync your develop branch with upstream
-git checkout develop
-git merge upstream/develop
-git push origin develop
-```
-
-#### Converting a Fork to Standalone
-
-> ⚠️ **Common Issue:** After making a fork standalone (e.g., disconnecting from the original repo on GitHub), your local git configuration may still reference the original forked repository, causing push/pull issues.
-
-If you convert your fork to a standalone repository:
-
-```bash
-# 1. Update origin to point to your standalone repo
-git remote set-url origin https://github.com/YOUR-USERNAME/Your-Standalone-Repo.git
-
-# 2. Remove the upstream remote (no longer applicable)
-git remote remove upstream
-
-# 3. Verify your configuration
-git remote -v
-# Should only show your standalone repo as origin
-
-# 4. Update your default branch tracking if needed
-git branch --set-upstream-to=origin/main main
-git branch --set-upstream-to=origin/develop develop
-```
-
-#### Troubleshooting Fork Issues
-
-| Problem | Cause | Solution |
-|---------|-------|----------|
-| `Permission denied` on push | Origin points to upstream repo | `git remote set-url origin <your-fork-url>` |
-| `Repository not found` | Fork was deleted or made standalone | Update remote URL to current repo location |
-| Can't push to develop | Local branch tracks wrong remote | `git branch --set-upstream-to=origin/develop` |
-| Commits show wrong author | Git config not set | `git config user.email "you@example.com"` |
-
 ### Branch Overview

 ```
@@ -8,7 +8,6 @@
 [![Discord](https://img.shields.io/badge/Discord-Join%20Community-5865F2?style=flat-square&logo=discord&logoColor=white)](https://discord.gg/KCXaPBr4Dj)
 [![YouTube](https://img.shields.io/badge/YouTube-Subscribe-FF0000?style=flat-square&logo=youtube&logoColor=white)](https://www.youtube.com/@AndreMikalsen)
 [![CI](https://img.shields.io/github/actions/workflow/status/AndyMik90/Auto-Claude/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/AndyMik90/Auto-Claude/actions)
-[![Mentioned in Awesome Claude Code](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/hesreallyhim/awesome-claude-code)

 ---

@@ -17,18 +16,17 @@
 ### Stable Release

 <!-- STABLE_VERSION_BADGE -->
-[![Stable](https://img.shields.io/badge/stable-2.7.6-blue?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.6)
+[![Stable](https://img.shields.io/badge/stable-2.7.3-blue?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.3)
 <!-- STABLE_VERSION_BADGE_END -->

 <!-- STABLE_DOWNLOADS -->
 | Platform | Download |
 |----------|----------|
-| **Windows** | [Auto-Claude-2.7.6-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-win32-x64.exe) |
-| **macOS (Apple Silicon)** | [Auto-Claude-2.7.6-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-darwin-arm64.dmg) |
-| **macOS (Intel)** | [Auto-Claude-2.7.6-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-darwin-x64.dmg) |
-| **Linux** | [Auto-Claude-2.7.6-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-linux-x86_64.AppImage) |
-| **Linux (Debian)** | [Auto-Claude-2.7.6-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-linux-amd64.deb) |
-| **Linux (Flatpak)** | [Auto-Claude-2.7.6-linux-x86_64.flatpak](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6/Auto-Claude-2.7.6-linux-x86_64.flatpak) |
+| **Windows** | [Auto-Claude-2.7.2-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2/Auto-Claude-2.7.2-win32-x64.exe) |
+| **macOS (Apple Silicon)** | [Auto-Claude-2.7.2-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2/Auto-Claude-2.7.2-darwin-arm64.dmg) |
+| **macOS (Intel)** | [Auto-Claude-2.7.2-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2/Auto-Claude-2.7.2-darwin-x64.dmg) |
+| **Linux** | [Auto-Claude-2.7.2-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2/Auto-Claude-2.7.2-linux-x86_64.AppImage) |
+| **Linux (Debian)** | [Auto-Claude-2.7.2-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2/Auto-Claude-2.7.2-linux-amd64.deb) |
 <!-- STABLE_DOWNLOADS_END -->

 ### Beta Release
@@ -36,18 +34,18 @@
 > ⚠️ Beta releases may contain bugs and breaking changes. [View all releases](https://github.com/AndyMik90/Auto-Claude/releases)

 <!-- BETA_VERSION_BADGE -->
-[![Beta](https://img.shields.io/badge/beta-2.7.6--beta.6-orange?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.6-beta.6)
+[![Beta](https://img.shields.io/badge/beta-2.7.2--beta.10-orange?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.2-beta.10)
 <!-- BETA_VERSION_BADGE_END -->

 <!-- BETA_DOWNLOADS -->
 | Platform | Download |
 |----------|----------|
-| **Windows** | [Auto-Claude-2.7.6-beta.6-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-win32-x64.exe) |
-| **macOS (Apple Silicon)** | [Auto-Claude-2.7.6-beta.6-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-darwin-arm64.dmg) |
-| **macOS (Intel)** | [Auto-Claude-2.7.6-beta.6-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-darwin-x64.dmg) |
-| **Linux** | [Auto-Claude-2.7.6-beta.6-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-linux-x86_64.AppImage) |
-| **Linux (Debian)** | [Auto-Claude-2.7.6-beta.6-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-linux-amd64.deb) |
-| **Linux (Flatpak)** | [Auto-Claude-2.7.6-beta.6-linux-x86_64.flatpak](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.6/Auto-Claude-2.7.6-beta.6-linux-x86_64.flatpak) |
+| **Windows** | [Auto-Claude-2.7.2-beta.10-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-win32-x64.exe) |
+| **macOS (Apple Silicon)** | [Auto-Claude-2.7.2-beta.10-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-darwin-arm64.dmg) |
+| **macOS (Intel)** | [Auto-Claude-2.7.2-beta.10-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-darwin-x64.dmg) |
+| **Linux** | [Auto-Claude-2.7.2-beta.10-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-x86_64.AppImage) |
+| **Linux (Debian)** | [Auto-Claude-2.7.2-beta.10-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-amd64.deb) |
+| **Linux (Flatpak)** | [Auto-Claude-2.7.2-beta.10-linux-x86_64.flatpak](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-x86_64.flatpak) |
 <!-- BETA_DOWNLOADS_END -->

 > All releases include SHA256 checksums and VirusTotal scan results for security verification.
@@ -186,6 +186,7 @@ The release workflow **validates** that `CHANGELOG.md` has an entry for the vers
 |----------|---------|---------|
 | `prepare-release.yml` | Push to `main` | Detects version bump, **validates CHANGELOG.md**, creates tag |
 | `release.yml` | Tag `v*` pushed | Builds binaries, extracts changelog, creates release |
+| `validate-version.yml` | Tag `v*` pushed | Validates tag matches package.json |
 | `update-readme` (in release.yml) | After release | Updates README with new version |

 ## Troubleshooting
@@ -32,8 +32,8 @@
 # API_TIMEOUT_MS=600000

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


 # =============================================================================
@@ -269,9 +269,9 @@ GRAPHITI_ENABLED=true
 # OpenRouter Base URL (default: https://openrouter.ai/api/v1)
 # OPENROUTER_BASE_URL=https://openrouter.ai/api/v1

-# OpenRouter LLM Model (default: anthropic/claude-sonnet-4)
-# Popular choices: anthropic/claude-sonnet-4, openai/gpt-4o, google/gemini-2.0-flash
-# OPENROUTER_LLM_MODEL=anthropic/claude-sonnet-4
+# OpenRouter LLM Model (default: anthropic/claude-3.5-sonnet)
+# Popular choices: anthropic/claude-3.5-sonnet, openai/gpt-4o, google/gemini-2.0-flash
+# OPENROUTER_LLM_MODEL=anthropic/claude-3.5-sonnet

 # OpenRouter Embedding Model (default: openai/text-embedding-3-small)
 # OPENROUTER_EMBEDDING_MODEL=openai/text-embedding-3-small
@@ -368,5 +368,5 @@ GRAPHITI_ENABLED=true
 # GRAPHITI_LLM_PROVIDER=openrouter
 # GRAPHITI_EMBEDDER_PROVIDER=openrouter
 # OPENROUTER_API_KEY=sk-or-xxxxxxxx
-# OPENROUTER_LLM_MODEL=anthropic/claude-sonnet-4
+# OPENROUTER_LLM_MODEL=anthropic/claude-3.5-sonnet
 # OPENROUTER_EMBEDDING_MODEL=openai/text-embedding-3-small
@@ -62,14 +62,5 @@ Thumbs.db
 # Tests (development only)
 tests/

-# Exception: Allow colocated tests within integrations/graphiti
-!integrations/graphiti/tests/
-
 # Auto Claude data directory
 .auto-claude/
-
-# Auto Claude generated files
-.auto-claude-security.json
-.auto-claude-status
-.security-key
-logs/security/
@@ -17,14 +17,12 @@ python -m pip install -r requirements.txt
 cp .env.example .env
 ```

-Authenticate with Claude Code (token auto-saved to Keychain):
-```bash
-claude
-# Type: /login
-# Press Enter to open browser
+Set your Claude API token in `.env`:
+```
+CLAUDE_CODE_OAUTH_TOKEN=your-token-here
 ```

-Token is auto-detected from macOS Keychain / Windows Credential Manager.
+Get your token by running: `claude setup-token`

 ### 3. Run

@@ -19,5 +19,5 @@ Quick Start:
 See README.md for full documentation.
 """

-__version__ = "2.7.6"
+__version__ = "2.7.3"
 __author__ = "Auto Claude Team"
@@ -6,7 +6,6 @@ Shared imports, types, and constants used across agent modules.
 """

 import logging
-import re

 # Configure logging
 logger = logging.getLogger(__name__)
@@ -14,86 +13,3 @@ logger = logging.getLogger(__name__)
 # Configuration constants
 AUTO_CONTINUE_DELAY_SECONDS = 3
 HUMAN_INTERVENTION_FILE = "PAUSE"
-
-# Retry configuration for subtask execution
-MAX_SUBTASK_RETRIES = 5  # Maximum attempts before marking subtask as stuck
-
-# Retry configuration for 400 tool concurrency errors
-MAX_CONCURRENCY_RETRIES = 5  # Maximum number of retries for tool concurrency errors
-INITIAL_RETRY_DELAY_SECONDS = (
-    2  # Initial retry delay (doubles each retry: 2s, 4s, 8s, 16s, 32s)
-)
-MAX_RETRY_DELAY_SECONDS = 32  # Cap retry delay at 32 seconds
-
-# Pause file constants for intelligent error recovery
-# These files signal pause/resume between frontend and backend
-RATE_LIMIT_PAUSE_FILE = "RATE_LIMIT_PAUSE"  # Created when rate limited
-AUTH_FAILURE_PAUSE_FILE = "AUTH_PAUSE"  # Created when auth fails
-RESUME_FILE = "RESUME"  # Created by frontend to signal resume
-
-# Maximum time to wait for rate limit reset (2 hours)
-# If reset time is beyond this, task should fail rather than wait indefinitely
-MAX_RATE_LIMIT_WAIT_SECONDS = 7200
-
-# Wait intervals for pause/resume checking
-RATE_LIMIT_CHECK_INTERVAL_SECONDS = (
-    30  # Check for RESUME file every 30 seconds during rate limit wait
-)
-AUTH_RESUME_CHECK_INTERVAL_SECONDS = 10  # Check for re-authentication every 10 seconds
-AUTH_RESUME_MAX_WAIT_SECONDS = 86400  # Maximum wait for re-authentication (24 hours)
-
-
-def sanitize_error_message(error_message: str, max_length: int = 500) -> str:
-    """
-    Sanitize error messages to remove potentially sensitive information.
-
-    Redacts:
-    - API keys (sk-..., key-...)
-    - Bearer tokens
-    - Token/secret values
-
-    Args:
-        error_message: The raw error message to sanitize
-        max_length: Maximum length to truncate to (default 500)
-
-    Returns:
-        Sanitized and truncated error message
-    """
-    if not error_message:
-        return ""
-
-    # Redact patterns that look like API keys or tokens
-    # Pattern: sk-... (OpenAI/Anthropic keys like sk-ant-api03-...)
-    sanitized = re.sub(
-        r"\bsk-[a-zA-Z0-9._\-]{20,}\b", "[REDACTED_API_KEY]", error_message
-    )
-
-    # Pattern: key-... (generic API keys)
-    sanitized = re.sub(r"\bkey-[a-zA-Z0-9._\-]{20,}\b", "[REDACTED_API_KEY]", sanitized)
-
-    # Pattern: Bearer ... (bearer tokens)
-    sanitized = re.sub(
-        r"\bBearer\s+[a-zA-Z0-9._\-]{20,}\b", "Bearer [REDACTED_TOKEN]", sanitized
-    )
-
-    # Pattern: token= or token: followed by long strings
-    sanitized = re.sub(
-        r"(token[=:]\s*)[a-zA-Z0-9._\-]{20,}\b",
-        r"\1[REDACTED_TOKEN]",
-        sanitized,
-        flags=re.IGNORECASE,
-    )
-
-    # Pattern: secret= or secret: followed by strings
-    sanitized = re.sub(
-        r"(secret[=:]\s*)[a-zA-Z0-9._\-]{20,}\b",
-        r"\1[REDACTED_SECRET]",
-        sanitized,
-        flags=re.IGNORECASE,
-    )
-
-    # Truncate to max length
-    if len(sanitized) > max_length:
-        sanitized = sanitized[:max_length] + "..."
-
-    return sanitized
@@ -10,7 +10,6 @@ Handles session memory storage using dual-layer approach:
 import logging
 from pathlib import Path

-from core.sentry import capture_exception
 from debug import (
    debug,
    debug_detailed,
@@ -117,15 +116,12 @@ async def get_graphiti_context(

    memory = None
    try:
-        # Use centralized helper for GraphitiMemory instantiation (async)
-        memory = await get_graphiti_memory(spec_dir, project_dir)
+        # Use centralized helper for GraphitiMemory instantiation
+        memory = get_graphiti_memory(spec_dir, project_dir)
        if memory is None:
            if is_debug_enabled():
-                debug_warning(
-                    "memory", "GraphitiMemory not available for context retrieval"
-                )
+                debug_warning("memory", "GraphitiMemory not available")
            return None
-
        # Build search query from subtask description
        subtask_desc = subtask.get("description", "")
        subtask_id = subtask.get("id", "")
@@ -232,15 +228,6 @@ async def get_graphiti_context(
        logger.warning(f"Failed to get Graphiti context: {e}")
        if is_debug_enabled():
            debug_error("memory", "Graphiti context retrieval failed", error=str(e))
-        # Capture exception to Sentry with full context
-        capture_exception(
-            e,
-            operation="get_graphiti_context",
-            subtask_id=subtask.get("id", "unknown"),
-            subtask_desc=subtask.get("description", "")[:200],
-            spec_dir=str(spec_dir),
-            project_dir=str(project_dir),
-        )
        return None
    finally:
        # Always close the memory connection (swallow exceptions to avoid overriding)
@@ -337,16 +324,21 @@ async def save_session_memory(

        memory = None
        try:
-            # Use centralized helper for GraphitiMemory instantiation (async)
-            memory = await get_graphiti_memory(spec_dir, project_dir)
+            # Use centralized helper for GraphitiMemory instantiation
+            memory = get_graphiti_memory(spec_dir, project_dir)
            if memory is None:
                if is_debug_enabled():
                    debug_warning("memory", "GraphitiMemory not available")
-                    debug(
-                        "memory",
-                        "get_graphiti_memory() returned None - this usually means Graphiti is disabled or provider config is invalid",
-                    )
                # Continue to file-based fallback
+            else:
+                if is_debug_enabled():
+                    debug_detailed(
+                        "memory",
+                        "GraphitiMemory instance created",
+                        is_enabled=memory.is_enabled,
+                        group_id=getattr(memory, "group_id", "unknown"),
+                    )
+
            if memory is not None and memory.is_enabled:
                if is_debug_enabled():
                    debug("memory", "Saving to Graphiti...")
@@ -401,17 +393,6 @@ async def save_session_memory(
            logger.warning(f"Graphiti save failed: {e}, falling back to file-based")
            if is_debug_enabled():
                debug_error("memory", "Graphiti save failed", error=str(e))
-            # Capture exception to Sentry with full context
-            capture_exception(
-                e,
-                operation="save_session_memory_graphiti",
-                subtask_id=subtask_id,
-                session_num=session_num,
-                success=success,
-                subtasks_completed=subtasks_completed,
-                spec_dir=str(spec_dir),
-                project_dir=str(project_dir),
-            )
        finally:
            # Always close the memory connection (swallow exceptions to avoid overriding)
            if memory is not None:
@@ -457,17 +438,6 @@ async def save_session_memory(
        logger.error(f"File-based memory save also failed: {e}")
        if is_debug_enabled():
            debug_error("memory", "File-based memory save FAILED", error=str(e))
-        # Capture exception to Sentry with full context
-        capture_exception(
-            e,
-            operation="save_session_memory_file",
-            subtask_id=subtask_id,
-            session_num=session_num,
-            success=success,
-            subtasks_completed=subtasks_completed,
-            spec_dir=str(spec_dir),
-            project_dir=str(project_dir),
-        )
        return False, "none"


@@ -1,198 +1,183 @@
-"""
-Planner Agent Module
-====================
-
-Handles follow-up planner sessions for adding new subtasks to completed specs.
-"""
-
-import logging
-from pathlib import Path
-
-from core.client import create_client
-from phase_config import (
-    get_fast_mode,
-    get_phase_client_thinking_kwargs,
-    get_phase_model,
-    get_phase_model_betas,
-)
-from phase_event import ExecutionPhase, emit_phase
-from task_logger import (
-    LogPhase,
-    get_task_logger,
-)
-from ui import (
-    BuildState,
-    Icons,
-    StatusManager,
-    bold,
-    box,
-    highlight,
-    icon,
-    muted,
-    print_status,
-)
-
-from .session import run_agent_session
-
-logger = logging.getLogger(__name__)
-
-
-async def run_followup_planner(
-    project_dir: Path,
-    spec_dir: Path,
-    model: str,
-    verbose: bool = False,
-) -> bool:
-    """
-    Run the follow-up planner to add new subtasks to a completed spec.
-
-    This is a simplified version of run_autonomous_agent that:
-    1. Creates a client
-    2. Loads the followup planner prompt
-    3. Runs a single planning session
-    4. Returns after the plan is updated (doesn't enter coding loop)
-
-    The planner agent will:
-    - Read FOLLOWUP_REQUEST.md for the new task
-    - Read the existing implementation_plan.json
-    - Add new phase(s) with pending subtasks
-    - Update the plan status back to in_progress
-
-    Args:
-        project_dir: Root directory for the project
-        spec_dir: Directory containing the completed spec
-        model: Claude model to use
-        verbose: Whether to show detailed output
-
-    Returns:
-        bool: True if planning completed successfully
-    """
-    from implementation_plan import ImplementationPlan
-    from prompts import get_followup_planner_prompt
-
-    # Initialize status manager for ccstatusline
-    status_manager = StatusManager(project_dir)
-    status_manager.set_active(spec_dir.name, BuildState.PLANNING)
-    emit_phase(ExecutionPhase.PLANNING, "Follow-up planning")
-
-    # Initialize task logger for persistent logging
-    task_logger = get_task_logger(spec_dir)
-
-    # Show header
-    content = [
-        bold(f"{icon(Icons.GEAR)} FOLLOW-UP PLANNER SESSION"),
-        "",
-        f"Spec: {highlight(spec_dir.name)}",
-        muted("Adding follow-up work to completed spec."),
-        "",
-        muted("The agent will read your FOLLOWUP_REQUEST.md and add new subtasks."),
-    ]
-    print()
-    print(box(content, width=70, style="heavy"))
-    print()
-
-    # Start planning phase in task logger
-    if task_logger:
-        task_logger.start_phase(LogPhase.PLANNING, "Starting follow-up planning...")
-        task_logger.set_session(1)
-
-    # Create client with phase-specific model and thinking budget
-    # Respects task_metadata.json configuration when no CLI override
-    planning_model = get_phase_model(spec_dir, "planning", model)
-    planning_betas = get_phase_model_betas(spec_dir, "planning", model)
-    thinking_kwargs = get_phase_client_thinking_kwargs(
-        spec_dir, "planning", planning_model
-    )
-    fast_mode = get_fast_mode(spec_dir)
-    logger.info(
-        f"[Planner] [Fast Mode] {'ENABLED' if fast_mode else 'disabled'} for follow-up planning"
-    )
-    client = create_client(
-        project_dir,
-        spec_dir,
-        planning_model,
-        agent_type="planner",
-        betas=planning_betas,
-        fast_mode=fast_mode,
-        **thinking_kwargs,
-    )
-
-    # Generate follow-up planner prompt
-    prompt = get_followup_planner_prompt(spec_dir)
-
-    print_status("Running follow-up planner...", "progress")
-    print()
-
-    try:
-        # Run single planning session
-        async with client:
-            status, response, error_info = await run_agent_session(
-                client, prompt, spec_dir, verbose, phase=LogPhase.PLANNING
-            )
-
-        # End planning phase in task logger
-        if task_logger:
-            task_logger.end_phase(
-                LogPhase.PLANNING,
-                success=(status != "error"),
-                message="Follow-up planning session completed",
-            )
-
-        if status == "error":
-            print()
-            print_status("Follow-up planning failed", "error")
-            status_manager.update(state=BuildState.ERROR)
-            return False
-
-        # Verify the plan was updated (should have pending subtasks now)
-        plan_file = spec_dir / "implementation_plan.json"
-        if plan_file.exists():
-            plan = ImplementationPlan.load(plan_file)
-
-            # Check if there are any pending subtasks
-            all_subtasks = [c for p in plan.phases for c in p.subtasks]
-            pending_subtasks = [c for c in all_subtasks if c.status.value == "pending"]
-
-            if pending_subtasks:
-                # Reset the plan status to in_progress (in case planner didn't)
-                plan.reset_for_followup()
-                await plan.async_save(plan_file)
-
-                print()
-                content = [
-                    bold(f"{icon(Icons.SUCCESS)} FOLLOW-UP PLANNING COMPLETE"),
-                    "",
-                    f"New pending subtasks: {highlight(str(len(pending_subtasks)))}",
-                    f"Total subtasks: {len(all_subtasks)}",
-                    "",
-                    muted("Next steps:"),
-                    f"  Run: {highlight(f'python auto-claude/run.py --spec {spec_dir.name}')}",
-                ]
-                print(box(content, width=70, style="heavy"))
-                print()
-                status_manager.update(state=BuildState.PAUSED)
-                return True
-            else:
-                print()
-                print_status(
-                    "Warning: No pending subtasks found after planning", "warning"
-                )
-                print(muted("The planner may not have added new subtasks."))
-                print(muted("Check implementation_plan.json manually."))
-                status_manager.update(state=BuildState.PAUSED)
-                return False
-        else:
-            print()
-            print_status(
-                "Error: implementation_plan.json not found after planning", "error"
-            )
-            status_manager.update(state=BuildState.ERROR)
-            return False
-
-    except Exception as e:
-        print()
-        print_status(f"Follow-up planning error: {e}", "error")
-        if task_logger:
-            task_logger.log_error(f"Follow-up planning error: {e}", LogPhase.PLANNING)
-        status_manager.update(state=BuildState.ERROR)
-        return False
+"""
+Planner Agent Module
+====================
+
+Handles follow-up planner sessions for adding new subtasks to completed specs.
+"""
+
+import logging
+from pathlib import Path
+
+from core.client import create_client
+from phase_config import get_phase_model, get_phase_thinking_budget
+from phase_event import ExecutionPhase, emit_phase
+from task_logger import (
+    LogPhase,
+    get_task_logger,
+)
+from ui import (
+    BuildState,
+    Icons,
+    StatusManager,
+    bold,
+    box,
+    highlight,
+    icon,
+    muted,
+    print_status,
+)
+
+from .session import run_agent_session
+
+logger = logging.getLogger(__name__)
+
+
+async def run_followup_planner(
+    project_dir: Path,
+    spec_dir: Path,
+    model: str,
+    verbose: bool = False,
+) -> bool:
+    """
+    Run the follow-up planner to add new subtasks to a completed spec.
+
+    This is a simplified version of run_autonomous_agent that:
+    1. Creates a client
+    2. Loads the followup planner prompt
+    3. Runs a single planning session
+    4. Returns after the plan is updated (doesn't enter coding loop)
+
+    The planner agent will:
+    - Read FOLLOWUP_REQUEST.md for the new task
+    - Read the existing implementation_plan.json
+    - Add new phase(s) with pending subtasks
+    - Update the plan status back to in_progress
+
+    Args:
+        project_dir: Root directory for the project
+        spec_dir: Directory containing the completed spec
+        model: Claude model to use
+        verbose: Whether to show detailed output
+
+    Returns:
+        bool: True if planning completed successfully
+    """
+    from implementation_plan import ImplementationPlan
+    from prompts import get_followup_planner_prompt
+
+    # Initialize status manager for ccstatusline
+    status_manager = StatusManager(project_dir)
+    status_manager.set_active(spec_dir.name, BuildState.PLANNING)
+    emit_phase(ExecutionPhase.PLANNING, "Follow-up planning")
+
+    # Initialize task logger for persistent logging
+    task_logger = get_task_logger(spec_dir)
+
+    # Show header
+    content = [
+        bold(f"{icon(Icons.GEAR)} FOLLOW-UP PLANNER SESSION"),
+        "",
+        f"Spec: {highlight(spec_dir.name)}",
+        muted("Adding follow-up work to completed spec."),
+        "",
+        muted("The agent will read your FOLLOWUP_REQUEST.md and add new subtasks."),
+    ]
+    print()
+    print(box(content, width=70, style="heavy"))
+    print()
+
+    # Start planning phase in task logger
+    if task_logger:
+        task_logger.start_phase(LogPhase.PLANNING, "Starting follow-up planning...")
+        task_logger.set_session(1)
+
+    # Create client with phase-specific model and thinking budget
+    # Respects task_metadata.json configuration when no CLI override
+    planning_model = get_phase_model(spec_dir, "planning", model)
+    planning_thinking_budget = get_phase_thinking_budget(spec_dir, "planning")
+    client = create_client(
+        project_dir,
+        spec_dir,
+        planning_model,
+        max_thinking_tokens=planning_thinking_budget,
+    )
+
+    # Generate follow-up planner prompt
+    prompt = get_followup_planner_prompt(spec_dir)
+
+    print_status("Running follow-up planner...", "progress")
+    print()
+
+    try:
+        # Run single planning session
+        async with client:
+            status, response = await run_agent_session(
+                client, prompt, spec_dir, verbose, phase=LogPhase.PLANNING
+            )
+
+        # End planning phase in task logger
+        if task_logger:
+            task_logger.end_phase(
+                LogPhase.PLANNING,
+                success=(status != "error"),
+                message="Follow-up planning session completed",
+            )
+
+        if status == "error":
+            print()
+            print_status("Follow-up planning failed", "error")
+            status_manager.update(state=BuildState.ERROR)
+            return False
+
+        # Verify the plan was updated (should have pending subtasks now)
+        plan_file = spec_dir / "implementation_plan.json"
+        if plan_file.exists():
+            plan = ImplementationPlan.load(plan_file)
+
+            # Check if there are any pending subtasks
+            all_subtasks = [c for p in plan.phases for c in p.subtasks]
+            pending_subtasks = [c for c in all_subtasks if c.status.value == "pending"]
+
+            if pending_subtasks:
+                # Reset the plan status to in_progress (in case planner didn't)
+                plan.reset_for_followup()
+                await plan.async_save(plan_file)
+
+                print()
+                content = [
+                    bold(f"{icon(Icons.SUCCESS)} FOLLOW-UP PLANNING COMPLETE"),
+                    "",
+                    f"New pending subtasks: {highlight(str(len(pending_subtasks)))}",
+                    f"Total subtasks: {len(all_subtasks)}",
+                    "",
+                    muted("Next steps:"),
+                    f"  Run: {highlight(f'python auto-claude/run.py --spec {spec_dir.name}')}",
+                ]
+                print(box(content, width=70, style="heavy"))
+                print()
+                status_manager.update(state=BuildState.PAUSED)
+                return True
+            else:
+                print()
+                print_status(
+                    "Warning: No pending subtasks found after planning", "warning"
+                )
+                print(muted("The planner may not have added new subtasks."))
+                print(muted("Check implementation_plan.json manually."))
+                status_manager.update(state=BuildState.PAUSED)
+                return False
+        else:
+            print()
+            print_status(
+                "Error: implementation_plan.json not found after planning", "error"
+            )
+            status_manager.update(state=BuildState.ERROR)
+            return False
+
+    except Exception as e:
+        print()
+        print_status(f"Follow-up planning error: {e}", "error")
+        if task_logger:
+            task_logger.log_error(f"Follow-up planning error: {e}", LogPhase.PLANNING)
+        status_manager.update(state=BuildState.ERROR)
+        return False
@@ -1,347 +0,0 @@
-"""
-PR Template Filler Agent Module
-================================
-
-Detects GitHub PR templates in a project and uses Claude to intelligently
-fill them based on code changes, spec context, commit history, and branch info.
-"""
-
-import logging
-from pathlib import Path
-
-from core.client import create_client
-from task_logger import LogPhase, get_task_logger
-
-from .session import run_agent_session
-
-logger = logging.getLogger(__name__)
-
-# Maximum diff size (in characters) before truncating to file-level summaries
-MAX_DIFF_CHARS = 30_000
-
-
-def detect_pr_template(project_dir: Path | str) -> str | None:
-    """
-    Detect a GitHub PR template in the project.
-
-    Searches for:
-    1. .github/PULL_REQUEST_TEMPLATE.md (single template)
-    2. .github/PULL_REQUEST_TEMPLATE/ directory (picks the first .md file)
-
-    Args:
-        project_dir: Root directory of the project
-
-    Returns:
-        The template content as a string, or None if no template is found.
-    """
-    project_dir = Path(project_dir)
-    # Check for single template file
-    single_template = project_dir / ".github" / "PULL_REQUEST_TEMPLATE.md"
-    if single_template.is_file():
-        try:
-            content = single_template.read_text(encoding="utf-8")
-            if content.strip():
-                logger.info(f"Found PR template: {single_template}")
-                return content
-        except Exception as e:
-            logger.warning(f"Failed to read PR template {single_template}: {e}")
-
-    # Check for template directory (pick first .md file alphabetically)
-    template_dir = project_dir / ".github" / "PULL_REQUEST_TEMPLATE"
-    if template_dir.is_dir():
-        try:
-            md_files = sorted(template_dir.glob("*.md"))
-            if md_files:
-                content = md_files[0].read_text(encoding="utf-8")
-                if content.strip():
-                    logger.info(f"Found PR template: {md_files[0]}")
-                    return content
-        except Exception as e:
-            logger.warning(f"Failed to read PR template from {template_dir}: {e}")
-
-    logger.info("No GitHub PR template found in project")
-    return None
-
-
-def _truncate_diff(diff_summary: str) -> str:
-    """
-    Truncate a large diff to file-level summaries to stay within token limits.
-
-    If the diff is within MAX_DIFF_CHARS, return it unchanged.
-    Otherwise, extract only file-level change summaries (e.g. file names
-    with insertions/deletions counts) and discard line-level detail.
-
-    Args:
-        diff_summary: The full diff summary text
-
-    Returns:
-        The original or truncated diff summary.
-    """
-    if len(diff_summary) <= MAX_DIFF_CHARS:
-        return diff_summary
-
-    lines = diff_summary.splitlines()
-    summary_lines: list[str] = []
-    summary_lines.append("(Diff truncated to file-level summaries due to size)")
-    summary_lines.append("")
-
-    for line in lines:
-        # Keep file-level summary lines (stat lines, file headers, etc.)
-        stripped = line.strip()
-        if (
-            stripped.startswith("diff --git")
-            or stripped.startswith("---")
-            or stripped.startswith("+++")
-            or "file changed" in stripped.lower()
-            or "files changed" in stripped.lower()
-            or "insertion" in stripped.lower()
-            or "deletion" in stripped.lower()
-            or stripped.startswith("rename")
-            or stripped.startswith("new file")
-            or stripped.startswith("deleted file")
-            or stripped.startswith("Binary files")
-        ):
-            summary_lines.append(line)
-
-    # If we couldn't extract meaningful summaries, take the first chunk
-    if len(summary_lines) <= 2:
-        truncated = diff_summary[:MAX_DIFF_CHARS]
-        return truncated + "\n\n(... diff truncated due to size)"
-
-    return "\n".join(summary_lines)
-
-
-def _strip_markdown_fences(content: str) -> str:
-    """
-    Strip markdown code fences from the response if present.
-
-    The AI sometimes wraps the output in ```markdown ... ``` even when instructed
-    not to. This ensures the PR body renders correctly on GitHub.
-
-    Args:
-        content: The response content to clean
-
-    Returns:
-        The content with markdown fences stripped.
-    """
-    result = content
-
-    # Strip opening fence (```markdown or just ```)
-    if result.startswith("```markdown"):
-        result = result[len("```markdown") :].lstrip("\n")
-    elif result.startswith("```md"):
-        result = result[len("```md") :].lstrip("\n")
-    elif result.startswith("```"):
-        result = result[3:].lstrip("\n")
-
-    # Strip closing fence
-    if result.endswith("```"):
-        result = result[:-3].rstrip("\n")
-
-    return result.strip()
-
-
-def _build_prompt(
-    template_content: str,
-    diff_summary: str,
-    spec_overview: str,
-    commit_log: str,
-    branch_name: str,
-    target_branch: str,
-) -> str:
-    """
-    Build the prompt for the PR template filler agent.
-
-    Combines the system prompt context variables into a single message
-    that includes the template and all change context.
-
-    Args:
-        template_content: The PR template markdown
-        diff_summary: Git diff summary (possibly truncated)
-        spec_overview: Spec.md content or summary
-        commit_log: Git log of commits in the PR
-        branch_name: Source branch name
-        target_branch: Target branch name
-
-    Returns:
-        The assembled prompt string.
-    """
-    return f"""Fill out the following GitHub PR template using the provided context.
-Return ONLY the filled template markdown — no preamble, no explanation, no code fences.
-
-## Checkbox Guidelines
-
-IMPORTANT: Be accurate and honest about what has and hasn't been verified.
-
-**Check these based on context (you can infer from the diff/spec):**
- Base Branch targeting — check based on target_branch value
- Type of Change (bug fix, feature, docs, refactor, test) — infer from diff and spec
- Area (Frontend, Backend, Fullstack) — infer from changed file paths
- Feature Toggle "N/A" — if the feature appears complete and not behind a flag
- Breaking Changes "No" — if changes appear backward compatible
-
-**Leave UNCHECKED (these require human verification you cannot perform):**
- "I've tested my changes locally" — you have not tested anything
- "All CI checks pass" — CI has not run yet
- "Windows/macOS/Linux tested" — requires manual testing on each platform
- "All existing tests pass" — CI has not run yet
- "New features include test coverage" — unless test files are clearly visible in the diff
- "Bug fixes include regression tests" — unless test files are clearly visible in the diff
-
-**For platform/code quality checkboxes:**
- "Used centralized platform/ module" — leave unchecked unless you can verify from the diff
- "No hardcoded paths" — leave unchecked unless you can verify from the diff
- "PR is small and focused (< 400 lines)" — check only if diff stats show < 400 lines changed
-
-**For the "I've synced with develop branch" checkbox:**
- Leave unchecked — you cannot verify the sync status
-
-## PR Template
-
-{template_content}
-
-## Change Context
-
-### Branch Information
- **Source branch:** {branch_name}
- **Target branch:** {target_branch}
-
-### Git Diff Summary
-```
-{diff_summary}
-```
-
-### Spec Overview
-{spec_overview}
-
-### Commit History
-```
-{commit_log}
-```
-
-Fill every section of the PR template. Follow the checkbox guidelines above carefully.
-Output ONLY the completed template — no code fences, no preamble."""
-
-
-def _load_spec_overview(spec_dir: Path) -> str:
-    """
-    Load the spec.md content for context. Falls back to a brief note if unavailable.
-
-    Args:
-        spec_dir: Directory containing the spec files
-
-    Returns:
-        The spec content or a fallback message.
-    """
-    spec_file = spec_dir / "spec.md"
-    if spec_file.is_file():
-        try:
-            content = spec_file.read_text(encoding="utf-8")
-            # Truncate very long specs to keep prompt manageable
-            if len(content) > 8000:
-                return content[:8000] + "\n\n(... spec truncated for brevity)"
-            return content
-        except Exception as e:
-            logger.warning(f"Failed to read spec.md: {e}")
-    return "(No spec overview available)"
-
-
-async def run_pr_template_filler(
-    project_dir: Path,
-    spec_dir: Path,
-    model: str,
-    thinking_budget: int | None = None,
-    branch_name: str = "",
-    target_branch: str = "develop",
-    diff_summary: str = "",
-    commit_log: str = "",
-    verbose: bool = False,
-) -> str | None:
-    """
-    Run the PR template filler agent to generate a filled PR body.
-
-    Detects the project's PR template, gathers change context, and invokes
-    Claude to intelligently fill out the template sections.
-
-    Args:
-        project_dir: Root directory of the project
-        spec_dir: Directory containing the spec files
-        model: Claude model to use
-        thinking_budget: Max thinking tokens (None to disable extended thinking)
-        branch_name: Source branch name for the PR
-        target_branch: Target branch name for the PR
-        diff_summary: Git diff summary of changes
-        commit_log: Git log of commits included in the PR
-        verbose: Whether to show detailed output
-
-    Returns:
-        The filled template markdown string, or None if template detection fails
-        or the agent encounters an error.
-    """
-    # Detect PR template
-    template_content = detect_pr_template(project_dir)
-    if template_content is None:
-        logger.info("No PR template detected — skipping template filler")
-        return None
-
-    # Load spec overview
-    spec_overview = _load_spec_overview(spec_dir)
-
-    # Truncate diff if too large
-    truncated_diff = _truncate_diff(diff_summary)
-
-    # Build the prompt
-    prompt = _build_prompt(
-        template_content=template_content,
-        diff_summary=truncated_diff,
-        spec_overview=spec_overview,
-        commit_log=commit_log,
-        branch_name=branch_name,
-        target_branch=target_branch,
-    )
-
-    # Initialize task logger
-    task_logger = get_task_logger(spec_dir)
-    if task_logger:
-        task_logger.start_phase(LogPhase.CODING, "PR template filling")
-
-    # Create client following the pattern from planner.py
-    client = create_client(
-        project_dir,
-        spec_dir,
-        model,
-        agent_type="pr_template_filler",
-        max_thinking_tokens=thinking_budget,
-    )
-
-    try:
-        async with client:
-            status, response, _ = await run_agent_session(
-                client, prompt, spec_dir, verbose, phase=LogPhase.CODING
-            )
-
-        if task_logger:
-            task_logger.end_phase(
-                LogPhase.CODING,
-                success=(status != "error"),
-                message="PR template filling completed",
-            )
-
-        if status == "error":
-            logger.error("PR template filler agent returned an error")
-            return None
-
-        # The agent should return only the filled template markdown
-        if response and response.strip():
-            result = _strip_markdown_fences(response.strip())
-            logger.info("PR template filled successfully")
-            return result
-
-        logger.warning("PR template filler returned empty response")
-        return None
-
-    except Exception as e:
-        logger.error(f"PR template filler error: {e}")
-        if task_logger:
-            task_logger.log_error(f"PR template filler error: {e}", LogPhase.CODING)
-        return None
@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""
+Verification script for agent module refactoring.
+
+This script verifies that:
+1. All modules can be imported
+2. All public API functions are accessible
+3. Backwards compatibility is maintained
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+def test_imports():
+    """Test that all modules can be imported."""
+    print("Testing module imports...")
+
+    # Test base module
+    from agents import base
+
+    assert hasattr(base, "AUTO_CONTINUE_DELAY_SECONDS")
+    assert hasattr(base, "HUMAN_INTERVENTION_FILE")
+    print("  ✓ agents.base")
+
+    # Test utils module
+    from agents import utils
+
+    assert hasattr(utils, "get_latest_commit")
+    assert hasattr(utils, "load_implementation_plan")
+    print("  ✓ agents.utils")
+
+    # Test memory module
+    from agents import memory
+
+    assert hasattr(memory, "save_session_memory")
+    assert hasattr(memory, "get_graphiti_context")
+    print("  ✓ agents.memory")
+
+    # Test session module
+    from agents import session
+
+    assert hasattr(session, "run_agent_session")
+    assert hasattr(session, "post_session_processing")
+    print("  ✓ agents.session")
+
+    # Test planner module
+    from agents import planner
+
+    assert hasattr(planner, "run_followup_planner")
+    print("  ✓ agents.planner")
+
+    # Test coder module
+    from agents import coder
+
+    assert hasattr(coder, "run_autonomous_agent")
+    print("  ✓ agents.coder")
+
+    print("\n✓ All module imports successful!\n")
+
+
+def test_public_api():
+    """Test that the public API is accessible."""
+    print("Testing public API...")
+
+    # Test main agent module exports
+    import agents
+
+    required_functions = [
+        "run_autonomous_agent",
+        "run_followup_planner",
+        "save_session_memory",
+        "get_graphiti_context",
+        "run_agent_session",
+        "post_session_processing",
+        "get_latest_commit",
+        "load_implementation_plan",
+    ]
+
+    for func_name in required_functions:
+        assert hasattr(agents, func_name), f"Missing function: {func_name}"
+        print(f"  ✓ agents.{func_name}")
+
+    print("\n✓ All public API functions accessible!\n")
+
+
+def test_backwards_compatibility():
+    """Test that the old agent.py facade maintains backwards compatibility."""
+    print("Testing backwards compatibility...")
+
+    # Test that agent.py can be imported
+    import agent
+
+    required_functions = [
+        "run_autonomous_agent",
+        "run_followup_planner",
+        "save_session_memory",
+        "save_session_to_graphiti",
+        "run_agent_session",
+        "post_session_processing",
+    ]
+
+    for func_name in required_functions:
+        assert hasattr(agent, func_name), (
+            f"Missing function in agent module: {func_name}"
+        )
+        print(f"  ✓ agent.{func_name}")
+
+    print("\n✓ Backwards compatibility maintained!\n")
+
+
+def test_module_structure():
+    """Test that the module structure is correct."""
+    print("Testing module structure...")
+
+    from pathlib import Path
+
+    agents_dir = Path(__file__).parent
+
+    required_files = [
+        "__init__.py",
+        "base.py",
+        "utils.py",
+        "memory.py",
+        "session.py",
+        "planner.py",
+        "coder.py",
+    ]
+
+    for filename in required_files:
+        filepath = agents_dir / filename
+        assert filepath.exists(), f"Missing file: {filename}"
+        print(f"  ✓ agents/{filename}")
+
+    print("\n✓ Module structure correct!\n")
+
+
+if __name__ == "__main__":
+    try:
+        test_module_structure()
+        test_imports()
+        test_public_api()
+        test_backwards_compatibility()
+
+        print("=" * 60)
+        print("✓ ALL TESTS PASSED - Refactoring verified!")
+        print("=" * 60)
+
+    except AssertionError as e:
+        print(f"\n✗ TEST FAILED: {e}")
+        sys.exit(1)
+    except ImportError as e:
+        print(f"\n✗ IMPORT ERROR: {e}")
+        print("Note: Some imports may fail due to missing dependencies.")
+        print("This is expected in test environments.")
+        sys.exit(0)  # Don't fail on import errors (expected in test env)
@@ -46,7 +46,7 @@ TOOL_UPDATE_QA_STATUS = "mcp__auto-claude__update_qa_status"
 # Context7 MCP tools for documentation lookup (always enabled)
 CONTEXT7_TOOLS = [
    "mcp__context7__resolve-library-id",
-    "mcp__context7__query-docs",
+    "mcp__context7__get-library-docs",
 ]

 # Linear MCP tools for project management (when LINEAR_API_KEY is set)
@@ -158,7 +158,7 @@ AGENT_CONFIGS = {
        "tools": BASE_READ_TOOLS,
        "mcp_servers": [],  # Self-critique, no external tools
        "auto_claude_tools": [],
-        "thinking_default": "high",
+        "thinking_default": "ultrathink",
    },
    "spec_discovery": {
        "tools": BASE_READ_TOOLS + WEB_TOOLS,
@@ -210,7 +210,7 @@ AGENT_CONFIGS = {
            TOOL_RECORD_GOTCHA,
            TOOL_GET_SESSION_CONTEXT,
        ],
-        "thinking_default": "low",  # Coding uses minimal thinking (effort: low for Opus, 1024 tokens for Sonnet/Haiku)
+        "thinking_default": "none",  # Coding doesn't use extended thinking
    },
    # ═══════════════════════════════════════════════════════════════════════
    # QA PHASES (Read + test + browser + Graphiti memory)
@@ -247,9 +247,7 @@ AGENT_CONFIGS = {
        "tools": BASE_READ_TOOLS + WEB_TOOLS,
        "mcp_servers": [],
        "auto_claude_tools": [],
-        # Note: Default to "low" for minimal thinking overhead
-        # Haiku doesn't support thinking; create_simple_client() handles this
-        "thinking_default": "low",
+        "thinking_default": "medium",
    },
    "merge_resolver": {
        "tools": [],  # Text-only analysis
@@ -263,12 +261,6 @@ AGENT_CONFIGS = {
        "auto_claude_tools": [],
        "thinking_default": "low",
    },
-    "pr_template_filler": {
-        "tools": BASE_READ_TOOLS,  # Read-only — reads diff, template, spec
-        "mcp_servers": [],  # No MCP needed, context passed via prompt
-        "auto_claude_tools": [],
-        "thinking_default": "low",  # Fast utility task for structured fill-in
-    },
    "pr_reviewer": {
        "tools": BASE_READ_TOOLS + WEB_TOOLS,  # Read-only
        "mcp_servers": ["context7"],
@@ -276,38 +268,18 @@ AGENT_CONFIGS = {
        "thinking_default": "high",
    },
    "pr_orchestrator_parallel": {
-        # Read-only for parallel PR orchestrator
-        # NOTE: Do NOT add "Task" here - the SDK auto-allows Task when agents are defined
-        # via the --agents flag. Explicitly adding it interferes with agent registration.
-        "tools": BASE_READ_TOOLS + WEB_TOOLS,
+        "tools": BASE_READ_TOOLS + WEB_TOOLS,  # Read-only for parallel PR orchestrator
        "mcp_servers": ["context7"],
        "auto_claude_tools": [],
        "thinking_default": "high",
    },
    "pr_followup_parallel": {
-        # Read-only for parallel followup reviewer
-        # NOTE: Do NOT add "Task" here - same reason as pr_orchestrator_parallel
-        "tools": BASE_READ_TOOLS + WEB_TOOLS,
+        "tools": BASE_READ_TOOLS
+        + WEB_TOOLS,  # Read-only for parallel followup reviewer
        "mcp_servers": ["context7"],
        "auto_claude_tools": [],
        "thinking_default": "high",
    },
-    "pr_followup_extraction": {
-        # Lightweight extraction call for recovering data when structured output fails
-        # Pure structured output extraction, no tools needed
-        "tools": [],
-        "mcp_servers": [],
-        "auto_claude_tools": [],
-        "thinking_default": "low",
-    },
-    "pr_finding_validator": {
-        # Standalone validator for re-checking findings against actual code
-        # Called separately from orchestrator to validate findings with fresh context
-        "tools": BASE_READ_TOOLS,
-        "mcp_servers": [],
-        "auto_claude_tools": [],
-        "thinking_default": "medium",
-    },
    # ═══════════════════════════════════════════════════════════════════════
    # ANALYSIS PHASES
    # ═══════════════════════════════════════════════════════════════════════
@@ -532,7 +504,7 @@ def get_default_thinking_level(agent_type: str) -> str:
        agent_type: The agent type identifier

    Returns:
-        Thinking level string (low, medium, high)
+        Thinking level string (none, low, medium, high, ultrathink)
    """
    config = get_agent_config(agent_type)
    return config.get("thinking_default", "medium")
@@ -52,7 +52,7 @@ async def _save_to_graphiti_async(
        # The helper handles enablement checks internally
        from memory.graphiti_helpers import get_graphiti_memory

-        memory = await get_graphiti_memory(spec_dir, project_dir)
+        memory = get_graphiti_memory(spec_dir, project_dir)
        if memory is None:
            return False

@@ -171,7 +171,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
            # PRIMARY: Save to file-based storage (always works)
            # Load existing map or create new
            if codebase_map_file.exists():
-                with open(codebase_map_file, encoding="utf-8") as f:
+                with open(codebase_map_file) as f:
                    codebase_map = json.load(f)
            else:
                codebase_map = {
@@ -187,7 +187,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
            }
            codebase_map["last_updated"] = datetime.now(timezone.utc).isoformat()

-            with open(codebase_map_file, "w", encoding="utf-8") as f:
+            with open(codebase_map_file, "w") as f:
                json.dump(codebase_map, f, indent=2)

            # SECONDARY: Also save to Graphiti/LadybugDB (for Memory UI)
@@ -246,7 +246,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
                entry += f"\n\n_Context: {context}_"
            entry += "\n"

-            with open(gotchas_file, "a", encoding="utf-8") as f:
+            with open(gotchas_file, "a") as f:
                if not gotchas_file.exists() or gotchas_file.stat().st_size == 0:
                    f.write(
                        "# Gotchas & Pitfalls\n\nThings to watch out for in this codebase.\n"
@@ -303,7 +303,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
        codebase_map_file = memory_dir / "codebase_map.json"
        if codebase_map_file.exists():
            try:
-                with open(codebase_map_file, encoding="utf-8") as f:
+                with open(codebase_map_file) as f:
                    codebase_map = json.load(f)

                discoveries = codebase_map.get("discovered_files", {})
@@ -319,7 +319,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
        gotchas_file = memory_dir / "gotchas.md"
        if gotchas_file.exists():
            try:
-                content = gotchas_file.read_text(encoding="utf-8")
+                content = gotchas_file.read_text()
                if content.strip():
                    result_parts.append("\n## Gotchas")
                    # Take last 1000 chars to avoid too much context
@@ -333,7 +333,7 @@ def create_memory_tools(spec_dir: Path, project_dir: Path) -> list:
        patterns_file = memory_dir / "patterns.md"
        if patterns_file.exists():
            try:
-                content = patterns_file.read_text(encoding="utf-8")
+                content = patterns_file.read_text()
                if content.strip():
                    result_parts.append("\n## Patterns")
                    result_parts.append(
@@ -57,7 +57,7 @@ def create_progress_tools(spec_dir: Path, project_dir: Path) -> list:
            }

        try:
-            with open(plan_file, encoding="utf-8") as f:
+            with open(plan_file) as f:
                plan = json.load(f)

            stats = {
@@ -6,14 +6,10 @@ Tools for managing QA status and sign-off in implementation_plan.json.
 """

 import json
-import logging
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any

-from core.file_utils import write_json_atomic
-from spec.validate_pkg.auto_fix import auto_fix_plan
-
 try:
    from claude_agent_sdk import tool

@@ -23,49 +19,6 @@ except ImportError:
    tool = None


-def _apply_qa_update(
-    plan: dict[str, Any],
-    status: str,
-    issues: list[Any],
-    tests_passed: dict[str, Any],
-) -> int:
-    """
-    Apply QA update to the plan and return the new QA session number.
-
-    Args:
-        plan: The implementation plan dict
-        status: QA status (pending, in_review, approved, rejected, fixes_applied)
-        issues: List of issues found
-        tests_passed: Dict of test results
-
-    Returns:
-        The new QA session number
-    """
-    # Get current QA session number
-    current_qa = plan.get("qa_signoff", {})
-    qa_session = current_qa.get("qa_session", 0)
-    if status in ["in_review", "rejected"]:
-        qa_session += 1
-
-    plan["qa_signoff"] = {
-        "status": status,
-        "qa_session": qa_session,
-        "issues_found": issues,
-        "tests_passed": tests_passed,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "ready_for_qa_revalidation": status == "fixes_applied",
-    }
-
-    # NOTE: Do NOT write plan["status"] or plan["planStatus"] here.
-    # The frontend XState task state machine owns status transitions.
-    # Writing status here races with XState's persistPlanStatusAndReasonSync()
-    # and can clobber the reviewReason field, causing tasks to appear "incomplete".
-
-    plan["last_updated"] = datetime.now(timezone.utc).isoformat()
-
-    return qa_session
-
-
 def create_qa_tools(spec_dir: Path, project_dir: Path) -> list:
    """
    Create QA management tools.
@@ -136,13 +89,37 @@ def create_qa_tools(spec_dir: Path, project_dir: Path) -> list:
            except json.JSONDecodeError:
                tests_passed = {}

-            with open(plan_file, encoding="utf-8") as f:
+            with open(plan_file) as f:
                plan = json.load(f)

-            qa_session = _apply_qa_update(plan, status, issues, tests_passed)
+            # Get current QA session number
+            current_qa = plan.get("qa_signoff", {})
+            qa_session = current_qa.get("qa_session", 0)
+            if status in ["in_review", "rejected"]:
+                qa_session += 1

-            # Use atomic write to prevent file corruption
-            write_json_atomic(plan_file, plan, indent=2)
+            plan["qa_signoff"] = {
+                "status": status,
+                "qa_session": qa_session,
+                "issues_found": issues,
+                "tests_passed": tests_passed,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "ready_for_qa_revalidation": status == "fixes_applied",
+            }
+
+            # Update plan status to match QA result
+            # This ensures the UI shows the correct column after QA
+            if status == "approved":
+                plan["status"] = "human_review"
+                plan["planStatus"] = "review"
+            elif status == "rejected":
+                plan["status"] = "human_review"
+                plan["planStatus"] = "review"
+
+            plan["last_updated"] = datetime.now(timezone.utc).isoformat()
+
+            with open(plan_file, "w") as f:
+                json.dump(plan, f, indent=2)

            return {
                "content": [
@@ -153,47 +130,6 @@ def create_qa_tools(spec_dir: Path, project_dir: Path) -> list:
                ]
            }

-        except json.JSONDecodeError as e:
-            # Attempt to auto-fix the plan and retry
-            if auto_fix_plan(spec_dir):
-                # Retry after fix
-                try:
-                    with open(plan_file, encoding="utf-8") as f:
-                        plan = json.load(f)
-
-                    qa_session = _apply_qa_update(plan, status, issues, tests_passed)
-                    write_json_atomic(plan_file, plan, indent=2)
-
-                    return {
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": f"Updated QA status to '{status}' (session {qa_session}) (after auto-fix)",
-                            }
-                        ]
-                    }
-                except Exception as retry_err:
-                    logging.warning(
-                        f"QA update retry failed after auto-fix: {retry_err} (original error: {e})"
-                    )
-                    return {
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": f"Error: QA update failed after auto-fix: {retry_err} (original JSON error: {e})",
-                            }
-                        ]
-                    }
-
-            return {
-                "content": [
-                    {
-                        "type": "text",
-                        "text": f"Error: Invalid JSON in implementation_plan.json: {e}",
-                    }
-                ]
-            }
-
        except Exception as e:
            return {
                "content": [{"type": "text", "text": f"Error updating QA status: {e}"}]
@@ -6,14 +6,10 @@ Tools for managing subtask status in implementation_plan.json.
 """

 import json
-import logging
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any

-from core.file_utils import write_json_atomic
-from spec.validate_pkg.auto_fix import auto_fix_plan
-
 try:
    from claude_agent_sdk import tool

@@ -23,43 +19,6 @@ except ImportError:
    tool = None


-def _update_subtask_in_plan(
-    plan: dict[str, Any],
-    subtask_id: str,
-    status: str,
-    notes: str,
-) -> bool:
-    """
-    Update a subtask in the plan.
-
-    Args:
-        plan: The implementation plan dict
-        subtask_id: ID of the subtask to update
-        status: New status (pending, in_progress, completed, failed)
-        notes: Optional notes to add
-
-    Returns:
-        True if subtask was found and updated, False otherwise
-    """
-    subtask_found = False
-    for phase in plan.get("phases", []):
-        for subtask in phase.get("subtasks", []):
-            if subtask.get("id") == subtask_id:
-                subtask["status"] = status
-                if notes:
-                    subtask["notes"] = notes
-                subtask["updated_at"] = datetime.now(timezone.utc).isoformat()
-                subtask_found = True
-                break
-        if subtask_found:
-            break
-
-    if subtask_found:
-        plan["last_updated"] = datetime.now(timezone.utc).isoformat()
-
-    return subtask_found
-
-
 def create_subtask_tools(spec_dir: Path, project_dir: Path) -> list:
    """
    Create subtask management tools.
@@ -113,10 +72,22 @@ def create_subtask_tools(spec_dir: Path, project_dir: Path) -> list:
            }

        try:
-            with open(plan_file, encoding="utf-8") as f:
+            with open(plan_file) as f:
                plan = json.load(f)

-            subtask_found = _update_subtask_in_plan(plan, subtask_id, status, notes)
+            # Find and update the subtask
+            subtask_found = False
+            for phase in plan.get("phases", []):
+                for subtask in phase.get("subtasks", []):
+                    if subtask.get("id") == subtask_id:
+                        subtask["status"] = status
+                        if notes:
+                            subtask["notes"] = notes
+                        subtask["updated_at"] = datetime.now(timezone.utc).isoformat()
+                        subtask_found = True
+                        break
+                if subtask_found:
+                    break

            if not subtask_found:
                return {
@@ -128,8 +99,11 @@ def create_subtask_tools(spec_dir: Path, project_dir: Path) -> list:
                    ]
                }

-            # Use atomic write to prevent file corruption
-            write_json_atomic(plan_file, plan, indent=2)
+            # Update plan metadata
+            plan["last_updated"] = datetime.now(timezone.utc).isoformat()
+
+            with open(plan_file, "w") as f:
+                json.dump(plan, f, indent=2)

            return {
                "content": [
@@ -141,49 +115,6 @@ def create_subtask_tools(spec_dir: Path, project_dir: Path) -> list:
            }

        except json.JSONDecodeError as e:
-            # Attempt to auto-fix the plan and retry
-            if auto_fix_plan(spec_dir):
-                # Retry after fix
-                try:
-                    with open(plan_file, encoding="utf-8") as f:
-                        plan = json.load(f)
-
-                    subtask_found = _update_subtask_in_plan(
-                        plan, subtask_id, status, notes
-                    )
-
-                    if subtask_found:
-                        write_json_atomic(plan_file, plan, indent=2)
-                        return {
-                            "content": [
-                                {
-                                    "type": "text",
-                                    "text": f"Successfully updated subtask '{subtask_id}' to status '{status}' (after auto-fix)",
-                                }
-                            ]
-                        }
-                    else:
-                        return {
-                            "content": [
-                                {
-                                    "type": "text",
-                                    "text": f"Error: Subtask '{subtask_id}' not found in implementation plan (after auto-fix)",
-                                }
-                            ]
-                        }
-                except Exception as retry_err:
-                    logging.warning(
-                        f"Subtask update retry failed after auto-fix: {retry_err}"
-                    )
-                    return {
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": f"Error: Subtask update failed after auto-fix: {retry_err}",
-                            }
-                        ]
-                    }
-
            return {
                "content": [
                    {
@@ -48,9 +48,9 @@ def load_implementation_plan(spec_dir: Path) -> dict | None:
    if not plan_file.exists():
        return None
    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            return json.load(f)
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return None


@@ -23,8 +23,7 @@ from .ci_discovery import CIDiscovery
 from .project_analyzer import ProjectAnalyzer
 from .risk_classifier import RiskClassifier
 from .security_scanner import SecurityScanner
-
-# TestDiscovery was removed - tests are now co-located in their respective modules
+from .test_discovery import TestDiscovery

 # insight_extractor is a module with functions, not a class, so don't import it here
 # Import it directly when needed: from analysis import insight_extractor
@@ -38,5 +37,5 @@ __all__ = [
    "RiskClassifier",
    "SecurityScanner",
    "CIDiscovery",
-    # "TestDiscovery",  # Removed - tests now co-located in their modules
+    "TestDiscovery",
 ]
@@ -46,7 +46,7 @@ def analyze_project(project_dir: Path, output_file: Path | None = None) -> dict:

    if output_file:
        output_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_file, "w", encoding="utf-8") as f:
+        with open(output_file, "w") as f:
            json.dump(results, f, indent=2)
        print(f"Project index saved to: {output_file}")

@@ -87,7 +87,7 @@ def analyze_service(

    if output_file:
        output_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_file, "w", encoding="utf-8") as f:
+        with open(output_file, "w") as f:
            json.dump(results, f, indent=2)
        print(f"Service analysis saved to: {output_file}")

@@ -99,7 +99,7 @@ class BaseAnalyzer:
    def _read_file(self, path: str) -> str:
        """Read a file relative to the analyzer's path."""
        try:
-            return (self.path / path).read_text(encoding="utf-8")
+            return (self.path / path).read_text()
        except (OSError, UnicodeDecodeError):
            return ""

@@ -126,7 +126,7 @@ class AuthDetector(BaseAnalyzer):

        for py_file in all_py_files:
            try:
-                content = py_file.read_text(encoding="utf-8")
+                content = py_file.read_text()
                # Find custom decorators
                if (
                    "@require" in content
@@ -52,7 +52,7 @@ class JobsDetector(BaseAnalyzer):
        tasks = []
        for task_file in celery_files:
            try:
-                content = task_file.read_text(encoding="utf-8")
+                content = task_file.read_text()
                # Find @celery.task or @shared_task decorators
                task_pattern = r"@(?:celery\.task|shared_task|app\.task)\s*(?:\([^)]*\))?\s*def\s+(\w+)"
                task_matches = re.findall(task_pattern, content)
@@ -77,7 +77,7 @@ class MonitoringDetector(BaseAnalyzer):
                continue

            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
                # Look for actual Prometheus imports or usage patterns
                prometheus_patterns = [
                    "from prometheus_client import",
@@ -52,7 +52,7 @@ class DatabaseDetector(BaseAnalyzer):

        for file_path in py_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -119,7 +119,7 @@ class DatabaseDetector(BaseAnalyzer):

        for file_path in model_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -168,7 +168,7 @@ class DatabaseDetector(BaseAnalyzer):
            return models

        try:
-            content = schema_file.read_text(encoding="utf-8")
+            content = schema_file.read_text()
        except (OSError, UnicodeDecodeError):
            return models

@@ -216,7 +216,7 @@ class DatabaseDetector(BaseAnalyzer):

        for file_path in ts_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -265,7 +265,7 @@ class DatabaseDetector(BaseAnalyzer):

        for file_path in schema_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -295,7 +295,7 @@ class DatabaseDetector(BaseAnalyzer):

        for file_path in model_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -235,15 +235,10 @@ class FrameworkAnalyzer(BaseAnalyzer):

        # Scripts
        scripts = pkg.get("scripts", {})
-        pkg_mgr = self.analysis.get("package_manager", "npm")
        if "dev" in scripts:
-            self.analysis["dev_command"] = f"{pkg_mgr} run dev"
+            self.analysis["dev_command"] = "npm run dev"
        elif "start" in scripts:
-            self.analysis["dev_command"] = f"{pkg_mgr} run start"
-
-        # Capture available scripts for downstream consumers (QA agents, init.sh)
-        if scripts:
-            self.analysis["scripts"] = dict(scripts)
+            self.analysis["dev_command"] = "npm run start"

    def _detect_go_framework(self, content: str) -> None:
        """Detect Go framework."""
@@ -31,7 +31,6 @@ class ProjectAnalyzer:
        """Run full project analysis."""
        self._detect_project_type()
        self._find_and_analyze_services()
-        self._aggregate_dependency_locations()
        self._analyze_infrastructure()
        self._detect_conventions()
        self._map_dependencies()
@@ -125,63 +124,6 @@ class ProjectAnalyzer:

        self.index["services"] = services

-    def _aggregate_dependency_locations(self) -> None:
-        """Aggregate dependency location metadata from all services.
-
-        Collects dependency_locations from each service and stores them as
-        paths relative to the project root (e.g., 'apps/backend/.venv'
-        instead of just '.venv').
-        """
-        aggregated: list[dict[str, Any]] = []
-
-        for service_name, service_info in self.index.get("services", {}).items():
-            service_deps = service_info.get("dependency_locations", [])
-            service_path = service_info.get("path", "")
-
-            # Compute service-relative prefix once per service
-            service_rel: Path | None = None
-            if service_path:
-                try:
-                    service_rel = Path(service_path).relative_to(self.project_dir)
-                except ValueError:
-                    # Service path is outside the project root — skip its deps
-                    # to avoid producing absolute paths that bypass containment
-                    continue
-
-            for dep in service_deps:
-                dep_path = dep.get("path")
-                if not dep_path:
-                    continue
-
-                # Build project-relative path from service path + dep path
-                if service_rel is not None:
-                    project_relative = str(service_rel / dep_path)
-                else:
-                    project_relative = dep_path
-
-                entry: dict[str, Any] = {
-                    "type": dep.get("type", "unknown"),
-                    "path": project_relative,
-                    "exists": dep.get("exists", False),
-                    "service": service_name,
-                }
-                if dep.get("requirements_file"):
-                    # Convert to project-relative path like we do for "path"
-                    if service_rel is not None:
-                        entry["requirements_file"] = str(
-                            service_rel / dep["requirements_file"]
-                        )
-                    else:
-                        entry["requirements_file"] = dep["requirements_file"]
-                pkg_mgr = dep.get("package_manager") or service_info.get(
-                    "package_manager"
-                )
-                if pkg_mgr:
-                    entry["package_manager"] = pkg_mgr
-                aggregated.append(entry)
-
-        self.index["dependency_locations"] = aggregated
-
    def _analyze_infrastructure(self) -> None:
        """Analyze infrastructure configuration."""
        infra = {}
@@ -345,6 +287,6 @@ class ProjectAnalyzer:

    def _read_file(self, path: str) -> str:
        try:
-            return (self.project_dir / path).read_text(encoding="utf-8")
+            return (self.project_dir / path).read_text()
        except (OSError, UnicodeDecodeError):
            return ""
@@ -66,7 +66,7 @@ class RouteDetector(BaseAnalyzer):

        for file_path in files_to_check:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -130,7 +130,7 @@ class RouteDetector(BaseAnalyzer):

        for file_path in files_to_check:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -179,7 +179,7 @@ class RouteDetector(BaseAnalyzer):

        for file_path in url_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -218,7 +218,7 @@ class RouteDetector(BaseAnalyzer):
        files_to_check = js_files + ts_files
        for file_path in files_to_check:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -283,7 +283,7 @@ class RouteDetector(BaseAnalyzer):
                route_path = re.sub(r"\[([^\]]+)\]", r":\1", route_path)

                try:
-                    content = route_file.read_text(encoding="utf-8")
+                    content = route_file.read_text()
                    # Detect exported methods: export async function GET(request)
                    methods = re.findall(
                        r"export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH)",
@@ -348,7 +348,7 @@ class RouteDetector(BaseAnalyzer):

        for file_path in go_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -384,7 +384,7 @@ class RouteDetector(BaseAnalyzer):

        for file_path in rust_files:
            try:
-                content = file_path.read_text(encoding="utf-8")
+                content = file_path.read_text()
            except (OSError, UnicodeDecodeError):
                continue

@@ -40,8 +40,6 @@ class ServiceAnalyzer(BaseAnalyzer):
        self._find_key_directories()
        self._find_entry_points()
        self._detect_dependencies()
-        self._detect_dependency_locations()
-        self._detect_package_manager()
        self._detect_testing()
        self._find_dockerfile()

@@ -211,121 +209,6 @@ class ServiceAnalyzer(BaseAnalyzer):
                        deps.append(match.group(1))
            self.analysis["dependencies"] = deps[:20]

-    def _detect_dependency_locations(self) -> None:
-        """Detect where dependencies live on disk for this service."""
-        locations: list[dict[str, Any]] = []
-
-        # Node.js: node_modules (only if package.json exists)
-        if self._exists("package.json"):
-            node_modules = self.path / "node_modules"
-            locations.append(
-                {
-                    "type": "node_modules",
-                    "path": "node_modules",
-                    "exists": node_modules.exists() and node_modules.is_dir(),
-                }
-            )
-
-        # Python: .venv or venv
-        for venv_dir in [".venv", "venv"]:
-            venv_path = self.path / venv_dir
-            if venv_path.exists() and venv_path.is_dir():
-                entry: dict[str, Any] = {
-                    "type": "venv",
-                    "path": venv_dir,
-                    "exists": True,
-                }
-                # Find requirements file
-                for req_file in ["requirements.txt", "pyproject.toml", "Pipfile"]:
-                    if self._exists(req_file):
-                        entry["requirements_file"] = req_file
-                        break
-                locations.append(entry)
-                break
-        else:
-            # No venv found, still record requirements file if present
-            for req_file in ["requirements.txt", "pyproject.toml", "Pipfile"]:
-                if self._exists(req_file):
-                    locations.append(
-                        {
-                            "type": "venv",
-                            "path": ".venv",
-                            "exists": False,
-                            "requirements_file": req_file,
-                        }
-                    )
-                    break
-
-        # PHP: vendor
-        vendor_path = self.path / "vendor"
-        if vendor_path.exists() and vendor_path.is_dir():
-            locations.append(
-                {
-                    "type": "vendor_php",
-                    "path": "vendor",
-                    "exists": True,
-                }
-            )
-
-        # Rust: target
-        target_path = self.path / "target"
-        if target_path.exists() and target_path.is_dir():
-            locations.append(
-                {
-                    "type": "cargo_target",
-                    "path": "target",
-                    "exists": True,
-                }
-            )
-
-        # Ruby: vendor/bundle
-        bundle_path = self.path / "vendor" / "bundle"
-        if bundle_path.exists() and bundle_path.is_dir():
-            locations.append(
-                {
-                    "type": "vendor_bundle",
-                    "path": "vendor/bundle",
-                    "exists": True,
-                }
-            )
-
-        self.analysis["dependency_locations"] = locations
-
-    def _detect_package_manager(self) -> None:
-        """Detect the package manager used by this service."""
-        # Node.js package managers
-        if self._exists("package-lock.json"):
-            self.analysis["package_manager"] = "npm"
-        elif self._exists("yarn.lock"):
-            self.analysis["package_manager"] = "yarn"
-        elif self._exists("pnpm-lock.yaml"):
-            self.analysis["package_manager"] = "pnpm"
-        elif self._exists("bun.lockb") or self._exists("bun.lock"):
-            self.analysis["package_manager"] = "bun"
-        # Python package managers
-        elif self._exists("Pipfile"):
-            self.analysis["package_manager"] = "pipenv"
-        elif self._exists("pyproject.toml"):
-            if self._exists("uv.lock"):
-                self.analysis["package_manager"] = "uv"
-            elif self._exists("poetry.lock"):
-                self.analysis["package_manager"] = "poetry"
-            else:
-                self.analysis["package_manager"] = "pip"
-        elif self._exists("requirements.txt"):
-            self.analysis["package_manager"] = "pip"
-        # Other
-        elif self._exists("Cargo.toml"):
-            self.analysis["package_manager"] = "cargo"
-        elif self._exists("go.mod"):
-            self.analysis["package_manager"] = "go_mod"
-        elif self._exists("Gemfile"):
-            self.analysis["package_manager"] = "gem"
-        elif self._exists("composer.json"):
-            self.analysis["package_manager"] = "composer"
-        else:
-            self.analysis["package_manager"] = None
-
    def _detect_testing(self) -> None:
        """Detect testing framework and configuration."""
        if self._exists("package.json"):
@@ -163,7 +163,7 @@ class CIDiscovery:
            )

            try:
-                content = wf_file.read_text(encoding="utf-8")
+                content = wf_file.read_text()
                workflow_data = self._parse_yaml(content)

                if not workflow_data:
@@ -242,7 +242,7 @@ class CIDiscovery:
        )

        try:
-            content = config_file.read_text(encoding="utf-8")
+            content = config_file.read_text()
            data = self._parse_yaml(content)

            if not data:
@@ -312,7 +312,7 @@ class CIDiscovery:
        )

        try:
-            content = config_file.read_text(encoding="utf-8")
+            content = config_file.read_text()
            data = self._parse_yaml(content)

            if not data:
@@ -370,7 +370,7 @@ class CIDiscovery:
        )

        try:
-            content = jenkinsfile.read_text(encoding="utf-8")
+            content = jenkinsfile.read_text()

            # Extract sh commands using regex
            sh_pattern = re.compile(r'sh\s+[\'"]([^\'"]+)[\'"]')
@@ -33,9 +33,7 @@ except ImportError:
 from core.auth import ensure_claude_code_oauth_token, get_auth_token

 # Default model for insight extraction (fast and cheap)
-# Note: Using Haiku 4.5 for fast, cheap extraction. Haiku does not support
-# extended thinking, so thinking_default is set to "none" in models.py
-DEFAULT_EXTRACTION_MODEL = "claude-haiku-4-5-20251001"
+DEFAULT_EXTRACTION_MODEL = "claude-3-5-haiku-latest"

 # Maximum diff size to send to the LLM (avoid context limits)
 MAX_DIFF_CHARS = 15000
@@ -237,7 +235,7 @@ def _get_subtask_description(spec_dir: Path, subtask_id: str) -> str:
        return f"Subtask: {subtask_id}"

    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan = json.load(f)

        # Search through phases for the subtask
@@ -280,7 +278,7 @@ def _build_extraction_prompt(inputs: dict) -> str:
    prompt_file = Path(__file__).parent / "prompts" / "insight_extractor.md"

    if prompt_file.exists():
-        base_prompt = prompt_file.read_text(encoding="utf-8")
+        base_prompt = prompt_file.read_text()
    else:
        # Fallback if prompt file missing
        base_prompt = """Extract structured insights from this coding session.
@@ -0,0 +1,690 @@
+#!/usr/bin/env python3
+"""
+Test Discovery Module
+=====================
+
+Detects test frameworks, test commands, and test directories in a project.
+This module analyzes project configuration files to discover how tests
+should be run.
+
+The test discovery results are used by:
+- QA Agent: To determine what test commands to run
+- Test Creator: To know what framework to use when creating tests
+- Planner: To include correct test commands in verification strategy
+
+Usage:
+    from test_discovery import TestDiscovery
+
+    discovery = TestDiscovery()
+    result = discovery.discover(project_dir)
+
+    print(f"Test frameworks: {result['frameworks']}")
+    print(f"Test command: {result['test_command']}")
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# =============================================================================
+# DATA CLASSES
+# =============================================================================
+
+
+@dataclass
+class TestFramework:
+    """
+    Represents a detected test framework.
+
+    Attributes:
+        name: Name of the framework (e.g., "pytest", "jest", "vitest")
+        type: Type of testing (unit, integration, e2e, all)
+        command: Command to run tests
+        config_file: Configuration file if found
+        version: Version if detected
+        coverage_command: Command for coverage if available
+    """
+
+    __test__ = False  # Prevent pytest from collecting this as a test class
+
+    name: str
+    type: str  # unit, integration, e2e, all
+    command: str
+    config_file: str | None = None
+    version: str | None = None
+    coverage_command: str | None = None
+
+
+@dataclass
+class TestDiscoveryResult:
+    """
+    Result of test framework discovery.
+
+    Attributes:
+        frameworks: List of detected test frameworks
+        test_command: Primary test command to run
+        test_directories: Discovered test directories
+        package_manager: Detected package manager
+        has_tests: Whether any test files were found
+        coverage_command: Command for coverage if available
+    """
+
+    __test__ = False  # Prevent pytest from collecting this as a test class
+
+    frameworks: list[TestFramework] = field(default_factory=list)
+    test_command: str = ""
+    test_directories: list[str] = field(default_factory=list)
+    package_manager: str = ""
+    has_tests: bool = False
+    coverage_command: str | None = None
+
+
+# =============================================================================
+# FRAMEWORK DETECTORS
+# =============================================================================
+
+
+# Pattern-based framework detection
+FRAMEWORK_PATTERNS = {
+    # JavaScript/TypeScript
+    "jest": {
+        "config_files": [
+            "jest.config.js",
+            "jest.config.ts",
+            "jest.config.mjs",
+            "jest.config.cjs",
+        ],
+        "package_key": "jest",
+        "type": "unit",
+        "command": "npx jest",
+        "coverage_command": "npx jest --coverage",
+    },
+    "vitest": {
+        "config_files": ["vitest.config.js", "vitest.config.ts", "vitest.config.mjs"],
+        "package_key": "vitest",
+        "type": "unit",
+        "command": "npx vitest run",
+        "coverage_command": "npx vitest run --coverage",
+    },
+    "mocha": {
+        "config_files": [
+            ".mocharc.js",
+            ".mocharc.json",
+            ".mocharc.yaml",
+            ".mocharc.yml",
+        ],
+        "package_key": "mocha",
+        "type": "unit",
+        "command": "npx mocha",
+        "coverage_command": "npx nyc mocha",
+    },
+    "playwright": {
+        "config_files": ["playwright.config.js", "playwright.config.ts"],
+        "package_key": "@playwright/test",
+        "type": "e2e",
+        "command": "npx playwright test",
+        "coverage_command": None,
+    },
+    "cypress": {
+        "config_files": ["cypress.config.js", "cypress.config.ts", "cypress.json"],
+        "package_key": "cypress",
+        "type": "e2e",
+        "command": "npx cypress run",
+        "coverage_command": None,
+    },
+    # Python
+    "pytest": {
+        "config_files": ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py"],
+        "pyproject_key": "pytest",
+        "requirements_key": "pytest",
+        "type": "all",
+        "command": "pytest",
+        "coverage_command": "pytest --cov",
+    },
+    "unittest": {
+        "config_files": [],
+        "type": "unit",
+        "command": "python -m unittest discover",
+        "coverage_command": "coverage run -m unittest discover",
+    },
+    # Rust
+    "cargo_test": {
+        "config_files": ["Cargo.toml"],
+        "type": "all",
+        "command": "cargo test",
+        "coverage_command": "cargo tarpaulin",
+    },
+    # Go
+    "go_test": {
+        "config_files": ["go.mod"],
+        "type": "all",
+        "command": "go test ./...",
+        "coverage_command": "go test -cover ./...",
+    },
+    # Ruby
+    "rspec": {
+        "config_files": [".rspec", "spec/spec_helper.rb"],
+        "gemfile_key": "rspec",
+        "type": "all",
+        "command": "bundle exec rspec",
+        "coverage_command": "bundle exec rspec --format documentation",
+    },
+    "minitest": {
+        "config_files": [],
+        "gemfile_key": "minitest",
+        "type": "unit",
+        "command": "bundle exec rake test",
+        "coverage_command": None,
+    },
+}
+
+
+# =============================================================================
+# TEST DISCOVERY
+# =============================================================================
+
+
+class TestDiscovery:
+    """
+    Discovers test frameworks and configurations in a project.
+
+    Analyzes:
+    - Package files (package.json, pyproject.toml, Cargo.toml, etc.)
+    - Configuration files (jest.config.js, pytest.ini, etc.)
+    - Directory structure (tests/, spec/, __tests__/)
+    """
+
+    __test__ = False  # Prevent pytest from collecting this as a test class
+
+    def __init__(self) -> None:
+        """Initialize the test discovery."""
+        self._cache: dict[str, TestDiscoveryResult] = {}
+
+    def discover(self, project_dir: Path) -> TestDiscoveryResult:
+        """
+        Discover test frameworks and configuration in the project.
+
+        Args:
+            project_dir: Path to the project root
+
+        Returns:
+            TestDiscoveryResult with detected frameworks and commands
+        """
+        project_dir = Path(project_dir)
+        cache_key = str(project_dir.resolve())
+
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        result = TestDiscoveryResult()
+
+        # Detect package manager
+        result.package_manager = self._detect_package_manager(project_dir)
+
+        # Discover frameworks based on project type
+        if (project_dir / "package.json").exists():
+            self._discover_js_frameworks(project_dir, result)
+
+        # Check for Python project indicators
+        python_indicators = [
+            project_dir / "pyproject.toml",
+            project_dir / "requirements.txt",
+            project_dir / "setup.py",
+            project_dir / "pytest.ini",
+            project_dir / "conftest.py",
+            project_dir / "tests" / "conftest.py",
+        ]
+        if any(p.exists() for p in python_indicators):
+            self._discover_python_frameworks(project_dir, result)
+
+        if (project_dir / "Cargo.toml").exists():
+            self._discover_rust_frameworks(project_dir, result)
+        if (project_dir / "go.mod").exists():
+            self._discover_go_frameworks(project_dir, result)
+        if (project_dir / "Gemfile").exists():
+            self._discover_ruby_frameworks(project_dir, result)
+
+        # Find test directories
+        result.test_directories = self._find_test_directories(project_dir)
+
+        # Check if tests exist
+        result.has_tests = self._has_test_files(project_dir, result.test_directories)
+
+        # Set primary test command
+        if result.frameworks:
+            result.test_command = result.frameworks[0].command
+
+        # Set coverage command from first framework that has one
+        if not result.coverage_command:
+            for framework in result.frameworks:
+                if framework.coverage_command:
+                    result.coverage_command = framework.coverage_command
+                    break
+
+        self._cache[cache_key] = result
+        return result
+
+    def _detect_package_manager(self, project_dir: Path) -> str:
+        """Detect the package manager used by the project."""
+        if (project_dir / "pnpm-lock.yaml").exists():
+            return "pnpm"
+        if (project_dir / "yarn.lock").exists():
+            return "yarn"
+        if (project_dir / "package-lock.json").exists():
+            return "npm"
+        if (project_dir / "bun.lockb").exists() or (project_dir / "bun.lock").exists():
+            return "bun"
+        if (project_dir / "uv.lock").exists():
+            return "uv"
+        if (project_dir / "poetry.lock").exists():
+            return "poetry"
+        if (project_dir / "Pipfile.lock").exists():
+            return "pipenv"
+        if (project_dir / "Cargo.lock").exists():
+            return "cargo"
+        if (project_dir / "go.sum").exists():
+            return "go"
+        if (project_dir / "Gemfile.lock").exists():
+            return "bundler"
+        return ""
+
+    def _discover_js_frameworks(
+        self, project_dir: Path, result: TestDiscoveryResult
+    ) -> None:
+        """Discover JavaScript/TypeScript test frameworks."""
+        package_json = project_dir / "package.json"
+        if not package_json.exists():
+            return
+
+        try:
+            with open(package_json, encoding="utf-8") as f:
+                pkg = json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return
+
+        deps = pkg.get("dependencies", {})
+        dev_deps = pkg.get("devDependencies", {})
+        all_deps = {**deps, **dev_deps}
+        scripts = pkg.get("scripts", {})
+
+        # Check for test frameworks in dependencies
+        for name, pattern in FRAMEWORK_PATTERNS.items():
+            if "package_key" not in pattern:
+                continue
+
+            if pattern["package_key"] in all_deps:
+                # Check for config file
+                config_file = None
+                for cf in pattern.get("config_files", []):
+                    if (project_dir / cf).exists():
+                        config_file = cf
+                        break
+
+                # Get version
+                version = all_deps.get(pattern["package_key"], "")
+                if version.startswith("^") or version.startswith("~"):
+                    version = version[1:]
+
+                # Determine command - prefer npm scripts if available
+                command = pattern["command"]
+                if "test" in scripts and pattern["package_key"] in scripts.get(
+                    "test", ""
+                ):
+                    command = f"{result.package_manager or 'npm'} test"
+
+                result.frameworks.append(
+                    TestFramework(
+                        name=name,
+                        type=pattern["type"],
+                        command=command,
+                        config_file=config_file,
+                        version=version,
+                        coverage_command=pattern.get("coverage_command"),
+                    )
+                )
+
+        # Check npm scripts for test commands
+        if not result.frameworks and "test" in scripts:
+            test_script = scripts["test"]
+            if (
+                test_script
+                and test_script != 'echo "Error: no test specified" && exit 1'
+            ):
+                # Try to infer framework from script
+                framework_name = "npm_test"
+                framework_type = "unit"
+
+                if "jest" in test_script:
+                    framework_name = "jest"
+                elif "vitest" in test_script:
+                    framework_name = "vitest"
+                elif "mocha" in test_script:
+                    framework_name = "mocha"
+                elif "playwright" in test_script:
+                    framework_name = "playwright"
+                    framework_type = "e2e"
+                elif "cypress" in test_script:
+                    framework_name = "cypress"
+                    framework_type = "e2e"
+
+                result.frameworks.append(
+                    TestFramework(
+                        name=framework_name,
+                        type=framework_type,
+                        command=f"{result.package_manager or 'npm'} test",
+                        config_file=None,
+                    )
+                )
+
+    def _discover_python_frameworks(
+        self, project_dir: Path, result: TestDiscoveryResult
+    ) -> None:
+        """Discover Python test frameworks."""
+        # Check for pytest.ini first (explicit pytest config)
+        if (project_dir / "pytest.ini").exists():
+            if not any(f.name == "pytest" for f in result.frameworks):
+                result.frameworks.append(
+                    TestFramework(
+                        name="pytest",
+                        type="all",
+                        command="pytest",
+                        config_file="pytest.ini",
+                    )
+                )
+
+        # Check pyproject.toml
+        pyproject = project_dir / "pyproject.toml"
+        if pyproject.exists():
+            content = pyproject.read_text()
+
+            # Check for pytest
+            if "pytest" in content:
+                if not any(f.name == "pytest" for f in result.frameworks):
+                    config_file = (
+                        "pyproject.toml" if "[tool.pytest" in content else None
+                    )
+                    result.frameworks.append(
+                        TestFramework(
+                            name="pytest",
+                            type="all",
+                            command="pytest",
+                            config_file=config_file,
+                        )
+                    )
+
+        # Check requirements.txt
+        requirements = project_dir / "requirements.txt"
+        if requirements.exists():
+            content = requirements.read_text().lower()
+            if "pytest" in content and not any(
+                f.name == "pytest" for f in result.frameworks
+            ):
+                result.frameworks.append(
+                    TestFramework(
+                        name="pytest",
+                        type="all",
+                        command="pytest",
+                        config_file=None,
+                    )
+                )
+
+        # Check for conftest.py (pytest marker)
+        conftest_root = project_dir / "conftest.py"
+        conftest_tests = project_dir / "tests" / "conftest.py"
+        if conftest_root.exists() or conftest_tests.exists():
+            if not any(f.name == "pytest" for f in result.frameworks):
+                result.frameworks.append(
+                    TestFramework(
+                        name="pytest",
+                        type="all",
+                        command="pytest",
+                        config_file="conftest.py",
+                    )
+                )
+
+        # Fall back to unittest if test files exist but no framework detected
+        if not result.frameworks:
+            test_dirs = self._find_test_directories(project_dir)
+            if test_dirs:
+                result.frameworks.append(
+                    TestFramework(
+                        name="unittest",
+                        type="unit",
+                        command="python -m unittest discover",
+                        config_file=None,
+                    )
+                )
+
+    def _discover_rust_frameworks(
+        self, project_dir: Path, result: TestDiscoveryResult
+    ) -> None:
+        """Discover Rust test frameworks."""
+        cargo_toml = project_dir / "Cargo.toml"
+        if cargo_toml.exists():
+            result.frameworks.append(
+                TestFramework(
+                    name="cargo_test",
+                    type="all",
+                    command="cargo test",
+                    config_file="Cargo.toml",
+                )
+            )
+
+    def _discover_go_frameworks(
+        self, project_dir: Path, result: TestDiscoveryResult
+    ) -> None:
+        """Discover Go test frameworks."""
+        go_mod = project_dir / "go.mod"
+        if go_mod.exists():
+            result.frameworks.append(
+                TestFramework(
+                    name="go_test",
+                    type="all",
+                    command="go test ./...",
+                    config_file="go.mod",
+                )
+            )
+
+    def _discover_ruby_frameworks(
+        self, project_dir: Path, result: TestDiscoveryResult
+    ) -> None:
+        """Discover Ruby test frameworks."""
+        gemfile = project_dir / "Gemfile"
+        if not gemfile.exists():
+            return
+
+        content = gemfile.read_text().lower()
+
+        if "rspec" in content or (project_dir / ".rspec").exists():
+            result.frameworks.append(
+                TestFramework(
+                    name="rspec",
+                    type="all",
+                    command="bundle exec rspec",
+                    config_file=".rspec" if (project_dir / ".rspec").exists() else None,
+                )
+            )
+        elif "minitest" in content:
+            result.frameworks.append(
+                TestFramework(
+                    name="minitest",
+                    type="unit",
+                    command="bundle exec rake test",
+                    config_file=None,
+                )
+            )
+
+    def _find_test_directories(self, project_dir: Path) -> list[str]:
+        """Find test directories in the project."""
+        test_dir_patterns = [
+            "tests",
+            "test",
+            "spec",
+            "__tests__",
+            "specs",
+            "test_*",
+        ]
+
+        found_dirs = []
+        for pattern in test_dir_patterns:
+            if pattern.endswith("*"):
+                # Glob pattern
+                for d in project_dir.glob(pattern):
+                    if d.is_dir():
+                        found_dirs.append(str(d.relative_to(project_dir)))
+            else:
+                # Exact name
+                test_dir = project_dir / pattern
+                if test_dir.is_dir():
+                    found_dirs.append(pattern)
+
+        return found_dirs
+
+    def _has_test_files(self, project_dir: Path, test_directories: list[str]) -> bool:
+        """Check if any test files exist."""
+        test_file_patterns = [
+            "**/test_*.py",
+            "**/*_test.py",
+            "**/*.test.js",
+            "**/*.test.ts",
+            "**/*.test.tsx",
+            "**/*.spec.js",
+            "**/*.spec.ts",
+            "**/*.spec.tsx",
+            "**/test_*.go",
+            "**/*_test.go",
+            "**/*_test.rs",
+            "**/spec/**/*_spec.rb",
+        ]
+
+        # Check in test directories
+        for test_dir in test_directories:
+            test_path = project_dir / test_dir
+            if test_path.exists():
+                for pattern in test_file_patterns:
+                    if list(test_path.glob(pattern.replace("**/", ""))):
+                        return True
+
+        # Check project-wide
+        for pattern in test_file_patterns:
+            if list(project_dir.glob(pattern)):
+                return True
+
+        return False
+
+    def to_dict(self, result: TestDiscoveryResult) -> dict[str, Any]:
+        """Convert result to dictionary for JSON serialization."""
+        return {
+            "frameworks": [
+                {
+                    "name": f.name,
+                    "type": f.type,
+                    "command": f.command,
+                    "config_file": f.config_file,
+                    "version": f.version,
+                    "coverage_command": f.coverage_command,
+                }
+                for f in result.frameworks
+            ],
+            "test_command": result.test_command,
+            "test_directories": result.test_directories,
+            "package_manager": result.package_manager,
+            "has_tests": result.has_tests,
+            "coverage_command": result.coverage_command,
+        }
+
+    def clear_cache(self) -> None:
+        """Clear the internal cache."""
+        self._cache.clear()
+
+
+# =============================================================================
+# CONVENIENCE FUNCTIONS
+# =============================================================================
+
+
+def discover_tests(project_dir: Path) -> TestDiscoveryResult:
+    """
+    Convenience function to discover tests in a project.
+
+    Args:
+        project_dir: Path to project root
+
+    Returns:
+        TestDiscoveryResult with detected frameworks
+    """
+    discovery = TestDiscovery()
+    return discovery.discover(project_dir)
+
+
+def get_test_command(project_dir: Path) -> str:
+    """
+    Get the primary test command for a project.
+
+    Args:
+        project_dir: Path to project root
+
+    Returns:
+        Test command string, or empty string if not found
+    """
+    discovery = TestDiscovery()
+    result = discovery.discover(project_dir)
+    return result.test_command
+
+
+def get_test_frameworks(project_dir: Path) -> list[str]:
+    """
+    Get list of test framework names in a project.
+
+    Args:
+        project_dir: Path to project root
+
+    Returns:
+        List of framework names
+    """
+    discovery = TestDiscovery()
+    result = discovery.discover(project_dir)
+    return [f.name for f in result.frameworks]
+
+
+# =============================================================================
+# CLI
+# =============================================================================
+
+
+def main() -> None:
+    """CLI entry point for testing."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Discover test frameworks")
+    parser.add_argument("project_dir", type=Path, help="Path to project root")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    args = parser.parse_args()
+
+    discovery = TestDiscovery()
+    result = discovery.discover(args.project_dir)
+
+    if args.json:
+        print(json.dumps(discovery.to_dict(result), indent=2))
+    else:
+        print(f"Package Manager: {result.package_manager or 'unknown'}")
+        print(f"Has Tests: {result.has_tests}")
+        print(f"Test Command: {result.test_command or 'none'}")
+        print(f"Test Directories: {', '.join(result.test_directories) or 'none'}")
+        print(f"Coverage Command: {result.coverage_command or 'none'}")
+        print(f"\nFrameworks ({len(result.frameworks)}):")
+        for f in result.frameworks:
+            print(f"  - {f.name} ({f.type})")
+            print(f"    Command: {f.command}")
+            if f.config_file:
+                print(f"    Config: {f.config_file}")
+            if f.version:
+                print(f"    Version: {f.version}")
+
+
+if __name__ == "__main__":
+    main()
@@ -10,7 +10,6 @@ import shutil
 import subprocess
 from pathlib import Path

-from qa.criteria import is_fixes_applied, is_qa_approved, is_qa_rejected
 from ui import highlight, print_status


@@ -32,7 +31,7 @@ def handle_batch_create_command(batch_file: str, project_dir: str) -> bool:
        return False

    try:
-        with open(batch_path, encoding="utf-8") as f:
+        with open(batch_path) as f:
            batch_data = json.load(f)
    except json.JSONDecodeError as e:
        print_status(f"Invalid JSON in batch file: {e}", "error")
@@ -82,7 +81,7 @@ def handle_batch_create_command(batch_file: str, project_dir: str) -> bool:
        }

        req_file = spec_dir / "requirements.json"
-        with open(req_file, "w", encoding="utf-8") as f:
+        with open(req_file, "w") as f:
            json.dump(requirements, f, indent=2, default=str)

        created_specs.append(
@@ -146,28 +145,19 @@ def handle_batch_status_command(project_dir: str) -> bool:

        if req_file.exists():
            try:
-                with open(req_file, encoding="utf-8") as f:
+                with open(req_file) as f:
                    req = json.load(f)
                    title = req.get("task_description", title)
            except json.JSONDecodeError:
                pass

-        # Determine status (highest priority first)
-        # Use authoritative QA status check, not just file existence
-        if is_qa_approved(spec_dir):
-            status = "qa_approved"
-        elif is_qa_rejected(spec_dir):
-            status = "qa_rejected"
-        elif is_fixes_applied(spec_dir):
-            status = "fixes_applied"
-        elif (spec_dir / "implementation_plan.json").exists():
-            # Check if there's a qa_report.md but no approval yet (QA in progress)
-            if (spec_dir / "qa_report.md").exists():
-                status = "qa_in_progress"
-            else:
-                status = "building"
-        elif (spec_dir / "spec.md").exists():
+        # Determine status
+        if (spec_dir / "spec.md").exists():
            status = "spec_created"
+        elif (spec_dir / "implementation_plan.json").exists():
+            status = "building"
+        elif (spec_dir / "qa_report.md").exists():
+            status = "qa_approved"
        else:
            status = "pending_spec"

@@ -175,10 +165,7 @@ def handle_batch_status_command(project_dir: str) -> bool:
            "pending_spec": "⏳",
            "spec_created": "📋",
            "building": "⚙️",
-            "qa_in_progress": "🔍",
            "qa_approved": "✅",
-            "qa_rejected": "❌",
-            "fixes_applied": "🔧",
            "unknown": "❓",
        }.get(status, "❓")

@@ -205,10 +192,10 @@ def handle_batch_cleanup_command(project_dir: str, dry_run: bool = True) -> bool
        print_status("No specs directory found", "info")
        return True

-    # Find completed specs (only QA-approved, matching status display logic)
+    # Find completed specs
    completed = []
    for spec_dir in specs_dir.iterdir():
-        if spec_dir.is_dir() and is_qa_approved(spec_dir):
+        if spec_dir.is_dir() and (spec_dir / "qa_report.md").exists():
            completed.append(spec_dir.name)

    if not completed:
@@ -87,10 +87,7 @@ def handle_build_command(
        debug_success,
    )
    from phase_config import get_phase_model
-    from prompts_pkg.prompts import (
-        get_base_branch_from_metadata,
-        get_use_local_branch_from_metadata,
-    )
+    from prompts_pkg.prompts import get_base_branch_from_metadata
    from qa_loop import run_qa_validation_loop, should_run_qa

    from .utils import print_banner, validate_environment
@@ -206,9 +203,6 @@ def handle_build_command(
            base_branch = metadata_branch
            debug("run.py", f"Using base branch from task metadata: {base_branch}")

-    # Check if user requested local branch (preserves gitignored files like .env)
-    use_local_branch = get_use_local_branch_from_metadata(spec_dir)
-
    if workspace_mode == WorkspaceMode.ISOLATED:
        # Keep reference to original spec directory for syncing progress back
        source_spec_dir = spec_dir
@@ -219,7 +213,6 @@ def handle_build_command(
            workspace_mode,
            source_spec_dir=spec_dir,
            base_branch=base_branch,
-            use_local_branch=use_local_branch,
        )
        # Use the localized spec directory (inside worktree) for AI access
        if localized_spec_dir:
@@ -428,7 +421,7 @@ def _handle_build_interrupt(
        if human_input:
            # Save to HUMAN_INPUT.md
            input_file = spec_dir / "HUMAN_INPUT.md"
-            input_file.write_text(human_input, encoding="utf-8")
+            input_file.write_text(human_input)

            content = [
                success(f"{icon(Icons.SUCCESS)} INSTRUCTIONS SAVED"),
@@ -449,7 +442,7 @@ def _handle_build_interrupt(
        if choice == "skip":
            print()
            print_status("Resuming build...", "info")
-            status_manager.update(state=BuildState.BUILDING)
+            status_manager.update(state=BuildState.RUNNING)
            asyncio.run(
                run_autonomous_agent(
                    project_dir=working_dir,
@@ -121,7 +121,7 @@ def collect_followup_task(spec_dir: Path, max_retries: int = 3) -> str | None:
                # Expand ~ and resolve path
                file_path = Path(file_path_str).expanduser().resolve()
                if file_path.exists():
-                    followup_task = file_path.read_text(encoding="utf-8").strip()
+                    followup_task = file_path.read_text().strip()
                    if followup_task:
                        print_status(
                            f"Loaded {len(followup_task)} characters from file",
@@ -195,7 +195,7 @@ def collect_followup_task(spec_dir: Path, max_retries: int = 3) -> str | None:

        # Save to FOLLOWUP_REQUEST.md
        request_file = spec_dir / "FOLLOWUP_REQUEST.md"
-        request_file.write_text(followup_task, encoding="utf-8")
+        request_file.write_text(followup_task)

        # Show confirmation
        content = [
@@ -285,7 +285,7 @@ def handle_followup_command(
    # Check for prior follow-ups (for sequential follow-up context)
    prior_followup_count = 0
    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan_data = json.load(f)
        phases = plan_data.get("phases", [])
        # Count phases that look like follow-up phases (name contains "Follow" or high phase number)
@@ -149,7 +149,7 @@ def read_from_file() -> str | None:
        # Expand ~ and resolve path
        file_path = Path(file_path_input).expanduser().resolve()
        if file_path.exists():
-            content = file_path.read_text(encoding="utf-8").strip()
+            content = file_path.read_text().strip()
            if content:
                print_status(
                    f"Loaded {len(content)} characters from file",
@@ -74,12 +74,12 @@ Examples:
  python auto-claude/run.py --spec 001 --qa-status      # Check QA validation status

 Prerequisites:
-  1. Authenticate: Run 'claude' and type '/login'
-  2. Create a spec first: claude /spec
+  1. Create a spec first: claude /spec
+  2. Run 'claude setup-token' and set CLAUDE_CODE_OAUTH_TOKEN

 Environment Variables:
-  CLAUDE_CODE_OAUTH_TOKEN  Your Claude Code OAuth token (auto-detected from Keychain)
-                           Or authenticate via: claude → /login
+  CLAUDE_CODE_OAUTH_TOKEN  Your Claude Code OAuth token (required)
+                           Get it by running: claude setup-token
  AUTO_BUILD_MODEL         Override default model (optional)
        """,
    )
@@ -288,28 +288,6 @@ def main() -> None:
    # Set up environment first
    setup_environment()

-    # Initialize Sentry early to capture any startup errors
-    from core.sentry import capture_exception, init_sentry
-
-    init_sentry(component="cli")
-
-    try:
-        _run_cli()
-    except KeyboardInterrupt:
-        # Clean exit on Ctrl+C
-        sys.exit(130)
-    except Exception as e:
-        # Capture unexpected errors to Sentry
-        capture_exception(e)
-        print(f"\nUnexpected error: {e}")
-        sys.exit(1)
-
-
-def _run_cli() -> None:
-    """Run the CLI logic (extracted for error handling)."""
-    # Import here to avoid import errors during startup
-    from core.sentry import set_context
-
    # Parse arguments
    args = parse_args()

@@ -380,15 +358,6 @@ def _run_cli() -> None:

    debug_success("run.py", "Spec found", spec_dir=str(spec_dir))

-    # Set Sentry context for error tracking
-    set_context(
-        "spec",
-        {
-            "name": spec_dir.name,
-            "project": str(project_dir),
-        },
-    )
-
    # Handle build management commands
    if args.merge_preview:
        from cli.workspace_commands import handle_merge_preview_command
@@ -56,9 +56,7 @@ def import_dotenv():

 # Load .env with helpful error if dependencies not installed
 load_dotenv = import_dotenv()
-# NOTE: graphiti_config is imported lazily in validate_environment() to avoid
-# triggering graphiti_core -> real_ladybug -> pywintypes import chain before
-# platform dependency validation can run. See ACS-253.
+from graphiti_config import get_graphiti_status
 from linear_integration import LinearManager
 from linear_updater import is_linear_enabled
 from spec.pipeline import get_specs_dir
@@ -207,9 +205,6 @@ def validate_environment(spec_dir: Path) -> bool:
        print("Linear integration: DISABLED (set LINEAR_API_KEY to enable)")

    # Check Graphiti integration (optional but show status)
-    # Lazy import to avoid triggering pywintypes import before validation (ACS-253)
-    from graphiti_config import get_graphiti_status
-
    graphiti_status = get_graphiti_status()
    if graphiti_status["available"]:
        print("Graphiti memory: ENABLED")
@@ -182,7 +182,7 @@ def _detect_worktree_base_branch(
    config_path = worktree_path / ".auto-claude" / "worktree-config.json"
    if config_path.exists():
        try:
-            config = json.loads(config_path.read_text(encoding="utf-8"))
+            config = json.loads(config_path.read_text())
            if config.get("base_branch"):
                debug(
                    MODULE,
@@ -536,175 +536,6 @@ def handle_cleanup_worktrees_command(project_dir: Path) -> None:
    cleanup_all_worktrees(project_dir, confirm=True)


-def _detect_conflict_scenario(
-    project_dir: Path,
-    conflicting_files: list[str],
-    spec_branch: str,
-    base_branch: str,
-) -> dict:
-    """
-    Analyze conflicting files to determine the conflict scenario.
-
-    This helps distinguish between:
-    - 'already_merged': Task changes already identical in target branch
-    - 'superseded': Target has newer version of same feature
-    - 'diverged': Standard diverged branches (AI can resolve)
-    - 'normal_conflict': Actual conflicting changes
-
-    Returns dict with:
-    - scenario: 'already_merged' | 'superseded' | 'diverged' | 'normal_conflict'
-    - already_merged_files: files identical in task and target
-    - details: additional context
-    """
-    if not conflicting_files:
-        return {
-            "scenario": "normal_conflict",
-            "already_merged_files": [],
-            "details": "No conflicting files to analyze",
-        }
-
-    already_merged_files = []
-    superseded_files = []
-    diverged_files = []
-
-    try:
-        # Get the merge-base commit
-        merge_base_result = subprocess.run(
-            ["git", "merge-base", base_branch, spec_branch],
-            cwd=project_dir,
-            capture_output=True,
-            text=True,
-        )
-        if merge_base_result.returncode != 0:
-            debug_warning(
-                MODULE, "Could not find merge base for conflict scenario detection"
-            )
-            return {
-                "scenario": "normal_conflict",
-                "already_merged_files": [],
-                "details": "Could not determine merge base",
-            }
-
-        merge_base = merge_base_result.stdout.strip()
-
-        for file_path in conflicting_files:
-            try:
-                # Get content from spec branch (task's changes)
-                spec_content_result = subprocess.run(
-                    ["git", "show", f"{spec_branch}:{file_path}"],
-                    cwd=project_dir,
-                    capture_output=True,
-                    text=True,
-                )
-                # Get content from base branch (target)
-                base_content_result = subprocess.run(
-                    ["git", "show", f"{base_branch}:{file_path}"],
-                    cwd=project_dir,
-                    capture_output=True,
-                    text=True,
-                )
-                # Get content from merge-base (original state)
-                merge_base_content_result = subprocess.run(
-                    ["git", "show", f"{merge_base}:{file_path}"],
-                    cwd=project_dir,
-                    capture_output=True,
-                    text=True,
-                )
-
-                # Check file existence in each ref
-                spec_exists = spec_content_result.returncode == 0
-                base_exists = base_content_result.returncode == 0
-                merge_base_exists = merge_base_content_result.returncode == 0
-
-                if spec_exists and base_exists:
-                    spec_content = spec_content_result.stdout
-                    base_content = base_content_result.stdout
-
-                    # If contents are identical, the changes are already merged
-                    if spec_content == base_content:
-                        already_merged_files.append(file_path)
-                        debug(
-                            MODULE,
-                            f"File {file_path}: already merged (identical content)",
-                        )
-                    elif merge_base_exists:
-                        merge_base_content = merge_base_content_result.stdout
-                        # If base has changed from merge_base but spec matches merge_base,
-                        # the task's changes are superseded by newer changes
-                        if spec_content == merge_base_content:
-                            superseded_files.append(file_path)
-                            debug(
-                                MODULE,
-                                f"File {file_path}: superseded (base has newer changes)",
-                            )
-                        else:
-                            diverged_files.append(file_path)
-                            debug(
-                                MODULE,
-                                f"File {file_path}: diverged (both branches modified)",
-                            )
-                    else:
-                        diverged_files.append(file_path)
-                else:
-                    diverged_files.append(file_path)
-
-            except Exception as e:
-                debug_warning(
-                    MODULE, f"Error analyzing file {file_path} for scenario: {e}"
-                )
-                diverged_files.append(file_path)
-
-        # Determine overall scenario based on dominant pattern
-        total_files = len(conflicting_files)
-
-        if len(already_merged_files) == total_files:
-            scenario = "already_merged"
-            details = "All conflicting files have identical content in both branches"
-        elif len(already_merged_files) > total_files / 2:
-            scenario = "already_merged"
-            details = f"{len(already_merged_files)} of {total_files} files already have the same content"
-        elif len(superseded_files) == total_files:
-            scenario = "superseded"
-            details = "All task changes have been superseded by newer changes in the target branch"
-        elif len(superseded_files) > total_files / 2:
-            scenario = "superseded"
-            details = (
-                f"{len(superseded_files)} of {total_files} files have been superseded"
-            )
-        elif diverged_files:
-            scenario = "diverged"
-            details = f"{len(diverged_files)} files have diverged and need AI merge"
-        else:
-            scenario = "normal_conflict"
-            details = "Standard merge conflicts detected"
-
-        debug(
-            MODULE,
-            f"Conflict scenario: {scenario}",
-            already_merged=len(already_merged_files),
-            superseded=len(superseded_files),
-            diverged=len(diverged_files),
-        )
-
-        return {
-            "scenario": scenario,
-            "already_merged_files": already_merged_files,
-            "superseded_files": superseded_files,
-            "diverged_files": diverged_files,
-            "details": details,
-        }
-
-    except Exception as e:
-        debug_error(MODULE, f"Error detecting conflict scenario: {e}")
-        return {
-            "scenario": "normal_conflict",
-            "already_merged_files": [],
-            "superseded_files": [],
-            "diverged_files": [],
-            "details": f"Error during analysis: {e}",
-        }
-
-
 def _check_git_merge_conflicts(
    project_dir: Path, spec_name: str, base_branch: str | None = None
 ) -> dict:
@@ -1048,24 +879,6 @@ def handle_merge_preview_command(
            f for f in git_conflicts.get("conflicting_files", []) if not is_lock_file(f)
        ]

-        # Detect conflict scenario (already_merged, superseded, diverged, normal_conflict)
-        # This helps the UI show appropriate messaging and actions
-        conflict_scenario = None
-        if non_lock_conflicting_files:
-            conflict_scenario = _detect_conflict_scenario(
-                project_dir,
-                non_lock_conflicting_files,
-                git_conflicts["spec_branch"],
-                git_conflicts["base_branch"],
-            )
-            debug(
-                MODULE,
-                f"Conflict scenario detected: {conflict_scenario.get('scenario')}",
-                already_merged_files=len(
-                    conflict_scenario.get("already_merged_files", [])
-                ),
-            )
-
        # Use git diff file count as the authoritative totalFiles count
        # The semantic tracker may not track all files (e.g., test files, config files)
        # but we want to show the user all files that will be merged
@@ -1139,16 +952,6 @@ def handle_merge_preview_command(
                # Path-mapped files that need AI merge due to renames
                "pathMappedAIMerges": path_mapped_ai_merges,
                "totalRenames": len(path_mappings),
-                # Conflict scenario detection for better UX messaging
-                "scenario": conflict_scenario.get("scenario")
-                if conflict_scenario
-                else None,
-                "alreadyMergedFiles": conflict_scenario.get("already_merged_files", [])
-                if conflict_scenario
-                else [],
-                "scenarioMessage": conflict_scenario.get("details")
-                if conflict_scenario
-                else None,
            },
            "summary": {
                # Use git diff count, not semantic tracker count
@@ -37,12 +37,8 @@ class ContextBuilder:
        """Load project index from file or create new one (.auto-claude is the installed instance)."""
        index_file = self.project_dir / ".auto-claude" / "project_index.json"
        if index_file.exists():
-            try:
-                with open(index_file, encoding="utf-8") as f:
-                    return json.load(f)
-            except (OSError, json.JSONDecodeError, UnicodeDecodeError):
-                # Corrupted or legacy-encoded file, regenerate
-                pass
+            with open(index_file) as f:
+                return json.load(f)

        # Try to create one
        from analyzer import analyze_project
@@ -234,9 +230,7 @@ class ContextBuilder:
        if context_file.exists():
            return {
                "source": "SERVICE_CONTEXT.md",
-                "content": context_file.read_text(encoding="utf-8")[
-                    :2000
-                ],  # First 2000 chars
+                "content": context_file.read_text()[:2000],  # First 2000 chars
            }

        # Generate basic context from service info
@@ -72,7 +72,7 @@ def build_task_context(

    if output_file:
        output_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_file, "w", encoding="utf-8") as f:
+        with open(output_file, "w") as f:
            json.dump(result, f, indent=2)
        print(f"Task context saved to: {output_file}")

@@ -38,7 +38,7 @@ class PatternDiscoverer:
        for match in reference_files[:max_files]:
            try:
                file_path = self.project_dir / match.path
-                content = file_path.read_text(encoding="utf-8", errors="ignore")
+                content = file_path.read_text(errors="ignore")

                # Look for common patterns
                for keyword in keywords:
@@ -41,7 +41,7 @@ class CodeSearcher:

        for file_path in self._iter_code_files(service_path):
            try:
-                content = file_path.read_text(encoding="utf-8", errors="ignore")
+                content = file_path.read_text(errors="ignore")
                content_lower = content.lower()

                # Score this file
@@ -41,7 +41,7 @@ def save_context(context: TaskContext, output_file: Path) -> None:
        output_file: Path to output JSON file
    """
    output_file.parent.mkdir(parents=True, exist_ok=True)
-    with open(output_file, "w", encoding="utf-8") as f:
+    with open(output_file, "w") as f:
        json.dump(serialize_context(context), f, indent=2)


@@ -55,5 +55,5 @@ def load_context(input_file: Path) -> dict:
    Returns:
        Context dictionary
    """
-    with open(input_file, encoding="utf-8") as f:
+    with open(input_file) as f:
        return json.load(f)
@@ -16,102 +16,14 @@ import copy
 import json
 import logging
 import os
+import platform
 import threading
 import time
 from pathlib import Path
 from typing import Any

-from core.fast_mode import ensure_fast_mode_in_user_settings
-from core.platform import (
-    is_windows,
-    validate_cli_path,
-)
-
 logger = logging.getLogger(__name__)

-# =============================================================================
-# SDK Message Parser Patch
-# =============================================================================
-# The Claude Agent SDK's message_parser raises MessageParseError for unknown
-# message types (e.g., "rate_limit_event"). Since parse_message runs inside an
-# async generator, the exception kills the entire agent session stream.
-# Patch to log a warning and return a SystemMessage instead of crashing.
-# This is needed until the SDK natively handles all CLI message types.
-
-
-def _patch_sdk_message_parser() -> None:
-    """Patch the SDK's parse_message to handle unknown message types gracefully.
-
-    The Claude CLI may emit message types that the installed SDK version doesn't
-    recognize (e.g., rate_limit_event, usage_event). Without this patch, any
-    unrecognized type raises MessageParseError inside the SDK's async generator,
-    which terminates the entire response stream and kills the agent session.
-
-    The patch converts unknown types into SystemMessage objects with a
-    'unknown_<type>' subtype, which all message consumers silently skip.
-    """
-    try:
-        import claude_agent_sdk._internal.message_parser as _parser
-        from claude_agent_sdk._errors import MessageParseError
-        from claude_agent_sdk.types import SystemMessage
-
-        _original_parse = _parser.parse_message
-
-        def _patched_parse(data):
-            try:
-                return _original_parse(data)
-            except MessageParseError as e:
-                msg = str(e)
-                if "Unknown message type" in msg:
-                    msg_type = (
-                        data.get("type", "unknown")
-                        if isinstance(data, dict)
-                        else "unknown"
-                    )
-                    # Rate limit events deserve a visible warning; others just debug-level
-                    if "rate_limit" in msg_type:
-                        retry_after = (
-                            data.get("retry_after")
-                            or data.get("data", {}).get("retry_after")
-                            if isinstance(data, dict)
-                            else None
-                        )
-                        retry_info = (
-                            f" (retry_after={retry_after}s)" if retry_after else ""
-                        )
-                        logger.warning(
-                            f"Rate limit event received from CLI{retry_info} — "
-                            f"the SDK will handle backoff automatically"
-                        )
-                    else:
-                        logger.debug(
-                            f"SDK received unhandled message type '{msg_type}', skipping"
-                        )
-                    return SystemMessage(
-                        subtype=f"unknown_{msg_type}",
-                        data=data if isinstance(data, dict) else {},
-                    )
-                raise
-
-        _parser.parse_message = _patched_parse
-    except Exception as e:
-        logger.warning(f"Failed to patch SDK message parser: {e}")
-
-
-_patch_sdk_message_parser()
-
-# =============================================================================
-# Windows System Prompt Limits
-# =============================================================================
-# Windows CreateProcessW has a 32,768 character limit for the entire command line.
-# When CLAUDE.md is very large and passed as --system-prompt, the command can exceed
-# this limit, causing ERROR_FILE_NOT_FOUND. We cap CLAUDE.md content to stay safe.
-# 20,000 chars leaves ~12KB headroom for CLI overhead (model, tools, MCP config, etc.)
-WINDOWS_MAX_SYSTEM_PROMPT_CHARS = 20000
-WINDOWS_TRUNCATION_MESSAGE = (
-    "\n\n[... CLAUDE.md truncated due to Windows command-line length limit ...]"
-)
-
 # =============================================================================
 # Project Index Cache
 # =============================================================================
@@ -222,10 +134,7 @@ from agents.tools_pkg import (
 )
 from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
 from claude_agent_sdk.types import HookMatcher
-from core.auth import (
-    configure_sdk_authentication,
-    get_sdk_env_vars,
-)
+from core.auth import get_sdk_env_vars, require_auth_token
 from linear_updater import is_linear_enabled
 from prompts_pkg.project_context import detect_project_capabilities, load_project_index
 from security import bash_security_hook
@@ -533,9 +442,6 @@ def create_client(
    max_thinking_tokens: int | None = None,
    output_format: dict | None = None,
    agents: dict | None = None,
-    betas: list[str] | None = None,
-    effort_level: str | None = None,
-    fast_mode: bool = False,
 ) -> ClaudeSDKClient:
    """
    Create a Claude Agent SDK client with multi-layered security.
@@ -551,9 +457,10 @@ def create_client(
        agent_type: Agent type identifier from AGENT_CONFIGS
                   (e.g., 'coder', 'planner', 'qa_reviewer', 'spec_gatherer')
        max_thinking_tokens: Token budget for extended thinking (None = disabled)
-                            - high: 16384 (spec creation, QA review)
-                            - medium: 4096 (planning, validation)
-                            - low: 1024 (coding)
+                            - ultrathink: 16000 (spec creation)
+                            - high: 10000 (QA review)
+                            - medium: 5000 (planning, validation)
+                            - None: disabled (coding)
        output_format: Optional structured output format for validated JSON responses.
                      Use {"type": "json_schema", "schema": Model.model_json_schema()}
                      See: https://platform.claude.com/docs/en/agent-sdk/structured-outputs
@@ -561,16 +468,6 @@ def create_client(
               Format: {"agent-name": {"description": "...", "prompt": "...",
                        "tools": [...], "model": "inherit"}}
               See: https://platform.claude.com/docs/en/agent-sdk/subagents
-        betas: Optional list of SDK beta header strings (e.g., ["context-1m-2025-08-07"]
-               for 1M context window). Use get_phase_model_betas() to compute from config.
-        effort_level: Optional effort level for adaptive thinking models (e.g., "low",
-                     "medium", "high"). When set, injected as CLAUDE_CODE_EFFORT_LEVEL
-                     env var for the SDK subprocess. Only meaningful for models that
-                     support adaptive thinking (e.g., Opus 4.6).
-        fast_mode: Enable Fast Mode for faster Opus 4.6 output. When True, enables
-                  the "user" setting source so the CLI reads fastMode from
-                  ~/.claude/settings.json. Requires extra usage enabled on Claude
-                  subscription; falls back to standard speed automatically.

    Returns:
        Configured ClaudeSDKClient
@@ -585,41 +482,17 @@ def create_client(
       (see security.py for ALLOWED_COMMANDS)
    4. Tool filtering - Each agent type only sees relevant tools (prevents misuse)
    """
-    # Collect env vars to pass to SDK (ANTHROPIC_BASE_URL, CLAUDE_CONFIG_DIR, etc.)
+    oauth_token = require_auth_token()
+    # Ensure SDK can access it via its expected env var
+    os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
+
+    # Collect env vars to pass to SDK (ANTHROPIC_BASE_URL, etc.)
    sdk_env = get_sdk_env_vars()

-    # Get the config dir for profile-specific credential lookup
-    # CLAUDE_CONFIG_DIR enables per-profile Keychain entries with SHA256-hashed service names
-    config_dir = sdk_env.get("CLAUDE_CONFIG_DIR")
-
-    # Configure SDK authentication (OAuth or API profile mode)
-    configure_sdk_authentication(config_dir)
-
-    if config_dir:
-        logger.info(f"Using CLAUDE_CONFIG_DIR for profile: {config_dir}")
-
-    # Inject effort level for adaptive thinking models (e.g., Opus 4.6)
-    if effort_level:
-        sdk_env["CLAUDE_CODE_EFFORT_LEVEL"] = effort_level
-
-    # Fast mode requires the CLI to read "fastMode" from user settings.
-    # The SDK default (setting_sources=None) passes --setting-sources "" which
-    # blocks ALL filesystem settings. We must explicitly enable "user" source
-    # so the CLI reads ~/.claude/settings.json where fastMode: true lives.
-    # See: https://code.claude.com/docs/en/fast-mode
-    if fast_mode:
-        ensure_fast_mode_in_user_settings()
-        logger.info("[Fast Mode] ACTIVE — will enable user setting source for fastMode")
-        print(
-            "[Fast Mode] ACTIVE — enabling user settings source for CLI to read fastMode"
-        )
-    else:
-        logger.info("[Fast Mode] inactive — not requested for this client")
-
    # Debug: Log git-bash path detection on Windows
    if "CLAUDE_CODE_GIT_BASH_PATH" in sdk_env:
        logger.info(f"Git Bash path found: {sdk_env['CLAUDE_CODE_GIT_BASH_PATH']}")
-    elif is_windows():
+    elif platform.system() == "Windows":
        logger.warning("Git Bash path not detected on Windows!")

    # Check if Linear integration is enabled
@@ -769,7 +642,7 @@ def create_client(

    # Write settings to a file in the project directory
    settings_file = project_dir / ".claude_settings.json"
-    with open(settings_file, "w", encoding="utf-8") as f:
+    with open(settings_file, "w") as f:
        json.dump(security_settings, f, indent=2)

    print(f"Security settings: {settings_file}")
@@ -779,12 +652,7 @@ def create_client(
        print("   - Worktree permissions: granted for original project directories")
    print("   - Bash commands restricted to allowlist")
    if max_thinking_tokens:
-        thinking_info = f"{max_thinking_tokens:,} tokens"
-        if effort_level:
-            thinking_info += f" + effort={effort_level}"
-        if fast_mode:
-            thinking_info += " + fast mode"
-        print(f"   - Extended thinking: {thinking_info}")
+        print(f"   - Extended thinking: {max_thinking_tokens:,} tokens")
    else:
        print("   - Extended thinking: disabled")

@@ -904,31 +772,8 @@ def create_client(
    if should_use_claude_md():
        claude_md_content = load_claude_md(project_dir)
        if claude_md_content:
-            # On Windows, the SDK passes system_prompt as a --system-prompt CLI argument.
-            # Windows CreateProcessW has a 32,768 character limit for the entire command line.
-            # When CLAUDE.md is very large, the command can exceed this limit, causing Windows
-            # to return ERROR_FILE_NOT_FOUND which the SDK misreports as "Claude Code not found".
-            # Cap CLAUDE.md content to keep total command line under the limit. (#1661)
-            was_truncated = False
-            if is_windows():
-                max_claude_md_chars = (
-                    WINDOWS_MAX_SYSTEM_PROMPT_CHARS
-                    - len(base_prompt)
-                    - len(WINDOWS_TRUNCATION_MESSAGE)
-                    - len("\n\n# Project Instructions (from CLAUDE.md)\n\n")
-                )
-                if len(claude_md_content) > max_claude_md_chars > 0:
-                    claude_md_content = (
-                        claude_md_content[:max_claude_md_chars]
-                        + WINDOWS_TRUNCATION_MESSAGE
-                    )
-                    print(
-                        "   - CLAUDE.md: truncated (exceeded Windows command-line limit)"
-                    )
-                    was_truncated = True
            base_prompt = f"{base_prompt}\n\n# Project Instructions (from CLAUDE.md)\n\n{claude_md_content}"
-            if not was_truncated:
-                print("   - CLAUDE.md: included in system prompt")
+            print("   - CLAUDE.md: included in system prompt")
        else:
            print("   - CLAUDE.md: not found in project root")
    else:
@@ -936,7 +781,7 @@ def create_client(
    print()

    # Build options dict, conditionally including output_format
-    options_kwargs: dict[str, Any] = {
+    options_kwargs = {
        "model": model,
        "system_prompt": base_prompt,
        "allowed_tools": allowed_tools_list,
@@ -959,19 +804,6 @@ def create_client(
        "enable_file_checkpointing": True,
    }

-    # Fast mode: enable user setting source so CLI reads fastMode from
-    # ~/.claude/settings.json. Without this, the SDK's default --setting-sources ""
-    # blocks all filesystem settings and the CLI never sees fastMode: true.
-    if fast_mode:
-        options_kwargs["setting_sources"] = ["user"]
-
-    # Optional: Allow CLI path override via environment variable
-    # The SDK bundles its own CLI, but users can override if needed
-    env_cli_path = os.environ.get("CLAUDE_CLI_PATH")
-    if env_cli_path and validate_cli_path(env_cli_path):
-        options_kwargs["cli_path"] = env_cli_path
-        logger.info(f"Using CLAUDE_CLI_PATH override: {env_cli_path}")
-
    # Add structured output format if specified
    # See: https://platform.claude.com/docs/en/agent-sdk/structured-outputs
    if output_format:
@@ -982,8 +814,4 @@ def create_client(
    if agents:
        options_kwargs["agents"] = agents

-    # Add beta headers if specified (e.g., for 1M context window)
-    if betas:
-        options_kwargs["betas"] = betas
-
    return ClaudeSDKClient(options=ClaudeAgentOptions(**options_kwargs))
@@ -110,7 +110,7 @@ def _write_log(message: str, to_file: bool = True) -> None:
                import re

                clean_message = re.sub(r"\033\[[0-9;]*m", "", message)
-                with open(log_file, "a", encoding="utf-8") as f:
+                with open(log_file, "a") as f:
                    f.write(clean_message + "\n")
            except Exception:
                pass  # Silently fail file logging
@@ -8,8 +8,6 @@ Validates platform-specific dependencies are installed before running agents.
 import sys
 from pathlib import Path

-from core.platform import is_linux, is_windows
-

 def validate_platform_dependencies() -> None:
    """
@@ -19,116 +17,34 @@ def validate_platform_dependencies() -> None:
        SystemExit: If required platform-specific dependencies are missing,
                   with helpful installation instructions.
    """
-    # Check Windows-specific dependencies (all Python versions per ACS-306)
-    # pywin32 is required on all Python versions on Windows - MCP library unconditionally imports win32api
-    if is_windows():
+    # Check Windows-specific dependencies
+    if sys.platform == "win32" and sys.version_info >= (3, 12):
        try:
            import pywintypes  # noqa: F401
        except ImportError:
            _exit_with_pywin32_error()

-    # Check Linux-specific dependencies (ACS-310)
-    # Note: secretstorage is optional for app functionality (falls back to .env),
-    # but we validate it to ensure proper OAuth token storage via keyring
-    if is_linux():
-        try:
-            import secretstorage  # noqa: F401
-        except ImportError:
-            _warn_missing_secretstorage()
-

 def _exit_with_pywin32_error() -> None:
    """Exit with helpful error message for missing pywin32."""
    # Use sys.prefix to detect the virtual environment path
    # This works for venv and poetry environments
-    # Check for common Windows activation scripts (activate, activate.bat, Activate.ps1)
-    scripts_dir = Path(sys.prefix) / "Scripts"
-    activation_candidates = [
-        scripts_dir / "activate",
-        scripts_dir / "activate.bat",
-        scripts_dir / "Activate.ps1",
-    ]
-    venv_activate = next((p for p in activation_candidates if p.exists()), None)
-
-    # Build activation step only if activate script exists
-    activation_step = ""
-    if venv_activate:
-        activation_step = (
-            "To fix this:\n"
-            "1. Activate your virtual environment:\n"
-            f"   {venv_activate}\n"
-            "\n"
-            "2. Install pywin32:\n"
-            "   pip install pywin32>=306\n"
-            "\n"
-            "   Or reinstall all dependencies:\n"
-            "   pip install -r requirements.txt\n"
-        )
-    else:
-        # For system Python or environments without activate script
-        activation_step = (
-            "To fix this:\n"
-            "Install pywin32:\n"
-            "   pip install pywin32>=306\n"
-            "\n"
-            "   Or reinstall all dependencies:\n"
-            "   pip install -r requirements.txt\n"
-        )
+    venv_activate = Path(sys.prefix) / "Scripts" / "activate"

    sys.exit(
        "Error: Required Windows dependency 'pywin32' is not installed.\n"
        "\n"
-        "Auto Claude requires pywin32 on Windows for:\n"
-        "  - MCP library (win32api, win32con, win32job modules)\n"
-        "  - LadybugDB/Graphiti memory integration\n"
+        "Auto Claude requires pywin32 on Windows for LadybugDB/Graphiti memory integration.\n"
        "\n"
-        f"{activation_step}"
+        "To fix this:\n"
+        "1. Activate your virtual environment:\n"
+        f"   {venv_activate}\n"
        "\n"
-        f"Current Python: {sys.executable}\n"
-    )
-
-
-def _warn_missing_secretstorage() -> None:
-    """Emit warning message for missing secretstorage.
-
-    Note: This is a warning, not a hard error - the app will fall back to .env
-    file storage for OAuth tokens. We warn users to ensure they understand the
-    security implications.
-    """
-    # Use sys.prefix to detect the virtual environment path
-    venv_activate = Path(sys.prefix) / "bin" / "activate"
-    # Only include activation instruction if venv script actually exists
-    activation_prefix = (
-        f"1. Activate your virtual environment:\n   source {venv_activate}\n\n"
-        if venv_activate.exists()
-        else ""
-    )
-    # Adjust step number based on whether activation step is included
-    install_step = (
-        "2. Install secretstorage:\n"
-        if activation_prefix
-        else "Install secretstorage:\n"
-    )
-
-    sys.stderr.write(
-        "Warning: Linux dependency 'secretstorage' is not installed.\n"
-        "\n"
-        "Auto Claude can use secretstorage for secure OAuth token storage via\n"
-        "the system keyring (gnome-keyring, kwallet, etc.). Without it, tokens\n"
-        "will be stored in plaintext in your .env file.\n"
-        "\n"
-        "To enable keyring integration:\n"
-        f"{activation_prefix}"
-        f"{install_step}"
-        "   pip install 'secretstorage>=3.3.3'\n"
+        "2. Install pywin32:\n"
+        "   pip install pywin32>=306\n"
        "\n"
        "   Or reinstall all dependencies:\n"
        "   pip install -r requirements.txt\n"
        "\n"
-        "Note: The app will continue to work, but OAuth tokens will be stored\n"
-        "in your .env file instead of the system keyring.\n"
-        "\n"
        f"Current Python: {sys.executable}\n"
    )
-    sys.stderr.flush()
-    # Continue execution - this is a warning, not a blocking error
@@ -1,188 +0,0 @@
-"""
-Shared Error Utilities
-======================
-
-Common error detection and classification functions used across
-agent sessions, QA, and other modules.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from claude_agent_sdk.types import Message
-
-logger = logging.getLogger(__name__)
-
-
-def is_tool_concurrency_error(error: Exception) -> bool:
-    """
-    Check if an error is a 400 tool concurrency error from Claude API.
-
-    Tool concurrency errors occur when too many tools are used simultaneously
-    in a single API request, hitting Claude's concurrent tool use limit.
-
-    Args:
-        error: The exception to check
-
-    Returns:
-        True if this is a tool concurrency error, False otherwise
-    """
-    error_str = str(error).lower()
-    # Check for 400 status AND tool concurrency keywords
-    return "400" in error_str and (
-        ("tool" in error_str and "concurrency" in error_str)
-        or "too many tools" in error_str
-        or "concurrent tool" in error_str
-    )
-
-
-def is_rate_limit_error(error: Exception) -> bool:
-    """
-    Check if an error is a rate limit error (429 or similar).
-
-    Rate limit errors occur when the API usage quota is exceeded,
-    either for session limits or weekly limits.
-
-    Args:
-        error: The exception to check
-
-    Returns:
-        True if this is a rate limit error, False otherwise
-    """
-    error_str = str(error).lower()
-
-    # Check for HTTP 429 with word boundaries to avoid false positives
-    if re.search(r"\b429\b", error_str):
-        return True
-
-    # Check for other rate limit indicators
-    return any(
-        p in error_str
-        for p in [
-            "limit reached",
-            "rate limit",
-            "too many requests",
-            "usage limit",
-            "quota exceeded",
-        ]
-    )
-
-
-def is_authentication_error(error: Exception) -> bool:
-    """
-    Check if an error is an authentication error (401, token expired, etc.).
-
-    Authentication errors occur when OAuth tokens are invalid, expired,
-    or have been revoked (e.g., after token refresh on another process).
-
-    Validation approach:
-    - HTTP 401 status code is checked with word boundaries to minimize false positives
-    - Additional string patterns are validated against lowercase error messages
-    - Patterns are designed to match known Claude API and OAuth error formats
-
-    Known false positive risks:
-    - Generic error messages containing "unauthorized" or "access denied" may match
-      even if not related to authentication (e.g., file permission errors)
-    - Error messages containing these keywords in user-provided content could match
-    - Mitigation: HTTP 401 check provides strong signal; string patterns are secondary
-
-    Real-world validation:
-    - Pattern matching has been tested against actual Claude API error responses
-    - False positive rate is acceptable given the recovery mechanism (prompt user to re-auth)
-    - If false positive occurs, user can simply resume without re-authenticating
-
-    Args:
-        error: The exception to check
-
-    Returns:
-        True if this is an authentication error, False otherwise
-    """
-    error_str = str(error).lower()
-
-    # Check for HTTP 401 with word boundaries to avoid false positives
-    if re.search(r"\b401\b", error_str):
-        return True
-
-    # Check for other authentication indicators
-    # NOTE: "authentication failed" and "authentication error" are more specific patterns
-    # to reduce false positives from generic "authentication" mentions
-    return any(
-        p in error_str
-        for p in [
-            "authentication failed",
-            "authentication error",
-            "unauthorized",
-            "invalid token",
-            "token expired",
-            "authentication_error",
-            "invalid_token",
-            "token_expired",
-            "not authenticated",
-            "http 401",
-            "does not have access to claude",
-            "please login again",
-        ]
-    )
-
-
-async def safe_receive_messages(
-    client,
-    *,
-    caller: str = "agent",
-) -> AsyncIterator[Message]:
-    """Iterate over SDK messages with resilience against unexpected errors.
-
-    The SDK's ``receive_response()`` async generator can terminate early if:
-    1. An unhandled message type slips past the monkey-patch (e.g., SDK upgrade
-       removes the patch surface).
-    2. A transient parse error corrupts a single message in the stream.
-    3. An unexpected ``StopAsyncIteration`` or runtime error occurs mid-stream.
-
-    This wrapper catches per-message errors, logs them, and continues yielding
-    subsequent messages so the agent session can complete its work.
-
-    It also detects rate-limit events (surfaced as ``SystemMessage`` with
-    subtype ``unknown_rate_limit_event``) and logs a user-visible warning.
-
-    Args:
-        client: A ``ClaudeSDKClient`` instance (must be inside ``async with``).
-        caller: Label for log messages (e.g., "session", "agent_runner").
-
-    Yields:
-        Parsed ``Message`` objects from the SDK response stream.
-    """
-    try:
-        async for msg in client.receive_response():
-            # Detect rate-limit events surfaced by the monkey-patch
-            msg_type = type(msg).__name__
-            if msg_type == "SystemMessage":
-                subtype = getattr(msg, "subtype", "")
-                if subtype.startswith("unknown_"):
-                    original_type = subtype[len("unknown_") :]
-                    if "rate_limit" in original_type:
-                        data = getattr(msg, "data", {})
-                        retry_after = data.get("retry_after") or data.get(
-                            "data", {}
-                        ).get("retry_after")
-                        retry_info = (
-                            f" (retry in {retry_after}s)" if retry_after else ""
-                        )
-                        logger.warning(f"[{caller}] Rate limit event{retry_info}")
-                    else:
-                        logger.debug(
-                            f"[{caller}] Skipping unknown SDK message type: {original_type}"
-                        )
-                    continue
-            yield msg
-    except GeneratorExit:
-        return
-    except Exception as e:
-        # If the generator itself raises (e.g., transport error), log and stop
-        # gracefully so callers can process whatever was collected so far.
-        logger.error(f"[{caller}] SDK response stream terminated unexpectedly: {e}")
-        return
@@ -1,76 +0,0 @@
-"""
-Fast Mode Settings Helper
-=========================
-
-Manages the fastMode flag in ~/.claude/settings.json for temporary
-per-task fast mode overrides. Shared by both client.py and simple_client.py.
-"""
-
-import json
-import logging
-from pathlib import Path
-
-from core.file_utils import write_json_atomic
-
-logger = logging.getLogger(__name__)
-
-_fast_mode_atexit_registered = False
-
-
-def _write_fast_mode_setting(enabled: bool) -> None:
-    """Write fastMode value to ~/.claude/settings.json (atomic read-modify-write).
-
-    Uses write_json_atomic from core.file_utils to prevent corruption when
-    multiple concurrent task processes modify the file simultaneously.
-    """
-    settings_file = Path.home() / ".claude" / "settings.json"
-    try:
-        settings: dict = {}
-        if settings_file.exists():
-            settings = json.loads(settings_file.read_text(encoding="utf-8"))
-
-        if settings.get("fastMode") != enabled:
-            settings["fastMode"] = enabled
-            settings_file.parent.mkdir(parents=True, exist_ok=True)
-            # Atomic write using shared utility
-            write_json_atomic(settings_file, settings)
-            state = "true" if enabled else "false"
-            logger.info(
-                f"[Fast Mode] Wrote fastMode={state} to ~/.claude/settings.json"
-            )
-    except Exception as e:
-        logger.warning(f"[Fast Mode] Could not update ~/.claude/settings.json: {e}")
-
-
-def _disable_fast_mode_on_exit() -> None:
-    """atexit handler: restore fastMode=false so interactive CLI sessions stay standard."""
-    _write_fast_mode_setting(False)
-
-
-def ensure_fast_mode_in_user_settings() -> None:
-    """
-    Enable fastMode in ~/.claude/settings.json and register cleanup.
-
-    The CLI reads fastMode from user settings (loaded via --setting-sources user).
-    This function:
-    1. Writes fastMode=true before spawning the CLI subprocess
-    2. Registers an atexit handler to restore fastMode=false when the process exits
-
-    This ensures fast mode is a temporary override per task process, not a permanent
-    setting change. The CLI subprocess reads settings at startup, so restoring false
-    after exit doesn't affect running tasks — only prevents fast mode from leaking
-    into subsequent interactive CLI sessions or non-fast-mode tasks.
-    """
-    global _fast_mode_atexit_registered
-
-    _write_fast_mode_setting(True)
-
-    # Register cleanup once per process — idempotent on repeated calls
-    if not _fast_mode_atexit_registered:
-        import atexit
-
-        atexit.register(_disable_fast_mode_on_exit)
-        _fast_mode_atexit_registered = True
-        logger.info(
-            "[Fast Mode] Registered atexit cleanup (will restore fastMode=false)"
-        )
@@ -1,192 +0,0 @@
-#!/usr/bin/env python3
-"""
-GitHub CLI Executable Finder
-============================
-
-Utility to find the gh (GitHub CLI) executable, with platform-specific fallbacks.
-"""
-
-import os
-import shutil
-import subprocess
-
-from core.platform import get_where_exe_path
-
-_cached_gh_path: str | None = None
-
-
-def invalidate_gh_cache() -> None:
-    """Invalidate the cached gh executable path.
-
-    Useful when gh may have been uninstalled, updated, or when
-    GITHUB_CLI_PATH environment variable has changed.
-    """
-    global _cached_gh_path
-    _cached_gh_path = None
-
-
-def _verify_gh_executable(path: str) -> bool:
-    """Verify that a path is a valid gh executable by checking version.
-
-    Args:
-        path: Path to the potential gh executable
-
-    Returns:
-        True if the path points to a valid gh executable, False otherwise
-    """
-    try:
-        result = subprocess.run(
-            [path, "--version"],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            timeout=5,
-        )
-        return result.returncode == 0
-    except (subprocess.TimeoutExpired, OSError):
-        return False
-
-
-def _run_where_command() -> str | None:
-    """Run Windows 'where gh' command to find gh executable.
-
-    Returns:
-        First path found, or None if command failed
-    """
-    try:
-        result = subprocess.run(
-            [get_where_exe_path(), "gh"],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            timeout=5,
-        )
-        if result.returncode == 0 and result.stdout.strip():
-            found_path = result.stdout.strip().split("\n")[0].strip()
-            if (
-                found_path
-                and os.path.isfile(found_path)
-                and _verify_gh_executable(found_path)
-            ):
-                return found_path
-    except (subprocess.TimeoutExpired, OSError):
-        # 'where' command failed or timed out - fall through to return None
-        pass
-    return None
-
-
-def get_gh_executable() -> str | None:
-    """Find the gh executable, with platform-specific fallbacks.
-
-    Returns the path to gh executable, or None if not found.
-
-    Priority order:
-    1. GITHUB_CLI_PATH env var (user-configured path from frontend)
-    2. shutil.which (if gh is in PATH)
-    3. Homebrew paths on macOS
-    4. Windows Program Files paths
-    5. Windows 'where' command
-
-    Caches the result after first successful find. Use invalidate_gh_cache()
-    to force re-detection (e.g., after gh installation/uninstallation).
-    """
-    global _cached_gh_path
-
-    # Return cached result if available AND still exists
-    if _cached_gh_path is not None and os.path.isfile(_cached_gh_path):
-        return _cached_gh_path
-
-    _cached_gh_path = _find_gh_executable()
-    return _cached_gh_path
-
-
-def _find_gh_executable() -> str | None:
-    """Internal function to find gh executable."""
-    # 1. Check GITHUB_CLI_PATH env var (set by Electron frontend)
-    env_path = os.environ.get("GITHUB_CLI_PATH")
-    if env_path and os.path.isfile(env_path) and _verify_gh_executable(env_path):
-        return env_path
-
-    # 2. Try shutil.which (works if gh is in PATH)
-    gh_path = shutil.which("gh")
-    if gh_path and _verify_gh_executable(gh_path):
-        return gh_path
-
-    # 3. macOS-specific: check Homebrew paths
-    if os.name != "nt":  # Unix-like systems (macOS, Linux)
-        homebrew_paths = [
-            "/opt/homebrew/bin/gh",  # Apple Silicon
-            "/usr/local/bin/gh",  # Intel Mac
-            "/home/linuxbrew/.linuxbrew/bin/gh",  # Linux Homebrew
-        ]
-        for path in homebrew_paths:
-            if os.path.isfile(path) and _verify_gh_executable(path):
-                return path
-
-    # 4. Windows-specific: check Program Files paths
-    if os.name == "nt":
-        windows_paths = [
-            os.path.expandvars(r"%PROGRAMFILES%\GitHub CLI\gh.exe"),
-            os.path.expandvars(r"%PROGRAMFILES(X86)%\GitHub CLI\gh.exe"),
-            os.path.expandvars(r"%LOCALAPPDATA%\Programs\GitHub CLI\gh.exe"),
-        ]
-        for path in windows_paths:
-            if os.path.isfile(path) and _verify_gh_executable(path):
-                return path
-
-        # 5. Try 'where' command with full path (works even when System32 isn't in PATH)
-        return _run_where_command()
-
-    return None
-
-
-def run_gh(
-    args: list[str],
-    cwd: str | None = None,
-    timeout: int = 60,
-    input_data: str | None = None,
-) -> subprocess.CompletedProcess:
-    """Run a gh command with proper executable finding.
-
-    Args:
-        args: gh command arguments (without 'gh' prefix)
-        cwd: Working directory for the command
-        timeout: Command timeout in seconds (default: 60)
-        input_data: Optional string data to pass to stdin
-
-    Returns:
-        CompletedProcess with command results.
-    """
-    gh = get_gh_executable()
-    if not gh:
-        return subprocess.CompletedProcess(
-            args=["gh"] + args,
-            returncode=-1,
-            stdout="",
-            stderr="GitHub CLI (gh) not found. Install from https://cli.github.com/",
-        )
-    try:
-        return subprocess.run(
-            [gh] + args,
-            cwd=cwd,
-            input=input_data,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        return subprocess.CompletedProcess(
-            args=[gh] + args,
-            returncode=-1,
-            stdout="",
-            stderr=f"Command timed out after {timeout} seconds",
-        )
-    except FileNotFoundError:
-        return subprocess.CompletedProcess(
-            args=[gh] + args,
-            returncode=-1,
-            stdout="",
-            stderr="GitHub CLI (gh) executable not found. Install from https://cli.github.com/",
-        )
@@ -1,12 +1,9 @@
 #!/usr/bin/env python3
 """
-Git Executable Finder and Isolation
-====================================
+Git Executable Finder
+======================

 Utility to find the git executable, with Windows-specific fallbacks.
-Also provides environment isolation to prevent pre-commit hooks and
-other git configurations from affecting worktree operations.
-
 Separated into its own module to avoid circular imports.
 """

@@ -15,55 +12,9 @@ import shutil
 import subprocess
 from pathlib import Path

-from core.platform import get_where_exe_path
-
-# Git environment variables that can interfere with worktree operations
-# when set by pre-commit hooks or other git configurations.
-# These must be cleared to prevent cross-worktree contamination.
-GIT_ENV_VARS_TO_CLEAR = [
-    "GIT_DIR",
-    "GIT_WORK_TREE",
-    "GIT_INDEX_FILE",
-    "GIT_OBJECT_DIRECTORY",
-    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-    # Identity variables that could be set by hooks
-    "GIT_AUTHOR_NAME",
-    "GIT_AUTHOR_EMAIL",
-    "GIT_AUTHOR_DATE",
-    "GIT_COMMITTER_NAME",
-    "GIT_COMMITTER_EMAIL",
-    "GIT_COMMITTER_DATE",
-]
-
 _cached_git_path: str | None = None


-def get_isolated_git_env(base_env: dict | None = None) -> dict:
-    """
-    Create an isolated environment for git operations.
-
-    Clears git environment variables that may be set by pre-commit hooks
-    or other git configurations, preventing cross-worktree contamination
-    and ensuring git operations target the intended repository.
-
-    Args:
-        base_env: Base environment dict to copy from. If None, uses os.environ.
-
-    Returns:
-        Environment dict safe for git subprocess operations.
-    """
-    env = dict(base_env) if base_env is not None else os.environ.copy()
-
-    for key in GIT_ENV_VARS_TO_CLEAR:
-        env.pop(key, None)
-
-    # Disable user's pre-commit hooks during Auto-Claude managed git operations
-    # to prevent double-hook execution and potential conflicts
-    env["HUSKY"] = "0"
-
-    return env
-
-
 def get_git_executable() -> str:
    """Find the git executable, with Windows-specific fallbacks.

@@ -126,13 +77,14 @@ def _find_git_executable() -> str:
            except OSError:
                continue

-        # 4. Try 'where' command with full path (works even when System32 isn't in PATH)
+        # 4. Try 'where' command with shell=True (more reliable on Windows)
        try:
            result = subprocess.run(
-                [get_where_exe_path(), "git"],
+                "where git",
                capture_output=True,
                text=True,
                timeout=5,
+                shell=True,
            )
            if result.returncode == 0 and result.stdout.strip():
                found_path = result.stdout.strip().split("\n")[0].strip()
@@ -150,27 +102,19 @@ def run_git(
    cwd: Path | str | None = None,
    timeout: int = 60,
    input_data: str | None = None,
-    env: dict | None = None,
-    isolate_env: bool = True,
 ) -> subprocess.CompletedProcess:
-    """Run a git command with proper executable finding and environment isolation.
+    """Run a git command with proper executable finding.

    Args:
        args: Git command arguments (without 'git' prefix)
        cwd: Working directory for the command
        timeout: Command timeout in seconds (default: 60)
        input_data: Optional string data to pass to stdin
-        env: Custom environment dict. If None and isolate_env=True, uses isolated env.
-        isolate_env: If True (default), clears git env vars to prevent hook interference.

    Returns:
        CompletedProcess with command results.
    """
    git = get_git_executable()
-
-    if env is None and isolate_env:
-        env = get_isolated_git_env()
-
    try:
        return subprocess.run(
            [git] + args,
@@ -181,7 +125,6 @@ def run_git(
            encoding="utf-8",
            errors="replace",
            timeout=timeout,
-            env=env,
        )
    except subprocess.TimeoutExpired:
        return subprocess.CompletedProcess(
@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-"""
-Git Provider Detection
-======================
-
-Utility to detect git hosting provider (GitHub, GitLab, or unknown) from git remote URLs.
-Supports both SSH and HTTPS remote formats, and self-hosted GitLab instances.
-"""
-
-import re
-from pathlib import Path
-
-from .git_executable import run_git
-
-
-def detect_git_provider(project_dir: str | Path, remote_name: str | None = None) -> str:
-    """Detect the git hosting provider from the git remote URL.
-
-    Args:
-        project_dir: Path to the git repository
-        remote_name: Name of the remote to check (defaults to "origin")
-
-    Returns:
-        'github' if GitHub remote detected
-        'gitlab' if GitLab remote detected (cloud or self-hosted)
-        'unknown' if no remote or unsupported provider
-
-    Examples:
-        >>> detect_git_provider('/path/to/repo')
-        'github'  # for git@github.com:user/repo.git
-        'gitlab'  # for git@gitlab.com:user/repo.git
-        'gitlab'  # for https://gitlab.company.com/user/repo.git
-        'unknown' # for no remote or other providers
-    """
-    try:
-        # Get the remote URL (use specified remote or default to origin)
-        remote = remote_name if remote_name else "origin"
-        result = run_git(
-            ["remote", "get-url", remote],
-            cwd=project_dir,
-            timeout=5,
-        )
-
-        # If command failed or no output, return unknown
-        if result.returncode != 0 or not result.stdout.strip():
-            return "unknown"
-
-        remote_url = result.stdout.strip()
-
-        # Parse ssh:// URL format: ssh://[user@]host[:port]/path
-        ssh_url_match = re.match(r"^ssh://(?:[^@]+@)?([^:/]+)(?::\d+)?/", remote_url)
-        if ssh_url_match:
-            hostname = ssh_url_match.group(1)
-            return _classify_hostname(hostname)
-
-        # Parse HTTPS/HTTP format: https://host/path or http://host/path
-        # Must check before scp-like format to avoid matching "https" as hostname
-        https_match = re.match(r"^https?://([^/]+)/", remote_url)
-        if https_match:
-            hostname = https_match.group(1)
-            return _classify_hostname(hostname)
-
-        # Parse scp-like format: [user@]host:path (any username, not just 'git')
-        # This handles git@github.com:user/repo.git and similar formats
-        scp_match = re.match(r"^(?:[^@]+@)?([^:]+):", remote_url)
-        if scp_match:
-            hostname = scp_match.group(1)
-            # Exclude paths that look like Windows drives (e.g., C:)
-            if len(hostname) > 1:
-                return _classify_hostname(hostname)
-
-        # Unrecognized URL format
-        return "unknown"
-
-    except Exception:
-        # Any error (subprocess issues, etc.) -> unknown
-        return "unknown"
-
-
-def _classify_hostname(hostname: str) -> str:
-    """Classify a hostname as github, gitlab, or unknown.
-
-    Args:
-        hostname: The git remote hostname (e.g., 'github.com', 'gitlab.example.com')
-
-    Returns:
-        'github', 'gitlab', or 'unknown'
-    """
-    hostname_lower = hostname.lower()
-
-    # Check for GitHub (cloud and self-hosted/enterprise)
-    # Match github.com, *.github.com, or domains where a segment is or starts with 'github'
-    hostname_parts = hostname_lower.split(".")
-    if (
-        hostname_lower == "github.com"
-        or hostname_lower.endswith(".github.com")
-        or any(
-            part == "github" or part.startswith("github-") for part in hostname_parts
-        )
-    ):
-        return "github"
-
-    # Check for GitLab (cloud and self-hosted)
-    # Match gitlab.com, *.gitlab.com, or domains where a segment is or starts with 'gitlab'
-    if (
-        hostname_lower == "gitlab.com"
-        or hostname_lower.endswith(".gitlab.com")
-        or any(
-            part == "gitlab" or part.startswith("gitlab-") for part in hostname_parts
-        )
-    ):
-        return "gitlab"
-
-    # Unknown provider
-    return "unknown"
@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-"""
-GitLab CLI Executable Finder
-============================
-
-Utility to find the glab (GitLab CLI) executable, with platform-specific fallbacks.
-"""
-
-import os
-import shutil
-import subprocess
-
-from core.platform import get_where_exe_path
-
-_cached_glab_path: str | None = None
-
-
-def invalidate_glab_cache() -> None:
-    """Invalidate the cached glab executable path.
-
-    Useful when glab may have been uninstalled, updated, or when
-    GITLAB_CLI_PATH environment variable has changed.
-    """
-    global _cached_glab_path
-    _cached_glab_path = None
-
-
-def _verify_glab_executable(path: str) -> bool:
-    """Verify that a path is a valid glab executable by checking version.
-
-    Args:
-        path: Path to the potential glab executable
-
-    Returns:
-        True if the path points to a valid glab executable, False otherwise
-    """
-    try:
-        result = subprocess.run(
-            [path, "--version"],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            timeout=5,
-        )
-        return result.returncode == 0
-    except (subprocess.TimeoutExpired, OSError):
-        return False
-
-
-def _run_where_command() -> str | None:
-    """Run Windows 'where glab' command to find glab executable.
-
-    Returns:
-        First path found, or None if command failed
-    """
-    try:
-        result = subprocess.run(
-            [get_where_exe_path(), "glab"],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            timeout=5,
-        )
-        if result.returncode == 0 and result.stdout.strip():
-            found_path = result.stdout.strip().split("\n")[0].strip()
-            if (
-                found_path
-                and os.path.isfile(found_path)
-                and _verify_glab_executable(found_path)
-            ):
-                return found_path
-    except (subprocess.TimeoutExpired, OSError):
-        # 'where' command failed or timed out - fall through to return None
-        pass
-    return None
-
-
-def get_glab_executable() -> str | None:
-    """Find the glab executable, with platform-specific fallbacks.
-
-    Returns the path to glab executable, or None if not found.
-
-    Priority order:
-    1. GITLAB_CLI_PATH env var (user-configured path from frontend)
-    2. shutil.which (if glab is in PATH)
-    3. Homebrew paths on macOS
-    4. Windows Program Files paths
-    5. Windows 'where' command
-
-    Caches the result after first successful find. Use invalidate_glab_cache()
-    to force re-detection (e.g., after glab installation/uninstallation).
-    """
-    global _cached_glab_path
-
-    # Return cached result if available AND still exists
-    if _cached_glab_path is not None and os.path.isfile(_cached_glab_path):
-        return _cached_glab_path
-
-    _cached_glab_path = _find_glab_executable()
-    return _cached_glab_path
-
-
-def _find_glab_executable() -> str | None:
-    """Internal function to find glab executable."""
-    # 1. Check GITLAB_CLI_PATH env var (set by Electron frontend)
-    env_path = os.environ.get("GITLAB_CLI_PATH")
-    if env_path and os.path.isfile(env_path) and _verify_glab_executable(env_path):
-        return env_path
-
-    # 2. Try shutil.which (works if glab is in PATH)
-    glab_path = shutil.which("glab")
-    if glab_path and _verify_glab_executable(glab_path):
-        return glab_path
-
-    # 3. macOS-specific: check Homebrew paths
-    if os.name != "nt":  # Unix-like systems (macOS, Linux)
-        homebrew_paths = [
-            "/opt/homebrew/bin/glab",  # Apple Silicon
-            "/usr/local/bin/glab",  # Intel Mac
-            "/home/linuxbrew/.linuxbrew/bin/glab",  # Linux Homebrew
-        ]
-        for path in homebrew_paths:
-            if os.path.isfile(path) and _verify_glab_executable(path):
-                return path
-
-    # 4. Windows-specific: check Program Files paths
-    # glab uses Inno Setup with DefaultDirName={autopf}\glab
-    if os.name == "nt":
-        windows_paths = [
-            os.path.expandvars(r"%PROGRAMFILES%\glab\glab.exe"),
-            os.path.expandvars(r"%PROGRAMFILES(X86)%\glab\glab.exe"),
-            os.path.expandvars(r"%LOCALAPPDATA%\Programs\glab\glab.exe"),
-        ]
-        for path in windows_paths:
-            if os.path.isfile(path) and _verify_glab_executable(path):
-                return path
-
-        # 5. Try 'where' command with full path (works even when System32 isn't in PATH)
-        return _run_where_command()
-
-    return None
-
-
-def run_glab(
-    args: list[str],
-    cwd: str | None = None,
-    timeout: int = 60,
-    input_data: str | None = None,
-) -> subprocess.CompletedProcess:
-    """Run a glab command with proper executable finding.
-
-    Args:
-        args: glab command arguments (without 'glab' prefix)
-        cwd: Working directory for the command
-        timeout: Command timeout in seconds (default: 60)
-        input_data: Optional string data to pass to stdin
-
-    Returns:
-        CompletedProcess with command results.
-    """
-    glab = get_glab_executable()
-    if not glab:
-        return subprocess.CompletedProcess(
-            args=["glab"] + args,
-            returncode=-1,
-            stdout="",
-            stderr="GitLab CLI (glab) not found. Install from https://gitlab.com/gitlab-org/cli",
-        )
-    try:
-        return subprocess.run(
-            [glab] + args,
-            cwd=cwd,
-            input=input_data,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        return subprocess.CompletedProcess(
-            args=[glab] + args,
-            returncode=-1,
-            stdout="",
-            stderr=f"Command timed out after {timeout} seconds",
-        )
-    except FileNotFoundError:
-        return subprocess.CompletedProcess(
-            args=[glab] + args,
-            returncode=-1,
-            stdout="",
-            stderr="GitLab CLI (glab) executable not found. Install from https://gitlab.com/gitlab-org/cli",
-        )
@@ -1,94 +0,0 @@
-"""
-I/O Utilities for Safe Console Output
-=====================================
-
-Safe I/O operations for processes running as subprocesses.
-
-When the backend runs as a subprocess of the Electron app, the parent
-process may close the pipe at any time (e.g., user closes the app,
-process killed, etc.). This module provides utilities to handle these
-cases gracefully.
-"""
-
-from __future__ import annotations
-
-import logging
-import sys
-
-logger = logging.getLogger(__name__)
-
-# Track if pipe is broken to avoid repeated failed writes
-_pipe_broken = False
-
-
-def safe_print(message: str, flush: bool = True) -> None:
-    """
-    Print to stdout with BrokenPipeError handling.
-
-    When running as a subprocess (e.g., from Electron), the parent process
-    may close the pipe at any time. This function gracefully handles that
-    case instead of raising an exception.
-
-    Args:
-        message: The message to print
-        flush: Whether to flush stdout after printing (default True)
-    """
-    global _pipe_broken
-
-    # Skip if we already know the pipe is broken
-    if _pipe_broken:
-        return
-
-    try:
-        print(message, flush=flush)
-    except BrokenPipeError:
-        # Pipe closed by parent process - this is expected during shutdown
-        _pipe_broken = True
-        # Quietly close stdout to prevent further errors
-        try:
-            sys.stdout.close()
-        except Exception:
-            pass
-        logger.debug("Output pipe closed by parent process")
-    except ValueError as e:
-        # Handle writes to closed file (can happen after stdout.close())
-        if "closed file" in str(e).lower():
-            _pipe_broken = True
-            logger.debug("Output stream closed")
-        else:
-            # Re-raise unexpected ValueErrors
-            raise
-    except OSError as e:
-        # Handle other pipe-related errors (EPIPE, etc.)
-        if e.errno == 32:  # EPIPE - Broken pipe
-            _pipe_broken = True
-            try:
-                sys.stdout.close()
-            except Exception:
-                pass
-            logger.debug("Output pipe closed (EPIPE)")
-        else:
-            # Re-raise unexpected OS errors
-            raise
-
-
-def is_pipe_broken() -> bool:
-    """Check if the output pipe has been closed."""
-    return _pipe_broken
-
-
-def reset_pipe_state() -> None:
-    """
-    Reset pipe broken state.
-
-    Useful for testing or when starting a new subprocess context where
-    stdout has been reopened. Should only be called when stdout is known
-    to be functional (e.g., in a fresh subprocess with a new stdout).
-
-    Warning:
-        Calling this after stdout has been closed will result in safe_print()
-        attempting to write to the closed stream. The ValueError will be
-        caught and the pipe will be marked as broken again.
-    """
-    global _pipe_broken
-    _pipe_broken = False
@@ -23,9 +23,6 @@ class ExecutionPhase(str, Enum):
    QA_FIXING = "qa_fixing"
    COMPLETE = "complete"
    FAILED = "failed"
-    # Pause states for intelligent error recovery
-    RATE_LIMIT_PAUSED = "rate_limit_paused"
-    AUTH_FAILURE_PAUSED = "auth_failure_paused"


 def emit_phase(
@@ -34,19 +31,8 @@ def emit_phase(
    *,
    progress: int | None = None,
    subtask: str | None = None,
-    reset_timestamp: int | None = None,
-    profile_id: str | None = None,
 ) -> None:
-    """Emit structured phase event to stdout for frontend parsing.
-
-    Args:
-        phase: The execution phase (e.g., PLANNING, CODING, RATE_LIMIT_PAUSED)
-        message: Optional message describing the phase state
-        progress: Optional progress percentage (0-100)
-        subtask: Optional subtask identifier
-        reset_timestamp: Optional Unix timestamp for rate limit reset time
-        profile_id: Optional profile ID that triggered the pause
-    """
+    """Emit structured phase event to stdout for frontend parsing."""
    phase_value = phase.value if isinstance(phase, ExecutionPhase) else phase

    payload: dict[str, Any] = {
@@ -62,12 +48,6 @@ def emit_phase(
    if subtask is not None:
        payload["subtask"] = subtask

-    if reset_timestamp is not None:
-        payload["reset_timestamp"] = reset_timestamp
-
-    if profile_id is not None:
-        payload["profile_id"] = profile_id
-
    try:
        print(f"{PHASE_MARKER_PREFIX}{json.dumps(payload, default=str)}", flush=True)
    except (OSError, UnicodeEncodeError) as e:
@@ -1,532 +0,0 @@
-"""
-Platform Abstraction Layer
-
-Centralized platform-specific operations for the Python backend.
-All code that checks sys.platform or handles OS differences should use this module.
-
-Design principles:
- Single source of truth for platform detection
- Feature detection over platform detection when possible
- Clear, intention-revealing names
- Immutable configurations where possible
-"""
-
-import os
-import platform
-import re
-import shutil
-import subprocess
-from enum import Enum
-from pathlib import Path
-
-# ============================================================================
-# Type Definitions
-# ============================================================================
-
-
-class OS(Enum):
-    """Supported operating systems."""
-
-    WINDOWS = "Windows"
-    MACOS = "Darwin"
-    LINUX = "Linux"
-
-
-class ShellType(Enum):
-    """Available shell types."""
-
-    POWERSHELL = "powershell"
-    CMD = "cmd"
-    BASH = "bash"
-    ZSH = "zsh"
-    FISH = "fish"
-    UNKNOWN = "unknown"
-
-
-# ============================================================================
-# Platform Detection
-# ============================================================================
-
-
-def get_current_os() -> OS:
-    """Get the current operating system.
-
-    Returns the OS enum for the current platform. For unsupported Unix-like
-    systems (e.g., FreeBSD, SunOS), defaults to Linux for compatibility.
-    """
-    system = platform.system()
-    if system == "Windows":
-        return OS.WINDOWS
-    elif system == "Darwin":
-        return OS.MACOS
-    # Default to Linux for other Unix-like systems (FreeBSD, SunOS, etc.)
-    return OS.LINUX
-
-
-def is_windows() -> bool:
-    """Check if running on Windows."""
-    return platform.system() == "Windows"
-
-
-def is_macos() -> bool:
-    """Check if running on macOS."""
-    return platform.system() == "Darwin"
-
-
-def is_linux() -> bool:
-    """Check if running on Linux."""
-    return platform.system() == "Linux"
-
-
-def is_unix() -> bool:
-    """Check if running on a Unix-like system (macOS or Linux)."""
-    return not is_windows()
-
-
-# ============================================================================
-# Path Configuration
-# ============================================================================
-
-
-def get_path_delimiter() -> str:
-    """Get the PATH separator for environment variables."""
-    return ";" if is_windows() else ":"
-
-
-def get_executable_extension() -> str:
-    """Get the default file extension for executables."""
-    return ".exe" if is_windows() else ""
-
-
-def with_executable_extension(base_name: str) -> str:
-    """Add executable extension to a base name if needed."""
-    if not base_name:
-        return base_name
-
-    # Check if already has extension
-    if os.path.splitext(base_name)[1]:
-        return base_name
-
-    exe_ext = get_executable_extension()
-    return f"{base_name}{exe_ext}" if exe_ext else base_name
-
-
-# ============================================================================
-# Binary Directories
-# ============================================================================
-
-
-def get_binary_directories() -> dict[str, list[str]]:
-    """
-    Get common binary directories for the current platform.
-
-    Returns:
-        Dict with 'user' and 'system' keys containing lists of directories.
-    """
-    home_dir = Path.home()
-
-    if is_windows():
-        return {
-            "user": [
-                str(home_dir / "AppData" / "Local" / "Programs"),
-                str(home_dir / "AppData" / "Roaming" / "npm"),
-                str(home_dir / ".local" / "bin"),
-            ],
-            "system": [
-                os.environ.get("ProgramFiles", "C:\\Program Files"),
-                os.environ.get("ProgramFiles(x86)", "C:\\Program Files (x86)"),
-                os.path.join(os.environ.get("SystemRoot", "C:\\Windows"), "System32"),
-            ],
-        }
-
-    if is_macos():
-        return {
-            "user": [
-                str(home_dir / ".local" / "bin"),
-                str(home_dir / "bin"),
-            ],
-            "system": [
-                "/opt/homebrew/bin",
-                "/usr/local/bin",
-                "/usr/bin",
-            ],
-        }
-
-    # Linux
-    return {
-        "user": [
-            str(home_dir / ".local" / "bin"),
-            str(home_dir / "bin"),
-        ],
-        "system": [
-            "/usr/bin",
-            "/usr/local/bin",
-            "/snap/bin",
-        ],
-    }
-
-
-def get_homebrew_path() -> str | None:
-    """
-    Get Homebrew binary directory (macOS only).
-
-    Returns:
-        Homebrew bin path or None if not on macOS.
-    """
-    if not is_macos():
-        return None
-
-    homebrew_paths = [
-        "/opt/homebrew/bin",  # Apple Silicon
-        "/usr/local/bin",  # Intel
-    ]
-
-    for brew_path in homebrew_paths:
-        if os.path.exists(brew_path):
-            return brew_path
-
-    return homebrew_paths[0]  # Default to Apple Silicon
-
-
-# ============================================================================
-# Tool Detection
-# ============================================================================
-
-
-def find_executable(name: str, additional_paths: list[str] | None = None) -> str | None:
-    """
-    Find an executable in standard locations.
-
-    Searches:
-    1. System PATH
-    2. Platform-specific binary directories
-    3. Additional custom paths
-
-    Args:
-        name: Name of the executable (without extension)
-        additional_paths: Optional list of additional paths to search
-
-    Returns:
-        Full path to executable if found, None otherwise
-    """
-    # First check system PATH
-    in_path = shutil.which(name)
-    if in_path:
-        return in_path
-
-    # Check with extension on Windows
-    if is_windows():
-        for ext in [".exe", ".cmd", ".bat"]:
-            in_path = shutil.which(f"{name}{ext}")
-            if in_path:
-                return in_path
-
-    # Search in platform-specific directories
-    bins = get_binary_directories()
-    search_dirs = bins["user"] + bins["system"]
-
-    if additional_paths:
-        search_dirs.extend(additional_paths)
-
-    for directory in search_dirs:
-        if not os.path.isdir(directory):
-            continue
-
-        # Try without extension
-        exe_path = os.path.join(directory, with_executable_extension(name))
-        if os.path.isfile(exe_path):
-            return exe_path
-
-        # Try common extensions on Windows
-        if is_windows():
-            for ext in [".exe", ".cmd", ".bat"]:
-                exe_path = os.path.join(directory, f"{name}{ext}")
-                if os.path.isfile(exe_path):
-                    return exe_path
-
-    return None
-
-
-def get_claude_detection_paths() -> list[str]:
-    """
-    Get platform-specific paths for Claude CLI detection.
-
-    Returns:
-        List of possible Claude CLI executable paths.
-    """
-    home_dir = Path.home()
-    paths = []
-
-    if is_windows():
-        paths.extend(
-            [
-                str(
-                    home_dir
-                    / "AppData"
-                    / "Local"
-                    / "Programs"
-                    / "claude"
-                    / "claude.exe"
-                ),
-                str(home_dir / "AppData" / "Roaming" / "npm" / "claude.cmd"),
-                str(home_dir / ".local" / "bin" / "claude.exe"),
-                r"C:\Program Files\Claude\claude.exe",
-                r"C:\Program Files (x86)\Claude\claude.exe",
-            ]
-        )
-    else:
-        paths.extend(
-            [
-                str(home_dir / ".local" / "bin" / "claude"),
-                str(home_dir / "bin" / "claude"),
-            ]
-        )
-
-    # Add Homebrew path on macOS
-    if is_macos():
-        brew_path = get_homebrew_path()
-        if brew_path:
-            paths.append(os.path.join(brew_path, "claude"))
-
-    return paths
-
-
-def get_claude_detection_paths_structured() -> dict[str, list[str] | str]:
-    """
-    Get platform-specific paths for Claude CLI detection in structured format.
-
-    Returns a dict with categorized paths for different detection strategies:
-    - 'homebrew': Homebrew installation paths (macOS)
-    - 'platform': Platform-specific standard installation locations
-    - 'nvm_versions_dir': NVM versions directory path for scanning Node installations
-
-    This structured format allows callers to implement custom detection logic
-    for each category (e.g., iterating NVM version directories).
-
-    Returns:
-        Dict with 'homebrew', 'platform', and 'nvm_versions_dir' keys
-    """
-    home_dir = Path.home()
-
-    homebrew_paths = [
-        "/opt/homebrew/bin/claude",  # Apple Silicon
-        "/usr/local/bin/claude",  # Intel Mac
-    ]
-
-    if is_windows():
-        platform_paths = [
-            str(home_dir / "AppData/Local/Programs/claude/claude.exe"),
-            str(home_dir / "AppData/Roaming/npm/claude.cmd"),
-            str(home_dir / ".local/bin/claude.exe"),
-            r"C:\Program Files\Claude\claude.exe",
-            r"C:\Program Files (x86)\Claude\claude.exe",
-        ]
-    else:
-        platform_paths = [
-            str(home_dir / ".local" / "bin" / "claude"),
-            str(home_dir / "bin" / "claude"),
-        ]
-
-    nvm_versions_dir = str(home_dir / ".nvm" / "versions" / "node")
-
-    return {
-        "homebrew": homebrew_paths,
-        "platform": platform_paths,
-        "nvm_versions_dir": nvm_versions_dir,
-    }
-
-
-def get_python_commands() -> list[list[str]]:
-    """
-    Get platform-specific Python command variations as argument sequences.
-
-    Returns command arguments as sequences so callers can pass each entry
-    directly to subprocess.run(cmd) or use cmd[0] with shutil.which().
-
-    Returns:
-        List of command argument lists to try, in order of preference.
-        Each inner list contains the executable and any required arguments.
-
-    Example:
-        for cmd in get_python_commands():
-            if shutil.which(cmd[0]):
-                subprocess.run(cmd + ["--version"])
-                break
-    """
-    if is_windows():
-        return [["py", "-3"], ["python"], ["python3"], ["py"]]
-    return [["python3"], ["python"]]
-
-
-def validate_cli_path(cli_path: str) -> bool:
-    """
-    Validate that a CLI path is secure and executable.
-
-    Prevents command injection attacks by rejecting paths with shell metacharacters,
-    directory traversal patterns, or environment variable expansion.
-
-    Args:
-        cli_path: Path to validate
-
-    Returns:
-        True if path is secure, False otherwise
-    """
-    if not cli_path or not cli_path.strip():
-        return False
-
-    # Security validation: reject paths with shell metacharacters or other dangerous patterns
-    dangerous_patterns = [
-        r'[;&|`${}[\]<>!"^]',  # Shell metacharacters
-        r"%[^%]+%",  # Windows environment variable expansion
-        r"\.\./",  # Unix directory traversal
-        r"\.\.\\",  # Windows directory traversal
-        r"[\r\n\x00]",  # Newlines (command injection), null bytes (path truncation)
-    ]
-
-    for pattern in dangerous_patterns:
-        if re.search(pattern, cli_path):
-            return False
-
-    # On Windows, validate executable name additionally
-    if is_windows():
-        # Extract just the executable name
-        exe_name = os.path.basename(cli_path)
-        name_without_ext = os.path.splitext(exe_name)[0]
-
-        # Allow only alphanumeric, dots, hyphens, underscores in the name
-        if not name_without_ext or not all(
-            c.isalnum() or c in "._-" for c in name_without_ext
-        ):
-            return False
-
-    # Check if path exists (if absolute)
-    if os.path.isabs(cli_path):
-        return os.path.isfile(cli_path)
-
-    return True
-
-
-# ============================================================================
-# Shell Execution
-# ============================================================================
-
-
-def requires_shell(command: str) -> bool:
-    """
-    Check if a command requires shell execution on Windows.
-
-    Windows needs shell execution for .cmd and .bat files.
-
-    Args:
-        command: Command string to check
-
-    Returns:
-        True if shell execution is required
-    """
-    if not is_windows():
-        return False
-
-    _, ext = os.path.splitext(command)
-    return ext.lower() in {".cmd", ".bat", ".ps1"}
-
-
-def get_where_exe_path() -> str:
-    """Get full path to where.exe on Windows.
-
-    Using the full path ensures where.exe works even when System32 isn't in PATH,
-    which can happen in restricted environments or when the app doesn't inherit
-    the full system PATH.
-
-    Returns:
-        Full path to where.exe (e.g., C:\\Windows\\System32\\where.exe)
-    """
-    system_root = os.environ.get(
-        "SystemRoot", os.environ.get("SYSTEMROOT", "C:\\Windows")
-    )
-    return os.path.join(system_root, "System32", "where.exe")
-
-
-def get_comspec_path() -> str:
-    """
-    Get the path to cmd.exe on Windows.
-
-    Returns:
-        Path to cmd.exe or default location.
-    """
-    if is_windows():
-        return os.environ.get(
-            "ComSpec",
-            os.path.join(
-                os.environ.get("SystemRoot", "C:\\Windows"), "System32", "cmd.exe"
-            ),
-        )
-    return "/bin/sh"
-
-
-def build_windows_command(cli_path: str, args: list[str]) -> list[str]:
-    """
-    Build a command array for Windows execution.
-
-    Handles .cmd/.bat files that require shell execution.
-
-    Args:
-        cli_path: Path to the CLI executable
-        args: Command arguments
-
-    Returns:
-        Command array suitable for subprocess.run
-    """
-    if is_windows() and cli_path.lower().endswith((".cmd", ".bat")):
-        # Use cmd.exe to execute .cmd/.bat files
-        cmd_exe = get_comspec_path()
-        # Properly escape arguments for Windows command line
-        escaped_args = subprocess.list2cmdline(args)
-        return [cmd_exe, "/d", "/s", "/c", f'"{cli_path}" {escaped_args}']
-
-    return [cli_path] + args
-
-
-# ============================================================================
-# Environment Variables
-# ============================================================================
-
-
-def get_env_var(name: str, default: str | None = None) -> str | None:
-    """
-    Get environment variable value with case-insensitive support on Windows.
-
-    Args:
-        name: Environment variable name
-        default: Default value if not found
-
-    Returns:
-        Environment variable value or default
-    """
-    if is_windows():
-        # Case-insensitive lookup on Windows
-        for key, value in os.environ.items():
-            if key.lower() == name.lower():
-                return value
-        return default
-
-    return os.environ.get(name, default)
-
-
-# ============================================================================
-# Platform Description
-# ============================================================================
-
-
-def get_platform_description() -> str:
-    """
-    Get a human-readable platform description.
-
-    Returns:
-        String like "Windows (AMD64)" or "macOS (arm64)"
-    """
-    os_name = {OS.WINDOWS: "Windows", OS.MACOS: "macOS", OS.LINUX: "Linux"}.get(
-        get_current_os(), platform.system()
-    )
-
-    arch = platform.machine()
-    return f"{os_name} ({arch})"
@@ -9,11 +9,8 @@ Enhanced with colored output, icons, and better visual formatting.
 """

 import json
-import logging
 from pathlib import Path

-logger = logging.getLogger(__name__)
-
 from core.plan_normalization import normalize_subtask_aliases
 from ui import (
    Icons,
@@ -46,7 +43,7 @@ def count_subtasks(spec_dir: Path) -> tuple[int, int]:
        return 0, 0

    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan = json.load(f)

        total = 0
@@ -59,7 +56,7 @@ def count_subtasks(spec_dir: Path) -> tuple[int, int]:
                    completed += 1

        return completed, total
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return 0, 0


@@ -84,7 +81,7 @@ def count_subtasks_detailed(spec_dir: Path) -> dict:
        return result

    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan = json.load(f)

        for phase in plan.get("phases", []):
@@ -97,7 +94,7 @@ def count_subtasks_detailed(spec_dir: Path) -> dict:
                    result["pending"] += 1

        return result
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return result


@@ -185,7 +182,7 @@ def print_progress_summary(spec_dir: Path, show_next: bool = True) -> None:

        # Phase summary
        try:
-            with open(spec_dir / "implementation_plan.json", encoding="utf-8") as f:
+            with open(spec_dir / "implementation_plan.json") as f:
                plan = json.load(f)

            print("\nPhases:")
@@ -233,8 +230,8 @@ def print_progress_summary(spec_dir: Path, show_next: bool = True) -> None:
                        f"  {icon(Icons.ARROW_RIGHT)} Next: {highlight(next_id)} - {next_desc}"
                    )

-        except (OSError, json.JSONDecodeError, UnicodeDecodeError) as e:
-            logger.debug(f"Failed to load plan file for phase summary: {e}")
+        except (OSError, json.JSONDecodeError):
+            pass
    else:
        print()
        print_status("No implementation subtasks yet - planner needs to run", "pending")
@@ -305,7 +302,7 @@ def get_plan_summary(spec_dir: Path) -> dict:
        }

    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan = json.load(f)

        summary = {
@@ -358,7 +355,7 @@ def get_plan_summary(spec_dir: Path) -> dict:

        return summary

-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return {
            "workflow_type": None,
            "total_phases": 0,
@@ -379,7 +376,7 @@ def get_current_phase(spec_dir: Path) -> dict | None:
        return None

    try:
-        with open(plan_file, encoding="utf-8") as f:
+        with open(plan_file) as f:
            plan = json.load(f)

        for phase in plan.get("phases", []):
@@ -399,7 +396,7 @@ def get_current_phase(spec_dir: Path) -> dict | None:

        return None

-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return None


@@ -407,8 +404,6 @@ def get_next_subtask(spec_dir: Path) -> dict | None:
    """
    Find the next subtask to work on, respecting phase dependencies.

-    Skips subtasks that are marked as stuck in the recovery manager's attempt history.
-
    Args:
        spec_dir: Directory containing implementation_plan.json

@@ -420,23 +415,6 @@ def get_next_subtask(spec_dir: Path) -> dict | None:
    if not plan_file.exists():
        return None

-    # Load stuck subtasks from recovery manager's attempt history
-    stuck_subtask_ids = set()
-    attempt_history_file = spec_dir / "memory" / "attempt_history.json"
-    if attempt_history_file.exists():
-        try:
-            with open(attempt_history_file, encoding="utf-8") as f:
-                attempt_history = json.load(f)
-            # Collect IDs of subtasks marked as stuck
-            stuck_subtask_ids = {
-                entry["subtask_id"]
-                for entry in attempt_history.get("stuck_subtasks", [])
-                if "subtask_id" in entry
-            }
-        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
-            # If we can't read the file, continue without stuck checking
-            pass
-
    try:
        with open(plan_file, encoding="utf-8") as f:
            plan = json.load(f)
@@ -477,15 +455,9 @@ def get_next_subtask(spec_dir: Path) -> dict | None:
            if not deps_satisfied:
                continue

-            # Find first pending subtask in this phase (skip stuck subtasks)
+            # Find first pending subtask in this phase
            for subtask in phase.get("subtasks", phase.get("chunks", [])):
                status = subtask.get("status", "pending")
-                subtask_id = subtask.get("id")
-
-                # Skip stuck subtasks
-                if subtask_id in stuck_subtask_ids:
-                    continue
-
                if status in {"pending", "not_started", "not started"}:
                    subtask_out, _changed = normalize_subtask_aliases(subtask)
                    subtask_out["status"] = "pending"
@@ -498,7 +470,7 @@ def get_next_subtask(spec_dir: Path) -> dict | None:

        return None

-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+    except (OSError, json.JSONDecodeError):
        return None


@@ -1,406 +0,0 @@
-"""
-Sentry Error Tracking for Python Backend
-=========================================
-
-Initializes Sentry for the Python backend with:
- Privacy-preserving path masking (usernames removed)
- Release tracking matching the Electron frontend
- Environment variable configuration (same as frontend)
-
-Configuration:
- SENTRY_DSN: Required to enable Sentry (same as frontend)
- SENTRY_TRACES_SAMPLE_RATE: Performance monitoring sample rate (0-1, default: 0.1)
- SENTRY_ENVIRONMENT: Override environment (default: auto-detected)
-
-Privacy Note:
- Usernames are masked from all file paths
- Project paths remain visible for debugging (this is expected)
- No user identifiers are collected
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import re
-import sys
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-# Track initialization state
-_sentry_initialized = False
-_sentry_enabled = False
-
-# Production trace sample rate (10%)
-PRODUCTION_TRACE_SAMPLE_RATE = 0.1
-
-
-def _get_version() -> str:
-    """
-    Get the application version.
-
-    Tries to read from package.json in the frontend directory,
-    falling back to a default version.
-    """
-    try:
-        # Try to find package.json relative to this file
-        backend_dir = Path(__file__).parent.parent
-        frontend_dir = backend_dir.parent / "frontend"
-        package_json = frontend_dir / "package.json"
-
-        if package_json.exists():
-            import json
-
-            with open(package_json, encoding="utf-8") as f:
-                data = json.load(f)
-                return data.get("version", "0.0.0")
-    except Exception as e:
-        logger.debug(f"Version detection failed: {e}")
-
-    return "0.0.0"
-
-
-def _mask_user_paths(text: str) -> str:
-    """
-    Mask user-specific paths for privacy.
-
-    Replaces usernames in common OS path patterns:
-    - macOS: /Users/username/... becomes /Users/***/...
-    - Windows: C:\\Users\\username\\... becomes C:\\Users\\***\\...
-    - Linux: /home/username/... becomes /home/***/...
-    - WSL: /mnt/c/Users/username/... becomes /mnt/c/Users/***/...
-
-    Note: Project paths remain visible for debugging purposes.
-    """
-    if not text:
-        return text
-
-    # macOS: /Users/username/...
-    text = re.sub(r"/Users/[^/]+(?=/|$)", "/Users/***", text)
-
-    # Windows: C:\Users\username\...
-    text = re.sub(
-        r"[A-Za-z]:\\Users\\[^\\]+(?=\\|$)",
-        lambda m: f"{m.group(0)[0]}:\\Users\\***",
-        text,
-    )
-
-    # Linux: /home/username/...
-    text = re.sub(r"/home/[^/]+(?=/|$)", "/home/***", text)
-
-    # WSL: /mnt/c/Users/username/... (accessing Windows filesystem from WSL)
-    text = re.sub(
-        r"/mnt/[a-z]/Users/[^/]+(?=/|$)",
-        lambda m: f"{m.group(0)[:6]}/Users/***",
-        text,
-    )
-
-    return text
-
-
-def _mask_object_paths(obj: Any, _depth: int = 0) -> Any:
-    """
-    Recursively mask paths in an object.
-
-    Args:
-        obj: The object to mask paths in
-        _depth: Current recursion depth (internal use)
-
-    Returns:
-        Object with paths masked
-    """
-    # Prevent stack overflow on deeply nested or circular structures
-    if _depth > 50:
-        return obj
-
-    if obj is None:
-        return obj
-
-    if isinstance(obj, str):
-        return _mask_user_paths(obj)
-
-    if isinstance(obj, list):
-        return [_mask_object_paths(item, _depth + 1) for item in obj]
-
-    if isinstance(obj, dict):
-        return {
-            key: _mask_object_paths(value, _depth + 1) for key, value in obj.items()
-        }
-
-    return obj
-
-
-def _before_send(event: dict, hint: dict) -> dict | None:
-    """
-    Process event before sending to Sentry.
-
-    Applies privacy masking to all paths in the event.
-    """
-    if not _sentry_enabled:
-        return None
-
-    # Mask paths in exception stack traces
-    if "exception" in event and "values" in event["exception"]:
-        for exception in event["exception"]["values"]:
-            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
-                for frame in exception["stacktrace"]["frames"]:
-                    if "filename" in frame:
-                        frame["filename"] = _mask_user_paths(frame["filename"])
-                    if "abs_path" in frame:
-                        frame["abs_path"] = _mask_user_paths(frame["abs_path"])
-            if "value" in exception:
-                exception["value"] = _mask_user_paths(exception["value"])
-
-    # Mask paths in breadcrumbs
-    if "breadcrumbs" in event:
-        for breadcrumb in event.get("breadcrumbs", {}).get("values", []):
-            if "message" in breadcrumb:
-                breadcrumb["message"] = _mask_user_paths(breadcrumb["message"])
-            if "data" in breadcrumb:
-                breadcrumb["data"] = _mask_object_paths(breadcrumb["data"])
-
-    # Mask paths in message
-    if "message" in event:
-        event["message"] = _mask_user_paths(event["message"])
-
-    # Mask paths in tags
-    if "tags" in event:
-        event["tags"] = _mask_object_paths(event["tags"])
-
-    # Mask paths in contexts
-    if "contexts" in event:
-        event["contexts"] = _mask_object_paths(event["contexts"])
-
-    # Mask paths in extra data
-    if "extra" in event:
-        event["extra"] = _mask_object_paths(event["extra"])
-
-    # Clear user info for privacy
-    if "user" in event:
-        event["user"] = {}
-
-    return event
-
-
-def init_sentry(
-    component: str = "backend",
-) -> bool:
-    """
-    Initialize Sentry for the Python backend.
-
-    Args:
-        component: Component name for tagging (e.g., "backend", "github-runner")
-
-    Returns:
-        True if Sentry was initialized, False otherwise
-    """
-    global _sentry_initialized, _sentry_enabled
-
-    if _sentry_initialized:
-        return _sentry_enabled
-
-    _sentry_initialized = True
-
-    # Get DSN from environment variable
-    dsn = os.environ.get("SENTRY_DSN", "")
-
-    if not dsn:
-        logger.debug("[Sentry] No SENTRY_DSN configured - error reporting disabled")
-        return False
-
-    # DSN is present (checked above), so Sentry should be enabled.
-    # The Electron main process only passes SENTRY_DSN to subprocesses in
-    # production builds, so its presence is sufficient to gate activation.
-    # In dev, set SENTRY_DSN in your environment to opt-in.
-    is_packaged = getattr(sys, "frozen", False) or hasattr(sys, "__compiled__")
-
-    try:
-        import sentry_sdk
-        from sentry_sdk.integrations.logging import LoggingIntegration
-    except ImportError:
-        logger.warning("[Sentry] sentry-sdk not installed - error reporting disabled")
-        return False
-
-    # Get configuration from environment variables
-    version = _get_version()
-    environment = os.environ.get(
-        "SENTRY_ENVIRONMENT", "production" if is_packaged else "development"
-    )
-
-    # Get sample rates
-    traces_sample_rate = PRODUCTION_TRACE_SAMPLE_RATE
-    try:
-        env_rate = os.environ.get("SENTRY_TRACES_SAMPLE_RATE")
-        if env_rate:
-            parsed = float(env_rate)
-            if 0 <= parsed <= 1:
-                traces_sample_rate = parsed
-    except (ValueError, TypeError):
-        pass
-
-    # Configure logging integration to capture errors and warnings
-    logging_integration = LoggingIntegration(
-        level=logging.INFO,  # Capture INFO and above as breadcrumbs
-        event_level=logging.ERROR,  # Send ERROR and above as events
-    )
-
-    # Initialize Sentry with exception handling for malformed DSN
-    try:
-        sentry_sdk.init(
-            dsn=dsn,
-            environment=environment,
-            release=f"auto-claude@{version}",
-            traces_sample_rate=traces_sample_rate,
-            before_send=_before_send,
-            integrations=[logging_integration],
-            # Don't send PII
-            send_default_pii=False,
-        )
-    except Exception as e:
-        # Handle malformed DSN (e.g., missing public key) gracefully
-        # This prevents crashes when SENTRY_DSN is misconfigured
-        logger.warning(
-            f"[Sentry] Failed to initialize - invalid DSN configuration: {e}"
-        )
-        logger.debug(
-            "[Sentry] DSN should be in format: https://PUBLIC_KEY@o123.ingest.sentry.io/PROJECT_ID"
-        )
-        return False
-
-    # Set component tag
-    sentry_sdk.set_tag("component", component)
-
-    _sentry_enabled = True
-    logger.info(
-        f"[Sentry] Backend initialized (component: {component}, release: auto-claude@{version}, traces: {traces_sample_rate})"
-    )
-
-    return True
-
-
-def capture_exception(error: Exception, **kwargs) -> None:
-    """
-    Capture an exception and send to Sentry.
-
-    Safe to call even if Sentry is not initialized.
-
-    Args:
-        error: The exception to capture
-        **kwargs: Additional context to attach to the event
-    """
-    if not _sentry_enabled:
-        logger.error(f"[Sentry] Not enabled, exception not captured: {error}")
-        return
-
-    try:
-        import sentry_sdk
-
-        with sentry_sdk.push_scope() as scope:
-            for key, value in kwargs.items():
-                # Apply defensive path masking for extra data
-                masked_value = (
-                    _mask_object_paths(value)
-                    if isinstance(value, (str, dict, list))
-                    else value
-                )
-                scope.set_extra(key, masked_value)
-            sentry_sdk.capture_exception(error)
-    except ImportError:
-        logger.error(f"[Sentry] SDK not installed, exception not captured: {error}")
-    except Exception as e:
-        logger.error(f"[Sentry] Failed to capture exception: {e}")
-
-
-def capture_message(message: str, level: str = "info", **kwargs) -> None:
-    """
-    Capture a message and send to Sentry.
-
-    Safe to call even if Sentry is not initialized.
-
-    Args:
-        message: The message to capture
-        level: Log level (debug, info, warning, error, fatal)
-        **kwargs: Additional context to attach to the event
-    """
-    if not _sentry_enabled:
-        return
-
-    try:
-        import sentry_sdk
-
-        with sentry_sdk.push_scope() as scope:
-            for key, value in kwargs.items():
-                # Apply defensive path masking for extra data (same as capture_exception)
-                masked_value = (
-                    _mask_object_paths(value)
-                    if isinstance(value, (str, dict, list))
-                    else value
-                )
-                scope.set_extra(key, masked_value)
-            sentry_sdk.capture_message(message, level=level)
-    except ImportError:
-        logger.debug("[Sentry] SDK not installed")
-    except Exception as e:
-        logger.error(f"[Sentry] Failed to capture message: {e}")
-
-
-def set_context(name: str, data: dict) -> None:
-    """
-    Set context data for subsequent events.
-
-    Safe to call even if Sentry is not initialized.
-
-    Args:
-        name: Context name (e.g., "pr_review", "spec")
-        data: Context data dictionary
-    """
-    if not _sentry_enabled:
-        return
-
-    try:
-        import sentry_sdk
-
-        # Apply path masking to context data before sending to Sentry
-        masked_data = _mask_object_paths(data)
-        sentry_sdk.set_context(name, masked_data)
-    except ImportError:
-        logger.debug("[Sentry] SDK not installed")
-    except Exception as e:
-        logger.debug(f"Failed to set context '{name}': {e}")
-
-
-def set_tag(key: str, value: str) -> None:
-    """
-    Set a tag for subsequent events.
-
-    Safe to call even if Sentry is not initialized.
-
-    Args:
-        key: Tag key
-        value: Tag value
-    """
-    if not _sentry_enabled:
-        return
-
-    try:
-        import sentry_sdk
-
-        # Apply path masking to tag value
-        masked_value = _mask_user_paths(value) if isinstance(value, str) else value
-        sentry_sdk.set_tag(key, masked_value)
-    except ImportError:
-        logger.debug("[Sentry] SDK not installed")
-    except Exception as e:
-        logger.debug(f"Failed to set tag '{key}': {e}")
-
-
-def is_enabled() -> bool:
-    """Check if Sentry is enabled."""
-    return _sentry_enabled
-
-
-def is_initialized() -> bool:
-    """Check if Sentry initialization has been attempted."""
-    return _sentry_initialized
@@ -21,22 +21,13 @@ Example usage:
    client = create_simple_client(agent_type="insights", cwd=project_dir)
 """

-import logging
-import os
 from pathlib import Path

 from agents.tools_pkg import get_agent_config, get_default_thinking_level
 from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
-from core.auth import (
-    configure_sdk_authentication,
-    get_sdk_env_vars,
-)
-from core.fast_mode import ensure_fast_mode_in_user_settings
-from core.platform import validate_cli_path
+from core.auth import get_sdk_env_vars, require_auth_token
 from phase_config import get_thinking_budget

-logger = logging.getLogger(__name__)
-

 def create_simple_client(
    agent_type: str = "merge_resolver",
@@ -45,9 +36,6 @@ def create_simple_client(
    cwd: Path | None = None,
    max_turns: int = 1,
    max_thinking_tokens: int | None = None,
-    betas: list[str] | None = None,
-    effort_level: str | None = None,
-    fast_mode: bool = False,
 ) -> ClaudeSDKClient:
    """
    Create a minimal Claude SDK client for single-turn utility operations.
@@ -69,11 +57,6 @@ def create_simple_client(
        max_turns: Maximum conversation turns (default: 1 for single-turn)
        max_thinking_tokens: Override thinking budget (None = use agent default from
                            AGENT_CONFIGS, converted using phase_config.THINKING_BUDGET_MAP)
-        betas: Optional list of SDK beta header strings (e.g., ["context-1m-2025-08-07"])
-        effort_level: Optional effort level for adaptive thinking models (e.g., "low",
-                     "medium", "high"). Injected as CLAUDE_CODE_EFFORT_LEVEL env var.
-        fast_mode: Enable Fast Mode for faster Opus 4.6 output. Enables the "user"
-                  setting source so the CLI reads fastMode from ~/.claude/settings.json.

    Returns:
        Configured ClaudeSDKClient for single-turn operations
@@ -81,27 +64,15 @@ def create_simple_client(
    Raises:
        ValueError: If agent_type is not found in AGENT_CONFIGS
    """
-    # Get environment variables for SDK (including CLAUDE_CONFIG_DIR if set)
+    # Get authentication
+    oauth_token = require_auth_token()
+    import os
+
+    os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
+
+    # Get environment variables for SDK
    sdk_env = get_sdk_env_vars()

-    # Get the config dir for profile-specific credential lookup
-    # CLAUDE_CONFIG_DIR enables per-profile Keychain entries with SHA256-hashed service names
-    config_dir = sdk_env.get("CLAUDE_CONFIG_DIR")
-
-    # Configure SDK authentication (OAuth or API profile mode)
-    configure_sdk_authentication(config_dir)
-
-    # Inject effort level for adaptive thinking models (e.g., Opus 4.6)
-    if effort_level:
-        sdk_env["CLAUDE_CODE_EFFORT_LEVEL"] = effort_level
-
-    # Fast mode: the CLI reads "fastMode" from user settings (~/.claude/settings.json).
-    # By default the SDK passes --setting-sources "" which blocks all filesystem settings.
-    # We enable "user" source so the CLI can read fastMode from user settings.
-    if fast_mode:
-        ensure_fast_mode_in_user_settings()
-        logger.info("[Fast Mode] ACTIVE — will enable user setting source for fastMode")
-
    # Get agent configuration (raises ValueError if unknown type)
    config = get_agent_config(agent_type)

@@ -113,34 +84,14 @@ def create_simple_client(
        thinking_level = get_default_thinking_level(agent_type)
        max_thinking_tokens = get_thinking_budget(thinking_level)

-    # Build options dict
-    # Note: SDK bundles its own CLI, so no cli_path detection needed
-    options_kwargs = {
-        "model": model,
-        "system_prompt": system_prompt,
-        "allowed_tools": allowed_tools,
-        "max_turns": max_turns,
-        "cwd": str(cwd.resolve()) if cwd else None,
-        "env": sdk_env,
-    }
-
-    # Fast mode: enable user setting source so CLI reads fastMode from
-    # ~/.claude/settings.json. Without this, --setting-sources "" blocks it.
-    if fast_mode:
-        options_kwargs["setting_sources"] = ["user"]
-
-    # Only add max_thinking_tokens if not None (Haiku doesn't support extended thinking)
-    if max_thinking_tokens is not None:
-        options_kwargs["max_thinking_tokens"] = max_thinking_tokens
-
-    # Add beta headers if specified (e.g., for 1M context window)
-    if betas:
-        options_kwargs["betas"] = betas
-
-    # Optional: Allow CLI path override via environment variable
-    env_cli_path = os.environ.get("CLAUDE_CLI_PATH")
-    if env_cli_path and validate_cli_path(env_cli_path):
-        options_kwargs["cli_path"] = env_cli_path
-        logger.info(f"Using CLAUDE_CLI_PATH override: {env_cli_path}")
-
-    return ClaudeSDKClient(options=ClaudeAgentOptions(**options_kwargs))
+    return ClaudeSDKClient(
+        options=ClaudeAgentOptions(
+            model=model,
+            system_prompt=system_prompt,
+            allowed_tools=allowed_tools,
+            max_turns=max_turns,
+            cwd=str(cwd.resolve()) if cwd else None,
+            env=sdk_env,
+            max_thinking_tokens=max_thinking_tokens,
+        )
+    )
@@ -1,101 +0,0 @@
-"""
-Task event protocol for frontend XState synchronization.
-
-Protocol: __TASK_EVENT__:{...}
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from uuid import uuid4
-
-TASK_EVENT_PREFIX = "__TASK_EVENT__:"
-_DEBUG = os.environ.get("DEBUG", "").lower() in ("1", "true", "yes")
-
-
-@dataclass
-class TaskEventContext:
-    task_id: str
-    spec_id: str
-    project_id: str
-    sequence_start: int = 0
-
-
-def _load_task_metadata(spec_dir: Path) -> dict:
-    metadata_path = spec_dir / "task_metadata.json"
-    if not metadata_path.exists():
-        return {}
-    try:
-        with open(metadata_path, encoding="utf-8") as f:
-            return json.load(f)
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
-        return {}
-
-
-def _load_last_sequence(spec_dir: Path) -> int:
-    plan_path = spec_dir / "implementation_plan.json"
-    if not plan_path.exists():
-        return 0
-    try:
-        with open(plan_path, encoding="utf-8") as f:
-            plan = json.load(f)
-        last_event = plan.get("lastEvent") or {}
-        seq = last_event.get("sequence")
-        if isinstance(seq, int) and seq >= 0:
-            return seq + 1
-    except (OSError, json.JSONDecodeError, UnicodeDecodeError):
-        return 0
-    return 0
-
-
-def load_task_event_context(spec_dir: Path) -> TaskEventContext:
-    metadata = _load_task_metadata(spec_dir)
-    task_id = metadata.get("taskId") or metadata.get("task_id") or spec_dir.name
-    spec_id = metadata.get("specId") or metadata.get("spec_id") or spec_dir.name
-    project_id = metadata.get("projectId") or metadata.get("project_id") or ""
-    sequence_start = _load_last_sequence(spec_dir)
-    return TaskEventContext(
-        task_id=str(task_id),
-        spec_id=str(spec_id),
-        project_id=str(project_id),
-        sequence_start=sequence_start,
-    )
-
-
-class TaskEventEmitter:
-    def __init__(self, context: TaskEventContext) -> None:
-        self._context = context
-        self._sequence = context.sequence_start
-
-    @classmethod
-    def from_spec_dir(cls, spec_dir: Path) -> TaskEventEmitter:
-        return cls(load_task_event_context(spec_dir))
-
-    def emit(self, event_type: str, payload: dict | None = None) -> None:
-        event = {
-            "type": event_type,
-            "taskId": self._context.task_id,
-            "specId": self._context.spec_id,
-            "projectId": self._context.project_id,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "eventId": str(uuid4()),
-            "sequence": self._sequence,
-        }
-        if payload:
-            event.update(payload)
-
-        try:
-            print(f"{TASK_EVENT_PREFIX}{json.dumps(event, default=str)}", flush=True)
-            self._sequence += 1
-        except (OSError, UnicodeEncodeError) as e:
-            if _DEBUG:
-                try:
-                    sys.stderr.write(f"[task_event] emit failed: {e}\n")
-                    sys.stderr.flush()
-                except (OSError, UnicodeEncodeError):
-                    pass  # Silent on complete I/O failure
@@ -17,6 +17,7 @@ This module has been refactored for better maintainability:
 Public API is exported via workspace/__init__.py for backward compatibility.
 """

+import subprocess
 from pathlib import Path

 # Import git command helper for centralized logging and allowlist compliance
@@ -121,7 +122,6 @@ from merge import (
    FileTimelineTracker,
    MergeOrchestrator,
 )
-from merge.progress import MergeProgressCallback, MergeProgressStage, emit_progress

 MODULE = "workspace"

@@ -146,26 +146,6 @@ MODULE = "workspace"
 # - _heuristic_merge


-def _create_merge_progress_callback() -> MergeProgressCallback | None:
-    """
-    Create a progress callback for merge operations when running as a subprocess.
-
-    Returns emit_progress (writing JSON to stdout) only when stdout is piped
-    (i.e., running as a subprocess from the Electron frontend). Returns None
-    when running interactively in a terminal to avoid polluting CLI output.
-
-    This function must be called at runtime (not at import time) to ensure
-    sys.stdout state is accurate.
-    """
-    import sys
-
-    # Only emit progress JSON when stdout is piped (subprocess mode).
-    # In interactive CLI mode (TTY), progress JSON would clutter the output.
-    if not sys.stdout.isatty():
-        return emit_progress
-    return None
-
-
 def merge_existing_build(
    project_dir: Path,
    spec_name: str,
@@ -208,9 +188,11 @@ def merge_existing_build(
    # Detect current branch - this is where user wants changes merged
    # Normal workflow: user is on their feature branch (e.g., version/2.5.5)
    # and wants to merge the spec changes into it, then PR to main
-    current_branch_result = run_git(
-        ["rev-parse", "--abbrev-ref", "HEAD"],
+    current_branch_result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
        cwd=project_dir,
+        capture_output=True,
+        text=True,
    )
    current_branch = (
        current_branch_result.stdout.strip()
@@ -273,11 +255,10 @@ def merge_existing_build(
                had_conflicts = stats.get("conflicts_resolved", 0) > 0
                ai_assisted = stats.get("ai_assisted", 0) > 0
                direct_copy = stats.get("direct_copy", False)
-                git_merge_used = stats.get("git_merge", False)

-                if had_conflicts or ai_assisted or direct_copy or git_merge_used:
-                    # AI resolved conflicts, assisted with merges, git merge was used, or direct copy was used
-                    # Changes are already written and staged - no need for additional git merge
+                if had_conflicts or ai_assisted or direct_copy:
+                    # AI resolved conflicts, assisted with merges, or direct copy was used
+                    # Changes are already written and staged - no need for git merge
                    _print_merge_success(
                        no_commit, stats, spec_name=spec_name, keep_worktree=True
                    )
@@ -424,20 +405,9 @@ def _try_smart_merge_inner(
        no_commit=no_commit,
    )

-    # Create progress callback for subprocess mode (Electron frontend).
-    # Only emits JSON to stdout when piped, not in interactive CLI.
-    progress_callback = _create_merge_progress_callback()
-
    try:
        print(muted("  Analyzing changes with intent-aware merge..."))

-        if progress_callback is not None:
-            progress_callback(
-                MergeProgressStage.ANALYZING,
-                0,
-                "Starting merge analysis",
-            )
-
        # Capture worktree state in FileTimelineTracker before merge
        try:
            timeline_tracker = FileTimelineTracker(project_dir)
@@ -473,13 +443,6 @@ def _try_smart_merge_inner(
        )

        # Check for git-level conflicts first (branch divergence)
-        if progress_callback is not None:
-            progress_callback(
-                MergeProgressStage.DETECTING_CONFLICTS,
-                25,
-                "Checking for git-level conflicts",
-            )
-
        debug(MODULE, "Checking for git-level conflicts")
        git_conflicts = _check_git_conflicts(project_dir, spec_name)

@@ -532,11 +495,12 @@ def _try_smart_merge_inner(
                # If rebase succeeded and now there are no conflicts,
                # the diverged_but_no_conflicts path will handle the merge
            else:
-                # Rebase failed (likely due to worktree lock) - continue with merge
-                # Git merge or AI resolver will handle it depending on conflict state
-                debug(
-                    MODULE,
-                    "Rebase skipped or failed, continuing with merge flow",
+                # Rebase failed - continue with conflict resolution as before
+                # The AI resolver will handle the conflicts
+                print(
+                    warning(
+                        "  Rebase encountered issues, using AI conflict resolution..."
+                    )
                )

        if git_conflicts.get("has_conflicts"):
@@ -557,18 +521,6 @@ def _try_smart_merge_inner(
                num_conflicts=len(git_conflicts.get("conflicting_files", [])),
            )

-            if progress_callback is not None:
-                progress_callback(
-                    MergeProgressStage.RESOLVING,
-                    50,
-                    f"Resolving {len(git_conflicts.get('conflicting_files', []))} conflicting files with AI",
-                    {
-                        "conflicts_found": len(
-                            git_conflicts.get("conflicting_files", [])
-                        )
-                    },
-                )
-
            # Try to resolve git conflicts with AI
            resolution_result = _resolve_git_conflicts_with_ai(
                project_dir,
@@ -586,22 +538,6 @@ def _try_smart_merge_inner(
                    resolved_files=resolution_result.get("resolved_files", []),
                    stats=resolution_result.get("stats", {}),
                )
-
-                if progress_callback is not None:
-                    stats = resolution_result.get("stats", {})
-                    original_conflict_count = len(
-                        git_conflicts.get("conflicting_files", [])
-                    )
-                    progress_callback(
-                        MergeProgressStage.COMPLETE,
-                        100,
-                        "Merge complete",
-                        {
-                            "conflicts_found": original_conflict_count,
-                            "conflicts_resolved": stats.get("conflicts_resolved", 0),
-                        },
-                    )
-
                return resolution_result
            else:
                # AI couldn't resolve all conflicts
@@ -614,26 +550,6 @@ def _try_smart_merge_inner(
                    resolved_files=resolution_result.get("resolved_files", []),
                    error=resolution_result.get("error"),
                )
-
-                if progress_callback is not None:
-                    original_conflict_count = len(
-                        git_conflicts.get("conflicting_files", [])
-                    )
-                    remaining_count = len(
-                        resolution_result.get("remaining_conflicts", [])
-                    )
-                    progress_callback(
-                        MergeProgressStage.ERROR,
-                        0,
-                        "Some conflicts could not be resolved",
-                        {
-                            "conflicts_found": original_conflict_count,
-                            "conflicts_resolved": original_conflict_count
-                            - remaining_count,
-                            "conflicts_remaining": remaining_count,
-                        },
-                    )
-
                return {
                    "success": False,
                    "conflicts": resolution_result.get("remaining_conflicts", []),
@@ -642,81 +558,153 @@ def _try_smart_merge_inner(
                    "error": resolution_result.get("error"),
                }

-        # Check if branches diverged but no actual conflicts (use git merge)
+        # Check if branches diverged but no actual conflicts (can do direct copy)
        if git_conflicts.get("diverged_but_no_conflicts"):
-            debug(MODULE, "Branches diverged but no conflicts - using git merge")
+            debug(MODULE, "Branches diverged but no conflicts - doing direct file copy")
            print(muted("  Branches diverged but no conflicts detected"))
-            print(muted("  Using git merge to combine changes..."))
+            print(muted("  Copying changed files directly from worktree..."))

+            # Get changed files from spec branch
            spec_branch = f"auto-claude/{spec_name}"
+            base_branch = git_conflicts.get("base_branch", "main")

-            # Use git merge --no-commit to combine changes from both branches
-            # Since merge-tree confirmed no conflicts, this should succeed cleanly
-            merge_result = run_git(
-                ["merge", "--no-commit", "--no-ff", spec_branch],
+            # Get merge-base for diff
+            merge_base_result = subprocess.run(
+                ["git", "merge-base", base_branch, spec_branch],
                cwd=project_dir,
+                capture_output=True,
+                text=True,
+            )
+            merge_base = (
+                merge_base_result.stdout.strip()
+                if merge_base_result.returncode == 0
+                else None
            )

-            if merge_result.returncode == 0:
-                # Merge succeeded - get list of files that were merged
-                # Use git diff --cached to see what's staged
-                diff_result = run_git(
-                    ["diff", "--cached", "--name-only"],
-                    cwd=project_dir,
-                )
-                merged_files = [
-                    f.strip()
-                    for f in diff_result.stdout.splitlines()
-                    if f.strip() and not _is_auto_claude_file(f.strip())
-                ]
-
-                debug_success(
-                    MODULE,
-                    "Git merge succeeded",
-                    merged_files_count=len(merged_files),
+            if merge_base:
+                # Get list of changed files in spec branch
+                changed_files = _get_changed_files_from_branch(
+                    project_dir, merge_base, spec_branch
                )

-                for file_path in merged_files:
-                    print(success(f"    ✓ {file_path}"))
+                resolved_files = []
+                skipped_files = []  # Track files that failed to copy
+                files_to_stage = []
+                for file_path, status in changed_files:
+                    if _is_auto_claude_file(file_path):
+                        continue

-                if progress_callback is not None:
-                    progress_callback(
-                        MergeProgressStage.COMPLETE,
-                        100,
-                        f"Git merge complete ({len(merged_files)} files)",
-                    )
+                    try:
+                        target_path = project_dir / file_path

-                return {
-                    "success": True,
-                    "resolved_files": merged_files,
+                        if status == "D":
+                            # Deleted in worktree
+                            if target_path.exists():
+                                target_path.unlink()
+                            files_to_stage.append(file_path)
+                            resolved_files.append(file_path)
+                            print(success(f"    ✓ {file_path} (deleted)"))
+                        else:
+                            # New or modified - copy from spec branch
+                            target_path.parent.mkdir(parents=True, exist_ok=True)
+
+                            if _is_binary_file(file_path):
+                                binary_content = _get_binary_file_content_from_ref(
+                                    project_dir, spec_branch, file_path
+                                )
+                                if binary_content is not None:
+                                    target_path.write_bytes(binary_content)
+                                    files_to_stage.append(file_path)
+                                    resolved_files.append(file_path)
+                                    status_label = (
+                                        "new file" if status == "A" else "updated"
+                                    )
+                                    print(
+                                        success(f"    ✓ {file_path} ({status_label})")
+                                    )
+                                else:
+                                    skipped_files.append(file_path)
+                                    debug_warning(
+                                        MODULE,
+                                        f"Could not retrieve binary content for {file_path}",
+                                    )
+                            else:
+                                content = _get_file_content_from_ref(
+                                    project_dir, spec_branch, file_path
+                                )
+                                if content is not None:
+                                    target_path.write_text(content, encoding="utf-8")
+                                    files_to_stage.append(file_path)
+                                    resolved_files.append(file_path)
+                                    status_label = (
+                                        "new file" if status == "A" else "updated"
+                                    )
+                                    print(
+                                        success(f"    ✓ {file_path} ({status_label})")
+                                    )
+                                else:
+                                    skipped_files.append(file_path)
+                                    debug_warning(
+                                        MODULE,
+                                        f"Could not retrieve content for {file_path}",
+                                    )
+
+                    except Exception as e:
+                        skipped_files.append(file_path)
+                        debug_warning(MODULE, f"Could not copy {file_path}: {e}")
+
+                # Stage all files in a single git add call for efficiency
+                if files_to_stage:
+                    try:
+                        subprocess.run(
+                            ["git", "add"] + files_to_stage,
+                            cwd=project_dir,
+                            capture_output=True,
+                            text=True,
+                            check=True,
+                        )
+                    except subprocess.CalledProcessError as e:
+                        debug_warning(
+                            MODULE, f"Failed to stage files for direct copy: {e.stderr}"
+                        )
+                        # Return failure - files were written but not staged
+                        return {
+                            "success": False,
+                            "error": f"Failed to stage files: {e.stderr}",
+                            "resolved_files": [],
+                        }
+
+                # Build result - check for skipped files to detect partial merges
+                result = {
+                    "success": len(skipped_files) == 0,
+                    "resolved_files": resolved_files,
                    "stats": {
-                        "files_merged": len(merged_files),
+                        "files_merged": len(resolved_files),
                        "conflicts_resolved": 0,
                        "ai_assisted": 0,
-                        "auto_merged": len(merged_files),
-                        "git_merge": True,  # Flag indicating git merge was used
+                        "auto_merged": len(resolved_files),
+                        "direct_copy": True,  # Flag indicating direct copy was used
+                        "skipped_count": len(skipped_files),
                    },
                }
+                if skipped_files:
+                    result["skipped_files"] = skipped_files
+                    result["partial_success"] = len(resolved_files) > 0
+                    print()
+                    print(
+                        warning(
+                            f"  ⚠ {len(skipped_files)} file(s) could not be retrieved:"
+                        )
+                    )
+                    for skipped_file in skipped_files:
+                        print(muted(f"    - {skipped_file}"))
+                    print(muted("  These files may need manual review."))
+                return result
            else:
-                # Merge failed unexpectedly - abort and fall back to semantic analysis
+                # merge-base failed - branches may not share history
                debug_warning(
                    MODULE,
-                    "Git merge failed unexpectedly despite no conflicts detected",
-                    stderr=merge_result.stderr[:500] if merge_result.stderr else "",
-                )
-                # Abort the merge to restore clean state
-                abort_result = run_git(["merge", "--abort"], cwd=project_dir)
-                if abort_result.returncode != 0:
-                    debug_error(
-                        MODULE,
-                        "Failed to abort merge - repo may be in inconsistent state",
-                        stderr=abort_result.stderr,
-                    )
-                    return None  # Trigger fallback to avoid operating on inconsistent state
-                print(
-                    warning(
-                        "  Git merge failed unexpectedly, falling back to semantic analysis..."
-                    )
+                    "Could not find merge-base between branches - falling back to semantic analysis",
                )

        # No git conflicts - proceed with semantic analysis
@@ -745,14 +733,6 @@ def _try_smart_merge_inner(

        # All conflicts can be auto-merged or no conflicts
        print(muted("  All changes compatible, proceeding with merge..."))
-
-        if progress_callback is not None:
-            progress_callback(
-                MergeProgressStage.COMPLETE,
-                100,
-                f"Analysis complete ({files_to_merge} files compatible)",
-            )
-
        return {
            "success": True,
            "stats": {
@@ -765,13 +745,6 @@ def _try_smart_merge_inner(
        # If smart merge fails, fall back to git
        import traceback

-        if progress_callback is not None:
-            progress_callback(
-                MergeProgressStage.ERROR,
-                0,
-                f"Smart merge error: {e}",
-            )
-
        print(muted(f"  Smart merge error: {e}"))
        traceback.print_exc()
        return None
@@ -783,11 +756,14 @@ def _rebase_spec_branch(
    base_branch: str,
 ) -> bool:
    """
-    Attempt to rebase the spec branch onto the latest base branch.
+    Rebase the spec branch onto the latest base branch.

-    NOTE: This will fail if the spec branch is checked out in a worktree,
-    which is the normal case. The caller should handle failure gracefully
-    by falling back to git merge or AI conflict resolution.
+    This performs an automatic rebase of the spec branch onto the current
+    base branch (main/develop) to bring it up to date before merging.
+    If conflicts occur during rebase, the function aborts and returns False
+    so that the caller can fall back to AI conflict resolution.
+
+    The function preserves the current HEAD by restoring it after completion.

    Args:
        project_dir: The project directory
@@ -796,36 +772,22 @@ def _rebase_spec_branch(

    Returns:
        True if rebase succeeded cleanly or branch was already up-to-date,
-        False if rebase failed (worktree lock, conflicts, or other errors)
+        False if rebase failed due to conflicts or other errors (aborted, no ref movement)
    """
    spec_branch = f"auto-claude/{spec_name}"

    debug(
        MODULE,
-        "Attempting to rebase spec branch",
+        "Rebasing spec branch",
        spec_branch=spec_branch,
        base_branch=base_branch,
    )

-    # Check if spec branch is used by a worktree (common case)
-    # In this case, we can't checkout/rebase from the main repo
-    worktree_list_result = run_git(["worktree", "list", "--porcelain"], cwd=project_dir)
-    if worktree_list_result.returncode == 0:
-        # Check if spec_branch is in use by a worktree
-        output = worktree_list_result.stdout
-        if f"branch refs/heads/{spec_branch}" in output:
-            debug(
-                MODULE,
-                "Spec branch is checked out in a worktree - skipping rebase",
-                spec_branch=spec_branch,
-            )
-            # This is expected - return False to let caller use git merge instead
-            return False
-
-    # Save original branch to restore after rebase
+    # Save original branch to restore after rebase (HIGH: prevents leaving repo on spec branch)
    original_branch_result = run_git(
        ["rev-parse", "--abbrev-ref", "HEAD"], cwd=project_dir
    )
+    # Check returncode and validate stdout before using original_branch
    if original_branch_result.returncode != 0:
        debug_error(
            MODULE,
@@ -841,6 +803,7 @@ def _rebase_spec_branch(
        )
        return False

+    # Save current state for recovery
    # Get the current commit of spec_branch before rebase
    before_commit_result = run_git(["rev-parse", spec_branch], cwd=project_dir)
    if before_commit_result.returncode != 0:
@@ -849,6 +812,8 @@ def _rebase_spec_branch(
            "Could not get spec branch commit before rebase",
            stderr=before_commit_result.stderr,
        )
+        # Restore original branch before returning
+        run_git(["checkout", original_branch], cwd=project_dir)
        return False
    before_commit = before_commit_result.stdout.strip()

@@ -856,18 +821,22 @@ def _rebase_spec_branch(
    print(muted(f"  Rebasing {spec_branch} onto {base_branch}..."))

    try:
-        # Try to checkout the spec branch
+        # Perform the rebase using safe/standard invocation:
+        # 1. Checkout the spec branch first
+        # 2. Run standard rebase (no strategy options - let conflicts stop the rebase)
+        # If conflicts occur, we'll abort and let AI handle them during merge
        checkout_result = run_git(["checkout", spec_branch], cwd=project_dir)
        if checkout_result.returncode != 0:
-            # Checkout failed - likely due to worktree lock
-            debug(
+            debug_error(
                MODULE,
-                "Could not checkout spec branch for rebase (likely worktree lock)",
-                stderr=checkout_result.stderr[:200] if checkout_result.stderr else "",
+                "Could not checkout spec branch for rebase",
+                stderr=checkout_result.stderr,
            )
            return False

-        # Run standard rebase
+        # Run standard rebase - will stop on conflicts so we can detect them
+        # Git syntax: git rebase [options] <upstream>
+        # where <upstream> is the branch to rebase onto
        rebase_result = run_git(
            ["rebase", base_branch],
            cwd=project_dir,
@@ -877,6 +846,9 @@ def _rebase_spec_branch(
            # Rebase failed - check if it was due to conflicts
            status_result = run_git(["status", "--porcelain"], cwd=project_dir)

+            # MEDIUM: Properly parse git status output for conflict markers
+            # Git status --porcelain uses two-character status codes:
+            # UU = both modified, AA = both added, DD = both deleted, etc.
            has_unmerged = any(
                line[:2] in ("UU", "AA", "DD", "AU", "UA", "DU", "UD")
                for line in status_result.stdout.splitlines()
@@ -884,6 +856,7 @@ def _rebase_spec_branch(
            )

            # Abort the rebase to return to clean state
+            # NEW-002: If abort fails, immediately return False (repo in bad state)
            abort_result = run_git(["rebase", "--abort"], cwd=project_dir)
            if abort_result.returncode != 0:
                debug_error(
@@ -891,16 +864,19 @@ def _rebase_spec_branch(
                    "Failed to abort rebase - repo may be in inconsistent state",
                    stderr=abort_result.stderr,
                )
-                return False
+                return False  # Abort failed - cannot safely continue

            if has_unmerged:
+                # Rebase failed due to conflicts - we aborted, so no ref movement happened
                debug_warning(
                    MODULE,
-                    "Rebase encountered conflicts - aborted, will use alternative merge",
+                    "Rebase encountered conflicts - aborted, will use AI conflict resolution",
                    stderr=rebase_result.stderr[:200] if rebase_result.stderr else "",
                )
+                # Return False since we aborted - no rebase occurred, caller should use AI
                return False

+            # Other error (not conflict-related)
            debug_error(
                MODULE,
                "Rebase failed with unexpected error",
@@ -914,7 +890,9 @@ def _rebase_spec_branch(
        if after_commit_result.returncode == 0:
            after_commit_hash = after_commit_result.stdout.strip()

+            # Verify the branch actually moved (commit changed)
            if before_commit == after_commit_hash:
+                # MEDIUM: Branch already up-to-date is a success condition, not failure
                debug(
                    MODULE,
                    "Branch already up-to-date, no rebase needed",
@@ -934,7 +912,8 @@ def _rebase_spec_branch(
        debug_error(MODULE, "Could not verify spec branch commit after rebase")
        return False
    finally:
-        # Always restore original branch
+        # HIGH: Always restore original branch, even on error/exception
+        # NEW-001: Log restoration failure (cannot modify return from finally block)
        if original_branch:
            restore_result = run_git(["checkout", original_branch], cwd=project_dir)
            if restore_result.returncode != 0:
@@ -943,6 +922,8 @@ def _rebase_spec_branch(
                    f"Failed to restore original branch '{original_branch}'",
                    stderr=restore_result.stderr,
                )
+                # Note: Cannot modify return value from finally block,
+                # but restoration failure is rare and non-critical (user can manually switch back)


 def _check_git_conflicts(project_dir: Path, spec_name: str) -> dict:
@@ -1156,9 +1137,11 @@ def _resolve_git_conflicts_with_ai(
    )

    # Get merge-base commit
-    merge_base_result = run_git(
-        ["merge-base", base_branch, spec_branch],
+    merge_base_result = subprocess.run(
+        ["git", "merge-base", base_branch, spec_branch],
        cwd=project_dir,
+        capture_output=True,
+        text=True,
    )
    merge_base = (
        merge_base_result.stdout.strip() if merge_base_result.returncode == 0 else None
@@ -1211,7 +1194,11 @@ def _resolve_git_conflicts_with_ai(
                    )
                    if binary_content is not None:
                        target_path.write_bytes(binary_content)
-                        run_git(["add", target_file_path], cwd=project_dir)
+                        subprocess.run(
+                            ["git", "add", target_file_path],
+                            cwd=project_dir,
+                            capture_output=True,
+                        )
                        resolved_files.append(target_file_path)
                        debug(MODULE, f"Copied new binary file: {file_path}")
                else:
@@ -1220,7 +1207,11 @@ def _resolve_git_conflicts_with_ai(
                    )
                    if content is not None:
                        target_path.write_text(content, encoding="utf-8")
-                        run_git(["add", target_file_path], cwd=project_dir)
+                        subprocess.run(
+                            ["git", "add", target_file_path],
+                            cwd=project_dir,
+                            capture_output=True,
+                        )
                        resolved_files.append(target_file_path)
                        if target_file_path != file_path:
                            debug(
@@ -1360,7 +1351,9 @@ def _resolve_git_conflicts_with_ai(
                    target_path = project_dir / file_path
                    target_path.parent.mkdir(parents=True, exist_ok=True)
                    target_path.write_text(merged_content, encoding="utf-8")
-                    run_git(["add", file_path], cwd=project_dir)
+                    subprocess.run(
+                        ["git", "add", file_path], cwd=project_dir, capture_output=True
+                    )
                    resolved_files.append(file_path)
                    # Show appropriate message based on merge type
                    if file_path in auto_merged_simple:
@@ -1379,7 +1372,11 @@ def _resolve_git_conflicts_with_ai(
                    target_path = project_dir / file_path
                    if target_path.exists():
                        target_path.unlink()
-                        run_git(["add", file_path], cwd=project_dir)
+                        subprocess.run(
+                            ["git", "add", file_path],
+                            cwd=project_dir,
+                            capture_output=True,
+                        )
                    resolved_files.append(file_path)
                    print(success(f"    ✓ {file_path} (deleted)"))
            except Exception as e:
@@ -1421,7 +1418,11 @@ def _resolve_git_conflicts_with_ai(
                target_path = project_dir / result.file_path
                target_path.parent.mkdir(parents=True, exist_ok=True)
                target_path.write_text(result.merged_content, encoding="utf-8")
-                run_git(["add", result.file_path], cwd=project_dir)
+                subprocess.run(
+                    ["git", "add", result.file_path],
+                    cwd=project_dir,
+                    capture_output=True,
+                )
                resolved_files.append(result.file_path)

                if result.was_auto_merged:
@@ -1536,7 +1537,11 @@ def _resolve_git_conflicts_with_ai(
                target_path = project_dir / result.file_path
                target_path.parent.mkdir(parents=True, exist_ok=True)
                target_path.write_text(result.merged_content, encoding="utf-8")
-                run_git(["add", result.file_path], cwd=project_dir)
+                subprocess.run(
+                    ["git", "add", result.file_path],
+                    cwd=project_dir,
+                    capture_output=True,
+                )
                resolved_files.append(result.file_path)

                if result.was_auto_merged:
@@ -1565,7 +1570,11 @@ def _resolve_git_conflicts_with_ai(
                target_path = project_dir / target_file_path
                if target_path.exists():
                    target_path.unlink()
-                    run_git(["add", target_file_path], cwd=project_dir)
+                    subprocess.run(
+                        ["git", "add", target_file_path],
+                        cwd=project_dir,
+                        capture_output=True,
+                    )
            else:
                # Modified without path change - simple copy
                # Check if binary file to use correct read/write method
@@ -1578,7 +1587,11 @@ def _resolve_git_conflicts_with_ai(
                    )
                    if binary_content is not None:
                        target_path.write_bytes(binary_content)
-                        run_git(["add", target_file_path], cwd=project_dir)
+                        subprocess.run(
+                            ["git", "add", target_file_path],
+                            cwd=project_dir,
+                            capture_output=True,
+                        )
                        resolved_files.append(target_file_path)
                        if target_file_path != file_path:
                            debug(
@@ -1591,7 +1604,11 @@ def _resolve_git_conflicts_with_ai(
                    )
                    if content is not None:
                        target_path.write_text(content, encoding="utf-8")
-                        run_git(["add", target_file_path], cwd=project_dir)
+                        subprocess.run(
+                            ["git", "add", target_file_path],
+                            cwd=project_dir,
+                            capture_output=True,
+                        )
                        resolved_files.append(target_file_path)
                        if target_file_path != file_path:
                            debug(
@@ -17,6 +17,7 @@ Public API exported from sub-modules.
 """

 import importlib.util
+import sys
 from pathlib import Path

 # Import merge functions from workspace.py (which coexists with this package)
@@ -27,17 +28,10 @@ _workspace_module = importlib.util.module_from_spec(_spec)
 _spec.loader.exec_module(_workspace_module)
 merge_existing_build = _workspace_module.merge_existing_build
 _run_parallel_merges = _workspace_module._run_parallel_merges
-_resolve_git_conflicts_with_ai = _workspace_module._resolve_git_conflicts_with_ai
 AI_MERGE_SYSTEM_PROMPT = _workspace_module.AI_MERGE_SYSTEM_PROMPT
 _build_merge_prompt = _workspace_module._build_merge_prompt
 _check_git_conflicts = _workspace_module._check_git_conflicts
 _rebase_spec_branch = _workspace_module._rebase_spec_branch
-_create_merge_progress_callback = _workspace_module._create_merge_progress_callback
-_infer_language_from_path = _workspace_module._infer_language_from_path
-_strip_code_fences = _workspace_module._strip_code_fences
-_try_simple_3way_merge = _workspace_module._try_simple_3way_merge
-_attempt_ai_merge = _workspace_module._attempt_ai_merge
-_merge_file_with_ai_async = _workspace_module._merge_file_with_ai_async

 # Models and Enums
 # Display Functions
@@ -80,9 +74,7 @@ from .git_utils import (
    # Export private names for backward compatibility
    _is_process_running,
    _validate_merged_syntax,
-    apply_path_mapping,
    create_conflict_file_with_git,
-    detect_file_renames,
    get_binary_file_content_from_ref,
    get_changed_files_from_branch,
    get_current_branch,
@@ -99,8 +91,6 @@ from .models import (
    MergeLockError,
    ParallelMergeResult,
    ParallelMergeTask,
-    SpecNumberLock,
-    SpecNumberLockError,
    WorkspaceChoice,
    WorkspaceMode,
 )
@@ -120,9 +110,11 @@ from .setup import (
 __all__ = [
    # Merge Operations (from workspace.py)
    "merge_existing_build",
-    # Note: Private functions (_run_parallel_merges, _resolve_git_conflicts_with_ai, etc.)
-    # are kept as module-level assignments for internal use but not exported in __all__
-    # to maintain the underscore convention for private/internal APIs
+    "_run_parallel_merges",  # Private but used internally
+    "AI_MERGE_SYSTEM_PROMPT",  # System prompt for AI merge (ACS-194)
+    "_build_merge_prompt",  # Internal prompt builder (ACS-194)
+    "_check_git_conflicts",  # Internal git conflict detection (ACS-224)
+    "_rebase_spec_branch",  # Internal rebase function (ACS-224)
    # Models
    "WorkspaceMode",
    "WorkspaceChoice",
@@ -130,8 +122,6 @@ __all__ = [
    "ParallelMergeResult",
    "MergeLock",
    "MergeLockError",
-    "SpecNumberLock",
-    "SpecNumberLockError",
    # Git Utils
    "has_uncommitted_changes",
    "get_current_branch",
@@ -141,11 +131,8 @@ __all__ = [
    "get_changed_files_from_branch",
    "is_process_running",
    "is_binary_file",
-    "is_lock_file",
    "validate_merged_syntax",
    "create_conflict_file_with_git",
-    "detect_file_renames",  # File rename detection
-    "apply_path_mapping",  # Path mapping for renamed files
    # Setup
    "choose_workspace",
    "copy_spec_to_worktree",
@@ -1,176 +0,0 @@
-"""
-Dependency Strategy Mapping
-============================
-
-Maps dependency types to sharing strategies for worktree creation.
-
-Each dependency ecosystem has different constraints:
-
- **node_modules**: Safe to symlink. Node's resolution algorithm follows symlinks
-  correctly, and the directory is self-contained.
-
- **venv / .venv**: Must be recreated. Python's ``pyvenv.cfg`` discovery walks the
-  real directory hierarchy without resolving symlinks (CPython bug #106045), so a
-  symlinked venv resolves paths relative to the *target*, not the worktree.
-
- **vendor (PHP)**: Safe to symlink. Composer's autoloader uses ``__DIR__``-relative
-  paths that resolve correctly through symlinks.
-
- **cargo target / go modules**: Skip entirely. Rust's ``target/`` dir contains
-  per-machine build artifacts that must be rebuilt. Go uses a global module cache
-  (``$GOPATH/pkg/mod``), so there is nothing in-tree to share.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from pathlib import Path, PurePosixPath, PureWindowsPath
-
-logger = logging.getLogger(__name__)
-
-from .models import DependencyShareConfig, DependencyStrategy
-
-# ---------------------------------------------------------------------------
-# Default strategy map
-# ---------------------------------------------------------------------------
-# Maps dependency type identifiers to the strategy that should be used when
-# sharing that dependency across worktrees.  Data-driven — add new entries
-# here rather than writing if/else branches.
-# ---------------------------------------------------------------------------
-
-DEFAULT_STRATEGY_MAP: dict[str, DependencyStrategy] = {
-    # JavaScript / Node.js — symlink is safe and fast
-    "node_modules": DependencyStrategy.SYMLINK,
-    # Python — venvs MUST be recreated (pyvenv.cfg symlink bug)
-    "venv": DependencyStrategy.RECREATE,
-    ".venv": DependencyStrategy.RECREATE,
-    # PHP — Composer vendor dir is safe to symlink
-    "vendor_php": DependencyStrategy.SYMLINK,
-    # Ruby — Bundler vendor/bundle is safe to symlink
-    "vendor_bundle": DependencyStrategy.SYMLINK,
-    # Rust — build output dir, skip (rebuilt per-worktree)
-    "cargo_target": DependencyStrategy.SKIP,
-    # Go — global module cache, nothing in-tree to share
-    "go_modules": DependencyStrategy.SKIP,
-}
-
-
-def get_dependency_configs(
-    project_index: dict | None,
-    project_dir: Path | None = None,
-) -> list[DependencyShareConfig]:
-    """Derive dependency share configs from a project index.
-
-    If *project_index* is ``None`` or lacks ``dependency_locations``,
-    falls back to a hardcoded node_modules config for backward compatibility
-    with existing worktree setups.
-
-    Args:
-        project_index: Parsed ``project_index.json`` dict, or ``None``.
-        project_dir: Project root directory for resolved-path containment
-            checks (defense-in-depth).  Should always be provided when
-            *project_index* is not ``None`` — omitting it disables the
-            resolved-path security check.
-
-    Returns:
-        List of :class:`DependencyShareConfig` objects — one per discovered
-        dependency location.
-    """
-
-    configs: list[DependencyShareConfig] = []
-    seen: set[str] = set()
-
-    if project_index is not None:
-        if project_dir is None:
-            logger.warning(
-                "get_dependency_configs called with project_index but no "
-                "project_dir — resolved-path containment check is disabled"
-            )
-
-        # Use the aggregated top-level dependency_locations which already
-        # contain project-relative paths (e.g. "apps/backend/.venv" instead
-        # of just ".venv").  This avoids a monorepo path resolution bug
-        # where service-relative paths were incorrectly treated as project-
-        # relative.
-        dep_locations = project_index.get("dependency_locations") or []
-        for dep in dep_locations:
-            if not isinstance(dep, dict):
-                continue
-
-            dep_type = dep.get("type", "")
-            rel_path = dep.get("path", "")
-
-            if not dep_type or not rel_path:
-                continue
-
-            # Path containment: reject absolute paths and traversals.
-            # Check both POSIX and Windows path styles for cross-platform safety.
-            p = PurePosixPath(rel_path)
-            if p.is_absolute() or PureWindowsPath(rel_path).is_absolute():
-                continue
-            if ".." in p.parts or ".." in PureWindowsPath(rel_path).parts:
-                continue
-
-            # Defense-in-depth: verify the resolved path stays within project_dir
-            if project_dir is not None:
-                resolved = (project_dir / rel_path).resolve()
-                if not str(resolved).startswith(str(project_dir.resolve()) + os.sep):
-                    continue
-
-            # Deduplicate by relative path
-            if rel_path in seen:
-                continue
-            seen.add(rel_path)
-
-            strategy = DEFAULT_STRATEGY_MAP.get(dep_type, DependencyStrategy.SKIP)
-
-            # Validate requirements_file path containment too
-            req_file = dep.get("requirements_file")
-            if req_file:
-                rp = PurePosixPath(req_file)
-                if (
-                    rp.is_absolute()
-                    or PureWindowsPath(req_file).is_absolute()
-                    or ".." in rp.parts
-                    or ".." in PureWindowsPath(req_file).parts
-                ):
-                    req_file = None
-
-                # Defense-in-depth: resolved-path containment (matches rel_path check)
-                if req_file and project_dir is not None:
-                    resolved_req = (project_dir / req_file).resolve()
-                    if not str(resolved_req).startswith(
-                        str(project_dir.resolve()) + os.sep
-                    ):
-                        req_file = None
-
-            configs.append(
-                DependencyShareConfig(
-                    dep_type=dep_type,
-                    strategy=strategy,
-                    source_rel_path=rel_path,
-                    requirements_file=req_file,
-                    package_manager=dep.get("package_manager"),
-                )
-            )
-
-    # Fallback: if no configs were discovered, default to node_modules-only
-    # so existing worktree behaviour is preserved.
-    if not configs:
-        configs.append(
-            DependencyShareConfig(
-                dep_type="node_modules",
-                strategy=DependencyStrategy.SYMLINK,
-                source_rel_path="node_modules",
-            )
-        )
-        configs.append(
-            DependencyShareConfig(
-                dep_type="node_modules",
-                strategy=DependencyStrategy.SYMLINK,
-                source_rel_path="apps/frontend/node_modules",
-            )
-        )
-
-    return configs
@@ -93,7 +93,7 @@ class MergeLock:
                os.close(fd)

                # Write our PID to the lock file
-                self.lock_file.write_text(str(os.getpid()), encoding="utf-8")
+                self.lock_file.write_text(str(os.getpid()))
                self.acquired = True
                return self

@@ -101,7 +101,7 @@ class MergeLock:
                # Lock file exists - check if process is still running
                if self.lock_file.exists():
                    try:
-                        pid = int(self.lock_file.read_text(encoding="utf-8").strip())
+                        pid = int(self.lock_file.read_text().strip())
                        # Import locally to avoid circular dependency
                        import os as _os

@@ -183,7 +183,7 @@ class SpecNumberLock:
                os.close(fd)

                # Write our PID to the lock file
-                self.lock_file.write_text(str(os.getpid()), encoding="utf-8")
+                self.lock_file.write_text(str(os.getpid()))
                self.acquired = True
                return self

@@ -191,7 +191,7 @@ class SpecNumberLock:
                # Lock file exists - check if process is still running
                if self.lock_file.exists():
                    try:
-                        pid = int(self.lock_file.read_text(encoding="utf-8").strip())
+                        pid = int(self.lock_file.read_text().strip())
                        import os as _os

                        try:
@@ -273,31 +273,3 @@ class SpecNumberLock:
                pass

        return max_num
-
-
-class DependencyStrategy(Enum):
-    """Strategy for sharing dependency directories across worktrees.
-
-    SYMLINK is fast but unsafe for certain ecosystems. Notably, Python venv
-    breaks when symlinked because CPython's pyvenv.cfg discovery walks the
-    real directory hierarchy without resolving symlinks first
-    (CPython bug #106045). This means a symlinked venv resolves its home
-    path relative to the symlink target's parent, not the worktree, causing
-    import failures and broken interpreters.
-    """
-
-    SYMLINK = "symlink"  # Create a symlink to the source (fast, works for node_modules)
-    RECREATE = "recreate"  # Re-run the package manager to create a fresh copy
-    COPY = "copy"  # Deep-copy the directory (slow but always correct)
-    SKIP = "skip"  # Do nothing; let the agent handle it
-
-
-@dataclass
-class DependencyShareConfig:
-    """Configuration for how a specific dependency type should be shared."""
-
-    dep_type: str  # e.g. "node_modules", "venv", ".venv"
-    strategy: DependencyStrategy
-    source_rel_path: str  # Relative path from project root, e.g. "node_modules"
-    requirements_file: str | None = None  # e.g. "requirements.txt", "pyproject.toml"
-    package_manager: str | None = None  # e.g. "npm", "uv", "pip"
@@ -7,14 +7,11 @@ Functions for setting up and initializing workspaces.
 """

 import json
-import os
 import shutil
-import subprocess
 import sys
 from pathlib import Path

 from core.git_executable import run_git
-from core.platform import is_windows
 from merge import FileTimelineTracker
 from security.constants import ALLOWLIST_FILENAME, PROFILE_FILENAME
 from ui import (
@@ -29,9 +26,8 @@ from ui import (
 )
 from worktree import WorktreeManager

-from .dependency_strategy import get_dependency_configs
 from .git_utils import has_uncommitted_changes
-from .models import DependencyShareConfig, DependencyStrategy, WorkspaceMode
+from .models import WorkspaceMode

 # Import debug utilities
 try:
@@ -185,103 +181,6 @@ def copy_env_files_to_worktree(project_dir: Path, worktree_path: Path) -> list[s
    return copied


-def symlink_node_modules_to_worktree(
-    project_dir: Path, worktree_path: Path
-) -> list[str]:
-    """
-    Symlink node_modules directories from project root to worktree.
-
-    .. deprecated::
-        Use :func:`setup_worktree_dependencies` instead, which handles all
-        dependency types (node_modules, venvs, vendor dirs, etc.) via
-        strategy-based dispatch.
-
-    This is a thin backward-compatibility wrapper that delegates to
-    ``setup_worktree_dependencies()`` with no project index (fallback mode).
-
-    Args:
-        project_dir: The main project directory
-        worktree_path: Path to the worktree
-
-    Returns:
-        List of symlinked paths (relative to worktree)
-    """
-    results = setup_worktree_dependencies(
-        project_dir, worktree_path, project_index=None
-    )
-    # Flatten all processed paths for backward-compatible return value
-    return [path for paths in results.values() for path in paths]
-
-
-def symlink_claude_config_to_worktree(
-    project_dir: Path, worktree_path: Path
-) -> list[str]:
-    """
-    Symlink .claude/ directory from project root to worktree.
-
-    This ensures the worktree has access to Claude Code configuration
-    (settings, CLAUDE.md, MCP servers, etc.) so that terminals opened
-    in the worktree behave identically to the project root.
-
-    Args:
-        project_dir: The main project directory
-        worktree_path: Path to the worktree
-
-    Returns:
-        List of symlinked paths (relative to worktree)
-    """
-    symlinked = []
-
-    source_path = project_dir / ".claude"
-    target_path = worktree_path / ".claude"
-
-    # Skip if source doesn't exist
-    if not source_path.exists():
-        debug(MODULE, "Skipping .claude/ - source does not exist")
-        return symlinked
-
-    # Skip if target already exists
-    if target_path.exists():
-        debug(MODULE, "Skipping .claude/ - target already exists")
-        return symlinked
-
-    # Also skip if target is a symlink (even if broken)
-    if target_path.is_symlink():
-        debug(MODULE, "Skipping .claude/ - symlink already exists (possibly broken)")
-        return symlinked
-
-    # Ensure parent directory exists
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        if sys.platform == "win32":
-            # On Windows, use junctions instead of symlinks (no admin rights required)
-            result = subprocess.run(
-                ["cmd", "/c", "mklink", "/J", str(target_path), str(source_path)],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode != 0:
-                raise OSError(result.stderr or "mklink /J failed")
-        else:
-            # On macOS/Linux, use relative symlinks for portability
-            relative_source = os.path.relpath(source_path, target_path.parent)
-            os.symlink(relative_source, target_path)
-        symlinked.append(".claude")
-        debug(MODULE, f"Symlinked .claude/ -> {source_path}")
-    except OSError as e:
-        debug_warning(
-            MODULE,
-            f"Could not symlink .claude/: {e}. Claude Code features may not work in worktree terminals.",
-        )
-        print_status(
-            "Warning: Could not link .claude/ - Claude Code features may not work in terminals",
-            "warning",
-        )
-
-    return symlinked
-
-
 def copy_spec_to_worktree(
    source_spec_dir: Path,
    worktree_path: Path,
@@ -324,7 +223,6 @@ def setup_workspace(
    mode: WorkspaceMode,
    source_spec_dir: Path | None = None,
    base_branch: str | None = None,
-    use_local_branch: bool = False,
 ) -> tuple[Path, WorktreeManager | None, Path | None]:
    """
    Set up the workspace based on user's choice.
@@ -337,7 +235,6 @@ def setup_workspace(
        mode: The workspace mode to use
        source_spec_dir: Optional source spec directory to copy to worktree
        base_branch: Base branch for worktree creation (default: current branch)
-        use_local_branch: If True, use local branch directly instead of preferring origin/branch

    Returns:
        Tuple of (working_directory, worktree_manager or None, localized_spec_dir or None)
@@ -358,9 +255,7 @@ def setup_workspace(
    # Ensure timeline tracking hook is installed (once per session)
    ensure_timeline_hook_installed(project_dir)

-    manager = WorktreeManager(
-        project_dir, base_branch=base_branch, use_local_branch=use_local_branch
-    )
+    manager = WorktreeManager(project_dir, base_branch=base_branch)
    manager.setup()

    # Get or create worktree for THIS SPECIFIC SPEC
@@ -373,34 +268,6 @@ def setup_workspace(
            f"Environment files copied: {', '.join(copied_env_files)}", "success"
        )

-    # Set up dependencies in worktree using strategy-based dispatch
-    # Load project index if available for ecosystem-aware dependency handling
-    project_index = None
-    project_index_path = project_dir / ".auto-claude" / "project_index.json"
-    if project_index_path.is_file():
-        try:
-            with open(project_index_path, encoding="utf-8") as f:
-                project_index = json.load(f)
-            debug(MODULE, "Loaded project_index.json for dependency setup")
-        except (OSError, json.JSONDecodeError) as e:
-            debug_warning(MODULE, f"Could not load project_index.json: {e}")
-
-    dep_results = setup_worktree_dependencies(
-        project_dir, worktree_info.path, project_index=project_index
-    )
-    for strategy_name, paths in dep_results.items():
-        if paths:
-            print_status(
-                f"Dependencies ({strategy_name}): {', '.join(paths)}", "success"
-            )
-
-    # Symlink .claude/ config to worktree for Claude Code features (settings, commands, etc.)
-    symlinked_claude = symlink_claude_config_to_worktree(
-        project_dir, worktree_info.path
-    )
-    if symlinked_claude:
-        print_status(f"Claude config linked: {', '.join(symlinked_claude)}", "success")
-
    # Copy security configuration files if they exist
    # Note: Unlike env files, security files always overwrite to ensure
    # the worktree uses the same security rules as the main project.
@@ -429,23 +296,6 @@ def setup_workspace(
            f"Security config copied: {', '.join(security_files_copied)}", "success"
        )

-        # Mark the security profile as inherited from parent project
-        # This prevents hash-based re-analysis which would produce a broken profile
-        # (worktrees lack node_modules and other build artifacts needed for detection)
-        if PROFILE_FILENAME in security_files_copied:
-            profile_path = worktree_info.path / PROFILE_FILENAME
-            try:
-                with open(profile_path, encoding="utf-8") as f:
-                    profile_data = json.load(f)
-                profile_data["inherited_from"] = str(project_dir.resolve())
-                with open(profile_path, "w", encoding="utf-8") as f:
-                    json.dump(profile_data, f, indent=2)
-                debug(
-                    MODULE, f"Marked security profile as inherited from {project_dir}"
-                )
-            except (OSError, json.JSONDecodeError) as e:
-                debug_warning(MODULE, f"Failed to mark profile as inherited: {e}")
-
    # Ensure .auto-claude/ is in the worktree's .gitignore
    # This is critical because the worktree inherits .gitignore from the base branch,
    # which may not have .auto-claude/ if that change wasn't committed/pushed.
@@ -497,7 +347,7 @@ def ensure_timeline_hook_installed(project_dir: Path) -> None:

        # Handle worktrees (where .git is a file, not directory)
        if git_dir.is_file():
-            content = git_dir.read_text(encoding="utf-8").strip()
+            content = git_dir.read_text().strip()
            if content.startswith("gitdir:"):
                git_dir = Path(content.split(":", 1)[1].strip())
            else:
@@ -507,7 +357,7 @@ def ensure_timeline_hook_installed(project_dir: Path) -> None:

        # Check if hook already installed
        if hook_path.exists():
-            if "FileTimelineTracker" in hook_path.read_text(encoding="utf-8"):
+            if "FileTimelineTracker" in hook_path.read_text():
                debug(MODULE, "FileTimelineTracker hook already installed")
                return

@@ -545,7 +395,7 @@ def initialize_timeline_tracking(
        if source_spec_dir:
            plan_path = source_spec_dir / "implementation_plan.json"
            if plan_path.exists():
-                with open(plan_path, encoding="utf-8") as f:
+                with open(plan_path) as f:
                    plan = json.load(f)
                task_title = plan.get("title", spec_name)
                task_intent = plan.get("description", "")
@@ -556,7 +406,6 @@ def initialize_timeline_tracking(
                        files_to_modify.extend(subtask.get("files", []))

        # Get the current branch point commit
-        # Note: run_git() already handles capture_output and encoding internally
        result = run_git(
            ["rev-parse", "HEAD"],
            cwd=project_dir,
@@ -593,299 +442,6 @@ def initialize_timeline_tracking(
        print(muted(f"  Note: Timeline tracking could not be initialized: {e}"))


-def setup_worktree_dependencies(
-    project_dir: Path,
-    worktree_path: Path,
-    project_index: dict | None = None,
-) -> dict[str, list[str]]:
-    """
-    Set up dependencies in a worktree using strategy-based dispatch.
-
-    Reads dependency configs from the project index and applies the correct
-    strategy for each: symlink, recreate, copy, or skip.
-
-    All operations are non-blocking — failures produce warnings but do not
-    prevent worktree creation.
-
-    Args:
-        project_dir: The main project directory
-        worktree_path: Path to the worktree
-        project_index: Parsed project_index.json dict, or None
-
-    Returns:
-        Dict mapping strategy names to lists of paths that were processed.
-    """
-    configs = get_dependency_configs(project_index, project_dir=project_dir)
-    results: dict[str, list[str]] = {}
-
-    for config in configs:
-        strategy_name = config.strategy.value
-        if strategy_name not in results:
-            results[strategy_name] = []
-
-        try:
-            performed = True
-            if config.strategy == DependencyStrategy.SYMLINK:
-                performed = _apply_symlink_strategy(project_dir, worktree_path, config)
-            elif config.strategy == DependencyStrategy.RECREATE:
-                performed = _apply_recreate_strategy(project_dir, worktree_path, config)
-            elif config.strategy == DependencyStrategy.COPY:
-                performed = _apply_copy_strategy(project_dir, worktree_path, config)
-            elif config.strategy == DependencyStrategy.SKIP:
-                _apply_skip_strategy(config)
-                # Don't record skipped entries — only report actual work
-                continue
-            if performed:
-                results[strategy_name].append(config.source_rel_path)
-        except Exception as e:
-            debug_warning(
-                MODULE,
-                f"Failed to apply {strategy_name} strategy for "
-                f"{config.source_rel_path}: {e}",
-            )
-
-    return results
-
-
-def _apply_symlink_strategy(
-    project_dir: Path,
-    worktree_path: Path,
-    config: DependencyShareConfig,
-) -> bool:
-    """Create a symlink (or Windows junction) from worktree to project source.
-
-    Returns True if a symlink was created, False if skipped.
-    """
-    source_path = project_dir / config.source_rel_path
-    target_path = worktree_path / config.source_rel_path
-
-    if not source_path.exists():
-        debug(MODULE, f"Skipping symlink {config.source_rel_path} - source missing")
-        return False
-
-    if target_path.exists() or target_path.is_symlink():
-        debug(MODULE, f"Skipping symlink {config.source_rel_path} - target exists")
-        return False
-
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        if is_windows():
-            # Windows: use directory junctions (no admin rights required).
-            # os.symlink creates a directory symlink that needs admin/DevMode,
-            # so we use mklink /J which creates a junction without privileges.
-            result = subprocess.run(
-                ["cmd", "/c", "mklink", "/J", str(target_path), str(source_path)],
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
-            if result.returncode != 0:
-                raise OSError(result.stderr or "mklink /J failed")
-        else:
-            # macOS/Linux: relative symlinks for portability
-            relative_source = os.path.relpath(source_path, target_path.parent)
-            os.symlink(relative_source, target_path)
-        debug(MODULE, f"Symlinked {config.source_rel_path} -> {source_path}")
-        return True
-    except subprocess.TimeoutExpired:
-        debug_warning(
-            MODULE,
-            f"Symlink creation timed out for {config.source_rel_path}",
-        )
-        print_status(
-            f"Warning: Symlink creation timed out for {config.source_rel_path}",
-            "warning",
-        )
-        return False
-    except OSError as e:
-        debug_warning(
-            MODULE,
-            f"Could not symlink {config.source_rel_path}: {e}",
-        )
-        print_status(f"Warning: Could not link {config.source_rel_path}", "warning")
-        return False
-
-
-def _apply_recreate_strategy(
-    project_dir: Path,
-    worktree_path: Path,
-    config: DependencyShareConfig,
-) -> bool:
-    """Create a fresh virtual environment in the worktree and install deps.
-
-    Returns True if the venv was successfully created, False if skipped or failed.
-    """
-    venv_path = worktree_path / config.source_rel_path
-
-    if venv_path.exists():
-        debug(MODULE, f"Skipping recreate {config.source_rel_path} - already exists")
-        return False
-
-    # Detect Python executable from the source venv or fall back to sys.executable
-    source_venv = project_dir / config.source_rel_path
-    python_exec = sys.executable
-
-    if source_venv.exists():
-        # Try to use the same Python version as the source venv
-        for candidate in ("bin/python", "Scripts/python.exe"):
-            candidate_path = source_venv / candidate
-            if candidate_path.exists():
-                python_exec = str(candidate_path.resolve())
-                break
-
-    # Create the venv
-    try:
-        debug(MODULE, f"Creating venv at {venv_path}")
-        result = subprocess.run(
-            [python_exec, "-m", "venv", str(venv_path)],
-            capture_output=True,
-            text=True,
-            timeout=120,
-        )
-        if result.returncode != 0:
-            debug_warning(MODULE, f"venv creation failed: {result.stderr}")
-            print_status(
-                f"Warning: Could not create venv at {config.source_rel_path}",
-                "warning",
-            )
-            # Clean up partial venv so retries aren't blocked
-            if venv_path.exists():
-                shutil.rmtree(venv_path, ignore_errors=True)
-            return False
-    except subprocess.TimeoutExpired:
-        debug_warning(MODULE, f"venv creation timed out for {config.source_rel_path}")
-        print_status(
-            f"Warning: venv creation timed out for {config.source_rel_path}",
-            "warning",
-        )
-        # Clean up partial venv so retries aren't blocked
-        if venv_path.exists():
-            shutil.rmtree(venv_path, ignore_errors=True)
-        return False
-
-    # Install from requirements file if specified
-    req_file = config.requirements_file
-    if req_file:
-        req_path = project_dir / req_file
-        if req_path.is_file():
-            # Determine pip executable inside the new venv
-            if is_windows():
-                pip_exec = str(venv_path / "Scripts" / "pip.exe")
-            else:
-                pip_exec = str(venv_path / "bin" / "pip")
-
-            # Build install command based on file type
-            req_basename = Path(req_file).name
-            if req_basename == "pyproject.toml":
-                # pyproject.toml: snapshot-install from the worktree copy.
-                # Non-editable so the venv doesn't symlink back to the source.
-                worktree_req = worktree_path / req_file
-                install_dir = str(
-                    worktree_req.parent if worktree_req.is_file() else req_path.parent
-                )
-                install_cmd = [pip_exec, "install", install_dir]
-            elif req_basename == "Pipfile":
-                # Pipfile: not directly installable via pip, skip
-                debug(
-                    MODULE,
-                    f"Skipping Pipfile-based install for {req_file} "
-                    "(use pipenv in the worktree)",
-                )
-                install_cmd = None
-            else:
-                # requirements.txt or similar: pip install -r
-                install_cmd = [pip_exec, "install", "-r", str(req_path)]
-
-            if install_cmd:
-                try:
-                    debug(MODULE, f"Installing deps from {req_file}")
-                    pip_result = subprocess.run(
-                        install_cmd,
-                        capture_output=True,
-                        text=True,
-                        timeout=120,
-                    )
-                    if pip_result.returncode != 0:
-                        debug_warning(
-                            MODULE,
-                            f"pip install failed (exit {pip_result.returncode}): "
-                            f"{pip_result.stderr}",
-                        )
-                        print_status(
-                            f"Warning: Dependency install failed for {req_file}",
-                            "warning",
-                        )
-                        # Clean up broken venv so retries aren't blocked
-                        if venv_path.exists():
-                            shutil.rmtree(venv_path, ignore_errors=True)
-                        return False
-                except subprocess.TimeoutExpired:
-                    debug_warning(
-                        MODULE,
-                        f"pip install timed out for {req_file}",
-                    )
-                    print_status(
-                        f"Warning: Dependency install timed out for {req_file}",
-                        "warning",
-                    )
-                    # Clean up broken venv so retries aren't blocked
-                    if venv_path.exists():
-                        shutil.rmtree(venv_path, ignore_errors=True)
-                    return False
-                except OSError as e:
-                    debug_warning(MODULE, f"pip install failed: {e}")
-                    # Clean up broken venv so retries aren't blocked
-                    if venv_path.exists():
-                        shutil.rmtree(venv_path, ignore_errors=True)
-                    return False
-
-    debug(MODULE, f"Recreated venv at {config.source_rel_path}")
-    return True
-
-
-def _apply_copy_strategy(
-    project_dir: Path,
-    worktree_path: Path,
-    config: DependencyShareConfig,
-) -> bool:
-    """Deep-copy a dependency directory from project to worktree.
-
-    Returns True if the copy was performed, False if skipped.
-    """
-    source_path = project_dir / config.source_rel_path
-    target_path = worktree_path / config.source_rel_path
-
-    if not source_path.exists():
-        debug(MODULE, f"Skipping copy {config.source_rel_path} - source missing")
-        return False
-
-    if target_path.exists():
-        debug(MODULE, f"Skipping copy {config.source_rel_path} - target exists")
-        return False
-
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-
-    try:
-        if source_path.is_file():
-            shutil.copy2(source_path, target_path)
-        else:
-            shutil.copytree(source_path, target_path)
-        debug(MODULE, f"Copied {config.source_rel_path} to worktree")
-        return True
-    except (OSError, shutil.Error) as e:
-        debug_warning(MODULE, f"Could not copy {config.source_rel_path}: {e}")
-        print_status(f"Warning: Could not copy {config.source_rel_path}", "warning")
-        return False
-
-
-def _apply_skip_strategy(config: DependencyShareConfig) -> None:
-    """Skip — nothing to do for this dependency type."""
-    debug(
-        MODULE, f"Skipping {config.dep_type} ({config.source_rel_path}) - skip strategy"
-    )
-
-
 # Export private functions for backward compatibility
 _ensure_timeline_hook_installed = ensure_timeline_hook_installed
 _initialize_timeline_tracking = initialize_timeline_tracking
@@ -1,250 +0,0 @@
-#!/usr/bin/env python3
-"""
-Pytest Configuration and Shared Fixtures for Workspace Tests
-==============================================================
-
-Provides test fixtures for the workspace module tests.
-"""
-
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-from collections.abc import Generator
-from pathlib import Path
-from unittest.mock import MagicMock
-
-import pytest
-
-# =============================================================================
-# MODULE MOCK CLEANUP - Prevents test isolation issues
-# =============================================================================
-
-# List of modules that might be mocked by test files
-_POTENTIALLY_MOCKED_MODULES = [
-    "claude_code_sdk",
-    "claude_code_sdk.types",
-    "claude_agent_sdk",
-    "claude_agent_sdk.types",
-]
-
-# Store original module references at import time (BEFORE pre-mocking)
-_original_module_state = {}
-for _name in _POTENTIALLY_MOCKED_MODULES:
-    if _name in sys.modules:
-        _original_module_state[_name] = sys.modules[_name]
-
-
-# =============================================================================
-# PRE-MOCK EXTERNAL SDK MODULES - Must happen BEFORE adding auto-claude to path
-# =============================================================================
-# These SDK modules may not be installed, so we mock them before any imports
-# that might trigger loading code that depends on them.
-
-
-def _create_sdk_mock():
-    """Create a comprehensive mock for SDK modules."""
-    mock = MagicMock()
-    mock.ClaudeAgentOptions = MagicMock
-    mock.ClaudeSDKClient = MagicMock
-    mock.HookMatcher = MagicMock
-    return mock
-
-
-# Pre-mock claude_agent_sdk if not installed
-if "claude_agent_sdk" not in sys.modules:
-    sys.modules["claude_agent_sdk"] = _create_sdk_mock()
-    sys.modules["claude_agent_sdk.types"] = MagicMock()
-
-# Pre-mock claude_code_sdk if not installed
-if "claude_code_sdk" not in sys.modules:
-    sys.modules["claude_code_sdk"] = _create_sdk_mock()
-    sys.modules["claude_code_sdk.types"] = MagicMock()
-
-# Add backend directory to path for imports
-# When co-located at workspace/tests/, go up to backend directory
-# workspace/tests -> workspace -> core -> backend (4 levels up)
-_backend = Path(__file__).resolve().parent.parent.parent.parent
-sys.path.insert(0, str(_backend))
-
-# Add repo root to sys.path for test_fixtures import fallback
-_repo_root = _backend.parent.parent
-sys.path.insert(0, str(_repo_root))
-
-
-def _cleanup_mocked_modules():
-    """Remove any MagicMock modules from sys.modules."""
-    for name in _POTENTIALLY_MOCKED_MODULES:
-        if name in sys.modules:
-            module = sys.modules[name]
-            if isinstance(module, MagicMock):
-                if name in _original_module_state:
-                    sys.modules[name] = _original_module_state[name]
-                else:
-                    del sys.modules[name]
-
-
-def pytest_sessionstart(session):
-    """Clean up any mocked modules before the test session starts."""
-    _cleanup_mocked_modules()
-
-
-# =============================================================================
-# DIRECTORY FIXTURES
-# =============================================================================
-
-
-@pytest.fixture
-def temp_dir() -> Generator[Path, None, None]:
-    """Create a temporary directory that's cleaned up after the test."""
-    temp_path = Path(tempfile.mkdtemp())
-    yield temp_path
-    shutil.rmtree(temp_path, ignore_errors=True)
-
-
-@pytest.fixture
-def temp_git_repo(temp_dir: Path) -> Generator[Path, None, None]:
-    """Create a temporary git repository with initial commit.
-
-    IMPORTANT: This fixture properly isolates git operations by clearing
-    git environment variables that may be set by pre-commit hooks. Without
-    this isolation, git operations could affect the parent repository when
-    tests run inside a git worktree (e.g., during pre-commit validation).
-
-    See: https://git-scm.com/docs/git#_environment_variables
-    """
-    # Save original environment values to restore later
-    orig_env = {}
-
-    # These git env vars may be set by pre-commit hooks and MUST be cleared
-    # to avoid git operations affecting the parent repository instead of
-    # our isolated test repo. This is critical when running inside worktrees.
-    git_vars_to_clear = [
-        "GIT_DIR",
-        "GIT_WORK_TREE",
-        "GIT_INDEX_FILE",
-        "GIT_OBJECT_DIRECTORY",
-        "GIT_ALTERNATE_OBJECT_DIRECTORIES",
-    ]
-
-    # Clear interfering git environment variables
-    for key in git_vars_to_clear:
-        orig_env[key] = os.environ.get(key)
-        if key in os.environ:
-            del os.environ[key]
-
-    # Set GIT_CEILING_DIRECTORIES to prevent git from discovering parent .git
-    # directories. This is critical for test isolation when running inside
-    # another git repo (like during pre-commit hooks in worktrees).
-    orig_env["GIT_CEILING_DIRECTORIES"] = os.environ.get("GIT_CEILING_DIRECTORIES")
-    os.environ["GIT_CEILING_DIRECTORIES"] = str(temp_dir.parent)
-
-    try:
-        # Initialize git repo
-        subprocess.run(["git", "init"], cwd=temp_dir, capture_output=True, check=True)
-        subprocess.run(
-            ["git", "config", "user.email", "test@example.com"],
-            cwd=temp_dir,
-            capture_output=True,
-        )
-        subprocess.run(
-            ["git", "config", "user.name", "Test User"],
-            cwd=temp_dir,
-            capture_output=True,
-        )
-
-        # Create initial commit
-        test_file = temp_dir / "README.md"
-        test_file.write_text("# Test Project\n", encoding="utf-8")
-        subprocess.run(["git", "add", "."], cwd=temp_dir, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Initial commit"], cwd=temp_dir, capture_output=True
-        )
-
-        # Ensure branch is named 'main' (some git configs default to 'master')
-        subprocess.run(
-            ["git", "branch", "-M", "main"], cwd=temp_dir, capture_output=True
-        )
-
-        yield temp_dir
-    finally:
-        # Restore original environment variables
-        for key, value in orig_env.items():
-            if value is None:
-                os.environ.pop(key, None)
-            else:
-                os.environ[key] = value
-
-
-@pytest.fixture
-def spec_dir(temp_dir: Path) -> Path:
-    """Create a spec directory inside temp_dir."""
-    spec_path = temp_dir / "spec"
-    spec_path.mkdir(parents=True)
-    return spec_path
-
-
-@pytest.fixture
-def project_dir(temp_dir: Path) -> Path:
-    """Create a project directory inside temp_dir."""
-    project_path = temp_dir / "project"
-    project_path.mkdir(parents=True)
-    return project_path
-
-
-@pytest.fixture
-def make_commit(temp_git_repo: Path):
-    """Fixture to make commits in the test git repo.
-
-    Usage:
-        def test_something(make_commit):
-            make_commit("message", files={"file.txt": "content"})
-    """
-
-    def _make_commit(message: str, files: dict[str, str] | None = None):
-        """Create a commit with the given message and files.
-
-        Args:
-            message: Commit message
-            files: Optional dict of {filepath: content} to create before committing
-        """
-        if files:
-            for file_path, content in files.items():
-                full_path = temp_git_repo / file_path
-                full_path.parent.mkdir(parents=True, exist_ok=True)
-                full_path.write_text(content, encoding="utf-8")
-
-        subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", message],
-            cwd=temp_git_repo,
-            capture_output=True,
-        )
-
-    return _make_commit
-
-
-@pytest.fixture
-def stage_files(temp_git_repo: Path):
-    """Fixture to stage files in the test git repo.
-
-    Usage:
-        def test_something(stage_files):
-            stage_files({"file.txt": "content"})
-    """
-
-    def _stage_files(files: dict[str, str]):
-        """Stage files for commit.
-
-        Args:
-            files: Dict of {filepath: content} to create and stage
-        """
-        for file_path, content in files.items():
-            full_path = temp_git_repo / file_path
-            full_path.parent.mkdir(parents=True, exist_ok=True)
-            full_path.write_text(content, encoding="utf-8")
-
-        subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
-
-    return _stage_files
@@ -1,10 +0,0 @@
-[pytest]
-# Pytest configuration for workspace module tests
-
-# Async test mode
-asyncio_mode = auto
-
-# Register custom markers
-markers =
-    slow: marks tests as slow (deselect with '-m "not slow"')
-    integration: marks tests as integration tests (deselect with '-m "not integration"')
@@ -1,856 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for Workspace Display Functions
-======================================
-
-Tests the display.py module functionality including:
- Build summary display
- Changed files display
- Merge success printing
- Conflict info display
- Environment file operations
- Node modules symlink operations
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-# Test constant - in the new per-spec architecture, each spec has its own worktree
-# named after the spec itself. This constant is used for test assertions.
-TEST_SPEC_NAME = "test-spec"
-
-
-class TestShowBuildSummary:
-    """Tests for show_build_summary display function."""
-
-    def test_show_build_summary_no_changes(self, capsys):
-        """show_build_summary prints info message when no changes."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 0,
-            "modified_files": 0,
-            "deleted_files": 0,
-        }
-        mock_manager.get_changed_files.return_value = []
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "No changes were made" in captured.out
-
-    def test_show_build_summary_with_new_files(self, capsys):
-        """show_build_summary displays new files count correctly."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 3,
-            "modified_files": 0,
-            "deleted_files": 0,
-        }
-        mock_manager.get_changed_files.return_value = [
-            ("A", "file1.py"),
-            ("A", "file2.py"),
-            ("A", "file3.py"),
-        ]
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "What was built" in captured.out
-        assert "+ 3 new files" in captured.out
-
-    def test_show_build_summary_singular_new_file(self, capsys):
-        """show_build_summary uses singular form for one new file."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 1,
-            "modified_files": 0,
-            "deleted_files": 0,
-        }
-        mock_manager.get_changed_files.return_value = [("A", "file1.py")]
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "+ 1 new file" in captured.out
-        assert "files" not in captured.out.split("new file")[1].split("\n")[0]
-
-    def test_show_build_summary_with_modified_files(self, capsys):
-        """show_build_summary displays modified files count correctly."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 0,
-            "modified_files": 2,
-            "deleted_files": 0,
-        }
-        mock_manager.get_changed_files.return_value = [
-            ("M", "file1.py"),
-            ("M", "file2.py"),
-        ]
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "~ 2 modified files" in captured.out
-
-    def test_show_build_summary_with_deleted_files(self, capsys):
-        """show_build_summary displays deleted files count correctly."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 0,
-            "modified_files": 0,
-            "deleted_files": 1,
-        }
-        mock_manager.get_changed_files.return_value = [("D", "old.py")]
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "- 1 deleted file" in captured.out
-
-    def test_show_build_summary_mixed_changes(self, capsys):
-        """show_build_summary displays all change types together."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_build_summary
-
-        mock_manager = MagicMock()
-        mock_manager.get_change_summary.return_value = {
-            "new_files": 2,
-            "modified_files": 3,
-            "deleted_files": 1,
-        }
-        mock_manager.get_changed_files.return_value = [
-            ("A", "new1.py"),
-            ("A", "new2.py"),
-            ("M", "mod1.py"),
-            ("M", "mod2.py"),
-            ("M", "mod3.py"),
-            ("D", "old.py"),
-        ]
-
-        show_build_summary(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "+ 2 new files" in captured.out
-        assert "~ 3 modified files" in captured.out
-        assert "- 1 deleted file" in captured.out
-
-
-class TestShowChangedFiles:
-    """Tests for show_changed_files display function."""
-
-    def test_show_changed_files_empty_list(self, capsys):
-        """show_changed_files prints info message when no files changed."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = []
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "No changes" in captured.out
-
-    def test_show_changed_files_with_added_file(self, capsys):
-        """show_changed_files displays added file with + prefix."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = [("A", "new_file.py")]
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "Changed files" in captured.out
-        assert "+ new_file.py" in captured.out
-
-    def test_show_changed_files_with_modified_file(self, capsys):
-        """show_changed_files displays modified file with ~ prefix."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = [("M", "changed.py")]
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "~ changed.py" in captured.out
-
-    def test_show_changed_files_with_deleted_file(self, capsys):
-        """show_changed_files displays deleted file with - prefix."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = [("D", "removed.py")]
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "- removed.py" in captured.out
-
-    def test_show_changed_files_with_unknown_status(self, capsys):
-        """show_changed_files displays unknown status code without decoration."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = [("R", "renamed.py")]
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "R renamed.py" in captured.out
-
-    def test_show_changed_files_multiple_files(self, capsys):
-        """show_changed_files displays all changed files."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.display import show_changed_files
-
-        mock_manager = MagicMock()
-        mock_manager.get_changed_files.return_value = [
-            ("A", "new.py"),
-            ("M", "modified.py"),
-            ("D", "deleted.py"),
-            ("R", "renamed.py"),
-        ]
-
-        show_changed_files(mock_manager, "test-spec")
-
-        captured = capsys.readouterr()
-        assert "+ new.py" in captured.out
-        assert "~ modified.py" in captured.out
-        assert "- deleted.py" in captured.out
-        assert "R renamed.py" in captured.out
-
-
-class TestPrintMergeSuccess:
-    """Tests for print_merge_success display function."""
-
-    def test_print_merge_success_no_commit_basic(self, capsys):
-        """print_merge_success with no_commit=True shows basic message."""
-        from core.workspace.display import print_merge_success
-
-        print_merge_success(no_commit=True)
-
-        captured = capsys.readouterr()
-        assert "CHANGES ADDED TO YOUR PROJECT" in captured.out
-        assert "working directory" in captured.out
-        assert "Review the changes" in captured.out
-        assert "commit when ready" in captured.out
-
-    def test_print_merge_success_no_commit_with_lock_files(self, capsys):
-        """print_merge_success with lock_files_excluded shows lock file note."""
-        from core.workspace.display import print_merge_success
-
-        stats = {"lock_files_excluded": 2}
-        print_merge_success(no_commit=True, stats=stats)
-
-        captured = capsys.readouterr()
-        assert "CHANGES ADDED TO YOUR PROJECT" in captured.out
-        assert "Lock files kept from main" in captured.out
-        assert "npm install" in captured.out
-
-    def test_print_merge_success_no_commit_with_keep_worktree(self, capsys):
-        """print_merge_success with keep_worktree shows discard command."""
-        from core.workspace.display import print_merge_success
-
-        print_merge_success(no_commit=True, spec_name="spec-001", keep_worktree=True)
-
-        captured = capsys.readouterr()
-        assert "CHANGES ADDED TO YOUR PROJECT" in captured.out
-        assert "Worktree kept for testing" in captured.out
-        assert "python auto-claude/run.py --spec spec-001 --discard" in captured.out
-
-    def test_print_merge_success_no_commit_full_scenario(self, capsys):
-        """print_merge_success with all optional parameters."""
-        from core.workspace.display import print_merge_success
-
-        stats = {"lock_files_excluded": 1}
-        print_merge_success(
-            no_commit=True,
-            stats=stats,
-            spec_name="test-spec",
-            keep_worktree=True,
-        )
-
-        captured = capsys.readouterr()
-        assert "CHANGES ADDED TO YOUR PROJECT" in captured.out
-        assert "Lock files kept from main" in captured.out
-        assert "Worktree kept for testing" in captured.out
-        assert "--spec test-spec --discard" in captured.out
-
-    def test_print_merge_success_with_commit_basic(self, capsys):
-        """print_merge_success with no_commit=False shows commit message."""
-        from core.workspace.display import print_merge_success
-
-        print_merge_success(no_commit=False)
-
-        captured = capsys.readouterr()
-        assert "FEATURE ADDED TO YOUR PROJECT" in captured.out
-        assert "separate workspace has been cleaned up" in captured.out
-
-    def test_print_merge_success_with_commit_and_stats(self, capsys):
-        """print_merge_success with stats shows file counts."""
-        from core.workspace.display import print_merge_success
-
-        stats = {
-            "files_added": 5,
-            "files_modified": 3,
-            "files_deleted": 1,
-        }
-        print_merge_success(no_commit=False, stats=stats)
-
-        captured = capsys.readouterr()
-        assert "FEATURE ADDED TO YOUR PROJECT" in captured.out
-        assert "What changed" in captured.out
-        assert "+ 5 files added" in captured.out
-        assert "~ 3 files modified" in captured.out
-        assert "- 1 file deleted" in captured.out
-
-    def test_print_merge_success_singular_file_counts(self, capsys):
-        """print_merge_success uses singular form for single file counts."""
-        from core.workspace.display import print_merge_success
-
-        stats = {
-            "files_added": 1,
-            "files_modified": 1,
-            "files_deleted": 1,
-        }
-        print_merge_success(no_commit=False, stats=stats)
-
-        captured = capsys.readouterr()
-        assert "+ 1 file added" in captured.out
-        assert "~ 1 file modified" in captured.out
-        assert "- 1 file deleted" in captured.out
-
-    def test_print_merge_success_with_keep_worktree(self, capsys):
-        """print_merge_success with keep_worktree shows discard command."""
-        from core.workspace.display import print_merge_success
-
-        print_merge_success(no_commit=False, keep_worktree=True, spec_name="my-spec")
-
-        captured = capsys.readouterr()
-        assert "FEATURE ADDED TO YOUR PROJECT" in captured.out
-        assert "Worktree kept for testing" in captured.out
-        assert "--spec my-spec --discard" in captured.out
-        assert "separate workspace has been cleaned up" not in captured.out
-
-    def test_print_merge_success_zero_file_counts_not_shown(self, capsys):
-        """print_merge_success doesn't show file types with zero count."""
-        from core.workspace.display import print_merge_success
-
-        stats = {
-            "files_added": 2,
-            "files_modified": 0,
-            "files_deleted": 0,
-        }
-        print_merge_success(no_commit=False, stats=stats)
-
-        captured = capsys.readouterr()
-        assert "+ 2 files added" in captured.out
-        assert "files modified" not in captured.out
-        assert "files deleted" not in captured.out
-
-
-class TestPrintConflictInfoExtended:
-    """Extended tests for print_conflict_info display function."""
-
-    def test_print_conflict_info_empty_conflicts(self, capsys):
-        """print_conflict_info returns early with empty conflicts list."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": []}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert captured.out == ""
-
-    def test_print_conflict_info_no_conflicts_key(self, capsys):
-        """print_conflict_info returns early when conflicts key missing."""
-        from core.workspace.display import print_conflict_info
-
-        result = {}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert captured.out == ""
-
-    def test_print_conflict_info_critical_severity(self, capsys):
-        """print_conflict_info shows critical severity icon."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {
-                    "file": "critical.py",
-                    "reason": "Breaking change",
-                    "severity": "critical",
-                }
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "critical.py" in captured.out
-        assert "⛔" in captured.out
-        assert "Breaking change" in captured.out
-
-    def test_print_conflict_info_high_severity(self, capsys):
-        """print_conflict_info shows high severity icon."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "high.py", "reason": "Major conflict", "severity": "high"}
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "high.py" in captured.out
-        assert "🔴" in captured.out
-        assert "Major conflict" in captured.out
-
-    def test_print_conflict_info_medium_severity(self, capsys):
-        """print_conflict_info shows medium severity icon."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "medium.py", "reason": "Minor conflict", "severity": "medium"}
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "medium.py" in captured.out
-        assert "🟡" in captured.out
-        assert "Minor conflict" in captured.out
-
-    def test_print_conflict_info_low_severity_no_icon(self, capsys):
-        """print_conflict_info shows no icon for low severity."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "low.py", "reason": "Trivial issue", "severity": "low"}
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "low.py" in captured.out
-        assert "Trivial issue" in captured.out
-        assert "⛔" not in captured.out
-        assert "🔴" not in captured.out
-        assert "🟡" not in captured.out
-
-    def test_print_conflict_info_unknown_severity(self, capsys):
-        """print_conflict_info handles unknown severity gracefully."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "unknown.py", "reason": "Unknown", "severity": "unknown"}
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "unknown.py" in captured.out
-        assert "Unknown" in captured.out
-
-    def test_print_conflict_info_missing_file_key(self, capsys):
-        """print_conflict_info handles missing file key."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": [{"reason": "No file specified", "severity": "high"}]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "unknown" in captured.out
-        assert "No file specified" in captured.out
-
-    def test_print_conflict_info_missing_reason_key(self, capsys):
-        """print_conflict_info handles missing reason key."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": [{"file": "noreason.py", "severity": "medium"}]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "noreason.py" in captured.out
-
-    def test_print_conflict_info_dict_no_reason(self, capsys):
-        """print_conflict_info with dict missing reason."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": [{"file": "test.py", "severity": "high"}]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "test.py" in captured.out
-        assert "🔴" in captured.out
-
-    def test_print_conflict_info_multiple_conflicts(self, capsys):
-        """print_conflict_info handles multiple conflicts."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "critical.py", "reason": "Critical", "severity": "critical"},
-                {"file": "high.py", "reason": "High", "severity": "high"},
-                {"file": "medium.py", "reason": "Medium", "severity": "medium"},
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "3 file" in captured.out
-        assert "⛔" in captured.out
-        assert "🔴" in captured.out
-        assert "🟡" in captured.out
-
-    def test_print_conflict_info_shows_marker_conflict_message(self, capsys):
-        """print_conflict_info shows marker conflict message for string conflicts."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": ["conflict.py"]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "conflict markers" in captured.out
-        # Check that the conflict markers are mentioned in the message
-
-    def test_print_conflict_info_shows_ai_conflict_message(self, capsys):
-        """print_conflict_info shows AI conflict message for dict conflicts."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {
-                    "file": "ai-conflict.py",
-                    "reason": "AI merge failed",
-                    "severity": "high",
-                }
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "could not be auto-merged" in captured.out
-
-    def test_print_conflict_info_shows_both_messages_mixed(self, capsys):
-        """print_conflict_info shows both messages for mixed conflicts."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                "marker.py",
-                {"file": "ai.py", "reason": "AI failed", "severity": "high"},
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "conflict markers" in captured.out
-        assert "could not be auto-merged" in captured.out
-
-    def test_print_conflict_info_shows_git_commands(self, capsys):
-        """print_conflict_info shows git add and commit commands."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": ["file1.py", "file2.py"]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "git add" in captured.out
-        assert "git commit" in captured.out
-
-    def test_print_conflict_info_quotes_special_paths(self, capsys):
-        """print_conflict_info properly quotes file paths with special characters."""
-        from core.workspace.display import print_conflict_info
-
-        result = {"conflicts": ["file with spaces.py", "file'with'quotes.py"]}
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        # shlex.quote should quote paths with spaces
-        assert "git add" in captured.out
-        assert "file with spaces.py" in captured.out
-
-    def test_print_conflict_info_deduplicates_files(self, capsys):
-        """print_conflict_info deduplicates file paths in git command."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                "file1.py",
-                {"file": "file1.py", "reason": "Also here", "severity": "medium"},
-                "file2.py",
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        # Count occurrences of file1.py
-        count = captured.out.count("file1.py")
-        assert count == 3  # Display shows it twice (string + dict), once in git add
-
-    def test_print_conflict_info_preserves_order(self, capsys):
-        """print_conflict_info preserves file order while deduplicating."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                "first.py",
-                {"file": "second.py", "severity": "high"},
-                "first.py",  # Duplicate
-                {"file": "third.py", "severity": "medium"},
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        # First occurrence should be preserved
-        lines = captured.out.split("\n")
-        first_idx = None
-        second_idx = None
-        for i, line in enumerate(lines):
-            if "first.py" in line:
-                if first_idx is None:
-                    first_idx = i
-            if "second.py" in line:
-                if second_idx is None:
-                    second_idx = i
-        assert first_idx is not None
-        assert second_idx is not None
-
-
-class TestCopyEnvFilesToWorktree:
-    """Tests for copy_env_files_to_worktree function."""
-
-    def test_copies_all_env_files(self, temp_git_repo: Path):
-        """Copies all .env files when they exist in project dir."""
-        from core.workspace.setup import copy_env_files_to_worktree
-
-        # Create .env files in project
-        (temp_git_repo / ".env").write_text("FOO=bar", encoding="utf-8")
-        (temp_git_repo / ".env.local").write_text("LOCAL=1", encoding="utf-8")
-        (temp_git_repo / ".env.development").write_text("DEV=1", encoding="utf-8")
-
-        # Create worktree directory
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        # Copy env files
-        copied = copy_env_files_to_worktree(temp_git_repo, worktree_path)
-
-        # Check all files were copied
-        assert ".env" in copied
-        assert ".env.local" in copied
-        assert ".env.development" in copied
-        assert len(copied) == 3
-
-        # Verify files exist in worktree
-        assert (worktree_path / ".env").exists()
-        assert (worktree_path / ".env.local").exists()
-        assert (worktree_path / ".env.development").exists()
-
-    def test_skips_nonexistent_env_files(self, temp_git_repo: Path):
-        """Only copies env files that exist."""
-        from core.workspace.setup import copy_env_files_to_worktree
-
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        copied = copy_env_files_to_worktree(temp_git_repo, worktree_path)
-
-        assert len(copied) == 0
-
-    def test_does_not_overwrite_existing_env_files(self, temp_git_repo: Path):
-        """Does not overwrite .env files that already exist in worktree."""
-        from core.workspace.setup import copy_env_files_to_worktree
-
-        # Create .env in project
-        (temp_git_repo / ".env").write_text("PROJECT=1", encoding="utf-8")
-
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        # Create existing .env in worktree with different content
-        (worktree_path / ".env").write_text("WORKTREE=1", encoding="utf-8")
-
-        copied = copy_env_files_to_worktree(temp_git_repo, worktree_path)
-
-        # .env should not be in copied list since it already existed
-        assert ".env" not in copied
-
-        # Worktree .env should keep its original content
-        assert (worktree_path / ".env").read_text(encoding="utf-8") == "WORKTREE=1"
-
-
-class TestSymlinkNodeModulesToWorktree:
-    """Tests for symlink_node_modules_to_worktree function."""
-
-    @pytest.mark.skipif(sys.platform != "linux", reason="Unix-specific test")
-    def test_symlinks_node_modules_on_unix(self, temp_git_repo: Path):
-        """Creates relative symlinks on Unix systems."""
-        from core.workspace.setup import symlink_node_modules_to_worktree
-
-        # Create node_modules in project
-        node_modules = temp_git_repo / "node_modules"
-        node_modules.mkdir()
-        (node_modules / "test.txt").write_text("test", encoding="utf-8")
-
-        # Create apps/frontend/node_modules
-        frontend_node_modules = temp_git_repo / "apps" / "frontend" / "node_modules"
-        frontend_node_modules.mkdir(parents=True)
-        (frontend_node_modules / "test2.txt").write_text("test2", encoding="utf-8")
-
-        # Create worktree
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-        (worktree_path / "apps" / "frontend").mkdir(parents=True)
-
-        # Create symlinks
-        symlinked = symlink_node_modules_to_worktree(temp_git_repo, worktree_path)
-
-        assert len(symlinked) == 2
-        assert "node_modules" in symlinked
-        assert "apps/frontend/node_modules" in symlinked
-
-        # Verify symlinks exist and point to correct location
-        assert (worktree_path / "node_modules").is_symlink()
-        assert (worktree_path / "apps" / "frontend" / "node_modules").is_symlink()
-
-    @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific test")
-    def test_creates_junctions_on_windows(self, temp_git_repo: Path, monkeypatch):
-        """Creates junctions on Windows systems."""
-        from unittest.mock import patch
-
-        from core.workspace.setup import symlink_node_modules_to_worktree
-
-        # Create node_modules in project
-        node_modules = temp_git_repo / "node_modules"
-        node_modules.mkdir()
-        (node_modules / "test.txt").write_text("test", encoding="utf-8")
-
-        # Create worktree
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        # Mock subprocess.run to simulate mklink /J success
-        def mock_subprocess_run(cmd, capture_output=False, text=False):
-            result = type("obj", (object,), {"returncode": 0, "stderr": ""})()
-            return result
-
-        with patch("subprocess.run", side_effect=mock_subprocess_run):
-            with monkeypatch.context() as m:
-                m.setattr("sys.platform", "win32")
-                symlinked = symlink_node_modules_to_worktree(
-                    temp_git_repo, worktree_path
-                )
-
-        assert "node_modules" in symlinked
-
-    def test_skips_nonexistent_node_modules(self, temp_git_repo: Path):
-        """Skips node_modules that don't exist in project."""
-        from core.workspace.setup import symlink_node_modules_to_worktree
-
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        symlinked = symlink_node_modules_to_worktree(temp_git_repo, worktree_path)
-
-        assert len(symlinked) == 0
-
-    def test_skips_existing_symlinks(self, temp_git_repo: Path):
-        """Does not recreate symlinks that already exist."""
-        from core.workspace.setup import symlink_node_modules_to_worktree
-
-        # Create node_modules in project
-        node_modules = temp_git_repo / "node_modules"
-        node_modules.mkdir()
-        (node_modules / "test.txt").write_text("test", encoding="utf-8")
-
-        # Create worktree
-        worktree_path = (
-            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
-        )
-        worktree_path.mkdir(parents=True)
-
-        # Create existing symlink
-        if sys.platform != "win32":
-            os.symlink(temp_git_repo / "node_modules", worktree_path / "node_modules")
-
-        symlinked = symlink_node_modules_to_worktree(temp_git_repo, worktree_path)
-
-        # Should skip existing symlink
-        assert "node_modules" not in symlinked
@@ -1,805 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for Workspace Selection and Management
-=============================================
-
-Tests the workspace.py module functionality including:
- Workspace mode selection (isolated vs direct)
- Uncommitted changes detection
- Workspace setup
- Build finalization workflows
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-# Add parent directory to path so we can import the workspace module
-# When co-located at workspace/tests/, we need to add backend to path
-# workspace/tests -> workspace -> core -> backend (4 levels up)
-_backend = Path(__file__).resolve().parent.parent.parent.parent
-sys.path.insert(0, str(_backend))
-
-from core.workspace import (
-    WorkspaceChoice,
-    WorkspaceMode,
-    get_current_branch,
-    get_existing_build_worktree,
-    has_uncommitted_changes,
-    setup_workspace,
-)
-from worktree import WorktreeError, WorktreeManager
-
-# Test constant - in the new per-spec architecture, each spec has its own worktree
-# named after the spec itself. This constant is used for test assertions.
-TEST_SPEC_NAME = "test-spec"
-
-# =============================================================================
-# TESTS FOR finalization.py
-# =============================================================================
-
-
-class TestFinalizeWorkspace:
-    """Tests for finalize_workspace function."""
-
-    def test_direct_mode_returns_merge(self, temp_git_repo: Path, monkeypatch, capsys):
-        """Direct mode returns MERGE choice and shows completion message."""
-        from core.workspace.finalization import finalize_workspace
-
-        # Mock the UI functions
-        def mock_box(content, width=60, style="heavy"):
-            return content
-
-        monkeypatch.setattr("core.workspace.finalization.box", mock_box)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            "test-spec",
-            manager=None,
-            auto_continue=False,
-        )
-
-        assert result == WorkspaceChoice.MERGE
-
-        captured = capsys.readouterr()
-        assert "BUILD COMPLETE" in captured.out
-        assert "directly to your project" in captured.out
-
-    def test_auto_continue_mode_returns_later(self, temp_git_repo: Path):
-        """Auto-continue mode returns LATER choice."""
-        from core.workspace.finalization import finalize_workspace
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree info
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            spec_name,
-            manager=manager,
-            auto_continue=True,
-        )
-
-        assert result == WorkspaceChoice.LATER
-
-    def test_isolated_mode_shows_menu(self, temp_git_repo: Path, monkeypatch):
-        """Isolated mode shows menu with test/review/merge/later options."""
-        from core.workspace.finalization import finalize_workspace
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return "test"
-        def mock_select_menu(title, options, allow_quit):
-            return "test"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            spec_name,
-            manager=manager,
-            auto_continue=False,
-        )
-
-        assert result == WorkspaceChoice.TEST
-
-
-class TestHandleWorkspaceChoice:
-    """Tests for handle_workspace_choice function."""
-
-    def test_choice_test_shows_instructions(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """TEST choice shows testing instructions."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        handle_workspace_choice(WorkspaceChoice.TEST, temp_git_repo, spec_name, manager)
-
-        captured = capsys.readouterr()
-        assert "TEST YOUR FEATURE" in captured.out
-        assert str(worktree_path) in captured.out
-
-    def test_choice_merge_calls_merge_worktree(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """MERGE choice calls manager.merge_worktree."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree and commit something
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-        (worktree_path / "test.py").write_text("test", encoding="utf-8")
-
-        # Initialize git in worktree and commit
-        subprocess.run(["git", "init"], cwd=worktree_path, capture_output=True)
-        subprocess.run(
-            ["git", "config", "user.email", "test@example.com"],
-            cwd=worktree_path,
-            capture_output=True,
-        )
-        subprocess.run(
-            ["git", "config", "user.name", "Test"],
-            cwd=worktree_path,
-            capture_output=True,
-        )
-        subprocess.run(["git", "add", "."], cwd=worktree_path, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Test"], cwd=worktree_path, capture_output=True
-        )
-
-        handle_workspace_choice(
-            WorkspaceChoice.MERGE, temp_git_repo, spec_name, manager
-        )
-
-        captured = capsys.readouterr()
-        assert "Adding changes" in captured.out
-
-    def test_choice_review_shows_changed_files(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """REVIEW choice shows changed files."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock show_changed_files
-        mock_shown = []
-
-        def mock_show_changed_files(manager, spec_name):
-            mock_shown.append(spec_name)
-
-        monkeypatch.setattr(
-            "core.workspace.finalization.show_changed_files", mock_show_changed_files
-        )
-
-        handle_workspace_choice(
-            WorkspaceChoice.REVIEW, temp_git_repo, spec_name, manager
-        )
-
-        assert len(mock_shown) == 1
-        assert mock_shown[0] == spec_name
-
-        captured = capsys.readouterr()
-        assert "To see full details" in captured.out
-
-    def test_choice_later_shows_deferred_message(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """LATER choice shows deferral message."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        handle_workspace_choice(
-            WorkspaceChoice.LATER, temp_git_repo, spec_name, manager
-        )
-
-        captured = capsys.readouterr()
-        assert "No problem!" in captured.out
-        assert "saved" in captured.out
-
-
-class TestReviewExistingBuild:
-    """Tests for review_existing_build function."""
-
-    def test_no_existing_build_shows_warning(self, temp_git_repo: Path, capsys):
-        """Shows warning when no existing build found."""
-        from core.workspace.finalization import review_existing_build
-
-        result = review_existing_build(temp_git_repo, "nonexistent-spec")
-
-        assert result is False
-
-        captured = capsys.readouterr()
-        assert "No existing build found" in captured.out
-
-    def test_shows_build_contents(self, temp_git_repo: Path, capsys):
-        """Shows build summary and changed files when build exists."""
-        from core.workspace.finalization import review_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        result = review_existing_build(temp_git_repo, spec_name)
-
-        assert result is True
-
-        captured = capsys.readouterr()
-        assert "BUILD CONTENTS" in captured.out
-
-
-class TestDiscardExistingBuild:
-    """Tests for discard_existing_build function."""
-
-    def test_no_existing_build_returns_false(self, temp_git_repo: Path, capsys):
-        """Returns False when no existing build found."""
-        from core.workspace.finalization import discard_existing_build
-
-        result = discard_existing_build(temp_git_repo, "nonexistent-spec")
-
-        assert result is False
-
-        captured = capsys.readouterr()
-        assert "No existing build found" in captured.out
-
-    def test_confirmation_deletes_build(self, temp_git_repo: Path, monkeypatch, capsys):
-        """Deletes build when user types 'delete' to confirm."""
-        from core.workspace.finalization import discard_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock input to return "delete"
-        monkeypatch.setattr("builtins.input", lambda: "delete")
-
-        result = discard_existing_build(temp_git_repo, spec_name)
-
-        assert result is True
-        captured = capsys.readouterr()
-        assert "Build deleted" in captured.out
-
-    def test_cancelled_confirmation_returns_false(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """Returns False when user doesn't confirm."""
-        from core.workspace.finalization import discard_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock input to return "no"
-        monkeypatch.setattr("builtins.input", lambda: "no")
-
-        result = discard_existing_build(temp_git_repo, spec_name)
-
-        assert result is False
-        captured = capsys.readouterr()
-        assert "Cancelled" in captured.out
-
-
-class TestCheckExistingBuild:
-    """Tests for check_existing_build function."""
-
-    def test_no_existing_build_returns_false(self, temp_git_repo: Path):
-        """Returns False when no existing build."""
-        from core.workspace.finalization import check_existing_build
-
-        result = check_existing_build(temp_git_repo, "nonexistent-spec")
-
-        assert result is False
-
-    def test_shows_menu_for_existing_build(self, temp_git_repo: Path, monkeypatch):
-        """Shows menu when existing build found."""
-        from core.workspace.finalization import check_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return "continue"
-        def mock_select_menu(title, options, allow_quit):
-            return "continue"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        result = check_existing_build(temp_git_repo, spec_name)
-
-        assert result is True
-
-    def test_review_choice_reviews_and_continues(
-        self, temp_git_repo: Path, monkeypatch
-    ):
-        """Review choice reviews build then continues."""
-        from core.workspace.finalization import check_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        review_called = []
-
-        def mock_review(project_dir, spec_name):
-            review_called.append(spec_name)
-            return True
-
-        def mock_select_menu(title, options, allow_quit):
-            return "review"
-
-        def mock_input(prompt):
-            return ""
-
-        monkeypatch.setattr(
-            "core.workspace.finalization.review_existing_build", mock_review
-        )
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-        monkeypatch.setattr("builtins.input", mock_input)
-
-        result = check_existing_build(temp_git_repo, spec_name)
-
-        assert result is True
-        assert spec_name in review_called
-
-
-class TestListAllWorktrees:
-    """Tests for list_all_worktrees function."""
-
-    def test_returns_empty_list_when_no_worktrees(self, temp_git_repo: Path):
-        """Returns empty list when no worktrees exist."""
-        from core.workspace.finalization import list_all_worktrees
-
-        result = list_all_worktrees(temp_git_repo)
-
-        assert result == []
-
-    def test_lists_existing_worktrees(self, temp_git_repo: Path):
-        """Returns list of existing worktrees."""
-        from core.workspace.finalization import list_all_worktrees
-
-        # Create worktrees
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        (worktrees_dir / "spec-001").mkdir()
-        (worktrees_dir / "spec-002").mkdir()
-
-        result = list_all_worktrees(temp_git_repo)
-
-        assert len(result) == 2
-        spec_names = {wt.spec_name for wt in result}
-        assert "spec-001" in spec_names
-        assert "spec-002" in spec_names
-
-
-class TestCleanupAllWorktrees:
-    """Tests for cleanup_all_worktrees function."""
-
-    def test_no_worktrees_returns_false(self, temp_git_repo: Path, capsys):
-        """Returns False when no worktrees found."""
-        from core.workspace.finalization import cleanup_all_worktrees
-
-        result = cleanup_all_worktrees(temp_git_repo, confirm=False)
-
-        assert result is False
-
-        captured = capsys.readouterr()
-        assert "No worktrees found" in captured.out
-
-    def test_cleanup_without_confirmation(self, temp_git_repo: Path):
-        """Cleans up worktrees when confirm=False."""
-        from core.workspace.finalization import cleanup_all_worktrees
-
-        # Create worktrees
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        spec1_path = worktrees_dir / "spec-001"
-        spec1_path.mkdir()
-        spec2_path = worktrees_dir / "spec-002"
-        spec2_path.mkdir()
-
-        result = cleanup_all_worktrees(temp_git_repo, confirm=False)
-
-        assert result is True
-        assert not spec1_path.exists()
-        assert not spec2_path.exists()
-
-    def test_cleanup_with_confirmation_yes(self, temp_git_repo: Path, monkeypatch):
-        """Cleans up worktrees when user confirms with 'yes'."""
-        from core.workspace.finalization import cleanup_all_worktrees
-
-        # Create worktrees
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        spec1_path = worktrees_dir / "spec-001"
-        spec1_path.mkdir()
-
-        # Mock input to return "yes"
-        monkeypatch.setattr("builtins.input", lambda: "yes")
-
-        result = cleanup_all_worktrees(temp_git_repo, confirm=True)
-
-        assert result is True
-        assert not spec1_path.exists()
-
-    def test_cleanup_with_confirmation_no(self, temp_git_repo: Path, monkeypatch):
-        """Cancels cleanup when user doesn't confirm."""
-        from core.workspace.finalization import cleanup_all_worktrees
-
-        # Create worktrees
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        spec1_path = worktrees_dir / "spec-001"
-        spec1_path.mkdir()
-
-        # Mock input to return "no"
-        monkeypatch.setattr("builtins.input", lambda: "no")
-
-        result = cleanup_all_worktrees(temp_git_repo, confirm=True)
-
-        assert result is False
-        assert spec1_path.exists()  # Should still exist
-
-    def test_cleanup_with_confirmation_keyboard_interrupt(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """Cancels cleanup when user presses Ctrl+C (KeyboardInterrupt)."""
-        from core.workspace.finalization import cleanup_all_worktrees
-
-        # Create worktrees
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        spec1_path = worktrees_dir / "spec-001"
-        spec1_path.mkdir()
-
-        # Mock input to raise KeyboardInterrupt
-        def mock_input(prompt=""):
-            raise KeyboardInterrupt()
-
-        monkeypatch.setattr("builtins.input", mock_input)
-
-        result = cleanup_all_worktrees(temp_git_repo, confirm=True)
-
-        assert result is False
-        assert spec1_path.exists()  # Should still exist
-
-        captured = capsys.readouterr()
-        assert "Cancelled" in captured.out
-
-
-class TestFinalizeWorkspaceBranchCoverage:
-    """Additional tests for finalize_workspace to cover missing branches."""
-
-    def test_isolated_mode_merge_choice(self, temp_git_repo: Path, monkeypatch):
-        """Isolated mode returns MERGE when user selects merge."""
-        from core.workspace.finalization import finalize_workspace
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return "merge"
-        def mock_select_menu(title, options, allow_quit):
-            return "merge"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            spec_name,
-            manager=manager,
-            auto_continue=False,
-        )
-
-        assert result == WorkspaceChoice.MERGE
-
-    def test_isolated_mode_review_choice(self, temp_git_repo: Path, monkeypatch):
-        """Isolated mode returns REVIEW when user selects review."""
-        from core.workspace.finalization import finalize_workspace
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return "review"
-        def mock_select_menu(title, options, allow_quit):
-            return "review"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            spec_name,
-            manager=manager,
-            auto_continue=False,
-        )
-
-        assert result == WorkspaceChoice.REVIEW
-
-    def test_isolated_mode_later_choice(self, temp_git_repo: Path, monkeypatch):
-        """Isolated mode returns LATER when user selects later."""
-        from core.workspace.finalization import finalize_workspace
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return "later"
-        def mock_select_menu(title, options, allow_quit):
-            return "later"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        result = finalize_workspace(
-            temp_git_repo,
-            spec_name,
-            manager=manager,
-            auto_continue=False,
-        )
-
-        assert result == WorkspaceChoice.LATER
-
-
-class TestHandleWorkspaceChoiceBranchCoverage:
-    """Additional tests for handle_workspace_choice to cover missing branches."""
-
-    def test_choice_test_without_staging_path(self, temp_git_repo: Path, capsys):
-        """TEST choice shows fallback instructions when staging_path is None."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree directory (but not through manager, so no staging_path)
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        handle_workspace_choice(WorkspaceChoice.TEST, temp_git_repo, spec_name, manager)
-
-        captured = capsys.readouterr()
-        assert "TEST YOUR FEATURE" in captured.out
-        # Should show the fallback path
-        assert (
-            str(worktree_path) in captured.out
-            or f".auto-claude/worktrees/tasks/{spec_name}" in captured.out
-        )
-
-    def test_choice_merge_success(self, temp_git_repo: Path, capsys):
-        """MERGE choice shows success message when merge succeeds."""
-        from core.workspace.finalization import handle_workspace_choice
-        from worktree import WorktreeManager
-
-        # Setup a proper isolated workspace with git worktree
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Make changes and commit
-        (working_dir / "test.py").write_text("test content", encoding="utf-8")
-        subprocess.run(["git", "add", "."], cwd=working_dir, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Add test"], cwd=working_dir, capture_output=True
-        )
-
-        handle_workspace_choice(
-            WorkspaceChoice.MERGE, temp_git_repo, "test-spec", manager
-        )
-
-        captured = capsys.readouterr()
-        assert "Your feature has been added" in captured.out
-
-    def test_choice_later_without_staging_path(self, temp_git_repo: Path, capsys):
-        """LATER choice shows fallback path when staging_path is None."""
-        from core.workspace.finalization import handle_workspace_choice
-
-        manager = WorktreeManager(temp_git_repo)
-        spec_name = "test-spec"
-
-        # Create worktree directory (but not through manager, so no staging_path)
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        handle_workspace_choice(
-            WorkspaceChoice.LATER, temp_git_repo, spec_name, manager
-        )
-
-        captured = capsys.readouterr()
-        assert "No problem!" in captured.out
-        # Should show the fallback path
-        assert (
-            str(worktree_path) in captured.out
-            or f".auto-claude/worktrees/tasks/{spec_name}" in captured.out
-        )
-
-
-class TestDiscardExistingBuildBranchCoverage:
-    """Additional tests for discard_existing_build to cover missing branches."""
-
-    def test_keyboard_interrupt_cancels_discard(
-        self, temp_git_repo: Path, monkeypatch, capsys
-    ):
-        """KeyboardInterrupt during confirmation returns False."""
-        from core.workspace.finalization import discard_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock input to raise KeyboardInterrupt
-        def mock_input(prompt=""):
-            raise KeyboardInterrupt()
-
-        monkeypatch.setattr("builtins.input", mock_input)
-
-        result = discard_existing_build(temp_git_repo, spec_name)
-
-        assert result is False
-
-        captured = capsys.readouterr()
-        assert "Cancelled" in captured.out
-
-
-class TestCheckExistingBuildBranchCoverage:
-    """Additional tests for check_existing_build to cover missing branches."""
-
-    def test_none_choice_exits(self, temp_git_repo: Path, monkeypatch):
-        """None choice (quit) calls sys.exit(0)."""
-        import sys
-
-        from core.workspace.finalization import check_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        # Mock select_menu to return None (quit)
-        def mock_select_menu(title, options, allow_quit):
-            return None
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        # Should raise SystemExit
-        with pytest.raises(SystemExit) as exc_info:
-            check_existing_build(temp_git_repo, spec_name)
-
-        assert exc_info.value.code == 0
-
-    def test_merge_choice_merges_and_returns_false(
-        self, temp_git_repo: Path, monkeypatch
-    ):
-        """Merge choice calls merge_existing_build and returns False."""
-        from unittest.mock import MagicMock
-
-        from core.workspace.finalization import check_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        merge_called = []
-
-        def mock_merge_existing_build(project_dir, spec_name):
-            merge_called.append(spec_name)
-
-        def mock_select_menu(title, options, allow_quit):
-            return "merge"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-
-        # Mock the workspace module import
-        import workspace as ws
-
-        original_merge = getattr(ws, "merge_existing_build", None)
-        ws.merge_existing_build = mock_merge_existing_build
-
-        try:
-            result = check_existing_build(temp_git_repo, spec_name)
-            assert result is False
-            assert spec_name in merge_called
-        finally:
-            if original_merge:
-                ws.merge_existing_build = original_merge
-
-    def test_fresh_choice_discards_and_returns_false(
-        self, temp_git_repo: Path, monkeypatch
-    ):
-        """Fresh choice discards build and returns False (start fresh)."""
-        from core.workspace.finalization import check_existing_build
-
-        spec_name = "test-spec"
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_path = worktrees_dir / spec_name
-        worktree_path.mkdir(parents=True)
-
-        def mock_select_menu(title, options, allow_quit):
-            return "fresh"
-
-        monkeypatch.setattr("core.workspace.finalization.select_menu", mock_select_menu)
-        # Mock input to return "delete" for confirmation
-        monkeypatch.setattr("builtins.input", lambda: "delete")
-
-        result = check_existing_build(temp_git_repo, spec_name)
-        assert result is False, "Fresh choice should return False"
@@ -1,638 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for Workspace Models
-==========================
-
-Tests the workspace.py module models including:
- WorkspaceMode enum
- WorkspaceChoice enum
- ParallelMergeTask
- ParallelMergeResult
- MergeLock and MergeLockError
- SpecNumberLock and SpecNumberLockError
-"""
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-# Add parent directory to path so we can import the workspace module
-# When co-located at workspace/tests/, we need to add backend to path
-# workspace/tests -> workspace -> core -> backend (4 levels up)
-_backend = Path(__file__).resolve().parent.parent.parent.parent
-sys.path.insert(0, str(_backend))
-
-from core.workspace.models import (
-    MergeLock,
-    MergeLockError,
-    ParallelMergeResult,
-    ParallelMergeTask,
-    SpecNumberLock,
-    SpecNumberLockError,
-)
-from worktree import WorktreeError, WorktreeManager
-
-# Test constant - in the new per-spec architecture, each spec has its own worktree
-# named after the spec itself. This constant is used for test assertions.
-TEST_SPEC_NAME = "test-spec"
-
-
-class TestWorkspaceMode:
-    """Tests for WorkspaceMode enum."""
-
-    def test_isolated_mode(self):
-        """ISOLATED mode value is correct."""
-        from core.workspace.models import WorkspaceMode
-
-        assert WorkspaceMode.ISOLATED.value == "isolated"
-
-    def test_direct_mode(self):
-        """DIRECT mode value is correct."""
-        from core.workspace.models import WorkspaceMode
-
-        assert WorkspaceMode.DIRECT.value == "direct"
-
-
-class TestWorkspaceChoice:
-    """Tests for WorkspaceChoice enum."""
-
-    def test_merge_choice(self):
-        """MERGE choice value is correct."""
-        from core.workspace.models import WorkspaceChoice
-
-        assert WorkspaceChoice.MERGE.value == "merge"
-
-    def test_review_choice(self):
-        """REVIEW choice value is correct."""
-        from core.workspace.models import WorkspaceChoice
-
-        assert WorkspaceChoice.REVIEW.value == "review"
-
-    def test_test_choice(self):
-        """TEST choice value is correct."""
-        from core.workspace.models import WorkspaceChoice
-
-        assert WorkspaceChoice.TEST.value == "test"
-
-    def test_later_choice(self):
-        """LATER choice value is correct."""
-        from core.workspace.models import WorkspaceChoice
-
-        assert WorkspaceChoice.LATER.value == "later"
-
-
-class TestParallelMergeTask:
-    """Tests for ParallelMergeTask dataclass."""
-
-    def test_create_merge_task(self):
-        """ParallelMergeTask can be instantiated with all fields."""
-        task = ParallelMergeTask(
-            file_path="src/example.py",
-            main_content="main content",
-            worktree_content="worktree content",
-            base_content="base content",
-            spec_name="test-spec",
-            project_dir=Path("/project"),
-        )
-
-        assert task.file_path == "src/example.py"
-        assert task.main_content == "main content"
-        assert task.worktree_content == "worktree content"
-        assert task.base_content == "base content"
-        assert task.spec_name == "test-spec"
-        assert task.project_dir == Path("/project")
-
-    def test_merge_task_with_none_base(self):
-        """ParallelMergeTask can have None for base_content."""
-        task = ParallelMergeTask(
-            file_path="src/example.py",
-            main_content="main content",
-            worktree_content="worktree content",
-            base_content=None,
-            spec_name="test-spec",
-            project_dir=Path("/project"),
-        )
-
-        assert task.base_content is None
-
-    def test_merge_task_field_assignment(self):
-        """ParallelMergeTask fields can be reassigned."""
-        task = ParallelMergeTask(
-            file_path="src/example.py",
-            main_content="main",
-            worktree_content="worktree",
-            base_content=None,
-            spec_name="spec-1",
-            project_dir=Path("/project"),
-        )
-
-        task.file_path = "src/updated.py"
-        task.main_content = "updated main"
-        task.worktree_content = "updated worktree"
-        task.base_content = "updated base"
-        task.spec_name = "spec-2"
-        task.project_dir = Path("/updated")
-
-        assert task.file_path == "src/updated.py"
-        assert task.main_content == "updated main"
-        assert task.worktree_content == "updated worktree"
-        assert task.base_content == "updated base"
-        assert task.spec_name == "spec-2"
-        assert task.project_dir == Path("/updated")
-
-
-class TestParallelMergeResult:
-    """Tests for ParallelMergeResult dataclass."""
-
-    def test_create_successful_result(self):
-        """ParallelMergeResult can represent a successful merge."""
-        result = ParallelMergeResult(
-            file_path="src/example.py",
-            merged_content="merged content",
-            success=True,
-            error=None,
-            was_auto_merged=True,
-        )
-
-        assert result.file_path == "src/example.py"
-        assert result.merged_content == "merged content"
-        assert result.success is True
-        assert result.error is None
-        assert result.was_auto_merged is True
-
-    def test_create_failed_result(self):
-        """ParallelMergeResult can represent a failed merge."""
-        result = ParallelMergeResult(
-            file_path="src/example.py",
-            merged_content=None,
-            success=False,
-            error="Merge conflict occurred",
-            was_auto_merged=False,
-        )
-
-        assert result.file_path == "src/example.py"
-        assert result.merged_content is None
-        assert result.success is False
-        assert result.error == "Merge conflict occurred"
-        assert result.was_auto_merged is False
-
-    def test_result_default_values(self):
-        """ParallelMergeResult has correct default values."""
-        result = ParallelMergeResult(
-            file_path="src/example.py",
-            merged_content="content",
-            success=True,
-        )
-
-        assert result.error is None
-        assert result.was_auto_merged is False
-
-    def test_result_field_assignment(self):
-        """ParallelMergeResult fields can be reassigned."""
-        result = ParallelMergeResult(
-            file_path="src/example.py",
-            merged_content="merged",
-            success=True,
-            error=None,
-            was_auto_merged=False,
-        )
-
-        result.file_path = "src/updated.py"
-        result.merged_content = "updated merged"
-        result.success = False
-        result.error = "New error"
-        result.was_auto_merged = True
-
-        assert result.file_path == "src/updated.py"
-        assert result.merged_content == "updated merged"
-        assert result.success is False
-        assert result.error == "New error"
-        assert result.was_auto_merged is True
-
-
-class TestMergeLockError:
-    """Tests for MergeLockError exception."""
-
-    def test_merge_lock_error_creation(self):
-        """MergeLockError can be instantiated with a message."""
-        error = MergeLockError("Could not acquire lock")
-        assert str(error) == "Could not acquire lock"
-
-    def test_merge_lock_error_is_exception(self):
-        """MergeLockError is an Exception subclass."""
-        error = MergeLockError("test")
-        assert isinstance(error, Exception)
-        assert isinstance(error, MergeLockError)
-
-    def test_raise_merge_lock_error(self):
-        """MergeLockError can be raised and caught."""
-        with pytest.raises(MergeLockError) as exc_info:
-            raise MergeLockError("Lock timeout")
-            assert str(exc_info.value) == "Lock timeout"
-
-
-class TestMergeLock:
-    """Tests for MergeLock context manager."""
-
-    def test_merge_lock_initialization(self, temp_git_repo: Path):
-        """MergeLock initializes with correct paths."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        assert lock.project_dir == temp_git_repo
-        assert lock.spec_name == "test-spec"
-        assert lock.lock_dir == temp_git_repo / ".auto-claude" / ".locks"
-        assert lock.lock_file == lock.lock_dir / "merge-test-spec.lock"
-        assert lock.acquired is False
-
-    def test_merge_lock_acquire_and_release(self, temp_git_repo: Path):
-        """MergeLock can be acquired and released."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        with lock:
-            assert lock.acquired is True
-            assert lock.lock_file.exists()
-
-        # After context, lock should be released
-        assert lock.lock_file.exists() is False
-
-    def test_merge_lock_creates_lock_dir(self, temp_git_repo: Path):
-        """MergeLock creates lock directory if it doesn't exist."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        # Remove lock dir if it exists
-        if lock.lock_dir.exists():
-            lock.lock_dir.rmdir()
-
-        with lock:
-            assert lock.lock_dir.exists()
-
-    def test_merge_lock_writes_pid(self, temp_git_repo: Path):
-        """MergeLock writes current PID to lock file."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        with lock:
-            pid_content = lock.lock_file.read_text(encoding="utf-8").strip()
-            assert pid_content == str(os.getpid())
-
-    @pytest.mark.slow
-    def test_merge_lock_timeout_on_contention(self, temp_git_repo: Path):
-        """MergeLock raises MergeLockError when lock is held by another process."""
-        lock1 = MergeLock(temp_git_repo, "test-spec")
-
-        # Acquire first lock
-        lock1.__enter__()
-
-        try:
-            # Create a second lock for the same spec
-            lock2 = MergeLock(temp_git_repo, "test-spec")
-
-            # This should timeout because lock1 holds the lock
-            with pytest.raises(MergeLockError) as exc_info:
-                lock2.__enter__()
-
-            assert "Could not acquire merge lock" in str(exc_info.value)
-            assert "test-spec" in str(exc_info.value)
-            assert "after 30s" in str(exc_info.value)
-        finally:
-            lock1.__exit__(None, None, None)
-
-    def test_merge_lock_removes_stale_lock(self, temp_git_repo: Path):
-        """MergeLock removes stale lock from dead process."""
-        lock1 = MergeLock(temp_git_repo, "test-spec")
-
-        with lock1:
-            # Write a fake PID that doesn't exist
-            fake_pid = 999999
-            lock1.lock_file.write_text(str(fake_pid), encoding="utf-8")
-
-            # Create a new lock - it should remove the stale lock
-            lock2 = MergeLock(temp_git_repo, "test-spec")
-            with lock2:
-                assert lock2.acquired is True
-
-    def test_merge_lock_handles_invalid_pid(self, temp_git_repo: Path):
-        """MergeLock handles invalid PID in lock file."""
-        lock1 = MergeLock(temp_git_repo, "test-spec")
-
-        with lock1:
-            # Write invalid content to lock file
-            lock1.lock_file.write_text("invalid-pid", encoding="utf-8")
-
-            # Create a new lock - it should remove the invalid lock
-            lock2 = MergeLock(temp_git_repo, "test-spec")
-            with lock2:
-                assert lock2.acquired is True
-
-    def test_merge_lock_cleanup_on_exception(self, temp_git_repo: Path):
-        """MergeLock releases lock even if exception occurs in context."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        try:
-            with lock:
-                assert lock.acquired is True
-                raise ValueError("Test exception")
-        except ValueError:
-            pass
-
-        # Lock should be released despite exception
-        assert lock.lock_file.exists() is False
-
-    def test_merge_lock_idempotent_release(self, temp_git_repo: Path):
-        """MergeLock __exit__ can be called multiple times safely."""
-        lock = MergeLock(temp_git_repo, "test-spec")
-
-        with lock:
-            pass
-
-        # Call __exit__ again - should not raise
-        lock.__exit__(None, None, None)
-        lock.__exit__(None, None, None)
-
-    def test_merge_lock_different_specs_dont_conflict(self, temp_git_repo: Path):
-        """MergeLock for different specs can be held simultaneously."""
-        lock1 = MergeLock(temp_git_repo, "spec-1")
-        lock2 = MergeLock(temp_git_repo, "spec-2")
-
-        with lock1:
-            with lock2:
-                assert lock1.acquired is True
-                assert lock2.acquired is True
-                assert lock1.lock_file != lock2.lock_file
-
-
-class TestSpecNumberLockError:
-    """Tests for SpecNumberLockError exception."""
-
-    def test_spec_number_lock_error_creation(self):
-        """SpecNumberLockError can be instantiated with a message."""
-        error = SpecNumberLockError("Could not acquire spec numbering lock")
-        assert str(error) == "Could not acquire spec numbering lock"
-
-    def test_spec_number_lock_error_is_exception(self):
-        """SpecNumberLockError is an Exception subclass."""
-        error = SpecNumberLockError("test")
-        assert isinstance(error, Exception)
-        assert isinstance(error, SpecNumberLockError)
-
-    def test_raise_spec_number_lock_error(self):
-        """SpecNumberLockError can be raised and caught."""
-        with pytest.raises(SpecNumberLockError) as exc_info:
-            raise SpecNumberLockError("Lock timeout")
-            assert str(exc_info.value) == "Lock timeout"
-
-
-class TestSpecNumberLock:
-    """Tests for SpecNumberLock context manager."""
-
-    def test_spec_number_lock_initialization(self, temp_git_repo: Path):
-        """SpecNumberLock initializes with correct paths."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        assert lock.project_dir == temp_git_repo
-        assert lock.lock_dir == temp_git_repo / ".auto-claude" / ".locks"
-        assert lock.lock_file == lock.lock_dir / "spec-numbering.lock"
-        assert lock.acquired is False
-        assert lock._global_max is None
-
-    def test_spec_number_lock_acquire_and_release(self, temp_git_repo: Path):
-        """SpecNumberLock can be acquired and released."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            assert lock.acquired is True
-            assert lock.lock_file.exists()
-
-        # After context, lock should be released
-        assert lock.lock_file.exists() is False
-
-    def test_spec_number_lock_creates_lock_dir(self, temp_git_repo: Path):
-        """SpecNumberLock creates lock directory if it doesn't exist."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        # Remove lock dir if it exists
-        if lock.lock_dir.exists():
-            lock.lock_dir.rmdir()
-
-        with lock:
-            assert lock.lock_dir.exists()
-
-    def test_spec_number_lock_writes_pid(self, temp_git_repo: Path):
-        """SpecNumberLock writes current PID to lock file."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            pid_content = lock.lock_file.read_text(encoding="utf-8").strip()
-            assert pid_content == str(os.getpid())
-
-    def test_get_next_spec_number_no_existing_specs(self, temp_git_repo: Path):
-        """get_next_spec_number returns 1 when no specs exist."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            next_num = lock.get_next_spec_number()
-            assert next_num == 1
-
-    def test_get_next_spec_number_with_existing_specs(self, temp_git_repo: Path):
-        """get_next_spec_number returns max existing spec number + 1."""
-        # Create spec directories
-        specs_dir = temp_git_repo / ".auto-claude" / "specs"
-        specs_dir.mkdir(parents=True)
-        (specs_dir / "001-first").mkdir()
-        (specs_dir / "003-third").mkdir()
-
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            next_num = lock.get_next_spec_number()
-            assert next_num == 4
-
-    def test_get_next_spec_number_caches_result(self, temp_git_repo: Path):
-        """get_next_spec_number caches the global max."""
-        specs_dir = temp_git_repo / ".auto-claude" / "specs"
-        specs_dir.mkdir(parents=True)
-        (specs_dir / "005-test").mkdir()
-
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            next_num1 = lock.get_next_spec_number()
-            next_num2 = lock.get_next_spec_number()
-
-            # Should return the same value (cached)
-            assert next_num1 == next_num2 == 6
-            assert lock._global_max == 5
-
-    def test_get_next_spec_number_requires_lock(self, temp_git_repo: Path):
-        """get_next_spec_number raises SpecNumberLockError if lock not acquired."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with pytest.raises(SpecNumberLockError) as exc_info:
-            lock.get_next_spec_number()
-
-        assert "Lock must be acquired" in str(exc_info.value)
-
-    def test_get_next_spec_number_scans_worktrees(self, temp_git_repo: Path):
-        """get_next_spec_number scans all worktree spec directories."""
-        # Create main project specs
-        main_specs = temp_git_repo / ".auto-claude" / "specs"
-        main_specs.mkdir(parents=True)
-        (main_specs / "002-main").mkdir()
-
-        # Create worktree with specs
-        worktrees_dir = temp_git_repo / ".auto-claude" / "worktrees" / "tasks"
-        worktrees_dir.mkdir(parents=True)
-        worktree_spec_dir = worktrees_dir / "test-worktree" / ".auto-claude" / "specs"
-        worktree_spec_dir.mkdir(parents=True)
-        (worktree_spec_dir / "005-worktree").mkdir()
-
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            next_num = lock.get_next_spec_number()
-            # Should find max of 2 and 5, return 6
-            assert next_num == 6
-
-    def test_scan_specs_dir_nonexistent(self, temp_git_repo: Path):
-        """_scan_specs_dir returns 0 for nonexistent directory."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            # Use a path inside temp_dir that doesn't exist
-            nonexistent = temp_git_repo / "this_does_not_exist_specs"
-            result = lock._scan_specs_dir(nonexistent)
-            assert result == 0
-
-    def test_scan_specs_dir_ignores_invalid_names(self, temp_git_repo: Path):
-        """_scan_specs_dir ignores directories with invalid spec names."""
-        specs_dir = temp_git_repo / ".auto-claude" / "specs"
-        specs_dir.mkdir(parents=True)
-        (specs_dir / "001-valid").mkdir()
-        (specs_dir / "invalid-name").mkdir()
-        (specs_dir / "abc").mkdir()
-        (specs_dir / "100-valid").mkdir()
-
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            result = lock._scan_specs_dir(specs_dir)
-            # Should only count 001 and 100
-            assert result == 100
-
-    @pytest.mark.slow
-    def test_spec_number_lock_timeout_on_contention(self, temp_git_repo: Path):
-        """SpecNumberLock raises SpecNumberLockError when lock is held."""
-        lock1 = SpecNumberLock(temp_git_repo)
-
-        # Acquire first lock
-        lock1.__enter__()
-
-        try:
-            # Create a second lock
-            lock2 = SpecNumberLock(temp_git_repo)
-
-            # This should timeout because lock1 holds the lock
-            with pytest.raises(SpecNumberLockError) as exc_info:
-                lock2.__enter__()
-
-            assert "Could not acquire spec numbering lock" in str(exc_info.value)
-            assert "after 30s" in str(exc_info.value)
-        finally:
-            lock1.__exit__(None, None, None)
-
-    def test_spec_number_lock_removes_stale_lock(self, temp_git_repo: Path):
-        """SpecNumberLock removes stale lock from dead process."""
-        lock1 = SpecNumberLock(temp_git_repo)
-
-        with lock1:
-            # Write a fake PID that doesn't exist
-            fake_pid = 999999
-            lock1.lock_file.write_text(str(fake_pid), encoding="utf-8")
-
-            # Create a new lock - it should remove the stale lock
-            lock2 = SpecNumberLock(temp_git_repo)
-            with lock2:
-                assert lock2.acquired is True
-
-    def test_spec_number_lock_handles_invalid_pid(self, temp_git_repo: Path):
-        """SpecNumberLock handles invalid PID in lock file."""
-        lock1 = SpecNumberLock(temp_git_repo)
-
-        with lock1:
-            # Write invalid content to lock file
-            lock1.lock_file.write_text("invalid-pid", encoding="utf-8")
-
-            # Create a new lock - it should remove the invalid lock
-            lock2 = SpecNumberLock(temp_git_repo)
-            with lock2:
-                assert lock2.acquired is True
-
-    def test_spec_number_lock_cleanup_on_exception(self, temp_git_repo: Path):
-        """SpecNumberLock releases lock even if exception occurs in context."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        try:
-            with lock:
-                assert lock.acquired is True
-                raise ValueError("Test exception")
-        except ValueError:
-            pass
-
-        # Lock should be released despite exception
-        assert lock.lock_file.exists() is False
-
-    def test_spec_number_lock_idempotent_release(self, temp_git_repo: Path):
-        """SpecNumberLock __exit__ can be called multiple times safely."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock:
-            pass
-
-        # Call __exit__ again - should not raise
-        lock.__exit__(None, None, None)
-        lock.__exit__(None, None, None)
-
-    def test_spec_number_lock_returns_self(self, temp_git_repo: Path):
-        """SpecNumberLock __enter__ returns self."""
-        lock = SpecNumberLock(temp_git_repo)
-
-        with lock as entered_lock:
-            assert entered_lock is lock
-
-    def test_merge_success_returns_true(self, temp_git_repo: Path):
-        """Successful merge returns True (ACS-163 verification)."""
-        manager = WorktreeManager(temp_git_repo)
-        manager.setup()
-
-        # Create a worktree with non-conflicting changes
-        worker_info = manager.create_worktree("worker-spec")
-        (worker_info.path / "worker-file.txt").write_text(
-            "worker content", encoding="utf-8"
-        )
-        subprocess.run(["git", "add", "."], cwd=worker_info.path, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Worker commit"],
-            cwd=worker_info.path,
-            capture_output=True,
-        )
-
-        # Merge should succeed
-        result = manager.merge_worktree("worker-spec", delete_after=False)
-
-        assert result is True
-
-        # Verify the file was merged into base branch
-        subprocess.run(
-            ["git", "checkout", manager.base_branch],
-            cwd=temp_git_repo,
-            capture_output=True,
-        )
-        assert (temp_git_repo / "worker-file.txt").exists(), (
-            "Merged file should exist in base branch"
-        )
-        merged_content = (temp_git_repo / "worker-file.txt").read_text(encoding="utf-8")
-        assert merged_content == "worker content", (
-            "Merged file should have worktree content"
-        )
--- a/Show More
+++ b/Show More