fix: enable pytest in worktrees for pre-commit hook

Remove the worktree skip since path resolution is now handled by running
pytest from project root. This catches test failures locally before CI.

.coveragerc

@@ -0,0 +1,12 @@
+[run]
+parallel = true
+source = apps/backend/cli
+omit =
+    */tests/*
+    */__pycache__/*
+    */.venv/*
+
+[report]
+exclude_lines =
+    pragma: no cover
+    if __name__ == "__main__":

.github/workflows/beta-release.yml

@@ -405,11 +405,11 @@ jobs:
       - name: Setup Node.js and install dependencies
         uses: ./.github/actions/setup-node-frontend
 
-      - name: Setup Flatpak
+      - name: Setup Flatpak and verification tools
         run: |
           set -e
           sudo apt-get update
-          sudo apt-get install -y flatpak flatpak-builder
+          sudo apt-get install -y flatpak flatpak-builder libarchive-tools
           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
@@ -447,6 +447,9 @@ 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:

.github/workflows/release.yml

@@ -344,10 +344,10 @@ jobs:
       - name: Setup Node.js and install dependencies
         uses: ./.github/actions/setup-node-frontend
 
-      - name: Setup Flatpak
+      - name: Setup Flatpak and verification tools
         run: |
           sudo apt-get update
-          sudo apt-get install -y flatpak flatpak-builder
+          sudo apt-get install -y flatpak flatpak-builder libarchive-tools
           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
@@ -383,6 +383,9 @@ 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:

.gitignore

@@ -7,6 +7,7 @@
 Thumbs.db
 ehthumbs.db
 Desktop.ini
+nul
 
 # ===========================
 # Security - Environment & Secrets

.husky/pre-commit

@@ -1,52 +1,36 @@
 #!/bin/sh
 
 # =============================================================================
-# GIT WORKTREE CONTEXT HANDLING
+# GIT WORKTREE ENVIRONMENT CLEANUP
 # =============================================================================
-# When running in a worktree, we need to preserve git context to prevent HEAD
-# corruption. However, we must also CLEAR these variables when NOT in a worktree
-# to prevent cross-worktree contamination (files leaking between worktrees).
+# 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.
 #
-# The bug: If GIT_DIR/GIT_WORK_TREE are set from a previous worktree session
-# and this hook runs in the main repo (where .git is a directory, not a file),
-# git commands will target the wrong repository, causing files to appear as
-# untracked in the wrong location.
-#
-# Fix: Explicitly unset these variables when NOT in a worktree context.
+# 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.
 # =============================================================================
-
-if [ -f ".git" ]; then
-  # We're in a worktree (.git is a file pointing to the actual git dir)
-  # Use -n with /p to only print lines that match the gitdir: prefix, head -1 for safety
-  WORKTREE_GIT_DIR=$(sed -n 's/^gitdir: //p' .git | head -1)
-  if [ -n "$WORKTREE_GIT_DIR" ] && [ -d "$WORKTREE_GIT_DIR" ]; then
-    export GIT_DIR="$WORKTREE_GIT_DIR"
-    export GIT_WORK_TREE="$(pwd)"
-  else
-    # .git file exists but is malformed or points to non-existent directory
-    # CRITICAL: Clear any inherited GIT_DIR/GIT_WORK_TREE to prevent cross-worktree leakage
-    unset GIT_DIR
-    unset GIT_WORK_TREE
-  fi
-else
-  # We're in the main repo (.git is a directory)
-  # CRITICAL: Clear any inherited GIT_DIR/GIT_WORK_TREE to prevent cross-worktree leakage
-  unset GIT_DIR
-  unset GIT_WORK_TREE
-fi
+unset GIT_DIR
+unset GIT_WORK_TREE
 
 # =============================================================================
 # SAFETY CHECK: Detect and fix corrupted core.worktree configuration
 # =============================================================================
-# If core.worktree is set in the main repo's config (pointing to a worktree),
-# this indicates previous corruption. Fix it automatically.
-if [ ! -f ".git" ]; then
-  CORE_WORKTREE=$(git config --get core.worktree 2>/dev/null || true)
-  if [ -n "$CORE_WORKTREE" ]; then
-    echo "Warning: Detected corrupted core.worktree setting, removing it..."
-    if ! git config --unset core.worktree 2>/dev/null; then
-      echo "Warning: Failed to unset core.worktree. Manual intervention may be needed."
-    fi
+# 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."
   fi
 fi
 
@@ -178,37 +162,39 @@ if git diff --cached --name-only | grep -q "^apps/backend/.*\.py$"; then
   fi
 
   # Run pytest (skip slow/integration tests and Windows-incompatible tests for pre-commit speed)
-  # Use subshell to isolate directory changes and prevent worktree corruption
+  # Run from repo root (not apps/backend) so tests that use Path.resolve() get correct CWD.
+  # PYTHONPATH includes apps/backend so imports resolve correctly.
   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)
-    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"
-    
+    # 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 ".venv/bin/python" ]; then
-      VENV_PYTHON=".venv/bin/python"
-    elif [ -f ".venv/Scripts/python.exe" ]; then
-      VENV_PYTHON=".venv/Scripts/python.exe"
+    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=. $VENV_PYTHON -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
+        PYTHONPATH=apps/backend $VENV_PYTHON -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $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=. $VENV_PYTHON -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
+        $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
       fi
-    elif [ -d ".venv" ]; then
+    elif [ -d "apps/backend/.venv" ]; then
       echo "Warning: venv exists but Python not found in it, using system Python"
-      PYTHONPATH=. python -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
+      PYTHONPATH=apps/backend python -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
     else
       echo "Warning: No .venv found in apps/backend, using system Python"
-      PYTHONPATH=. python -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" $IGNORE_TESTS
+      PYTHONPATH=apps/backend python -m pytest tests/ -v --tb=short -x -m "not slow and not integration" -k "not windows_path" $IGNORE_TESTS
     fi
   )
   if [ $? -ne 0 ]; then

.pre-commit-config.yaml

@@ -97,9 +97,8 @@ repos:
       - id: ruff-format
         files: ^apps/backend/
 
-  # Python tests (apps/backend/) - skip slow/integration tests for pre-commit speed
+  # Python tests (apps/backend/) - run full test suite from project root
   # 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
@@ -108,31 +107,24 @@ repos:
         args:
           - -c
           - |
-            # 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"
+            # 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"
             else
               PYTEST_CMD="python -m pytest"
             fi
-            PYTHONPATH=. $PYTEST_CMD \
-              ../../tests/ \
+            $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

CHANGELOG.md

@@ -74,6 +74,8 @@
 
 ### 🐛 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

CLAUDE.md

@@ -40,6 +40,18 @@ Auto Claude is a desktop application (+ CLI) where users describe a goal and AI
 
 **PR target** — Always target the `develop` branch for PRs to AndyMik90/Auto-Claude, NOT `main`.
 
+## 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.
+
 ## Project Structure
 
 ```
@@ -98,30 +110,6 @@ cd apps/backend && uv venv && uv pip install -r requirements.txt
 cd apps/frontend && npm install
 ```
 
-### Backend
-```bash
-cd apps/backend
-python spec_runner.py --interactive            # Create spec interactively
-python spec_runner.py --task "description"      # Create from task
-python run.py --spec 001                        # Run autonomous build
-python run.py --spec 001 --qa                   # Run QA validation
-python run.py --spec 001 --merge                # Merge completed build
-python run.py --list                            # List all specs
-```
-
-### Frontend
-```bash
-cd apps/frontend
-npm run dev              # Dev mode (Electron + Vite HMR)
-npm run build            # Production build
-npm run test             # Vitest unit tests
-npm run test:watch       # Vitest watch mode
-npm run lint             # Biome check
-npm run lint:fix         # Biome auto-fix
-npm run typecheck        # TypeScript strict check
-npm run package          # Package for distribution
-```
-
 ### Testing
 
 | Stack | Command | Tool |
@@ -145,30 +133,7 @@ See [RELEASE.md](RELEASE.md) for full release process.
 
 Client: `apps/backend/core/client.py` — `create_client()` returns a configured `ClaudeSDKClient` with security hooks, tool permissions, and MCP server integration.
 
-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:
-
-```python
-from core.client import create_client
-from phase_config import get_phase_model, get_phase_thinking_budget
-
-# Resolve model/thinking from user settings (Electron UI or CLI override)
-phase_model = get_phase_model(spec_dir, "coding", cli_model=None)
-phase_thinking = get_phase_thinking_budget(spec_dir, "coding", cli_thinking=None)
-
-client = create_client(
-    project_dir=project_dir,
-    spec_dir=spec_dir,
-    model=phase_model,
-    agent_type="coder",          # planner | coder | qa_reviewer | qa_fixer
-    max_thinking_tokens=phase_thinking,
-)
-
-# Run agent session (uses context manager + run_agent_session helper)
-async with client:
-    status, response = await run_agent_session(client, prompt, spec_dir)
-```
-
-Working examples: `agents/planner.py`, `agents/coder.py`, `qa/reviewer.py`, `qa/fixer.py`, `spec/`
+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
 
 ### Agent Prompts (`apps/backend/prompts/`)
 
@@ -323,6 +288,8 @@ 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)
 ```

README.md

@@ -35,18 +35,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.2--beta.10-orange?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.2-beta.10)
+[![Beta](https://img.shields.io/badge/beta-2.7.6--beta.3-orange?style=flat-square)](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.6-beta.3)
 <!-- BETA_VERSION_BADGE_END -->
 
 <!-- BETA_DOWNLOADS -->
 | Platform | Download |
 |----------|----------|
-| **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) |
+| **Windows** | [Auto-Claude-2.7.6-beta.3-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-win32-x64.exe) |
+| **macOS (Apple Silicon)** | [Auto-Claude-2.7.6-beta.3-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-darwin-arm64.dmg) |
+| **macOS (Intel)** | [Auto-Claude-2.7.6-beta.3-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-darwin-x64.dmg) |
+| **Linux** | [Auto-Claude-2.7.6-beta.3-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-linux-x86_64.AppImage) |
+| **Linux (Debian)** | [Auto-Claude-2.7.6-beta.3-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-linux-amd64.deb) |
+| **Linux (Flatpak)** | [Auto-Claude-2.7.6-beta.3-linux-x86_64.flatpak](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.6-beta.3/Auto-Claude-2.7.6-beta.3-linux-x86_64.flatpak) |
 <!-- BETA_DOWNLOADS_END -->
 
 > All releases include SHA256 checksums and VirusTotal scan results for security verification.

apps/backend/.env.example

@@ -32,8 +32,8 @@
 # API_TIMEOUT_MS=600000
 
 # Model override (OPTIONAL)
-# Default: claude-opus-4-5-20251101
-# AUTO_BUILD_MODEL=claude-opus-4-5-20251101
+# Default: claude-opus-4-6
+# AUTO_BUILD_MODEL=claude-opus-4-6
 
 
 # =============================================================================

apps/backend/.gitignore

@@ -62,5 +62,15 @@ 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/
+coverage.json

apps/backend/INVESTIGATION.md

@@ -1,421 +0,0 @@
-# Token Encryption Investigation
-
-## Issue Summary
-
-Auto-Claude users are experiencing API 401 errors ("Invalid bearer token") because the Python backend is passing encrypted tokens (with `enc:` prefix) directly to the Claude Agent SDK without decryption. Standalone Claude Code terminals work correctly because they decrypt these tokens before use.
-
-**Key insight from user thehaffk:** "python cant unencrypt claude token and it launches session with CLAUDE_CODE_OAUTH_TOKEN=enc:djEwtxMGISt3tQ..."
-
-## Token Storage Format
-
-### Encrypted Token Format
-
-Claude Code CLI stores OAuth tokens in an encrypted format with the prefix `enc:`:
-
-```text
-enc:djEwtxMGISt3tQ...
-```
-
-This format is used when tokens are stored in:
-- **macOS**: Keychain (service: "Claude Code-credentials")
-- **Linux**: Secret Service API (DBus, via secretstorage library)
-- **Windows**: Credential Manager / .credentials.json files
-
-### Decrypted Token Format
-
-Valid Claude OAuth tokens have the format:
-```text
-sk-ant-oat01-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-```
-
-## Current Token Flow (BROKEN)
-
-1. **Token Storage**: Claude Code CLI stores encrypted token with `enc:` prefix in system keychain
-2. **Token Retrieval**: `apps/backend/core/auth.py::get_auth_token()` retrieves token from:
-   - Environment variable `CLAUDE_CODE_OAUTH_TOKEN`
-   - OR system keychain via `get_token_from_keychain()`
-3. **❌ NO DECRYPTION**: Token is returned as-is with `enc:` prefix intact
-4. **SDK Initialization**: Encrypted token passed to Claude Agent SDK
-5. **API Call Fails**: SDK sends encrypted token to API → 401 error
-
-### Proof of Broken Flow
-
-Test in `apps/backend`:
-```python
-import os
-os.environ['CLAUDE_CODE_OAUTH_TOKEN'] = 'enc:test123'
-
-from core.auth import get_auth_token
-token = get_auth_token()
-print(f"Token: {token}")  # Output: "enc:test123"
-print(f"Encrypted: {token.startswith('enc:')}")  # Output: True
-```
-
-## How Standalone Claude Code CLI Handles Tokens
-
-### Current Understanding
-
-1. **Token Detection**: CLI checks if token starts with `enc:` prefix
-2. **Decryption**: If encrypted, CLI decrypts using platform-specific keyring access
-3. **Authentication**: Decrypted `sk-ant-oat01-` token is used for API calls
-
-### Missing Documentation
-
-Web search for "Claude Code CLI encrypted token enc: prefix decryption" found:
-- Token storage formats (JSON with accessToken, refreshToken, expiresAt)
-- Security issues (tokens exposed in debug logs before v2.1.0)
-- Keychain access patterns for macOS/Linux/Windows
-
-**❌ NOT FOUND**: Specific documentation on how Claude Code CLI decrypts `enc:` tokens
-
-Sources:
-- [Claude Code CLI over SSH on macOS: Fixing Keychain Access](https://phoenixtrap.com/2025/10/26/claude-code-cli-over-ssh-on-macos-fixing-keychain-access/)
-- [Identity and Access Management - Claude Code Docs](https://code.claude.com/docs/en/iam)
-- [Claude Code sessions should be encrypted | yoav.blog](https://yoav.blog/2026/01/09/claude-code-sessions-should-be-encrypted/)
-
-## Decryption Approach Options
-
-### Option 1: Claude Agent SDK Built-in Decryption
-
-**Status**: NEEDS VERIFICATION
-
-The Claude Agent SDK (`claude-agent-sdk>=0.1.19`) may handle decryption internally if:
-- Token is passed to SDK still encrypted
-- SDK detects `enc:` prefix
-- SDK has access to system keyring for decryption
-
-**Action Required**: Check if SDK has decryption capabilities by examining:
-- SDK source code or documentation
-- Whether SDK expects encrypted vs decrypted tokens
-- If SDK requires specific environment variables for decryption
-
-### Option 2: Python Backend Decryption (Recommended)
-
-**Approach**: Implement decryption in `apps/backend/core/auth.py` before passing to SDK
-
-**Implementation Pattern**:
-```python
-def get_auth_token() -> str | None:
-    """Get authentication token (decrypted if necessary)."""
-    token = _retrieve_token_from_sources()  # From env or keychain
-
-    if token and token.startswith("enc:"):
-        # Decrypt the token
-        token = decrypt_token(token)
-
-    return token
-
-def decrypt_token(encrypted_token: str) -> str:
-    """
-    Decrypt Claude Code encrypted token.
-
-    Args:
-        encrypted_token: Token with 'enc:' prefix
-
-    Returns:
-        Decrypted token in format 'sk-ant-oat01-...'
-    """
-    # Remove 'enc:' prefix
-    encrypted_data = encrypted_token[4:]
-
-    # TODO: Implement decryption logic
-    # Questions to answer:
-    # 1. What encryption algorithm does Claude Code use?
-    # 2. Where is the decryption key stored?
-    # 3. Is the decryption key platform-specific (per-user)?
-    # 4. Can we reuse Claude Code's decryption mechanism?
-
-    raise NotImplementedError("Token decryption not yet implemented")
-```
-
-### Option 3: Call Claude Code CLI for Decryption
-
-**Approach**: Use the Claude Code CLI binary to decrypt tokens
-
-```python
-def decrypt_token(encrypted_token: str) -> str:
-    """Decrypt token by invoking Claude Code CLI."""
-    # Find claude binary
-    claude_path = shutil.which("claude") or "~/.local/bin/claude"
-
-    # Use CLI command to get decrypted token
-    # (if such a command exists - needs research)
-    result = subprocess.run(
-        [claude_path, "auth", "decrypt", encrypted_token],
-        capture_output=True,
-        text=True
-    )
-
-    return result.stdout.strip()
-```
-
-**Issues**:
-- Requires Claude Code CLI to be installed
-- No documented CLI command for token decryption
-- Adds external dependency
-
-## Required Investigation Steps
-
-### 1. Verify SDK Decryption Capabilities
-
-**Task**: Check if `claude-agent-sdk` handles `enc:` tokens automatically
-
-**Method**:
-```bash
-# In environment with SDK installed
-python3 << 'EOF'
-import os
-os.environ['CLAUDE_CODE_OAUTH_TOKEN'] = 'enc:...'  # Real encrypted token
-
-from claude_agent_sdk import Client
-# Try creating client - does it decrypt internally?
-client = Client()
-# Check if authentication works
-EOF
-```
-
-### 2. Reverse Engineer Claude Code CLI Decryption
-
-**Task**: Understand how Claude CLI decrypts tokens
-
-**Method**:
-- Examine Claude CLI binary (if possible)
-- Trace system calls when CLI runs (strace on Linux, dtruss on macOS)
-- Check if CLI accesses specific keychain entries for decryption keys
-- Look for encryption/decryption libraries used by CLI
-
-### 3. Find Decryption Key Storage
-
-**Task**: Locate where decryption keys are stored
-
-**Hypothesis**: Decryption key stored in:
-- macOS: Keychain (separate entry from encrypted token)
-- Linux: Secret Service API
-- Windows: Credential Manager
-
-**Verification**:
-```bash
-# macOS: List all keychain entries
-security find-generic-password -a "$(whoami)" | grep -i claude
-
-# Linux: Use secretstorage to list all items
-python3 -c "import secretstorage; ..."
-```
-
-## Recommended Decryption Approach for Python Backend
-
-Based on investigation so far, the recommended approach is:
-
-1. **Detect encrypted tokens**: Check for `enc:` prefix in `get_auth_token()`
-2. **Decrypt before use**: Implement `decrypt_token()` function
-3. **Platform-specific decryption**: Use appropriate keyring library:
-   - macOS: Use `subprocess` with `/usr/bin/security` to access decryption key
-   - Linux: Use `secretstorage` library to access Secret Service API
-   - Windows: Access Credential Manager or credentials.json
-4. **Backward compatibility**: Support both encrypted and plaintext tokens
-5. **Error handling**: Provide clear error messages if decryption fails
-
-## Complete Token Flow Trace (Frontend → Backend)
-
-### 1. Token Retrieval (Frontend)
-
-**File**: `apps/frontend/src/main/services/profile-service.ts`
-
-The frontend retrieves the OAuth token from the system keychain but **does not decrypt it**. When no API profile is active (OAuth mode), the frontend returns an empty environment object, which means it relies on:
-- The token already being in the environment as `CLAUDE_CODE_OAUTH_TOKEN`
-- OR the Python backend retrieving it from the keychain
-
-**Key Code**:
-```typescript
-// Line 223: Returns empty object in OAuth mode, allowing
-// CLAUDE_CODE_OAUTH_TOKEN to be used from system keychain
-```
-
-### 2. Environment Variable Passing (Frontend → PTY)
-
-**File**: `apps/frontend/src/main/terminal/pty-manager.ts`
-
-The PTY manager spawns the terminal shell with environment variables, including `CLAUDE_CODE_OAUTH_TOKEN`:
-
-**Key Code** (Lines 149-152):
-```typescript
-// Remove ANTHROPIC_API_KEY to ensure Claude Code uses OAuth tokens
-// (CLAUDE_CODE_OAUTH_TOKEN from profileEnv) instead of API keys
-const { DEBUG: _DEBUG, ANTHROPIC_API_KEY: _ANTHROPIC_API_KEY, ...cleanEnv } = process.env;
-```
-
-**Important**: The frontend passes through whatever token value exists in the environment - it does NOT check for `enc:` prefix or decrypt it.
-
-### 3. Token Retrieval (Backend)
-
-**File**: `apps/backend/core/auth.py`
-
-#### 3.1. get_auth_token()
-
-This function retrieves the token from multiple sources:
-
-```python
-def get_auth_token() -> str | None:
-    # First check environment variables
-    for var in AUTH_TOKEN_ENV_VARS:  # CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_AUTH_TOKEN
-        token = os.environ.get(var)
-        if token:
-            return token  # ❌ Returns immediately without checking for enc: prefix
-
-    # Fallback to system credential store
-    return get_token_from_keychain()  # ❌ Also returns without decryption
-```
-
-**Issue**: Returns token as-is with `enc:` prefix intact.
-
-#### 3.2. require_auth_token()
-
-This function calls `get_auth_token()` and raises an error if no token is found:
-
-```python
-def require_auth_token() -> str:
-    token = get_auth_token()  # ❌ Gets encrypted token
-    if not token:
-        raise ValueError("No OAuth token found...")
-    return token  # ❌ Returns encrypted token
-```
-
-**Issue**: No decryption step between retrieval and return.
-
-#### 3.3. ensure_claude_code_oauth_token()
-
-This function ensures the environment variable is set:
-
-```python
-def ensure_claude_code_oauth_token() -> None:
-    if os.environ.get("CLAUDE_CODE_OAUTH_TOKEN"):
-        return
-
-    token = get_auth_token()  # ❌ Gets encrypted token
-    if token:
-        os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = token  # ❌ Sets encrypted token
-```
-
-**Issue**: Propagates encrypted token to environment variable.
-
-### 4. Token Usage in SDK Client Creation (Backend)
-
-#### 4.1. Full Client Creation
-
-**File**: `apps/backend/core/client.py` (see `create_client()` function)
-
-```python
-def create_client(...):
-    oauth_token = require_auth_token()  # ❌ Gets encrypted token
-    # Ensure SDK can access it via its expected env var
-    os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token  # ❌ Sets encrypted token
-```
-
-**Issue**: Encrypted token is passed to the Claude Agent SDK, which expects a decrypted `sk-ant-oat01-` token.
-
-#### 4.2. Simple Client Creation
-
-**File**: `apps/backend/core/simple_client.py` (see `create_simple_client()` function)
-
-```python
-def create_simple_client(...):
-    # Get authentication
-    oauth_token = require_auth_token()  # ❌ Gets encrypted token
-    import os
-    os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token  # ❌ Sets encrypted token
-```
-
-**Issue**: Same problem - encrypted token passed to SDK.
-
-#### 4.3. Other Usages
-
-**Files**:
-- `apps/backend/core/workspace.py` (Line 1966) - AI merge operations
-- `apps/backend/runners/insights_runner.py` - Insights analysis
-- `apps/backend/runners/github/batch_issues.py` - GitHub batch operations
-- `apps/backend/integrations/linear/updater.py` - Linear integration
-- `apps/backend/commit_message.py` - Commit message generation
-- `apps/backend/analysis/insight_extractor.py` - Code insights
-- `apps/backend/merge/ai_resolver/claude_client.py` - Merge resolution
-
-**All follow the same pattern**: Call `ensure_claude_code_oauth_token()` → encrypted token in environment → SDK receives encrypted token → API 401 error.
-
-### 5. Where Decryption Should Be Inserted
-
-Based on the flow analysis, decryption should be added at **the earliest point of token retrieval** to avoid duplicating decryption logic:
-
-**RECOMMENDED INSERTION POINT**: `apps/backend/core/auth.py::get_auth_token()`
-
-```python
-def get_auth_token() -> str | None:
-    # First check environment variables
-    for var in AUTH_TOKEN_ENV_VARS:
-        token = os.environ.get(var)
-        if token:
-            # ✅ INSERT DECRYPTION HERE
-            if token.startswith("enc:"):
-                token = decrypt_token(token)
-            return token
-
-    # Fallback to system credential store
-    token = get_token_from_keychain()
-    # ✅ ALSO DECRYPT KEYCHAIN TOKENS
-    if token and token.startswith("enc:"):
-        token = decrypt_token(token)
-    return token
-```
-
-**Benefits of this approach**:
-1. Single location for decryption logic
-2. All downstream functions automatically get decrypted tokens
-3. Backward compatible (plaintext tokens pass through unchanged)
-4. Consistent behavior across all token sources (env vars and keychain)
-
-**Alternative insertion points** (NOT recommended):
-- `require_auth_token()` - Would need similar logic in `get_auth_token()` for non-required usage
-- `create_client()` - Would need duplication in `create_simple_client()` and all other clients
-- `ensure_claude_code_oauth_token()` - Would miss direct `get_auth_token()` calls
-
-## Next Steps
-
-1. ✅ Document current token flow and identify issue (THIS FILE - COMPLETED)
-2. ✅ Trace token flow from frontend to backend (THIS FILE - COMPLETED)
-3. ✅ Identify where decryption should be inserted (THIS FILE - COMPLETED)
-4. ⏳ Verify if Claude Agent SDK handles decryption internally
-5. ⏳ Reverse engineer or document Claude Code CLI decryption mechanism
-6. ⏳ Implement `decrypt_token()` function in `apps/backend/core/auth.py`
-7. ⏳ Add encryption detection and auto-decryption to `get_auth_token()`
-8. ⏳ Test with real encrypted tokens on macOS and Linux
-9. ⏳ Add comprehensive error handling for decryption failures
-
-## Open Questions
-
-1. **What encryption algorithm does Claude Code use for `enc:` tokens?**
-   - Possible: AES-256, ChaCha20, or similar
-   - Key derivation method?
-
-2. **Where is the decryption key stored?**
-   - Same keychain entry as encrypted token?
-   - Separate keychain entry?
-   - Derived from system/user credentials?
-
-3. **Does Claude Agent SDK expect encrypted or decrypted tokens?**
-   - If it expects decrypted: we must decrypt before passing
-   - If it handles encryption: we may be missing SDK configuration
-
-4. **Is there a Claude Code CLI command to decrypt tokens?**
-   - `claude auth decrypt <token>`?
-   - `claude auth get-token`?
-   - No documented command found in research
-
-5. **Can we reuse Claude Code's decryption mechanism?**
-   - Import decryption functions from CLI?
-   - Call CLI as subprocess?
-   - Implement decryption ourselves?
-
-## References
-
-- Issue: [GitHub #1223: API Error 401](https://github.com/AndyMik90/Auto-Claude/issues/1223)
-- Current auth implementation: `apps/backend/core/auth.py`
-- SDK client initialization: `apps/backend/core/client.py`
-- Requirements: `apps/backend/requirements.txt` (includes `secretstorage>=3.3.3` for Linux)

apps/backend/__init__.py

@@ -19,5 +19,5 @@ Quick Start:
 See README.md for full documentation.
 """
 
-__version__ = "2.7.5"
+__version__ = "2.7.6-beta.3"
 __author__ = "Auto Claude Team"

apps/backend/agents/base.py

@@ -6,6 +6,7 @@ Shared imports, types, and constants used across agent modules.
 """
 
 import logging
+import re
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -13,3 +14,86 @@ 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

apps/backend/agents/planner.py

@@ -1,183 +1,198 @@
-"""
-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
+"""
+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

apps/backend/agents/pr_template_filler.py

@@ -0,0 +1,347 @@
+"""
+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

apps/backend/agents/test_refactoring.py

@@ -1,159 +0,0 @@
-#!/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)

apps/backend/agents/tools_pkg/models.py

@@ -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__get-library-docs",
+    "mcp__context7__query-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": "ultrathink",
+        "thinking_default": "high",
     },
     "spec_discovery": {
         "tools": BASE_READ_TOOLS + WEB_TOOLS,
@@ -210,7 +210,7 @@ AGENT_CONFIGS = {
             TOOL_RECORD_GOTCHA,
             TOOL_GET_SESSION_CONTEXT,
         ],
-        "thinking_default": "none",  # Coding doesn't use extended thinking
+        "thinking_default": "low",  # Coding uses minimal thinking (effort: low for Opus, 1024 tokens for Sonnet/Haiku)
     },
     # ═══════════════════════════════════════════════════════════════════════
     # QA PHASES (Read + test + browser + Graphiti memory)
@@ -247,9 +247,9 @@ AGENT_CONFIGS = {
         "tools": BASE_READ_TOOLS + WEB_TOOLS,
         "mcp_servers": [],
         "auto_claude_tools": [],
-        # Note: Default to "none" because insight_extractor uses Haiku which doesn't support thinking
-        # If using Sonnet/Opus models, override max_thinking_tokens in create_simple_client()
-        "thinking_default": "none",
+        # Note: Default to "low" for minimal thinking overhead
+        # Haiku doesn't support thinking; create_simple_client() handles this
+        "thinking_default": "low",
     },
     "merge_resolver": {
         "tools": [],  # Text-only analysis
@@ -263,6 +263,12 @@ 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"],
@@ -270,18 +276,30 @@ AGENT_CONFIGS = {
         "thinking_default": "high",
     },
     "pr_orchestrator_parallel": {
-        "tools": BASE_READ_TOOLS + WEB_TOOLS,  # Read-only for parallel PR orchestrator
+        # 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,
         "mcp_servers": ["context7"],
         "auto_claude_tools": [],
         "thinking_default": "high",
     },
     "pr_followup_parallel": {
-        "tools": BASE_READ_TOOLS
-        + WEB_TOOLS,  # Read-only for parallel followup reviewer
+        # Read-only for parallel followup reviewer
+        # NOTE: Do NOT add "Task" here - same reason as pr_orchestrator_parallel
+        "tools": BASE_READ_TOOLS + WEB_TOOLS,
         "mcp_servers": ["context7"],
         "auto_claude_tools": [],
         "thinking_default": "high",
     },
+    "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
     # ═══════════════════════════════════════════════════════════════════════
@@ -506,7 +524,7 @@ def get_default_thinking_level(agent_type: str) -> str:
         agent_type: The agent type identifier
 
     Returns:
-        Thinking level string (none, low, medium, high, ultrathink)
+        Thinking level string (low, medium, high)
     """
     config = get_agent_config(agent_type)
     return config.get("thinking_default", "medium")

apps/backend/agents/tools_pkg/tools/qa.py

@@ -56,14 +56,10 @@ def _apply_qa_update(
         "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"
+    # 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()
 

apps/backend/analysis/__init__.py

@@ -23,7 +23,8 @@ from .ci_discovery import CIDiscovery
 from .project_analyzer import ProjectAnalyzer
 from .risk_classifier import RiskClassifier
 from .security_scanner import SecurityScanner
-from .test_discovery import TestDiscovery
+
+# TestDiscovery was removed - tests are now co-located in their respective modules
 
 # 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
@@ -37,5 +38,5 @@ __all__ = [
     "RiskClassifier",
     "SecurityScanner",
     "CIDiscovery",
-    "TestDiscovery",
+    # "TestDiscovery",  # Removed - tests now co-located in their modules
 ]

apps/backend/analysis/analyzers/framework_analyzer.py

@@ -235,10 +235,15 @@ class FrameworkAnalyzer(BaseAnalyzer):
 
         # Scripts
         scripts = pkg.get("scripts", {})
+        pkg_mgr = self.analysis.get("package_manager", "npm")
         if "dev" in scripts:
-            self.analysis["dev_command"] = "npm run dev"
+            self.analysis["dev_command"] = f"{pkg_mgr} run dev"
         elif "start" in scripts:
-            self.analysis["dev_command"] = "npm run start"
+            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)
 
     def _detect_go_framework(self, content: str) -> None:
         """Detect Go framework."""

apps/backend/analysis/test_discovery.py

@@ -1,690 +0,0 @@
-#!/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, UnicodeDecodeError):
-            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(encoding="utf-8")
-
-            # 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(encoding="utf-8").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(encoding="utf-8").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()

apps/backend/cli/batch_commands.py

@@ -10,6 +10,7 @@ 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
 
 
@@ -151,13 +152,22 @@ def handle_batch_status_command(project_dir: str) -> bool:
             except json.JSONDecodeError:
                 pass
 
-        # 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():
+        # 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():
+            status = "spec_created"
         else:
             status = "pending_spec"
 
@@ -165,7 +175,10 @@ 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, "❓")
 
@@ -192,10 +205,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
+    # Find completed specs (only QA-approved, matching status display logic)
     completed = []
     for spec_dir in specs_dir.iterdir():
-        if spec_dir.is_dir() and (spec_dir / "qa_report.md").exists():
+        if spec_dir.is_dir() and is_qa_approved(spec_dir):
             completed.append(spec_dir.name)
 
     if not completed:

apps/backend/cli/build_commands.py

@@ -87,7 +87,10 @@ def handle_build_command(
         debug_success,
     )
     from phase_config import get_phase_model
-    from prompts_pkg.prompts import get_base_branch_from_metadata
+    from prompts_pkg.prompts import (
+        get_base_branch_from_metadata,
+        get_use_local_branch_from_metadata,
+    )
     from qa_loop import run_qa_validation_loop, should_run_qa
 
     from .utils import print_banner, validate_environment
@@ -203,6 +206,9 @@ 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
@@ -213,6 +219,7 @@ 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:
@@ -442,7 +449,7 @@ def _handle_build_interrupt(
         if choice == "skip":
             print()
             print_status("Resuming build...", "info")
-            status_manager.update(state=BuildState.RUNNING)
+            status_manager.update(state=BuildState.BUILDING)
             asyncio.run(
                 run_autonomous_agent(
                     project_dir=working_dir,

apps/backend/cli/workspace_commands.py

@@ -536,6 +536,175 @@ 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:
@@ -879,6 +1048,24 @@ 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
@@ -952,6 +1139,16 @@ 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

apps/backend/core/auth.py

@@ -6,6 +6,7 @@ for multiple environment variables, and SDK environment variable passthrough
 for custom API endpoints.
 """
 
+import hashlib
 import json
 import logging
 import os
@@ -14,6 +15,7 @@ import subprocess
 from typing import TYPE_CHECKING
 
 from core.platform import (
+    get_where_exe_path,
     is_linux,
     is_macos,
     is_windows,
@@ -65,6 +67,48 @@ SDK_ENV_VARS = [
 ]
 
 
+def _calculate_config_dir_hash(config_dir: str) -> str:
+    """
+    Calculate hash of config directory path for Keychain service name.
+
+    This MUST match the frontend's calculateConfigDirHash() in credential-utils.ts.
+    The frontend uses SHA256 hash of the config dir path, taking first 8 hex chars.
+
+    Args:
+        config_dir: Path to the config directory (should be absolute/expanded)
+
+    Returns:
+        8-character hex hash string (e.g., "d74c9506")
+    """
+    return hashlib.sha256(config_dir.encode()).hexdigest()[:8]
+
+
+def _get_keychain_service_name(config_dir: str | None = None) -> str:
+    """
+    Get the Keychain service name for credential storage.
+
+    This MUST match the frontend's getKeychainServiceName() in credential-utils.ts.
+    All profiles use hash-based keychain entries for isolation:
+    - Profile with configDir: "Claude Code-credentials-{hash}"
+    - No configDir (legacy/default): "Claude Code-credentials"
+
+    Args:
+        config_dir: Optional CLAUDE_CONFIG_DIR path. If provided, uses hash-based name.
+
+    Returns:
+        Keychain service name (e.g., "Claude Code-credentials-d74c9506")
+    """
+    if not config_dir:
+        return "Claude Code-credentials"
+
+    # Expand ~ to home directory (matching frontend normalization)
+    expanded_dir = os.path.expanduser(config_dir)
+
+    # Calculate hash and return hash-based service name
+    hash_suffix = _calculate_config_dir_hash(expanded_dir)
+    return f"Claude Code-credentials-{hash_suffix}"
+
+
 def is_encrypted_token(token: str | None) -> bool:
     """
     Check if a token is encrypted (has "enc:" prefix).
@@ -346,36 +390,50 @@ def _try_decrypt_token(token: str | None) -> str | None:
     return token
 
 
-def get_token_from_keychain() -> str | None:
+def get_token_from_keychain(config_dir: str | None = None) -> str | None:
     """
     Get authentication token from system credential store.
 
     Reads Claude Code credentials from:
-    - macOS: Keychain
+    - macOS: Keychain (uses hash-based service name if config_dir provided)
     - Windows: Credential Manager
     - Linux: Secret Service API (via dbus/secretstorage)
 
+    Args:
+        config_dir: Optional CLAUDE_CONFIG_DIR path for profile-specific credentials.
+                   When provided, reads from hash-based keychain entry matching
+                   the frontend's storage location.
+
     Returns:
         Token string if found, None otherwise
     """
     if is_macos():
-        return _get_token_from_macos_keychain()
+        return _get_token_from_macos_keychain(config_dir)
     elif is_windows():
-        return _get_token_from_windows_credential_files()
+        return _get_token_from_windows_credential_files(config_dir)
     else:
         # Linux: use secret-service API via DBus
-        return _get_token_from_linux_secret_service()
+        return _get_token_from_linux_secret_service(config_dir)
 
 
-def _get_token_from_macos_keychain() -> str | None:
-    """Get token from macOS Keychain."""
+def _get_token_from_macos_keychain(config_dir: str | None = None) -> str | None:
+    """Get token from macOS Keychain.
+
+    Args:
+        config_dir: Optional CLAUDE_CONFIG_DIR path. When provided, uses hash-based
+                   service name (e.g., "Claude Code-credentials-d74c9506") matching
+                   the frontend's credential storage location.
+    """
+    # Get the correct service name (hash-based if config_dir provided)
+    service_name = _get_keychain_service_name(config_dir)
+
     try:
         result = subprocess.run(
             [
                 "/usr/bin/security",
                 "find-generic-password",
                 "-s",
-                "Claude Code-credentials",
+                service_name,
                 "-w",
             ],
             capture_output=True,
@@ -384,6 +442,14 @@ def _get_token_from_macos_keychain() -> str | None:
         )
 
         if result.returncode != 0:
+            # If hash-based lookup fails and we have a config_dir, DON'T fall back
+            # to default service name - that would return the wrong profile's token.
+            # The config_dir was provided explicitly, so we should only use that.
+            if config_dir:
+                logger.debug(
+                    f"No keychain entry found for service '{service_name}' "
+                    f"(config_dir: {config_dir})"
+                )
             return None
 
         credentials_json = result.stdout.strip()
@@ -397,22 +463,51 @@ def _get_token_from_macos_keychain() -> str | None:
             return None
 
         # Validate token format (Claude OAuth tokens start with sk-ant-oat01-)
-        if not token.startswith("sk-ant-oat01-"):
+        # Also accept encrypted tokens (enc:) which will be decrypted later
+        if not (token.startswith("sk-ant-oat01-") or token.startswith("enc:")):
             return None
 
+        logger.debug(f"Found token in keychain service '{service_name}'")
         return token
 
     except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, Exception):
         return None
 
 
-def _get_token_from_windows_credential_files() -> str | None:
+def _get_token_from_windows_credential_files(
+    config_dir: str | None = None,
+) -> str | None:
     """Get token from Windows credential files.
 
     Claude Code on Windows stores credentials in ~/.claude/.credentials.json
+    For custom profiles, uses the config_dir's .credentials.json file.
+
+    Args:
+        config_dir: Optional CLAUDE_CONFIG_DIR path for profile-specific credentials.
     """
     try:
-        # Claude Code stores credentials in ~/.claude/.credentials.json
+        # If config_dir is provided, read from that directory first
+        if config_dir:
+            expanded_dir = os.path.expanduser(config_dir)
+            profile_cred_paths = [
+                os.path.join(expanded_dir, ".credentials.json"),
+                os.path.join(expanded_dir, "credentials.json"),
+            ]
+            for cred_path in profile_cred_paths:
+                if os.path.exists(cred_path):
+                    with open(cred_path, encoding="utf-8") as f:
+                        data = json.load(f)
+                        token = data.get("claudeAiOauth", {}).get("accessToken")
+                        if token and (
+                            token.startswith("sk-ant-oat01-")
+                            or token.startswith("enc:")
+                        ):
+                            logger.debug(f"Found token in {cred_path}")
+                            return token
+            # If config_dir provided but no token found, don't fall back to default
+            return None
+
+        # Default Claude Code credential paths (no profile specified)
         cred_paths = [
             os.path.expandvars(r"%USERPROFILE%\.claude\.credentials.json"),
             os.path.expandvars(r"%USERPROFILE%\.claude\credentials.json"),
@@ -425,7 +520,9 @@ def _get_token_from_windows_credential_files() -> str | None:
                 with open(cred_path, encoding="utf-8") as f:
                     data = json.load(f)
                     token = data.get("claudeAiOauth", {}).get("accessToken")
-                    if token and token.startswith("sk-ant-oat01-"):
+                    if token and (
+                        token.startswith("sk-ant-oat01-") or token.startswith("enc:")
+                    ):
                         return token
 
         return None
@@ -434,7 +531,7 @@ def _get_token_from_windows_credential_files() -> str | None:
         return None
 
 
-def _get_token_from_linux_secret_service() -> str | None:
+def _get_token_from_linux_secret_service(config_dir: str | None = None) -> str | None:
     """Get token from Linux Secret Service API via DBus.
 
     Claude Code on Linux stores credentials in the Secret Service API
@@ -442,9 +539,12 @@ def _get_token_from_linux_secret_service() -> str | None:
     uses the secretstorage library which communicates via DBus.
 
     The credential is stored with:
-    - Label: "Claude Code-credentials"
+    - Label: "Claude Code-credentials" or "Claude Code-credentials-{hash}" for profiles
     - Attributes: {application: "claude-code"}
 
+    Args:
+        config_dir: Optional CLAUDE_CONFIG_DIR path for profile-specific credentials.
+
     Returns:
         Token string if found, None otherwise
     """
@@ -452,6 +552,9 @@ def _get_token_from_linux_secret_service() -> str | None:
         # secretstorage not installed, fall back to env var
         return None
 
+    # Get the correct service name (hash-based if config_dir provided)
+    target_label = _get_keychain_service_name(config_dir)
+
     try:
         # Get the default collection (typically "login" keyring)
         # secretstorage handles DBus communication internally
@@ -476,10 +579,10 @@ def _get_token_from_linux_secret_service() -> str | None:
         items = collection.search_items({"application": "claude-code"})
 
         for item in items:
-            # Check if this is the Claude Code credentials item
+            # Check if this is the correct Claude Code credentials item
             label = item.get_label()
-            # Use exact match for "Claude Code-credentials" to avoid false positives
-            if label == "Claude Code-credentials":
+            # Use exact match for target label (profile-specific or default)
+            if label == target_label:
                 # Get the secret (stored as JSON string)
                 secret = item.get_secret()
                 if not secret:
@@ -492,11 +595,23 @@ def _get_token_from_linux_secret_service() -> str | None:
                     data = json.loads(secret)
                     token = data.get("claudeAiOauth", {}).get("accessToken")
 
-                    if token and token.startswith("sk-ant-oat01-"):
+                    if token and (
+                        token.startswith("sk-ant-oat01-") or token.startswith("enc:")
+                    ):
+                        logger.debug(
+                            f"Found token in secret service with label '{target_label}'"
+                        )
                         return token
                 except json.JSONDecodeError:
                     continue
 
+        # If config_dir was provided but no token found, don't fall back
+        if config_dir:
+            logger.debug(
+                f"No secret service entry found with label '{target_label}' "
+                f"(config_dir: {config_dir})"
+            )
+
         return None
 
     except (
@@ -589,13 +704,37 @@ def get_auth_token(config_dir: str | None = None) -> str | None:
     env_config_dir = os.environ.get("CLAUDE_CONFIG_DIR")
     effective_config_dir = config_dir or env_config_dir
 
-    # If a custom config directory is specified, read from there
+    # Debug: Log which config_dir is being used for credential resolution
+    debug = os.environ.get("DEBUG", "").lower() in ("true", "1")
+    if debug and effective_config_dir:
+        service_name = _get_keychain_service_name(effective_config_dir)
+        logger.info(
+            f"[Auth] Resolving credentials for profile config_dir: {effective_config_dir} "
+            f"(Keychain service: {service_name})"
+        )
+
+    # If a custom config directory is specified, read from there first
     if effective_config_dir:
+        # Try reading from .credentials.json file in the config directory
         token = _get_token_from_config_dir(effective_config_dir)
         if token:
             return _try_decrypt_token(token)
 
-    # Fallback to system credential store (default locations)
+        # Also try the system credential store with hash-based service name
+        # This is needed because macOS stores credentials in Keychain, not files
+        token = get_token_from_keychain(effective_config_dir)
+        if token:
+            return _try_decrypt_token(token)
+
+        # If config_dir was explicitly provided, DON'T fall back to default keychain
+        # - that would return the wrong profile's token
+        logger.debug(
+            f"No credentials found for config_dir '{effective_config_dir}' "
+            "in file or keychain"
+        )
+        return None
+
+    # No config_dir specified - use default system credential store
     return _try_decrypt_token(get_token_from_keychain())
 
 
@@ -616,10 +755,20 @@ def get_auth_token_source(config_dir: str | None = None) -> str | None:
     # Check if token came from custom config directory (profile's configDir)
     env_config_dir = os.environ.get("CLAUDE_CONFIG_DIR")
     effective_config_dir = config_dir or env_config_dir
-    if effective_config_dir and _get_token_from_config_dir(effective_config_dir):
-        return "CLAUDE_CONFIG_DIR"
+    if effective_config_dir:
+        # Check file-based storage
+        if _get_token_from_config_dir(effective_config_dir):
+            return "CLAUDE_CONFIG_DIR"
+        # Check hash-based keychain entry for this profile
+        if get_token_from_keychain(effective_config_dir):
+            if is_macos():
+                return "macOS Keychain (profile)"
+            elif is_windows():
+                return "Windows Credential Files (profile)"
+            else:
+                return "Linux Secret Service (profile)"
 
-    # Check if token came from system credential store
+    # Check if token came from default system credential store
     if get_token_from_keychain():
         if is_macos():
             return "macOS Keychain"
@@ -706,9 +855,9 @@ def _find_git_bash_path() -> str | None:
 
     # Method 1: Use 'where' command to find git.exe
     try:
-        # Use where.exe explicitly for reliability
+        # Use full path to where.exe for reliability (works even when System32 isn't in PATH)
         result = subprocess.run(
-            ["where.exe", "git"],
+            [get_where_exe_path(), "git"],
             capture_output=True,
             text=True,
             timeout=5,
@@ -800,6 +949,57 @@ def get_sdk_env_vars() -> dict[str, str]:
     return env
 
 
+def configure_sdk_authentication(config_dir: str | None = None) -> None:
+    """
+    Configure SDK authentication based on environment variables.
+
+    Supports two authentication modes:
+    - API Profile mode (ANTHROPIC_BASE_URL set): uses ANTHROPIC_AUTH_TOKEN
+    - OAuth mode (default): uses CLAUDE_CODE_OAUTH_TOKEN
+
+    In API profile mode, explicitly removes CLAUDE_CODE_OAUTH_TOKEN from the
+    environment because the SDK gives OAuth priority over API keys when both
+    are present.
+
+    Args:
+        config_dir: Optional profile config directory for per-profile Keychain
+                    lookup. When set, enables multi-profile token storage.
+
+    Raises:
+        ValueError: If required tokens are missing for the active mode.
+                   - API profile mode: requires ANTHROPIC_AUTH_TOKEN
+                   - OAuth mode: requires CLAUDE_CODE_OAUTH_TOKEN (from Keychain or env)
+    """
+    api_profile_mode = bool(os.environ.get("ANTHROPIC_BASE_URL", "").strip())
+
+    if api_profile_mode:
+        # API profile mode: ensure ANTHROPIC_AUTH_TOKEN is present
+        if not os.environ.get("ANTHROPIC_AUTH_TOKEN"):
+            raise ValueError(
+                "API profile mode active (ANTHROPIC_BASE_URL is set) "
+                "but ANTHROPIC_AUTH_TOKEN is not set"
+            )
+        # Explicitly remove CLAUDE_CODE_OAUTH_TOKEN so SDK uses ANTHROPIC_AUTH_TOKEN
+        # SDK gives OAuth priority over API keys when both are present
+        os.environ.pop("CLAUDE_CODE_OAUTH_TOKEN", None)
+        logger.info("Using API profile authentication")
+    else:
+        # OAuth mode: require and validate OAuth token
+        # Get OAuth token - uses profile-specific Keychain lookup when config_dir is set
+        # This correctly reads from "Claude Code-credentials-{hash}" for non-default profiles
+        oauth_token = require_auth_token(config_dir)
+
+        # Validate token is not encrypted before passing to SDK
+        # Encrypted tokens (enc:...) should have been decrypted by require_auth_token()
+        # If we still have an encrypted token here, it means decryption failed or was skipped
+        validate_token_not_encrypted(oauth_token)
+
+        # Ensure SDK can access it via its expected env var
+        # This is required because the SDK doesn't know about per-profile Keychain naming
+        os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
+        logger.info("Using OAuth authentication")
+
+
 def ensure_claude_code_oauth_token() -> None:
     """
     Ensure CLAUDE_CODE_OAUTH_TOKEN is set (for SDK compatibility).

apps/backend/core/client.py

@@ -21,6 +21,7 @@ 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,
@@ -139,9 +140,8 @@ 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,
-    require_auth_token,
-    validate_token_not_encrypted,
 )
 from linear_updater import is_linear_enabled
 from prompts_pkg.project_context import detect_project_capabilities, load_project_index
@@ -450,6 +450,9 @@ 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.
@@ -465,10 +468,9 @@ 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)
-                            - ultrathink: 16000 (spec creation)
-                            - high: 10000 (QA review)
-                            - medium: 5000 (planning, validation)
-                            - None: disabled (coding)
+                            - high: 16384 (spec creation, QA review)
+                            - medium: 4096 (planning, validation)
+                            - low: 1024 (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
@@ -476,6 +478,16 @@ 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
@@ -490,20 +502,37 @@ def create_client(
        (see security.py for ALLOWED_COMMANDS)
     4. Tool filtering - Each agent type only sees relevant tools (prevents misuse)
     """
-    # Get OAuth token - Claude CLI handles token lifecycle internally
-    oauth_token = require_auth_token()
-
-    # Validate token is not encrypted before passing to SDK
-    # Encrypted tokens (enc:...) should have been decrypted by require_auth_token()
-    # If we still have an encrypted token here, it means decryption failed or was skipped
-    validate_token_not_encrypted(oauth_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.)
+    # Collect env vars to pass to SDK (ANTHROPIC_BASE_URL, CLAUDE_CONFIG_DIR, 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']}")
@@ -667,7 +696,12 @@ def create_client(
         print("   - Worktree permissions: granted for original project directories")
     print("   - Bash commands restricted to allowlist")
     if max_thinking_tokens:
-        print(f"   - Extended thinking: {max_thinking_tokens:,} 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}")
     else:
         print("   - Extended thinking: disabled")
 
@@ -819,6 +853,12 @@ 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")
@@ -836,4 +876,8 @@ 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))

apps/backend/core/error_utils.py

@@ -0,0 +1,120 @@
+"""
+Shared Error Utilities
+======================
+
+Common error detection and classification functions used across
+agent sessions, QA, and other modules.
+"""
+
+import re
+
+
+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",
+        ]
+    )

apps/backend/core/fast_mode.py

@@ -0,0 +1,76 @@
+"""
+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)"
+        )

apps/backend/core/gh_executable.py

@@ -10,6 +10,8 @@ import os
 import shutil
 import subprocess
 
+from core.platform import get_where_exe_path
+
 _cached_gh_path: str | None = None
 
 
@@ -53,12 +55,11 @@ def _run_where_command() -> str | None:
     """
     try:
         result = subprocess.run(
-            "where gh",
+            [get_where_exe_path(), "gh"],
             capture_output=True,
             text=True,
             encoding="utf-8",
             timeout=5,
-            shell=True,  # Required: 'where' command must be executed through shell on Windows
         )
         if result.returncode == 0 and result.stdout.strip():
             found_path = result.stdout.strip().split("\n")[0].strip()
@@ -133,7 +134,7 @@ def _find_gh_executable() -> str | None:
             if os.path.isfile(path) and _verify_gh_executable(path):
                 return path
 
-        # 5. Try 'where' command with shell=True (more reliable on Windows)
+        # 5. Try 'where' command with full path (works even when System32 isn't in PATH)
         return _run_where_command()
 
     return None

apps/backend/core/git_executable.py

@@ -15,6 +15,8 @@ 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.
@@ -124,14 +126,13 @@ def _find_git_executable() -> str:
             except OSError:
                 continue
 
-        # 4. Try 'where' command with shell=True (more reliable on Windows)
+        # 4. Try 'where' command with full path (works even when System32 isn't in PATH)
         try:
             result = subprocess.run(
-                "where git",
+                [get_where_exe_path(), "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()

apps/backend/core/git_provider.py

@@ -0,0 +1,115 @@
+#!/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"

apps/backend/core/glab_executable.py

@@ -0,0 +1,193 @@
+#!/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",
+        )

apps/backend/core/phase_event.py

@@ -23,6 +23,9 @@ 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(
@@ -31,8 +34,19 @@ 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."""
+    """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
+    """
     phase_value = phase.value if isinstance(phase, ExecutionPhase) else phase
 
     payload: dict[str, Any] = {
@@ -48,6 +62,12 @@ 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:

apps/backend/core/platform/__init__.py

@@ -430,6 +430,22 @@ def requires_shell(command: str) -> bool:
     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.

apps/backend/core/simple_client.py

@@ -22,15 +22,16 @@ Example usage:
 """
 
 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,
-    require_auth_token,
-    validate_token_not_encrypted,
 )
+from core.fast_mode import ensure_fast_mode_in_user_settings
 from core.platform import validate_cli_path
 from phase_config import get_thinking_budget
 
@@ -44,6 +45,9 @@ 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.
@@ -65,6 +69,11 @@ 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
@@ -72,21 +81,27 @@ def create_simple_client(
     Raises:
         ValueError: If agent_type is not found in AGENT_CONFIGS
     """
-    # Get authentication
-    oauth_token = require_auth_token()
-
-    # Validate token is not encrypted before passing to SDK
-    # Encrypted tokens (enc:...) should have been decrypted by require_auth_token()
-    # If we still have an encrypted token here, it means decryption failed or was skipped
-    validate_token_not_encrypted(oauth_token)
-
-    import os
-
-    os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
-
-    # Get environment variables for SDK
+    # Get environment variables for SDK (including CLAUDE_CONFIG_DIR if set)
     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)
 
@@ -109,10 +124,19 @@ def create_simple_client(
         "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):

apps/backend/core/task_event.py

@@ -0,0 +1,101 @@
+"""
+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

apps/backend/core/workspace.py

@@ -121,6 +121,7 @@ from merge import (
     FileTimelineTracker,
     MergeOrchestrator,
 )
+from merge.progress import MergeProgressCallback, MergeProgressStage, emit_progress
 
 MODULE = "workspace"
 
@@ -145,6 +146,26 @@ 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,
@@ -252,10 +273,11 @@ 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:
-                    # AI resolved conflicts, assisted with merges, or direct copy was used
-                    # Changes are already written and staged - no need for git merge
+                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
                     _print_merge_success(
                         no_commit, stats, spec_name=spec_name, keep_worktree=True
                     )
@@ -402,9 +424,20 @@ 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)
@@ -440,6 +473,13 @@ 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)
 
@@ -492,12 +532,11 @@ 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 - continue with conflict resolution as before
-                # The AI resolver will handle the conflicts
-                print(
-                    warning(
-                        "  Rebase encountered issues, using AI conflict resolution..."
-                    )
+                # 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",
                 )
 
         if git_conflicts.get("has_conflicts"):
@@ -518,6 +557,18 @@ 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,
@@ -535,6 +586,22 @@ 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
@@ -547,6 +614,26 @@ 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", []),
@@ -555,148 +642,81 @@ def _try_smart_merge_inner(
                     "error": resolution_result.get("error"),
                 }
 
-        # Check if branches diverged but no actual conflicts (can do direct copy)
+        # Check if branches diverged but no actual conflicts (use git merge)
         if git_conflicts.get("diverged_but_no_conflicts"):
-            debug(MODULE, "Branches diverged but no conflicts - doing direct file copy")
+            debug(MODULE, "Branches diverged but no conflicts - using git merge")
             print(muted("  Branches diverged but no conflicts detected"))
-            print(muted("  Copying changed files directly from worktree..."))
+            print(muted("  Using git merge to combine changes..."))
 
-            # Get changed files from spec branch
             spec_branch = f"auto-claude/{spec_name}"
-            base_branch = git_conflicts.get("base_branch", "main")
 
-            # Get merge-base for diff
-            merge_base_result = run_git(
-                ["merge-base", base_branch, spec_branch],
+            # 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],
                 cwd=project_dir,
             )
-            merge_base = (
-                merge_base_result.stdout.strip()
-                if merge_base_result.returncode == 0
-                else None
-            )
 
-            if merge_base:
-                # Get list of changed files in spec branch
-                changed_files = _get_changed_files_from_branch(
-                    project_dir, merge_base, spec_branch
+            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),
                 )
 
-                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
+                for file_path in merged_files:
+                    print(success(f"    ✓ {file_path}"))
 
-                    try:
-                        target_path = project_dir / file_path
-
-                        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:
-                    add_result = run_git(
-                        ["add"] + files_to_stage,
-                        cwd=project_dir,
+                if progress_callback is not None:
+                    progress_callback(
+                        MergeProgressStage.COMPLETE,
+                        100,
+                        f"Git merge complete ({len(merged_files)} files)",
                     )
-                    if add_result.returncode != 0:
-                        debug_warning(
-                            MODULE,
-                            f"Failed to stage files for direct copy: {add_result.stderr}",
-                        )
-                        # Return failure - files were written but not staged
-                        return {
-                            "success": False,
-                            "error": f"Failed to stage files: {add_result.stderr}",
-                            "resolved_files": [],
-                        }
 
-                # Build result - check for skipped files to detect partial merges
-                result = {
-                    "success": len(skipped_files) == 0,
-                    "resolved_files": resolved_files,
+                return {
+                    "success": True,
+                    "resolved_files": merged_files,
                     "stats": {
-                        "files_merged": len(resolved_files),
+                        "files_merged": len(merged_files),
                         "conflicts_resolved": 0,
                         "ai_assisted": 0,
-                        "auto_merged": len(resolved_files),
-                        "direct_copy": True,  # Flag indicating direct copy was used
-                        "skipped_count": len(skipped_files),
+                        "auto_merged": len(merged_files),
+                        "git_merge": True,  # Flag indicating git merge was used
                     },
                 }
-                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-base failed - branches may not share history
+                # Merge failed unexpectedly - abort and fall back to semantic analysis
                 debug_warning(
                     MODULE,
-                    "Could not find merge-base between branches - falling back to semantic analysis",
+                    "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..."
+                    )
                 )
 
         # No git conflicts - proceed with semantic analysis
@@ -725,6 +745,14 @@ 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": {
@@ -737,6 +765,13 @@ 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
@@ -748,14 +783,11 @@ def _rebase_spec_branch(
     base_branch: str,
 ) -> bool:
     """
-    Rebase the spec branch onto the latest base branch.
+    Attempt to rebase the spec branch onto the latest base branch.
 
-    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.
+    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.
 
     Args:
         project_dir: The project directory
@@ -764,22 +796,36 @@ def _rebase_spec_branch(
 
     Returns:
         True if rebase succeeded cleanly or branch was already up-to-date,
-        False if rebase failed due to conflicts or other errors (aborted, no ref movement)
+        False if rebase failed (worktree lock, conflicts, or other errors)
     """
     spec_branch = f"auto-claude/{spec_name}"
 
     debug(
         MODULE,
-        "Rebasing spec branch",
+        "Attempting to rebase spec branch",
         spec_branch=spec_branch,
         base_branch=base_branch,
     )
 
-    # Save original branch to restore after rebase (HIGH: prevents leaving repo on spec 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
     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,
@@ -795,7 +841,6 @@ 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:
@@ -804,8 +849,6 @@ 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()
 
@@ -813,22 +856,18 @@ def _rebase_spec_branch(
     print(muted(f"  Rebasing {spec_branch} onto {base_branch}..."))
 
     try:
-        # 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
+        # Try to checkout the spec branch
         checkout_result = run_git(["checkout", spec_branch], cwd=project_dir)
         if checkout_result.returncode != 0:
-            debug_error(
+            # Checkout failed - likely due to worktree lock
+            debug(
                 MODULE,
-                "Could not checkout spec branch for rebase",
-                stderr=checkout_result.stderr,
+                "Could not checkout spec branch for rebase (likely worktree lock)",
+                stderr=checkout_result.stderr[:200] if checkout_result.stderr else "",
             )
             return False
 
-        # 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
+        # Run standard rebase
         rebase_result = run_git(
             ["rebase", base_branch],
             cwd=project_dir,
@@ -838,9 +877,6 @@ 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()
@@ -848,7 +884,6 @@ 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(
@@ -856,19 +891,16 @@ def _rebase_spec_branch(
                     "Failed to abort rebase - repo may be in inconsistent state",
                     stderr=abort_result.stderr,
                 )
-                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 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)
+            if has_unmerged:
+                debug_warning(
+                    MODULE,
+                    "Rebase encountered conflicts - aborted, will use alternative merge",
+                    stderr=rebase_result.stderr[:200] if rebase_result.stderr else "",
+                )
+                return False
+
             debug_error(
                 MODULE,
                 "Rebase failed with unexpected error",
@@ -882,9 +914,7 @@ 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",
@@ -904,8 +934,7 @@ def _rebase_spec_branch(
         debug_error(MODULE, "Could not verify spec branch commit after rebase")
         return False
     finally:
-        # HIGH: Always restore original branch, even on error/exception
-        # NEW-001: Log restoration failure (cannot modify return from finally block)
+        # Always restore original branch
         if original_branch:
             restore_result = run_git(["checkout", original_branch], cwd=project_dir)
             if restore_result.returncode != 0:
@@ -914,8 +943,6 @@ 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:

apps/backend/core/workspace/__init__.py

@@ -17,7 +17,6 @@ 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)
@@ -28,10 +27,17 @@ _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
@@ -74,7 +80,9 @@ 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,
@@ -91,6 +99,8 @@ from .models import (
     MergeLockError,
     ParallelMergeResult,
     ParallelMergeTask,
+    SpecNumberLock,
+    SpecNumberLockError,
     WorkspaceChoice,
     WorkspaceMode,
 )
@@ -110,11 +120,9 @@ from .setup import (
 __all__ = [
     # Merge Operations (from workspace.py)
     "merge_existing_build",
-    "_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)
+    # 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
     # Models
     "WorkspaceMode",
     "WorkspaceChoice",
@@ -122,6 +130,8 @@ __all__ = [
     "ParallelMergeResult",
     "MergeLock",
     "MergeLockError",
+    "SpecNumberLock",
+    "SpecNumberLockError",
     # Git Utils
     "has_uncommitted_changes",
     "get_current_branch",
@@ -131,8 +141,11 @@ __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",

apps/backend/core/workspace/setup.py

@@ -325,6 +325,7 @@ 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,6 +338,7 @@ 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)
@@ -357,7 +359,9 @@ 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)
+    manager = WorktreeManager(
+        project_dir, base_branch=base_branch, use_local_branch=use_local_branch
+    )
     manager.setup()
 
     # Get or create worktree for THIS SPECIFIC SPEC

apps/backend/core/workspace/tests/conftest.py

@@ -0,0 +1,250 @@
+#!/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

apps/backend/core/workspace/tests/pytest.ini

@@ -0,0 +1,10 @@
+[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"')

apps/backend/core/workspace/tests/test_display.py

@@ -0,0 +1,856 @@
+#!/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

apps/backend/core/workspace/tests/test_finalization.py

@@ -0,0 +1,805 @@
+#!/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"

apps/backend/core/workspace/tests/test_models.py

@@ -0,0 +1,638 @@
+#!/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"
+        )

apps/backend/core/workspace/tests/test_rebase.py

@@ -1,539 +1,31 @@
 #!/usr/bin/env python3
 """
-Tests for Workspace Selection and Management
-=============================================
+Tests for Workspace Rebase Operations
+======================================
 
-Tests the workspace.py module functionality including:
-- Workspace mode selection (isolated vs direct)
-- Uncommitted changes detection
-- Workspace setup
-- Build finalization workflows
+Tests the rebase functionality including:
+- Rebase detection (_check_git_conflicts)
+- Spec branch rebase operations
+- Rebase integration tests
+- Rebase error handling
 """
 
+import json
+import os
+import shutil
 import subprocess
+import sys
 from pathlib import Path
 
 import pytest
-from workspace import (
-    WorkspaceChoice,
-    WorkspaceMode,
-    get_current_branch,
-    get_existing_build_worktree,
-    has_uncommitted_changes,
-    setup_workspace,
-)
-from worktree import WorktreeManager
+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."""
-        assert WorkspaceMode.ISOLATED.value == "isolated"
-
-    def test_direct_mode(self):
-        """DIRECT mode value is correct."""
-        assert WorkspaceMode.DIRECT.value == "direct"
-
-
-class TestWorkspaceChoice:
-    """Tests for WorkspaceChoice enum."""
-
-    def test_merge_choice(self):
-        """MERGE choice value is correct."""
-        assert WorkspaceChoice.MERGE.value == "merge"
-
-    def test_review_choice(self):
-        """REVIEW choice value is correct."""
-        assert WorkspaceChoice.REVIEW.value == "review"
-
-    def test_test_choice(self):
-        """TEST choice value is correct."""
-        assert WorkspaceChoice.TEST.value == "test"
-
-    def test_later_choice(self):
-        """LATER choice value is correct."""
-        assert WorkspaceChoice.LATER.value == "later"
-
-
-class TestHasUncommittedChanges:
-    """Tests for uncommitted changes detection."""
-
-    def test_clean_repo_no_changes(self, temp_git_repo: Path):
-        """Clean repo returns False."""
-        result = has_uncommitted_changes(temp_git_repo)
-        assert result is False
-
-    def test_untracked_file_has_changes(self, temp_git_repo: Path):
-        """Untracked file counts as changes."""
-        (temp_git_repo / "new_file.txt").write_text("content")
-
-        result = has_uncommitted_changes(temp_git_repo)
-        assert result is True
-
-    def test_modified_file_has_changes(self, temp_git_repo: Path):
-        """Modified tracked file counts as changes."""
-        (temp_git_repo / "README.md").write_text("modified content")
-
-        result = has_uncommitted_changes(temp_git_repo)
-        assert result is True
-
-    def test_staged_file_has_changes(self, temp_git_repo: Path):
-        """Staged file counts as changes."""
-        (temp_git_repo / "README.md").write_text("modified")
-        subprocess.run(["git", "add", "README.md"], cwd=temp_git_repo, capture_output=True)
-
-        result = has_uncommitted_changes(temp_git_repo)
-        assert result is True
-
-
-class TestGetCurrentBranch:
-    """Tests for current branch detection."""
-
-    def test_gets_main_branch(self, temp_git_repo: Path):
-        """Gets the main/master branch."""
-        branch = get_current_branch(temp_git_repo)
-
-        # Could be main or master depending on git config
-        assert branch in ["main", "master"]
-
-    def test_gets_feature_branch(self, temp_git_repo: Path):
-        """Gets feature branch name."""
-        subprocess.run(
-            ["git", "checkout", "-b", "feature/test-branch"],
-            cwd=temp_git_repo, capture_output=True
-        )
-
-        branch = get_current_branch(temp_git_repo)
-        assert branch == "feature/test-branch"
-
-
-class TestGetExistingBuildWorktree:
-    """Tests for existing build worktree detection."""
-
-    def test_no_existing_worktree(self, temp_git_repo: Path):
-        """Returns None when no worktree exists."""
-        result = get_existing_build_worktree(temp_git_repo, "test-spec")
-        assert result is None
-
-    def test_existing_worktree(self, temp_git_repo: Path):
-        """Returns path when worktree exists."""
-        # Create the worktree directory structure (per-spec architecture)
-        worktree_path = temp_git_repo / ".worktrees" / TEST_SPEC_NAME
-        worktree_path.mkdir(parents=True)
-
-        result = get_existing_build_worktree(temp_git_repo, TEST_SPEC_NAME)
-        assert result == worktree_path
-
-
-class TestSetupWorkspace:
-    """Tests for workspace setup."""
-
-    def test_setup_direct_mode(self, temp_git_repo: Path):
-        """Direct mode returns project dir and no manager."""
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.DIRECT,
-        )
-
-        assert working_dir == temp_git_repo
-        assert manager is None
-
-    def test_setup_isolated_mode(self, temp_git_repo: Path):
-        """Isolated mode creates worktree and returns manager."""
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            TEST_SPEC_NAME,
-            WorkspaceMode.ISOLATED,
-        )
-
-        assert working_dir != temp_git_repo
-        assert manager is not None
-        assert working_dir.exists()
-        # Per-spec architecture: worktree is named after the spec
-        assert working_dir.name == TEST_SPEC_NAME
-
-    def test_setup_isolated_creates_worktrees_dir(self, temp_git_repo: Path):
-        """Isolated mode creates worktrees directory."""
-        setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        assert (temp_git_repo / ".auto-claude" / "worktrees" / "tasks").exists()
-
-
-class TestWorkspaceUtilities:
-    """Tests for workspace utility functions."""
-
-    def test_per_spec_worktree_naming(self, temp_git_repo: Path):
-        """Per-spec architecture uses spec name for worktree directory."""
-        spec_name = "my-spec-001"
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            spec_name,
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Worktree should be named after the spec
-        assert working_dir.name == spec_name
-        # New path: .auto-claude/worktrees/tasks/{spec_name}
-        assert working_dir.parent.name == "tasks"
-
-
-class TestWorkspaceIntegration:
-    """Integration tests for workspace management."""
-
-    def test_isolated_workflow(self, temp_git_repo: Path):
-        """Full isolated workflow: setup -> work -> finalize."""
-        # Setup isolated workspace
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Make changes in workspace
-        (working_dir / "feature.py").write_text("# New feature\n")
-
-        # Verify changes are in workspace
-        assert (working_dir / "feature.py").exists()
-
-        # Verify changes are NOT in main project
-        assert not (temp_git_repo / "feature.py").exists()
-
-    def test_direct_workflow(self, temp_git_repo: Path):
-        """Full direct workflow: setup -> work."""
-        # Setup direct workspace
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.DIRECT,
-        )
-
-        # Working dir is the project dir
-        assert working_dir == temp_git_repo
-
-        # Make changes directly
-        (working_dir / "feature.py").write_text("# New feature\n")
-
-        # Changes are in main project
-        assert (temp_git_repo / "feature.py").exists()
-
-    def test_isolated_merge(self, temp_git_repo: Path):
-        """Can merge isolated workspace back to main."""
-        # Setup
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Make changes and commit using git directly
-        (working_dir / "feature.py").write_text("# New feature\n")
-        subprocess.run(["git", "add", "."], cwd=working_dir, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Add feature"],
-            cwd=working_dir, capture_output=True
-        )
-
-        # Merge back using merge_worktree
-        result = manager.merge_worktree("test-spec", delete_after=False)
-
-        assert result is True
-
-        # Check changes are in main
-        subprocess.run(
-            ["git", "checkout", manager.base_branch],
-            cwd=temp_git_repo, capture_output=True
-        )
-        assert (temp_git_repo / "feature.py").exists()
-
-
-class TestWorkspaceCleanup:
-    """Tests for workspace cleanup."""
-
-    def test_cleanup_after_merge(self, temp_git_repo: Path):
-        """Workspace is cleaned up after merge with delete_after=True."""
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Commit changes using git directly
-        (working_dir / "test.py").write_text("test")
-        subprocess.run(["git", "add", "."], cwd=working_dir, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Test"],
-            cwd=working_dir, capture_output=True
-        )
-
-        # Merge with cleanup
-        manager.merge_worktree("test-spec", delete_after=True)
-
-        # Workspace should be removed
-        assert not working_dir.exists()
-
-    def test_workspace_preserved_after_merge_no_delete(self, temp_git_repo: Path):
-        """Workspace preserved after merge with delete_after=False."""
-        working_dir, manager, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Commit changes using git directly
-        (working_dir / "test.py").write_text("test")
-        subprocess.run(["git", "add", "."], cwd=working_dir, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Test"],
-            cwd=working_dir, capture_output=True
-        )
-
-        # Merge without cleanup
-        manager.merge_worktree("test-spec", delete_after=False)
-
-        # Workspace should still exist
-        assert working_dir.exists()
-
-
-class TestWorkspaceReuse:
-    """Tests for reusing existing workspaces."""
-
-    def test_reuse_existing_workspace(self, temp_git_repo: Path):
-        """Can reuse existing workspace on second setup."""
-        # First setup
-        working_dir1, manager1, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Add a marker file
-        (working_dir1 / "marker.txt").write_text("marker")
-
-        # Second setup (should reuse)
-        working_dir2, manager2, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Should be the same directory
-        assert working_dir1 == working_dir2
-
-        # Marker should still exist
-        assert (working_dir2 / "marker.txt").exists()
-
-
-class TestWorkspaceErrors:
-    """Tests for workspace error handling."""
-
-    def test_setup_non_git_directory(self, temp_dir: Path):
-        """Handles non-git directories gracefully."""
-        with pytest.raises(Exception):
-            # This should fail because temp_dir is not a git repo
-            setup_workspace(
-                temp_dir,
-                "test-spec",
-                WorkspaceMode.ISOLATED,
-            )
-
-
-class TestPerSpecWorktreeName:
-    """Tests for per-spec worktree naming (new architecture)."""
-
-    def test_worktree_named_after_spec(self, temp_git_repo: Path):
-        """Worktree is named after the spec."""
-        spec_name = "spec-1"
-        working_dir, _, _ = setup_workspace(
-            temp_git_repo,
-            spec_name,
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Per-spec architecture: worktree directory matches spec name
-        assert working_dir.name == spec_name
-
-    def test_different_specs_get_different_worktrees(self, temp_git_repo: Path):
-        """Different specs create separate worktrees."""
-        working_dir1, _, _ = setup_workspace(
-            temp_git_repo,
-            "spec-1",
-            WorkspaceMode.ISOLATED,
-        )
-
-        working_dir2, _, _ = setup_workspace(
-            temp_git_repo,
-            "spec-2",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # Each spec has its own worktree
-        assert working_dir1.name == "spec-1"
-        assert working_dir2.name == "spec-2"
-        assert working_dir1 != working_dir2
-
-    def test_worktree_path_in_worktrees_dir(self, temp_git_repo: Path):
-        """Worktree is created in worktrees directory."""
-        working_dir, _, _ = setup_workspace(
-            temp_git_repo,
-            "test-spec",
-            WorkspaceMode.ISOLATED,
-        )
-
-        # New path: .auto-claude/worktrees/tasks/{spec_name}
-        assert "worktrees" in str(working_dir)
-        assert working_dir.parent.name == "tasks"
-
-
-class TestConflictInfoDisplay:
-    """Tests for conflict info display function (ACS-179)."""
-
-    def test_print_conflict_info_with_string_list(self, capsys):
-        """print_conflict_info handles string list of file paths (ACS-179)."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": ["file1.txt", "file2.py", "file3.js"]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "3 file" in captured.out
-        assert "file1.txt" in captured.out
-        assert "file2.py" in captured.out
-        assert "file3.js" in captured.out
-        assert "git add" in captured.out
-
-    def test_print_conflict_info_with_dict_list(self, capsys):
-        """print_conflict_info handles dict list with file/reason/severity (ACS-179)."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                {"file": "file1.txt", "reason": "Syntax error", "severity": "high"},
-                {"file": "file2.py", "reason": "Merge conflict", "severity": "medium"},
-                {"file": "file3.js", "reason": "Unknown error", "severity": "low"},
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "3 file" in captured.out
-        assert "file1.txt" in captured.out
-        assert "file2.py" in captured.out
-        assert "file3.js" in captured.out
-        assert "Syntax error" in captured.out
-        assert "Merge conflict" in captured.out
-        # Verify severity emoji indicators
-        assert "🔴" in captured.out  # High severity
-        assert "🟡" in captured.out  # Medium severity
-
-    def test_print_conflict_info_mixed_formats(self, capsys):
-        """print_conflict_info handles mixed string and dict conflicts (ACS-179)."""
-        from core.workspace.display import print_conflict_info
-
-        result = {
-            "conflicts": [
-                "simple-file.txt",
-                {"file": "complex-file.py", "reason": "AI merge failed", "severity": "high"},
-            ]
-        }
-
-        print_conflict_info(result)
-
-        captured = capsys.readouterr()
-        assert "2 file" in captured.out
-        assert "simple-file.txt" in captured.out
-        assert "complex-file.py" in captured.out
-        assert "AI merge failed" in captured.out
-
-
-class TestMergeErrorHandling:
-    """Tests for merge error handling (ACS-163)."""
-
-    def test_merge_failure_returns_false_immediately(self, temp_git_repo: Path):
-        """Failed merge returns False without falling through (ACS-163)."""
-        manager = WorktreeManager(temp_git_repo)
-        manager.setup()
-
-        # Create a worktree with changes
-        worker_info = manager.create_worktree("worker-spec")
-        (worker_info.path / "worker-file.txt").write_text("worker content")
-        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
-        )
-
-        # Create a conflicting change on main
-        subprocess.run(["git", "checkout", manager.base_branch], cwd=temp_git_repo, capture_output=True)
-        (temp_git_repo / "worker-file.txt").write_text("main content")
-        subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
-        subprocess.run(
-            ["git", "commit", "-m", "Main commit"],
-            cwd=temp_git_repo, capture_output=True
-        )
-
-        # Merge should fail (conflict) and return False
-        # This tests the fix for ACS-163 where failed merge would fall through
-        result = manager.merge_worktree("worker-spec", delete_after=False)
-
-        # Should return False on merge conflict
-        assert result is False
-
-        # Verify side effects: base branch content is unchanged
-        subprocess.run(["git", "checkout", manager.base_branch], cwd=temp_git_repo, capture_output=True)
-        base_content = (temp_git_repo / "worker-file.txt").read_text()
-        assert base_content == "main content", "Base branch should be unchanged after failed merge"
-
-        # Verify worktree still exists (delete_after=False)
-        assert worker_info.path.exists(), "Worktree should still exist after failed merge"
-
-        # Verify worktree content is unchanged
-        worktree_content = (worker_info.path / "worker-file.txt").read_text()
-        assert worktree_content == "worker content", "Worktree content should be unchanged"
-
-    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")
-        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()
-        assert merged_content == "worker content", "Merged file should have worktree content"
-
-
 class TestRebaseDetection:
-    """Tests for automatic rebase detection (ACS-224)."""
-
     def test_check_git_conflicts_detects_branch_behind(self, temp_git_repo: Path):
         """_check_git_conflicts detects when spec branch is behind base branch (ACS-224)."""
         from core.workspace import _check_git_conflicts
@@ -547,7 +39,7 @@ class TestRebaseDetection:
         )
 
         # Add a commit to spec branch
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -561,7 +53,7 @@ class TestRebaseDetection:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "main-file.txt").write_text("main content")
+        (temp_git_repo / "main-file.txt").write_text("main content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Main commit after spec"],
@@ -574,7 +66,9 @@ class TestRebaseDetection:
 
         assert result is not None
         assert result.get("needs_rebase") is True, "Should detect branch is behind"
-        assert result.get("commits_behind") == 1, "Should count commits behind correctly"
+        assert result.get("commits_behind") == 1, (
+            "Should count commits behind correctly"
+        )
         assert result.get("spec_branch") == spec_branch
 
     def test_check_git_conflicts_no_commits_behind(self, temp_git_repo: Path):
@@ -588,7 +82,7 @@ class TestRebaseDetection:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -624,7 +118,7 @@ class TestRebaseDetection:
         )
 
         # Add a commit to spec branch
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -639,7 +133,9 @@ class TestRebaseDetection:
             capture_output=True,
         )
         for i in range(3):
-            (temp_git_repo / f"main-file-{i}.txt").write_text(f"main content {i}")
+            (temp_git_repo / f"main-file-{i}.txt").write_text(
+                f"main content {i}", encoding="utf-8"
+            )
             subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
             subprocess.run(
                 ["git", "commit", "-m", f"Main commit {i}"],
@@ -671,7 +167,7 @@ class TestRebaseSpecBranch:
         )
 
         # Add a commit to spec branch
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -685,7 +181,7 @@ class TestRebaseSpecBranch:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "main-file.txt").write_text("main content")
+        (temp_git_repo / "main-file.txt").write_text("main content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Main commit"],
@@ -726,7 +222,9 @@ class TestRebaseSpecBranch:
         ).stdout
         assert "Main commit" in log, "Spec branch should have main commit after rebase"
 
-    def test_rebase_spec_branch_with_conflicts_aborts_cleanly(self, temp_git_repo: Path):
+    def test_rebase_spec_branch_with_conflicts_aborts_cleanly(
+        self, temp_git_repo: Path
+    ):
         """_rebase_spec_branch handles conflicts by aborting and returning False (ACS-224)."""
         from core.workspace import _rebase_spec_branch
 
@@ -739,7 +237,7 @@ class TestRebaseSpecBranch:
         )
 
         # Create a file that will conflict
-        (temp_git_repo / "conflict.txt").write_text("spec version")
+        (temp_git_repo / "conflict.txt").write_text("spec version", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec conflict"],
@@ -753,7 +251,7 @@ class TestRebaseSpecBranch:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "conflict.txt").write_text("main version")
+        (temp_git_repo / "conflict.txt").write_text("main version", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Main conflict"],
@@ -823,7 +321,7 @@ class TestRebaseSpecBranch:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -842,7 +340,9 @@ class TestRebaseSpecBranch:
         # (branch already up-to-date is a success condition)
         result = _rebase_spec_branch(temp_git_repo, "test-spec", "main")
 
-        assert result is True, "Rebase should return True when branch is already up-to-date"
+        assert result is True, (
+            "Rebase should return True when branch is already up-to-date"
+        )
 
 
 class TestRebaseIntegration:
@@ -859,7 +359,9 @@ class TestRebaseIntegration:
         worker_info = manager.create_worktree("test-spec")
 
         # Add a file in spec worktree and commit
-        (worker_info.path / "spec-file.txt").write_text("spec content")
+        (worker_info.path / "spec-file.txt").write_text(
+            "spec content", encoding="utf-8"
+        )
         subprocess.run(["git", "add", "."], cwd=worker_info.path, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -874,7 +376,7 @@ class TestRebaseIntegration:
             capture_output=True,
         )
         for i in range(2):
-            (temp_git_repo / f"main-{i}.txt").write_text(f"main {i}")
+            (temp_git_repo / f"main-{i}.txt").write_text(f"main {i}", encoding="utf-8")
             subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
             subprocess.run(
                 ["git", "commit", "-m", f"Main {i}"],
@@ -906,7 +408,7 @@ class TestRebaseIntegration:
         )
 
         # Add a commit to spec
-        (temp_git_repo / "spec.txt").write_text("spec")
+        (temp_git_repo / "spec.txt").write_text("spec", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec"],
@@ -920,7 +422,7 @@ class TestRebaseIntegration:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "main.txt").write_text("main")
+        (temp_git_repo / "main.txt").write_text("main", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Main"],
@@ -966,7 +468,7 @@ class TestRebaseErrorHandling:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],
@@ -1007,7 +509,6 @@ class TestRebaseErrorHandling:
 
     def test_check_git_conflicts_handles_corrupted_repo(self, temp_git_repo: Path):
         """_check_git_conflicts handles corrupted repo metadata gracefully (ACS-224)."""
-        import shutil
 
         from core.workspace import _check_git_conflicts
 
@@ -1018,7 +519,7 @@ class TestRebaseErrorHandling:
             cwd=temp_git_repo,
             capture_output=True,
         )
-        (temp_git_repo / "spec-file.txt").write_text("spec content")
+        (temp_git_repo / "spec-file.txt").write_text("spec content", encoding="utf-8")
         subprocess.run(["git", "add", "."], cwd=temp_git_repo, capture_output=True)
         subprocess.run(
             ["git", "commit", "-m", "Spec commit"],

apps/backend/core/workspace/tests/test_setup.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Tests for Workspace Setup Operations
+=====================================
+
+Tests the setup functionality including:
+- Spec copy to workspace operations
+- Timeline hook installation
+- Timeline tracking initialization
+"""
+
+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 TestCopySpecToWorktree:
+    """Tests for copy_spec_to_worktree function."""
+
+    def test_copies_spec_files_to_worktree(self, temp_git_repo: Path):
+        """Copies spec directory to worktree .auto-claude/specs/ location."""
+        from core.workspace.setup import copy_spec_to_worktree
+
+        # Create source spec directory
+        source_spec = temp_git_repo / "specs" / "test-spec"
+        source_spec.mkdir(parents=True)
+        (source_spec / "spec.md").write_text("# Test Spec", encoding="utf-8")
+        (source_spec / "requirements.json").write_text("{}", encoding="utf-8")
+
+        # Create worktree
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
+        )
+        worktree_path.mkdir(parents=True)
+
+        # Copy spec
+        result = copy_spec_to_worktree(source_spec, worktree_path, "test-spec")
+
+        # Verify path is correct
+        expected = worktree_path / ".auto-claude" / "specs" / "test-spec"
+        assert result == expected
+
+        # Verify files were copied
+        assert (expected / "spec.md").exists()
+        assert (expected / "requirements.json").exists()
+        assert (expected / "spec.md").read_text(encoding="utf-8") == "# Test Spec"
+
+    def test_overwrites_existing_spec_in_worktree(self, temp_git_repo: Path):
+        """Overwrites spec files if they already exist in worktree."""
+        from core.workspace.setup import copy_spec_to_worktree
+
+        # Create source spec
+        source_spec = temp_git_repo / "specs" / "test-spec"
+        source_spec.mkdir(parents=True)
+        (source_spec / "spec.md").write_text("# New Spec", encoding="utf-8")
+
+        # Create worktree with existing spec
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
+        )
+        worktree_path.mkdir(parents=True)
+        existing_spec = worktree_path / ".auto-claude" / "specs" / "test-spec"
+        existing_spec.mkdir(parents=True)
+        (existing_spec / "spec.md").write_text("# Old Spec", encoding="utf-8")
+
+        # Copy spec
+        result = copy_spec_to_worktree(source_spec, worktree_path, "test-spec")
+
+        # Verify new content was copied
+        assert (result / "spec.md").read_text(encoding="utf-8") == "# New Spec"
+
+    def test_creates_parent_directories(self, temp_git_repo: Path):
+        """Creates .auto-claude/specs directory if it doesn't exist."""
+        from core.workspace.setup import copy_spec_to_worktree
+
+        source_spec = temp_git_repo / "specs" / "test-spec"
+        source_spec.mkdir(parents=True)
+        (source_spec / "spec.md").write_text("# Test", encoding="utf-8")
+
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / "test-spec"
+        )
+        worktree_path.mkdir(parents=True)
+
+        result = copy_spec_to_worktree(source_spec, worktree_path, "test-spec")
+
+        # Parent directories should be created
+        assert result.exists()
+        assert (result.parent).exists()
+
+
+class TestEnsureTimelineHookInstalled:
+    """Tests for ensure_timeline_hook_installed function."""
+
+    def test_skips_if_not_git_repo(self, temp_dir: Path):
+        """Skips hook installation if directory is not a git repo."""
+        from core.workspace.setup import ensure_timeline_hook_installed
+
+        # Should not raise exception
+        ensure_timeline_hook_installed(temp_dir)
+
+    def test_skips_if_hook_already_installed(self, temp_git_repo: Path, monkeypatch):
+        """Skips if FileTimelineTracker hook is already installed."""
+        from core.workspace.setup import ensure_timeline_hook_installed
+
+        # Create hooks directory
+        hooks_dir = temp_git_repo / ".git" / "hooks"
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create hook with FileTimelineTracker marker
+        hook_file = hooks_dir / "post-commit"
+        hook_file.write_text(
+            "#!/bin/sh\n# FileTimelineTracker hook\necho 'tracked'", encoding="utf-8"
+        )
+
+        # Mock install_hook to track if it was called
+        install_called = []
+
+        def mock_install_hook(project_dir):
+            install_called.append(True)
+
+        monkeypatch.setattr("merge.install_hook.install_hook", mock_install_hook)
+
+        ensure_timeline_hook_installed(temp_git_repo)
+
+        # install_hook should not be called
+        assert len(install_called) == 0
+
+    def test_installs_hook_if_missing(self, temp_git_repo: Path):
+        """Installs hook if it doesn't exist."""
+        from core.workspace.setup import ensure_timeline_hook_installed
+
+        # Create hooks directory but no hook file
+        hooks_dir = temp_git_repo / ".git" / "hooks"
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+
+        # This test verifies the function runs without error
+        # The actual install_hook call is hard to mock because it's imported locally
+        # In production, the real install_hook would be called
+        ensure_timeline_hook_installed(temp_git_repo)
+
+        # Verify hooks directory exists (function ran)
+        assert hooks_dir.exists()
+
+
+class TestInitializeTimelineTracking:
+    """Tests for initialize_timeline_tracking function."""
+
+    def test_with_implementation_plan(self, temp_git_repo: Path, monkeypatch):
+        """Initializes tracking with files from implementation plan."""
+        from core.workspace.setup import initialize_timeline_tracking
+
+        # Create source spec with implementation plan
+        spec_name = "test-spec"
+        source_spec = temp_git_repo / ".auto-claude" / "specs" / spec_name
+        source_spec.mkdir(parents=True)
+
+        plan = {
+            "title": "Test Feature",
+            "description": "Test description",
+            "phases": [
+                {
+                    "subtasks": [
+                        {"files": ["app/main.py", "app/utils.py"]},
+                        {"files": ["tests/test_main.py"]},
+                    ]
+                }
+            ],
+        }
+        (source_spec / "implementation_plan.json").write_text(
+            json.dumps(plan), encoding="utf-8"
+        )
+
+        # Create worktree
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / spec_name
+        )
+        worktree_path.mkdir(parents=True)
+
+        # Mock FileTimelineTracker
+        mock_tracker_calls = []
+
+        class MockTracker:
+            def __init__(self, project_dir):
+                pass
+
+            def on_task_start(
+                self,
+                task_id,
+                files_to_modify,
+                branch_point_commit,
+                task_intent,
+                task_title,
+            ):
+                mock_tracker_calls.append(
+                    {
+                        "task_id": task_id,
+                        "files": files_to_modify,
+                        "branch": branch_point_commit,
+                        "intent": task_intent,
+                        "title": task_title,
+                    }
+                )
+
+        monkeypatch.setattr("core.workspace.setup.FileTimelineTracker", MockTracker)
+
+        initialize_timeline_tracking(
+            temp_git_repo, spec_name, worktree_path, source_spec
+        )
+
+        # Verify tracker was called with correct parameters
+        assert len(mock_tracker_calls) == 1
+        call = mock_tracker_calls[0]
+        assert call["task_id"] == spec_name
+        assert set(call["files"]) == {
+            "app/main.py",
+            "app/utils.py",
+            "tests/test_main.py",
+        }
+        assert call["title"] == "Test Feature"
+        assert call["intent"] == "Test description"
+
+    def test_without_implementation_plan(self, temp_git_repo: Path, monkeypatch):
+        """Initializes tracking retroactively from worktree if no plan."""
+        from core.workspace.setup import initialize_timeline_tracking
+
+        spec_name = "test-spec"
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / spec_name
+        )
+        worktree_path.mkdir(parents=True)
+
+        # Mock FileTimelineTracker
+        mock_calls = []
+
+        class MockTracker:
+            def __init__(self, project_dir):
+                pass
+
+            def initialize_from_worktree(
+                self, task_id, worktree_path, task_intent, task_title
+            ):
+                mock_calls.append(
+                    {
+                        "task_id": task_id,
+                        "worktree": worktree_path,
+                        "intent": task_intent,
+                        "title": task_title,
+                    }
+                )
+
+        monkeypatch.setattr("core.workspace.setup.FileTimelineTracker", MockTracker)
+
+        initialize_timeline_tracking(temp_git_repo, spec_name, worktree_path, None)
+
+        # Should use retroactive initialization
+        assert len(mock_calls) == 1
+        assert mock_calls[0]["task_id"] == spec_name
+
+    def test_handles_exception_gracefully(
+        self, temp_git_repo: Path, monkeypatch, capsys
+    ):
+        """Logs warning but doesn't raise exception on error."""
+        from core.workspace.setup import initialize_timeline_tracking
+
+        spec_name = "test-spec"
+        worktree_path = (
+            temp_git_repo / ".auto-claude" / "worktrees" / "tasks" / spec_name
+        )
+        worktree_path.mkdir(parents=True)
+
+        # Mock FileTimelineTracker to raise exception
+        class FailingTracker:
+            def __init__(self, project_dir):
+                raise Exception("Tracker init failed")
+
+        monkeypatch.setattr("core.workspace.setup.FileTimelineTracker", FailingTracker)
+
+        # Should not raise
+        initialize_timeline_tracking(temp_git_repo, spec_name, worktree_path, None)
+
+        # Should print warning
+        captured = capsys.readouterr()
+        assert "Timeline tracking" in captured.out or "Note:" in captured.out

apps/backend/core/worktree.py

@@ -15,6 +15,8 @@ This allows:
 """
 
 import asyncio
+import json
+import logging
 import os
 import re
 import shutil
@@ -28,8 +30,13 @@ from typing import TypedDict, TypeVar
 
 from core.gh_executable import get_gh_executable, invalidate_gh_cache
 from core.git_executable import get_git_executable, get_isolated_git_env, run_git
+from core.git_provider import detect_git_provider
+from core.glab_executable import get_glab_executable, invalidate_glab_cache
+from core.model_config import get_utility_model_config
 from debug import debug_warning
 
+logger = logging.getLogger(__name__)
+
 T = TypeVar("T")
 
 
@@ -136,6 +143,7 @@ class PushAndCreatePRResult(TypedDict, total=False):
     pushed: bool
     remote: str
     branch: str
+    provider: str  # 'github', 'gitlab', or 'unknown'
     pr_url: str | None  # None when PR was created but URL couldn't be extracted
     already_exists: bool
     error: str
@@ -175,12 +183,18 @@ class WorktreeManager:
 
     # Timeout constants for subprocess operations
     GIT_PUSH_TIMEOUT = 120  # 2 minutes for git push (network operations)
-    GH_CLI_TIMEOUT = 60  # 1 minute for gh CLI commands
-    GH_QUERY_TIMEOUT = 30  # 30 seconds for gh CLI queries
+    CLI_TIMEOUT = 60  # 1 minute for CLI commands (gh/glab)
+    CLI_QUERY_TIMEOUT = 30  # 30 seconds for CLI queries (gh/glab)
 
-    def __init__(self, project_dir: Path, base_branch: str | None = None):
+    def __init__(
+        self,
+        project_dir: Path,
+        base_branch: str | None = None,
+        use_local_branch: bool = False,
+    ):
         self.project_dir = project_dir
         self.base_branch = base_branch or self._detect_base_branch()
+        self.use_local_branch = use_local_branch
         self.worktrees_dir = project_dir / ".auto-claude" / "worktrees" / "tasks"
         self._merge_lock = asyncio.Lock()
 
@@ -416,6 +430,7 @@ class WorktreeManager:
                         if os.path.samefile(resolved_path, current_path):
                             return line[len("branch refs/heads/") :]
                 except OSError:
+                    # File system comparison errors are handled by fallback below
                     pass
                 # Fallback to normalized case comparison
                 if os.path.normcase(str(resolved_path)) == os.path.normcase(
@@ -496,6 +511,7 @@ class WorktreeManager:
                     if os.path.samefile(resolved_path, registered_path):
                         return True
             except OSError:
+                # File system errors handled by fallback comparison below
                 pass
             # Fallback to normalized case comparison for non-existent paths
             if os.path.normcase(str(resolved_path)) == os.path.normcase(
@@ -687,18 +703,23 @@ class WorktreeManager:
         else:
             # Branch doesn't exist - create new branch from remote or local base
             # Determine the start point for the worktree
-            remote_ref = f"origin/{self.base_branch}"
             start_point = self.base_branch  # Default to local branch
 
-            # Check if remote ref exists and use it as the source of truth
-            check_remote = self._run_git(["rev-parse", "--verify", remote_ref])
-            if check_remote.returncode == 0:
-                start_point = remote_ref
-                print(f"Creating worktree from remote: {remote_ref}")
+            if self.use_local_branch:
+                # User explicitly requested local branch - skip auto-switch to remote
+                # This preserves gitignored files (.env, configs) that may not exist on remote
+                print(f"Creating worktree from local branch: {self.base_branch}")
             else:
-                print(
-                    f"Remote ref {remote_ref} not found, using local branch: {self.base_branch}"
-                )
+                # Check if remote ref exists and use it as the source of truth
+                remote_ref = f"origin/{self.base_branch}"
+                check_remote = self._run_git(["rev-parse", "--verify", remote_ref])
+                if check_remote.returncode == 0:
+                    start_point = remote_ref
+                    print(f"Creating worktree from remote: {remote_ref}")
+                else:
+                    print(
+                        f"Remote ref {remote_ref} not found, using local branch: {self.base_branch}"
+                    )
 
             # Create worktree with new branch from the start point
             result = self._run_git(
@@ -1192,8 +1213,22 @@ class WorktreeManager:
         target = target_branch or self.base_branch
         pr_title = title or f"auto-claude: {spec_name}"
 
-        # Get PR body from spec.md if available
-        pr_body = self._extract_spec_summary(spec_name)
+        # Try AI-powered PR body from project's PR template, fall back to spec summary
+        pr_body: str | None = None
+        try:
+            diff_summary, commit_log = self._gather_pr_context(spec_name, target)
+            pr_body = self._try_ai_pr_body(
+                spec_name=spec_name,
+                target_branch=target,
+                branch_name=info.branch,
+                diff_summary=diff_summary,
+                commit_log=commit_log,
+            )
+        except Exception as e:
+            logger.warning(f"AI PR body generation encountered an error: {e}")
+
+        if not pr_body:
+            pr_body = self._extract_spec_summary(spec_name)
 
         # Find gh executable before attempting PR creation
         gh_executable = get_gh_executable()
@@ -1236,7 +1271,7 @@ class WorktreeManager:
                     text=True,
                     encoding="utf-8",
                     errors="replace",
-                    timeout=self.GH_CLI_TIMEOUT,
+                    timeout=self.CLI_TIMEOUT,
                     env=get_isolated_git_env(),
                 )
 
@@ -1312,9 +1347,328 @@ class WorktreeManager:
             invalidate_gh_cache()
             return PullRequestResult(
                 success=False,
-                error="gh CLI not found. Install from https://cli.github.com/",
+                error="GitHub CLI (gh) not found. Install from https://cli.github.com/",
             )
 
+    def create_merge_request(
+        self,
+        spec_name: str,
+        target_branch: str | None = None,
+        title: str | None = None,
+        draft: bool = False,
+    ) -> PullRequestResult:
+        """
+        Create a GitLab merge request for a spec's branch using glab CLI with retry logic.
+
+        Args:
+            spec_name: The spec folder name
+            target_branch: Target branch for MR (defaults to base_branch)
+            title: MR title (defaults to spec name)
+            draft: Whether to create as draft MR
+
+        Returns:
+            PullRequestResult with keys:
+                - success: bool
+                - pr_url: str (if created)
+                - already_exists: bool (if MR already exists)
+                - error: str (if failed)
+        """
+        info = self.get_worktree_info(spec_name)
+        if not info:
+            return PullRequestResult(
+                success=False,
+                error=f"No worktree found for spec: {spec_name}",
+            )
+
+        target = target_branch or self.base_branch
+        mr_title = title or f"auto-claude: {spec_name}"
+
+        # Get MR body from spec.md if available
+        mr_body = self._extract_spec_summary(spec_name)
+
+        # Find glab executable before attempting MR creation
+        glab_executable = get_glab_executable()
+        if not glab_executable:
+            return PullRequestResult(
+                success=False,
+                error="GitLab CLI (glab) not found. Install from https://gitlab.com/gitlab-org/cli",
+            )
+
+        # Build glab mr create command
+        glab_args = [
+            glab_executable,
+            "mr",
+            "create",
+            "--target-branch",
+            target,
+            "--source-branch",
+            info.branch,
+            "--title",
+            mr_title,
+            "--description",
+            mr_body,
+        ]
+        if draft:
+            glab_args.append("--draft")
+
+        def is_mr_retryable(stderr: str) -> bool:
+            """Check if MR creation error is retryable (network or HTTP 5xx)."""
+            return _is_retryable_network_error(stderr) or _is_retryable_http_error(
+                stderr
+            )
+
+        def do_create_mr() -> tuple[bool, PullRequestResult | None, str]:
+            """Execute MR creation for retry wrapper."""
+            try:
+                result = subprocess.run(
+                    glab_args,
+                    cwd=info.path,
+                    capture_output=True,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    timeout=self.CLI_TIMEOUT,
+                    env=get_isolated_git_env(),
+                )
+
+                # Check for "already exists" case (success, no retry needed)
+                if result.returncode != 0 and "already exists" in result.stderr.lower():
+                    existing_url = self._get_existing_mr_url(spec_name, target)
+                    result_dict = PullRequestResult(
+                        success=True,
+                        pr_url=existing_url,
+                        already_exists=True,
+                    )
+                    if existing_url is None:
+                        result_dict["message"] = (
+                            "MR already exists but URL could not be retrieved"
+                        )
+                    return (True, result_dict, "")
+
+                if result.returncode == 0:
+                    # Extract MR URL from output
+                    mr_url: str | None = result.stdout.strip()
+                    if not mr_url.startswith("http"):
+                        # Try to find URL in output
+                        # GitLab URL pattern: matches any HTTPS URL with /merge_requests/<number> or /-/merge_requests/<number> path
+                        match = re.search(
+                            r"https://[^\s]+(?:/merge_requests/|/-/merge_requests/)\d+",
+                            result.stdout,
+                        )
+                        if match:
+                            mr_url = match.group(0)
+                        else:
+                            # Invalid output - no valid URL found
+                            mr_url = None
+
+                    return (
+                        True,
+                        PullRequestResult(
+                            success=True,
+                            pr_url=mr_url,
+                            already_exists=False,
+                        ),
+                        "",
+                    )
+
+                return (False, None, result.stderr)
+
+            except FileNotFoundError:
+                # glab CLI not installed - not retryable, raise to exit retry loop
+                raise
+
+        max_retries = 3
+        try:
+            result, last_error = _with_retry(
+                operation=do_create_mr,
+                max_retries=max_retries,
+                is_retryable=is_mr_retryable,
+            )
+
+            if result:
+                return result
+
+            # Handle timeout error message
+            if last_error == "Operation timed out":
+                return PullRequestResult(
+                    success=False,
+                    error=f"MR creation timed out after {max_retries} attempts.",
+                )
+
+            return PullRequestResult(
+                success=False,
+                error=f"Failed to create MR: {last_error}",
+            )
+
+        except FileNotFoundError:
+            # Cached glab path became invalid - clear cache so next call re-discovers
+            invalidate_glab_cache()
+            return PullRequestResult(
+                success=False,
+                error="GitLab CLI (glab) not found. Install from https://gitlab.com/gitlab-org/cli",
+            )
+
+    def _gather_pr_context(self, spec_name: str, target_branch: str) -> tuple[str, str]:
+        """
+        Gather diff summary and commit log for PR template filling.
+
+        Args:
+            spec_name: The spec folder name
+            target_branch: The target branch for the PR
+
+        Returns:
+            Tuple of (diff_summary, commit_log)
+        """
+        worktree_path = self.get_worktree_path(spec_name)
+        info = self.get_worktree_info(spec_name)
+        branch = info.branch if info else self.get_branch_name(spec_name)
+
+        # Get diff summary (stat for overview)
+        diff_result = self._run_git(
+            ["diff", "--stat", f"{target_branch}...{branch}"],
+            cwd=worktree_path,
+            timeout=30,
+        )
+        diff_summary = diff_result.stdout.strip() if diff_result.returncode == 0 else ""
+
+        # Get shortstat for quick summary
+        shortstat_result = self._run_git(
+            ["diff", "--shortstat", f"{target_branch}...{branch}"],
+            cwd=worktree_path,
+            timeout=30,
+        )
+        if shortstat_result.returncode == 0 and shortstat_result.stdout.strip():
+            diff_summary += "\n\n" + shortstat_result.stdout.strip()
+
+        # Get actual code changes (patch format) for better AI context
+        # Truncate to 30k chars to avoid token limits while still providing meaningful context
+        patch_result = self._run_git(
+            ["diff", "-p", "--stat-width=999", f"{target_branch}...{branch}"],
+            cwd=worktree_path,
+            timeout=30,
+        )
+        if patch_result.returncode == 0 and patch_result.stdout.strip():
+            patch_content = patch_result.stdout.strip()
+            MAX_DIFF_CHARS = 30_000
+
+            if len(patch_content) > MAX_DIFF_CHARS:
+                # Truncate patch and add notice
+                truncated_patch = patch_content[:MAX_DIFF_CHARS]
+                diff_summary += (
+                    "\n\n" + truncated_patch + "\n\n(... diff truncated due to size)"
+                )
+            else:
+                diff_summary += "\n\n" + patch_content
+
+        # Get commit log
+        log_result = self._run_git(
+            [
+                "log",
+                "--oneline",
+                "--no-merges",
+                f"{target_branch}..{branch}",
+            ],
+            cwd=worktree_path,
+            timeout=30,
+        )
+        commit_log = log_result.stdout.strip() if log_result.returncode == 0 else ""
+
+        return diff_summary, commit_log
+
+    def _try_ai_pr_body(
+        self,
+        spec_name: str,
+        target_branch: str,
+        branch_name: str,
+        diff_summary: str,
+        commit_log: str,
+    ) -> str | None:
+        """
+        Attempt to generate a PR body using the AI template filler agent.
+
+        Runs the async agent synchronously with a 30-second timeout.
+        Returns None on any failure so the caller can fall back gracefully.
+
+        Args:
+            spec_name: The spec folder name
+            target_branch: The target branch for the PR
+            branch_name: The source branch name
+            diff_summary: Git diff summary of changes
+            commit_log: Git log of commits
+
+        Returns:
+            The AI-generated PR body string, or None if unavailable.
+        """
+        try:
+            from agents.pr_template_filler import (
+                detect_pr_template,
+                run_pr_template_filler,
+            )
+        except ImportError:
+            logger.warning(
+                "PR template filler module not available, skipping AI PR body"
+            )
+            return None
+
+        # Check if a PR template exists before doing any heavy lifting
+        template = detect_pr_template(self.project_dir)
+        if template is None:
+            return None
+
+        # Resolve spec directory
+        spec_dir = self.project_dir / ".auto-claude" / "specs" / spec_name
+        if not spec_dir.is_dir():
+            # Try worktree-local spec path
+            worktree_path = self.get_worktree_path(spec_name)
+            spec_dir = worktree_path / ".auto-claude" / "specs" / spec_name
+            if not spec_dir.is_dir():
+                logger.warning("Spec directory not found for AI PR body generation")
+                return None
+
+        # Get model configuration from environment (respects user settings)
+        model, thinking_budget = get_utility_model_config()
+
+        async def _run_with_timeout() -> str | None:
+            try:
+                return await asyncio.wait_for(
+                    run_pr_template_filler(
+                        project_dir=self.project_dir,
+                        spec_dir=spec_dir,
+                        model=model,
+                        thinking_budget=thinking_budget,
+                        branch_name=branch_name,
+                        target_branch=target_branch,
+                        diff_summary=diff_summary,
+                        commit_log=commit_log,
+                        verbose=False,
+                    ),
+                    timeout=30.0,
+                )
+            except asyncio.TimeoutError:
+                logger.warning("PR template filler timed out after 30s")
+                return None
+
+        try:
+            # Check if there's already a running event loop
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+
+            if loop and loop.is_running():
+                # We're already inside an async context — run in a new thread
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                    future = pool.submit(asyncio.run, _run_with_timeout())
+                    return future.result(timeout=35)
+            else:
+                return asyncio.run(_run_with_timeout())
+
+        except Exception as e:
+            logger.warning(f"AI PR body generation failed: {e}")
+            return None
+
     def _extract_spec_summary(self, spec_name: str) -> str:
         """Extract a summary from spec.md for PR body."""
         worktree_path = self.get_worktree_path(spec_name)
@@ -1389,7 +1743,7 @@ class WorktreeManager:
                 text=True,
                 encoding="utf-8",
                 errors="replace",
-                timeout=self.GH_QUERY_TIMEOUT,
+                timeout=self.CLI_QUERY_TIMEOUT,
                 env=get_isolated_git_env(),
             )
             if result.returncode == 0:
@@ -1408,6 +1762,57 @@ class WorktreeManager:
 
         return None
 
+    def _get_existing_mr_url(self, spec_name: str, target_branch: str) -> str | None:
+        """Get the URL of an existing MR for this branch."""
+        info = self.get_worktree_info(spec_name)
+        if not info:
+            return None
+
+        glab_executable = get_glab_executable()
+        if not glab_executable:
+            # glab CLI not found - return None and let caller handle it
+            return None
+
+        try:
+            result = subprocess.run(
+                [
+                    glab_executable,
+                    "mr",
+                    "view",
+                    info.branch,
+                    "--output",
+                    "json",
+                ],
+                cwd=info.path,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=self.CLI_QUERY_TIMEOUT,
+                env=get_isolated_git_env(),
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                # Parse JSON output to extract web_url (glab uses snake_case)
+                try:
+                    data = json.loads(result.stdout)
+                    return data.get("web_url")
+                except json.JSONDecodeError:
+                    # If JSON parsing fails, return None
+                    pass
+        except (
+            subprocess.TimeoutExpired,
+            FileNotFoundError,
+            subprocess.SubprocessError,
+        ) as e:
+            # Silently ignore errors when fetching existing MR URL - this is a best-effort
+            # lookup that may fail due to network issues, missing glab CLI, or auth problems.
+            # Returning None allows the caller to handle missing URLs gracefully.
+            if isinstance(e, FileNotFoundError):
+                invalidate_glab_cache()
+            debug_warning("worktree", f"Could not get existing MR URL: {e}")
+
+        return None
+
     def push_and_create_pr(
         self,
         spec_name: str,
@@ -1417,13 +1822,14 @@ class WorktreeManager:
         force_push: bool = False,
     ) -> PushAndCreatePRResult:
         """
-        Push branch and create a pull request in one operation.
+        Push branch and create a pull request/merge request in one operation.
+        Automatically detects git provider (GitHub or GitLab) and routes to the appropriate CLI.
 
         Args:
             spec_name: The spec folder name
-            target_branch: Target branch for PR (defaults to base_branch)
-            title: PR title (defaults to spec name)
-            draft: Whether to create as draft PR
+            target_branch: Target branch for PR/MR (defaults to base_branch)
+            title: PR/MR title (defaults to spec name)
+            draft: Whether to create as draft PR/MR
             force_push: Whether to force push the branch
 
         Returns:
@@ -1431,7 +1837,8 @@ class WorktreeManager:
                 - success: bool
                 - pr_url: str (if created)
                 - pushed: bool (if push succeeded)
-                - already_exists: bool (if PR already exists)
+                - provider: str ('github', 'gitlab', or 'unknown')
+                - already_exists: bool (if PR/MR already exists)
                 - error: str (if failed)
         """
         # Step 1: Push the branch
@@ -1445,20 +1852,44 @@ class WorktreeManager:
                 error=push_result.get("error", "Push failed"),
             )
 
-        # Step 2: Create the PR
-        pr_result = self.create_pull_request(
-            spec_name=spec_name,
-            target_branch=target_branch,
-            title=title,
-            draft=draft,
+        # Step 2: Detect git provider (use the remote that was pushed to)
+        provider = detect_git_provider(
+            self.project_dir, remote_name=push_result.get("remote")
         )
 
+        # Step 3: Create the PR/MR based on provider
+        if provider == "github":
+            pr_result = self.create_pull_request(
+                spec_name=spec_name,
+                target_branch=target_branch,
+                title=title,
+                draft=draft,
+            )
+        elif provider == "gitlab":
+            pr_result = self.create_merge_request(
+                spec_name=spec_name,
+                target_branch=target_branch,
+                title=title,
+                draft=draft,
+            )
+        else:
+            # Unknown provider
+            return PushAndCreatePRResult(
+                success=False,
+                pushed=True,
+                remote=push_result.get("remote"),
+                branch=push_result.get("branch"),
+                provider=provider,
+                error="Unable to determine git hosting provider. Supported: GitHub, GitLab.",
+            )
+
         # Combine results
         return PushAndCreatePRResult(
             success=pr_result.get("success", False),
             pushed=True,
             remote=push_result.get("remote"),
             branch=push_result.get("branch"),
+            provider=provider,
             pr_url=pr_result.get("pr_url"),
             already_exists=pr_result.get("already_exists", False),
             error=pr_result.get("error"),

apps/backend/ideation/config.py

@@ -29,6 +29,7 @@ class IdeationConfigManager:
         thinking_level: str = "medium",
         refresh: bool = False,
         append: bool = False,
+        fast_mode: bool = False,
     ):
         """Initialize configuration manager.
 
@@ -64,6 +65,7 @@ class IdeationConfigManager:
             self.model,
             self.thinking_level,
             self.max_ideas_per_type,
+            fast_mode=fast_mode,
         )
         self.analyzer = ProjectAnalyzer(
             self.project_dir,

apps/backend/ideation/generator.py

@@ -17,7 +17,12 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from client import create_client
-from phase_config import get_thinking_budget, resolve_model_id
+from phase_config import (
+    get_model_betas,
+    get_thinking_budget,
+    get_thinking_kwargs_for_model,
+    resolve_model_id,
+)
 from ui import print_status
 
 # Ideation types
@@ -59,6 +64,7 @@ class IdeationGenerator:
         model: str = "sonnet",  # Changed from "opus" (fix #433)
         thinking_level: str = "medium",
         max_ideas_per_type: int = 5,
+        fast_mode: bool = False,
     ):
         self.project_dir = Path(project_dir)
         self.output_dir = Path(output_dir)
@@ -66,6 +72,7 @@ class IdeationGenerator:
         self.thinking_level = thinking_level
         self.thinking_budget = get_thinking_budget(thinking_level)
         self.max_ideas_per_type = max_ideas_per_type
+        self.fast_mode = fast_mode
         self.prompts_dir = Path(__file__).parent.parent / "prompts"
 
     async def run_agent(
@@ -91,11 +98,21 @@ class IdeationGenerator:
             prompt += f"\n{additional_context}\n"
 
         # Create client with thinking budget
+        # Use agent_type="ideation" to avoid loading unnecessary MCP servers
+        # which can cause 60-second timeout delays
+        resolved_model = resolve_model_id(self.model)
+        betas = get_model_betas(self.model)
+        thinking_kwargs = get_thinking_kwargs_for_model(
+            resolved_model, self.thinking_level
+        )
         client = create_client(
             self.project_dir,
             self.output_dir,
-            resolve_model_id(self.model),
-            max_thinking_tokens=self.thinking_budget,
+            resolved_model,
+            agent_type="ideation",
+            betas=betas,
+            fast_mode=self.fast_mode,
+            **thinking_kwargs,
         )
 
         try:
@@ -184,11 +201,20 @@ Common fixes:
 Write the fixed JSON to the file now.
 """
 
+        # Use agent_type="ideation" for recovery agent as well
+        resolved_model = resolve_model_id(self.model)
+        betas = get_model_betas(self.model)
+        thinking_kwargs = get_thinking_kwargs_for_model(
+            resolved_model, self.thinking_level
+        )
         client = create_client(
             self.project_dir,
             self.output_dir,
-            resolve_model_id(self.model),
-            max_thinking_tokens=self.thinking_budget,
+            resolved_model,
+            agent_type="ideation",
+            betas=betas,
+            fast_mode=self.fast_mode,
+            **thinking_kwargs,
         )
 
         try:

apps/backend/ideation/runner.py

@@ -28,6 +28,7 @@ from .types import IdeationPhaseResult
 
 # Configuration
 MAX_RETRIES = 3
+IDEATION_TIMEOUT_SECONDS = 5 * 60  # 5 minutes max for all ideation types
 
 
 class IdeationOrchestrator:
@@ -45,6 +46,7 @@ class IdeationOrchestrator:
         thinking_level: str = "medium",
         refresh: bool = False,
         append: bool = False,
+        fast_mode: bool = False,
     ):
         """Initialize the ideation orchestrator.
 
@@ -59,6 +61,7 @@ class IdeationOrchestrator:
             thinking_level: Thinking level for extended reasoning
             refresh: Force regeneration of existing files
             append: Preserve existing ideas when merging
+            fast_mode: Enable Fast Mode for faster Opus 4.6 output
         """
         # Initialize configuration manager
         self.config_manager = IdeationConfigManager(
@@ -72,6 +75,7 @@ class IdeationOrchestrator:
             thinking_level=thinking_level,
             refresh=refresh,
             append=append,
+            fast_mode=fast_mode,
         )
 
         # Expose configuration for convenience
@@ -173,16 +177,45 @@ class IdeationOrchestrator:
             "progress",
         )
 
-        # Create tasks for all enabled types
-        ideation_tasks = [
-            self.output_streamer.stream_ideation_result(
-                ideation_type, self.phase_executor, MAX_RETRIES
+        # Create tasks explicitly so we can cancel them on timeout
+        ideation_task_objs = [
+            asyncio.create_task(
+                self.output_streamer.stream_ideation_result(
+                    ideation_type, self.phase_executor, MAX_RETRIES
+                )
             )
             for ideation_type in self.enabled_types
         ]
 
-        # Run all ideation types concurrently
-        ideation_results = await asyncio.gather(*ideation_tasks, return_exceptions=True)
+        # Run all ideation types concurrently with timeout protection
+        # 5 minute timeout prevents infinite hangs if one type stalls
+        try:
+            ideation_results = await asyncio.wait_for(
+                asyncio.gather(*ideation_task_objs, return_exceptions=True),
+                timeout=IDEATION_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            print_status(
+                "Ideation generation timed out after 5 minutes",
+                "error",
+            )
+            # Cancel all pending tasks to prevent resource leaks
+            for task in ideation_task_objs:
+                if not task.done():
+                    task.cancel()
+            # Wait for cancellation to complete and preserve results from completed tasks
+            # Tasks that finished before timeout will return their results;
+            # cancelled tasks will return CancelledError
+            results_after_cancel = await asyncio.gather(
+                *ideation_task_objs, return_exceptions=True
+            )
+            # Convert CancelledError to timeout exception, preserve completed results
+            ideation_results = [
+                Exception("Ideation timed out")
+                if isinstance(res, asyncio.CancelledError)
+                else res
+                for res in results_after_cancel
+            ]
 
         # Process results
         for i, result in enumerate(ideation_results):

apps/backend/integrations/graphiti/config.py

@@ -145,7 +145,7 @@ class GraphitiConfig:
 
     # OpenRouter settings (multi-provider aggregator)
     openrouter_api_key: str = ""
-    openrouter_base_url: str = "https://openrouter.ai/api/v1"
+    openrouter_base_url: str = "https://openrouter.ai/api"
     openrouter_llm_model: str = "anthropic/claude-sonnet-4"
     openrouter_embedding_model: str = "openai/text-embedding-3-small"
 
@@ -207,7 +207,7 @@ class GraphitiConfig:
         # OpenRouter settings
         openrouter_api_key = os.environ.get("OPENROUTER_API_KEY", "")
         openrouter_base_url = os.environ.get(
-            "OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"
+            "OPENROUTER_BASE_URL", "https://openrouter.ai/api"
         )
         openrouter_llm_model = os.environ.get(
             "OPENROUTER_LLM_MODEL", "anthropic/claude-sonnet-4"
@@ -624,7 +624,10 @@ def get_graphiti_status() -> dict:
 
     # CRITICAL FIX: Actually verify packages are importable before reporting available
     # Don't just check config.is_valid() - actually try to import the module
-    if not config.is_valid():
+    # Note: This branch is currently unreachable because is_valid() returns True
+    # whenever enabled is True. Kept for defensive purposes in case is_valid()
+    # logic changes in the future.
+    if not config.is_valid():  # pragma: no cover
         status["reason"] = errors[0] if errors else "Configuration invalid"
         return status
 
@@ -635,7 +638,7 @@ def get_graphiti_status() -> dict:
         from graphiti_core.driver.falkordb_driver import FalkorDriver  # noqa: F401
 
         # If we got here, packages are importable
-        status["available"] = True
+        status["available"] = True  # pragma: no cover
     except ImportError as e:
         status["available"] = False
         status["reason"] = f"Graphiti packages not installed: {e}"

apps/backend/integrations/graphiti/memory.py

@@ -12,12 +12,8 @@ The refactored code is now organized as:
 - graphiti/search.py - Semantic search logic
 - graphiti/schema.py - Graph schema definitions
 
-This facade ensures existing imports continue to work:
-    from graphiti_memory import GraphitiMemory, is_graphiti_enabled
-
-New code should prefer importing from the graphiti package:
-    from graphiti import GraphitiMemory
-    from graphiti.schema import GroupIdMode
+Import from this module:
+    from integrations.graphiti.memory import GraphitiMemory, is_graphiti_enabled, GroupIdMode
 
 For detailed documentation on the memory system architecture and usage,
 see graphiti/graphiti.py.
@@ -76,6 +72,8 @@ async def test_graphiti_connection() -> tuple[bool, str]:
     """
     Test if LadybugDB is available and Graphiti can connect.
 
+    Uses the embedded LadybugDB via the patched KuzuDriver (no remote connection).
+
     Returns:
         Tuple of (success: bool, message: str)
     """
@@ -91,43 +89,48 @@ async def test_graphiti_connection() -> tuple[bool, str]:
 
     try:
         from graphiti_core import Graphiti
-        from graphiti_core.driver.falkordb_driver import FalkorDriver
         from graphiti_providers import ProviderError, create_embedder, create_llm_client
 
+        # Import the patched driver creator (handles LadybugDB monkeypatch internally)
+        from integrations.graphiti.queries_pkg.client import _apply_ladybug_monkeypatch
+        from integrations.graphiti.queries_pkg.kuzu_driver_patched import (
+            create_patched_kuzu_driver,
+        )
+
         # Create providers
         try:
-            llm_client = create_llm_client(config)
-            embedder = create_embedder(config)
+            llm_client = create_llm_client(config)  # pragma: no cover
+            embedder = create_embedder(config)  # pragma: no cover
         except ProviderError as e:
             return False, f"Provider error: {e}"
 
-        # Try to connect
-        driver = FalkorDriver(
-            host=config.falkordb_host,
-            port=config.falkordb_port,
-            password=config.falkordb_password or None,
-            database=config.database,
-        )
+        # Apply LadybugDB monkeypatch for embedded database
+        if not _apply_ladybug_monkeypatch():  # pragma: no cover
+            return False, "LadybugDB not installed (requires Python 3.12+)"
 
-        graphiti = Graphiti(
+        # Create embedded database driver
+        db_path = config.get_db_path()
+        driver = create_patched_kuzu_driver(db=str(db_path))  # pragma: no cover
+
+        graphiti = Graphiti(  # pragma: no cover
             graph_driver=driver,
             llm_client=llm_client,
             embedder=embedder,
         )
 
         # Try a simple operation
-        await graphiti.build_indices_and_constraints()
-        await graphiti.close()
+        await graphiti.build_indices_and_constraints()  # pragma: no cover
+        await graphiti.close()  # pragma: no cover
 
-        return True, (
-            f"Connected to LadybugDB at {config.falkordb_host}:{config.falkordb_port} "
+        return True, (  # pragma: no cover
+            f"Connected to LadybugDB at {db_path} "
             f"(providers: {config.get_provider_summary()})"
         )
 
     except ImportError as e:
         return False, f"Graphiti packages not installed: {e}"
 
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         return False, f"Connection failed: {e}"
 
 

apps/backend/integrations/graphiti/providers_pkg/utils.py

@@ -62,7 +62,7 @@ async def get_graph_hints(
     try:
         from pathlib import Path
 
-        from graphiti_memory import GraphitiMemory, GroupIdMode
+        from integrations.graphiti.memory import GraphitiMemory, GroupIdMode
 
         # Determine project directory from project_id or use current dir
         project_dir = Path.cwd()

apps/backend/integrations/graphiti/queries_pkg/kuzu_driver_patched.py

@@ -15,7 +15,10 @@ from typing import Any
 # Import kuzu (might be real_ladybug via monkeypatch)
 try:
     import kuzu
-except ImportError:
+except ImportError:  # pragma: no cover
+    # Fallback to real_ladybug if kuzu is not available.
+    # This import-time fallback is hard to test in normal unit tests
+    # since the module is imported once before tests can mock anything.
     import real_ladybug as kuzu  # type: ignore
 
 logger = logging.getLogger(__name__)

apps/backend/integrations/graphiti/queries_pkg/search.py

@@ -67,7 +67,8 @@ class GraphitiSearch:
         Args:
             query: Search query
             num_results: Maximum number of results to return
-            include_project_context: If True and in PROJECT mode, search project-wide
+            include_project_context: If True and in SPEC mode, also search project-wide
+            min_score: Minimum relevance score threshold (0.0 to 1.0)
 
         Returns:
             List of relevant context items with content, score, and type
@@ -101,10 +102,14 @@ class GraphitiSearch:
                     or str(result)
                 )
 
+                # Normalize score to float, treating None as 0.0
+                raw_score = getattr(result, "score", None)
+                score = raw_score if raw_score is not None else 0.0
+
                 context_items.append(
                     {
                         "content": content,
-                        "score": getattr(result, "score", 0.0),
+                        "score": score,
                         "type": getattr(result, "type", "unknown"),
                     }
                 )
@@ -112,7 +117,9 @@ class GraphitiSearch:
             # Filter by minimum score if specified
             if min_score > 0:
                 context_items = [
-                    item for item in context_items if item.get("score", 0) >= min_score
+                    item
+                    for item in context_items
+                    if (item.get("score", 0.0)) >= min_score
                 ]
 
             logger.info(
@@ -225,12 +232,14 @@ class GraphitiSearch:
                         if not isinstance(data, dict):
                             continue
                         if data.get("type") == EPISODE_TYPE_TASK_OUTCOME:
+                            raw_score = getattr(result, "score", None)
+                            score = raw_score if raw_score is not None else 0.0
                             outcomes.append(
                                 {
                                     "task_id": data.get("task_id"),
                                     "success": data.get("success"),
                                     "outcome": data.get("outcome"),
-                                    "score": getattr(result, "score", 0.0),
+                                    "score": score,
                                 }
                             )
                     except (json.JSONDecodeError, TypeError, AttributeError):
@@ -284,7 +293,8 @@ class GraphitiSearch:
                 content = getattr(result, "content", None) or getattr(
                     result, "fact", None
                 )
-                score = getattr(result, "score", 0.0)
+                raw_score = getattr(result, "score", None)
+                score = raw_score if raw_score is not None else 0.0
 
                 if score < min_score:
                     continue
@@ -320,7 +330,8 @@ class GraphitiSearch:
                 content = getattr(result, "content", None) or getattr(
                     result, "fact", None
                 )
-                score = getattr(result, "score", 0.0)
+                raw_score = getattr(result, "score", None)
+                score = raw_score if raw_score is not None else 0.0
 
                 if score < min_score:
                     continue

apps/backend/integrations/graphiti/run_graphiti_memory_test.py

@@ -22,13 +22,13 @@ Usage:
 
     # Run the test:
     cd auto-claude
-    python integrations/graphiti/test_graphiti_memory.py
+    python integrations/graphiti/run_graphiti_memory_test.py
 
     # Or run specific tests:
-    python integrations/graphiti/test_graphiti_memory.py --test connection
-    python integrations/graphiti/test_graphiti_memory.py --test save
-    python integrations/graphiti/test_graphiti_memory.py --test search
-    python integrations/graphiti/test_graphiti_memory.py --test ollama
+    python integrations/graphiti/run_graphiti_memory_test.py --test connection
+    python integrations/graphiti/run_graphiti_memory_test.py --test save
+    python integrations/graphiti/run_graphiti_memory_test.py --test search
+    python integrations/graphiti/run_graphiti_memory_test.py --test ollama
 """
 
 import argparse
@@ -36,18 +36,15 @@ import asyncio
 import json
 import os
 import sys
+import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 
-# Add auto-claude to path
-auto_claude_dir = Path(__file__).parent.parent.parent
-sys.path.insert(0, str(auto_claude_dir))
-
 # Load .env file
 try:
     from dotenv import load_dotenv
 
-    env_file = auto_claude_dir / ".env"
+    env_file = Path(__file__).parent.parent.parent.parent / ".env"
     if env_file.exists():
         load_dotenv(env_file)
         print(f"Loaded .env from {env_file}")
@@ -170,7 +167,9 @@ async def test_save_episode(db_path: str, database: str) -> tuple[str, str]:
             "embedder": config.embedder_provider,
         }
 
-        episode_name = f"test_episode_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        episode_name = (
+            f"test_episode_{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}"
+        )
         group_id = "ladybug_test_group"
 
         print(f"  Episode name: {episode_name}")
@@ -186,7 +185,7 @@ async def test_save_episode(db_path: str, database: str) -> tuple[str, str]:
             name=episode_name,
             episode_body=json.dumps(test_data),
             source=EpisodeType.text,
-            source_description="Test episode from test_graphiti_memory.py",
+            source_description="Test episode from run_graphiti_memory_test.py",
             reference_time=datetime.now(timezone.utc),
             group_id=group_id,
         )
@@ -432,11 +431,8 @@ async def test_graphiti_memory_class(db_path: str, database: str) -> bool:
         from integrations.graphiti.memory import GraphitiMemory
 
         # Create temporary directories for testing
-        test_spec_dir = Path("/tmp/graphiti_test_spec")
-        test_spec_dir.mkdir(parents=True, exist_ok=True)
-
-        test_project_dir = Path("/tmp/graphiti_test_project")
-        test_project_dir.mkdir(parents=True, exist_ok=True)
+        test_spec_dir = Path(tempfile.mkdtemp(prefix="graphiti_test_spec_"))
+        test_project_dir = Path(tempfile.mkdtemp(prefix="graphiti_test_project_"))
 
         print(f"  Spec dir: {test_spec_dir}")
         print(f"  Project dir: {test_project_dir}")
@@ -704,14 +700,14 @@ async def main():
     print()
     print("  Quick commands:")
     print("    # Run all tests:")
-    print("    python integrations/graphiti/test_graphiti_memory.py")
+    print("    python integrations/graphiti/run_graphiti_memory_test.py")
     print()
     print("    # Test just Ollama embeddings:")
-    print("    python integrations/graphiti/test_graphiti_memory.py --test ollama")
+    print("    python integrations/graphiti/run_graphiti_memory_test.py --test ollama")
     print()
     print("    # Test with production database:")
     print(
-        "    python integrations/graphiti/test_graphiti_memory.py --database auto_claude_memory"
+        "    python integrations/graphiti/run_graphiti_memory_test.py --database auto_claude_memory"
     )
     print()
 

apps/backend/integrations/graphiti/run_ollama_embedding_test.py

@@ -36,13 +36,13 @@ NOTE: graphiti-core internally uses an OpenAI reranker for search ranking.
 
 Usage:
     cd apps/backend
-    python integrations/graphiti/test_ollama_embedding_memory.py
+    python integrations/graphiti/run_ollama_embedding_test.py
 
     # Run specific tests:
-    python integrations/graphiti/test_ollama_embedding_memory.py --test embeddings
-    python integrations/graphiti/test_ollama_embedding_memory.py --test create
-    python integrations/graphiti/test_ollama_embedding_memory.py --test retrieve
-    python integrations/graphiti/test_ollama_embedding_memory.py --test full-cycle
+    python integrations/graphiti/run_ollama_embedding_test.py --test embeddings
+    python integrations/graphiti/run_ollama_embedding_test.py --test create
+    python integrations/graphiti/run_ollama_embedding_test.py --test retrieve
+    python integrations/graphiti/run_ollama_embedding_test.py --test full-cycle
 """
 
 import argparse
@@ -54,15 +54,15 @@ import tempfile
 from datetime import datetime
 from pathlib import Path
 
-# Add auto-claude to path
-auto_claude_dir = Path(__file__).parent.parent.parent
-sys.path.insert(0, str(auto_claude_dir))
+# Add backend to path
+backend_dir = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(backend_dir))
 
 # Load .env file
 try:
     from dotenv import load_dotenv
 
-    env_file = auto_claude_dir / ".env"
+    env_file = backend_dir / ".env"
     if env_file.exists():
         load_dotenv(env_file)
         print(f"Loaded .env from {env_file}")
@@ -843,18 +843,18 @@ async def main():
     print()
     print("  Commands:")
     print("    # Run all tests:")
-    print("    python integrations/graphiti/test_ollama_embedding_memory.py")
+    print("    python integrations/graphiti/run_ollama_embedding_test.py")
     print()
     print("    # Run specific test:")
     print(
-        "    python integrations/graphiti/test_ollama_embedding_memory.py --test embeddings"
+        "    python integrations/graphiti/run_ollama_embedding_test.py --test embeddings"
     )
     print(
-        "    python integrations/graphiti/test_ollama_embedding_memory.py --test full-cycle"
+        "    python integrations/graphiti/run_ollama_embedding_test.py --test full-cycle"
     )
     print()
     print("    # Keep database for inspection:")
-    print("    python integrations/graphiti/test_ollama_embedding_memory.py --keep-db")
+    print("    python integrations/graphiti/run_ollama_embedding_test.py --keep-db")
     print()
 
 

apps/backend/integrations/graphiti/test_provider_naming.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick test to demonstrate provider-specific database naming.
-
-Shows how Auto Claude automatically generates provider-specific database names
-to prevent embedding dimension mismatches.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-# Add auto-claude to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from integrations.graphiti.config import GraphitiConfig
-
-
-def test_provider_naming():
-    """Demonstrate provider-specific database naming."""
-
-    print("\n" + "=" * 70)
-    print("  PROVIDER-SPECIFIC DATABASE NAMING")
-    print("=" * 70 + "\n")
-
-    providers = [
-        ("openai", None, None),
-        ("ollama", "embeddinggemma", 768),
-        ("ollama", "qwen3-embedding:0.6b", 1024),
-        ("voyage", None, None),
-        ("google", None, None),
-    ]
-
-    for provider, model, dim in providers:
-        # Create config
-        config = GraphitiConfig.from_env()
-        config.embedder_provider = provider
-
-        if provider == "ollama" and model:
-            config.ollama_embedding_model = model
-            if dim:
-                config.ollama_embedding_dim = dim
-
-        # Get naming info
-        dimension = config.get_embedding_dimension()
-        signature = config.get_provider_signature()
-        db_name = config.get_provider_specific_database_name("auto_claude_memory")
-
-        print(f"Provider: {provider}")
-        if model:
-            print(f"  Model: {model}")
-        print(f"  Embedding Dimension: {dimension}")
-        print(f"  Provider Signature: {signature}")
-        print(f"  Database Name: {db_name}")
-        print(f"  Full Path: ~/.auto-claude/memories/{db_name}/")
-        print()
-
-    print("=" * 70)
-    print("\nKey Benefits:")
-    print("  ✅ No dimension mismatch errors")
-    print("  ✅ Each provider uses its own database")
-    print("  ✅ Can switch providers without conflicts")
-    print("  ✅ Migration utility available for data transfer")
-    print()
-
-
-if __name__ == "__main__":
-    test_provider_naming()

apps/backend/integrations/graphiti/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for Graphiti memory integration."""

apps/backend/integrations/graphiti/tests/conftest.py

@@ -0,0 +1,610 @@
+"""
+Pytest configuration and fixtures for graphiti integration tests.
+
+This module provides shared fixtures for testing the memory system integration,
+including mocks for external dependencies, test configurations, and client fixtures.
+"""
+
+import os
+import sys
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
+
+import pytest
+
+# Add the backend directory to sys.path to allow imports
+backend_dir = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(backend_dir))
+
+
+def pytest_collection_modifyitems(config, items):
+    """
+    Exclude validator functions from test collection.
+
+    The validators.py module contains functions named test_llm_connection and
+    test_embedder_connection which are not pytest tests but validator functions.
+    """
+    # Filter out items that are from validators.py and are not in test classes
+    filtered_items = []
+    for item in items:
+        # Get the full path of the test
+        item_path = str(item.fspath) if hasattr(item, "fspath") else str(item.path)
+
+        # Skip the standalone test_llm_connection and test_embedder_connection
+        # functions from validators.py (they're not pytest tests)
+        if item.name in [
+            "test_llm_connection",
+            "test_embedder_connection",
+            "test_ollama_connection",
+        ]:
+            # Check if it's from validators.py
+            if "validators.py" in item_path or "test_providers.py" in item_path:
+                # Only skip if it's a standalone function (not in a TestClass)
+                if not item.parent.name.startswith("Test"):
+                    continue
+
+        filtered_items.append(item)
+
+    items[:] = filtered_items
+
+
+# =============================================================================
+# External Dependency Mocks
+# =============================================================================
+
+
+@pytest.fixture
+def mock_graphiti_core():
+    """Mock graphiti_core.Graphiti and related classes.
+
+    Patches the graphiti_core library to prevent actual graph database connections
+    during tests.
+
+    Yields:
+        tuple: (mock_graphiti_class, mock_graphiti_instance)
+    """
+    with patch(
+        "integrations.graphiti.queries_pkg.graphiti.graphiti_core.Graphiti"
+    ) as mock_graphiti:
+        # Configure the mock to return a mock instance
+        mock_instance = MagicMock()
+        mock_graphiti.return_value = mock_instance
+
+        # Mock common methods that might be called
+        mock_instance.add_edges = AsyncMock()
+        mock_instance.add_nodes = AsyncMock()
+        mock_instance.search = AsyncMock(return_value=[])
+        mock_instance.delete_graph = AsyncMock()
+        mock_instance.close = AsyncMock()
+
+        yield mock_graphiti, mock_instance
+
+
+@pytest.fixture
+def mock_falkor_driver():
+    """Mock graphiti_core.driver.falkordb_driver.FalkorDriver.
+
+    Prevents actual FalkorDB connections during tests.
+
+    Yields:
+        tuple: (mock_driver_class, mock_driver_instance)
+    """
+    with patch(
+        "integrations.graphiti.queries_pkg.graphiti.graphiti_core.driver.falkordb_driver.FalkorDriver"
+    ) as mock_driver:
+        mock_instance = MagicMock()
+        mock_driver.return_value = mock_instance
+
+        # Mock driver methods
+        mock_instance.close = MagicMock()
+        mock_instance.execute_query = MagicMock(return_value=[])
+
+        yield mock_driver, mock_instance
+
+
+@pytest.fixture
+def mock_graphiti_providers():
+    """Mock graphiti_providers module.
+
+    Patches the graphiti_providers module to prevent actual LLM/embedder calls.
+
+    Yields:
+        tuple: (mock_get_client, mock_client_instance)
+    """
+    with patch(
+        "integrations.graphiti.providers_pkg.providers.get_client"
+    ) as mock_get_client:
+        mock_client = MagicMock()
+        mock_get_client.return_value = mock_client
+        yield mock_get_client, mock_client
+
+
+@pytest.fixture
+def mock_ladybug_db():
+    """Mock real_ladybug and kuzu database connections.
+
+    Prevents actual database connections during tests.
+
+    Yields:
+        dict: Dictionary with 'ladybug' and 'kuzu' keys, each containing
+              (mock_class, mock_instance) tuples.
+    """
+    with (
+        patch(
+            "integrations.graphiti.queries_pkg.client.real_ladybug.Ladybug"
+        ) as mock_ladybug,
+        patch("integrations.graphiti.queries_pkg.client.kuzu.Connection") as mock_kuzu,
+    ):
+        # Mock Ladybug instance
+        ladybug_instance = MagicMock()
+        mock_ladybug.return_value = ladybug_instance
+        ladybug_instance.close = MagicMock()
+
+        # Mock Kuzu connection
+        kuzu_instance = MagicMock()
+        mock_kuzu.return_value = kuzu_instance
+        kuzu_instance.close = MagicMock()
+
+        yield {
+            "ladybug": (mock_ladybug, ladybug_instance),
+            "kuzu": (mock_kuzu, kuzu_instance),
+        }
+
+
+# =============================================================================
+# Config Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_config():
+    """Return a GraphitiConfig with test values.
+
+    Provides a test configuration that doesn't require real environment variables
+    or database connections.
+
+    Returns:
+        GraphitiConfig: Configuration with test values.
+    """
+    from integrations.graphiti.config import GraphitiConfig
+
+    config = GraphitiConfig(
+        enabled=True,
+        database="test_dataset",
+        db_path="/tmp/test_graphiti.db",
+        llm_provider="openai",
+        openai_model="gpt-5-mini",
+        embedder_provider="openai",
+        openai_embedding_model="text-embedding-3-small",
+        openai_api_key="sk-test-key-for-testing",
+    )
+
+    return config
+
+
+@pytest.fixture
+def mock_env_vars(tmp_path):
+    """Set test environment variables for Graphiti configuration.
+
+    Sets up a clean environment with test values for all Graphiti-related
+    environment variables.
+
+    Yields:
+        dict: Dictionary of environment variables that were set.
+    """
+    test_db_path = str(tmp_path / "test_graphiti.db")
+
+    env_vars = {
+        "GRAPHITI_ENABLED": "true",
+        "GRAPHITI_LLM_PROVIDER": "openai",
+        "GRAPHITI_EMBEDDER_PROVIDER": "openai",
+        "GRAPHITI_DATABASE": "test_dataset",
+        "GRAPHITI_DB_PATH": test_db_path,
+        "OPENAI_MODEL": "gpt-5-mini",
+        "OPENAI_EMBEDDING_MODEL": "text-embedding-3-small",
+        "OPENAI_API_KEY": "sk-test-key-for-testing",
+    }
+
+    # Save original values
+    original = {k: os.environ.get(k) for k in env_vars}
+
+    # Set test values
+    for key, value in env_vars.items():
+        os.environ[key] = value
+
+    yield env_vars
+
+    # Restore original values
+    for key, original_value in original.items():
+        if original_value is None:
+            os.environ.pop(key, None)
+        else:
+            os.environ[key] = original_value
+
+
+# =============================================================================
+# Client Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_graphiti_client():
+    """Mock GraphitiClient with all necessary methods.
+
+    Provides a mock client that simulates the behavior of the GraphitiClient
+    without requiring actual graph database connections.
+
+    Returns:
+        Mock: Mocked GraphitiClient with typical methods mocked.
+    """
+    client = Mock()
+    client.graphiti = Mock()
+
+    # Core client methods
+    client.is_initialized = Mock(return_value=True)
+    client.initialize = AsyncMock()
+    client.get_session_id = Mock(return_value="test_session")
+    client.get_user_id = Mock(return_value="test_user")
+    client.get_project_id = Mock(return_value="test_project")
+
+    # Memory operations (async)
+    client.add_episode = AsyncMock(return_value="episode_id_123")
+    client.add_episodic_memories = AsyncMock(return_value=["mem_id_1", "mem_id_2"])
+    client.add_abstract_memories = AsyncMock(return_value=["abstract_id_1"])
+    client.search = AsyncMock(return_value=[])
+    client.delete_graph = AsyncMock()
+
+    # Graphiti instance methods
+    client.graphiti.search = AsyncMock(return_value=[])
+
+    # Configuration
+    client.get_config = Mock(
+        return_value=Mock(
+            enabled=True, database="test_dataset", db_path="/tmp/test_graphiti.db"
+        )
+    )
+
+    return client
+
+
+@pytest.fixture
+def mock_graphiti_instance():
+    """Mock the Graphiti instance from graphiti_core.
+
+    Provides a mock of the actual Graphiti core instance with all methods
+    that might be called during operations.
+
+    Returns:
+        Mock: Mocked Graphiti instance with typical methods mocked.
+    """
+    instance = MagicMock()
+
+    # Search methods (async)
+    instance.search = AsyncMock(return_value=[])
+    instance.search_by_abstract = AsyncMock(return_value=[])
+    instance.search_by_vector = AsyncMock(return_value=[])
+
+    # Add methods (async)
+    instance.add_episode = AsyncMock(return_value="episode_id")
+    instance.add_edges = AsyncMock()
+    instance.add_nodes = AsyncMock()
+
+    # Graph management
+    instance.delete_graph = AsyncMock()
+    instance.close = AsyncMock()
+    instance.get_graph_summary = Mock(return_value={"nodes": 0, "edges": 0})
+
+    # Configuration
+    instance.database = "test_dataset"
+
+    return instance
+
+
+# =============================================================================
+# Test Directory Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def temp_spec_dir(tmp_path):
+    """Create a temporary directory for spec testing.
+
+    Provides a temporary directory with spec-like structure for testing
+    spec-related functionality.
+
+    Args:
+        tmp_path: pytest's built-in tmp_path fixture.
+
+    Returns:
+        Path: Path to the temporary spec directory.
+    """
+    spec_dir = tmp_path / "spec_001_test"
+    spec_dir.mkdir()
+
+    # Create common spec subdirectories
+    (spec_dir / ".auto-claude").mkdir()
+    (spec_dir / "context").mkdir()
+
+    return spec_dir
+
+
+@pytest.fixture
+def temp_project_dir(tmp_path):
+    """Create a temporary directory for project testing.
+
+    Provides a temporary directory with project-like structure for testing
+    project-related functionality.
+
+    Args:
+        tmp_path: pytest's built-in tmp_path fixture.
+
+    Returns:
+        Path: Path to the temporary project directory.
+    """
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+
+    # Create common project subdirectories
+    (project_dir / "src").mkdir()
+    (project_dir / "tests").mkdir()
+    (project_dir / ".auto-claude").mkdir()
+
+    return project_dir
+
+
+@pytest.fixture
+def temp_db_path(tmp_path):
+    """Create a temporary path for test database.
+
+    Provides a temporary file path that can be used for database testing
+    without affecting real databases.
+
+    Args:
+        tmp_path: pytest's built-in tmp_path fixture.
+
+    Returns:
+        str: Path to temporary database file.
+    """
+    db_path = str(tmp_path / "test_graphiti.db")
+    return db_path
+
+
+# =============================================================================
+# Provider Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_llm_client():
+    """Mocked LLM client for testing.
+
+    Provides a mock client that simulates LLM responses without making
+    actual API calls.
+
+    Returns:
+        Mock: Mocked LLM client.
+    """
+    client = Mock()
+
+    # Message methods
+    client.messages = Mock()
+    mock_response = Mock()
+    mock_response.id = "msg_test_123"
+    mock_response.content = []
+    mock_response.model = "claude-3-5-sonnet-20241022"
+    mock_response.role = "assistant"
+    client.messages.create = Mock(return_value=mock_response)
+
+    # Streaming support
+    client.messages.stream = Mock(return_value=iter([]))
+
+    # Token counting
+    client.count_tokens = Mock(return_value=100)
+
+    return client
+
+
+@pytest.fixture
+def mock_embedder():
+    """Mocked embedder with get_embedding() method.
+
+    Provides a mock embedder that returns fake embeddings without making
+    actual API calls. Uses deterministic values for reproducibility.
+
+    Returns:
+        tuple: (mock_embedder, test_embedding_list)
+    """
+    embedder = Mock()
+
+    # Return a deterministic embedding vector (1536 dimensions is common for OpenAI)
+    # Using 0.1 for all values makes tests reproducible
+    test_embedding = [0.1] * 1536
+
+    embedder.get_embedding = Mock(return_value=test_embedding)
+    embedder.get_embeddings = Mock(return_value=[test_embedding])
+
+    return embedder, test_embedding
+
+
+# =============================================================================
+# State Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_state():
+    """GraphitiState with test values.
+
+    Provides a mock state object with typical values for testing state-related
+    functionality.
+
+    Returns:
+        Mock: Mocked GraphitiState with test values.
+    """
+    from integrations.graphiti.config import GraphitiState
+
+    state = GraphitiState(
+        initialized=True,
+        database="test_dataset",
+        indices_built=True,
+        llm_provider="openai",
+        embedder_provider="openai",
+    )
+
+    return state
+
+
+@pytest.fixture
+def mock_empty_state():
+    """Empty GraphitiState.
+
+    Provides a mock state object with default/uninitialized values for testing
+    initialization logic.
+
+    Returns:
+        Mock: Mocked GraphitiState with empty/default values.
+    """
+    from integrations.graphiti.config import GraphitiState
+
+    state = GraphitiState()
+
+    return state
+
+
+# =============================================================================
+# Test Data Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def sample_episode_data():
+    """Sample episode data for testing.
+
+    Provides realistic episode data structure for testing memory operations.
+
+    Returns:
+        dict: Sample episode data.
+    """
+    return {
+        "episode_id": "episode_123",
+        "content": "Test episode content about a feature implementation",
+        "metadata": {
+            "task_id": "task_001",
+            "timestamp": "2024-01-01T00:00:00Z",
+            "type": "implementation",
+        },
+        "session_id": "test_session",
+        "user_id": "test_user",
+    }
+
+
+@pytest.fixture
+def sample_memory_nodes():
+    """Sample memory nodes for testing.
+
+    Provides realistic node data for testing graph operations.
+
+    Returns:
+        list: List of sample memory node dictionaries.
+    """
+    return [
+        {
+            "uuid": "node_1",
+            "name": "Feature Implementation",
+            "label": "CONCEPT",
+            "summary": "Implementation of new feature",
+            "created_at": "2024-01-01T00:00:00Z",
+        },
+        {
+            "uuid": "node_2",
+            "name": "Bug Fix",
+            "label": "CONCEPT",
+            "summary": "Fixed critical bug",
+            "created_at": "2024-01-02T00:00:00Z",
+        },
+    ]
+
+
+@pytest.fixture
+def sample_search_results():
+    """Sample search results for testing.
+
+    Provides realistic search result data for testing search operations.
+
+    Returns:
+        list: List of sample search result dictionaries.
+    """
+    return [
+        {
+            "uuid": "result_1",
+            "name": "Search Result 1",
+            "summary": "First search result",
+            "score": 0.95,
+        },
+        {
+            "uuid": "result_2",
+            "name": "Search Result 2",
+            "summary": "Second search result",
+            "score": 0.87,
+        },
+    ]
+
+
+# =============================================================================
+# Helper Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def clean_env():
+    """Fixture to ensure clean environment for each test.
+
+    Removes all Graphiti-related environment variables before the test
+    and restores them afterward.
+
+    Yields:
+        dict: Dictionary of original environment values.
+    """
+    # Store original env vars
+    env_keys = [
+        "GRAPHITI_ENABLED",
+        "GRAPHITI_LLM_PROVIDER",
+        "GRAPHITI_EMBEDDER_PROVIDER",
+        "GRAPHITI_DATABASE",
+        "GRAPHITI_DB_PATH",
+        "OPENAI_API_KEY",
+        "OPENAI_MODEL",
+        "OPENAI_EMBEDDING_MODEL",
+        "ANTHROPIC_API_KEY",
+        "GRAPHITI_ANTHROPIC_MODEL",
+        "AZURE_OPENAI_API_KEY",
+        "AZURE_OPENAI_BASE_URL",
+        "AZURE_OPENAI_LLM_DEPLOYMENT",
+        "AZURE_OPENAI_EMBEDDING_DEPLOYMENT",
+        "VOYAGE_API_KEY",
+        "VOYAGE_EMBEDDING_MODEL",
+        "GOOGLE_API_KEY",
+        "GOOGLE_LLM_MODEL",
+        "GOOGLE_EMBEDDING_MODEL",
+        "OPENROUTER_API_KEY",
+        "OPENROUTER_BASE_URL",
+        "OPENROUTER_LLM_MODEL",
+        "OPENROUTER_EMBEDDING_MODEL",
+        "OLLAMA_BASE_URL",
+        "OLLAMA_LLM_MODEL",
+        "OLLAMA_EMBEDDING_MODEL",
+        "OLLAMA_EMBEDDING_DIM",
+    ]
+
+    original = {}
+    for key in env_keys:
+        original[key] = os.environ.get(key)
+        if key in os.environ:
+            os.environ.pop(key)
+
+    yield original
+
+    # Restore original values
+    for key, value in original.items():
+        if value is not None:
+            os.environ[key] = value

apps/backend/integrations/graphiti/tests/test_cross_encoder.py

@@ -0,0 +1,216 @@
+"""
+Tests for integrations.graphiti.providers_pkg.cross_encoder module.
+
+Tests cover:
+1. create_cross_encoder():
+   - Returns None for non-Ollama providers
+   - Returns None when llm_client is None
+   - Returns None on ImportError (graphiti_core not available)
+   - Returns None on Exception during creation
+   - Creates correct base_url for Ollama
+   - Creates LLMConfig with correct parameters
+"""
+
+import builtins
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# =============================================================================
+# Test Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_config():
+    """Mock GraphitiConfig."""
+    config = MagicMock()
+    config.llm_provider = "ollama"
+    config.ollama_base_url = "http://localhost:11434"
+    config.ollama_llm_model = "llama3.2"
+    return config
+
+
+@pytest.fixture
+def mock_llm_client():
+    """Mock LLM client."""
+    return MagicMock()
+
+
+@pytest.fixture
+def graphiti_core_mocks():
+    """Mock graphiti_core modules and capture LLMConfig calls."""
+    captured_config = {}
+
+    def capture_llm_config(**kwargs):
+        captured_config.update(kwargs)
+        return MagicMock()
+
+    with patch.dict(
+        "sys.modules",
+        {
+            "graphiti_core": MagicMock(),
+            "graphiti_core.cross_encoder": MagicMock(),
+            "graphiti_core.cross_encoder.openai_reranker_client": MagicMock(),
+            "graphiti_core.llm_client": MagicMock(),
+            "graphiti_core.llm_client.config": MagicMock(),
+        },
+    ):
+        from graphiti_core.cross_encoder.openai_reranker_client import (
+            OpenAIRerankerClient,
+        )
+        from graphiti_core.llm_client.config import LLMConfig
+
+        LLMConfig.side_effect = capture_llm_config
+        OpenAIRerankerClient.return_value = MagicMock()
+
+        yield captured_config
+
+
+# =============================================================================
+# Test create_cross_encoder()
+# =============================================================================
+
+
+class TestCreateCrossEncoder:
+    """Tests for create_cross_encoder() function."""
+
+    def test_returns_none_for_non_ollama_provider(self, mock_config, mock_llm_client):
+        """Test create_cross_encoder returns None for non-Ollama providers."""
+        mock_config.llm_provider = "openai"
+
+        import integrations.graphiti.providers_pkg.cross_encoder as ce_module
+
+        # The function returns None for non-ollama providers
+        result = ce_module.create_cross_encoder(mock_config, mock_llm_client)
+
+        assert result is None
+
+    def test_returns_none_for_anthropic_provider(self, mock_config, mock_llm_client):
+        """Test create_cross_encoder returns None for Anthropic provider."""
+        mock_config.llm_provider = "anthropic"
+
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        result = create_cross_encoder(mock_config, mock_llm_client)
+
+        assert result is None
+
+    def test_returns_none_for_google_provider(self, mock_config, mock_llm_client):
+        """Test create_cross_encoder returns None for Google provider."""
+        mock_config.llm_provider = "google"
+
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        result = create_cross_encoder(mock_config, mock_llm_client)
+
+        assert result is None
+
+    def test_returns_none_when_llm_client_is_none(self, mock_config):
+        """Test create_cross_encoder returns None when llm_client is None."""
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        result = create_cross_encoder(mock_config, llm_client=None)
+
+        assert result is None
+
+    def test_base_url_without_v1_gets_suffix_added(
+        self, mock_config, mock_llm_client, graphiti_core_mocks
+    ):
+        """Test that base_url without /v1 gets /v1 suffix added."""
+        mock_config.ollama_base_url = "http://localhost:11434"
+
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        _ = create_cross_encoder(mock_config, mock_llm_client)
+
+        # Verify base_url was captured and has /v1 suffix added
+        assert "base_url" in graphiti_core_mocks
+        assert graphiti_core_mocks["base_url"] == "http://localhost:11434/v1"
+
+    def test_base_url_with_v1_is_preserved(
+        self, mock_config, mock_llm_client, graphiti_core_mocks
+    ):
+        """Test that base_url with /v1 suffix is preserved."""
+        mock_config.ollama_base_url = "http://localhost:11434/v1"
+
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        _ = create_cross_encoder(mock_config, mock_llm_client)
+
+        # Verify base_url was preserved with /v1 suffix
+        assert "base_url" in graphiti_core_mocks
+        assert graphiti_core_mocks["base_url"] == "http://localhost:11434/v1"
+
+    def test_import_error_returns_none(self, mock_config, mock_llm_client):
+        """Test create_cross_encoder returns None when graphiti_core modules not available."""
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        # Mock the import to raise ImportError
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "graphiti_core.cross_encoder.openai_reranker_client":
+                raise ImportError("graphiti_core not installed")
+            if name == "graphiti_core.llm_client.config":
+                raise ImportError("graphiti_core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            result = create_cross_encoder(mock_config, mock_llm_client)
+
+        assert result is None
+
+    def test_exception_during_creation_returns_none(self, mock_config, mock_llm_client):
+        """Test create_cross_encoder returns None on exception during creation."""
+        from integrations.graphiti.providers_pkg.cross_encoder import (
+            create_cross_encoder,
+        )
+
+        # Mock the graphiti_core modules but make LLMConfig raise an exception
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.cross_encoder": MagicMock(),
+                "graphiti_core.cross_encoder.openai_reranker_client": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.config": MagicMock(),
+            },
+        ):
+            from graphiti_core.llm_client.config import LLMConfig
+
+            # Make LLMConfig raise an exception
+            LLMConfig.side_effect = Exception("Config creation failed")
+
+            result = create_cross_encoder(mock_config, mock_llm_client)
+
+        assert result is None
+
+
+# =============================================================================
+# Test module exports
+# =============================================================================
+
+
+class TestModuleExports:
+    """Tests for cross_encoder module exports."""
+
+    def test_create_cross_encoder_is_exported(self):
+        """Test that create_cross_encoder is exported from module."""
+        from integrations.graphiti.providers_pkg import cross_encoder
+
+        assert hasattr(cross_encoder, "create_cross_encoder")
+        assert callable(cross_encoder.create_cross_encoder)

apps/backend/integrations/graphiti/tests/test_init.py

@@ -0,0 +1,238 @@
+"""
+Tests for integrations.graphiti.__init__ module.
+
+Tests cover:
+- __getattr__ lazy import functionality
+- Direct imports (GraphitiConfig, validate_graphiti_config)
+- Invalid attribute access raises AttributeError
+"""
+
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+
+class TestInitModuleDirectImports:
+    """Test direct imports that don't require lazy loading."""
+
+    def test_import_graphiti_config_directly(self):
+        """Test GraphitiConfig can be imported directly."""
+        from integrations.graphiti import GraphitiConfig
+
+        assert GraphitiConfig is not None
+
+    def test_import_validate_graphiti_config_directly(self):
+        """Test validate_graphiti_config can be imported directly."""
+        from integrations.graphiti import validate_graphiti_config
+
+        assert validate_graphiti_config is not None
+
+    def test___all___exports(self):
+        """Test __all__ contains expected exports."""
+        import integrations.graphiti as graphiti_module
+
+        expected_all = [
+            "GraphitiConfig",
+            "validate_graphiti_config",
+            "GraphitiMemory",
+            "create_llm_client",
+            "create_embedder",
+        ]
+        assert graphiti_module.__all__ == expected_all
+
+
+class TestInitModuleLazyImports:
+    """Test __getattr__ lazy import functionality."""
+
+    @pytest.fixture
+    def mock_memory_module(self):
+        """Mock the memory module."""
+        memory_mock = MagicMock()
+        memory_mock.GraphitiMemory = MagicMock
+        return memory_mock
+
+    @pytest.fixture
+    def mock_providers_module(self):
+        """Mock the providers module."""
+        providers_mock = MagicMock()
+        providers_mock.create_llm_client = MagicMock(return_value=AsyncMock())
+        providers_mock.create_embedder = MagicMock(return_value=AsyncMock())
+        return providers_mock
+
+    def test_getattr_graphiti_memory_lazy_import(self, mock_memory_module):
+        """Test accessing GraphitiMemory triggers lazy import."""
+        import integrations.graphiti as graphiti_module
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "integrations.graphiti.memory": mock_memory_module,
+            },
+        ):
+            # Access the attribute via __getattr__
+            result = graphiti_module.__getattr__("GraphitiMemory")
+
+            assert result == mock_memory_module.GraphitiMemory
+
+    def test_getattr_create_llm_client_lazy_import(self, mock_providers_module):
+        """Test accessing create_llm_client triggers lazy import."""
+        import integrations.graphiti as graphiti_module
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "integrations.graphiti.providers": mock_providers_module,
+            },
+        ):
+            result = graphiti_module.__getattr__("create_llm_client")
+
+            assert result == mock_providers_module.create_llm_client
+
+    def test_getattr_create_embedder_lazy_import(self, mock_providers_module):
+        """Test accessing create_embedder triggers lazy import."""
+        import integrations.graphiti as graphiti_module
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "integrations.graphiti.providers": mock_providers_module,
+            },
+        ):
+            result = graphiti_module.__getattr__("create_embedder")
+
+            assert result == mock_providers_module.create_embedder
+
+    def test_getattr_invalid_attribute_raises_attribute_error(self):
+        """Test accessing invalid attribute raises AttributeError."""
+        import integrations.graphiti as graphiti_module
+
+        with pytest.raises(AttributeError) as exc_info:
+            graphiti_module.__getattr__("NonExistentAttribute")
+
+        assert "has no attribute" in str(exc_info.value)
+        assert "NonExistentAttribute" in str(exc_info.value)
+
+    def test_getattr_empty_string_attribute(self):
+        """Test accessing empty string attribute raises AttributeError."""
+        import integrations.graphiti as graphiti_module
+
+        with pytest.raises(AttributeError):
+            graphiti_module.__getattr__("")
+
+    def test_getattr_case_sensitive(self):
+        """Test that __getattr__ is case-sensitive."""
+        import integrations.graphiti as graphiti_module
+
+        # lowercase should fail
+        with pytest.raises(AttributeError):
+            graphiti_module.__getattr__("graphitimemory")
+
+        # mixed case should fail
+        with pytest.raises(AttributeError):
+            graphiti_module.__getattr__("Graphiti_Memory")
+
+
+class TestInitModuleAccessPatterns:
+    """Test various access patterns for the init module."""
+
+    def test_hasattr_on_graphiti_memory(self):
+        """Test hasattr works correctly with lazy imports."""
+        import integrations.graphiti as graphiti_module
+
+        # Mock the import
+        with patch.dict(
+            "sys.modules",
+            {
+                "integrations.graphiti.memory": MagicMock(GraphitiMemory=MagicMock),
+            },
+        ):
+            # hasattr should call __getattr__ and not raise
+            result = hasattr(graphiti_module, "GraphitiMemory")
+            assert result is True
+
+    def test_hasattr_on_invalid_attribute(self):
+        """Test hasattr returns False for invalid attributes."""
+        import integrations.graphiti as graphiti_module
+
+        result = hasattr(graphiti_module, "InvalidAttribute")
+        assert result is False
+
+    def test_getattr_on_existing_direct_import(self):
+        """Test __getattr__ is not called for direct imports."""
+        import integrations.graphiti as graphiti_module
+
+        # GraphitiConfig is imported directly, so __getattr__ shouldn't be called
+        # This tests that the normal import mechanism works
+        assert hasattr(graphiti_module, "GraphitiConfig")
+
+    def test_module_docstring(self):
+        """Test the module has a docstring."""
+        import integrations.graphiti as graphiti_module
+
+        assert graphiti_module.__doc__ is not None
+        assert "Graphiti" in graphiti_module.__doc__
+
+
+class TestInitModuleIntegration:
+    """Integration tests for the init module."""
+
+    def test_import_star(self):
+        """Test 'from integrations.graphiti import *' includes direct imports."""
+        # Create a new namespace for the import
+        namespace = {}
+        exec("from integrations.graphiti import *", namespace)
+
+        # Direct imports should be available
+        assert "GraphitiConfig" in namespace
+        assert "validate_graphiti_config" in namespace
+
+    def test_reimport_does_not_fail(self):
+        """Test that re-importing the module doesn't cause issues."""
+        import importlib
+
+        import integrations.graphiti
+
+        # Reload the module
+        importlib.reload(integrations.graphiti)
+
+        # Should still work
+        assert hasattr(integrations.graphiti, "GraphitiConfig")
+
+    @pytest.mark.slow
+    def test_concurrent_attribute_access(self):
+        """Test that concurrent attribute access doesn't cause issues."""
+        import concurrent.futures
+
+        import integrations.graphiti as graphiti_module
+
+        # Mock the imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "integrations.graphiti.memory": MagicMock(GraphitiMemory=MagicMock),
+                "integrations.graphiti.providers": MagicMock(
+                    create_llm_client=MagicMock(return_value=AsyncMock()),
+                    create_embedder=MagicMock(return_value=AsyncMock()),
+                ),
+            },
+        ):
+
+            def access_attribute(attr_name):
+                try:
+                    return getattr(graphiti_module, attr_name)
+                except AttributeError:
+                    return None
+
+            # Access multiple attributes concurrently
+            with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+                futures = [
+                    executor.submit(access_attribute, "GraphitiMemory"),
+                    executor.submit(access_attribute, "create_llm_client"),
+                    executor.submit(access_attribute, "create_embedder"),
+                ]
+                results = [f.result() for f in concurrent.futures.as_completed(futures)]
+
+            # All should succeed
+            assert len(results) == 3
+            assert all(r is not None for r in results)

apps/backend/integrations/graphiti/tests/test_memory.py

@@ -0,0 +1,425 @@
+"""
+Tests for integrations.graphiti.memory module.
+
+This module is a backward compatibility facade that re-exports from
+queries_pkg and provides convenience functions.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# =============================================================================
+# Test Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_spec_dir(tmp_path):
+    """Create a temporary spec directory."""
+    spec_dir = tmp_path / "specs" / "001-test"
+    spec_dir.mkdir(parents=True)
+    return spec_dir
+
+
+@pytest.fixture
+def mock_project_dir(tmp_path):
+    """Create a temporary project directory."""
+    project_dir = tmp_path / "project"
+    project_dir.mkdir(parents=True)
+    return project_dir
+
+
+# =============================================================================
+# Tests for module imports
+# =============================================================================
+
+
+class TestModuleImports:
+    """Test that all expected exports are available."""
+
+    def test_import_GraphitiMemory(self):
+        """Test GraphitiMemory can be imported."""
+        from integrations.graphiti.memory import GraphitiMemory
+
+        assert GraphitiMemory is not None
+
+    def test_import_GroupIdMode(self):
+        """Test GroupIdMode can be imported."""
+        from integrations.graphiti.memory import GroupIdMode
+
+        assert GroupIdMode is not None
+        assert hasattr(GroupIdMode, "SPEC")
+        assert hasattr(GroupIdMode, "PROJECT")
+
+    def test_import_is_graphiti_enabled(self):
+        """Test is_graphiti_enabled can be imported."""
+        from integrations.graphiti.memory import is_graphiti_enabled
+
+        assert is_graphiti_enabled is not None
+
+    def test_import_get_graphiti_memory(self):
+        """Test get_graphiti_memory can be imported."""
+        from integrations.graphiti.memory import get_graphiti_memory
+
+        assert get_graphiti_memory is not None
+
+    def test_import_test_graphiti_connection(self):
+        """Test test_graphiti_connection can be imported."""
+        from integrations.graphiti.memory import test_graphiti_connection
+
+        assert test_graphiti_connection is not None
+
+    def test_import_test_provider_configuration(self):
+        """Test test_provider_configuration can be imported."""
+        from integrations.graphiti.memory import test_provider_configuration
+
+        assert test_provider_configuration is not None
+
+    def test_import_episode_types(self):
+        """Test all episode type constants can be imported."""
+        from integrations.graphiti.memory import (
+            EPISODE_TYPE_CODEBASE_DISCOVERY,
+            EPISODE_TYPE_GOTCHA,
+            EPISODE_TYPE_HISTORICAL_CONTEXT,
+            EPISODE_TYPE_PATTERN,
+            EPISODE_TYPE_QA_RESULT,
+            EPISODE_TYPE_SESSION_INSIGHT,
+            EPISODE_TYPE_TASK_OUTCOME,
+        )
+
+        assert EPISODE_TYPE_SESSION_INSIGHT == "session_insight"
+        assert EPISODE_TYPE_CODEBASE_DISCOVERY == "codebase_discovery"
+        assert EPISODE_TYPE_PATTERN == "pattern"
+        assert EPISODE_TYPE_GOTCHA == "gotcha"
+        assert EPISODE_TYPE_TASK_OUTCOME == "task_outcome"
+        assert EPISODE_TYPE_QA_RESULT == "qa_result"
+        assert EPISODE_TYPE_HISTORICAL_CONTEXT == "historical_context"
+
+    def test_import_MAX_CONTEXT_RESULTS(self):
+        """Test MAX_CONTEXT_RESULTS can be imported."""
+        from integrations.graphiti.memory import MAX_CONTEXT_RESULTS
+
+        assert MAX_CONTEXT_RESULTS is not None
+
+
+# =============================================================================
+# Tests for get_graphiti_memory()
+# =============================================================================
+
+
+class TestGetGraphitiMemory:
+    """Tests for get_graphiti_memory convenience function."""
+
+    def test_returns_graphiti_memory_instance(self, mock_spec_dir, mock_project_dir):
+        """Test get_graphiti_memory returns GraphitiMemory instance."""
+        from integrations.graphiti.memory import get_graphiti_memory
+
+        memory = get_graphiti_memory(mock_spec_dir, mock_project_dir)
+
+        assert memory is not None
+        assert hasattr(memory, "spec_dir")
+        assert hasattr(memory, "project_dir")
+
+    def test_default_group_id_mode_is_project(self, mock_spec_dir, mock_project_dir):
+        """Test default group_id_mode is PROJECT."""
+        from integrations.graphiti.memory import get_graphiti_memory
+        from integrations.graphiti.queries_pkg.schema import GroupIdMode
+
+        memory = get_graphiti_memory(mock_spec_dir, mock_project_dir)
+
+        # Check that group_id_mode defaults to PROJECT
+        assert memory.group_id_mode == GroupIdMode.PROJECT
+
+    def test_spec_group_id_mode(self, mock_spec_dir, mock_project_dir):
+        """Test SPEC group_id_mode can be set."""
+        from integrations.graphiti.memory import get_graphiti_memory
+        from integrations.graphiti.queries_pkg.schema import GroupIdMode
+
+        memory = get_graphiti_memory(mock_spec_dir, mock_project_dir, GroupIdMode.SPEC)
+
+        assert memory.group_id_mode == GroupIdMode.SPEC
+
+    def test_project_group_id_mode(self, mock_spec_dir, mock_project_dir):
+        """Test PROJECT group_id_mode can be set."""
+        from integrations.graphiti.memory import get_graphiti_memory
+        from integrations.graphiti.queries_pkg.schema import GroupIdMode
+
+        memory = get_graphiti_memory(
+            mock_spec_dir, mock_project_dir, GroupIdMode.PROJECT
+        )
+
+        assert memory.group_id_mode == GroupIdMode.PROJECT
+
+
+# =============================================================================
+# Tests for test_graphiti_connection()
+# =============================================================================
+
+
+class TestTestGraphitiConnection:
+    """Tests for test_graphiti_connection function."""
+
+    @pytest.mark.asyncio
+    async def test_returns_false_when_not_enabled(self):
+        """Test returns False when Graphiti not enabled."""
+        from integrations.graphiti.memory import test_graphiti_connection
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.enabled = False
+            mock_config_class.from_env.return_value = mock_config
+
+            success, message = await test_graphiti_connection()
+
+            assert success is False
+            assert "not enabled" in message.lower()
+
+    @pytest.mark.asyncio
+    async def test_returns_false_with_validation_errors(self):
+        """Test returns False when config has validation errors."""
+        from integrations.graphiti.memory import test_graphiti_connection
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.enabled = True
+            mock_config.get_validation_errors.return_value = ["API key missing"]
+            mock_config_class.from_env.return_value = mock_config
+
+            success, message = await test_graphiti_connection()
+
+            assert success is False
+            assert "Configuration errors" in message
+
+    @pytest.mark.asyncio
+    async def test_returns_false_on_import_error(self):
+        """Test returns False when graphiti_core not installed."""
+        from integrations.graphiti.memory import test_graphiti_connection
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.enabled = True
+            mock_config.get_validation_errors.return_value = []
+            mock_config_class.from_env.return_value = mock_config
+
+            # Only raise ImportError for graphiti_core imports
+            import builtins
+
+            original_import = builtins.__import__
+
+            def selective_import_error(name, *args, **kwargs):
+                if "graphiti_core" in name:
+                    raise ImportError(f"No module named '{name}'")
+                return original_import(name, *args, **kwargs)
+
+            with patch("builtins.__import__", side_effect=selective_import_error):
+                success, message = await test_graphiti_connection()
+
+                assert success is False
+                assert "not installed" in message.lower()
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_returns_true_on_successful_connection(self):
+        """Test returns True when connection succeeds (requires graphiti_core)."""
+        from integrations.graphiti.memory import test_graphiti_connection
+
+        # This test requires graphiti_core to be installed
+        # Marked as slow since it connects to actual database
+        try:
+            success, message = await test_graphiti_connection()
+
+            # If graphiti_core is not installed, success will be False
+            if "not installed" in message.lower():
+                assert success is False
+            # If installed but DB not available, check for connection error
+            elif "connection failed" in message.lower():
+                assert success is False
+            # If everything is set up, should succeed
+            else:
+                # Concrete assertion for successful connection
+                assert success is True, (
+                    f"Expected success=True, got {success} with message: {message}"
+                )
+                assert message, "Message should not be empty for successful connection"
+
+        except AssertionError as e:
+            # Re-raise AssertionError to properly surface test failures
+            raise
+        except Exception as e:
+            # If there's an unexpected error, fail the test with useful info
+            pytest.skip(f"Graphiti connection test failed: {e}")
+
+    @pytest.mark.asyncio
+    async def test_handles_provider_error(self):
+        """Test handles ProviderError during provider creation."""
+        from integrations.graphiti.memory import test_graphiti_connection
+        from integrations.graphiti.providers_pkg.exceptions import ProviderError
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.enabled = True
+            mock_config.get_validation_errors.return_value = []
+            mock_config_class.from_env.return_value = mock_config
+
+            # Mock graphiti_core imports to succeed
+            mock_graphiti = MagicMock()
+            mock_falkordb_driver = MagicMock()
+
+            # Mock provider creation to raise ProviderError
+            with patch("graphiti_providers.create_llm_client") as mock_create_llm:
+                mock_create_llm.side_effect = ProviderError("Test provider error")
+
+                with patch.dict(
+                    "sys.modules",
+                    {
+                        "graphiti_core": MagicMock(Graphiti=mock_graphiti),
+                        "graphiti_core.driver": MagicMock(),
+                        "graphiti_core.driver.falkordb_driver": mock_falkordb_driver,
+                        "graphiti_providers": MagicMock(
+                            ProviderError=ProviderError,
+                            create_embedder=MagicMock(),
+                            create_llm_client=mock_create_llm,
+                        ),
+                    },
+                ):
+                    success, message = await test_graphiti_connection()
+
+                    assert success is False
+                    assert "Provider error" in message
+
+
+# =============================================================================
+# Tests for test_provider_configuration()
+# =============================================================================
+
+
+class TestTestProviderConfiguration:
+    """Tests for test_provider_configuration function."""
+
+    @pytest.mark.asyncio
+    async def test_returns_configuration_status(self):
+        """Test returns dict with configuration status."""
+        pytest.importorskip("graphiti_providers")
+        from integrations.graphiti.memory import test_provider_configuration
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.is_valid.return_value = True
+            mock_config.get_validation_errors.return_value = []
+            mock_config.llm_provider = "openai"
+            mock_config.embedder_provider = "openai"
+            mock_config_class.from_env.return_value = mock_config
+
+            # Mock the test functions
+            with patch(
+                "graphiti_providers.test_llm_connection",
+                return_value=(True, "LLM OK"),
+            ):
+                with patch(
+                    "graphiti_providers.test_embedder_connection",
+                    return_value=(True, "Embedder OK"),
+                ):
+                    results = await test_provider_configuration()
+
+                    assert isinstance(results, dict)
+                    assert results["config_valid"] is True
+                    assert results["validation_errors"] == []
+                    assert results["llm_provider"] == "openai"
+                    assert results["embedder_provider"] == "openai"
+                    assert results["llm_test"]["success"] is True
+                    assert results["embedder_test"]["success"] is True
+
+    @pytest.mark.asyncio
+    async def test_includes_ollama_test_when_ollama_provider(self):
+        """Test includes ollama_test when using ollama provider."""
+        pytest.importorskip("graphiti_providers")
+        from integrations.graphiti.memory import test_provider_configuration
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.is_valid.return_value = True
+            mock_config.get_validation_errors.return_value = []
+            mock_config.llm_provider = "ollama"
+            mock_config.embedder_provider = "openai"
+            mock_config.ollama_base_url = "http://localhost:11434"
+            mock_config_class.from_env.return_value = mock_config
+
+            with patch(
+                "graphiti_providers.test_llm_connection",
+                return_value=(True, "LLM OK"),
+            ):
+                with patch(
+                    "graphiti_providers.test_embedder_connection",
+                    return_value=(True, "Embedder OK"),
+                ):
+                    with patch(
+                        "graphiti_providers.test_ollama_connection",
+                        return_value=(True, "Ollama OK"),
+                    ):
+                        results = await test_provider_configuration()
+
+                        assert "ollama_test" in results
+                        assert results["ollama_test"]["success"] is True
+
+    @pytest.mark.asyncio
+    async def test_omits_ollama_test_when_not_ollama_provider(self):
+        """Test omits ollama_test when not using ollama provider."""
+        pytest.importorskip("graphiti_providers")
+        from integrations.graphiti.memory import test_provider_configuration
+
+        with patch("integrations.graphiti.memory.GraphitiConfig") as mock_config_class:
+            mock_config = MagicMock()
+            mock_config.is_valid.return_value = True
+            mock_config.get_validation_errors.return_value = []
+            mock_config.llm_provider = "openai"
+            mock_config.embedder_provider = "openai"
+            mock_config_class.from_env.return_value = mock_config
+
+            with patch(
+                "graphiti_providers.test_llm_connection",
+                return_value=(True, "LLM OK"),
+            ):
+                with patch(
+                    "graphiti_providers.test_embedder_connection",
+                    return_value=(True, "Embedder OK"),
+                ):
+                    results = await test_provider_configuration()
+
+                    assert "ollama_test" not in results
+
+
+# =============================================================================
+# Tests for __all__ export list
+# =============================================================================
+
+
+class TestAllExports:
+    """Test __all__ contains expected exports."""
+
+    def test_all_exports_defined(self):
+        """Test __all__ is defined and contains expected items."""
+        from integrations.graphiti import memory
+
+        assert hasattr(memory, "__all__")
+        assert isinstance(memory.__all__, list)
+
+        expected_exports = [
+            "GraphitiMemory",
+            "GroupIdMode",
+            "get_graphiti_memory",
+            "is_graphiti_enabled",
+            "test_graphiti_connection",
+            "test_provider_configuration",
+            "MAX_CONTEXT_RESULTS",
+            "EPISODE_TYPE_SESSION_INSIGHT",
+            "EPISODE_TYPE_CODEBASE_DISCOVERY",
+            "EPISODE_TYPE_PATTERN",
+            "EPISODE_TYPE_GOTCHA",
+            "EPISODE_TYPE_TASK_OUTCOME",
+            "EPISODE_TYPE_QA_RESULT",
+            "EPISODE_TYPE_HISTORICAL_CONTEXT",
+        ]
+
+        for export in expected_exports:
+            assert export in memory.__all__, f"{export} not in __all__"

apps/backend/integrations/graphiti/tests/test_provider_naming.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Quick test to demonstrate provider-specific database naming.
+
+Shows how Auto Claude automatically generates provider-specific database names
+to prevent embedding dimension mismatches.
+"""
+
+import pytest
+from integrations.graphiti.config import GraphitiConfig
+
+
+@pytest.mark.parametrize(
+    "provider,model,dim",
+    [
+        ("openai", None, None),
+        ("ollama", "embeddinggemma", 768),
+        ("ollama", "qwen3-embedding:0.6b", 1024),
+        ("voyage", None, None),
+        ("google", None, None),
+    ],
+)
+def test_provider_naming(provider, model, dim):
+    """Demonstrate provider-specific database naming."""
+    # Create explicit config without relying on environment
+    config = GraphitiConfig()
+    config.embedder_provider = provider
+    config.openai_embedding_model = "text-embedding-3-small"
+
+    if provider == "ollama" and model:
+        config.ollama_embedding_model = model
+        if dim is not None:
+            config.ollama_embedding_dim = dim
+    elif provider == "voyage":
+        config.voyage_embedding_model = "voyage-3"
+    elif provider == "google":
+        config.google_embedding_model = "text-embedding-004"
+
+    # Get naming info
+    dimension = config.get_embedding_dimension()
+    signature = config.get_provider_signature()
+    db_name = config.get_provider_specific_database_name("auto_claude_memory")
+
+    # Strengthened assertions with exact expected values where known
+    if provider == "openai":
+        assert dimension == 1536, f"OpenAI dimension should be 1536, got {dimension}"
+        assert "openai" in signature.lower(), "OpenAI signature should contain 'openai'"
+        # Signature format is provider_dimension for openai
+        assert signature == "openai_1536", f"Expected 'openai_1536', got '{signature}'"
+    elif provider == "ollama" and model == "embeddinggemma":
+        assert dimension == 768, (
+            f"Ollama gemma dimension should be 768, got {dimension}"
+        )
+        assert signature == f"ollama_{model}_{dimension}", (
+            f"Expected 'ollama_{model}_{dimension}', got '{signature}'"
+        )
+    elif provider == "ollama" and model == "qwen3-embedding:0.6b":
+        assert dimension == 1024, (
+            f"Ollama qwen dimension should be 1024, got {dimension}"
+        )
+        # Colons in model names are replaced with underscores in signature
+        assert signature == "ollama_qwen3-embedding_0_6b_1024", (
+            f"Expected 'ollama_qwen3-embedding_0_6b_1024', got '{signature}'"
+        )
+    elif provider == "voyage":
+        assert dimension == 1024, f"Voyage dimension should be 1024, got {dimension}"
+        assert signature == "voyage_1024", f"Expected 'voyage_1024', got '{signature}'"
+    elif provider == "google":
+        assert dimension == 768, f"Google dimension should be 768, got {dimension}"
+        assert signature == "google_768", f"Expected 'google_768', got '{signature}'"
+
+    # Verify signature appears in db_name
+    assert signature is not None and signature != "", (
+        f"Signature should be non-empty for {provider}"
+    )
+    assert signature in db_name, (
+        f"Signature '{signature}' should appear in db_name '{db_name}' for {provider}"
+    )

apps/backend/integrations/graphiti/tests/test_providers_azure_openai.py

@@ -0,0 +1,149 @@
+"""
+Unit tests for Azure OpenAI embedder provider.
+
+Tests cover:
+- create_azure_openai_embedder factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.azure_openai_embedder import (
+    create_azure_openai_embedder,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Test create_azure_openai_embedder
+# =============================================================================
+
+
+class TestCreateAzureOpenAIEmbedder:
+    """Test create_azure_openai_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.azure_openai_api_key = "test-azure-key"
+        config.azure_openai_base_url = "https://test.openai.azure.com"
+        config.azure_openai_embedding_deployment = "test-embedding-deployment"
+        return config
+
+    @pytest.mark.slow
+    def test_create_azure_openai_embedder_success(self, mock_config):
+        """Test create_azure_openai_embedder returns embedder with valid config."""
+        mock_azure_client = MagicMock()
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.azure_openai_embedder.AsyncOpenAI",
+            return_value=mock_azure_client,
+        ):
+            with patch(
+                "graphiti_core.embedder.azure_openai.AzureOpenAIEmbedderClient",
+                return_value=mock_embedder,
+            ):
+                result = create_azure_openai_embedder(mock_config)
+                assert result == mock_embedder
+
+    def test_create_azure_openai_embedder_success_fast(self, mock_config):
+        """Fast test for create_azure_openai_embedder success path."""
+        mock_embedder = MagicMock()
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.embedder": MagicMock(),
+                "graphiti_core.embedder.azure_openai": MagicMock(),
+            },
+        ):
+            from graphiti_core.embedder.azure_openai import AzureOpenAIEmbedderClient
+
+            AzureOpenAIEmbedderClient.return_value = mock_embedder
+
+            result = create_azure_openai_embedder(mock_config)
+
+            # Verify the embedder was created and returned
+            AzureOpenAIEmbedderClient.assert_called_once()
+            assert result == mock_embedder
+
+    def test_create_azure_openai_embedder_missing_api_key(self, mock_config):
+        """Test create_azure_openai_embedder raises ProviderError for missing API key."""
+        mock_config.azure_openai_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_embedder(mock_config)
+
+        assert "AZURE_OPENAI_API_KEY" in str(exc_info.value)
+
+    def test_create_azure_openai_embedder_missing_base_url(self, mock_config):
+        """Test create_azure_openai_embedder raises ProviderError for missing base URL."""
+        mock_config.azure_openai_base_url = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_embedder(mock_config)
+
+        assert "AZURE_OPENAI_BASE_URL" in str(exc_info.value)
+
+    def test_create_azure_openai_embedder_missing_deployment(self, mock_config):
+        """Test create_azure_openai_embedder raises ProviderError for missing deployment."""
+        mock_config.azure_openai_embedding_deployment = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_embedder(mock_config)
+
+        assert "AZURE_OPENAI_EMBEDDING_DEPLOYMENT" in str(exc_info.value)
+
+    def test_create_azure_openai_embedder_import_error(self, mock_config):
+        """Test create_azure_openai_embedder raises ProviderNotInstalled on ImportError."""
+        # Mock the import to raise ImportError
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "graphiti_core.embedder.azure_openai":
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_azure_openai_embedder(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_azure_openai_embedder_passes_config_correctly(self, mock_config):
+        """Test create_azure_openai_embedder passes config values correctly."""
+        mock_azure_client = MagicMock()
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.azure_openai_embedder.AsyncOpenAI",
+            return_value=mock_azure_client,
+        ) as mock_openai:
+            with patch(
+                "graphiti_core.embedder.azure_openai.AzureOpenAIEmbedderClient",
+                return_value=mock_embedder,
+            ) as mock_azure_embedder:
+                create_azure_openai_embedder(mock_config)
+
+                # Verify AsyncOpenAI was called with correct arguments
+                mock_openai.assert_called_once_with(
+                    base_url=mock_config.azure_openai_base_url,
+                    api_key=mock_config.azure_openai_api_key,
+                )
+
+                # Verify AzureOpenAIEmbedderClient was called with correct arguments
+                mock_azure_embedder.assert_called_once_with(
+                    azure_client=mock_azure_client,
+                    model=mock_config.azure_openai_embedding_deployment,
+                )

apps/backend/integrations/graphiti/tests/test_providers_facade.py

@@ -0,0 +1,252 @@
+"""
+Tests for integrations.graphiti.providers module.
+
+This module is a re-export facade that re-exports all public APIs
+from the graphiti_providers package.
+"""
+
+import pytest
+
+# Expected exports from integrations.graphiti.providers module
+EXPECTED_EXPORTS = [
+    "ProviderError",
+    "ProviderNotInstalled",
+    "create_llm_client",
+    "create_embedder",
+    "create_cross_encoder",
+    "EMBEDDING_DIMENSIONS",
+    "get_expected_embedding_dim",
+    "validate_embedding_config",
+    "test_llm_connection",
+    "test_embedder_connection",
+    "test_ollama_connection",
+    "is_graphiti_enabled",
+    "get_graph_hints",
+]
+
+# =============================================================================
+# Tests for module imports
+# =============================================================================
+
+
+class TestModuleImports:
+    """Test that all expected exports are available."""
+
+    def test_import_ProviderError(self):
+        """Test ProviderError can be imported."""
+        from integrations.graphiti.providers import ProviderError
+
+        assert ProviderError is not None
+        # Should be an exception class
+        assert issubclass(ProviderError, Exception)
+
+    def test_import_ProviderNotInstalled(self):
+        """Test ProviderNotInstalled can be imported."""
+        from integrations.graphiti.providers import ProviderNotInstalled
+
+        assert ProviderNotInstalled is not None
+        # Should be an exception class
+        assert issubclass(ProviderNotInstalled, Exception)
+
+    def test_import_create_llm_client(self):
+        """Test create_llm_client can be imported."""
+        from integrations.graphiti.providers import create_llm_client
+
+        assert create_llm_client is not None
+        assert callable(create_llm_client)
+
+    def test_import_create_embedder(self):
+        """Test create_embedder can be imported."""
+        from integrations.graphiti.providers import create_embedder
+
+        assert create_embedder is not None
+        assert callable(create_embedder)
+
+    def test_import_create_cross_encoder(self):
+        """Test create_cross_encoder can be imported."""
+        from integrations.graphiti.providers import create_cross_encoder
+
+        assert create_cross_encoder is not None
+        assert callable(create_cross_encoder)
+
+    def test_import_EMBEDDING_DIMENSIONS(self):
+        """Test EMBEDDING_DIMENSIONS can be imported."""
+        from integrations.graphiti.providers import EMBEDDING_DIMENSIONS
+
+        assert EMBEDDING_DIMENSIONS is not None
+        assert isinstance(EMBEDDING_DIMENSIONS, dict)
+
+    def test_import_get_expected_embedding_dim(self):
+        """Test get_expected_embedding_dim can be imported."""
+        from integrations.graphiti.providers import get_expected_embedding_dim
+
+        assert get_expected_embedding_dim is not None
+        assert callable(get_expected_embedding_dim)
+
+    def test_import_validate_embedding_config(self):
+        """Test validate_embedding_config can be imported."""
+        from integrations.graphiti.providers import validate_embedding_config
+
+        assert validate_embedding_config is not None
+        assert callable(validate_embedding_config)
+
+    def test_import_test_llm_connection(self):
+        """Test test_llm_connection can be imported."""
+        from integrations.graphiti.providers import test_llm_connection
+
+        assert test_llm_connection is not None
+        assert callable(test_llm_connection)
+
+    def test_import_test_embedder_connection(self):
+        """Test test_embedder_connection can be imported."""
+        from integrations.graphiti.providers import test_embedder_connection
+
+        assert test_embedder_connection is not None
+        assert callable(test_embedder_connection)
+
+    def test_import_test_ollama_connection(self):
+        """Test test_ollama_connection can be imported."""
+        from integrations.graphiti.providers import test_ollama_connection
+
+        assert test_ollama_connection is not None
+        assert callable(test_ollama_connection)
+
+    def test_import_is_graphiti_enabled(self):
+        """Test is_graphiti_enabled can be imported."""
+        from integrations.graphiti.providers import is_graphiti_enabled
+
+        assert is_graphiti_enabled is not None
+        assert callable(is_graphiti_enabled)
+
+    def test_import_get_graph_hints(self):
+        """Test get_graph_hints can be imported."""
+        from integrations.graphiti.providers import get_graph_hints
+
+        assert get_graph_hints is not None
+        assert callable(get_graph_hints)
+
+
+# =============================================================================
+# Tests for __all__ export list
+# =============================================================================
+
+
+class TestAllExports:
+    """Test __all__ contains expected exports."""
+
+    def test_all_exports_defined(self):
+        """Test __all__ is defined and contains expected items."""
+        from integrations.graphiti import providers
+
+        assert hasattr(providers, "__all__")
+        assert isinstance(providers.__all__, list)
+
+        for export in EXPECTED_EXPORTS:
+            assert export in providers.__all__, f"{export} not in __all__"
+
+    def test_all_exports_count(self):
+        """Test __all__ contains the expected number of exports."""
+        from integrations.graphiti import providers
+
+        # Should have same number of exports as EXPECTED_EXPORTS list
+        assert len(providers.__all__) == len(EXPECTED_EXPORTS)
+
+
+# =============================================================================
+# Tests for module docstring and metadata
+# =============================================================================
+
+
+class TestModuleMetadata:
+    """Test module has proper documentation."""
+
+    def test_module_has_docstring(self):
+        """Test module has docstring."""
+        import integrations.graphiti.providers
+
+        assert integrations.graphiti.providers.__doc__ is not None
+        assert len(integrations.graphiti.providers.__doc__) > 0
+
+
+# =============================================================================
+# Tests for re-export behavior
+# =============================================================================
+
+
+class TestReExportBehavior:
+    """Test that re-exports work correctly."""
+
+    def test_ProviderError_is_exception(self):
+        """Test ProviderError can be raised and caught."""
+        from integrations.graphiti.providers import ProviderError
+
+        with pytest.raises(ProviderError):
+            raise ProviderError("Test error")
+
+    def test_ProviderNotInstalled_is_exception(self):
+        """Test ProviderNotInstalled can be raised and caught."""
+        from integrations.graphiti.providers import ProviderNotInstalled
+
+        with pytest.raises(ProviderNotInstalled):
+            raise ProviderNotInstalled("Test error")
+
+    def test_ProviderNotInstalled_subclass_of_ProviderError(self):
+        """Test ProviderNotInstalled is a subclass of ProviderError."""
+        from integrations.graphiti.providers import ProviderError, ProviderNotInstalled
+
+        assert issubclass(ProviderNotInstalled, ProviderError)
+
+    def test_EMBEDDING_DIMENSIONS_has_expected_keys(self):
+        """Test EMBEDDING_DIMENSIONS has expected model keys."""
+        from integrations.graphiti.providers import EMBEDDING_DIMENSIONS
+
+        # Check that expected model names exist in EMBEDDING_DIMENSIONS
+        # Note: EMBEDDING_DIMENSIONS is keyed by model name, not provider name
+        expected_models = [
+            "text-embedding-3-small",  # OpenAI
+            "voyage-3",  # Voyage AI
+            "nomic-embed-text",  # Ollama
+            "all-minilm",  # Ollama
+        ]
+
+        for model in expected_models:
+            assert model in EMBEDDING_DIMENSIONS, f"{model} not in EMBEDDING_DIMENSIONS"
+            assert isinstance(EMBEDDING_DIMENSIONS[model], int)
+
+
+# =============================================================================
+# Tests for namespace integrity
+# =============================================================================
+
+
+class TestNamespaceIntegrity:
+    """Test module namespace remains consistent."""
+
+    def test_exports_are_accessible(self):
+        """Test all exports in __all__ are accessible."""
+        from integrations.graphiti import providers
+
+        for name in providers.__all__:
+            # Each export should be accessible
+            assert hasattr(providers, name), f"{name} not accessible"
+
+    def test_import_from_module_works(self):
+        """Test 'from' imports work correctly."""
+        # This tests the re-export mechanism
+        from integrations.graphiti.providers import (
+            ProviderError,
+            create_embedder,
+            create_llm_client,
+        )
+
+        assert ProviderError is not None
+        assert create_llm_client is not None
+        assert create_embedder is not None
+
+    def test_module_level_import_works(self):
+        """Test module-level import works."""
+        import integrations.graphiti.providers as providers
+
+        assert providers.ProviderError is not None
+        assert providers.create_llm_client is not None
+        assert providers.create_embedder is not None

apps/backend/integrations/graphiti/tests/test_providers_google.py

@@ -0,0 +1,256 @@
+"""
+Unit tests for Google embedder provider.
+
+Tests cover:
+- create_google_embedder factory function
+- GoogleEmbedder class (create, create_batch methods)
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.google_embedder import (
+    DEFAULT_GOOGLE_EMBEDDING_MODEL,
+    GoogleEmbedder,
+    create_google_embedder,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Pytest fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def google_genai_mock():
+    """Mock google.generativeai module with common setup."""
+    mock_genai = MagicMock()
+    mock_genai.configure = MagicMock()
+    mock_genai.embed_content = MagicMock(return_value={"embedding": [0.1, 0.2, 0.3]})
+    return mock_genai
+
+
+# =============================================================================
+# Test GoogleEmbedder class
+# =============================================================================
+
+
+class TestGoogleEmbedder:
+    """Test GoogleEmbedder class."""
+
+    def test_google_embedder_init_success(self, google_genai_mock):
+        """Test GoogleEmbedder initializes with API key and model."""
+        # Inject mock into sys.modules before importing
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key", model="test-model")
+
+            assert embedder.api_key == "test-key"
+            assert embedder.model == "test-model"
+            google_genai_mock.configure.assert_called_once_with(api_key="test-key")
+
+    def test_google_embedder_init_default_model(self, google_genai_mock):
+        """Test GoogleEmbedder uses default model when not specified."""
+        # Inject mock into sys.modules before importing
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+
+            assert embedder.model == DEFAULT_GOOGLE_EMBEDDING_MODEL
+
+    def test_google_embedder_init_import_error(self):
+        """Test GoogleEmbedder raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "google.generativeai" or name.startswith("google.generativeai."):
+                raise ImportError("google-generativeai not installed")
+            return original_import(name, *args, **kwargs)
+
+        # Remove google.generativeai from sys.modules if present
+        # to ensure the import actually goes through __import__
+        with patch.dict(sys.modules, {"google.generativeai": None}):
+            with patch("builtins.__import__", side_effect=mock_import):
+                with pytest.raises(ProviderNotInstalled) as exc_info:
+                    GoogleEmbedder(api_key="test-key")
+
+                assert "google-generativeai" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_with_string(self, google_genai_mock):
+        """Test GoogleEmbedder.create with string input."""
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            result = await embedder.create("test text")
+
+            assert result == [0.1, 0.2, 0.3]
+            # Assert embed_content was called
+            google_genai_mock.embed_content.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_with_list(self, google_genai_mock):
+        """Test GoogleEmbedder.create with list input."""
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            result = await embedder.create(["test", "text"])
+
+            assert result == [0.1, 0.2, 0.3]
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_with_non_string_list(self, google_genai_mock):
+        """Test GoogleEmbedder.create with non-string list items (lines 71-73)."""
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            # List with non-string items - should convert to string
+            result = await embedder.create([123, 456])
+
+            assert result == [0.1, 0.2, 0.3]
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_with_empty_list(self, google_genai_mock):
+        """Test GoogleEmbedder.create with empty or invalid input (line 75)."""
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            # Empty list - should be converted to string
+            result = await embedder.create([])
+
+            assert result == [0.1, 0.2, 0.3]
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_batch(self, google_genai_mock):
+        """Test GoogleEmbedder.create_batch with multiple inputs (lines 100-127)."""
+        # Override embed_content return value for batch test
+        google_genai_mock.embed_content = MagicMock(
+            return_value={"embedding": [[0.1, 0.2], [0.3, 0.4]]}
+        )
+
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            result = await embedder.create_batch(["text1", "text2"])
+
+            # Should handle nested list response (lines 122-125)
+            assert len(result) == 2
+
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_batch_single_response(
+        self, google_genai_mock
+    ):
+        """Test GoogleEmbedder.create_batch with single embedding response (lines 124-125)."""
+        # Override embed_content return value for single response test
+        google_genai_mock.embed_content = MagicMock(
+            return_value={"embedding": [0.1, 0.2, 0.3]}
+        )
+
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            result = await embedder.create_batch(["text1"])
+
+            # Should handle single embedding response (line 125)
+            assert len(result) == 1
+            assert result[0] == [0.1, 0.2, 0.3]
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_google_embedder_create_batch_large_input(self, google_genai_mock):
+        """Test GoogleEmbedder.create_batch with >100 items (batching)."""
+        # Override embed_content return value for large batch test
+        google_genai_mock.embed_content = MagicMock(
+            return_value={"embedding": [[0.1, 0.2]]}
+        )
+
+        with patch.dict(sys.modules, {"google.generativeai": google_genai_mock}):
+            embedder = GoogleEmbedder(api_key="test-key")
+            # Create 250 items - should be split into 3 batches (100, 100, 50)
+            result = await embedder.create_batch([f"text{i}" for i in range(250)])
+
+            # Should call embed_content 3 times
+            assert google_genai_mock.embed_content.call_count == 3
+
+
+# =============================================================================
+# Test create_google_embedder
+# =============================================================================
+
+
+class TestCreateGoogleEmbedder:
+    """Test create_google_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.google_api_key = "test-google-key"
+        config.google_embedding_model = None
+        return config
+
+    def test_create_google_embedder_success(self, mock_config):
+        """Test create_google_embedder returns embedder with valid config."""
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.google_embedder.GoogleEmbedder",
+            return_value=mock_embedder,
+        ):
+            result = create_google_embedder(mock_config)
+            assert result == mock_embedder
+
+    def test_create_google_embedder_missing_api_key(self, mock_config):
+        """Test create_google_embedder raises ProviderError for missing API key."""
+        mock_config.google_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_google_embedder(mock_config)
+
+        assert "GOOGLE_API_KEY" in str(exc_info.value)
+
+    def test_create_google_embedder_with_custom_model(self, mock_config):
+        """Test create_google_embedder uses custom model when specified."""
+        mock_config.google_embedding_model = "custom-model"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.google_embedder.GoogleEmbedder",
+            return_value=mock_embedder,
+        ) as mock_google_embedder:
+            create_google_embedder(mock_config)
+
+            mock_google_embedder.assert_called_once_with(
+                api_key=mock_config.google_api_key,
+                model="custom-model",
+            )
+
+    def test_create_google_embedder_with_default_model(self, mock_config):
+        """Test create_google_embedder uses default model when not specified."""
+        mock_config.google_embedding_model = None
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.google_embedder.GoogleEmbedder",
+            return_value=mock_embedder,
+        ) as mock_google_embedder:
+            create_google_embedder(mock_config)
+
+            mock_google_embedder.assert_called_once_with(
+                api_key=mock_config.google_api_key,
+                model=DEFAULT_GOOGLE_EMBEDDING_MODEL,
+            )
+
+
+# =============================================================================
+# Test Constants
+# =============================================================================
+
+
+class TestGoogleEmbedderConstants:
+    """Test Google embedder constants."""
+
+    def test_default_google_embedding_model(self):
+        # Note: This test verifies the default Google embedding model.
+        # The value should match the model used in production.
+        assert DEFAULT_GOOGLE_EMBEDDING_MODEL == "text-embedding-004"

apps/backend/integrations/graphiti/tests/test_providers_llm_anthropic.py

@@ -0,0 +1,146 @@
+"""
+Unit tests for Anthropic LLM provider.
+
+Tests cover:
+- create_anthropic_llm_client factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.anthropic_llm import (
+    create_anthropic_llm_client,
+)
+
+# =============================================================================
+# Test create_anthropic_llm_client
+# =============================================================================
+
+
+class TestCreateAnthropicLLMClient:
+    """Test create_anthropic_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.anthropic_api_key = "sk-ant-test-key"
+        config.anthropic_model = "claude-sonnet-4-20250514"
+        return config
+
+    @pytest.mark.slow
+    def test_create_anthropic_llm_client_success(self, mock_config):
+        """Test create_anthropic_llm_client returns client with valid config."""
+        mock_client = MagicMock()
+
+        # Patch at the location where the import happens (local import inside function)
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.anthropic_llm.AnthropicClient",
+            return_value=mock_client,
+        ):
+            result = create_anthropic_llm_client(mock_config)
+            assert result == mock_client
+
+    def test_create_anthropic_llm_client_success_fast(self, mock_config):
+        """Fast test for create_anthropic_llm_client success path."""
+        mock_llm_client = MagicMock()
+
+        # Create the config mock
+        mock_config_module = MagicMock()
+        mock_config_module.LLMConfig = MagicMock
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.anthropic_client": MagicMock(),
+                "graphiti_core.llm_client.config": mock_config_module,
+            },
+        ):
+            from graphiti_core.llm_client.anthropic_client import AnthropicClient
+
+            AnthropicClient.return_value = mock_llm_client
+
+            result = create_anthropic_llm_client(mock_config)
+
+            # Verify the client was created and returned
+            AnthropicClient.assert_called_once()
+            assert result == mock_llm_client
+
+    def test_create_anthropic_llm_client_missing_api_key_fast(self, mock_config):
+        """Fast test for API key validation (line 41)."""
+        # Mock the graphiti_core imports first to avoid ImportError
+        mock_config_module = MagicMock()
+        mock_config_module.LLMConfig = MagicMock
+
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.anthropic_client": MagicMock(),
+                "graphiti_core.llm_client.config": mock_config_module,
+            },
+        ):
+            from graphiti_core.llm_client.anthropic_client import AnthropicClient
+
+            AnthropicClient.return_value = MagicMock()
+
+            # Now set API key to None to test validation
+            mock_config.anthropic_api_key = None
+
+            with pytest.raises(ProviderError) as exc_info:
+                create_anthropic_llm_client(mock_config)
+
+            assert "ANTHROPIC_API_KEY" in str(exc_info.value)
+
+    def test_create_anthropic_llm_client_import_error(self, mock_config):
+        """Test create_anthropic_llm_client raises ProviderNotInstalled on ImportError."""
+        from types import ModuleType
+
+        # Create a broken module that raises ImportError on attribute access
+        def broken_getattr(name):
+            if name in ("llm_client", "anthropic_client", "config"):
+                raise ImportError("graphiti-core[anthropic] not installed")
+            raise AttributeError(f"module has no attribute '{name}'")
+
+        broken_module = ModuleType("graphiti_core")
+        broken_module.__getattr__ = broken_getattr
+
+        # Patch both modules that are imported
+        with patch.dict(sys.modules, {"graphiti_core": broken_module}):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_anthropic_llm_client(mock_config)
+
+            assert "graphiti-core[anthropic]" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_anthropic_llm_client_passes_config_correctly(self, mock_config):
+        """Test create_anthropic_llm_client passes config values correctly."""
+        mock_config.anthropic_api_key = "sk-ant-test-key-123"
+        mock_config.anthropic_model = "claude-opus-4-20250514"
+        mock_client = MagicMock()
+
+        # Patch at the location where the imports happen (local imports inside function)
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.anthropic_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.anthropic_llm.AnthropicClient",
+                return_value=mock_client,
+            ):
+                create_anthropic_llm_client(mock_config)
+
+                # Verify LLMConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "sk-ant-test-key-123"
+                assert call_kwargs["model"] == "claude-opus-4-20250514"

apps/backend/integrations/graphiti/tests/test_providers_llm_azure_openai.py

@@ -0,0 +1,163 @@
+"""
+Unit tests for Azure OpenAI LLM provider.
+
+Tests cover:
+- create_azure_openai_llm_client factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.azure_openai_llm import (
+    create_azure_openai_llm_client,
+)
+
+# =============================================================================
+# Test create_azure_openai_llm_client
+# =============================================================================
+
+
+class TestCreateAzureOpenAILLMClient:
+    """Test create_azure_openai_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.azure_openai_api_key = "test-azure-key"
+        config.azure_openai_base_url = "https://test.openai.azure.com"
+        config.azure_openai_llm_deployment = "test-llm-deployment"
+        return config
+
+    @pytest.mark.slow
+    def test_create_azure_openai_llm_client_success(self, mock_config):
+        """Test create_azure_openai_llm_client returns client with valid config."""
+        mock_azure_client = MagicMock()
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.azure_openai_llm.AsyncOpenAI",
+            return_value=mock_azure_client,
+        ):
+            with patch(
+                "graphiti_core.llm_client.azure_openai_client.AzureOpenAILLMClient",
+                return_value=mock_client,
+            ):
+                result = create_azure_openai_llm_client(mock_config)
+                assert result == mock_client
+
+    def test_create_azure_openai_llm_client_success_fast(self, mock_config):
+        """Fast test for create_azure_openai_llm_client success path."""
+        mock_llm_client = MagicMock()
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.azure_openai_client": MagicMock(),
+                "graphiti_core.llm_client.config": MagicMock(),
+            },
+        ):
+            from graphiti_core.llm_client.azure_openai_client import (
+                AzureOpenAILLMClient,
+            )
+
+            AzureOpenAILLMClient.return_value = mock_llm_client
+
+            result = create_azure_openai_llm_client(mock_config)
+
+            # Verify the client was created and returned
+            AzureOpenAILLMClient.assert_called_once()
+            assert result == mock_llm_client
+
+    def test_create_azure_openai_llm_client_missing_api_key(self, mock_config):
+        """Test create_azure_openai_llm_client raises ProviderError for missing API key."""
+        mock_config.azure_openai_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_llm_client(mock_config)
+
+        assert "AZURE_OPENAI_API_KEY" in str(exc_info.value)
+
+    def test_create_azure_openai_llm_client_missing_base_url(self, mock_config):
+        """Test create_azure_openai_llm_client raises ProviderError for missing base URL."""
+        mock_config.azure_openai_base_url = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_llm_client(mock_config)
+
+        assert "AZURE_OPENAI_BASE_URL" in str(exc_info.value)
+
+    def test_create_azure_openai_llm_client_missing_deployment(self, mock_config):
+        """Test create_azure_openai_llm_client raises ProviderError for missing deployment."""
+        mock_config.azure_openai_llm_deployment = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_azure_openai_llm_client(mock_config)
+
+        assert "AZURE_OPENAI_LLM_DEPLOYMENT" in str(exc_info.value)
+
+    def test_create_azure_openai_llm_client_import_error(self, mock_config):
+        """Test create_azure_openai_llm_client raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if (
+                name.startswith("graphiti_core.llm_client")
+                or name == "openai"
+                or name.startswith("openai.")
+            ):
+                raise ImportError("Required package not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_azure_openai_llm_client(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+            assert "openai" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_azure_openai_llm_client_passes_config_correctly(self, mock_config):
+        """Test create_azure_openai_llm_client passes config values correctly."""
+        mock_azure_client = MagicMock()
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.azure_openai_llm.AsyncOpenAI",
+            return_value=mock_azure_client,
+        ) as mock_openai:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.azure_openai_llm.LLMConfig",
+            ) as mock_config_class:
+                with patch(
+                    "graphiti_core.llm_client.azure_openai_client.AzureOpenAILLMClient",
+                    return_value=mock_client,
+                ):
+                    create_azure_openai_llm_client(mock_config)
+
+                    # Verify AsyncOpenAI was called with correct arguments
+                    mock_openai.assert_called_once_with(
+                        base_url=mock_config.azure_openai_base_url,
+                        api_key=mock_config.azure_openai_api_key,
+                    )
+
+                    # Verify LLMConfig was called with correct arguments
+                    call_kwargs = mock_config_class.call_args.kwargs
+                    assert (
+                        call_kwargs["model"] == mock_config.azure_openai_llm_deployment
+                    )
+                    assert (
+                        call_kwargs["small_model"]
+                        == mock_config.azure_openai_llm_deployment
+                    )

apps/backend/integrations/graphiti/tests/test_providers_llm_google.py

@@ -0,0 +1,410 @@
+"""
+Unit tests for Google LLM provider.
+
+Tests cover:
+- create_google_llm_client factory function
+- GoogleLLMClient class (generate_response, generate_response_with_tools)
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.google_llm import (
+    DEFAULT_GOOGLE_LLM_MODEL,
+    GoogleLLMClient,
+    create_google_llm_client,
+)
+
+# =============================================================================
+# Test GoogleLLMClient class
+# =============================================================================
+
+
+class TestGoogleLLMClient:
+    """Test GoogleLLMClient class."""
+
+    def test_google_llm_client_init_success(self):
+        """Test GoogleLLMClient initializes with API key and model."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key", model="test-model")
+
+            assert client.api_key == "test-key"
+            assert client.model == "test-model"
+            mock_genai.configure.assert_called_once_with(api_key="test-key")
+            mock_genai.GenerativeModel.assert_called_once_with("test-model")
+
+    def test_google_llm_client_init_default_model(self):
+        """Test GoogleLLMClient uses default model when not specified."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+
+            assert client.model == DEFAULT_GOOGLE_LLM_MODEL
+
+    def test_google_llm_client_init_import_error(self):
+        """Test GoogleLLMClient raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "google.generativeai" or name.startswith("google.generativeai."):
+                raise ImportError("google-generativeai not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                GoogleLLMClient(api_key="test-key")
+
+            assert "google-generativeai" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_user_message(self):
+        """Test GoogleLLMClient.generate_response with user message (lines 73-133)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [{"role": "user", "content": "Hello"}]
+            )
+
+            assert result == "Test response"
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_user_message_slow(self):
+        """Test GoogleLLMClient.generate_response with user message (slow variant)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [{"role": "user", "content": "Hello"}]
+            )
+
+            assert result == "Test response"
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_system_message(self):
+        """Test GoogleLLMClient.generate_response with system instruction (lines 84-98)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model_with_sys = MagicMock()
+        mock_model_without_sys = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(
+            side_effect=[mock_model_without_sys, mock_model_with_sys]
+        )
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model_with_sys.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [
+                    {"role": "system", "content": "You are helpful"},
+                    {"role": "user", "content": "Hello"},
+                ]
+            )
+
+            assert result == "Test response"
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_system_message_slow(self):
+        """Test GoogleLLMClient.generate_response with system instruction (slow variant)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model_with_sys = MagicMock()
+        mock_model_without_sys = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(
+            side_effect=[mock_model_without_sys, mock_model_with_sys]
+        )
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model_with_sys.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [
+                    {"role": "system", "content": "You are helpful"},
+                    {"role": "user", "content": "Hello"},
+                ]
+            )
+
+            assert result == "Test response"
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_assistant_message(self):
+        """Test GoogleLLMClient.generate_response with assistant role (lines 87-88)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [
+                    {"role": "user", "content": "Hello"},
+                    {"role": "assistant", "content": "Hi there"},
+                    {"role": "user", "content": "How are you?"},
+                ]
+            )
+
+            assert result == "Test response"
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_response_model(self):
+        """Test GoogleLLMClient.generate_response with structured output (lines 103-127)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = '{"key": "value"}'
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+        mock_genai.GenerationConfig = MagicMock()
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            from pydantic import BaseModel
+
+            class TestModel(BaseModel):
+                key: str
+
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [{"role": "user", "content": "Hello"}],
+                response_model=TestModel,
+            )
+
+            assert isinstance(result, TestModel)
+            assert result.key == "value"
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_response_model_slow(self):
+        """Test GoogleLLMClient.generate_response with structured output (slow variant)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = '{"key": "value"}'
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+        mock_genai.GenerationConfig = MagicMock()
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            from pydantic import BaseModel
+
+            class TestModel(BaseModel):
+                key: str
+
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [{"role": "user", "content": "Hello"}],
+                response_model=TestModel,
+            )
+
+            assert isinstance(result, TestModel)
+            assert result.key == "value"
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_json_decode_error(self):
+        """Test GoogleLLMClient.generate_response with JSON decode error (lines 122-127)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Not valid JSON"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+        mock_genai.GenerationConfig = MagicMock()
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            from pydantic import BaseModel
+
+            class TestModel(BaseModel):
+                key: str
+
+            client = GoogleLLMClient(api_key="test-key")
+            result = await client.generate_response(
+                [{"role": "user", "content": "Hello"}],
+                response_model=TestModel,
+            )
+
+            # Should return raw text when JSON parsing fails
+            assert result == "Not valid JSON"
+
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_tools(self):
+        """Test GoogleLLMClient.generate_response_with_tools (lines 155-160)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.google_llm.logger"
+            ) as mock_logger:
+                result = await client.generate_response_with_tools(
+                    [{"role": "user", "content": "Hello"}],
+                    tools=[{"name": "test_tool"}],
+                )
+
+                # Should log warning about tools not being supported
+                mock_logger.warning.assert_called_once()
+                assert "does not yet support tool calling" in str(
+                    mock_logger.warning.call_args
+                )
+                assert result == "Test response"
+
+    @pytest.mark.slow
+    @pytest.mark.asyncio
+    async def test_google_llm_client_generate_response_with_tools_slow(self):
+        """Test GoogleLLMClient.generate_response_with_tools (slow variant)."""
+        mock_genai = MagicMock()
+        mock_genai.configure = MagicMock()
+        mock_model = MagicMock()
+        mock_genai.GenerativeModel = MagicMock(return_value=mock_model)
+        mock_response = MagicMock()
+        mock_response.text = "Test response"
+        mock_model.generate_content = MagicMock(return_value=mock_response)
+
+        with patch.dict(sys.modules, {"google.generativeai": mock_genai}):
+            client = GoogleLLMClient(api_key="test-key")
+
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.google_llm.logger"
+            ) as mock_logger:
+                result = await client.generate_response_with_tools(
+                    [{"role": "user", "content": "Hello"}],
+                    tools=[{"name": "test_tool"}],
+                )
+
+                mock_logger.warning.assert_called_once()
+                assert "does not yet support tool calling" in str(
+                    mock_logger.warning.call_args
+                )
+                assert result == "Test response"
+
+
+# =============================================================================
+# Test create_google_llm_client
+# =============================================================================
+
+
+class TestCreateGoogleLLMClient:
+    """Test create_google_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.google_api_key = "test-google-key"
+        config.google_llm_model = None
+        return config
+
+    def test_create_google_llm_client_success(self, mock_config):
+        """Test create_google_llm_client returns client with valid config."""
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.google_llm.GoogleLLMClient",
+            return_value=mock_client,
+        ):
+            result = create_google_llm_client(mock_config)
+            assert result == mock_client
+
+    def test_create_google_llm_client_missing_api_key(self, mock_config):
+        """Test create_google_llm_client raises ProviderError for missing API key."""
+        mock_config.google_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_google_llm_client(mock_config)
+
+        assert "GOOGLE_API_KEY" in str(exc_info.value)
+
+    def test_create_google_llm_client_with_custom_model(self, mock_config):
+        """Test create_google_llm_client uses custom model when specified."""
+        mock_config.google_llm_model = "custom-model"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.google_llm.GoogleLLMClient",
+            return_value=mock_client,
+        ) as mock_google_client:
+            create_google_llm_client(mock_config)
+
+            mock_google_client.assert_called_once_with(
+                api_key=mock_config.google_api_key,
+                model="custom-model",
+            )
+
+    def test_create_google_llm_client_with_default_model(self, mock_config):
+        """Test create_google_llm_client uses default model when not specified."""
+        mock_config.google_llm_model = None
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.google_llm.GoogleLLMClient",
+            return_value=mock_client,
+        ) as mock_google_client:
+            create_google_llm_client(mock_config)
+
+            mock_google_client.assert_called_once_with(
+                api_key=mock_config.google_api_key,
+                model=DEFAULT_GOOGLE_LLM_MODEL,
+            )
+
+
+# =============================================================================
+# Test Constants
+# =============================================================================
+
+
+class TestGoogleLLMConstants:
+    """Test Google LLM constants."""
+
+    def test_default_google_llm_model(self):
+        """Test DEFAULT_GOOGLE_LLM_MODEL is set correctly."""
+        assert DEFAULT_GOOGLE_LLM_MODEL == "gemini-2.0-flash"

apps/backend/integrations/graphiti/tests/test_providers_llm_ollama.py

@@ -0,0 +1,181 @@
+"""
+Unit tests for Ollama LLM provider.
+
+Tests cover:
+- create_ollama_llm_client factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.ollama_llm import (
+    create_ollama_llm_client,
+)
+
+# =============================================================================
+# Test create_ollama_llm_client
+# =============================================================================
+
+
+class TestCreateOllamaLLMClient:
+    """Test create_ollama_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.ollama_llm_model = "llama3.2"
+        config.ollama_base_url = "http://localhost:11434"
+        return config
+
+    @pytest.mark.slow
+    def test_create_ollama_llm_client_success(self, mock_config):
+        """Test create_ollama_llm_client returns client with valid config."""
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.OpenAIGenericClient",
+            return_value=mock_client,
+        ):
+            result = create_ollama_llm_client(mock_config)
+            assert result == mock_client
+
+    def test_create_ollama_llm_client_success_fast(self, mock_config):
+        """Fast test for create_ollama_llm_client success path."""
+        mock_llm_client = MagicMock()
+
+        # Create the config mock
+        mock_config_module = MagicMock()
+        mock_config_module.LLMConfig = MagicMock
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.config": mock_config_module,
+                "graphiti_core.llm_client.openai_generic_client": MagicMock(),
+            },
+        ):
+            from graphiti_core.llm_client.openai_generic_client import (
+                OpenAIGenericClient,
+            )
+
+            OpenAIGenericClient.return_value = mock_llm_client
+
+            result = create_ollama_llm_client(mock_config)
+
+            # Verify the client was created and returned
+            OpenAIGenericClient.assert_called_once()
+            assert result == mock_llm_client
+
+    def test_create_ollama_llm_client_missing_model(self, mock_config):
+        """Test create_ollama_llm_client raises ProviderError for missing model."""
+        mock_config.ollama_llm_model = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_ollama_llm_client(mock_config)
+
+        assert "OLLAMA_LLM_MODEL" in str(exc_info.value)
+
+    def test_create_ollama_llm_client_import_error(self, mock_config):
+        """Test create_ollama_llm_client raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.llm_client"):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_ollama_llm_client(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_ollama_llm_client_base_url_without_v1(self, mock_config):
+        """Test create_ollama_llm_client appends /v1 to base URL if missing."""
+        mock_config.ollama_base_url = "http://localhost:11434"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.OpenAIGenericClient",
+                return_value=mock_client,
+            ):
+                create_ollama_llm_client(mock_config)
+
+                # Verify base_url has /v1 appended
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_llm_client_base_url_with_v1(self, mock_config):
+        """Test create_ollama_llm_client doesn't duplicate /v1 in base URL."""
+        mock_config.ollama_base_url = "http://localhost:11434/v1"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.OpenAIGenericClient",
+                return_value=mock_client,
+            ):
+                create_ollama_llm_client(mock_config)
+
+                # Verify base_url is not duplicated
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_llm_client_base_url_with_trailing_slash(self, mock_config):
+        """Test create_ollama_llm_client handles trailing slash correctly."""
+        mock_config.ollama_base_url = "http://localhost:11434/"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.OpenAIGenericClient",
+                return_value=mock_client,
+            ):
+                create_ollama_llm_client(mock_config)
+
+                # Verify trailing slash is handled
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_llm_client_passes_config_correctly(self, mock_config):
+        """Test create_ollama_llm_client passes config values correctly."""
+        mock_config.ollama_llm_model = "qwen2.5"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.ollama_llm.OpenAIGenericClient",
+                return_value=mock_client,
+            ):
+                create_ollama_llm_client(mock_config)
+
+                # Verify LLMConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "ollama"
+                assert call_kwargs["model"] == "qwen2.5"
+                assert call_kwargs["small_model"] == "qwen2.5"

apps/backend/integrations/graphiti/tests/test_providers_llm_openai.py

@@ -0,0 +1,207 @@
+"""
+Unit tests for OpenAI LLM provider.
+
+Tests cover:
+- create_openai_llm_client factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.openai_llm import (
+    create_openai_llm_client,
+)
+
+# =============================================================================
+# Test create_openai_llm_client
+# =============================================================================
+
+
+class TestCreateOpenAILLMClient:
+    """Test create_openai_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.openai_api_key = "sk-test-key"
+        config.openai_model = "gpt-4o"
+        return config
+
+    @pytest.mark.slow
+    def test_create_openai_llm_client_success(self, mock_config):
+        """Test create_openai_llm_client returns client with valid config."""
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openai_llm.OpenAIClient",
+            return_value=mock_client,
+        ):
+            result = create_openai_llm_client(mock_config)
+            assert result == mock_client
+
+    def test_create_openai_llm_client_success_fast(self, mock_config):
+        """Fast test for create_openai_llm_client success path."""
+        mock_llm_client = MagicMock()
+
+        # Create the config mock
+        mock_config_module = MagicMock()
+        mock_config_module.LLMConfig = MagicMock
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.config": mock_config_module,
+                "graphiti_core.llm_client.openai_client": MagicMock(),
+            },
+        ):
+            from graphiti_core.llm_client.openai_client import OpenAIClient
+
+            OpenAIClient.return_value = mock_llm_client
+
+            result = create_openai_llm_client(mock_config)
+
+            # Verify the client was created and returned
+            OpenAIClient.assert_called_once()
+            assert result == mock_llm_client
+
+    def test_create_openai_llm_client_missing_api_key(self, mock_config):
+        """Test create_openai_llm_client raises ProviderError for missing API key."""
+        mock_config.openai_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_openai_llm_client(mock_config)
+
+        assert "OPENAI_API_KEY" in str(exc_info.value)
+
+    def test_create_openai_llm_client_import_error(self, mock_config):
+        """Test create_openai_llm_client raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.llm_client"):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_openai_llm_client(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    def test_create_openai_llm_client_gpt5_model_with_reasoning_fast(self, mock_config):
+        """Fast test for GPT-5 model with reasoning (line 58)."""
+        mock_config.openai_model = "gpt-5-turbo"
+        mock_client = MagicMock()
+
+        # Create the config mock
+        mock_config_module = MagicMock()
+        mock_config_module.LLMConfig = MagicMock
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.llm_client": MagicMock(),
+                "graphiti_core.llm_client.config": mock_config_module,
+                "graphiti_core.llm_client.openai_client": MagicMock(),
+            },
+        ):
+            from graphiti_core.llm_client.openai_client import OpenAIClient
+
+            OpenAIClient.return_value = mock_client
+
+            result = create_openai_llm_client(mock_config)
+
+            # Verify the client was created with default config (no extra params)
+            OpenAIClient.assert_called_once()
+            call_kwargs = OpenAIClient.call_args.kwargs
+            # Should not have reasoning/verbosity params set to None for GPT-5
+            assert (
+                "reasoning" not in call_kwargs
+                or call_kwargs.get("reasoning") is not False
+            )
+            assert (
+                "verbosity" not in call_kwargs
+                or call_kwargs.get("verbosity") is not False
+            )
+            assert result == mock_client
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize(
+        "model,expected_reasoning,expected_verbosity",
+        [
+            pytest.param("gpt-5-turbo", True, None, id="gpt5"),
+            pytest.param("o1-preview", True, None, id="o1"),
+            pytest.param("o3-mini", True, None, id="o3"),
+        ],
+    )
+    def test_create_openai_llm_client_reasoning_models(
+        self, mock_config, model, expected_reasoning, expected_verbosity
+    ):
+        """Test create_openai_llm_client with reasoning-capable models."""
+        mock_config.openai_model = model
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openai_llm.OpenAIClient",
+            return_value=mock_client,
+        ) as mock_openai_client:
+            create_openai_llm_client(mock_config)
+
+            mock_openai_client.assert_called_once()
+            call_kwargs = mock_openai_client.call_args.kwargs
+            # Verify reasoning is set to True for reasoning models
+            assert call_kwargs.get("reasoning") is expected_reasoning
+            # Verify verbosity matches expected value (None for these models)
+            assert call_kwargs.get("verbosity") == expected_verbosity
+
+    @pytest.mark.slow
+    def test_create_openai_llm_client_gpt4_model_without_reasoning(self, mock_config):
+        """Test create_openai_llm_client with GPT-4 model disables reasoning."""
+        mock_config.openai_model = "gpt-4o"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openai_llm.OpenAIClient",
+            return_value=mock_client,
+        ) as mock_openai_client:
+            create_openai_llm_client(mock_config)
+
+            # GPT-4 models should be created with reasoning=None, verbosity=None
+            call_kwargs = mock_openai_client.call_args.kwargs
+            assert call_kwargs.get("reasoning") is None
+            assert call_kwargs.get("verbosity") is None
+
+    @pytest.mark.slow
+    def test_create_openai_llm_client_passes_config_correctly(self, mock_config):
+        """Test create_openai_llm_client passes config values correctly."""
+        mock_config.openai_api_key = "sk-test-key-123"
+        mock_config.openai_model = "gpt-4o-mini"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openai_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.openai_llm.OpenAIClient",
+                return_value=mock_client,
+            ):
+                create_openai_llm_client(mock_config)
+
+                # Verify LLMConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "sk-test-key-123"
+                assert call_kwargs["model"] == "gpt-4o-mini"

apps/backend/integrations/graphiti/tests/test_providers_llm_openrouter.py

@@ -0,0 +1,113 @@
+"""
+Unit tests for OpenRouter LLM provider.
+
+Tests cover:
+- create_openrouter_llm_client factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+from integrations.graphiti.providers_pkg.llm_providers.openrouter_llm import (
+    create_openrouter_llm_client,
+)
+
+# =============================================================================
+# Test create_openrouter_llm_client
+# =============================================================================
+
+
+class TestCreateOpenRouterLLMClient:
+    """Test create_openrouter_llm_client factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.openrouter_api_key = "sk-or-test-key"
+        config.openrouter_llm_model = "anthropic/claude-sonnet-4"
+        config.openrouter_base_url = "https://openrouter.ai/api/v1"
+        return config
+
+    @pytest.mark.slow
+    def test_create_openrouter_llm_client_success(self, mock_config):
+        """Test create_openrouter_llm_client returns client with valid config."""
+        mock_client = MagicMock()
+
+        with patch(
+            "graphiti_core.llm_client.openai_client.OpenAIClient",
+            return_value=mock_client,
+        ):
+            result = create_openrouter_llm_client(mock_config)
+            assert result == mock_client
+
+    def test_create_openrouter_llm_client_missing_api_key(self, mock_config):
+        """Test create_openrouter_llm_client raises ProviderError for missing API key."""
+        mock_config.openrouter_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_openrouter_llm_client(mock_config)
+
+        assert "OPENROUTER_API_KEY" in str(exc_info.value)
+
+    def test_create_openrouter_llm_client_import_error(self, mock_config):
+        """Test create_openrouter_llm_client raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.llm_client"):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_openrouter_llm_client(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_openrouter_llm_client_passes_config_correctly(self, mock_config):
+        """Test create_openrouter_llm_client passes config values correctly."""
+        mock_config.openrouter_api_key = "sk-or-test-key-123"
+        mock_config.openrouter_llm_model = "openai/gpt-4o"
+        mock_config.openrouter_base_url = "https://custom.openrouter.ai/api/v1"
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openrouter_llm.LLMConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.llm_providers.openrouter_llm.OpenAIClient",
+                return_value=mock_client,
+            ):
+                create_openrouter_llm_client(mock_config)
+
+                # Verify LLMConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "sk-or-test-key-123"
+                assert call_kwargs["model"] == "openai/gpt-4o"
+                assert call_kwargs["base_url"] == "https://custom.openrouter.ai/api/v1"
+
+    @pytest.mark.slow
+    def test_create_openrouter_llm_client_disables_reasoning(self, mock_config):
+        """Test create_openrouter_llm_client disables reasoning/verbosity for compatibility."""
+        mock_client = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.llm_providers.openrouter_llm.OpenAIClient",
+            return_value=mock_client,
+        ) as mock_openai_client:
+            create_openrouter_llm_client(mock_config)
+
+            # OpenRouter should have reasoning=None, verbosity=None for compatibility
+            call_kwargs = mock_openai_client.call_args.kwargs
+            assert call_kwargs.get("reasoning") is None
+            assert call_kwargs.get("verbosity") is None

apps/backend/integrations/graphiti/tests/test_providers_module.py

@@ -0,0 +1,246 @@
+"""
+Tests for integrations.graphiti.providers module.
+
+Tests cover:
+- All re-exported items are accessible
+- __all__ exports match documentation
+- Module has proper docstring
+"""
+
+import pytest
+
+
+class TestProvidersModuleReExports:
+    """Test that all items are properly re-exported from graphiti_providers."""
+
+    def test_import_provider_error(self):
+        """Test ProviderError is re-exported."""
+        from integrations.graphiti.providers import ProviderError
+
+        assert ProviderError is not None
+        assert Exception in ProviderError.__mro__
+
+    def test_import_provider_not_installed(self):
+        """Test ProviderNotInstalled is re-exported."""
+        from integrations.graphiti.providers import ProviderNotInstalled
+
+        assert ProviderNotInstalled is not None
+        assert Exception in ProviderNotInstalled.__mro__
+
+    def test_import_create_llm_client(self):
+        """Test create_llm_client is re-exported."""
+        from integrations.graphiti.providers import create_llm_client
+
+        assert create_llm_client is not None
+        assert callable(create_llm_client)
+
+    def test_import_create_embedder(self):
+        """Test create_embedder is re-exported."""
+        from integrations.graphiti.providers import create_embedder
+
+        assert create_embedder is not None
+        assert callable(create_embedder)
+
+    def test_import_create_cross_encoder(self):
+        """Test create_cross_encoder is re-exported."""
+        from integrations.graphiti.providers import create_cross_encoder
+
+        assert create_cross_encoder is not None
+        assert callable(create_cross_encoder)
+
+    def test_import_embedding_dimensions(self):
+        """Test EMBEDDING_DIMENSIONS is re-exported."""
+        from integrations.graphiti.providers import EMBEDDING_DIMENSIONS
+
+        assert EMBEDDING_DIMENSIONS is not None
+        assert isinstance(EMBEDDING_DIMENSIONS, dict)
+
+    def test_import_get_expected_embedding_dim(self):
+        """Test get_expected_embedding_dim is re-exported."""
+        from integrations.graphiti.providers import get_expected_embedding_dim
+
+        assert get_expected_embedding_dim is not None
+        assert callable(get_expected_embedding_dim)
+
+    def test_import_validate_embedding_config(self):
+        """Test validate_embedding_config is re-exported."""
+        from integrations.graphiti.providers import validate_embedding_config
+
+        assert validate_embedding_config is not None
+        assert callable(validate_embedding_config)
+
+    def test_import_test_llm_connection(self):
+        """Test test_llm_connection is re-exported."""
+        from integrations.graphiti.providers import test_llm_connection
+
+        assert test_llm_connection is not None
+        assert callable(test_llm_connection)
+
+    def test_import_test_embedder_connection(self):
+        """Test test_embedder_connection is re-exported."""
+        from integrations.graphiti.providers import test_embedder_connection
+
+        assert test_embedder_connection is not None
+        assert callable(test_embedder_connection)
+
+    def test_import_test_ollama_connection(self):
+        """Test test_ollama_connection is re-exported."""
+        from integrations.graphiti.providers import test_ollama_connection
+
+        assert test_ollama_connection is not None
+        assert callable(test_ollama_connection)
+
+    def test_import_is_graphiti_enabled(self):
+        """Test is_graphiti_enabled is re-exported."""
+        from integrations.graphiti.providers import is_graphiti_enabled
+
+        assert is_graphiti_enabled is not None
+        assert callable(is_graphiti_enabled)
+
+    def test_import_get_graph_hints(self):
+        """Test get_graph_hints is re-exported."""
+        from integrations.graphiti.providers import get_graph_hints
+
+        assert get_graph_hints is not None
+        assert callable(get_graph_hints)
+
+
+class TestProvidersModuleAll:
+    """Test __all__ exports match documented exports."""
+
+    def test___all___contains_all_exports(self):
+        """Test __all__ contains all expected exports."""
+        import integrations.graphiti.providers as providers_module
+
+        expected_all = [
+            # Exceptions
+            "ProviderError",
+            "ProviderNotInstalled",
+            # Factory functions
+            "create_llm_client",
+            "create_embedder",
+            "create_cross_encoder",
+            # Models
+            "EMBEDDING_DIMENSIONS",
+            "get_expected_embedding_dim",
+            # Validators
+            "validate_embedding_config",
+            "test_llm_connection",
+            "test_embedder_connection",
+            "test_ollama_connection",
+            # Utilities
+            "is_graphiti_enabled",
+            "get_graph_hints",
+        ]
+
+        assert providers_module.__all__ == expected_all
+
+    def test_import_star_includes_all_exports(self):
+        """Test 'from integrations.graphiti.providers import *' works."""
+        namespace = {}
+        exec("from integrations.graphiti.providers import *", namespace)
+
+        # Verify all __all__ items are in the namespace
+        import integrations.graphiti.providers as providers_module
+
+        for item in providers_module.__all__:
+            assert item in namespace, f"{item} not found in namespace"
+
+    def test_all_exports_are_accessible(self):
+        """Test all items in __all__ are accessible."""
+        import integrations.graphiti.providers as providers_module
+
+        for item in providers_module.__all__:
+            assert hasattr(providers_module, item), f"{item} not accessible"
+
+
+class TestProvidersModuleDocumentation:
+    """Test module documentation."""
+
+    def test_module_has_docstring(self):
+        """Test the module has a docstring."""
+        import integrations.graphiti.providers as providers_module
+
+        assert providers_module.__doc__ is not None
+        assert len(providers_module.__doc__) > 0
+
+    def test_docstring_contains_key_terms(self):
+        """Test the docstring contains key terms."""
+        import integrations.graphiti.providers as providers_module
+
+        docstring = providers_module.__doc__.lower()
+        assert "provider" in docstring
+        assert "graphiti" in docstring
+
+
+class TestProvidersModuleReExportBehavior:
+    """Test re-export behavior matches the source module."""
+
+    def test_create_llm_client_matches_source(self):
+        """Test create_llm_client is the same as the source."""
+        from graphiti_providers import create_llm_client as source
+        from integrations.graphiti.providers import create_llm_client as re_export
+
+        assert re_export is source
+
+    def test_create_embedder_matches_source(self):
+        """Test create_embedder is the same as the source."""
+        from graphiti_providers import create_embedder as source
+        from integrations.graphiti.providers import create_embedder as re_export
+
+        assert re_export is source
+
+    def test_exceptions_match_source(self):
+        """Test exceptions are the same as the source."""
+        from graphiti_providers import ProviderError as source_error
+        from graphiti_providers import ProviderNotInstalled as source_not_installed
+        from integrations.graphiti.providers import (
+            ProviderError as re_export_error,
+        )
+        from integrations.graphiti.providers import (
+            ProviderNotInstalled as re_export_not_installed,
+        )
+
+        assert re_export_error is source_error
+        assert re_export_not_installed is source_not_installed
+
+    def test_embedding_dimensions_matches_source(self):
+        """Test EMBEDDING_DIMENSIONS is the same as the source."""
+        from graphiti_providers import EMBEDDING_DIMENSIONS as source
+        from integrations.graphiti.providers import EMBEDDING_DIMENSIONS as re_export
+
+        assert re_export is source
+
+
+class TestProvidersModuleIntegration:
+    """Integration tests for the providers module."""
+
+    def test_module_can_be_imported_multiple_times(self):
+        """Test the module can be imported multiple times without issues."""
+        import importlib
+
+        import integrations.graphiti.providers
+
+        importlib.reload(integrations.graphiti.providers)
+
+        # Should still work
+        from integrations.graphiti.providers import create_llm_client
+
+        assert create_llm_client is not None
+
+    def test_concurrent_imports(self):
+        """Test concurrent imports don't cause issues."""
+        import concurrent.futures
+
+        def import_module():
+            from integrations.graphiti.providers import create_llm_client
+
+            return create_llm_client
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [executor.submit(import_module) for _ in range(5)]
+            results = [f.result() for f in concurrent.futures.as_completed(futures)]
+
+        # All should succeed
+        assert len(results) == 5
+        assert all(r is not None for r in results)

apps/backend/integrations/graphiti/tests/test_providers_ollama.py

@@ -0,0 +1,285 @@
+"""
+Unit tests for Ollama embedder provider.
+
+Tests cover:
+- get_embedding_dim_for_model helper function
+- create_ollama_embedder factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder import (
+    KNOWN_OLLAMA_EMBEDDING_MODELS,
+    create_ollama_embedder,
+    get_embedding_dim_for_model,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Test get_embedding_dim_for_model
+# =============================================================================
+
+
+class TestGetEmbeddingDimForModel:
+    """Test get_embedding_dim_for_model helper function."""
+
+    def test_get_embedding_dim_for_model_exact_match(self):
+        """Test get_embedding_dim_for_model with exact model match."""
+        result = get_embedding_dim_for_model("nomic-embed-text")
+        assert result == 768
+
+    def test_get_embedding_dim_for_model_with_tag(self):
+        """Test get_embedding_dim_for_model with tagged model."""
+        result = get_embedding_dim_for_model("qwen3-embedding:8b")
+        assert result == 4096
+
+    def test_get_embedding_dim_for_model_base_name_fallback(self):
+        """Test get_embedding_dim_for_model falls back to base name."""
+        result = get_embedding_dim_for_model("nomic-embed-text:custom-tag")
+        assert result == 768  # Should use base model dimension
+
+    def test_get_embedding_dim_for_model_configured_dim_override(self):
+        """Test get_embedding_dim_for_model with configured dimension override."""
+        result = get_embedding_dim_for_model("unknown-model", configured_dim=512)
+        assert result == 512
+
+    def test_get_embedding_dim_for_model_unknown_model(self):
+        """Test get_embedding_dim_for_model raises ProviderError for unknown model."""
+        with pytest.raises(ProviderError) as exc_info:
+            get_embedding_dim_for_model("totally-unknown-model")
+
+        assert "Unknown Ollama embedding model" in str(exc_info.value)
+        assert "totally-unknown-model" in str(exc_info.value)
+        assert "OLLAMA_EMBEDDING_DIM" in str(exc_info.value)
+
+    def test_get_embedding_dim_for_model_configured_dim_zero(self):
+        """Test get_embedding_dim_for_model ignores zero configured dimension."""
+        # When configured_dim is 0, should use known model dimension
+        result = get_embedding_dim_for_model("nomic-embed-text", configured_dim=0)
+        assert result == 768
+
+
+# =============================================================================
+# Test KNOWN_OLLAMA_EMBEDDING_MODELS constant
+# =============================================================================
+
+
+class TestKnownOllamaEmbeddingModels:
+    """Test KNOWN_OLLAMA_EMBEDDING_MODELS constant."""
+
+    def test_known_models_contains_expected_entries(self):
+        """Test KNOWN_OLLAMA_EMBEDDING_MODELS has expected models."""
+        expected_models = [
+            "embeddinggemma",
+            "qwen3-embedding",
+            "nomic-embed-text",
+            "mxbai-embed-large",
+            "bge-large",
+            "all-minilm",
+        ]
+
+        for model in expected_models:
+            # Check if base model exists (without tag)
+            base_found = any(
+                key.startswith(model) for key in KNOWN_OLLAMA_EMBEDDING_MODELS.keys()
+            )
+            assert base_found, (
+                f"Model {model} not found in KNOWN_OLLAMA_EMBEDDING_MODELS"
+            )
+
+    def test_known_models_dimensions_are_positive(self):
+        """Test all dimensions in KNOWN_OLLAMA_EMBEDDING_MODELS are positive integers."""
+        for model, dimension in KNOWN_OLLAMA_EMBEDDING_MODELS.items():
+            assert isinstance(dimension, int), f"Dimension for {model} is not int"
+            assert dimension > 0, f"Dimension for {model} is not positive: {dimension}"
+
+
+# =============================================================================
+# Test create_ollama_embedder
+# =============================================================================
+
+
+class TestCreateOllamaEmbedder:
+    """Test create_ollama_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.ollama_embedding_model = "nomic-embed-text"
+        config.ollama_embedding_dim = None
+        config.ollama_base_url = "http://localhost:11434"
+        return config
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_success(self, mock_config):
+        """Test create_ollama_embedder returns embedder with valid config."""
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+            return_value=mock_embedder,
+        ):
+            result = create_ollama_embedder(mock_config)
+            assert result == mock_embedder
+
+    def test_create_ollama_embedder_success_fast(self, mock_config):
+        """Fast test for create_ollama_embedder success path."""
+        mock_embedder = MagicMock()
+
+        # Set embedding_dim to 0 to allow auto-detection
+        mock_config.ollama_embedding_dim = 0
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.embedder": MagicMock(),
+                "graphiti_core.embedder.openai": MagicMock(),
+            },
+        ):
+            from graphiti_core.embedder.openai import OpenAIEmbedder
+
+            OpenAIEmbedder.return_value = mock_embedder
+
+            result = create_ollama_embedder(mock_config)
+
+            # Verify the embedder was created and returned
+            OpenAIEmbedder.assert_called_once()
+            assert result == mock_embedder
+
+    def test_create_ollama_embedder_missing_model(self, mock_config):
+        """Test create_ollama_embedder raises ProviderError for missing model."""
+        mock_config.ollama_embedding_model = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_ollama_embedder(mock_config)
+
+        assert "OLLAMA_EMBEDDING_MODEL" in str(exc_info.value)
+
+    def test_create_ollama_embedder_import_error(self, mock_config):
+        """Test create_ollama_embedder raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            # Only block the specific import that create_ollama_embedder uses
+            if name == "graphiti_core.embedder.openai" or name.startswith(
+                "graphiti_core.embedder.openai."
+            ):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_ollama_embedder(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_base_url_without_v1(self, mock_config):
+        """Test create_ollama_embedder appends /v1 to base URL if missing."""
+        mock_config.ollama_base_url = "http://localhost:11434"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_ollama_embedder(mock_config)
+
+                # Verify base_url has /v1 appended
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_base_url_with_v1(self, mock_config):
+        """Test create_ollama_embedder doesn't duplicate /v1 in base URL."""
+        mock_config.ollama_base_url = "http://localhost:11434/v1"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_ollama_embedder(mock_config)
+
+                # Verify base_url is not duplicated
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_base_url_with_trailing_slash(self, mock_config):
+        """Test create_ollama_embedder handles trailing slash correctly."""
+        mock_config.ollama_base_url = "http://localhost:11434/"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_ollama_embedder(mock_config)
+
+                # Verify trailing slash is handled
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["base_url"] == "http://localhost:11434/v1"
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_passes_config_correctly(self, mock_config):
+        """Test create_ollama_embedder passes config values correctly."""
+        mock_config.ollama_embedding_model = "mxbai-embed-large"
+        mock_config.ollama_embedding_dim = None
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_ollama_embedder(mock_config)
+
+                # Verify OpenAIEmbedderConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "ollama"
+                assert call_kwargs["embedding_model"] == "mxbai-embed-large"
+                assert (
+                    call_kwargs["embedding_dim"] == 1024
+                )  # Known dimension for mxbai-embed-large
+
+    @pytest.mark.slow
+    def test_create_ollama_embedder_with_configured_dimension(self, mock_config):
+        """Test create_ollama_embedder uses configured dimension when set."""
+        mock_config.ollama_embedding_dim = 512
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.ollama_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_ollama_embedder(mock_config)
+
+                # Verify configured dimension is used
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["embedding_dim"] == 512

apps/backend/integrations/graphiti/tests/test_providers_openai.py

@@ -0,0 +1,117 @@
+"""
+Unit tests for OpenAI embedder provider.
+
+Tests cover:
+- create_openai_embedder factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.openai_embedder import (
+    create_openai_embedder,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Test create_openai_embedder
+# =============================================================================
+
+
+class TestCreateOpenAIEmbedder:
+    """Test create_openai_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.openai_api_key = "sk-test-key"
+        config.openai_embedding_model = "text-embedding-3-small"
+        return config
+
+    @pytest.mark.slow
+    def test_create_openai_embedder_success(self, mock_config):
+        """Test create_openai_embedder returns embedder with valid config."""
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.openai_embedder.OpenAIEmbedder",
+            return_value=mock_embedder,
+        ):
+            result = create_openai_embedder(mock_config)
+            assert result == mock_embedder
+
+    def test_create_openai_embedder_success_fast(self, mock_config):
+        """Fast test for create_openai_embedder success path."""
+        mock_embedder = MagicMock()
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.embedder": MagicMock(),
+                "graphiti_core.embedder.openai": MagicMock(),
+            },
+        ):
+            from graphiti_core.embedder.openai import OpenAIEmbedder
+
+            OpenAIEmbedder.return_value = mock_embedder
+
+            result = create_openai_embedder(mock_config)
+
+            # Verify the embedder was created and returned
+            OpenAIEmbedder.assert_called_once()
+            assert result == mock_embedder
+
+    def test_create_openai_embedder_missing_api_key(self, mock_config):
+        """Test create_openai_embedder raises ProviderError for missing API key."""
+        mock_config.openai_api_key = None
+
+        with pytest.raises(ProviderError) as exc_info:
+            create_openai_embedder(mock_config)
+
+        assert "OPENAI_API_KEY" in str(exc_info.value)
+
+    def test_create_openai_embedder_import_error(self, mock_config):
+        """Test create_openai_embedder raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.embedder"):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_openai_embedder(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_openai_embedder_passes_config_correctly(self, mock_config):
+        """Test create_openai_embedder passes config values correctly."""
+        mock_config.openai_api_key = "sk-test-key-123"
+        mock_config.openai_embedding_model = "text-embedding-3-large"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.openai_embedder.OpenAIEmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.openai_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_openai_embedder(mock_config)
+
+                # Verify OpenAIEmbedderConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "sk-test-key-123"
+                assert call_kwargs["embedding_model"] == "text-embedding-3-large"

apps/backend/integrations/graphiti/tests/test_providers_openrouter.py

@@ -0,0 +1,129 @@
+"""
+Unit tests for OpenRouter embedder provider.
+
+Tests cover:
+- create_openrouter_embedder factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.openrouter_embedder import (
+    create_openrouter_embedder,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Test create_openrouter_embedder
+# =============================================================================
+
+
+class TestCreateOpenRouterEmbedder:
+    """Test create_openrouter_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.openrouter_api_key = "sk-or-test-key"
+        config.openrouter_embedding_model = "openai/text-embedding-3-small"
+        config.openrouter_base_url = "https://openrouter.ai/api/v1"
+        return config
+
+    @pytest.mark.slow
+    def test_create_openrouter_embedder_success(self, mock_config):
+        """Test create_openrouter_embedder returns embedder with valid config."""
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.openrouter_embedder.OpenAIEmbedder",
+            return_value=mock_embedder,
+        ):
+            result = create_openrouter_embedder(mock_config)
+            assert result == mock_embedder
+
+    def test_create_openrouter_embedder_success_fast(self, mock_config):
+        """Fast test for create_openrouter_embedder success path."""
+        mock_embedder = MagicMock()
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.embedder": MagicMock(),
+            },
+        ):
+            from graphiti_core.embedder import OpenAIEmbedder
+
+            OpenAIEmbedder.return_value = mock_embedder
+
+            result = create_openrouter_embedder(mock_config)
+
+            # Verify the embedder was created and returned
+            OpenAIEmbedder.assert_called_once()
+            assert result == mock_embedder
+
+    def test_create_openrouter_embedder_missing_api_key(self, mock_config):
+        """Test create_openrouter_embedder raises ProviderError for missing API key."""
+
+        mock_graphiti_core_embedder = MagicMock()
+        mock_graphiti_core_embedder.EmbedderConfig = MagicMock
+        mock_graphiti_core_embedder.OpenAIEmbedder = MagicMock
+
+        # Mock the graphiti_core.embedder module to allow import to succeed
+        with patch.dict(
+            sys.modules, {"graphiti_core.embedder": mock_graphiti_core_embedder}
+        ):
+            mock_config.openrouter_api_key = None
+
+            with pytest.raises(ProviderError) as exc_info:
+                create_openrouter_embedder(mock_config)
+
+            assert "OPENROUTER_API_KEY" in str(exc_info.value)
+
+    def test_create_openrouter_embedder_import_error(self, mock_config):
+        """Test create_openrouter_embedder raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.embedder"):
+                raise ImportError("graphiti-core not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_openrouter_embedder(mock_config)
+
+            assert "graphiti-core" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_openrouter_embedder_passes_config_correctly(self, mock_config):
+        """Test create_openrouter_embedder passes config values correctly."""
+        mock_config.openrouter_api_key = "sk-or-test-key-123"
+        mock_config.openrouter_embedding_model = "voyage/voyage-3"
+        mock_config.openrouter_base_url = "https://custom.openrouter.ai/api/v1"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "integrations.graphiti.providers_pkg.embedder_providers.openrouter_embedder.EmbedderConfig",
+        ) as mock_config_class:
+            with patch(
+                "integrations.graphiti.providers_pkg.embedder_providers.openrouter_embedder.OpenAIEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_openrouter_embedder(mock_config)
+
+                # Verify EmbedderConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "sk-or-test-key-123"
+                assert call_kwargs["model"] == "voyage/voyage-3"
+                assert call_kwargs["base_url"] == "https://custom.openrouter.ai/api/v1"

apps/backend/integrations/graphiti/tests/test_providers_voyage.py

@@ -0,0 +1,128 @@
+"""
+Unit tests for Voyage AI embedder provider.
+
+Tests cover:
+- create_voyage_embedder factory function
+- ProviderNotInstalled exception handling
+- ProviderError for missing configuration
+"""
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from integrations.graphiti.providers_pkg.embedder_providers.voyage_embedder import (
+    create_voyage_embedder,
+)
+from integrations.graphiti.providers_pkg.exceptions import (
+    ProviderError,
+    ProviderNotInstalled,
+)
+
+# =============================================================================
+# Test create_voyage_embedder
+# =============================================================================
+
+
+class TestCreateVoyageEmbedder:
+    """Test create_voyage_embedder factory function."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock GraphitiConfig."""
+        config = MagicMock()
+        config.voyage_api_key = "test-voyage-key"
+        config.voyage_embedding_model = "voyage-3"
+        return config
+
+    @pytest.mark.slow
+    def test_create_voyage_embedder_success(self, mock_config):
+        """Test create_voyage_embedder returns embedder with valid config."""
+        mock_embedder = MagicMock()
+
+        with patch(
+            "graphiti_core.embedder.voyage.VoyageEmbedder",
+            return_value=mock_embedder,
+        ):
+            result = create_voyage_embedder(mock_config)
+            assert result == mock_embedder
+
+    def test_create_voyage_embedder_success_fast(self, mock_config):
+        """Fast test for create_voyage_embedder success path."""
+        mock_embedder = MagicMock()
+
+        # Mock the graphiti_core imports
+        with patch.dict(
+            "sys.modules",
+            {
+                "graphiti_core": MagicMock(),
+                "graphiti_core.embedder": MagicMock(),
+                "graphiti_core.embedder.voyage": MagicMock(),
+            },
+        ):
+            from graphiti_core.embedder.voyage import VoyageEmbedder
+
+            VoyageEmbedder.return_value = mock_embedder
+
+            result = create_voyage_embedder(mock_config)
+
+            # Verify the embedder was created and returned
+            VoyageEmbedder.assert_called_once()
+            assert result == mock_embedder
+
+    def test_create_voyage_embedder_missing_api_key(self, mock_config):
+        """Test create_voyage_embedder raises ProviderError for missing API key."""
+
+        mock_voyage = MagicMock()
+        mock_voyage.VoyageAIConfig = MagicMock()
+        mock_voyage.VoyageEmbedder = MagicMock()
+
+        # Clear sys.modules cache to ensure fresh import
+        sys.modules.pop("graphiti_core.embedder.voyage", None)
+
+        # Mock the voyage module to allow import to succeed
+        with patch.dict(sys.modules, {"graphiti_core.embedder.voyage": mock_voyage}):
+            mock_config.voyage_api_key = None
+
+            with pytest.raises(ProviderError) as exc_info:
+                create_voyage_embedder(mock_config)
+
+            assert "VOYAGE_API_KEY" in str(exc_info.value)
+
+    def test_create_voyage_embedder_import_error(self, mock_config):
+        """Test create_voyage_embedder raises ProviderNotInstalled on ImportError."""
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name.startswith("graphiti_core.embedder.voyage"):
+                raise ImportError("graphiti-core[voyage] not installed")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            with pytest.raises(ProviderNotInstalled) as exc_info:
+                create_voyage_embedder(mock_config)
+
+            assert "graphiti-core[voyage]" in str(exc_info.value)
+
+    @pytest.mark.slow
+    def test_create_voyage_embedder_passes_config_correctly(self, mock_config):
+        """Test create_voyage_embedder passes config values correctly."""
+        mock_config.voyage_api_key = "test-voyage-key-123"
+        mock_config.voyage_embedding_model = "voyage-3-lite"
+        mock_embedder = MagicMock()
+
+        with patch(
+            "graphiti_core.embedder.voyage.VoyageAIConfig",
+        ) as mock_config_class:
+            with patch(
+                "graphiti_core.embedder.voyage.VoyageEmbedder",
+                return_value=mock_embedder,
+            ):
+                create_voyage_embedder(mock_config)
+
+                # Verify VoyageAIConfig was called with correct arguments
+                call_kwargs = mock_config_class.call_args.kwargs
+                assert call_kwargs["api_key"] == "test-voyage-key-123"
+                assert call_kwargs["embedding_model"] == "voyage-3-lite"

apps/backend/integrations/graphiti/tests/test_queries.py

@@ -0,0 +1,783 @@
+"""
+Tests for GraphitiQueries class.
+
+Tests cover:
+- GraphitiQueries initialization
+- add_session_insight()
+- add_codebase_discoveries()
+- add_pattern()
+- add_gotcha()
+- add_task_outcome()
+- add_structured_insights()
+"""
+
+import json
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+# =============================================================================
+# Mock External Dependencies
+# =============================================================================
+
+
+@pytest.fixture(autouse=True)
+def mock_graphiti_core_nodes():
+    """Auto-mock graphiti_core for all tests."""
+    import sys
+
+    # Patch graphiti_core at module level before import
+    mock_graphiti_core = MagicMock()
+    mock_nodes = MagicMock()
+    mock_episode_type = MagicMock()
+    mock_episode_type.text = "text"
+    mock_nodes.EpisodeType = mock_episode_type
+    mock_graphiti_core.nodes = mock_nodes
+
+    sys.modules["graphiti_core"] = mock_graphiti_core
+    sys.modules["graphiti_core.nodes"] = mock_nodes
+
+    try:
+        yield mock_episode_type
+    finally:
+        # Clean up - always run even if test fails
+        sys.modules.pop("graphiti_core", None)
+        sys.modules.pop("graphiti_core.nodes", None)
+
+
+# =============================================================================
+# Client and Queries Fixtures
+# =============================================================================
+
+
+@pytest.fixture
+def mock_client():
+    """Create a mock GraphitiClient."""
+    client = MagicMock()
+    client.graphiti = MagicMock()
+    client.graphiti.add_episode = AsyncMock()
+    return client
+
+
+@pytest.fixture
+def queries(mock_client):
+    """Create a GraphitiQueries instance."""
+    from integrations.graphiti.queries_pkg.queries import GraphitiQueries
+
+    return GraphitiQueries(
+        client=mock_client,
+        group_id="test_group",
+        spec_context_id="test_spec",
+    )
+
+
+# =============================================================================
+# Test Classes
+# =============================================================================
+
+
+class TestGraphitiQueriesInit:
+    """Test GraphitiQueries initialization."""
+
+    def test_init_sets_attributes(self, mock_client):
+        """Test constructor sets all attributes correctly."""
+        from integrations.graphiti.queries_pkg.queries import GraphitiQueries
+
+        queries = GraphitiQueries(
+            client=mock_client,
+            group_id="my_group",
+            spec_context_id="my_spec",
+        )
+
+        assert queries.client == mock_client
+        assert queries.group_id == "my_group"
+        assert queries.spec_context_id == "my_spec"
+
+
+class TestAddSessionInsight:
+    """Test add_session_insight method."""
+
+    @pytest.mark.asyncio
+    async def test_add_session_insight_success(self, queries):
+        """Test successful session insight save."""
+        insights = {
+            "subtasks_completed": ["task-1", "task-2"],
+            "discoveries": {"files_understood": {}},
+            "what_worked": ["Using pytest"],
+            "what_failed": [],
+        }
+
+        result = await queries.add_session_insight(session_num=1, insights=insights)
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_called_once()
+
+        # Verify episode format
+        call_args = queries.client.graphiti.add_episode.call_args
+        assert "session_001_test_spec" in call_args[1]["name"]
+
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["type"] == "session_insight"
+        assert episode_body["session_number"] == 1
+        assert episode_body["spec_id"] == "test_spec"
+        assert "subtasks_completed" in episode_body
+
+    @pytest.mark.asyncio
+    async def test_add_session_insight_exception(self, queries):
+        """Test exception handling in add_session_insight."""
+        queries.client.graphiti.add_episode.side_effect = Exception("Database error")
+
+        result = await queries.add_session_insight(session_num=1, insights={})
+
+        assert result is False
+
+
+class TestAddCodebaseDiscoveries:
+    """Test add_codebase_discoveries method."""
+
+    @pytest.mark.asyncio
+    async def test_add_codebase_discoveries_empty_dict(self, queries):
+        """Test empty discoveries returns True without calling add_episode."""
+        result = await queries.add_codebase_discoveries({})
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_add_codebase_discoveries_success(self, queries):
+        """Test successful codebase discoveries save."""
+        discoveries = {
+            "src/main.py": "Entry point for the application",
+            "src/config.py": "Configuration module",
+        }
+
+        result = await queries.add_codebase_discoveries(discoveries)
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_called_once()
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["type"] == "codebase_discovery"
+        assert episode_body["files"] == discoveries
+
+    @pytest.mark.asyncio
+    async def test_add_codebase_discoveries_exception(self, queries):
+        """Test exception handling in add_codebase_discoveries."""
+        queries.client.graphiti.add_episode.side_effect = Exception("Database error")
+
+        result = await queries.add_codebase_discoveries({"file.py": "desc"})
+
+        assert result is False
+
+
+class TestAddPattern:
+    """Test add_pattern method."""
+
+    @pytest.mark.asyncio
+    async def test_add_pattern_success(self, queries):
+        """Test successful pattern save."""
+        pattern = "Use dependency injection for database connections"
+
+        result = await queries.add_pattern(pattern)
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_called_once()
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["type"] == "pattern"
+        assert episode_body["pattern"] == pattern
+
+    @pytest.mark.asyncio
+    async def test_add_pattern_exception(self, queries):
+        """Test exception handling in add_pattern."""
+        queries.client.graphiti.add_episode.side_effect = Exception("Database error")
+
+        result = await queries.add_pattern("test pattern")
+
+        assert result is False
+
+
+class TestAddGotcha:
+    """Test add_gotcha method."""
+
+    @pytest.mark.asyncio
+    async def test_add_gotcha_success(self, queries):
+        """Test successful gotcha save."""
+        gotcha = "Always close database connections in finally blocks"
+
+        result = await queries.add_gotcha(gotcha)
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_called_once()
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["type"] == "gotcha"
+        assert episode_body["gotcha"] == gotcha
+
+    @pytest.mark.asyncio
+    async def test_add_gotcha_exception(self, queries):
+        """Test exception handling in add_gotcha."""
+        queries.client.graphiti.add_episode.side_effect = Exception("Database error")
+
+        result = await queries.add_gotcha("test gotcha")
+
+        assert result is False
+
+
+class TestAddTaskOutcome:
+    """Test add_task_outcome method."""
+
+    @pytest.mark.asyncio
+    async def test_add_task_outcome_success(self, queries):
+        """Test successful task outcome save."""
+        result = await queries.add_task_outcome(
+            task_id="task-123",
+            success=True,
+            outcome="Implementation completed successfully",
+            metadata={"duration": 120},
+        )
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_called_once()
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["type"] == "task_outcome"
+        assert episode_body["task_id"] == "task-123"
+        assert episode_body["success"] is True
+        assert episode_body["outcome"] == "Implementation completed successfully"
+        assert episode_body["duration"] == 120
+
+    @pytest.mark.asyncio
+    async def test_add_task_outcome_without_metadata(self, queries):
+        """Test task outcome save without metadata."""
+        result = await queries.add_task_outcome(
+            task_id="task-456",
+            success=False,
+            outcome="Failed due to timeout",
+        )
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["task_id"] == "task-456"
+        assert episode_body["success"] is False
+        assert episode_body["outcome"] == "Failed due to timeout"
+
+    @pytest.mark.asyncio
+    async def test_add_task_outcome_exception(self, queries):
+        """Test exception handling in add_task_outcome."""
+        queries.client.graphiti.add_episode.side_effect = Exception("Database error")
+
+        result = await queries.add_task_outcome("task-1", True, "success")
+
+        assert result is False
+
+
+class TestAddStructuredInsights:
+    """Test add_structured_insights method."""
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_empty_dict(self, queries):
+        """Test empty insights returns True."""
+        result = await queries.add_structured_insights({})
+
+        assert result is True
+        queries.client.graphiti.add_episode.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_with_file_insights(self, queries):
+        """Test structured insights with file insights."""
+        insights = {
+            "file_insights": [
+                {
+                    "path": "src/main.py",
+                    "purpose": "Entry point",
+                    "changes_made": "Added error handling",
+                    "patterns_used": ["error boundaries"],
+                    "gotchas": ["needs timeout"],
+                }
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+        assert queries.client.graphiti.add_episode.call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_with_patterns(self, queries):
+        """Test structured insights with discovered patterns."""
+        insights = {
+            "patterns_discovered": [
+                {
+                    "pattern": "Use factory pattern for object creation",
+                    "applies_to": "Complex object initialization",
+                    "example": "src/factory.py",
+                },
+                "Simple pattern string",  # Test non-dict pattern
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+        assert queries.client.graphiti.add_episode.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_with_gotchas(self, queries):
+        """Test structured insights with discovered gotchas."""
+        insights = {
+            "gotchas_discovered": [
+                {
+                    "gotcha": "Don't use mutable default arguments",
+                    "trigger": "Function definition with [] as default",
+                    "solution": "Use None and check in function body",
+                }
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_with_outcome(self, queries):
+        """Test structured insights with approach outcome."""
+        insights = {
+            "subtask_id": "task-1",
+            "approach_outcome": {
+                "success": True,
+                "approach_used": "Used Graphiti for memory",
+                "why_it_worked": "Efficient semantic search",
+                "alternatives_tried": ["PostgreSQL"],
+            },
+            "changed_files": ["src/memory.py"],
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_with_recommendations(self, queries):
+        """Test structured insights with recommendations."""
+        insights = {
+            "subtask_id": "task-2",
+            "recommendations": [
+                "Add error handling",
+                "Improve test coverage",
+            ],
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_handles_duplicate_facts_error(self, queries):
+        """Test that duplicate_facts error is handled as non-fatal."""
+        insights = {"file_insights": [{"path": "src/test.py", "purpose": "Test file"}]}
+
+        # First call fails with duplicate_facts, second succeeds
+        queries.client.graphiti.add_episode.side_effect = [
+            Exception("invalid duplicate_facts idx"),
+            None,  # Second call succeeds
+        ]
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_string_pattern(self, queries):
+        """Test string pattern (non-dict) handling."""
+        insights = {"patterns_discovered": ["Simple string pattern"]}
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["pattern"] == "Simple string pattern"
+        assert episode_body["applies_to"] == ""
+        assert episode_body["example"] == ""
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_string_gotcha(self, queries):
+        """Test string gotcha (non-dict) handling."""
+        insights = {"gotchas_discovered": ["Simple string gotcha"]}
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["gotcha"] == "Simple string gotcha"
+        assert episode_body["trigger"] == ""
+        assert episode_body["solution"] == ""
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_file_insight_with_all_fields(self, queries):
+        """Test file insight with all optional fields."""
+        insights = {
+            "file_insights": [
+                {
+                    "path": "src/test.py",
+                    "purpose": "Test module",
+                    "changes_made": "Added new tests",
+                    "patterns_used": ["pattern1", "pattern2"],
+                    "gotchas": ["gotcha1", "gotcha2"],
+                }
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["file_path"] == "src/test.py"
+        assert episode_body["purpose"] == "Test module"
+        assert episode_body["changes_made"] == "Added new tests"
+        assert episode_body["patterns_used"] == ["pattern1", "pattern2"]
+        assert episode_body["gotchas"] == ["gotcha1", "gotcha2"]
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_gotcha_non_duplicate_exception(
+        self, queries
+    ):
+        """Test gotcha save with non-duplicate_facts exception."""
+        insights = {"gotchas_discovered": [{"gotcha": "Test gotcha"}]}
+
+        # Raise non-duplicate error
+        queries.client.graphiti.add_episode.side_effect = Exception("Other error")
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return False since all saves failed
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_gotcha_duplicate_facts_exception(
+        self, queries
+    ):
+        """Test gotcha save with duplicate_facts exception (lines 418-419)."""
+        insights = {"gotchas_discovered": [{"gotcha": "Test gotcha"}]}
+
+        # Raise duplicate_facts error (should be counted as success)
+        queries.client.graphiti.add_episode.side_effect = Exception(
+            "invalid duplicate_facts idx"
+        )
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return True because duplicate_facts is non-fatal
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_outcome_non_duplicate_exception(
+        self, queries
+    ):
+        """Test outcome save with non-duplicate_facts exception."""
+        insights = {
+            "subtask_id": "task-1",
+            "approach_outcome": {"success": True, "approach_used": "Test approach"},
+        }
+
+        # Raise non-duplicate error
+        queries.client.graphiti.add_episode.side_effect = Exception("Other error")
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return False since all saves failed
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_outcome_duplicate_facts_exception(
+        self, queries
+    ):
+        """Test outcome save with duplicate_facts exception (lines 457-458)."""
+        insights = {
+            "subtask_id": "task-1",
+            "approach_outcome": {"success": True, "approach_used": "Test approach"},
+        }
+
+        # Raise duplicate_facts error (should be counted as success)
+        queries.client.graphiti.add_episode.side_effect = Exception(
+            "invalid duplicate_facts idx"
+        )
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return True because duplicate_facts is non-fatal
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_recommendations_non_duplicate_exception(
+        self, queries
+    ):
+        """Test recommendations save with non-duplicate_facts exception."""
+        insights = {"subtask_id": "task-1", "recommendations": ["Test recommendation"]}
+
+        # Raise non-duplicate error
+        queries.client.graphiti.add_episode.side_effect = Exception("Other error")
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return False since all saves failed
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_recommendations_duplicate_facts_exception(
+        self, queries
+    ):
+        """Test recommendations save with duplicate_facts exception (lines 488-489)."""
+        insights = {"subtask_id": "task-1", "recommendations": ["Test recommendation"]}
+
+        # Raise duplicate_facts error (should be counted as success)
+        queries.client.graphiti.add_episode.side_effect = Exception(
+            "invalid duplicate_facts idx"
+        )
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return True because duplicate_facts is non-fatal
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_top_level_exception_with_content(
+        self, queries
+    ):
+        """Test top-level exception with insights content."""
+        insights = {
+            "file_insights": [{"path": "test.py", "purpose": "test"}],
+            "patterns_discovered": [{"pattern": "test pattern"}],
+            "gotchas_discovered": [{"gotcha": "test gotcha"}],
+            "approach_outcome": {"success": True},
+            "recommendations": ["test recommendation"],
+        }
+
+        # Mock exception during processing
+        with patch(
+            "integrations.graphiti.queries_pkg.queries.json.dumps",
+            side_effect=Exception("JSON error"),
+        ):
+            result = await queries.add_structured_insights(insights)
+
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_outer_exception_handler(self, queries):
+        """Test outer exception handler for add_structured_insights (lines 499-523)."""
+        insights = {
+            "file_insights": [{"path": "test.py", "purpose": "test"}],
+            "patterns_discovered": [{"pattern": "Test pattern"}],
+            "gotchas_discovered": [{"gotcha": "Test gotcha"}],
+            "approach_outcome": {"success": True, "approach_used": "Test approach"},
+            "recommendations": ["Test recommendation"],
+        }
+
+        # Mock EpisodeType import to fail, triggering outer exception handler
+        import builtins
+
+        original_import = builtins.__import__
+
+        def mock_import(name, *args, **kwargs):
+            if name == "graphiti_core.nodes":
+                raise ImportError("EpisodeType not available")
+            return original_import(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            result = await queries.add_structured_insights(insights)
+
+        # Should return False and trigger outer exception handler
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_all_fail(self, queries):
+        """Test when all episode saves fail."""
+        insights = {"file_insights": [{"path": "test.py", "purpose": "test"}]}
+
+        queries.client.graphiti.add_episode.side_effect = Exception("Total failure")
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is False
+
+
+class TestAddStructuredInsightsExceptionHandling:
+    """Test add_structured_insights exception handling branches."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "insights_key,insights_value",
+        [
+            ("patterns_discovered", [{"pattern": "Test pattern"}]),
+            ("gotchas_discovered", [{"gotcha": "Test gotcha"}]),
+            (
+                "approach_outcome",
+                {
+                    "subtask_id": "task-1",
+                    "success": True,
+                    "approach_used": "Test approach",
+                },
+            ),
+            (
+                "recommendations",
+                {"subtask_id": "task-1", "recommendations": ["Test recommendation"]},
+            ),
+        ],
+    )
+    async def test_add_structured_insights_non_duplicate_exception(
+        self, queries, insights_key, insights_value
+    ):
+        """Test exception handling for non-duplicate errors across different insight types."""
+        insights = {insights_key: insights_value}
+
+        queries.client.graphiti.add_episode.side_effect = Exception(
+            "Non-duplicate error"
+        )
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_top_level_exception(self, queries):
+        """Test top-level exception handling in add_structured_insights."""
+        insights = {"file_insights": [{"path": "test.py", "purpose": "test"}]}
+
+        # Simulate exception during JSON serialization
+        with patch(
+            "integrations.graphiti.queries_pkg.queries.json.dumps",
+            side_effect=Exception("JSON error"),
+        ):
+            result = await queries.add_structured_insights(insights)
+
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_mixed_success_failure(self, queries):
+        """Test mixed success and failure in structured insights."""
+        insights = {
+            "file_insights": [
+                {"path": "test1.py", "purpose": "test1"},
+                {"path": "test2.py", "purpose": "test2"},
+            ]
+        }
+
+        # First succeeds, second fails with non-duplicate error
+        queries.client.graphiti.add_episode.side_effect = [
+            None,  # First succeeds
+            Exception("Non-duplicate error"),  # Second fails
+        ]
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return True because at least one succeeded
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_all_patterns_fail_with_duplicate(
+        self, queries
+    ):
+        """Test all pattern saves fail with duplicate_facts error."""
+        insights = {
+            "patterns_discovered": [{"pattern": "Pattern 1"}, {"pattern": "Pattern 2"}]
+        }
+
+        # Both fail with duplicate_facts error (should be counted as success)
+        queries.client.graphiti.add_episode.side_effect = [
+            Exception("invalid duplicate_facts idx"),
+            Exception("invalid duplicate_facts idx"),
+        ]
+
+        result = await queries.add_structured_insights(insights)
+
+        # Should return True because duplicate_facts is non-fatal
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_dict_pattern_with_all_fields(self, queries):
+        """Test dict pattern with applies_to and example fields."""
+        insights = {
+            "patterns_discovered": [
+                {
+                    "pattern": "Factory pattern",
+                    "applies_to": "Object creation",
+                    "example": "src/factory.py",
+                }
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+        assert queries.client.graphiti.add_episode.call_count == 1
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["pattern"] == "Factory pattern"
+        assert episode_body["applies_to"] == "Object creation"
+        assert episode_body["example"] == "src/factory.py"
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_dict_gotcha_with_all_fields(self, queries):
+        """Test dict gotcha with trigger and solution fields."""
+        insights = {
+            "gotchas_discovered": [
+                {
+                    "gotcha": "Mutable default args",
+                    "trigger": "Function with [] as default",
+                    "solution": "Use None and check in body",
+                }
+            ]
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["gotcha"] == "Mutable default args"
+        assert episode_body["trigger"] == "Function with [] as default"
+        assert episode_body["solution"] == "Use None and check in body"
+
+    @pytest.mark.asyncio
+    async def test_add_structured_insights_outcome_with_all_fields(self, queries):
+        """Test outcome with all optional fields."""
+        insights = {
+            "subtask_id": "task-1",
+            "approach_outcome": {
+                "success": True,
+                "approach_used": "Test approach",
+                "why_it_worked": "Because reasons",
+                "why_it_failed": None,
+                "alternatives_tried": ["Alt1", "Alt2"],
+            },
+            "changed_files": ["file1.py", "file2.py"],
+        }
+
+        result = await queries.add_structured_insights(insights)
+
+        assert result is True
+
+        call_args = queries.client.graphiti.add_episode.call_args
+        episode_body = json.loads(call_args[1]["episode_body"])
+        assert episode_body["task_id"] == "task-1"
+        assert episode_body["success"] is True
+        assert episode_body["outcome"] == "Test approach"
+        assert episode_body["why_worked"] == "Because reasons"
+        assert episode_body["why_failed"] is None
+        assert episode_body["alternatives_tried"] == ["Alt1", "Alt2"]
+        assert episode_body["changed_files"] == ["file1.py", "file2.py"]

apps/backend/integrations/graphiti/tests/test_schema.py

@@ -0,0 +1,123 @@
+"""
+Tests for Graphiti schema constants and types.
+
+Tests cover:
+- Episode type constants
+- MAX_CONTEXT_RESULTS constant
+- GroupIdMode enum values
+"""
+
+import pytest
+from integrations.graphiti.queries_pkg.schema import (
+    EPISODE_TYPE_CODEBASE_DISCOVERY,
+    EPISODE_TYPE_GOTCHA,
+    EPISODE_TYPE_HISTORICAL_CONTEXT,
+    EPISODE_TYPE_PATTERN,
+    EPISODE_TYPE_QA_RESULT,
+    EPISODE_TYPE_SESSION_INSIGHT,
+    EPISODE_TYPE_TASK_OUTCOME,
+    MAX_CONTEXT_RESULTS,
+    MAX_RETRIES,
+    RETRY_DELAY_SECONDS,
+    GroupIdMode,
+)
+
+
+class TestEpisodeTypeConstants:
+    """Test episode type constants."""
+
+    def test_session_insight_constant(self):
+        """Test EPISODE_TYPE_SESSION_INSIGHT constant."""
+        assert EPISODE_TYPE_SESSION_INSIGHT == "session_insight"
+        assert isinstance(EPISODE_TYPE_SESSION_INSIGHT, str)
+
+    def test_codebase_discovery_constant(self):
+        """Test EPISODE_TYPE_CODEBASE_DISCOVERY constant."""
+        assert EPISODE_TYPE_CODEBASE_DISCOVERY == "codebase_discovery"
+        assert isinstance(EPISODE_TYPE_CODEBASE_DISCOVERY, str)
+
+    def test_pattern_constant(self):
+        """Test EPISODE_TYPE_PATTERN constant."""
+        assert EPISODE_TYPE_PATTERN == "pattern"
+        assert isinstance(EPISODE_TYPE_PATTERN, str)
+
+    def test_gotcha_constant(self):
+        """Test EPISODE_TYPE_GOTCHA constant."""
+        assert EPISODE_TYPE_GOTCHA == "gotcha"
+        assert isinstance(EPISODE_TYPE_GOTCHA, str)
+
+    def test_task_outcome_constant(self):
+        """Test EPISODE_TYPE_TASK_OUTCOME constant."""
+        assert EPISODE_TYPE_TASK_OUTCOME == "task_outcome"
+        assert isinstance(EPISODE_TYPE_TASK_OUTCOME, str)
+
+    def test_qa_result_constant(self):
+        """Test EPISODE_TYPE_QA_RESULT constant."""
+        assert EPISODE_TYPE_QA_RESULT == "qa_result"
+        assert isinstance(EPISODE_TYPE_QA_RESULT, str)
+
+    def test_historical_context_constant(self):
+        """Test EPISODE_TYPE_HISTORICAL_CONTEXT constant."""
+        assert EPISODE_TYPE_HISTORICAL_CONTEXT == "historical_context"
+        assert isinstance(EPISODE_TYPE_HISTORICAL_CONTEXT, str)
+
+    def test_all_episode_types_are_unique(self):
+        """Test that all episode type constants have unique values."""
+        episode_types = [
+            EPISODE_TYPE_SESSION_INSIGHT,
+            EPISODE_TYPE_CODEBASE_DISCOVERY,
+            EPISODE_TYPE_PATTERN,
+            EPISODE_TYPE_GOTCHA,
+            EPISODE_TYPE_TASK_OUTCOME,
+            EPISODE_TYPE_QA_RESULT,
+            EPISODE_TYPE_HISTORICAL_CONTEXT,
+        ]
+        assert len(episode_types) == len(set(episode_types)), (
+            "Episode types must be unique"
+        )
+
+
+class TestMaxContextResults:
+    """Test MAX_CONTEXT_RESULTS constant."""
+
+    def test_max_context_results_is_positive_integer(self):
+        """Test MAX_CONTEXT_RESULTS is a positive integer."""
+        assert isinstance(MAX_CONTEXT_RESULTS, int)
+        assert MAX_CONTEXT_RESULTS > 0
+
+    def test_max_context_results_reasonable_value(self):
+        """Test MAX_CONTEXT_RESULTS has a reasonable value."""
+        # Should be between 1 and 100 for practical use
+        assert 1 <= MAX_CONTEXT_RESULTS <= 100
+
+
+class TestRetryConfiguration:
+    """Test retry configuration constants."""
+
+    def test_max_retries_is_positive_integer(self):
+        """Test MAX_RETRIES is a positive integer."""
+        assert isinstance(MAX_RETRIES, int)
+        assert MAX_RETRIES > 0
+
+    def test_retry_delay_is_positive_number(self):
+        """Test RETRY_DELAY_SECONDS is a positive number."""
+        assert isinstance(RETRY_DELAY_SECONDS, (int, float))
+        assert RETRY_DELAY_SECONDS >= 0
+
+
+class TestGroupIdMode:
+    """Test GroupIdMode class."""
+
+    def test_spec_mode_constant(self):
+        """Test GroupIdMode.SPEC constant."""
+        assert GroupIdMode.SPEC == "spec"
+        assert isinstance(GroupIdMode.SPEC, str)
+
+    def test_project_mode_constant(self):
+        """Test GroupIdMode.PROJECT constant."""
+        assert GroupIdMode.PROJECT == "project"
+        assert isinstance(GroupIdMode.PROJECT, str)
+
+    def test_modes_are_unique(self):
+        """Test that mode values are unique."""
+        assert GroupIdMode.SPEC != GroupIdMode.PROJECT

apps/backend/memory/graphiti_helpers.py

@@ -17,7 +17,7 @@ from core.sentry import capture_exception
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from graphiti_memory import GraphitiMemory
+    from integrations.graphiti.memory import GraphitiMemory
 
 
 def is_graphiti_memory_enabled() -> bool:
@@ -60,7 +60,7 @@ async def get_graphiti_memory(
         return None
 
     try:
-        from graphiti_memory import GraphitiMemory, GroupIdMode
+        from integrations.graphiti.memory import GraphitiMemory, GroupIdMode
 
         if project_dir is None:
             project_dir = spec_dir.parent.parent

apps/backend/merge/conflict_resolver.py

@@ -17,6 +17,7 @@ import logging
 from .ai_resolver import AIResolver
 from .auto_merger import AutoMerger, MergeContext
 from .file_merger import apply_ai_merge, extract_location_content
+from .progress import MergeProgressCallback, MergeProgressStage
 from .types import (
     ConflictRegion,
     ConflictSeverity,
@@ -60,6 +61,7 @@ class ConflictResolver:
         baseline_content: str,
         task_snapshots: list[TaskSnapshot],
         conflicts: list[ConflictRegion],
+        progress_callback: MergeProgressCallback | None = None,
     ) -> MergeResult:
         """
         Resolve conflicts using AutoMerger and AIResolver.
@@ -69,6 +71,8 @@ class ConflictResolver:
             baseline_content: Original file content
             task_snapshots: Snapshots from all tasks modifying this file
             conflicts: List of detected conflicts
+            progress_callback: Optional callback for emitting per-conflict
+                resolution progress with details about current file and conflict count
 
         Returns:
             MergeResult with resolution details
@@ -78,8 +82,23 @@ class ConflictResolver:
         remaining: list[ConflictRegion] = []
         ai_calls = 0
         tokens_used = 0
+        total_conflicts = len(conflicts)
 
-        for conflict in conflicts:
+        for idx, conflict in enumerate(conflicts):
+            if progress_callback:
+                # Emit per-conflict progress within the resolving stage (50-75%)
+                # Calculate progress after processing (idx + 1) to reach 75% on last conflict
+                conflict_percent = 50 + int(((idx + 1) / max(total_conflicts, 1)) * 25)
+                progress_callback(
+                    stage=MergeProgressStage.RESOLVING,
+                    percent=conflict_percent,
+                    message=f"Resolving conflict {idx + 1}/{total_conflicts} in {file_path}",
+                    details={
+                        "current_file": file_path,
+                        "conflicts_found": total_conflicts,
+                        "conflicts_resolved": len(resolved),
+                    },
+                )
             # Try auto-merge first
             if conflict.can_auto_merge and conflict.merge_strategy:
                 context = MergeContext(

apps/backend/merge/merge_pipeline.py

@@ -18,6 +18,7 @@ import logging
 from .conflict_detector import ConflictDetector
 from .conflict_resolver import ConflictResolver
 from .file_merger import apply_single_task_changes, combine_non_conflicting_changes
+from .progress import MergeProgressCallback, MergeProgressStage
 from .types import (
     ChangeType,
     FileAnalysis,
@@ -57,6 +58,7 @@ class MergePipeline:
         file_path: str,
         baseline_content: str,
         task_snapshots: list[TaskSnapshot],
+        progress_callback: MergeProgressCallback | None = None,
     ) -> MergeResult:
         """
         Merge changes from multiple tasks for a single file.
@@ -65,6 +67,8 @@ class MergePipeline:
             file_path: Path to the file
             baseline_content: Original baseline content
             task_snapshots: Snapshots from tasks that modified this file
+            progress_callback: Optional callback for emitting per-file progress
+                within the 'resolving' stage (50-75% range)
 
         Returns:
             MergeResult with merged content or conflict info
@@ -72,6 +76,14 @@ class MergePipeline:
         task_ids = [s.task_id for s in task_snapshots]
         logger.info(f"Merging {file_path} with {len(task_snapshots)} task(s)")
 
+        if progress_callback:
+            progress_callback(
+                stage=MergeProgressStage.RESOLVING,
+                percent=50,
+                message=f"Merging file: {file_path}",
+                details={"current_file": file_path},
+            )
+
         # If only one task modified the file, no conflict possible
         if len(task_snapshots) == 1:
             snapshot = task_snapshots[0]
@@ -119,6 +131,7 @@ class MergePipeline:
             baseline_content=baseline_content,
             task_snapshots=task_snapshots,
             conflicts=conflicts,
+            progress_callback=progress_callback,
         )
 
     def _build_task_analyses(

apps/backend/merge/orchestrator.py

@@ -33,6 +33,7 @@ from .merge_pipeline import MergePipeline
 
 # Re-export models for backwards compatibility
 from .models import MergeReport, MergeStats, TaskMergeRequest
+from .progress import MergeProgressCallback, MergeProgressStage
 from .semantic_analyzer import SemanticAnalyzer
 from .types import (
     ConflictRegion,
@@ -260,6 +261,7 @@ class MergeOrchestrator:
         task_id: str,
         worktree_path: Path | None = None,
         target_branch: str = "main",
+        progress_callback: MergeProgressCallback | None = None,
     ) -> MergeReport:
         """
         Merge a single task's changes into the target branch.
@@ -268,6 +270,8 @@ class MergeOrchestrator:
             task_id: The task identifier
             worktree_path: Path to the task's worktree (auto-detected if not provided)
             target_branch: Branch to merge into
+            progress_callback: Optional callback for progress updates.
+                Called with (stage, percent, message, details) at key pipeline stages.
 
         Returns:
             MergeReport with results
@@ -284,7 +288,20 @@ class MergeOrchestrator:
         report = MergeReport(started_at=datetime.now(), tasks_merged=[task_id])
         start_time = datetime.now()
 
+        def _emit(
+            stage: MergeProgressStage,
+            percent: int,
+            message: str,
+            details: dict[str, Any] | None = None,
+        ) -> None:
+            """Emit progress if a callback is provided."""
+            if progress_callback is not None:
+                progress_callback(stage, percent, message, details)
+
         try:
+            # --- ANALYZING stage (0-25%) ---
+            _emit(MergeProgressStage.ANALYZING, 0, "Starting merge analysis")
+
             # Find worktree if not provided
             if worktree_path is None:
                 debug_detailed(MODULE, "Auto-detecting worktree path...")
@@ -293,16 +310,23 @@ class MergeOrchestrator:
                     debug_error(MODULE, f"Could not find worktree for task {task_id}")
                     report.success = False
                     report.error = f"Could not find worktree for task {task_id}"
+                    _emit(
+                        MergeProgressStage.ERROR,
+                        0,
+                        f"Could not find worktree for task {task_id}",
+                    )
                     return report
                 debug_detailed(MODULE, f"Found worktree: {worktree_path}")
 
             # Ensure evolution data is up to date
+            _emit(MergeProgressStage.ANALYZING, 5, "Loading file evolution data")
             debug(MODULE, "Refreshing evolution data from git...")
             self.evolution_tracker.refresh_from_git(
                 task_id, worktree_path, target_branch=target_branch
             )
 
             # Get files modified by this task
+            _emit(MergeProgressStage.ANALYZING, 15, "Running semantic analysis")
             modifications = self.evolution_tracker.get_task_modifications(task_id)
             debug(
                 MODULE,
@@ -312,11 +336,39 @@ class MergeOrchestrator:
             if not modifications:
                 debug_warning(MODULE, f"No modifications found for task {task_id}")
                 logger.info(f"No modifications found for task {task_id}")
+                _emit(
+                    MergeProgressStage.COMPLETE,
+                    100,
+                    "No modifications found",
+                )
                 report.completed_at = datetime.now()
                 return report
 
-            # Process each modified file
-            for file_path, snapshot in modifications:
+            _emit(
+                MergeProgressStage.ANALYZING,
+                25,
+                f"Found {len(modifications)} modified files",
+            )
+
+            # --- DETECTING_CONFLICTS stage (25-50%) ---
+            _emit(
+                MergeProgressStage.DETECTING_CONFLICTS,
+                25,
+                "Detecting conflicts",
+            )
+
+            # --- RESOLVING stage (50-75%) ---
+            total_files = len(modifications)
+            for idx, (file_path, snapshot) in enumerate(modifications):
+                # Calculate progress after processing (idx + 1) to reach 75% on last file
+                file_percent = 50 + int(((idx + 1) / max(total_files, 1)) * 25)
+                _emit(
+                    MergeProgressStage.RESOLVING,
+                    file_percent,
+                    f"Merging file {idx + 1}/{total_files}",
+                    {"current_file": file_path},
+                )
+
                 debug_detailed(
                     MODULE,
                     f"Processing file: {file_path}",
@@ -349,13 +401,31 @@ class MergeOrchestrator:
                     file=file_path,
                 )
 
+            # --- VALIDATING stage (75-100%) ---
+            _emit(
+                MergeProgressStage.VALIDATING,
+                75,
+                "Validating merge results",
+                {
+                    "conflicts_found": report.stats.conflicts_detected,
+                    "conflicts_resolved": report.stats.conflicts_auto_resolved,
+                },
+            )
+
             report.success = report.stats.files_failed == 0
 
+            _emit(
+                MergeProgressStage.VALIDATING,
+                90,
+                "Validation complete",
+            )
+
         except Exception as e:
             debug_error(MODULE, f"Merge failed for task {task_id}", error=str(e))
             logger.exception(f"Merge failed for task {task_id}")
             report.success = False
             report.error = str(e)
+            _emit(MergeProgressStage.ERROR, 0, f"Merge failed: {e}")
 
         report.completed_at = datetime.now()
         report.stats.duration_seconds = (
@@ -366,6 +436,18 @@ class MergeOrchestrator:
         if not self.dry_run:
             self._save_report(report, task_id)
 
+        # --- COMPLETE stage (100%) ---
+        if report.success:
+            _emit(
+                MergeProgressStage.COMPLETE,
+                100,
+                f"Merge complete for {task_id}",
+                {
+                    "conflicts_found": report.stats.conflicts_detected,
+                    "conflicts_resolved": report.stats.conflicts_auto_resolved,
+                },
+            )
+
         debug_success(
             MODULE,
             f"Merge complete for {task_id}",
@@ -382,6 +464,7 @@ class MergeOrchestrator:
         self,
         requests: list[TaskMergeRequest],
         target_branch: str = "main",
+        progress_callback: MergeProgressCallback | None = None,
     ) -> MergeReport:
         """
         Merge multiple tasks' changes.
@@ -392,6 +475,8 @@ class MergeOrchestrator:
         Args:
             requests: List of merge requests (one per task)
             target_branch: Branch to merge into
+            progress_callback: Optional callback for progress updates.
+                Called with (stage, percent, message, details) at key pipeline stages.
 
         Returns:
             MergeReport with combined results
@@ -402,11 +487,33 @@ class MergeOrchestrator:
         )
         start_time = datetime.now()
 
+        def _emit(
+            stage: MergeProgressStage,
+            percent: int,
+            message: str,
+            details: dict[str, Any] | None = None,
+        ) -> None:
+            """Emit progress if a callback is provided."""
+            if progress_callback is not None:
+                progress_callback(stage, percent, message, details)
+
         try:
+            # --- ANALYZING stage (0-25%) ---
+            _emit(
+                MergeProgressStage.ANALYZING,
+                0,
+                f"Starting merge analysis for {len(requests)} tasks",
+            )
+
             # Sort by priority (higher first)
             requests = sorted(requests, key=lambda r: -r.priority)
 
             # Refresh evolution data for all tasks
+            _emit(
+                MergeProgressStage.ANALYZING,
+                5,
+                "Loading file evolution data",
+            )
             for request in requests:
                 if request.worktree_path and request.worktree_path.exists():
                     self.evolution_tracker.refresh_from_git(
@@ -416,11 +523,38 @@ class MergeOrchestrator:
                     )
 
             # Find all files modified by any task
+            _emit(
+                MergeProgressStage.ANALYZING,
+                15,
+                "Running semantic analysis",
+            )
             task_ids = [r.task_id for r in requests]
             file_tasks = self.evolution_tracker.get_files_modified_by_tasks(task_ids)
 
-            # Process each file
-            for file_path, modifying_tasks in file_tasks.items():
+            _emit(
+                MergeProgressStage.ANALYZING,
+                25,
+                f"Found {len(file_tasks)} files to merge",
+            )
+
+            # --- DETECTING_CONFLICTS stage (25-50%) ---
+            _emit(
+                MergeProgressStage.DETECTING_CONFLICTS,
+                25,
+                "Detecting conflicts across tasks",
+            )
+
+            # --- RESOLVING stage (50-75%) ---
+            total_files = len(file_tasks)
+            for idx, (file_path, modifying_tasks) in enumerate(file_tasks.items()):
+                file_percent = 50 + int((idx / max(total_files, 1)) * 25)
+                _emit(
+                    MergeProgressStage.RESOLVING,
+                    file_percent,
+                    f"Merging file {idx + 1}/{total_files}",
+                    {"current_file": file_path},
+                )
+
                 # Get snapshots from all tasks that modified this file
                 evolution = self.evolution_tracker.get_file_evolution(file_path)
                 if not evolution:
@@ -466,8 +600,25 @@ class MergeOrchestrator:
                 report.file_results[file_path] = result
                 self._update_stats(report.stats, result)
 
+            # --- VALIDATING stage (75-100%) ---
+            _emit(
+                MergeProgressStage.VALIDATING,
+                75,
+                "Validating merge results",
+                {
+                    "conflicts_found": report.stats.conflicts_detected,
+                    "conflicts_resolved": report.stats.conflicts_auto_resolved,
+                },
+            )
+
             report.success = report.stats.files_failed == 0
 
+            _emit(
+                MergeProgressStage.VALIDATING,
+                90,
+                "Validation complete",
+            )
+
         except Exception as e:
             debug_error(
                 MODULE,
@@ -478,6 +629,7 @@ class MergeOrchestrator:
             logger.exception("Merge failed")
             report.success = False
             report.error = str(e)
+            _emit(MergeProgressStage.ERROR, 0, f"Merge failed: {e}")
 
         report.completed_at = datetime.now()
         report.stats.duration_seconds = (
@@ -489,6 +641,18 @@ class MergeOrchestrator:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             self._save_report(report, f"multi_{timestamp}")
 
+        # --- COMPLETE stage (100%) ---
+        if report.success:
+            _emit(
+                MergeProgressStage.COMPLETE,
+                100,
+                f"Merge complete for {len(requests)} tasks",
+                {
+                    "conflicts_found": report.stats.conflicts_detected,
+                    "conflicts_resolved": report.stats.conflicts_auto_resolved,
+                },
+            )
+
         return report
 
     def _merge_file(

apps/backend/merge/progress.py

@@ -0,0 +1,105 @@
+"""
+Merge Progress Emission
+=======================
+
+Structured progress event emission for the merge pipeline.
+
+This module provides the progress reporting infrastructure used by the
+merge orchestrator to communicate real-time status updates to the
+Electron frontend via stdout JSON lines.
+
+Progress events are emitted as JSON lines to stdout with type='progress',
+allowing the frontend to parse them separately from the final merge result.
+
+Components:
+- MergeProgressStage: Enum of pipeline stages
+- MergeProgressCallback: Protocol for type-safe callback threading
+- emit_progress: Function to emit structured progress events to stdout
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from typing import Any, Protocol
+
+
+class MergeProgressStage(Enum):
+    """
+    Stages of the merge pipeline.
+
+    Each stage corresponds to a phase of the merge process and maps
+    to a percentage range for progress reporting:
+    - ANALYZING: 0-25% — Loading file evolution, running semantic analysis
+    - DETECTING_CONFLICTS: 25-50% — Conflict detection and compatibility checks
+    - RESOLVING: 50-75% — Auto-merge and AI resolution of conflicts
+    - VALIDATING: 75-100% — Final validation of merged results
+    - COMPLETE: 100% — Merge finished successfully
+    - ERROR: N/A — Merge failed with an error
+    """
+
+    ANALYZING = "analyzing"
+    DETECTING_CONFLICTS = "detecting_conflicts"
+    RESOLVING = "resolving"
+    VALIDATING = "validating"
+    COMPLETE = "complete"
+    ERROR = "error"
+
+
+class MergeProgressCallback(Protocol):
+    """
+    Protocol for type-safe progress callback threading.
+
+    Implementations receive structured progress updates from the merge
+    pipeline stages and can forward them to any output channel.
+
+    Args:
+        stage: Current pipeline stage
+        percent: Progress percentage (0-100)
+        message: Human-readable status message
+        details: Optional additional context (conflicts_found, conflicts_resolved, current_file)
+    """
+
+    def __call__(
+        self,
+        stage: MergeProgressStage,
+        percent: int,
+        message: str,
+        details: dict[str, Any] | None = None,
+    ) -> None: ...
+
+
+def emit_progress(
+    stage: MergeProgressStage,
+    percent: int,
+    message: str,
+    details: dict[str, Any] | None = None,
+) -> None:
+    """
+    Emit a progress event as a JSON line to stdout.
+
+    The Electron main process parses these JSON lines from the merge
+    subprocess stdout and forwards them to the renderer via IPC.
+
+    Args:
+        stage: Current pipeline stage
+        percent: Progress percentage (0-100), clamped to valid range
+        message: Human-readable status message
+        details: Optional dict with additional context. Supported keys:
+            - conflicts_found (int): Number of conflicts detected
+            - conflicts_resolved (int): Number of conflicts resolved so far
+            - current_file (str): File currently being processed
+    """
+    percent = max(0, min(100, percent))
+
+    event: dict[str, Any] = {
+        "type": "progress",
+        "stage": stage.value,
+        "percent": percent,
+        "message": message,
+    }
+
+    if details:
+        event["details"] = details
+
+    print(json.dumps(event), flush=True)

apps/backend/phase_config.py

@@ -7,35 +7,53 @@ Reads configuration from task_metadata.json and provides resolved model IDs.
 """
 
 import json
+import logging
 import os
 from pathlib import Path
 from typing import Literal, TypedDict
 
+logger = logging.getLogger(__name__)
+
 # Model shorthand to full model ID mapping
+# Values must match apps/frontend/src/shared/constants/models.ts MODEL_ID_MAP
 MODEL_ID_MAP: dict[str, str] = {
-    "opus": "claude-opus-4-5-20251101",
+    "opus": "claude-opus-4-6",
+    "opus-1m": "claude-opus-4-6",
+    "opus-4.5": "claude-opus-4-5-20251101",
     "sonnet": "claude-sonnet-4-5-20250929",
     "haiku": "claude-haiku-4-5-20251001",
 }
 
-# Thinking level to budget tokens mapping (None = no extended thinking)
-# Values must match auto-claude-ui/src/shared/constants/models.ts THINKING_BUDGET_MAP
-THINKING_BUDGET_MAP: dict[str, int | None] = {
-    "none": None,
+# Model shorthand to required SDK beta headers
+# Maps model shorthands that need special beta flags (e.g., 1M context window)
+MODEL_BETAS_MAP: dict[str, list[str]] = {
+    "opus-1m": ["context-1m-2025-08-07"],
+}
+
+# Thinking level to budget tokens mapping
+# Values must match apps/frontend/src/shared/constants/models.ts THINKING_BUDGET_MAP
+THINKING_BUDGET_MAP: dict[str, int] = {
     "low": 1024,
     "medium": 4096,  # Moderate analysis
     "high": 16384,  # Deep thinking for QA review
-    "ultrathink": 63999,  # Maximum reasoning depth (API requires max_tokens >= budget + 1, so 63999 + 1 = 64000 limit)
 }
 
+# Effort level mapping for adaptive thinking models (e.g., Opus 4.6)
+# These models support CLAUDE_CODE_EFFORT_LEVEL env var for effort-based routing
+EFFORT_LEVEL_MAP: dict[str, str] = {"low": "low", "medium": "medium", "high": "high"}
+
+# Models that support adaptive thinking via effort level (env var)
+# These models get both max_thinking_tokens AND effort_level
+ADAPTIVE_THINKING_MODELS: set[str] = {"claude-opus-4-6"}
+
 # Spec runner phase-specific thinking levels
-# Heavy phases use ultrathink for deep analysis
+# Heavy phases use high for deep analysis
 # Light phases use medium after compaction
 SPEC_PHASE_THINKING_LEVELS: dict[str, str] = {
-    # Heavy phases - ultrathink (discovery, spec creation, self-critique)
-    "discovery": "ultrathink",
-    "spec_writing": "ultrathink",
-    "self_critique": "ultrathink",
+    # Heavy phases - high (discovery, spec creation, self-critique)
+    "discovery": "high",
+    "spec_writing": "high",
+    "self_critique": "high",
     # Light phases - medium (after first invocation with compaction)
     "requirements": "medium",
     "research": "medium",
@@ -85,6 +103,7 @@ class TaskMetadataConfig(TypedDict, total=False):
     phaseThinking: PhaseThinkingConfig
     model: str
     thinkingLevel: str
+    fastMode: bool
 
 
 Phase = Literal["spec", "planning", "coding", "qa"]
@@ -112,6 +131,9 @@ def resolve_model_id(model: str) -> str:
             "haiku": "ANTHROPIC_DEFAULT_HAIKU_MODEL",
             "sonnet": "ANTHROPIC_DEFAULT_SONNET_MODEL",
             "opus": "ANTHROPIC_DEFAULT_OPUS_MODEL",
+            "opus-1m": "ANTHROPIC_DEFAULT_OPUS_MODEL",
+            # opus-4.5 intentionally omitted — always resolves to its hardcoded
+            # model ID (claude-opus-4-5-20251101) regardless of env var overrides.
         }
         env_var = env_var_map.get(model)
         if env_var:
@@ -126,23 +148,69 @@ def resolve_model_id(model: str) -> str:
     return model
 
 
-def get_thinking_budget(thinking_level: str) -> int | None:
+def get_model_betas(model_short: str) -> list[str]:
+    """
+    Get required SDK beta headers for a model shorthand.
+
+    Some model configurations (e.g., opus-1m for 1M context window) require
+    passing beta headers to the Claude Agent SDK.
+
+    Args:
+        model_short: Model shorthand (e.g., 'opus', 'opus-1m', 'sonnet')
+
+    Returns:
+        List of beta header strings, or empty list if none required
+    """
+    return MODEL_BETAS_MAP.get(model_short, [])
+
+
+VALID_THINKING_LEVELS = {"low", "medium", "high"}
+
+# Mapping from legacy/removed thinking levels to valid ones
+LEGACY_THINKING_LEVEL_MAP: dict[str, str] = {
+    "ultrathink": "high",
+    "none": "low",
+}
+
+
+def sanitize_thinking_level(thinking_level: str) -> str:
+    """
+    Validate and sanitize a thinking level string.
+
+    Maps legacy values (e.g., 'ultrathink') to valid equivalents and falls
+    back to 'medium' for completely unknown values. Used by CLI argparse
+    handlers to make the backend resilient to invalid values from the frontend.
+
+    Args:
+        thinking_level: Raw thinking level string from CLI or task_metadata.json
+
+    Returns:
+        A valid thinking level string (low, medium, high)
+    """
+    if thinking_level in VALID_THINKING_LEVELS:
+        return thinking_level
+
+    mapped = LEGACY_THINKING_LEVEL_MAP.get(thinking_level, "medium")
+    logger.warning("Invalid thinking level '%s' mapped to '%s'", thinking_level, mapped)
+    return mapped
+
+
+def get_thinking_budget(thinking_level: str) -> int:
     """
     Get the thinking budget for a thinking level.
 
     Args:
-        thinking_level: Thinking level (none, low, medium, high, ultrathink)
+        thinking_level: Thinking level (low, medium, high)
 
     Returns:
-        Token budget or None for no extended thinking
+        Token budget for extended thinking
     """
-    import logging
-
     if thinking_level not in THINKING_BUDGET_MAP:
         valid_levels = ", ".join(THINKING_BUDGET_MAP.keys())
-        logging.warning(
-            f"Invalid thinking_level '{thinking_level}'. Valid values: {valid_levels}. "
-            f"Defaulting to 'medium'."
+        logger.warning(
+            "Invalid thinking_level '%s'. Valid values: %s. Defaulting to 'medium'.",
+            thinking_level,
+            valid_levels,
         )
         return THINKING_BUDGET_MAP["medium"]
 
@@ -214,6 +282,43 @@ def get_phase_model(
     return resolve_model_id(DEFAULT_PHASE_MODELS[phase])
 
 
+def get_phase_model_betas(
+    spec_dir: Path,
+    phase: Phase,
+    cli_model: str | None = None,
+) -> list[str]:
+    """
+    Get required SDK beta headers for the model selected for a specific phase.
+
+    Uses the same priority logic as get_phase_model() to determine which model
+    shorthand is selected, then looks up any required beta headers.
+
+    Args:
+        spec_dir: Path to the spec directory
+        phase: Execution phase (spec, planning, coding, qa)
+        cli_model: Model from CLI argument (optional)
+
+    Returns:
+        List of beta header strings, or empty list if none required
+    """
+    # Determine the model shorthand (before resolution to full ID)
+    if cli_model:
+        return get_model_betas(cli_model)
+
+    metadata = load_task_metadata(spec_dir)
+
+    if metadata:
+        if metadata.get("isAutoProfile") and metadata.get("phaseModels"):
+            phase_models = metadata["phaseModels"]
+            model_short = phase_models.get(phase, DEFAULT_PHASE_MODELS[phase])
+            return get_model_betas(model_short)
+
+        if metadata.get("model"):
+            return get_model_betas(metadata["model"])
+
+    return get_model_betas(DEFAULT_PHASE_MODELS[phase])
+
+
 def get_phase_thinking(
     spec_dir: Path,
     phase: Phase,
@@ -261,7 +366,7 @@ def get_phase_thinking_budget(
     spec_dir: Path,
     phase: Phase,
     cli_thinking: str | None = None,
-) -> int | None:
+) -> int:
     """
     Get the thinking budget tokens for a specific execution phase.
 
@@ -271,7 +376,7 @@ def get_phase_thinking_budget(
         cli_thinking: Thinking level from CLI argument (optional)
 
     Returns:
-        Token budget or None for no extended thinking
+        Token budget for extended thinking
     """
     thinking_level = get_phase_thinking(spec_dir, phase, cli_thinking)
     return get_thinking_budget(thinking_level)
@@ -282,7 +387,7 @@ def get_phase_config(
     phase: Phase,
     cli_model: str | None = None,
     cli_thinking: str | None = None,
-) -> tuple[str, str, int | None]:
+) -> tuple[str, str, int]:
     """
     Get the full configuration for a specific execution phase.
 
@@ -302,7 +407,95 @@ def get_phase_config(
     return model_id, thinking_level, thinking_budget
 
 
-def get_spec_phase_thinking_budget(phase_name: str) -> int | None:
+def is_adaptive_model(model_id: str) -> bool:
+    """
+    Check if a model supports adaptive thinking via effort level.
+
+    Adaptive models support the CLAUDE_CODE_EFFORT_LEVEL environment variable
+    for effort-based routing in addition to max_thinking_tokens.
+
+    Args:
+        model_id: Full model ID (e.g., 'claude-opus-4-6')
+
+    Returns:
+        True if the model supports adaptive thinking
+    """
+    return model_id in ADAPTIVE_THINKING_MODELS
+
+
+def get_thinking_kwargs_for_model(model_id: str, thinking_level: str) -> dict:
+    """
+    Get thinking-related kwargs for create_client() based on model type.
+
+    For adaptive models (Opus 4.6): returns both max_thinking_tokens and effort_level.
+    For other models (Sonnet, Haiku): returns only max_thinking_tokens.
+
+    Args:
+        model_id: Full model ID (e.g., 'claude-opus-4-6')
+        thinking_level: Thinking level string (low, medium, high)
+
+    Returns:
+        Dict with 'max_thinking_tokens' and optionally 'effort_level'
+    """
+    kwargs: dict = {"max_thinking_tokens": get_thinking_budget(thinking_level)}
+    if is_adaptive_model(model_id):
+        kwargs["effort_level"] = EFFORT_LEVEL_MAP.get(thinking_level, "medium")
+    return kwargs
+
+
+def get_phase_client_thinking_kwargs(
+    spec_dir: Path,
+    phase: Phase,
+    phase_model: str,
+    cli_thinking: str | None = None,
+) -> dict:
+    """
+    Get thinking kwargs for create_client() for a specific execution phase.
+
+    Combines get_phase_thinking() and get_thinking_kwargs_for_model() to produce
+    the correct kwargs dict based on phase config and model capabilities.
+
+    Args:
+        spec_dir: Path to the spec directory
+        phase: Execution phase (spec, planning, coding, qa)
+        phase_model: Resolved full model ID for this phase
+        cli_thinking: Thinking level from CLI argument (optional)
+
+    Returns:
+        Dict with 'max_thinking_tokens' and optionally 'effort_level'
+    """
+    thinking_level = get_phase_thinking(spec_dir, phase, cli_thinking)
+    return get_thinking_kwargs_for_model(phase_model, thinking_level)
+
+
+def get_fast_mode(spec_dir: Path) -> bool:
+    """
+    Check if Fast Mode is enabled for this task.
+
+    Fast Mode provides faster Opus 4.6 output at higher cost.
+    Reads the fastMode flag from task_metadata.json.
+
+    Args:
+        spec_dir: Path to the spec directory
+
+    Returns:
+        True if Fast Mode is enabled, False otherwise
+    """
+    metadata = load_task_metadata(spec_dir)
+    if metadata:
+        enabled = bool(metadata.get("fastMode", False))
+        if enabled:
+            logger.info(
+                "[Fast Mode] ENABLED — read fastMode=true from task_metadata.json"
+            )
+        else:
+            logger.info("[Fast Mode] disabled — fastMode not set in task_metadata.json")
+        return enabled
+    logger.info("[Fast Mode] disabled — no task_metadata.json found")
+    return False
+
+
+def get_spec_phase_thinking_budget(phase_name: str) -> int:
     """
     Get the thinking budget for a specific spec runner phase.
 
@@ -313,7 +506,7 @@ def get_spec_phase_thinking_budget(phase_name: str) -> int | None:
         phase_name: Name of the spec phase (e.g., 'discovery', 'spec_writing')
 
     Returns:
-        Token budget for extended thinking, or None for no extended thinking
+        Token budget for extended thinking
     """
     thinking_level = SPEC_PHASE_THINKING_LEVELS.get(phase_name, "medium")
     return get_thinking_budget(thinking_level)