refactor: Fix logo overlapping in Discord classic view

V0.15.0rc

.automaker-lock

@@ -0,0 +1,5 @@
+{
+  "pid": 95678,
+  "featureId": "feature-1769860192729-yjxrtx35yh",
+  "startedAt": "2026-03-05T18:26:48.876Z"
+}

.github/workflows/e2e-tests.yml

@@ -46,7 +46,8 @@ jobs:
           echo "SERVER_PID=$SERVER_PID" >> $GITHUB_ENV
 
         env:
-          PORT: 3008
+          PORT: 3108
+          TEST_SERVER_PORT: 3108
           NODE_ENV: test
           # Use a deterministic API key so Playwright can log in reliably
           AUTOMAKER_API_KEY: test-api-key-for-e2e-tests
@@ -81,13 +82,13 @@ jobs:
 
           # Wait for health endpoint
           for i in {1..60}; do
-            if curl -s -f http://localhost:3008/api/health > /dev/null 2>&1; then
+            if curl -s -f http://localhost:3108/api/health > /dev/null 2>&1; then
               echo "Backend server is ready!"
               echo "=== Backend logs ==="
               cat backend.log
               echo ""
               echo "Health check response:"
-              curl -s http://localhost:3008/api/health | jq . 2>/dev/null || echo "Health check: $(curl -s http://localhost:3008/api/health 2>/dev/null || echo 'No response')"
+              curl -s http://localhost:3108/api/health | jq . 2>/dev/null || echo "Health check: $(curl -s http://localhost:3108/api/health 2>/dev/null || echo 'No response')"
               exit 0
             fi
             
@@ -111,11 +112,11 @@ jobs:
           ps aux | grep -E "(node|tsx)" | grep -v grep || echo "No node processes found"
           echo ""
           echo "=== Port status ==="
-          netstat -tlnp 2>/dev/null | grep :3008 || echo "Port 3008 not listening"
-          lsof -i :3008 2>/dev/null || echo "lsof not available or port not in use"
+          netstat -tlnp 2>/dev/null | grep :3108 || echo "Port 3108 not listening"
+          lsof -i :3108 2>/dev/null || echo "lsof not available or port not in use"
           echo ""
           echo "=== Health endpoint test ==="
-          curl -v http://localhost:3008/api/health 2>&1 || echo "Health endpoint failed"
+          curl -v http://localhost:3108/api/health 2>&1 || echo "Health endpoint failed"
 
           # Kill the server process if it's still hanging
           if kill -0 $SERVER_PID 2>/dev/null; then
@@ -132,8 +133,8 @@ jobs:
         run: npm run test --workspace=apps/ui
         env:
           CI: true
-          VITE_SERVER_URL: http://localhost:3008
-          SERVER_URL: http://localhost:3008
+          VITE_SERVER_URL: http://localhost:3108
+          SERVER_URL: http://localhost:3108
           VITE_SKIP_SETUP: 'true'
           # Keep UI-side login/defaults consistent
           AUTOMAKER_API_KEY: test-api-key-for-e2e-tests
@@ -148,7 +149,7 @@ jobs:
           ps aux | grep -E "(node|tsx)" | grep -v grep || echo "No node processes found"
           echo ""
           echo "=== Port status ==="
-          netstat -tlnp 2>/dev/null | grep :3008 || echo "Port 3008 not listening"
+          netstat -tlnp 2>/dev/null | grep :3108 || echo "Port 3108 not listening"
 
       - name: Upload Playwright report
         uses: actions/upload-artifact@v4

apps/server/.env.example

@@ -52,6 +52,12 @@ HOST=0.0.0.0
 # Port to run the server on
 PORT=3008
 
+# Port to run the server on for testing
+TEST_SERVER_PORT=3108
+
+# Port to run the UI on for testing
+TEST_PORT=3107
+
 # Data directory for sessions and metadata
 DATA_DIR=./data
 

apps/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automaker/server",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Backend server for Automaker - provides API for both web and Electron modes",
   "author": "AutoMaker Team",
   "license": "SEE LICENSE IN LICENSE",

apps/server/src/lib/sdk-options.ts

@@ -133,12 +133,16 @@ export const TOOL_PRESETS = {
     'Read',
     'Write',
     'Edit',
+    'MultiEdit',
     'Glob',
     'Grep',
+    'LS',
     'Bash',
     'WebSearch',
     'WebFetch',
     'TodoWrite',
+    'Task',
+    'Skill',
   ] as const,
 
   /** Tools for chat/interactive mode */
@@ -146,12 +150,16 @@ export const TOOL_PRESETS = {
     'Read',
     'Write',
     'Edit',
+    'MultiEdit',
     'Glob',
     'Grep',
+    'LS',
     'Bash',
     'WebSearch',
     'WebFetch',
     'TodoWrite',
+    'Task',
+    'Skill',
   ] as const,
 } as const;
 
@@ -282,11 +290,15 @@ function buildThinkingOptions(thinkingLevel?: ThinkingLevel): Partial<Options> {
 }
 
 /**
- * Build system prompt configuration based on autoLoadClaudeMd setting.
- * When autoLoadClaudeMd is true:
- * - Uses preset mode with 'claude_code' to enable CLAUDE.md auto-loading
- * - If there's a custom systemPrompt, appends it to the preset
- * - Sets settingSources to ['project'] for SDK to load CLAUDE.md files
+ * Build system prompt and settingSources based on two independent settings:
+ * - useClaudeCodeSystemPrompt: controls whether to use the 'claude_code' preset as the base prompt
+ * - autoLoadClaudeMd: controls whether to add settingSources for SDK to load CLAUDE.md files
+ *
+ * These combine independently (4 possible states):
+ * 1. Both ON: preset + settingSources (full Claude Code experience)
+ * 2. useClaudeCodeSystemPrompt ON, autoLoadClaudeMd OFF: preset only (no CLAUDE.md auto-loading)
+ * 3. useClaudeCodeSystemPrompt OFF, autoLoadClaudeMd ON: plain string + settingSources
+ * 4. Both OFF: plain string only
  *
  * @param config - The SDK options config
  * @returns Object with systemPrompt and settingSources for SDK options
@@ -295,27 +307,34 @@ function buildClaudeMdOptions(config: CreateSdkOptionsConfig): {
   systemPrompt?: string | SystemPromptConfig;
   settingSources?: Array<'user' | 'project' | 'local'>;
 } {
-  if (!config.autoLoadClaudeMd) {
-    // Standard mode - just pass through the system prompt as-is
-    return config.systemPrompt ? { systemPrompt: config.systemPrompt } : {};
-  }
-
-  // Auto-load CLAUDE.md mode - use preset with settingSources
   const result: {
-    systemPrompt: SystemPromptConfig;
-    settingSources: Array<'user' | 'project' | 'local'>;
-  } = {
-    systemPrompt: {
+    systemPrompt?: string | SystemPromptConfig;
+    settingSources?: Array<'user' | 'project' | 'local'>;
+  } = {};
+
+  // Determine system prompt format based on useClaudeCodeSystemPrompt
+  if (config.useClaudeCodeSystemPrompt) {
+    // Use Claude Code's built-in system prompt as the base
+    const presetConfig: SystemPromptConfig = {
       type: 'preset',
       preset: 'claude_code',
-    },
-    // Load both user (~/.claude/CLAUDE.md) and project (.claude/CLAUDE.md) settings
-    settingSources: ['user', 'project'],
-  };
+    };
+    // If there's a custom system prompt, append it to the preset
+    if (config.systemPrompt) {
+      presetConfig.append = config.systemPrompt;
+    }
+    result.systemPrompt = presetConfig;
+  } else {
+    // Standard mode - just pass through the system prompt as-is
+    if (config.systemPrompt) {
+      result.systemPrompt = config.systemPrompt;
+    }
+  }
 
-  // If there's a custom system prompt, append it to the preset
-  if (config.systemPrompt) {
-    result.systemPrompt.append = config.systemPrompt;
+  // Determine settingSources based on autoLoadClaudeMd
+  if (config.autoLoadClaudeMd) {
+    // Load both user (~/.claude/CLAUDE.md) and project (.claude/CLAUDE.md) settings
+    result.settingSources = ['user', 'project'];
   }
 
   return result;
@@ -323,12 +342,14 @@ function buildClaudeMdOptions(config: CreateSdkOptionsConfig): {
 
 /**
  * System prompt configuration for SDK options
- * When using preset mode with claude_code, CLAUDE.md files are automatically loaded
+ * The 'claude_code' preset provides the system prompt only — it does NOT auto-load
+ * CLAUDE.md files. CLAUDE.md auto-loading is controlled independently by
+ * settingSources (set via autoLoadClaudeMd). These two settings are orthogonal.
  */
 export interface SystemPromptConfig {
-  /** Use preset mode with claude_code to enable CLAUDE.md auto-loading */
+  /** Use preset mode to select the base system prompt */
   type: 'preset';
-  /** The preset to use - 'claude_code' enables CLAUDE.md loading */
+  /** The preset to use - 'claude_code' uses the Claude Code system prompt */
   preset: 'claude_code';
   /** Optional additional prompt to append to the preset */
   append?: string;
@@ -362,6 +383,9 @@ export interface CreateSdkOptionsConfig {
   /** Enable auto-loading of CLAUDE.md files via SDK's settingSources */
   autoLoadClaudeMd?: boolean;
 
+  /** Use Claude Code's built-in system prompt (claude_code preset) as the base prompt */
+  useClaudeCodeSystemPrompt?: boolean;
+
   /** MCP servers to make available to the agent */
   mcpServers?: Record<string, McpServerConfig>;
 

apps/server/src/lib/settings-helpers.ts

@@ -34,10 +34,10 @@ import {
 const logger = createLogger('SettingsHelper');
 
 /** Default number of agent turns used when no value is configured. */
-export const DEFAULT_MAX_TURNS = 1000;
+export const DEFAULT_MAX_TURNS = 10000;
 
 /** Upper bound for the max-turns clamp; values above this are capped here. */
-export const MAX_ALLOWED_TURNS = 2000;
+export const MAX_ALLOWED_TURNS = 10000;
 
 /**
  * Get the autoLoadClaudeMd setting, with project settings taking precedence over global.
@@ -80,6 +80,49 @@ export async function getAutoLoadClaudeMdSetting(
   }
 }
 
+/**
+ * Get the useClaudeCodeSystemPrompt setting, with project settings taking precedence over global.
+ * Falls back to global settings and defaults to true when unset.
+ * Returns true if settings service is not available.
+ *
+ * @param projectPath - Path to the project
+ * @param settingsService - Optional settings service instance
+ * @param logPrefix - Prefix for log messages (e.g., '[AgentService]')
+ * @returns Promise resolving to the useClaudeCodeSystemPrompt setting value
+ */
+export async function getUseClaudeCodeSystemPromptSetting(
+  projectPath: string,
+  settingsService?: SettingsService | null,
+  logPrefix = '[SettingsHelper]'
+): Promise<boolean> {
+  if (!settingsService) {
+    logger.info(
+      `${logPrefix} SettingsService not available, useClaudeCodeSystemPrompt defaulting to true`
+    );
+    return true;
+  }
+
+  try {
+    // Check project settings first (takes precedence)
+    const projectSettings = await settingsService.getProjectSettings(projectPath);
+    if (projectSettings.useClaudeCodeSystemPrompt !== undefined) {
+      logger.info(
+        `${logPrefix} useClaudeCodeSystemPrompt from project settings: ${projectSettings.useClaudeCodeSystemPrompt}`
+      );
+      return projectSettings.useClaudeCodeSystemPrompt;
+    }
+
+    // Fall back to global settings
+    const globalSettings = await settingsService.getGlobalSettings();
+    const result = globalSettings.useClaudeCodeSystemPrompt ?? true;
+    logger.info(`${logPrefix} useClaudeCodeSystemPrompt from global settings: ${result}`);
+    return result;
+  } catch (error) {
+    logger.error(`${logPrefix} Failed to load useClaudeCodeSystemPrompt setting:`, error);
+    throw error;
+  }
+}
+
 /**
  * Get the default max turns setting from global settings.
  *

apps/server/src/providers/claude-provider.ts

@@ -33,8 +33,23 @@ const logger = createLogger('ClaudeProvider');
  */
 type ProviderConfig = ClaudeApiProfile | ClaudeCompatibleProvider;
 
-// System vars are always passed from process.env regardless of profile
-const SYSTEM_ENV_VARS = ['PATH', 'HOME', 'SHELL', 'TERM', 'USER', 'LANG', 'LC_ALL'];
+// System vars are always passed from process.env regardless of profile.
+// Includes filesystem, locale, and temp directory vars that the Claude CLI
+// needs internally for config resolution and temp file creation.
+const SYSTEM_ENV_VARS = [
+  'PATH',
+  'HOME',
+  'SHELL',
+  'TERM',
+  'USER',
+  'LANG',
+  'LC_ALL',
+  'TMPDIR',
+  'XDG_CONFIG_HOME',
+  'XDG_DATA_HOME',
+  'XDG_CACHE_HOME',
+  'XDG_STATE_HOME',
+];
 
 /**
  * Check if the config is a ClaudeCompatibleProvider (new system)
@@ -213,6 +228,8 @@ export class ClaudeProvider extends BaseProvider {
       env: buildEnv(providerConfig, credentials),
       // Pass through allowedTools if provided by caller (decided by sdk-options.ts)
       ...(allowedTools && { allowedTools }),
+      // Restrict available built-in tools if specified (tools: [] disables all tools)
+      ...(options.tools && { tools: options.tools }),
       // AUTONOMOUS MODE: Always bypass permissions for fully autonomous operation
       permissionMode: 'bypassPermissions',
       allowDangerouslySkipPermissions: true,

apps/server/src/providers/codex-provider.ts

@@ -33,7 +33,6 @@ import {
   supportsReasoningEffort,
   validateBareModelId,
   calculateReasoningTimeout,
-  DEFAULT_TIMEOUT_MS,
   type CodexApprovalPolicy,
   type CodexSandboxMode,
   type CodexAuthStatus,
@@ -52,6 +51,7 @@ import { CODEX_MODELS } from './codex-models.js';
 
 const CODEX_COMMAND = 'codex';
 const CODEX_EXEC_SUBCOMMAND = 'exec';
+const CODEX_RESUME_SUBCOMMAND = 'resume';
 const CODEX_JSON_FLAG = '--json';
 const CODEX_MODEL_FLAG = '--model';
 const CODEX_VERSION_FLAG = '--version';
@@ -98,7 +98,7 @@ const TEXT_ENCODING = 'utf-8';
  *
  * @see calculateReasoningTimeout from @automaker/types
  */
-const CODEX_CLI_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+const CODEX_CLI_TIMEOUT_MS = 120000; // 2 minutes — matches CLI provider base timeout
 const CODEX_FEATURE_GENERATION_BASE_TIMEOUT_MS = 300000; // 5 minutes for feature generation
 const SYSTEM_PROMPT_SEPARATOR = '\n\n';
 const CODEX_INSTRUCTIONS_DIR = '.codex';
@@ -127,11 +127,16 @@ const DEFAULT_ALLOWED_TOOLS = [
   'Read',
   'Write',
   'Edit',
+  'MultiEdit',
   'Glob',
   'Grep',
+  'LS',
   'Bash',
   'WebSearch',
   'WebFetch',
+  'TodoWrite',
+  'Task',
+  'Skill',
 ] as const;
 const SEARCH_TOOL_NAMES = new Set(['WebSearch', 'WebFetch']);
 const MIN_MAX_TURNS = 1;
@@ -356,9 +361,14 @@ function resolveSystemPrompt(systemPrompt?: unknown): string | null {
   return null;
 }
 
+function buildPromptText(options: ExecuteOptions): string {
+  return typeof options.prompt === 'string'
+    ? options.prompt
+    : extractTextFromContent(options.prompt);
+}
+
 function buildCombinedPrompt(options: ExecuteOptions, systemPromptText?: string | null): string {
-  const promptText =
-    typeof options.prompt === 'string' ? options.prompt : extractTextFromContent(options.prompt);
+  const promptText = buildPromptText(options);
   const historyText = options.conversationHistory
     ? formatHistoryAsText(options.conversationHistory)
     : '';
@@ -371,6 +381,11 @@ function buildCombinedPrompt(options: ExecuteOptions, systemPromptText?: string
   return `${historyText}${systemSection}${HISTORY_HEADER}${promptText}`;
 }
 
+function buildResumePrompt(options: ExecuteOptions): string {
+  const promptText = buildPromptText(options);
+  return `${HISTORY_HEADER}${promptText}`;
+}
+
 function formatConfigValue(value: string | number | boolean): string {
   return String(value);
 }
@@ -794,16 +809,22 @@ export class CodexProvider extends BaseProvider {
       }
       const searchEnabled =
         codexSettings.enableWebSearch || resolveSearchEnabled(resolvedAllowedTools, restrictTools);
-      const schemaPath = await writeOutputSchemaFile(options.cwd, options.outputFormat);
-      const imageBlocks = codexSettings.enableImages ? extractImageBlocks(options.prompt) : [];
-      const imagePaths = await writeImageFiles(options.cwd, imageBlocks);
+      const isResumeQuery = Boolean(options.sdkSessionId);
+      const schemaPath = isResumeQuery
+        ? null
+        : await writeOutputSchemaFile(options.cwd, options.outputFormat);
+      const imageBlocks =
+        !isResumeQuery && codexSettings.enableImages ? extractImageBlocks(options.prompt) : [];
+      const imagePaths = isResumeQuery ? [] : await writeImageFiles(options.cwd, imageBlocks);
       const approvalPolicy =
         hasMcpServers && options.mcpAutoApproveTools !== undefined
           ? options.mcpAutoApproveTools
             ? 'never'
             : 'on-request'
           : codexSettings.approvalPolicy;
-      const promptText = buildCombinedPrompt(options, combinedSystemPrompt);
+      const promptText = isResumeQuery
+        ? buildResumePrompt(options)
+        : buildCombinedPrompt(options, combinedSystemPrompt);
       const commandPath = executionPlan.cliPath || CODEX_COMMAND;
 
       // Build config overrides for max turns and reasoning effort
@@ -833,21 +854,30 @@ export class CodexProvider extends BaseProvider {
       const preExecArgs: string[] = [];
 
       // Add additional directories with write access
-      if (codexSettings.additionalDirs && codexSettings.additionalDirs.length > 0) {
+      if (
+        !isResumeQuery &&
+        codexSettings.additionalDirs &&
+        codexSettings.additionalDirs.length > 0
+      ) {
         for (const dir of codexSettings.additionalDirs) {
           preExecArgs.push(CODEX_ADD_DIR_FLAG, dir);
         }
       }
 
-      // If images were written to disk, add the image directory so the CLI can access them
+      // If images were written to disk, add the image directory so the CLI can access them.
+      // Note: imagePaths is set to [] when isResumeQuery is true, so this check is sufficient.
       if (imagePaths.length > 0) {
         const imageDir = path.join(options.cwd, CODEX_INSTRUCTIONS_DIR, IMAGE_TEMP_DIR);
         preExecArgs.push(CODEX_ADD_DIR_FLAG, imageDir);
       }
 
       // Model is already bare (no prefix) - validated by executeQuery
+      const codexCommand = isResumeQuery
+        ? [CODEX_EXEC_SUBCOMMAND, CODEX_RESUME_SUBCOMMAND]
+        : [CODEX_EXEC_SUBCOMMAND];
+
       const args = [
-        CODEX_EXEC_SUBCOMMAND,
+        ...codexCommand,
         CODEX_YOLO_FLAG,
         CODEX_SKIP_GIT_REPO_CHECK_FLAG,
         ...preExecArgs,
@@ -856,6 +886,7 @@ export class CodexProvider extends BaseProvider {
         CODEX_JSON_FLAG,
         ...configOverrideArgs,
         ...(schemaPath ? [CODEX_OUTPUT_SCHEMA_FLAG, schemaPath] : []),
+        ...(options.sdkSessionId ? [options.sdkSessionId] : []),
         '-', // Read prompt from stdin to avoid shell escaping issues
       ];
 

apps/server/src/providers/copilot-provider.ts

@@ -30,6 +30,7 @@ import {
   type CopilotRuntimeModel,
 } from '@automaker/types';
 import { createLogger, isAbortError } from '@automaker/utils';
+import { resolveModelString } from '@automaker/model-resolver';
 import { CopilotClient, type PermissionRequest } from '@github/copilot-sdk';
 import {
   normalizeTodos,
@@ -116,6 +117,12 @@ export interface CopilotError extends Error {
   suggestion?: string;
 }
 
+type CopilotSession = Awaited<ReturnType<CopilotClient['createSession']>>;
+type CopilotSessionOptions = Parameters<CopilotClient['createSession']>[0];
+type ResumableCopilotClient = CopilotClient & {
+  resumeSession?: (sessionId: string, options: CopilotSessionOptions) => Promise<CopilotSession>;
+};
+
 // =============================================================================
 // Tool Name Normalization
 // =============================================================================
@@ -382,9 +389,14 @@ export class CopilotProvider extends CliProvider {
 
       case 'session.error': {
         const errorEvent = sdkEvent as SdkSessionErrorEvent;
+        const enrichedError =
+          errorEvent.data.message ||
+          (errorEvent.data.code
+            ? `Copilot agent error (code: ${errorEvent.data.code})`
+            : 'Copilot agent error');
         return {
           type: 'error',
-          error: errorEvent.data.message || 'Unknown error',
+          error: enrichedError,
         };
       }
 
@@ -516,7 +528,11 @@ export class CopilotProvider extends CliProvider {
     }
 
     const promptText = this.extractPromptText(options);
-    const bareModel = options.model || DEFAULT_BARE_MODEL;
+    // resolveModelString may return dash-separated canonical names (e.g. "claude-sonnet-4-6"),
+    // but the Copilot SDK expects dot-separated version suffixes (e.g. "claude-sonnet-4.6").
+    // Normalize by converting the last dash-separated numeric pair to dot notation.
+    const resolvedModel = resolveModelString(options.model || DEFAULT_BARE_MODEL);
+    const bareModel = resolvedModel.replace(/-(\d+)-(\d+)$/, '-$1.$2');
     const workingDirectory = options.cwd || process.cwd();
 
     logger.debug(
@@ -554,12 +570,14 @@ export class CopilotProvider extends CliProvider {
       });
     };
 
+    // Declare session outside try so it's accessible in the catch block for cleanup.
+    let session: CopilotSession | undefined;
+
     try {
       await client.start();
       logger.debug(`CopilotClient started with cwd: ${workingDirectory}`);
 
-      // Create session with streaming enabled for real-time events
-      const session = await client.createSession({
+      const sessionOptions: CopilotSessionOptions = {
         model: bareModel,
         streaming: true,
         // AUTONOMOUS MODE: Auto-approve all permission requests.
@@ -572,13 +590,33 @@ export class CopilotProvider extends CliProvider {
           logger.debug(`Permission request: ${request.kind}`);
           return { kind: 'approved' };
         },
-      });
+      };
 
-      const sessionId = session.sessionId;
-      logger.debug(`Session created: ${sessionId}`);
+      // Resume the previous Copilot session when possible; otherwise create a fresh one.
+      const resumableClient = client as ResumableCopilotClient;
+      let sessionResumed = false;
+      if (options.sdkSessionId && typeof resumableClient.resumeSession === 'function') {
+        try {
+          session = await resumableClient.resumeSession(options.sdkSessionId, sessionOptions);
+          sessionResumed = true;
+          logger.debug(`Resumed Copilot session: ${session.sessionId}`);
+        } catch (resumeError) {
+          logger.warn(
+            `Failed to resume Copilot session "${options.sdkSessionId}", creating a new session: ${resumeError}`
+          );
+          session = await client.createSession(sessionOptions);
+        }
+      } else {
+        session = await client.createSession(sessionOptions);
+      }
+
+      // session is always assigned by this point (both branches above assign it)
+      const activeSession = session!;
+      const sessionId = activeSession.sessionId;
+      logger.debug(`Session ${sessionResumed ? 'resumed' : 'created'}: ${sessionId}`);
 
       // Set up event handler to push events to queue
-      session.on((event: SdkEvent) => {
+      activeSession.on((event: SdkEvent) => {
         logger.debug(`SDK event: ${event.type}`);
 
         if (event.type === 'session.idle') {
@@ -596,7 +634,7 @@ export class CopilotProvider extends CliProvider {
       });
 
       // Send the prompt (non-blocking)
-      await session.send({ prompt: promptText });
+      await activeSession.send({ prompt: promptText });
 
       // Process events as they arrive
       while (!sessionComplete || eventQueue.length > 0) {
@@ -604,7 +642,7 @@ export class CopilotProvider extends CliProvider {
 
         // Check for errors first (before processing events to avoid race condition)
         if (sessionError) {
-          await session.destroy();
+          await activeSession.destroy();
           await client.stop();
           throw sessionError;
         }
@@ -624,11 +662,19 @@ export class CopilotProvider extends CliProvider {
       }
 
       // Cleanup
-      await session.destroy();
+      await activeSession.destroy();
       await client.stop();
       logger.debug('CopilotClient stopped successfully');
     } catch (error) {
-      // Ensure client is stopped on error
+      // Ensure session is destroyed and client is stopped on error to prevent leaks.
+      // The session may have been created/resumed before the error occurred.
+      if (session) {
+        try {
+          await session.destroy();
+        } catch (sessionCleanupError) {
+          logger.debug(`Failed to destroy session during cleanup: ${sessionCleanupError}`);
+        }
+      }
       try {
         await client.stop();
       } catch (cleanupError) {

apps/server/src/providers/cursor-provider.ts

@@ -450,6 +450,11 @@ export class CursorProvider extends CliProvider {
       cliArgs.push('--model', model);
     }
 
+    // Resume an existing chat when a provider session ID is available
+    if (options.sdkSessionId) {
+      cliArgs.push('--resume', options.sdkSessionId);
+    }
+
     // Use '-' to indicate reading prompt from stdin
     cliArgs.push('-');
 
@@ -557,10 +562,14 @@ export class CursorProvider extends CliProvider {
         const resultEvent = cursorEvent as CursorResultEvent;
 
         if (resultEvent.is_error) {
+          const errorText = resultEvent.error || resultEvent.result || '';
+          const enrichedError =
+            errorText ||
+            `Cursor agent failed (duration: ${resultEvent.duration_ms}ms, subtype: ${resultEvent.subtype}, session: ${resultEvent.session_id ?? 'none'})`;
           return {
             type: 'error',
             session_id: resultEvent.session_id,
-            error: resultEvent.error || resultEvent.result || 'Unknown error',
+            error: enrichedError,
           };
         }
 

apps/server/src/providers/gemini-provider.ts

@@ -24,7 +24,7 @@ import type {
 import { validateBareModelId } from '@automaker/types';
 import { GEMINI_MODEL_MAP, type GeminiAuthStatus } from '@automaker/types';
 import { createLogger, isAbortError } from '@automaker/utils';
-import { spawnJSONLProcess } from '@automaker/platform';
+import { spawnJSONLProcess, type SubprocessOptions } from '@automaker/platform';
 import { normalizeTodos } from './tool-normalization.js';
 
 // Create logger for this module
@@ -263,6 +263,14 @@ export class GeminiProvider extends CliProvider {
     // Use explicit approval-mode for clearer semantics
     cliArgs.push('--approval-mode', 'yolo');
 
+    // Force headless (non-interactive) mode with --prompt flag.
+    // The actual prompt content is passed via stdin (see buildSubprocessOptions()),
+    // but we MUST include -p to trigger headless mode. Without it, Gemini CLI
+    // starts in interactive mode which adds significant startup overhead
+    // (interactive REPL setup, extra context loading, etc.).
+    // Per Gemini CLI docs: stdin content is "appended to" the -p value.
+    cliArgs.push('--prompt', '');
+
     // Explicitly include the working directory in allowed workspace directories
     // This ensures Gemini CLI allows file operations in the project directory,
     // even if it has a different workspace cached from a previous session
@@ -270,13 +278,15 @@ export class GeminiProvider extends CliProvider {
       cliArgs.push('--include-directories', options.cwd);
     }
 
+    // Resume an existing Gemini session when one is available
+    if (options.sdkSessionId) {
+      cliArgs.push('--resume', options.sdkSessionId);
+    }
+
     // Note: Gemini CLI doesn't have a --thinking-level flag.
     // Thinking capabilities are determined by the model selection (e.g., gemini-2.5-pro).
     // The model handles thinking internally based on the task complexity.
 
-    // The prompt will be passed as the last positional argument
-    // We'll append it in executeQuery after extracting the text
-
     return cliArgs;
   }
 
@@ -371,10 +381,13 @@ export class GeminiProvider extends CliProvider {
         const resultEvent = geminiEvent as GeminiResultEvent;
 
         if (resultEvent.status === 'error') {
+          const enrichedError =
+            resultEvent.error ||
+            `Gemini agent failed (duration: ${resultEvent.stats?.duration_ms ?? 'unknown'}ms, session: ${resultEvent.session_id ?? 'none'})`;
           return {
             type: 'error',
             session_id: resultEvent.session_id,
-            error: resultEvent.error || 'Unknown error',
+            error: enrichedError,
           };
         }
 
@@ -391,10 +404,12 @@ export class GeminiProvider extends CliProvider {
 
       case 'error': {
         const errorEvent = geminiEvent as GeminiResultEvent;
+        const enrichedError =
+          errorEvent.error || `Gemini agent failed (session: ${errorEvent.session_id ?? 'none'})`;
         return {
           type: 'error',
           session_id: errorEvent.session_id,
-          error: errorEvent.error || 'Unknown error',
+          error: enrichedError,
         };
       }
 
@@ -408,6 +423,32 @@ export class GeminiProvider extends CliProvider {
   // CliProvider Overrides
   // ==========================================================================
 
+  /**
+   * Build subprocess options with stdin data for prompt and speed-optimized env vars.
+   *
+   * Passes the prompt via stdin instead of --prompt CLI arg to:
+   * - Avoid shell argument size limits with large prompts (system prompt + context)
+   * - Avoid shell escaping issues with special characters in prompts
+   * - Match the pattern used by Cursor, OpenCode, and Codex providers
+   *
+   * Also injects environment variables to reduce Gemini CLI startup overhead:
+   * - GEMINI_TELEMETRY_ENABLED=false: Disables OpenTelemetry collection
+   */
+  protected buildSubprocessOptions(options: ExecuteOptions, cliArgs: string[]): SubprocessOptions {
+    const subprocessOptions = super.buildSubprocessOptions(options, cliArgs);
+
+    // Pass prompt via stdin to avoid shell interpretation of special characters
+    // and shell argument size limits with large system prompts + context files
+    subprocessOptions.stdinData = this.extractPromptText(options);
+
+    // Disable telemetry to reduce startup overhead
+    if (subprocessOptions.env) {
+      subprocessOptions.env['GEMINI_TELEMETRY_ENABLED'] = 'false';
+    }
+
+    return subprocessOptions;
+  }
+
   /**
    * Override error mapping for Gemini-specific error codes
    */
@@ -517,14 +558,21 @@ export class GeminiProvider extends CliProvider {
       );
     }
 
-    // Extract prompt text to pass as positional argument
-    const promptText = this.extractPromptText(options);
+    // Ensure .geminiignore exists in the working directory to prevent Gemini CLI
+    // from scanning .git and node_modules directories during startup. This reduces
+    // startup time significantly (reported: 35s → 11s) by skipping large directories
+    // that Gemini CLI would otherwise traverse for context discovery.
+    await this.ensureGeminiIgnore(options.cwd || process.cwd());
 
-    // Build CLI args and append the prompt as the last positional argument
-    const cliArgs = this.buildCliArgs(options);
-    cliArgs.push(promptText); // Gemini CLI uses positional args for the prompt
+    // Embed system prompt into the user prompt so Gemini CLI receives
+    // project context (CLAUDE.md, CODE_QUALITY.md, etc.) that would
+    // otherwise be silently dropped since Gemini CLI has no --system-prompt flag.
+    const effectiveOptions = this.embedSystemPromptIntoPrompt(options);
 
-    const subprocessOptions = this.buildSubprocessOptions(options, cliArgs);
+    // Build CLI args for headless execution.
+    const cliArgs = this.buildCliArgs(effectiveOptions);
+
+    const subprocessOptions = this.buildSubprocessOptions(effectiveOptions, cliArgs);
 
     let sessionId: string | undefined;
 
@@ -577,6 +625,49 @@ export class GeminiProvider extends CliProvider {
   // Gemini-Specific Methods
   // ==========================================================================
 
+  /**
+   * Ensure a .geminiignore file exists in the working directory.
+   *
+   * Gemini CLI scans the working directory for context discovery during startup.
+   * Excluding .git and node_modules dramatically reduces startup time by preventing
+   * traversal of large directories (reported improvement: 35s → 11s).
+   *
+   * Only creates the file if it doesn't already exist to avoid overwriting user config.
+   */
+  private async ensureGeminiIgnore(cwd: string): Promise<void> {
+    const ignorePath = path.join(cwd, '.geminiignore');
+    const content = [
+      '# Auto-generated by Automaker to speed up Gemini CLI startup',
+      '# Prevents Gemini CLI from scanning large directories during context discovery',
+      '.git',
+      'node_modules',
+      'dist',
+      'build',
+      '.next',
+      '.nuxt',
+      'coverage',
+      '.automaker',
+      '.worktrees',
+      '.vscode',
+      '.idea',
+      '*.lock',
+      '',
+    ].join('\n');
+    try {
+      // Use 'wx' flag for atomic creation - fails if file exists (EEXIST)
+      await fs.writeFile(ignorePath, content, { encoding: 'utf-8', flag: 'wx' });
+      logger.debug(`Created .geminiignore at ${ignorePath}`);
+    } catch (writeError) {
+      // EEXIST means file already exists - that's fine, preserve user's file
+      if ((writeError as NodeJS.ErrnoException).code === 'EEXIST') {
+        logger.debug(`.geminiignore already exists at ${ignorePath}, preserving existing file`);
+        return;
+      }
+      // Non-fatal: startup will just be slower without the ignore file
+      logger.debug(`Failed to create .geminiignore: ${writeError}`);
+    }
+  }
+
   /**
    * Create a GeminiError with details
    */

apps/server/src/routes/auto-mode/routes/analyze-project.ts

@@ -19,10 +19,11 @@ export function createAnalyzeProjectHandler(autoModeService: AutoModeServiceComp
         return;
       }
 
-      // Start analysis in background
-      autoModeService.analyzeProject(projectPath).catch((error) => {
-        logger.error(`[AutoMode] Project analysis error:`, error);
-      });
+      // Kick off analysis in the background; attach a rejection handler so
+      // unhandled-promise warnings don't surface and errors are at least logged.
+      // Synchronous throws (e.g. "not implemented") still propagate here.
+      const analysisPromise = autoModeService.analyzeProject(projectPath);
+      analysisPromise.catch((err) => logError(err, 'Background analyzeProject failed'));
 
       res.json({ success: true, message: 'Project analysis started' });
     } catch (error) {

apps/server/src/routes/backlog-plan/common.ts

@@ -114,9 +114,20 @@ export function mapBacklogPlanError(rawMessage: string): string {
     return 'Claude CLI could not be launched. Make sure the Claude CLI is installed and available in PATH, or check that Node.js is correctly installed. Try running "which claude" or "claude --version" in your terminal to verify.';
   }
 
-  // Claude Code process crash
+  // Claude Code process crash - extract exit code for diagnostics
   if (rawMessage.includes('Claude Code process exited')) {
-    return 'Claude exited unexpectedly. Try again. If it keeps happening, re-run `claude login` or update your API key in Setup.';
+    const exitCodeMatch = rawMessage.match(/exited with code (\d+)/);
+    const exitCode = exitCodeMatch ? exitCodeMatch[1] : 'unknown';
+    logger.error(`[BacklogPlan] Claude process exit code: ${exitCode}`);
+    return `Claude exited unexpectedly (exit code: ${exitCode}). This is usually a transient issue. Try again. If it keeps happening, re-run \`claude login\` or update your API key in Setup.`;
+  }
+
+  // Claude Code process killed by signal
+  if (rawMessage.includes('Claude Code process terminated by signal')) {
+    const signalMatch = rawMessage.match(/terminated by signal (\w+)/);
+    const signal = signalMatch ? signalMatch[1] : 'unknown';
+    logger.error(`[BacklogPlan] Claude process terminated by signal: ${signal}`);
+    return `Claude was terminated by signal ${signal}. This may indicate a resource issue. Try again.`;
   }
 
   // Rate limiting

apps/server/src/routes/backlog-plan/generate-plan.ts

@@ -3,6 +3,9 @@
  *
  * Model is configurable via phaseModels.backlogPlanningModel in settings
  * (defaults to Sonnet). Can be overridden per-call via model parameter.
+ *
+ * Includes automatic retry for transient CLI failures (e.g., "Claude Code
+ * process exited unexpectedly") to improve reliability.
  */
 
 import type { EventEmitter } from '../../lib/events.js';
@@ -12,8 +15,10 @@ import {
   isCursorModel,
   stripProviderPrefix,
   type ThinkingLevel,
+  type SystemPromptPreset,
 } from '@automaker/types';
 import { resolvePhaseModel } from '@automaker/model-resolver';
+import { getCurrentBranch } from '@automaker/git-utils';
 import { FeatureLoader } from '../../services/feature-loader.js';
 import { ProviderFactory } from '../../providers/provider-factory.js';
 import { extractJsonWithArray } from '../../lib/json-extractor.js';
@@ -27,10 +32,28 @@ import {
 import type { SettingsService } from '../../services/settings-service.js';
 import {
   getAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting,
   getPromptCustomization,
   getPhaseModelWithOverrides,
+  getProviderByModelId,
 } from '../../lib/settings-helpers.js';
 
+/** Maximum number of retry attempts for transient CLI failures */
+const MAX_RETRIES = 2;
+/** Delay between retries in milliseconds */
+const RETRY_DELAY_MS = 2000;
+
+/**
+ * Check if an error is retryable (transient CLI process failure)
+ */
+function isRetryableError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes('Claude Code process exited') ||
+    message.includes('Claude Code process terminated by signal')
+  );
+}
+
 const featureLoader = new FeatureLoader();
 
 /**
@@ -84,6 +107,53 @@ function parsePlanResponse(response: string): BacklogPlanResult {
   };
 }
 
+/**
+ * Try to parse a valid plan response without fallback behavior.
+ * Returns null if parsing fails.
+ */
+function tryParsePlanResponse(response: string): BacklogPlanResult | null {
+  if (!response || response.trim().length === 0) {
+    return null;
+  }
+  return extractJsonWithArray<BacklogPlanResult>(response, 'changes', { logger });
+}
+
+/**
+ * Choose the most reliable response text between streamed assistant chunks
+ * and provider final result payload.
+ */
+function selectBestResponseText(accumulatedText: string, providerResultText: string): string {
+  const hasAccumulated = accumulatedText.trim().length > 0;
+  const hasProviderResult = providerResultText.trim().length > 0;
+
+  if (!hasProviderResult) {
+    return accumulatedText;
+  }
+  if (!hasAccumulated) {
+    return providerResultText;
+  }
+
+  const accumulatedParsed = tryParsePlanResponse(accumulatedText);
+  const providerParsed = tryParsePlanResponse(providerResultText);
+
+  if (providerParsed && !accumulatedParsed) {
+    logger.info('[BacklogPlan] Using provider result (parseable JSON)');
+    return providerResultText;
+  }
+  if (accumulatedParsed && !providerParsed) {
+    logger.info('[BacklogPlan] Keeping accumulated text (parseable JSON)');
+    return accumulatedText;
+  }
+
+  if (providerResultText.length > accumulatedText.length) {
+    logger.info('[BacklogPlan] Using provider result (longer content)');
+    return providerResultText;
+  }
+
+  logger.info('[BacklogPlan] Keeping accumulated text (longer content)');
+  return accumulatedText;
+}
+
 /**
  * Generate a backlog modification plan based on user prompt
  */
@@ -93,11 +163,40 @@ export async function generateBacklogPlan(
   events: EventEmitter,
   abortController: AbortController,
   settingsService?: SettingsService,
-  model?: string
+  model?: string,
+  branchName?: string
 ): Promise<BacklogPlanResult> {
   try {
     // Load current features
-    const features = await featureLoader.getAll(projectPath);
+    const allFeatures = await featureLoader.getAll(projectPath);
+
+    // Filter features by branch if specified (worktree-scoped backlog)
+    let features: Feature[];
+    if (branchName) {
+      // Determine the primary branch so unassigned features show for the main worktree
+      let primaryBranch: string | null = null;
+      try {
+        primaryBranch = await getCurrentBranch(projectPath);
+      } catch {
+        // If git fails, fall back to 'main' so unassigned features are visible
+        // when branchName matches a common default branch name
+        primaryBranch = 'main';
+      }
+      const isMainBranch = branchName === primaryBranch;
+
+      features = allFeatures.filter((f) => {
+        if (!f.branchName) {
+          // Unassigned features belong to the main/primary worktree
+          return isMainBranch;
+        }
+        return f.branchName === branchName;
+      });
+      logger.info(
+        `[BacklogPlan] Filtered to ${features.length}/${allFeatures.length} features for branch: ${branchName}`
+      );
+    } else {
+      features = allFeatures;
+    }
 
     events.emit('backlog-plan:event', {
       type: 'backlog_plan_progress',
@@ -133,6 +232,35 @@ export async function generateBacklogPlan(
       effectiveModel = resolved.model;
       thinkingLevel = resolved.thinkingLevel;
       credentials = await settingsService?.getCredentials();
+      // Resolve Claude-compatible provider when client sends a model (e.g. MiniMax, GLM)
+      if (settingsService) {
+        const providerResult = await getProviderByModelId(
+          effectiveModel,
+          settingsService,
+          '[BacklogPlan]'
+        );
+        if (providerResult.provider) {
+          claudeCompatibleProvider = providerResult.provider;
+          if (providerResult.credentials) {
+            credentials = providerResult.credentials;
+          }
+        }
+        // Fallback: use phase settings provider if model lookup found nothing (e.g. model
+        // string format differs from provider's model id, but backlog planning phase has providerId).
+        if (!claudeCompatibleProvider) {
+          const phaseResult = await getPhaseModelWithOverrides(
+            'backlogPlanningModel',
+            settingsService,
+            projectPath,
+            '[BacklogPlan]'
+          );
+          const phaseResolved = resolvePhaseModel(phaseResult.phaseModel);
+          if (phaseResult.provider && phaseResolved.model === effectiveModel) {
+            claudeCompatibleProvider = phaseResult.provider;
+            credentials = phaseResult.credentials ?? credentials;
+          }
+        }
+      }
     } else if (settingsService) {
       // Use settings-based model with provider info
       const phaseResult = await getPhaseModelWithOverrides(
@@ -162,17 +290,23 @@ export async function generateBacklogPlan(
     // Strip provider prefix - providers expect bare model IDs
     const bareModel = stripProviderPrefix(effectiveModel);
 
-    // Get autoLoadClaudeMd setting
+    // Get autoLoadClaudeMd and useClaudeCodeSystemPrompt settings
     const autoLoadClaudeMd = await getAutoLoadClaudeMdSetting(
       projectPath,
       settingsService,
       '[BacklogPlan]'
     );
+    const useClaudeCodeSystemPrompt = await getUseClaudeCodeSystemPromptSetting(
+      projectPath,
+      settingsService,
+      '[BacklogPlan]'
+    );
 
     // For Cursor models, we need to combine prompts with explicit instructions
     // because Cursor doesn't support systemPrompt separation like Claude SDK
     let finalPrompt = userPrompt;
-    let finalSystemPrompt: string | undefined = systemPrompt;
+    let finalSystemPrompt: string | SystemPromptPreset | undefined = systemPrompt;
+    let finalSettingSources: Array<'user' | 'project' | 'local'> | undefined;
 
     if (isCursorModel(effectiveModel)) {
       logger.info('[BacklogPlan] Using Cursor model - adding explicit no-file-write instructions');
@@ -187,54 +321,145 @@ CRITICAL INSTRUCTIONS:
 
 ${userPrompt}`;
       finalSystemPrompt = undefined; // System prompt is now embedded in the user prompt
+    } else if (claudeCompatibleProvider) {
+      // Claude-compatible providers (MiniMax, GLM, etc.) use a plain API; do not use
+      // the claude_code preset (which is for Claude CLI/subprocess and can break the request).
+      finalSystemPrompt = systemPrompt;
+    } else if (useClaudeCodeSystemPrompt) {
+      // Use claude_code preset for native Claude so the SDK subprocess
+      // authenticates via CLI OAuth or API key the same way all other SDK calls do.
+      finalSystemPrompt = {
+        type: 'preset',
+        preset: 'claude_code',
+        append: systemPrompt,
+      };
+    }
+    // Include settingSources when autoLoadClaudeMd is enabled
+    if (autoLoadClaudeMd) {
+      finalSettingSources = ['user', 'project'];
     }
 
-    // Execute the query
-    const stream = provider.executeQuery({
+    // Execute the query with retry logic for transient CLI failures
+    const queryOptions = {
       prompt: finalPrompt,
       model: bareModel,
       cwd: projectPath,
       systemPrompt: finalSystemPrompt,
       maxTurns: 1,
-      allowedTools: [], // No tools needed for this
+      tools: [] as string[], // Disable all built-in tools - plan generation only needs text output
       abortController,
-      settingSources: autoLoadClaudeMd ? ['user', 'project'] : undefined,
-      readOnly: true, // Plan generation only generates text, doesn't write files
+      settingSources: finalSettingSources,
       thinkingLevel, // Pass thinking level for extended thinking
       claudeCompatibleProvider, // Pass provider for alternative endpoint configuration
       credentials, // Pass credentials for resolving 'credentials' apiKeySource
-    });
+    };
 
     let responseText = '';
+    let bestResponseText = ''; // Preserve best response across all retry attempts
+    let recoveredResult: BacklogPlanResult | null = null;
+    let lastError: unknown = null;
 
-    for await (const msg of stream) {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       if (abortController.signal.aborted) {
         throw new Error('Generation aborted');
       }
 
-      if (msg.type === 'assistant') {
-        if (msg.message?.content) {
-          for (const block of msg.message.content) {
-            if (block.type === 'text') {
-              responseText += block.text;
+      if (attempt > 0) {
+        logger.info(
+          `[BacklogPlan] Retry attempt ${attempt}/${MAX_RETRIES} after transient failure`
+        );
+        events.emit('backlog-plan:event', {
+          type: 'backlog_plan_progress',
+          content: `Retrying... (attempt ${attempt + 1}/${MAX_RETRIES + 1})`,
+        });
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+      }
+
+      let accumulatedText = '';
+      let providerResultText = '';
+
+      try {
+        const stream = provider.executeQuery(queryOptions);
+
+        for await (const msg of stream) {
+          if (abortController.signal.aborted) {
+            throw new Error('Generation aborted');
+          }
+
+          if (msg.type === 'assistant') {
+            if (msg.message?.content) {
+              for (const block of msg.message.content) {
+                if (block.type === 'text') {
+                  accumulatedText += block.text;
+                }
+              }
             }
+          } else if (msg.type === 'result' && msg.subtype === 'success' && msg.result) {
+            providerResultText = msg.result;
+            logger.info(
+              '[BacklogPlan] Received result from provider, length:',
+              providerResultText.length
+            );
+            logger.info('[BacklogPlan] Accumulated response length:', accumulatedText.length);
           }
         }
-      } else if (msg.type === 'result' && msg.subtype === 'success' && msg.result) {
-        // Use result if it's a final accumulated message (from Cursor provider)
-        logger.info('[BacklogPlan] Received result from Cursor, length:', msg.result.length);
-        logger.info('[BacklogPlan] Previous responseText length:', responseText.length);
-        if (msg.result.length > responseText.length) {
-          logger.info('[BacklogPlan] Using Cursor result (longer than accumulated text)');
-          responseText = msg.result;
-        } else {
-          logger.info('[BacklogPlan] Keeping accumulated text (longer than Cursor result)');
+
+        responseText = selectBestResponseText(accumulatedText, providerResultText);
+
+        // If we got here, the stream completed successfully
+        lastError = null;
+        break;
+      } catch (error) {
+        lastError = error;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        responseText = selectBestResponseText(accumulatedText, providerResultText);
+
+        // Preserve the best response text across all attempts so that if a retry
+        // crashes immediately (empty response), we can still recover from an earlier attempt
+        bestResponseText = selectBestResponseText(bestResponseText, responseText);
+
+        // Claude SDK can occasionally exit non-zero after emitting a complete response.
+        // If we already have valid JSON, recover instead of failing the entire planning flow.
+        if (isRetryableError(error)) {
+          const parsed = tryParsePlanResponse(bestResponseText);
+          if (parsed) {
+            logger.warn(
+              '[BacklogPlan] Recovered from transient CLI exit using accumulated valid response'
+            );
+            recoveredResult = parsed;
+            lastError = null;
+            break;
+          }
+
+          // On final retryable failure, degrade gracefully if we have text from any attempt.
+          if (attempt >= MAX_RETRIES && bestResponseText.trim().length > 0) {
+            logger.warn(
+              '[BacklogPlan] Final retryable CLI failure with non-empty response, attempting fallback parse'
+            );
+            recoveredResult = parsePlanResponse(bestResponseText);
+            lastError = null;
+            break;
+          }
         }
+
+        // Only retry on transient CLI failures, not on user aborts or other errors
+        if (!isRetryableError(error) || attempt >= MAX_RETRIES) {
+          throw error;
+        }
+
+        logger.warn(
+          `[BacklogPlan] Transient CLI failure (attempt ${attempt + 1}/${MAX_RETRIES + 1}): ${errorMessage}`
+        );
       }
     }
 
+    // If we exhausted retries, throw the last error
+    if (lastError) {
+      throw lastError;
+    }
+
     // Parse the response
-    const result = parsePlanResponse(responseText);
+    const result = recoveredResult ?? parsePlanResponse(responseText);
 
     await saveBacklogPlan(projectPath, {
       savedAt: new Date().toISOString(),

apps/server/src/routes/backlog-plan/routes/generate.ts

@@ -17,10 +17,11 @@ import type { SettingsService } from '../../../services/settings-service.js';
 export function createGenerateHandler(events: EventEmitter, settingsService?: SettingsService) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { projectPath, prompt, model } = req.body as {
+      const { projectPath, prompt, model, branchName } = req.body as {
         projectPath: string;
         prompt: string;
         model?: string;
+        branchName?: string;
       };
 
       if (!projectPath) {
@@ -42,28 +43,30 @@ export function createGenerateHandler(events: EventEmitter, settingsService?: Se
         return;
       }
 
-      setRunningState(true);
+      const abortController = new AbortController();
+      setRunningState(true, abortController);
       setRunningDetails({
         projectPath,
         prompt,
         model,
         startedAt: new Date().toISOString(),
       });
-      const abortController = new AbortController();
-      setRunningState(true, abortController);
 
       // Start generation in background
-      // Note: generateBacklogPlan handles its own error event emission,
-      // so we only log here to avoid duplicate error toasts
-      generateBacklogPlan(projectPath, prompt, events, abortController, settingsService, model)
-        .catch((error) => {
-          // Just log - error event already emitted by generateBacklogPlan
-          logError(error, 'Generate backlog plan failed (background)');
-        })
-        .finally(() => {
-          setRunningState(false, null);
-          setRunningDetails(null);
-        });
+      // Note: generateBacklogPlan handles its own error event emission
+      // and state cleanup in its finally block, so we only log here
+      generateBacklogPlan(
+        projectPath,
+        prompt,
+        events,
+        abortController,
+        settingsService,
+        model,
+        branchName
+      ).catch((error) => {
+        // Just log - error event already emitted by generateBacklogPlan
+        logError(error, 'Generate backlog plan failed (background)');
+      });
 
       res.json({ success: true });
     } catch (error) {

apps/server/src/routes/context/routes/describe-image.ts

@@ -142,11 +142,33 @@ function mapDescribeImageError(rawMessage: string | undefined): {
 
   if (!rawMessage) return baseResponse;
 
-  if (rawMessage.includes('Claude Code process exited')) {
+  if (
+    rawMessage.includes('Claude Code process exited') ||
+    rawMessage.includes('Claude Code process terminated by signal')
+  ) {
+    const exitCodeMatch = rawMessage.match(/exited with code (\d+)/);
+    const signalMatch = rawMessage.match(/terminated by signal (\w+)/);
+    const detail = exitCodeMatch
+      ? ` (exit code: ${exitCodeMatch[1]})`
+      : signalMatch
+        ? ` (signal: ${signalMatch[1]})`
+        : '';
+
+    // Crash/OS-kill signals suggest a process crash, not an auth failure —
+    // omit auth recovery advice and suggest retry/reporting instead.
+    const crashSignals = ['SIGSEGV', 'SIGABRT', 'SIGKILL', 'SIGBUS', 'SIGTRAP'];
+    const isCrashSignal = signalMatch ? crashSignals.includes(signalMatch[1]) : false;
+
+    if (isCrashSignal) {
+      return {
+        statusCode: 503,
+        userMessage: `Claude crashed unexpectedly${detail} while describing the image. This may be a transient condition. Please try again. If the problem persists, collect logs and report the issue.`,
+      };
+    }
+
     return {
       statusCode: 503,
-      userMessage:
-        'Claude exited unexpectedly while describing the image. Try again. If it keeps happening, re-run `claude login` or update your API key in Setup so Claude can restart cleanly.',
+      userMessage: `Claude exited unexpectedly${detail} while describing the image. This is usually a transient issue. Try again. If it keeps happening, re-run \`claude login\` or update your API key in Setup.`,
     };
   }
 

apps/server/src/routes/features/index.ts

@@ -44,7 +44,11 @@ export function createFeaturesRoutes(
     validatePathParams('projectPath'),
     createCreateHandler(featureLoader, events)
   );
-  router.post('/update', validatePathParams('projectPath'), createUpdateHandler(featureLoader));
+  router.post(
+    '/update',
+    validatePathParams('projectPath'),
+    createUpdateHandler(featureLoader, events)
+  );
   router.post(
     '/bulk-update',
     validatePathParams('projectPath'),

apps/server/src/routes/features/routes/update.ts

@@ -5,6 +5,7 @@
 import type { Request, Response } from 'express';
 import { FeatureLoader } from '../../../services/feature-loader.js';
 import type { Feature, FeatureStatus } from '@automaker/types';
+import type { EventEmitter } from '../../../lib/events.js';
 import { getErrorMessage, logError } from '../common.js';
 import { createLogger } from '@automaker/utils';
 
@@ -13,7 +14,7 @@ const logger = createLogger('features/update');
 // Statuses that should trigger syncing to app_spec.txt
 const SYNC_TRIGGER_STATUSES: FeatureStatus[] = ['verified', 'completed'];
 
-export function createUpdateHandler(featureLoader: FeatureLoader) {
+export function createUpdateHandler(featureLoader: FeatureLoader, events?: EventEmitter) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
       const {
@@ -54,8 +55,18 @@ export function createUpdateHandler(featureLoader: FeatureLoader) {
         preEnhancementDescription
       );
 
-      // Trigger sync to app_spec.txt when status changes to verified or completed
+      // Emit completion event and sync to app_spec.txt when status transitions to verified/completed
       if (newStatus && SYNC_TRIGGER_STATUSES.includes(newStatus) && previousStatus !== newStatus) {
+        events?.emit('feature:completed', {
+          featureId,
+          featureName: updated.title,
+          projectPath,
+          passes: true,
+          message:
+            newStatus === 'verified' ? 'Feature verified manually' : 'Feature completed manually',
+          executionMode: 'manual',
+        });
+
         try {
           const synced = await featureLoader.syncFeatureToAppSpec(projectPath, updated);
           if (synced) {

apps/server/src/routes/worktree/index.ts

@@ -67,6 +67,9 @@ import { createAbortOperationHandler } from './routes/abort-operation.js';
 import { createContinueOperationHandler } from './routes/continue-operation.js';
 import { createStageFilesHandler } from './routes/stage-files.js';
 import { createCheckChangesHandler } from './routes/check-changes.js';
+import { createSetTrackingHandler } from './routes/set-tracking.js';
+import { createSyncHandler } from './routes/sync.js';
+import { createUpdatePRNumberHandler } from './routes/update-pr-number.js';
 import type { SettingsService } from '../../services/settings-service.js';
 
 export function createWorktreeRoutes(
@@ -94,6 +97,12 @@ export function createWorktreeRoutes(
   router.post('/delete', validatePathParams('projectPath', 'worktreePath'), createDeleteHandler());
   router.post('/create-pr', createCreatePRHandler());
   router.post('/pr-info', createPRInfoHandler());
+  router.post(
+    '/update-pr-number',
+    validatePathParams('worktreePath', 'projectPath?'),
+    requireValidWorktree,
+    createUpdatePRNumberHandler()
+  );
   router.post(
     '/commit',
     validatePathParams('worktreePath'),
@@ -118,6 +127,18 @@ export function createWorktreeRoutes(
     requireValidWorktree,
     createPullHandler()
   );
+  router.post(
+    '/sync',
+    validatePathParams('worktreePath'),
+    requireValidWorktree,
+    createSyncHandler()
+  );
+  router.post(
+    '/set-tracking',
+    validatePathParams('worktreePath'),
+    requireValidWorktree,
+    createSetTrackingHandler()
+  );
   router.post(
     '/checkout-branch',
     validatePathParams('worktreePath'),

apps/server/src/routes/worktree/routes/delete.ts

@@ -5,6 +5,7 @@
 import type { Request, Response } from 'express';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import fs from 'fs/promises';
 import { isGitRepo } from '@automaker/git-utils';
 import { getErrorMessage, logError, isValidBranchName } from '../common.js';
 import { execGitCommand } from '../../../lib/git.js';
@@ -46,20 +47,79 @@ export function createDeleteHandler() {
         });
         branchName = stdout.trim();
       } catch {
-        // Could not get branch name
+        // Could not get branch name - worktree directory may already be gone
+        logger.debug('Could not determine branch for worktree, directory may be missing');
       }
 
       // Remove the worktree (using array arguments to prevent injection)
+      let removeSucceeded = false;
       try {
         await execGitCommand(['worktree', 'remove', worktreePath, '--force'], projectPath);
-      } catch {
-        // Try with prune if remove fails
-        await execGitCommand(['worktree', 'prune'], projectPath);
+        removeSucceeded = true;
+      } catch (removeError) {
+        // `git worktree remove` can fail if the directory is already missing
+        // or in a bad state. Try pruning stale worktree entries as a fallback.
+        logger.debug('git worktree remove failed, trying prune', {
+          error: getErrorMessage(removeError),
+        });
+        try {
+          await execGitCommand(['worktree', 'prune'], projectPath);
+
+          // Verify the specific worktree is no longer registered after prune.
+          // `git worktree prune` exits 0 even if worktreePath was never registered,
+          // so we must explicitly check the worktree list to avoid false positives.
+          const { stdout: listOut } = await execAsync('git worktree list --porcelain', {
+            cwd: projectPath,
+          });
+          // Parse porcelain output and check for an exact path match.
+          // Using substring .includes() can produce false positives when one
+          // worktree path is a prefix of another (e.g. /foo vs /foobar).
+          const stillRegistered = listOut
+            .split('\n')
+            .filter((line) => line.startsWith('worktree '))
+            .map((line) => line.slice('worktree '.length).trim())
+            .some((registeredPath) => registeredPath === worktreePath);
+          if (stillRegistered) {
+            // Prune didn't clean up our entry - treat as failure
+            throw removeError;
+          }
+          removeSucceeded = true;
+        } catch (pruneError) {
+          // If pruneError is the original removeError re-thrown, propagate it
+          if (pruneError === removeError) {
+            throw removeError;
+          }
+          logger.warn('git worktree prune also failed', {
+            error: getErrorMessage(pruneError),
+          });
+          // If both remove and prune fail, still try to return success
+          // if the worktree directory no longer exists (it may have been
+          // manually deleted already).
+          let dirExists = false;
+          try {
+            await fs.access(worktreePath);
+            dirExists = true;
+          } catch {
+            // Directory doesn't exist
+          }
+          if (dirExists) {
+            // Directory still exists - this is a real failure
+            throw removeError;
+          }
+          // Directory is gone, treat as success
+          removeSucceeded = true;
+        }
       }
 
-      // Optionally delete the branch
+      // Optionally delete the branch (only if worktree was successfully removed)
       let branchDeleted = false;
-      if (deleteBranch && branchName && branchName !== 'main' && branchName !== 'master') {
+      if (
+        removeSucceeded &&
+        deleteBranch &&
+        branchName &&
+        branchName !== 'main' &&
+        branchName !== 'master'
+      ) {
         // Validate branch name to prevent command injection
         if (!isValidBranchName(branchName)) {
           logger.warn(`Invalid branch name detected, skipping deletion: ${branchName}`);

apps/server/src/routes/worktree/routes/discard-changes.ts

@@ -5,12 +5,12 @@
  * 1. Discard ALL changes (when no files array is provided)
  *    - Resets staged changes (git reset HEAD)
  *    - Discards modified tracked files (git checkout .)
- *    - Removes untracked files and directories (git clean -fd)
+ *    - Removes untracked files and directories (git clean -ffd)
  *
  * 2. Discard SELECTED files (when files array is provided)
  *    - Unstages selected staged files (git reset HEAD -- <files>)
  *    - Reverts selected tracked file changes (git checkout -- <files>)
- *    - Removes selected untracked files (git clean -fd -- <files>)
+ *    - Removes selected untracked files (git clean -ffd -- <files>)
  *
  * Note: Git repository validation (isGitRepo) is handled by
  * the requireGitRepoOnly middleware in index.ts
@@ -52,6 +52,22 @@ function validateFilePath(filePath: string, worktreePath: string): boolean {
   }
 }
 
+/**
+ * Parse a file path from git status --porcelain output, handling renames.
+ * For renamed files (R status), git reports "old_path -> new_path" and
+ * we need the new path to match what parseGitStatus() returns in git-utils.
+ */
+function parseFilePath(rawPath: string, indexStatus: string, workTreeStatus: string): string {
+  const trimmedPath = rawPath.trim();
+  if (indexStatus === 'R' || workTreeStatus === 'R') {
+    const arrowIndex = trimmedPath.indexOf(' -> ');
+    if (arrowIndex !== -1) {
+      return trimmedPath.slice(arrowIndex + 4);
+    }
+  }
+  return trimmedPath;
+}
+
 export function createDiscardChangesHandler() {
   return async (req: Request, res: Response): Promise<void> => {
     try {
@@ -91,11 +107,16 @@ export function createDiscardChangesHandler() {
 
       // Parse the status output to categorize files
       // Git --porcelain format: XY PATH where X=index status, Y=worktree status
-      // Preserve the exact two-character XY status (no trim) to keep index vs worktree info
+      // For renamed files: XY OLD_PATH -> NEW_PATH
       const statusLines = status.trim().split('\n').filter(Boolean);
       const allFiles = statusLines.map((line) => {
         const fileStatus = line.substring(0, 2);
-        const filePath = line.slice(3).trim();
+        const rawPath = line.slice(3);
+        const indexStatus = fileStatus.charAt(0);
+        const workTreeStatus = fileStatus.charAt(1);
+        // Parse path consistently with parseGitStatus() in git-utils,
+        // which extracts the new path for renames
+        const filePath = parseFilePath(rawPath, indexStatus, workTreeStatus);
         return { status: fileStatus, path: filePath };
       });
 
@@ -122,8 +143,12 @@ export function createDiscardChangesHandler() {
         const untrackedFiles: string[] = []; // Untracked files (?)
         const warnings: string[] = [];
 
+        // Track which requested files were matched so we can handle unmatched ones
+        const matchedFiles = new Set<string>();
+
         for (const file of allFiles) {
           if (!filesToDiscard.has(file.path)) continue;
+          matchedFiles.add(file.path);
 
           // file.status is the raw two-character XY git porcelain status (no trim)
           // X = index/staging status, Y = worktree status
@@ -151,6 +176,16 @@ export function createDiscardChangesHandler() {
           }
         }
 
+        // Handle files from the UI that didn't match any entry in allFiles.
+        // This can happen due to timing differences between the UI loading diffs
+        // and the discard request, or path format differences.
+        // Attempt to clean unmatched files directly as untracked files.
+        for (const requestedFile of files) {
+          if (!matchedFiles.has(requestedFile)) {
+            untrackedFiles.push(requestedFile);
+          }
+        }
+
         // 1. Unstage selected staged files (using execFile to bypass shell)
         if (stagedFiles.length > 0) {
           try {
@@ -174,9 +209,10 @@ export function createDiscardChangesHandler() {
         }
 
         // 3. Remove selected untracked files
+        // Use -ffd (double force) to also handle nested git repositories
         if (untrackedFiles.length > 0) {
           try {
-            await execGitCommand(['clean', '-fd', '--', ...untrackedFiles], worktreePath);
+            await execGitCommand(['clean', '-ffd', '--', ...untrackedFiles], worktreePath);
           } catch (error) {
             const msg = getErrorMessage(error);
             logError(error, `Failed to clean untracked files: ${msg}`);
@@ -234,11 +270,12 @@ export function createDiscardChangesHandler() {
         }
 
         // 3. Remove untracked files and directories
+        // Use -ffd (double force) to also handle nested git repositories
         try {
-          await execGitCommand(['clean', '-fd'], worktreePath);
+          await execGitCommand(['clean', '-ffd', '--'], worktreePath);
         } catch (error) {
           const msg = getErrorMessage(error);
-          logError(error, `git clean -fd failed: ${msg}`);
+          logError(error, `git clean -ffd failed: ${msg}`);
           warnings.push(`Failed to remove untracked files: ${msg}`);
         }
 

apps/server/src/routes/worktree/routes/generate-pr-description.ts

@@ -53,7 +53,9 @@ Rules:
 - Focus on the user-facing impact when possible
 - If there are breaking changes, mention them prominently
 - The diff may include both committed changes and uncommitted working directory changes. Treat all changes as part of the PR since uncommitted changes will be committed when the PR is created
-- Do NOT distinguish between committed and uncommitted changes in the output - describe all changes as a unified set of PR changes`;
+- Do NOT distinguish between committed and uncommitted changes in the output - describe all changes as a unified set of PR changes
+- EXCLUDE any files that are gitignored (e.g., node_modules, dist, build, .env files, lock files, generated files, binary artifacts, coverage reports, cache directories). These should not be mentioned in the description even if they appear in the diff
+- Focus only on meaningful source code changes that are tracked by git and relevant to reviewers`;
 
 /**
  * Wraps an async generator with a timeout.
@@ -168,127 +170,125 @@ export function createGeneratePRDescriptionHandler(
       // Determine the base branch for comparison
       const base = baseBranch || 'main';
 
-      // Get the diff between current branch and base branch (committed changes)
-      // Track whether the diff method used only includes committed changes.
-      // `git diff base...HEAD` and `git diff origin/base...HEAD` only show committed changes,
-      // while the fallback methods (`git diff HEAD`, `git diff --cached + git diff`) already
-      // include uncommitted working directory changes.
-      let diff = '';
-      let diffIncludesUncommitted = false;
+      // Collect diffs in three layers and combine them:
+      //   1. Committed changes on the branch: `git diff base...HEAD`
+      //   2. Staged (cached) changes not yet committed: `git diff --cached`
+      //   3. Unstaged changes to tracked files: `git diff` (no --cached flag)
+      //
+      // Untracked files are intentionally excluded — they are typically build artifacts,
+      // planning files, hidden dotfiles, or other files unrelated to the PR.
+      // `git diff` and `git diff --cached` only show changes to files already tracked by git,
+      // which is exactly the correct scope.
+      //
+      // We combine all three sources and deduplicate by file path so that a file modified
+      // in commits AND with additional uncommitted changes is not double-counted.
+
+      /** Parse a unified diff into per-file hunks keyed by file path */
+      function parseDiffIntoFileHunks(diffText: string): Map<string, string> {
+        const fileHunks = new Map<string, string>();
+        if (!diffText.trim()) return fileHunks;
+
+        // Split on "diff --git" boundaries (keep the delimiter)
+        const sections = diffText.split(/(?=^diff --git )/m);
+        for (const section of sections) {
+          if (!section.trim()) continue;
+          // Use a back-reference pattern so the "b/" side must match the "a/" capture,
+          // correctly handling paths that contain " b/" in their name.
+          // Falls back to a two-capture pattern to handle renames (a/ and b/ differ).
+          const backrefMatch = section.match(/^diff --git a\/(.+) b\/\1$/m);
+          const renameMatch = !backrefMatch ? section.match(/^diff --git a\/(.+) b\/(.+)$/m) : null;
+          const match = backrefMatch || renameMatch;
+          if (match) {
+            // Prefer the backref capture (identical paths); for renames use the destination (match[2])
+            const filePath = backrefMatch ? match[1] : match[2];
+            // Merge hunks if the same file appears in multiple diff sources
+            const existing = fileHunks.get(filePath) ?? '';
+            fileHunks.set(filePath, existing + section);
+          }
+        }
+        return fileHunks;
+      }
+
+      // --- Step 1: committed changes (branch vs base) ---
+      let committedDiff = '';
       try {
-        // First, try to get diff against the base branch
-        const { stdout: branchDiff } = await execFileAsync('git', ['diff', `${base}...HEAD`], {
+        const { stdout } = await execFileAsync('git', ['diff', `${base}...HEAD`], {
           cwd: worktreePath,
-          maxBuffer: 1024 * 1024 * 5, // 5MB buffer
+          maxBuffer: 1024 * 1024 * 5,
         });
-        diff = branchDiff;
-        // git diff base...HEAD only shows committed changes
-        diffIncludesUncommitted = false;
+        committedDiff = stdout;
       } catch {
-        // If branch comparison fails (e.g., base branch doesn't exist locally),
-        // try fetching and comparing against remote base
+        // Base branch may not exist locally; try the remote tracking branch
         try {
-          const { stdout: remoteDiff } = await execFileAsync(
-            'git',
-            ['diff', `origin/${base}...HEAD`],
-            {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            }
-          );
-          diff = remoteDiff;
-          // git diff origin/base...HEAD only shows committed changes
-          diffIncludesUncommitted = false;
+          const { stdout } = await execFileAsync('git', ['diff', `origin/${base}...HEAD`], {
+            cwd: worktreePath,
+            maxBuffer: 1024 * 1024 * 5,
+          });
+          committedDiff = stdout;
         } catch {
-          // Fall back to getting all uncommitted + committed changes
-          try {
-            const { stdout: allDiff } = await execFileAsync('git', ['diff', 'HEAD'], {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            });
-            diff = allDiff;
-            // git diff HEAD includes uncommitted changes
-            diffIncludesUncommitted = true;
-          } catch {
-            // Last resort: get staged + unstaged changes
-            const { stdout: stagedDiff } = await execFileAsync('git', ['diff', '--cached'], {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            });
-            const { stdout: unstagedDiff } = await execFileAsync('git', ['diff'], {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            });
-            diff = stagedDiff + unstagedDiff;
-            // These already include uncommitted changes
-            diffIncludesUncommitted = true;
-          }
+          // Cannot compare against base — leave committedDiff empty; the uncommitted
+          // changes gathered below will still be included.
+          logger.warn(`Could not get committed diff against ${base} or origin/${base}`);
         }
       }
 
-      // Check for uncommitted changes (staged + unstaged) to include in the description.
-      // When creating a PR, uncommitted changes will be auto-committed, so they should be
-      // reflected in the generated description. We only need to fetch uncommitted diffs
-      // when the primary diff method (base...HEAD) was used, since it only shows committed changes.
-      let hasUncommittedChanges = false;
+      // --- Step 2: staged changes (tracked files only) ---
+      let stagedDiff = '';
       try {
-        const { stdout: statusOutput } = await execFileAsync('git', ['status', '--porcelain'], {
+        const { stdout } = await execFileAsync('git', ['diff', '--cached'], {
           cwd: worktreePath,
+          maxBuffer: 1024 * 1024 * 5,
         });
-        hasUncommittedChanges = statusOutput.trim().length > 0;
-
-        if (hasUncommittedChanges && !diffIncludesUncommitted) {
-          logger.info('Uncommitted changes detected, including in PR description context');
-
-          let uncommittedDiff = '';
-
-          // Get staged changes
-          try {
-            const { stdout: stagedDiff } = await execFileAsync('git', ['diff', '--cached'], {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            });
-            if (stagedDiff.trim()) {
-              uncommittedDiff += stagedDiff;
-            }
-          } catch {
-            // Ignore staged diff errors
-          }
-
-          // Get unstaged changes (tracked files only)
-          try {
-            const { stdout: unstagedDiff } = await execFileAsync('git', ['diff'], {
-              cwd: worktreePath,
-              maxBuffer: 1024 * 1024 * 5,
-            });
-            if (unstagedDiff.trim()) {
-              uncommittedDiff += unstagedDiff;
-            }
-          } catch {
-            // Ignore unstaged diff errors
-          }
-
-          // Get list of untracked files for context
-          const untrackedFiles = statusOutput
-            .split('\n')
-            .filter((line) => line.startsWith('??'))
-            .map((line) => line.substring(3).trim());
-
-          if (untrackedFiles.length > 0) {
-            // Add a summary of untracked (new) files as context
-            uncommittedDiff += `\n# New untracked files:\n${untrackedFiles.map((f) => `# + ${f}`).join('\n')}\n`;
-          }
-
-          // Append uncommitted changes to the committed diff
-          if (uncommittedDiff.trim()) {
-            diff = diff + uncommittedDiff;
-          }
-        }
-      } catch {
-        // Ignore errors checking for uncommitted changes
+        stagedDiff = stdout;
+      } catch (err) {
+        // Non-fatal — staged diff is a best-effort supplement
+        logger.debug('Failed to get staged diff', err);
       }
 
-      // Also get the commit log for context
+      // --- Step 3: unstaged changes (tracked files only) ---
+      let unstagedDiff = '';
+      try {
+        const { stdout } = await execFileAsync('git', ['diff'], {
+          cwd: worktreePath,
+          maxBuffer: 1024 * 1024 * 5,
+        });
+        unstagedDiff = stdout;
+      } catch (err) {
+        // Non-fatal — unstaged diff is a best-effort supplement
+        logger.debug('Failed to get unstaged diff', err);
+      }
+
+      // --- Combine and deduplicate ---
+      // Build a map of filePath → diff content by concatenating hunks from all sources
+      // in chronological order (committed → staged → unstaged) so that no changes
+      // are lost when a file appears in multiple diff sources.
+      const combinedFileHunks = new Map<string, string>();
+
+      for (const source of [committedDiff, stagedDiff, unstagedDiff]) {
+        const hunks = parseDiffIntoFileHunks(source);
+        for (const [filePath, hunk] of hunks) {
+          if (combinedFileHunks.has(filePath)) {
+            combinedFileHunks.set(filePath, combinedFileHunks.get(filePath)! + hunk);
+          } else {
+            combinedFileHunks.set(filePath, hunk);
+          }
+        }
+      }
+
+      const diff = Array.from(combinedFileHunks.values()).join('');
+
+      // Log what files were included for observability
+      if (combinedFileHunks.size > 0) {
+        logger.info(`PR description scope: ${combinedFileHunks.size} file(s)`);
+        logger.debug(
+          `PR description scope files: ${Array.from(combinedFileHunks.keys()).join(', ')}`
+        );
+      }
+
+      // Also get the commit log for context — always scoped to the selected base branch
+      // so the log only contains commits that are part of this PR.
+      // We do NOT fall back to an unscoped `git log` because that would include commits
+      // from the base branch itself and produce misleading AI context.
       let commitLog = '';
       try {
         const { stdout: logOutput } = await execFileAsync(
@@ -301,11 +301,11 @@ export function createGeneratePRDescriptionHandler(
         );
         commitLog = logOutput.trim();
       } catch {
-        // If comparing against base fails, fall back to recent commits
+        // Base branch not available locally — try the remote tracking branch
         try {
           const { stdout: logOutput } = await execFileAsync(
             'git',
-            ['log', '--oneline', '-10', '--no-decorate'],
+            ['log', `origin/${base}..HEAD`, '--oneline', '--no-decorate'],
             {
               cwd: worktreePath,
               maxBuffer: 1024 * 1024,
@@ -313,7 +313,9 @@ export function createGeneratePRDescriptionHandler(
           );
           commitLog = logOutput.trim();
         } catch {
-          // Ignore commit log errors
+          // Cannot scope commit log to base branch — leave empty rather than
+          // including unscoped commits that would pollute the AI context.
+          logger.warn(`Could not get commit log against ${base} or origin/${base}`);
         }
       }
 
@@ -339,10 +341,6 @@ export function createGeneratePRDescriptionHandler(
         userPrompt += `\nCommit History:\n${commitLog}\n`;
       }
 
-      if (hasUncommittedChanges) {
-        userPrompt += `\nNote: This branch has uncommitted changes that will be included in the PR.\n`;
-      }
-
       if (truncatedDiff) {
         userPrompt += `\n\`\`\`diff\n${truncatedDiff}\n\`\`\``;
       }

apps/server/src/routes/worktree/routes/list-branches.ts

@@ -9,6 +9,7 @@ import type { Request, Response } from 'express';
 import { exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import { getErrorMessage, logWorktreeError } from '../common.js';
+import { getRemotesWithBranch } from '../../../services/worktree-service.js';
 
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
@@ -131,6 +132,8 @@ export function createListBranchesHandler() {
       let behindCount = 0;
       let hasRemoteBranch = false;
       let trackingRemote: string | undefined;
+      // List of remote names that have a branch matching the current branch name
+      let remotesWithBranch: string[] = [];
       try {
         // First check if there's a remote tracking branch
         const { stdout: upstreamOutput } = await execFileAsync(
@@ -172,6 +175,12 @@ export function createListBranchesHandler() {
         }
       }
 
+      // Check which remotes have a branch matching the current branch name.
+      // This helps the UI distinguish between "branch exists on tracking remote" vs
+      // "branch was pushed to a different remote" (e.g., pushed to 'upstream' but tracking 'origin').
+      // Use for-each-ref to check cached remote refs (already fetched above if includeRemote was true)
+      remotesWithBranch = await getRemotesWithBranch(worktreePath, currentBranch, hasAnyRemotes);
+
       res.json({
         success: true,
         result: {
@@ -182,6 +191,7 @@ export function createListBranchesHandler() {
           hasRemoteBranch,
           hasAnyRemotes,
           trackingRemote,
+          remotesWithBranch,
         },
       });
     } catch (error) {

apps/server/src/routes/worktree/routes/push.ts

@@ -1,24 +1,24 @@
 /**
  * POST /push endpoint - Push a worktree branch to remote
  *
+ * Git business logic is delegated to push-service.ts.
+ *
  * Note: Git repository validation (isGitRepo, hasCommits) is handled by
  * the requireValidWorktree middleware in index.ts
  */
 
 import type { Request, Response } from 'express';
-import { exec } from 'child_process';
-import { promisify } from 'util';
 import { getErrorMessage, logError } from '../common.js';
-
-const execAsync = promisify(exec);
+import { performPush } from '../../../services/push-service.js';
 
 export function createPushHandler() {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { worktreePath, force, remote } = req.body as {
+      const { worktreePath, force, remote, autoResolve } = req.body as {
         worktreePath: string;
         force?: boolean;
         remote?: string;
+        autoResolve?: boolean;
       };
 
       if (!worktreePath) {
@@ -29,34 +29,28 @@ export function createPushHandler() {
         return;
       }
 
-      // Get branch name
-      const { stdout: branchOutput } = await execAsync('git rev-parse --abbrev-ref HEAD', {
-        cwd: worktreePath,
-      });
-      const branchName = branchOutput.trim();
+      const result = await performPush(worktreePath, { remote, force, autoResolve });
 
-      // Use specified remote or default to 'origin'
-      const targetRemote = remote || 'origin';
-
-      // Push the branch
-      const forceFlag = force ? '--force' : '';
-      try {
-        await execAsync(`git push -u ${targetRemote} ${branchName} ${forceFlag}`, {
-          cwd: worktreePath,
-        });
-      } catch {
-        // Try setting upstream
-        await execAsync(`git push --set-upstream ${targetRemote} ${branchName} ${forceFlag}`, {
-          cwd: worktreePath,
+      if (!result.success) {
+        const statusCode = isClientError(result.error ?? '') ? 400 : 500;
+        res.status(statusCode).json({
+          success: false,
+          error: result.error,
+          diverged: result.diverged,
+          hasConflicts: result.hasConflicts,
+          conflictFiles: result.conflictFiles,
         });
+        return;
       }
 
       res.json({
         success: true,
         result: {
-          branch: branchName,
-          pushed: true,
-          message: `Successfully pushed ${branchName} to ${targetRemote}`,
+          branch: result.branch,
+          pushed: result.pushed,
+          diverged: result.diverged,
+          autoResolved: result.autoResolved,
+          message: result.message,
         },
       });
     } catch (error) {
@@ -65,3 +59,15 @@ export function createPushHandler() {
     }
   };
 }
+
+/**
+ * Determine whether an error message represents a client error (400)
+ * vs a server error (500).
+ */
+function isClientError(errorMessage: string): boolean {
+  return (
+    errorMessage.includes('detached HEAD') ||
+    errorMessage.includes('rejected') ||
+    errorMessage.includes('diverged')
+  );
+}

apps/server/src/routes/worktree/routes/set-tracking.ts

@@ -0,0 +1,76 @@
+/**
+ * POST /set-tracking endpoint - Set the upstream tracking branch for a worktree
+ *
+ * Sets `git branch --set-upstream-to=<remote>/<branch>` for the current branch.
+ *
+ * Note: Git repository validation (isGitRepo, hasCommits) is handled by
+ * the requireValidWorktree middleware in index.ts
+ */
+
+import type { Request, Response } from 'express';
+import { execGitCommand } from '@automaker/git-utils';
+import { getErrorMessage, logError } from '../common.js';
+import { getCurrentBranch } from '../../../lib/git.js';
+
+export function createSetTrackingHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { worktreePath, remote, branch } = req.body as {
+        worktreePath: string;
+        remote: string;
+        branch?: string;
+      };
+
+      if (!worktreePath) {
+        res.status(400).json({ success: false, error: 'worktreePath required' });
+        return;
+      }
+
+      if (!remote) {
+        res.status(400).json({ success: false, error: 'remote required' });
+        return;
+      }
+
+      // Get current branch if not provided
+      let targetBranch = branch;
+      if (!targetBranch) {
+        try {
+          targetBranch = await getCurrentBranch(worktreePath);
+        } catch (err) {
+          res.status(400).json({
+            success: false,
+            error: `Failed to get current branch: ${getErrorMessage(err)}`,
+          });
+          return;
+        }
+
+        if (targetBranch === 'HEAD') {
+          res.status(400).json({
+            success: false,
+            error: 'Cannot set tracking in detached HEAD state.',
+          });
+          return;
+        }
+      }
+
+      // Set upstream tracking (pass local branch name as final arg to be explicit)
+      await execGitCommand(
+        ['branch', '--set-upstream-to', `${remote}/${targetBranch}`, targetBranch],
+        worktreePath
+      );
+
+      res.json({
+        success: true,
+        result: {
+          branch: targetBranch,
+          remote,
+          upstream: `${remote}/${targetBranch}`,
+          message: `Set tracking branch to ${remote}/${targetBranch}`,
+        },
+      });
+    } catch (error) {
+      logError(error, 'Set tracking branch failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/worktree/routes/sync.ts

@@ -0,0 +1,66 @@
+/**
+ * POST /sync endpoint - Pull then push a worktree branch
+ *
+ * Performs a full sync operation: pull latest from remote, then push
+ * local commits. Handles divergence automatically.
+ *
+ * Git business logic is delegated to sync-service.ts.
+ *
+ * Note: Git repository validation (isGitRepo, hasCommits) is handled by
+ * the requireValidWorktree middleware in index.ts
+ */
+
+import type { Request, Response } from 'express';
+import { getErrorMessage, logError } from '../common.js';
+import { performSync } from '../../../services/sync-service.js';
+
+export function createSyncHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { worktreePath, remote } = req.body as {
+        worktreePath: string;
+        remote?: string;
+      };
+
+      if (!worktreePath) {
+        res.status(400).json({
+          success: false,
+          error: 'worktreePath required',
+        });
+        return;
+      }
+
+      const result = await performSync(worktreePath, { remote });
+
+      if (!result.success) {
+        const statusCode = result.hasConflicts ? 409 : 500;
+        res.status(statusCode).json({
+          success: false,
+          error: result.error,
+          hasConflicts: result.hasConflicts,
+          conflictFiles: result.conflictFiles,
+          conflictSource: result.conflictSource,
+          pulled: result.pulled,
+          pushed: result.pushed,
+        });
+        return;
+      }
+
+      res.json({
+        success: true,
+        result: {
+          branch: result.branch,
+          pulled: result.pulled,
+          pushed: result.pushed,
+          isFastForward: result.isFastForward,
+          isMerge: result.isMerge,
+          autoResolved: result.autoResolved,
+          message: result.message,
+        },
+      });
+    } catch (error) {
+      logError(error, 'Sync worktree failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/worktree/routes/update-pr-number.ts

@@ -0,0 +1,163 @@
+/**
+ * POST /update-pr-number endpoint - Update the tracked PR number for a worktree
+ *
+ * Allows users to manually change which PR number is tracked for a worktree branch.
+ * Fetches updated PR info from GitHub when available, or updates metadata with the
+ * provided number only if GitHub CLI is unavailable.
+ */
+
+import type { Request, Response } from 'express';
+import { getErrorMessage, logError, execAsync, execEnv, isGhCliAvailable } from '../common.js';
+import { updateWorktreePRInfo } from '../../../lib/worktree-metadata.js';
+import { createLogger } from '@automaker/utils';
+import { validatePRState } from '@automaker/types';
+
+const logger = createLogger('UpdatePRNumber');
+
+export function createUpdatePRNumberHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { worktreePath, projectPath, prNumber } = req.body as {
+        worktreePath: string;
+        projectPath?: string;
+        prNumber: number;
+      };
+
+      if (!worktreePath) {
+        res.status(400).json({ success: false, error: 'worktreePath required' });
+        return;
+      }
+
+      if (
+        !prNumber ||
+        typeof prNumber !== 'number' ||
+        prNumber <= 0 ||
+        !Number.isInteger(prNumber)
+      ) {
+        res.status(400).json({ success: false, error: 'prNumber must be a positive integer' });
+        return;
+      }
+
+      const effectiveProjectPath = projectPath || worktreePath;
+
+      // Get current branch name
+      const { stdout: branchOutput } = await execAsync('git rev-parse --abbrev-ref HEAD', {
+        cwd: worktreePath,
+        env: execEnv,
+      });
+      const branchName = branchOutput.trim();
+
+      if (!branchName || branchName === 'HEAD') {
+        res.status(400).json({
+          success: false,
+          error: 'Cannot update PR number in detached HEAD state',
+        });
+        return;
+      }
+
+      // Try to fetch PR info from GitHub for the given PR number
+      const ghCliAvailable = await isGhCliAvailable();
+
+      if (ghCliAvailable) {
+        try {
+          // Detect repository for gh CLI
+          let repoFlag = '';
+          try {
+            const { stdout: remotes } = await execAsync('git remote -v', {
+              cwd: worktreePath,
+              env: execEnv,
+            });
+            const lines = remotes.split(/\r?\n/);
+            let upstreamRepo: string | null = null;
+            let originOwner: string | null = null;
+            let originRepo: string | null = null;
+
+            for (const line of lines) {
+              const match =
+                line.match(/^(\w+)\s+.*[:/]([^/]+)\/([^/\s]+?)(?:\.git)?\s+\(fetch\)/) ||
+                line.match(/^(\w+)\s+git@[^:]+:([^/]+)\/([^\s]+?)(?:\.git)?\s+\(fetch\)/) ||
+                line.match(/^(\w+)\s+https?:\/\/[^/]+\/([^/]+)\/([^\s]+?)(?:\.git)?\s+\(fetch\)/);
+
+              if (match) {
+                const [, remoteName, owner, repo] = match;
+                if (remoteName === 'upstream') {
+                  upstreamRepo = `${owner}/${repo}`;
+                } else if (remoteName === 'origin') {
+                  originOwner = owner;
+                  originRepo = repo;
+                }
+              }
+            }
+
+            const targetRepo =
+              upstreamRepo || (originOwner && originRepo ? `${originOwner}/${originRepo}` : null);
+            if (targetRepo) {
+              repoFlag = ` --repo "${targetRepo}"`;
+            }
+          } catch {
+            // Ignore remote parsing errors
+          }
+
+          // Fetch PR info from GitHub using the PR number
+          const viewCmd = `gh pr view ${prNumber}${repoFlag} --json number,title,url,state,createdAt`;
+          const { stdout: prOutput } = await execAsync(viewCmd, {
+            cwd: worktreePath,
+            env: execEnv,
+          });
+
+          const prData = JSON.parse(prOutput);
+
+          const prInfo = {
+            number: prData.number,
+            url: prData.url,
+            title: prData.title,
+            state: validatePRState(prData.state),
+            createdAt: prData.createdAt || new Date().toISOString(),
+          };
+
+          await updateWorktreePRInfo(effectiveProjectPath, branchName, prInfo);
+
+          logger.info(`Updated PR tracking to #${prNumber} for branch ${branchName}`);
+
+          res.json({
+            success: true,
+            result: {
+              branch: branchName,
+              prInfo,
+            },
+          });
+          return;
+        } catch (error) {
+          logger.warn(`Failed to fetch PR #${prNumber} from GitHub:`, error);
+          // Fall through to simple update below
+        }
+      }
+
+      // Fallback: update with just the number, preserving existing PR info structure
+      // or creating minimal info if no GitHub data available
+      const prInfo = {
+        number: prNumber,
+        url: `https://github.com/pulls/${prNumber}`,
+        title: `PR #${prNumber}`,
+        state: validatePRState('OPEN'),
+        createdAt: new Date().toISOString(),
+      };
+
+      await updateWorktreePRInfo(effectiveProjectPath, branchName, prInfo);
+
+      logger.info(`Updated PR tracking to #${prNumber} for branch ${branchName} (no GitHub data)`);
+
+      res.json({
+        success: true,
+        result: {
+          branch: branchName,
+          prInfo,
+          ghCliUnavailable: !ghCliAvailable,
+        },
+      });
+    } catch (error) {
+      logError(error, 'Update PR number failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/services/agent-executor-types.ts

@@ -5,6 +5,7 @@
 import type {
   PlanningMode,
   ThinkingLevel,
+  ReasoningEffort,
   ParsedTask,
   ClaudeCompatibleProvider,
   Credentials,
@@ -24,11 +25,14 @@ export interface AgentExecutionOptions {
   previousContent?: string;
   systemPrompt?: string;
   autoLoadClaudeMd?: boolean;
+  useClaudeCodeSystemPrompt?: boolean;
   thinkingLevel?: ThinkingLevel;
+  reasoningEffort?: ReasoningEffort;
   branchName?: string | null;
   credentials?: Credentials;
   claudeCompatibleProvider?: ClaudeCompatibleProvider;
   mcpServers?: Record<string, unknown>;
+  sdkSessionId?: string;
   sdkOptions?: {
     maxTurns?: number;
     allowedTools?: string[];

apps/server/src/services/agent-executor.ts

@@ -38,7 +38,7 @@ export type {
 
 const logger = createLogger('AgentExecutor');
 
-const DEFAULT_MAX_TURNS = 1000;
+const DEFAULT_MAX_TURNS = 10000;
 
 export class AgentExecutor {
   private static readonly WRITE_DEBOUNCE_MS = 500;
@@ -93,6 +93,7 @@ export class AgentExecutor {
       credentials,
       claudeCompatibleProvider,
       mcpServers,
+      sdkSessionId,
       sdkOptions,
     } = options;
     const { content: promptContent } = await buildPromptWithImages(
@@ -127,8 +128,10 @@ export class AgentExecutor {
           ? (mcpServers as Record<string, { command: string }>)
           : undefined,
       thinkingLevel: options.thinkingLevel,
+      reasoningEffort: options.reasoningEffort,
       credentials,
       claudeCompatibleProvider,
+      sdkSessionId,
     };
     const featureDirForOutput = getFeatureDir(projectPath, featureId);
     const outputPath = path.join(featureDirForOutput, 'agent-output.md');
@@ -217,6 +220,9 @@ export class AgentExecutor {
     try {
       const stream = provider.executeQuery(executeOptions);
       streamLoop: for await (const msg of stream) {
+        if (msg.session_id && msg.session_id !== options.sdkSessionId) {
+          options.sdkSessionId = msg.session_id;
+        }
         receivedAnyStreamMessage = true;
         appendRawEvent(msg);
         if (abortController.signal.aborted) {
@@ -290,8 +296,28 @@ export class AgentExecutor {
             }
           }
         } else if (msg.type === 'error') {
-          throw new Error(AgentExecutor.sanitizeProviderError(msg.error));
-        } else if (msg.type === 'result' && msg.subtype === 'success') scheduleWrite();
+          const sanitized = AgentExecutor.sanitizeProviderError(msg.error);
+          logger.error(
+            `[execute] Feature ${featureId} received error from provider. ` +
+              `raw="${msg.error}", sanitized="${sanitized}", session_id=${msg.session_id ?? 'none'}`
+          );
+          throw new Error(sanitized);
+        } else if (msg.type === 'result') {
+          if (msg.subtype === 'success') {
+            scheduleWrite();
+          } else if (msg.subtype?.startsWith('error')) {
+            // Non-success result subtypes from the SDK (error_max_turns, error_during_execution, etc.)
+            logger.error(
+              `[execute] Feature ${featureId} ended with error subtype: ${msg.subtype}. ` +
+                `session_id=${msg.session_id ?? 'none'}`
+            );
+            throw new Error(`Agent execution ended with: ${msg.subtype}`);
+          } else {
+            logger.warn(
+              `[execute] Feature ${featureId} received unhandled result subtype: ${msg.subtype}`
+            );
+          }
+        }
       }
     } finally {
       clearInterval(streamHeartbeat);
@@ -385,6 +411,9 @@ export class AgentExecutor {
         taskCompleteDetected = false;
 
       for await (const msg of taskStream) {
+        if (msg.session_id && msg.session_id !== options.sdkSessionId) {
+          options.sdkSessionId = msg.session_id;
+        }
         if (msg.type === 'assistant' && msg.message?.content) {
           for (const b of msg.message.content) {
             if (b.type === 'text') {
@@ -438,16 +467,28 @@ export class AgentExecutor {
               });
           }
         } else if (msg.type === 'error') {
-          // Clean the error: strip ANSI codes and redundant "Error: " prefix
-          const cleanedError =
-            (msg.error || `Error during task ${task.id}`)
-              .replace(/\x1b\[[0-9;]*m/g, '')
-              .replace(/^Error:\s*/i, '')
-              .trim() || `Error during task ${task.id}`;
-          throw new Error(cleanedError);
-        } else if (msg.type === 'result' && msg.subtype === 'success') {
-          taskOutput += msg.result || '';
-          responseText += msg.result || '';
+          const fallback = `Error during task ${task.id}`;
+          const sanitized = AgentExecutor.sanitizeProviderError(msg.error || fallback);
+          logger.error(
+            `[executeTasksLoop] Feature ${featureId} task ${task.id} received error from provider. ` +
+              `raw="${msg.error}", sanitized="${sanitized}", session_id=${msg.session_id ?? 'none'}`
+          );
+          throw new Error(sanitized);
+        } else if (msg.type === 'result') {
+          if (msg.subtype === 'success') {
+            taskOutput += msg.result || '';
+            responseText += msg.result || '';
+          } else if (msg.subtype?.startsWith('error')) {
+            logger.error(
+              `[executeTasksLoop] Feature ${featureId} task ${task.id} ended with error subtype: ${msg.subtype}. ` +
+                `session_id=${msg.session_id ?? 'none'}`
+            );
+            throw new Error(`Agent execution ended with: ${msg.subtype}`);
+          } else {
+            logger.warn(
+              `[executeTasksLoop] Feature ${featureId} task ${task.id} received unhandled result subtype: ${msg.subtype}`
+            );
+          }
         }
       }
       if (!taskCompleteDetected)
@@ -599,6 +640,9 @@ export class AgentExecutor {
           for await (const msg of provider.executeQuery(
             this.buildExecOpts(options, revPrompt, sdkOptions?.maxTurns ?? DEFAULT_MAX_TURNS)
           )) {
+            if (msg.session_id && msg.session_id !== options.sdkSessionId) {
+              options.sdkSessionId = msg.session_id;
+            }
             if (msg.type === 'assistant' && msg.message?.content)
               for (const b of msg.message.content)
                 if (b.type === 'text') {
@@ -692,12 +736,14 @@ export class AgentExecutor {
       allowedTools: o.sdkOptions?.allowedTools as string[] | undefined,
       abortController: o.abortController,
       thinkingLevel: o.thinkingLevel,
+      reasoningEffort: o.reasoningEffort,
       mcpServers:
         o.mcpServers && Object.keys(o.mcpServers).length > 0
           ? (o.mcpServers as Record<string, { command: string }>)
           : undefined,
       credentials: o.credentials,
       claudeCompatibleProvider: o.claudeCompatibleProvider,
+      sdkSessionId: o.sdkSessionId,
     };
   }
 
@@ -717,6 +763,9 @@ export class AgentExecutor {
     for await (const msg of provider.executeQuery(
       this.buildExecOpts(options, contPrompt, options.sdkOptions?.maxTurns ?? DEFAULT_MAX_TURNS)
     )) {
+      if (msg.session_id && msg.session_id !== options.sdkSessionId) {
+        options.sdkSessionId = msg.session_id;
+      }
       if (msg.type === 'assistant' && msg.message?.content)
         for (const b of msg.message.content) {
           if (b.type === 'text') {

apps/server/src/services/agent-service.ts

@@ -21,6 +21,7 @@ import { createChatOptions, validateWorkingDirectory } from '../lib/sdk-options.
 import type { SettingsService } from './settings-service.js';
 import {
   getAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting,
   filterClaudeMdFromContext,
   getMCPServersFromSettings,
   getPromptCustomization,
@@ -329,12 +330,6 @@ export class AgentService {
       timestamp: new Date().toISOString(),
     };
 
-    // Build conversation history from existing messages BEFORE adding current message
-    const conversationHistory = session.messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content,
-    }));
-
     session.messages.push(userMessage);
     session.isRunning = true;
     session.abortController = new AbortController();
@@ -363,6 +358,22 @@ export class AgentService {
         '[AgentService]'
       );
 
+      // Load useClaudeCodeSystemPrompt setting (project setting takes precedence over global)
+      // Wrap in try/catch so transient settingsService errors don't abort message processing
+      let useClaudeCodeSystemPrompt = true;
+      try {
+        useClaudeCodeSystemPrompt = await getUseClaudeCodeSystemPromptSetting(
+          effectiveWorkDir,
+          this.settingsService,
+          '[AgentService]'
+        );
+      } catch (err) {
+        this.logger.error(
+          '[AgentService] getUseClaudeCodeSystemPromptSetting failed, defaulting to true',
+          err
+        );
+      }
+
       // Load MCP servers from settings (global setting only)
       const mcpServers = await getMCPServersFromSettings(this.settingsService, '[AgentService]');
 
@@ -406,6 +417,7 @@ export class AgentService {
         }
       }
 
+      let combinedSystemPrompt: string | undefined;
       // Load project context files (CLAUDE.md, CODE_QUALITY.md, etc.) and memory files
       // Use the user's message as task context for smart memory selection
       const contextResult = await loadContextFiles({
@@ -423,7 +435,7 @@ export class AgentService {
 
       // Build combined system prompt with base prompt and context files
       const baseSystemPrompt = await this.getSystemPrompt();
-      const combinedSystemPrompt = contextFilesPrompt
+      combinedSystemPrompt = contextFilesPrompt
         ? `${contextFilesPrompt}\n\n${baseSystemPrompt}`
         : baseSystemPrompt;
 
@@ -448,6 +460,7 @@ export class AgentService {
         systemPrompt: combinedSystemPrompt,
         abortController: session.abortController!,
         autoLoadClaudeMd,
+        useClaudeCodeSystemPrompt,
         thinkingLevel: effectiveThinkingLevel, // Pass thinking level for Claude models
         maxTurns: userMaxTurns, // User-configured max turns from settings
         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
@@ -474,7 +487,19 @@ export class AgentService {
         Object.keys(customSubagents).length > 0;
 
       // Base tools that match the provider's default set
-      const baseTools = ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch'];
+      const baseTools = [
+        'Read',
+        'Write',
+        'Edit',
+        'MultiEdit',
+        'Glob',
+        'Grep',
+        'LS',
+        'Bash',
+        'WebSearch',
+        'WebFetch',
+        'TodoWrite',
+      ];
 
       if (allowedTools) {
         allowedTools = [...allowedTools]; // Create a copy to avoid mutating SDK options
@@ -513,6 +538,14 @@ export class AgentService {
         : stripProviderPrefix(effectiveModel);
 
       // Build options for provider
+      const conversationHistory = session.messages
+        .slice(0, -1)
+        .map((msg) => ({
+          role: msg.role,
+          content: msg.content,
+        }))
+        .filter((msg) => msg.content.trim().length > 0);
+
       const options: ExecuteOptions = {
         prompt: '', // Will be set below based on images
         model: bareModel, // Bare model ID (e.g., "gpt-5.1-codex-max", "composer-1")
@@ -522,7 +555,8 @@ export class AgentService {
         maxTurns: maxTurns,
         allowedTools: allowedTools,
         abortController: session.abortController!,
-        conversationHistory: conversationHistory.length > 0 ? conversationHistory : undefined,
+        conversationHistory:
+          conversationHistory && conversationHistory.length > 0 ? conversationHistory : undefined,
         settingSources: settingSources.length > 0 ? settingSources : undefined,
         sdkSessionId: session.sdkSessionId, // Pass SDK session ID for resuming
         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined, // Pass MCP servers configuration
@@ -550,6 +584,7 @@ export class AgentService {
       let currentAssistantMessage: Message | null = null;
       let responseText = '';
       const toolUses: Array<{ name: string; input: unknown }> = [];
+      const toolNamesById = new Map<string, string>();
 
       for await (const msg of stream) {
         // Capture SDK session ID from any message and persist it.
@@ -594,11 +629,50 @@ export class AgentService {
                   input: block.input,
                 };
                 toolUses.push(toolUse);
+                if (block.tool_use_id) {
+                  toolNamesById.set(block.tool_use_id, toolUse.name);
+                }
 
                 this.emitAgentEvent(sessionId, {
                   type: 'tool_use',
                   tool: toolUse,
                 });
+              } else if (block.type === 'tool_result') {
+                const toolUseId = block.tool_use_id;
+                const toolName = toolUseId ? toolNamesById.get(toolUseId) : undefined;
+
+                // Normalize block.content to a string for the emitted event
+                const rawContent: unknown = block.content;
+                let contentString: string;
+                if (typeof rawContent === 'string') {
+                  contentString = rawContent;
+                } else if (Array.isArray(rawContent)) {
+                  // Extract text from content blocks (TextBlock, ImageBlock, etc.)
+                  contentString = rawContent
+                    .map((part: { text?: string; type?: string }) => {
+                      if (typeof part === 'string') return part;
+                      if (part.text) return part.text;
+                      // For non-text blocks (e.g., images), represent as type indicator
+                      if (part.type) return `[${part.type}]`;
+                      return JSON.stringify(part);
+                    })
+                    .join('\n');
+                } else if (rawContent !== undefined && rawContent !== null) {
+                  contentString = JSON.stringify(rawContent);
+                } else {
+                  contentString = '';
+                }
+
+                this.emitAgentEvent(sessionId, {
+                  type: 'tool_result',
+                  tool: {
+                    name: toolName || 'unknown',
+                    input: {
+                      toolUseId,
+                      content: contentString,
+                    },
+                  },
+                });
               }
             }
           }

apps/server/src/services/auto-mode/facade.ts

@@ -14,7 +14,7 @@
 import path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import type { Feature, PlanningMode, ThinkingLevel } from '@automaker/types';
+import type { Feature, PlanningMode, ThinkingLevel, ReasoningEffort } from '@automaker/types';
 import { DEFAULT_MAX_CONCURRENCY, DEFAULT_MODELS, stripProviderPrefix } from '@automaker/types';
 import { resolveModelString } from '@automaker/model-resolver';
 import { createLogger, loadContextFiles, classifyError } from '@automaker/utils';
@@ -213,7 +213,9 @@ export class AutoModeServiceFacade {
           previousContent?: string;
           systemPrompt?: string;
           autoLoadClaudeMd?: boolean;
+          useClaudeCodeSystemPrompt?: boolean;
           thinkingLevel?: ThinkingLevel;
+          reasoningEffort?: ReasoningEffort;
           branchName?: string | null;
           [key: string]: unknown;
         }
@@ -244,6 +246,7 @@ export class AutoModeServiceFacade {
         // internal defaults which may be much lower than intended (e.g., Codex CLI's
         // default turn limit can cause feature runs to stop prematurely).
         const autoLoadClaudeMd = opts?.autoLoadClaudeMd ?? false;
+        const useClaudeCodeSystemPrompt = opts?.useClaudeCodeSystemPrompt ?? true;
         let mcpServers: Record<string, unknown> | undefined;
         try {
           if (settingsService) {
@@ -265,6 +268,7 @@ export class AutoModeServiceFacade {
           systemPrompt: opts?.systemPrompt,
           abortController,
           autoLoadClaudeMd,
+          useClaudeCodeSystemPrompt,
           thinkingLevel: opts?.thinkingLevel,
           maxTurns: userMaxTurns,
           mcpServers: mcpServers as
@@ -292,7 +296,9 @@ export class AutoModeServiceFacade {
             previousContent: opts?.previousContent as string | undefined,
             systemPrompt: opts?.systemPrompt as string | undefined,
             autoLoadClaudeMd: opts?.autoLoadClaudeMd as boolean | undefined,
+            useClaudeCodeSystemPrompt,
             thinkingLevel: opts?.thinkingLevel as ThinkingLevel | undefined,
+            reasoningEffort: opts?.reasoningEffort as ReasoningEffort | undefined,
             branchName: opts?.branchName as string | null | undefined,
             provider,
             effectiveBareModel,
@@ -761,6 +767,7 @@ export class AutoModeServiceFacade {
         featureId,
         featureName: feature?.title,
         branchName: feature?.branchName ?? null,
+        executionMode: 'auto',
         passes: allPassed,
         message: allPassed
           ? 'All verification checks passed'
@@ -823,6 +830,7 @@ export class AutoModeServiceFacade {
           featureId,
           featureName: feature?.title,
           branchName: feature?.branchName ?? null,
+          executionMode: 'auto',
           passes: true,
           message: `Changes committed: ${hash.trim().substring(0, 8)}`,
           projectPath: this.projectPath,
@@ -910,7 +918,7 @@ export class AutoModeServiceFacade {
           if (feature) {
             title = feature.title;
             description = feature.description;
-            branchName = feature.branchName;
+            branchName = feature.branchName ?? undefined;
           }
         } catch {
           // Silently ignore
@@ -1140,10 +1148,31 @@ export class AutoModeServiceFacade {
   // ===========================================================================
 
   /**
-   * Save execution state for recovery
+   * Save execution state for recovery.
+   *
+   * Uses the active auto-loop config for each worktree so that the persisted
+   * state reflects the real branch and maxConcurrency values rather than the
+   * hard-coded fallbacks (null / DEFAULT_MAX_CONCURRENCY).
    */
   private async saveExecutionState(): Promise<void> {
-    return this.saveExecutionStateForProject(null, DEFAULT_MAX_CONCURRENCY);
+    const projectWorktrees = this.autoLoopCoordinator
+      .getActiveWorktrees()
+      .filter((w) => w.projectPath === this.projectPath);
+
+    if (projectWorktrees.length === 0) {
+      // No active auto loops — save with defaults as a best-effort fallback.
+      return this.saveExecutionStateForProject(null, DEFAULT_MAX_CONCURRENCY);
+    }
+
+    // Save state for every active worktree using its real config values.
+    for (const { branchName } of projectWorktrees) {
+      const config = this.autoLoopCoordinator.getAutoLoopConfigForProject(
+        this.projectPath,
+        branchName
+      );
+      const maxConcurrency = config?.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
+      await this.saveExecutionStateForProject(branchName, maxConcurrency);
+    }
   }
 
   /**

apps/server/src/services/auto-mode/global-service.ts

@@ -159,7 +159,7 @@ export class GlobalAutoModeService {
           if (feature) {
             title = feature.title;
             description = feature.description;
-            branchName = feature.branchName;
+            branchName = feature.branchName ?? undefined;
           }
         } catch {
           // Silently ignore

apps/server/src/services/event-hook-service.ts

@@ -60,10 +60,13 @@ interface AutoModeEventPayload {
   featureId?: string;
   featureName?: string;
   passes?: boolean;
+  executionMode?: 'auto' | 'manual';
   message?: string;
   error?: string;
   errorType?: string;
   projectPath?: string;
+  /** Status field present when type === 'feature_status_changed' */
+  status?: string;
 }
 
 /**
@@ -75,6 +78,40 @@ interface FeatureCreatedPayload {
   projectPath: string;
 }
 
+/**
+ * Feature status changed event payload structure
+ */
+interface FeatureStatusChangedPayload {
+  featureId: string;
+  projectPath: string;
+  status: string;
+}
+
+/**
+ * Type guard to safely narrow AutoModeEventPayload to FeatureStatusChangedPayload
+ */
+function isFeatureStatusChangedPayload(
+  payload: AutoModeEventPayload
+): payload is AutoModeEventPayload & FeatureStatusChangedPayload {
+  return (
+    typeof payload.featureId === 'string' &&
+    typeof payload.projectPath === 'string' &&
+    typeof payload.status === 'string'
+  );
+}
+
+/**
+ * Feature completed event payload structure
+ */
+interface FeatureCompletedPayload {
+  featureId: string;
+  featureName?: string;
+  projectPath: string;
+  passes?: boolean;
+  message?: string;
+  executionMode?: 'auto' | 'manual';
+}
+
 /**
  * Event Hook Service
  *
@@ -82,12 +119,30 @@ interface FeatureCreatedPayload {
  * Also stores events to history for debugging and replay.
  */
 export class EventHookService {
+  /** Feature status that indicates agent work is done and awaiting human review (tests skipped) */
+  private static readonly STATUS_WAITING_APPROVAL = 'waiting_approval';
+  /** Feature status that indicates agent work passed automated verification */
+  private static readonly STATUS_VERIFIED = 'verified';
+
   private emitter: EventEmitter | null = null;
   private settingsService: SettingsService | null = null;
   private eventHistoryService: EventHistoryService | null = null;
   private featureLoader: FeatureLoader | null = null;
   private unsubscribe: (() => void) | null = null;
 
+  /**
+   * Track feature IDs that have already had hooks fired via auto_mode_feature_complete
+   * to prevent double-firing when feature_status_changed also fires for the same feature.
+   * Entries are automatically cleaned up after 30 seconds.
+   */
+  private recentlyHandledFeatures = new Set<string>();
+
+  /**
+   * Timer IDs for pending cleanup of recentlyHandledFeatures entries,
+   * keyed by featureId. Stored so they can be cancelled in destroy().
+   */
+  private recentlyHandledTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
   /**
    * Initialize the service with event emitter, settings service, event history service, and feature loader
    */
@@ -108,6 +163,8 @@ export class EventHookService {
         this.handleAutoModeEvent(payload as AutoModeEventPayload);
       } else if (type === 'feature:created') {
         this.handleFeatureCreatedEvent(payload as FeatureCreatedPayload);
+      } else if (type === 'feature:completed') {
+        this.handleFeatureCompletedEvent(payload as FeatureCompletedPayload);
       }
     });
 
@@ -122,6 +179,12 @@ export class EventHookService {
       this.unsubscribe();
       this.unsubscribe = null;
     }
+    // Cancel all pending cleanup timers to avoid cross-session mutations
+    for (const timerId of this.recentlyHandledTimers.values()) {
+      clearTimeout(timerId);
+    }
+    this.recentlyHandledTimers.clear();
+    this.recentlyHandledFeatures.clear();
     this.emitter = null;
     this.settingsService = null;
     this.eventHistoryService = null;
@@ -139,15 +202,31 @@ export class EventHookService {
 
     switch (payload.type) {
       case 'auto_mode_feature_complete':
+        // Only map explicit auto-mode completion events.
+        // Manual feature completions are emitted as feature:completed.
+        if (payload.executionMode !== 'auto') return;
         trigger = payload.passes ? 'feature_success' : 'feature_error';
+        // Track this feature so feature_status_changed doesn't double-fire hooks
+        if (payload.featureId) {
+          this.markFeatureHandled(payload.featureId);
+        }
         break;
       case 'auto_mode_error':
         // Feature-level error (has featureId) vs auto-mode level error
         trigger = payload.featureId ? 'feature_error' : 'auto_mode_error';
+        // Track this feature so feature_status_changed doesn't double-fire hooks
+        if (payload.featureId) {
+          this.markFeatureHandled(payload.featureId);
+        }
         break;
       case 'auto_mode_idle':
         trigger = 'auto_mode_complete';
         break;
+      case 'feature_status_changed':
+        if (isFeatureStatusChangedPayload(payload)) {
+          this.handleFeatureStatusChanged(payload);
+        }
+        return;
       default:
         // Other event types don't trigger hooks
         return;
@@ -187,6 +266,46 @@ export class EventHookService {
     await this.executeHooksForTrigger(trigger, context, { passes: payload.passes });
   }
 
+  /**
+   * Handle feature:completed events and trigger matching hooks
+   */
+  private async handleFeatureCompletedEvent(payload: FeatureCompletedPayload): Promise<void> {
+    if (!payload.featureId || !payload.projectPath) return;
+
+    // Mark as handled to prevent duplicate firing if feature_status_changed also fires
+    this.markFeatureHandled(payload.featureId);
+
+    const passes = payload.passes ?? true;
+    const trigger: EventHookTrigger = passes ? 'feature_success' : 'feature_error';
+
+    // Load feature name if we have featureId but no featureName
+    let featureName: string | undefined = undefined;
+    if (payload.projectPath && this.featureLoader) {
+      try {
+        const feature = await this.featureLoader.get(payload.projectPath, payload.featureId);
+        if (feature?.title) {
+          featureName = feature.title;
+        }
+      } catch (error) {
+        logger.warn(`Failed to load feature ${payload.featureId} for event hook:`, error);
+      }
+    }
+
+    const isErrorTrigger = trigger === 'feature_error';
+    const context: HookContext = {
+      featureId: payload.featureId,
+      featureName: featureName || payload.featureName,
+      projectPath: payload.projectPath,
+      projectName: this.extractProjectName(payload.projectPath),
+      error: isErrorTrigger ? payload.message : undefined,
+      errorType: undefined,
+      timestamp: new Date().toISOString(),
+      eventType: trigger,
+    };
+
+    await this.executeHooksForTrigger(trigger, context, { passes });
+  }
+
   /**
    * Handle feature:created events and trigger matching hooks
    */
@@ -203,6 +322,74 @@ export class EventHookService {
     await this.executeHooksForTrigger('feature_created', context);
   }
 
+  /**
+   * Handle feature_status_changed events for non-auto-mode feature completion.
+   *
+   * Auto-mode features already emit auto_mode_feature_complete which triggers hooks.
+   * This handler catches manual (non-auto-mode) feature completions by detecting
+   * status transitions to completion states (verified, waiting_approval).
+   */
+  private async handleFeatureStatusChanged(payload: FeatureStatusChangedPayload): Promise<void> {
+    // Skip if this feature was already handled via auto_mode_feature_complete
+    if (this.recentlyHandledFeatures.has(payload.featureId)) {
+      return;
+    }
+
+    let trigger: EventHookTrigger | null = null;
+
+    if (
+      payload.status === EventHookService.STATUS_VERIFIED ||
+      payload.status === EventHookService.STATUS_WAITING_APPROVAL
+    ) {
+      trigger = 'feature_success';
+    } else {
+      // Only completion statuses trigger hooks from status changes
+      return;
+    }
+
+    // Load feature name
+    let featureName: string | undefined = undefined;
+    if (this.featureLoader) {
+      try {
+        const feature = await this.featureLoader.get(payload.projectPath, payload.featureId);
+        if (feature?.title) {
+          featureName = feature.title;
+        }
+      } catch (error) {
+        logger.warn(`Failed to load feature ${payload.featureId} for status change hook:`, error);
+      }
+    }
+
+    const context: HookContext = {
+      featureId: payload.featureId,
+      featureName,
+      projectPath: payload.projectPath,
+      projectName: this.extractProjectName(payload.projectPath),
+      timestamp: new Date().toISOString(),
+      eventType: trigger,
+    };
+
+    await this.executeHooksForTrigger(trigger, context, { passes: true });
+  }
+
+  /**
+   * Mark a feature as recently handled to prevent double-firing hooks.
+   * Entries are cleaned up after 30 seconds.
+   */
+  private markFeatureHandled(featureId: string): void {
+    // Cancel any existing timer for this feature before setting a new one
+    const existing = this.recentlyHandledTimers.get(featureId);
+    if (existing !== undefined) {
+      clearTimeout(existing);
+    }
+    this.recentlyHandledFeatures.add(featureId);
+    const timerId = setTimeout(() => {
+      this.recentlyHandledFeatures.delete(featureId);
+      this.recentlyHandledTimers.delete(featureId);
+    }, 30000);
+    this.recentlyHandledTimers.set(featureId, timerId);
+  }
+
   /**
    * Execute all enabled hooks matching the given trigger and store event to history
    */

apps/server/src/services/execution-service.ts

@@ -12,6 +12,7 @@ import * as secureFs from '../lib/secure-fs.js';
 import {
   getPromptCustomization,
   getAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting,
   filterClaudeMdFromContext,
 } from '../lib/settings-helpers.js';
 import { validateWorkingDirectory } from '../lib/sdk-options.js';
@@ -59,6 +60,12 @@ import type {
 
 const logger = createLogger('ExecutionService');
 
+/** Marker written by agent-executor for each tool invocation. */
+const TOOL_USE_MARKER = '🔧 Tool:';
+
+/** Minimum trimmed output length to consider agent work meaningful. */
+const MIN_MEANINGFUL_OUTPUT_LENGTH = 200;
+
 export class ExecutionService {
   constructor(
     private eventBus: TypedEventBus,
@@ -241,6 +248,11 @@ ${feature.spec}
         this.settingsService,
         '[ExecutionService]'
       );
+      const useClaudeCodeSystemPrompt = await getUseClaudeCodeSystemPromptSetting(
+        projectPath,
+        this.settingsService,
+        '[ExecutionService]'
+      );
       const prompts = await getPromptCustomization(this.settingsService, '[ExecutionService]');
       let prompt: string;
       const contextResult = await this.loadContextFilesFn({
@@ -289,7 +301,9 @@ ${feature.spec}
           requirePlanApproval: feature.requirePlanApproval,
           systemPrompt: combinedSystemPrompt || undefined,
           autoLoadClaudeMd,
+          useClaudeCodeSystemPrompt,
           thinkingLevel: feature.thinkingLevel,
+          reasoningEffort: feature.reasoningEffort,
           branchName: feature.branchName ?? null,
         }
       );
@@ -353,7 +367,9 @@ Please continue from where you left off and complete all remaining tasks. Use th
             requirePlanApproval: false,
             systemPrompt: combinedSystemPrompt || undefined,
             autoLoadClaudeMd,
+            useClaudeCodeSystemPrompt,
             thinkingLevel: feature.thinkingLevel,
+            reasoningEffort: feature.reasoningEffort,
             branchName: feature.branchName ?? null,
           }
         );
@@ -388,6 +404,7 @@ Please continue from where you left off and complete all remaining tasks. Use th
           branchName: feature.branchName ?? null,
           abortController,
           autoLoadClaudeMd,
+          useClaudeCodeSystemPrompt,
           testAttempts: 0,
           maxTestAttempts: 5,
         });
@@ -398,7 +415,41 @@ Please continue from where you left off and complete all remaining tasks. Use th
         }
       }
 
-      const finalStatus = feature.skipTests ? 'waiting_approval' : 'verified';
+      // Read agent output before determining final status.
+      // CLI-based providers (Cursor, Codex, etc.) may exit quickly without doing
+      // meaningful work. Check output to avoid prematurely marking as 'verified'.
+      const outputPath = path.join(getFeatureDir(projectPath, featureId), 'agent-output.md');
+      let agentOutput = '';
+      try {
+        agentOutput = (await secureFs.readFile(outputPath, 'utf-8')) as string;
+      } catch {
+        /* */
+      }
+
+      // Determine if the agent did meaningful work by checking for tool usage
+      // indicators in the output. The agent executor writes "🔧 Tool:" markers
+      // each time a tool is invoked. No tool usage suggests the CLI exited
+      // without performing implementation work.
+      const hasToolUsage = agentOutput.includes(TOOL_USE_MARKER);
+      const isOutputTooShort = agentOutput.trim().length < MIN_MEANINGFUL_OUTPUT_LENGTH;
+      const agentDidWork = hasToolUsage && !isOutputTooShort;
+
+      let finalStatus: 'verified' | 'waiting_approval';
+      if (feature.skipTests) {
+        finalStatus = 'waiting_approval';
+      } else if (!agentDidWork) {
+        // Agent didn't produce meaningful output (e.g., CLI exited quickly).
+        // Route to waiting_approval so the user can review and re-run.
+        finalStatus = 'waiting_approval';
+        logger.warn(
+          `[executeFeature] Feature ${featureId}: agent produced insufficient output ` +
+            `(${agentOutput.trim().length}/${MIN_MEANINGFUL_OUTPUT_LENGTH} chars, toolUsage=${hasToolUsage}). ` +
+            `Setting status to waiting_approval instead of verified.`
+        );
+      } else {
+        finalStatus = 'verified';
+      }
+
       await this.updateFeatureStatusFn(projectPath, featureId, finalStatus);
       this.recordSuccessFn();
 
@@ -410,13 +461,6 @@ Please continue from where you left off and complete all remaining tasks. Use th
       const hasIncompleteTasks = totalTasks > 0 && completedTasks < totalTasks;
 
       try {
-        const outputPath = path.join(getFeatureDir(projectPath, featureId), 'agent-output.md');
-        let agentOutput = '';
-        try {
-          agentOutput = (await secureFs.readFile(outputPath, 'utf-8')) as string;
-        } catch {
-          /* */
-        }
         if (agentOutput) {
           const summary = extractSummary(agentOutput);
           if (summary) await this.saveFeatureSummaryFn(projectPath, featureId, summary);
@@ -446,6 +490,7 @@ Please continue from where you left off and complete all remaining tasks. Use th
           featureId,
           featureName: feature.title,
           branchName: feature.branchName ?? null,
+          executionMode: 'auto',
           passes: true,
           message: completionMessage,
           projectPath,
@@ -462,6 +507,7 @@ Please continue from where you left off and complete all remaining tasks. Use th
             featureId,
             featureName: feature?.title,
             branchName: feature?.branchName ?? null,
+            executionMode: 'auto',
             passes: false,
             message: 'Feature stopped by user',
             projectPath,
@@ -491,6 +537,22 @@ Please continue from where you left off and complete all remaining tasks. Use th
   async stopFeature(featureId: string): Promise<boolean> {
     const running = this.concurrencyManager.getRunningFeature(featureId);
     if (!running) return false;
+    const { projectPath } = running;
+
+    // Immediately update feature status to 'interrupted' so the UI reflects
+    // the stop right away. CLI-based providers can take seconds to terminate
+    // their subprocess after the abort signal fires, leaving the feature stuck
+    // in 'in_progress' on the Kanban board until the executeFeature catch block
+    // eventually runs. By persisting and emitting the status change here, the
+    // board updates immediately regardless of how long the subprocess takes to stop.
+    try {
+      await this.updateFeatureStatusFn(projectPath, featureId, 'interrupted');
+    } catch (err) {
+      // Non-fatal: the abort still proceeds and executeFeature's catch block
+      // will attempt the same update once the subprocess terminates.
+      logger.warn(`stopFeature: failed to immediately update status for ${featureId}:`, err);
+    }
+
     running.abortController.abort();
     this.releaseRunningFeature(featureId, { force: true });
     return true;

apps/server/src/services/execution-types.ts

@@ -5,7 +5,7 @@
  * allowing the service to delegate to other services without circular dependencies.
  */
 
-import type { Feature, PlanningMode, ThinkingLevel } from '@automaker/types';
+import type { Feature, PlanningMode, ThinkingLevel, ReasoningEffort } from '@automaker/types';
 import type { loadContextFiles } from '@automaker/utils';
 import type { PipelineContext } from './pipeline-orchestrator.js';
 
@@ -31,7 +31,9 @@ export type RunAgentFn = (
     previousContent?: string;
     systemPrompt?: string;
     autoLoadClaudeMd?: boolean;
+    useClaudeCodeSystemPrompt?: boolean;
     thinkingLevel?: ThinkingLevel;
+    reasoningEffort?: ReasoningEffort;
     branchName?: string | null;
   }
 ) => Promise<void>;

apps/server/src/services/pipeline-orchestrator.ts

@@ -16,6 +16,7 @@ import * as secureFs from '../lib/secure-fs.js';
 import {
   getPromptCustomization,
   getAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting,
   filterClaudeMdFromContext,
 } from '../lib/settings-helpers.js';
 import { validateWorkingDirectory } from '../lib/sdk-options.js';
@@ -70,8 +71,16 @@ export class PipelineOrchestrator {
   ) {}
 
   async executePipeline(ctx: PipelineContext): Promise<void> {
-    const { projectPath, featureId, feature, steps, workDir, abortController, autoLoadClaudeMd } =
-      ctx;
+    const {
+      projectPath,
+      featureId,
+      feature,
+      steps,
+      workDir,
+      abortController,
+      autoLoadClaudeMd,
+      useClaudeCodeSystemPrompt,
+    } = ctx;
     const prompts = await getPromptCustomization(this.settingsService, '[AutoMode]');
     const contextResult = await this.loadContextFilesFn({
       projectPath,
@@ -121,7 +130,9 @@ export class PipelineOrchestrator {
           previousContent: previousContext,
           systemPrompt: contextFilesPrompt || undefined,
           autoLoadClaudeMd,
+          useClaudeCodeSystemPrompt,
           thinkingLevel: feature.thinkingLevel,
+          reasoningEffort: feature.reasoningEffort,
         }
       );
       try {
@@ -232,6 +243,7 @@ export class PipelineOrchestrator {
           featureId,
           featureName: feature.title,
           branchName: feature.branchName ?? null,
+          executionMode: 'auto',
           passes: true,
           message: 'Pipeline step no longer exists',
           projectPath,
@@ -281,6 +293,7 @@ export class PipelineOrchestrator {
             featureId,
             featureName: feature.title,
             branchName: feature.branchName ?? null,
+            executionMode: 'auto',
             passes: true,
             message: 'Pipeline completed (remaining steps excluded)',
             projectPath,
@@ -306,6 +319,7 @@ export class PipelineOrchestrator {
           featureId,
           featureName: feature.title,
           branchName: feature.branchName ?? null,
+          executionMode: 'auto',
           passes: true,
           message: 'Pipeline completed (all steps excluded)',
           projectPath,
@@ -354,6 +368,11 @@ export class PipelineOrchestrator {
         this.settingsService,
         '[AutoMode]'
       );
+      const useClaudeCodeSystemPrompt = await getUseClaudeCodeSystemPromptSetting(
+        projectPath,
+        this.settingsService,
+        '[AutoMode]'
+      );
       const context: PipelineContext = {
         projectPath,
         featureId,
@@ -364,6 +383,7 @@ export class PipelineOrchestrator {
         branchName: branchName ?? null,
         abortController,
         autoLoadClaudeMd,
+        useClaudeCodeSystemPrompt,
         testAttempts: 0,
         maxTestAttempts: 5,
       };
@@ -384,6 +404,7 @@ export class PipelineOrchestrator {
           featureId,
           featureName: feature.title,
           branchName: feature.branchName ?? null,
+          executionMode: 'auto',
           passes: true,
           message: 'Pipeline resumed successfully',
           projectPath,
@@ -397,6 +418,7 @@ export class PipelineOrchestrator {
             featureId,
             featureName: feature.title,
             branchName: feature.branchName ?? null,
+            executionMode: 'auto',
             passes: false,
             message: 'Pipeline stopped by user',
             projectPath,
@@ -462,7 +484,14 @@ export class PipelineOrchestrator {
           projectPath,
           undefined,
           undefined,
-          { projectPath, planningMode: 'skip', requirePlanApproval: false }
+          {
+            projectPath,
+            planningMode: 'skip',
+            requirePlanApproval: false,
+            useClaudeCodeSystemPrompt: context.useClaudeCodeSystemPrompt,
+            autoLoadClaudeMd: context.autoLoadClaudeMd,
+            reasoningEffort: context.feature.reasoningEffort,
+          }
         );
       }
     }
@@ -556,6 +585,7 @@ export class PipelineOrchestrator {
           featureId,
           featureName: feature.title,
           branchName,
+          executionMode: 'auto',
           passes: true,
           message: 'Pipeline completed and merged',
           projectPath,
@@ -596,7 +626,7 @@ export class PipelineOrchestrator {
       }
       // Only capture assertion details when they appear in failure context
       // or match explicit assertion error / expect patterns
-      if (trimmed.includes('AssertionError') || trimmed.includes('AssertionError')) {
+      if (trimmed.includes('AssertionError')) {
         failedTests.push(trimmed);
       } else if (
         inFailureContext &&

apps/server/src/services/pipeline-types.ts

@@ -14,6 +14,7 @@ export interface PipelineContext {
   branchName: string | null;
   abortController: AbortController;
   autoLoadClaudeMd: boolean;
+  useClaudeCodeSystemPrompt?: boolean;
   testAttempts: number;
   maxTestAttempts: number;
 }

apps/server/src/services/push-service.ts

@@ -0,0 +1,258 @@
+/**
+ * PushService - Push git operations without HTTP
+ *
+ * Encapsulates the full git push workflow including:
+ * - Branch name and detached HEAD detection
+ * - Safe array-based command execution (no shell interpolation)
+ * - Divergent branch detection and auto-resolution via pull-then-retry
+ * - Structured result reporting
+ *
+ * Mirrors the pull-service.ts pattern for consistency.
+ */
+
+import { createLogger, getErrorMessage } from '@automaker/utils';
+import { execGitCommand } from '@automaker/git-utils';
+import { getCurrentBranch } from '../lib/git.js';
+import { performPull } from './pull-service.js';
+
+const logger = createLogger('PushService');
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface PushOptions {
+  /** Remote name to push to (defaults to 'origin') */
+  remote?: string;
+  /** Force push */
+  force?: boolean;
+  /** When true and push is rejected due to divergence, pull then retry push */
+  autoResolve?: boolean;
+}
+
+export interface PushResult {
+  success: boolean;
+  error?: string;
+  branch?: string;
+  pushed?: boolean;
+  /** Whether the push was initially rejected because the branches diverged */
+  diverged?: boolean;
+  /** Whether divergence was automatically resolved via pull-then-retry */
+  autoResolved?: boolean;
+  /** Whether the auto-resolve pull resulted in merge conflicts */
+  hasConflicts?: boolean;
+  /** Files with merge conflicts (only when hasConflicts is true) */
+  conflictFiles?: string[];
+  message?: string;
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Detect whether push error output indicates a diverged/non-fast-forward rejection.
+ */
+function isDivergenceError(errorOutput: string): boolean {
+  const lower = errorOutput.toLowerCase();
+  // Require specific divergence indicators rather than just 'rejected' alone,
+  // which could match pre-receive hook rejections or protected branch errors.
+  const hasNonFastForward = lower.includes('non-fast-forward');
+  const hasFetchFirst = lower.includes('fetch first');
+  const hasFailedToPush = lower.includes('failed to push some refs');
+  const hasRejected = lower.includes('rejected');
+  return hasNonFastForward || hasFetchFirst || (hasRejected && hasFailedToPush);
+}
+
+// ============================================================================
+// Main Service Function
+// ============================================================================
+
+/**
+ * Perform a git push on the given worktree.
+ *
+ * The workflow:
+ * 1. Get current branch name (detect detached HEAD)
+ * 2. Attempt `git push <remote> <branch>` with safe array args
+ * 3. If push fails with divergence and autoResolve is true:
+ *    a. Pull from the same remote (with stash support)
+ *    b. If pull succeeds without conflicts, retry push
+ * 4. If push fails with "no upstream" error, retry with --set-upstream
+ * 5. Return structured result
+ *
+ * @param worktreePath - Path to the git worktree
+ * @param options - Push options (remote, force, autoResolve)
+ * @returns PushResult with detailed status information
+ */
+export async function performPush(
+  worktreePath: string,
+  options?: PushOptions
+): Promise<PushResult> {
+  const targetRemote = options?.remote || 'origin';
+  const force = options?.force ?? false;
+  const autoResolve = options?.autoResolve ?? false;
+
+  // 1. Get current branch name
+  let branchName: string;
+  try {
+    branchName = await getCurrentBranch(worktreePath);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to get current branch: ${getErrorMessage(err)}`,
+    };
+  }
+
+  // 2. Check for detached HEAD state
+  if (branchName === 'HEAD') {
+    return {
+      success: false,
+      error: 'Cannot push in detached HEAD state. Please checkout a branch first.',
+    };
+  }
+
+  // 3. Build push args (no -u flag; upstream is set in the fallback path only when needed)
+  const pushArgs = ['push', targetRemote, branchName];
+  if (force) {
+    pushArgs.push('--force');
+  }
+
+  // 4. Attempt push
+  try {
+    await execGitCommand(pushArgs, worktreePath);
+
+    return {
+      success: true,
+      branch: branchName,
+      pushed: true,
+      message: `Successfully pushed ${branchName} to ${targetRemote}`,
+    };
+  } catch (pushError: unknown) {
+    const err = pushError as { stderr?: string; stdout?: string; message?: string };
+    const errorOutput = `${err.stderr || ''} ${err.stdout || ''} ${err.message || ''}`;
+
+    // 5. Check if the error is a divergence rejection
+    if (isDivergenceError(errorOutput)) {
+      if (!autoResolve) {
+        return {
+          success: false,
+          branch: branchName,
+          pushed: false,
+          diverged: true,
+          error: `Push rejected: remote has changes not present locally. Use sync or pull first, or enable auto-resolve.`,
+          message: `Push to ${targetRemote} was rejected because the remote branch has diverged.`,
+        };
+      }
+
+      // 6. Auto-resolve: pull then retry push
+      logger.info('Push rejected due to divergence, attempting auto-resolve via pull', {
+        worktreePath,
+        remote: targetRemote,
+        branch: branchName,
+      });
+
+      try {
+        const pullResult = await performPull(worktreePath, {
+          remote: targetRemote,
+          stashIfNeeded: true,
+        });
+
+        if (!pullResult.success) {
+          return {
+            success: false,
+            branch: branchName,
+            pushed: false,
+            diverged: true,
+            autoResolved: false,
+            error: `Auto-resolve failed during pull: ${pullResult.error}`,
+          };
+        }
+
+        if (pullResult.hasConflicts) {
+          return {
+            success: false,
+            branch: branchName,
+            pushed: false,
+            diverged: true,
+            autoResolved: false,
+            hasConflicts: true,
+            conflictFiles: pullResult.conflictFiles,
+            error:
+              'Auto-resolve pull resulted in merge conflicts. Resolve conflicts and push again.',
+          };
+        }
+
+        // 7. Retry push after successful pull
+        try {
+          await execGitCommand(pushArgs, worktreePath);
+
+          return {
+            success: true,
+            branch: branchName,
+            pushed: true,
+            diverged: true,
+            autoResolved: true,
+            message: `Push succeeded after auto-resolving divergence (pulled from ${targetRemote} first).`,
+          };
+        } catch (retryError: unknown) {
+          const retryErr = retryError as { stderr?: string; message?: string };
+          return {
+            success: false,
+            branch: branchName,
+            pushed: false,
+            diverged: true,
+            autoResolved: false,
+            error: `Push failed after auto-resolve pull: ${retryErr.stderr || retryErr.message || 'Unknown error'}`,
+          };
+        }
+      } catch (pullError) {
+        return {
+          success: false,
+          branch: branchName,
+          pushed: false,
+          diverged: true,
+          autoResolved: false,
+          error: `Auto-resolve pull failed: ${getErrorMessage(pullError)}`,
+        };
+      }
+    }
+
+    // 6b. Non-divergence error (e.g. no upstream configured) - retry with --set-upstream
+    const isNoUpstreamError =
+      errorOutput.toLowerCase().includes('no upstream') ||
+      errorOutput.toLowerCase().includes('has no upstream branch') ||
+      errorOutput.toLowerCase().includes('set-upstream');
+    if (isNoUpstreamError) {
+      try {
+        const setUpstreamArgs = ['push', '--set-upstream', targetRemote, branchName];
+        if (force) {
+          setUpstreamArgs.push('--force');
+        }
+        await execGitCommand(setUpstreamArgs, worktreePath);
+
+        return {
+          success: true,
+          branch: branchName,
+          pushed: true,
+          message: `Successfully pushed ${branchName} to ${targetRemote} (set upstream)`,
+        };
+      } catch (upstreamError: unknown) {
+        const upstreamErr = upstreamError as { stderr?: string; message?: string };
+        return {
+          success: false,
+          branch: branchName,
+          pushed: false,
+          error: upstreamErr.stderr || upstreamErr.message || getErrorMessage(pushError),
+        };
+      }
+    }
+
+    // 6c. Other push error - return as-is
+    return {
+      success: false,
+      branch: branchName,
+      pushed: false,
+      error: err.stderr || err.message || getErrorMessage(pushError),
+    };
+  }
+}

apps/server/src/services/settings-service.ts

@@ -31,6 +31,7 @@ import type {
   WorktreeInfo,
   PhaseModelConfig,
   PhaseModelEntry,
+  FeatureTemplate,
   ClaudeApiProfile,
   ClaudeCompatibleProvider,
   ProviderModel,
@@ -40,6 +41,7 @@ import {
   DEFAULT_CREDENTIALS,
   DEFAULT_PROJECT_SETTINGS,
   DEFAULT_PHASE_MODELS,
+  DEFAULT_FEATURE_TEMPLATES,
   SETTINGS_VERSION,
   CREDENTIALS_VERSION,
   PROJECT_SETTINGS_VERSION,
@@ -139,6 +141,11 @@ export class SettingsService {
     // Migrate model IDs to canonical format
     const migratedModelSettings = this.migrateModelSettings(settings);
 
+    // Merge built-in feature templates: ensure all built-in templates exist in user settings.
+    // User customizations (enabled/disabled state, order overrides) are preserved.
+    // New built-in templates added in code updates are injected for existing users.
+    const mergedFeatureTemplates = this.mergeBuiltInTemplates(settings.featureTemplates);
+
     // Apply any missing defaults (for backwards compatibility)
     let result: GlobalSettings = {
       ...DEFAULT_GLOBAL_SETTINGS,
@@ -149,6 +156,7 @@ export class SettingsService {
         ...settings.keyboardShortcuts,
       },
       phaseModels: migratedPhaseModels,
+      featureTemplates: mergedFeatureTemplates,
     };
 
     // Version-based migrations
@@ -250,6 +258,32 @@ export class SettingsService {
     return result;
   }
 
+  /**
+   * Merge built-in feature templates with user's stored templates.
+   *
+   * Ensures new built-in templates added in code updates are available to existing users
+   * without overwriting their customizations (e.g., enabled/disabled state, custom order).
+   * Built-in templates missing from stored settings are appended with their defaults.
+   *
+   * @param storedTemplates - Templates from user's settings file (may be undefined for new installs)
+   * @returns Merged template list with all built-in templates present
+   */
+  private mergeBuiltInTemplates(storedTemplates: FeatureTemplate[] | undefined): FeatureTemplate[] {
+    if (!storedTemplates) {
+      return DEFAULT_FEATURE_TEMPLATES;
+    }
+
+    const storedIds = new Set(storedTemplates.map((t) => t.id));
+    const missingBuiltIns = DEFAULT_FEATURE_TEMPLATES.filter((t) => !storedIds.has(t.id));
+
+    if (missingBuiltIns.length === 0) {
+      return storedTemplates;
+    }
+
+    // Append missing built-in templates after existing ones
+    return [...storedTemplates, ...missingBuiltIns];
+  }
+
   /**
    * Migrate legacy enhancementModel/validationModel fields to phaseModels structure
    *
@@ -573,6 +607,17 @@ export class SettingsService {
     ignoreEmptyArrayOverwrite('claudeApiProfiles');
     // Note: claudeCompatibleProviders intentionally NOT guarded - users should be able to delete all providers
 
+    // Check for explicit permission to clear eventHooks (escape hatch for intentional clearing)
+    const allowEmptyEventHooks =
+      (sanitizedUpdates as Record<string, unknown>).__allowEmptyEventHooks === true;
+    // Remove the flag so it doesn't get persisted
+    delete (sanitizedUpdates as Record<string, unknown>).__allowEmptyEventHooks;
+
+    // Only guard eventHooks if explicit permission wasn't granted
+    if (!allowEmptyEventHooks) {
+      ignoreEmptyArrayOverwrite('eventHooks');
+    }
+
     // Empty object overwrite guard
     const ignoreEmptyObjectOverwrite = <K extends keyof GlobalSettings>(key: K): void => {
       const nextVal = sanitizedUpdates[key] as unknown;

apps/server/src/services/sync-service.ts

@@ -0,0 +1,209 @@
+/**
+ * SyncService - Pull then push in a single operation
+ *
+ * Composes performPull() and performPush() to synchronize a branch
+ * with its remote. Always uses stashIfNeeded for the pull step.
+ * If push fails with divergence after pull, retries once.
+ *
+ * Follows the same pattern as pull-service.ts and push-service.ts.
+ */
+
+import { createLogger, getErrorMessage } from '@automaker/utils';
+import { performPull } from './pull-service.js';
+import { performPush } from './push-service.js';
+import type { PullResult } from './pull-service.js';
+import type { PushResult } from './push-service.js';
+
+const logger = createLogger('SyncService');
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface SyncOptions {
+  /** Remote name (defaults to 'origin') */
+  remote?: string;
+}
+
+export interface SyncResult {
+  success: boolean;
+  error?: string;
+  branch?: string;
+  /** Whether the pull step was performed */
+  pulled?: boolean;
+  /** Whether the push step was performed */
+  pushed?: boolean;
+  /** Pull resulted in conflicts */
+  hasConflicts?: boolean;
+  /** Files with merge conflicts */
+  conflictFiles?: string[];
+  /** Source of conflicts ('pull' | 'stash') */
+  conflictSource?: 'pull' | 'stash';
+  /** Whether the pull was a fast-forward */
+  isFastForward?: boolean;
+  /** Whether the pull resulted in a merge commit */
+  isMerge?: boolean;
+  /** Whether push divergence was auto-resolved */
+  autoResolved?: boolean;
+  message?: string;
+}
+
+// ============================================================================
+// Main Service Function
+// ============================================================================
+
+/**
+ * Perform a sync operation (pull then push) on the given worktree.
+ *
+ * The workflow:
+ * 1. Pull from remote with stashIfNeeded: true
+ * 2. If pull has conflicts, stop and return conflict info
+ * 3. Push to remote
+ * 4. If push fails with divergence after pull, retry once
+ *
+ * @param worktreePath - Path to the git worktree
+ * @param options - Sync options (remote)
+ * @returns SyncResult with detailed status information
+ */
+export async function performSync(
+  worktreePath: string,
+  options?: SyncOptions
+): Promise<SyncResult> {
+  const targetRemote = options?.remote || 'origin';
+
+  // 1. Pull from remote
+  logger.info('Sync: starting pull', { worktreePath, remote: targetRemote });
+
+  let pullResult: PullResult;
+  try {
+    pullResult = await performPull(worktreePath, {
+      remote: targetRemote,
+      stashIfNeeded: true,
+    });
+  } catch (pullError) {
+    return {
+      success: false,
+      error: `Sync pull failed: ${getErrorMessage(pullError)}`,
+    };
+  }
+
+  if (!pullResult.success) {
+    return {
+      success: false,
+      branch: pullResult.branch,
+      pulled: false,
+      pushed: false,
+      error: `Sync pull failed: ${pullResult.error}`,
+      hasConflicts: pullResult.hasConflicts,
+      conflictFiles: pullResult.conflictFiles,
+      conflictSource: pullResult.conflictSource,
+    };
+  }
+
+  // 2. If pull had conflicts, stop and return conflict info
+  if (pullResult.hasConflicts) {
+    return {
+      success: false,
+      branch: pullResult.branch,
+      pulled: true,
+      pushed: false,
+      hasConflicts: true,
+      conflictFiles: pullResult.conflictFiles,
+      conflictSource: pullResult.conflictSource,
+      isFastForward: pullResult.isFastForward,
+      isMerge: pullResult.isMerge,
+      error: 'Sync stopped: pull resulted in merge conflicts. Resolve conflicts and try again.',
+      message: pullResult.message,
+    };
+  }
+
+  // 3. Push to remote
+  logger.info('Sync: pull succeeded, starting push', { worktreePath, remote: targetRemote });
+
+  let pushResult: PushResult;
+  try {
+    pushResult = await performPush(worktreePath, {
+      remote: targetRemote,
+    });
+  } catch (pushError) {
+    return {
+      success: false,
+      branch: pullResult.branch,
+      pulled: true,
+      pushed: false,
+      isFastForward: pullResult.isFastForward,
+      isMerge: pullResult.isMerge,
+      error: `Sync push failed: ${getErrorMessage(pushError)}`,
+    };
+  }
+
+  if (!pushResult.success) {
+    // 4. If push diverged after pull, retry once with autoResolve
+    if (pushResult.diverged) {
+      logger.info('Sync: push diverged after pull, retrying with autoResolve', {
+        worktreePath,
+        remote: targetRemote,
+      });
+
+      try {
+        const retryResult = await performPush(worktreePath, {
+          remote: targetRemote,
+          autoResolve: true,
+        });
+
+        if (retryResult.success) {
+          return {
+            success: true,
+            branch: retryResult.branch,
+            pulled: true,
+            pushed: true,
+            autoResolved: true,
+            isFastForward: pullResult.isFastForward,
+            isMerge: pullResult.isMerge,
+            message: 'Sync completed (push required auto-resolve).',
+          };
+        }
+
+        return {
+          success: false,
+          branch: retryResult.branch,
+          pulled: true,
+          pushed: false,
+          hasConflicts: retryResult.hasConflicts,
+          conflictFiles: retryResult.conflictFiles,
+          error: retryResult.error,
+        };
+      } catch (retryError) {
+        return {
+          success: false,
+          branch: pullResult.branch,
+          pulled: true,
+          pushed: false,
+          error: `Sync push retry failed: ${getErrorMessage(retryError)}`,
+        };
+      }
+    }
+
+    return {
+      success: false,
+      branch: pushResult.branch,
+      pulled: true,
+      pushed: false,
+      isFastForward: pullResult.isFastForward,
+      isMerge: pullResult.isMerge,
+      error: `Sync push failed: ${pushResult.error}`,
+    };
+  }
+
+  return {
+    success: true,
+    branch: pushResult.branch,
+    pulled: pullResult.pulled ?? true,
+    pushed: true,
+    isFastForward: pullResult.isFastForward,
+    isMerge: pullResult.isMerge,
+    message: pullResult.pulled
+      ? 'Sync completed: pulled latest changes and pushed.'
+      : 'Sync completed: already up to date, pushed local commits.',
+  };
+}

apps/server/src/services/worktree-service.ts

@@ -8,9 +8,60 @@
 
 import path from 'path';
 import fs from 'fs/promises';
+import { execGitCommand } from '@automaker/git-utils';
 import type { EventEmitter } from '../lib/events.js';
 import type { SettingsService } from './settings-service.js';
 
+/**
+ * Get the list of remote names that have a branch matching the given branch name.
+ *
+ * Uses `git for-each-ref` to check cached remote refs, returning the names of
+ * any remotes that already have a branch with the same name as `currentBranch`.
+ * Returns an empty array when `hasAnyRemotes` is false or when no matching
+ * remote refs are found.
+ *
+ * This helps the UI distinguish between "branch exists on the tracking remote"
+ * vs "branch was pushed to a different remote".
+ *
+ * @param worktreePath  - Path to the git worktree
+ * @param currentBranch - Branch name to search for on remotes
+ * @param hasAnyRemotes - Whether the repository has any remotes configured
+ * @returns Array of remote names (e.g. ["origin", "upstream"]) that contain the branch
+ */
+export async function getRemotesWithBranch(
+  worktreePath: string,
+  currentBranch: string,
+  hasAnyRemotes: boolean
+): Promise<string[]> {
+  if (!hasAnyRemotes) {
+    return [];
+  }
+
+  try {
+    const remoteRefsOutput = await execGitCommand(
+      ['for-each-ref', '--format=%(refname:short)', `refs/remotes/*/${currentBranch}`],
+      worktreePath
+    );
+
+    if (!remoteRefsOutput.trim()) {
+      return [];
+    }
+
+    return remoteRefsOutput
+      .trim()
+      .split('\n')
+      .map((ref) => {
+        // Extract remote name from "remote/branch" format
+        const slashIdx = ref.indexOf('/');
+        return slashIdx !== -1 ? ref.slice(0, slashIdx) : ref;
+      })
+      .filter((name) => name.length > 0);
+  } catch {
+    // Ignore errors - return empty array
+    return [];
+  }
+}
+
 /**
  * Error thrown when one or more file copy operations fail during
  * `copyConfiguredFiles`.  The caller can inspect `failures` for details.

apps/server/src/types/settings.ts

@@ -23,6 +23,7 @@ export type {
   PhaseModelConfig,
   PhaseModelKey,
   PhaseModelEntry,
+  FeatureTemplate,
   // Claude-compatible provider types
   ApiKeySource,
   ClaudeCompatibleProviderType,
@@ -41,6 +42,7 @@ export {
   DEFAULT_CREDENTIALS,
   DEFAULT_PROJECT_SETTINGS,
   DEFAULT_PHASE_MODELS,
+  DEFAULT_FEATURE_TEMPLATES,
   SETTINGS_VERSION,
   CREDENTIALS_VERSION,
   PROJECT_SETTINGS_VERSION,

apps/server/tests/unit/lib/enhancement-prompts.test.ts

@@ -168,7 +168,7 @@ describe('enhancement-prompts.ts', () => {
       const prompt = buildUserPrompt('improve', testText);
       expect(prompt).toContain('Example 1:');
       expect(prompt).toContain(testText);
-      expect(prompt).toContain('Now, please enhance the following task description:');
+      expect(prompt).toContain('Please enhance the following task description:');
     });
 
     it('should build prompt without examples when includeExamples is false', () => {

apps/server/tests/unit/lib/thinking-level-normalization.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeThinkingLevelForModel } from '@automaker/types';
+
+describe('normalizeThinkingLevelForModel', () => {
+  it('preserves explicitly selected none for Opus models', () => {
+    expect(normalizeThinkingLevelForModel('claude-opus', 'none')).toBe('none');
+  });
+
+  it('falls back to none when Opus receives an unsupported manual thinking level', () => {
+    expect(normalizeThinkingLevelForModel('claude-opus', 'medium')).toBe('none');
+  });
+
+  it('keeps adaptive for Opus when adaptive is selected', () => {
+    expect(normalizeThinkingLevelForModel('claude-opus', 'adaptive')).toBe('adaptive');
+  });
+
+  it('preserves supported manual levels for non-Opus models', () => {
+    expect(normalizeThinkingLevelForModel('claude-sonnet', 'high')).toBe('high');
+  });
+});

apps/server/tests/unit/providers/codex-provider.test.ts

@@ -170,6 +170,30 @@ describe('codex-provider.ts', () => {
       expect(call.args).toContain('--json');
     });
 
+    it('uses exec resume when sdkSessionId is provided', async () => {
+      vi.mocked(spawnJSONLProcess).mockReturnValue((async function* () {})());
+
+      await collectAsyncGenerator(
+        provider.executeQuery({
+          prompt: 'Continue',
+          model: 'gpt-5.2',
+          cwd: '/tmp',
+          sdkSessionId: 'codex-session-123',
+          outputFormat: { type: 'json_schema', schema: { type: 'object', properties: {} } },
+          codexSettings: { additionalDirs: ['/extra/dir'] },
+        })
+      );
+
+      const call = vi.mocked(spawnJSONLProcess).mock.calls[0][0];
+      expect(call.args[0]).toBe('exec');
+      expect(call.args[1]).toBe('resume');
+      expect(call.args).toContain('codex-session-123');
+      expect(call.args).toContain('--json');
+      // Resume queries must not include --output-schema or --add-dir
+      expect(call.args).not.toContain('--output-schema');
+      expect(call.args).not.toContain('--add-dir');
+    });
+
     it('overrides approval policy when MCP auto-approval is enabled', async () => {
       // Note: With full-permissions always on (--dangerously-bypass-approvals-and-sandbox),
       // approval policy is bypassed, not configured via --config
@@ -320,8 +344,10 @@ describe('codex-provider.ts', () => {
       );
 
       const call = vi.mocked(spawnJSONLProcess).mock.calls[0][0];
-      // High reasoning effort should have 3x the default timeout (90000ms)
-      expect(call.timeout).toBe(DEFAULT_TIMEOUT_MS * REASONING_TIMEOUT_MULTIPLIERS.high);
+      // High reasoning effort should have 3x the CLI base timeout (120000ms)
+      // CODEX_CLI_TIMEOUT_MS = 120000, multiplier for 'high' = 3.0 → 360000ms
+      const CODEX_CLI_TIMEOUT_MS = 120000;
+      expect(call.timeout).toBe(CODEX_CLI_TIMEOUT_MS * REASONING_TIMEOUT_MULTIPLIERS.high);
     });
 
     it('passes extended timeout for xhigh reasoning effort', async () => {
@@ -357,8 +383,10 @@ describe('codex-provider.ts', () => {
       );
 
       const call = vi.mocked(spawnJSONLProcess).mock.calls[0][0];
-      // No reasoning effort should use the default timeout
-      expect(call.timeout).toBe(DEFAULT_TIMEOUT_MS);
+      // No reasoning effort should use the CLI base timeout (2 minutes)
+      // CODEX_CLI_TIMEOUT_MS = 120000ms, no multiplier applied
+      const CODEX_CLI_TIMEOUT_MS = 120000;
+      expect(call.timeout).toBe(CODEX_CLI_TIMEOUT_MS);
     });
   });
 

apps/server/tests/unit/providers/copilot-provider.test.ts

@@ -1,17 +1,35 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { CopilotProvider, CopilotErrorCode } from '@/providers/copilot-provider.js';
+import { collectAsyncGenerator } from '../../utils/helpers.js';
+import { CopilotClient } from '@github/copilot-sdk';
+
+const createSessionMock = vi.fn();
+const resumeSessionMock = vi.fn();
+
+function createMockSession(sessionId = 'test-session') {
+  let eventHandler: ((event: any) => void) | null = null;
+  return {
+    sessionId,
+    send: vi.fn().mockImplementation(async () => {
+      if (eventHandler) {
+        eventHandler({ type: 'assistant.message', data: { content: 'hello' } });
+        eventHandler({ type: 'session.idle' });
+      }
+    }),
+    destroy: vi.fn().mockResolvedValue(undefined),
+    on: vi.fn().mockImplementation((handler: (event: any) => void) => {
+      eventHandler = handler;
+    }),
+  };
+}
 
 // Mock the Copilot SDK
 vi.mock('@github/copilot-sdk', () => ({
   CopilotClient: vi.fn().mockImplementation(() => ({
     start: vi.fn().mockResolvedValue(undefined),
     stop: vi.fn().mockResolvedValue(undefined),
-    createSession: vi.fn().mockResolvedValue({
-      sessionId: 'test-session',
-      send: vi.fn().mockResolvedValue(undefined),
-      destroy: vi.fn().mockResolvedValue(undefined),
-      on: vi.fn(),
-    }),
+    createSession: createSessionMock,
+    resumeSession: resumeSessionMock,
   })),
 }));
 
@@ -49,6 +67,16 @@ describe('copilot-provider.ts', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    vi.mocked(CopilotClient).mockImplementation(function () {
+      return {
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        createSession: createSessionMock,
+        resumeSession: resumeSessionMock,
+      } as any;
+    });
+    createSessionMock.mockResolvedValue(createMockSession());
+    resumeSessionMock.mockResolvedValue(createMockSession('resumed-session'));
 
     // Mock fs.existsSync for CLI path validation
     vi.mocked(fs.existsSync).mockReturnValue(true);
@@ -369,6 +397,45 @@ describe('copilot-provider.ts', () => {
       });
     });
 
+    it('should use error code in fallback when session.error message is empty', () => {
+      const event = {
+        type: 'session.error',
+        data: { message: '', code: 'RATE_LIMIT_EXCEEDED' },
+      };
+
+      const result = provider.normalizeEvent(event);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe('error');
+      expect(result!.error).toContain('RATE_LIMIT_EXCEEDED');
+      expect(result!.error).not.toBe('Unknown error');
+    });
+
+    it('should return generic "Copilot agent error" fallback when both message and code are empty', () => {
+      const event = {
+        type: 'session.error',
+        data: { message: '', code: '' },
+      };
+
+      const result = provider.normalizeEvent(event);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe('error');
+      expect(result!.error).toBe('Copilot agent error');
+      // Must NOT be the old opaque 'Unknown error'
+      expect(result!.error).not.toBe('Unknown error');
+    });
+
+    it('should return generic "Copilot agent error" fallback when data has no code field', () => {
+      const event = {
+        type: 'session.error',
+        data: { message: '' },
+      };
+
+      const result = provider.normalizeEvent(event);
+      expect(result).not.toBeNull();
+      expect(result!.type).toBe('error');
+      expect(result!.error).toBe('Copilot agent error');
+    });
+
     it('should return null for unknown event types', () => {
       const event = { type: 'unknown.event' };
 
@@ -514,4 +581,45 @@ describe('copilot-provider.ts', () => {
       expect(todoInput.todos[0].status).toBe('completed');
     });
   });
+
+  describe('executeQuery resume behavior', () => {
+    it('uses resumeSession when sdkSessionId is provided', async () => {
+      const results = await collectAsyncGenerator(
+        provider.executeQuery({
+          prompt: 'Hello',
+          model: 'claude-sonnet-4.6',
+          cwd: '/tmp/project',
+          sdkSessionId: 'session-123',
+        })
+      );
+
+      expect(resumeSessionMock).toHaveBeenCalledWith(
+        'session-123',
+        expect.objectContaining({ model: 'claude-sonnet-4.6', streaming: true })
+      );
+      expect(createSessionMock).not.toHaveBeenCalled();
+      expect(results.some((msg) => msg.session_id === 'resumed-session')).toBe(true);
+    });
+
+    it('falls back to createSession when resumeSession fails', async () => {
+      resumeSessionMock.mockRejectedValueOnce(new Error('session not found'));
+      createSessionMock.mockResolvedValueOnce(createMockSession('fresh-session'));
+
+      const results = await collectAsyncGenerator(
+        provider.executeQuery({
+          prompt: 'Hello',
+          model: 'claude-sonnet-4.6',
+          cwd: '/tmp/project',
+          sdkSessionId: 'stale-session',
+        })
+      );
+
+      expect(resumeSessionMock).toHaveBeenCalledWith(
+        'stale-session',
+        expect.objectContaining({ model: 'claude-sonnet-4.6', streaming: true })
+      );
+      expect(createSessionMock).toHaveBeenCalledTimes(1);
+      expect(results.some((msg) => msg.session_id === 'fresh-session')).toBe(true);
+    });
+  });
 });

apps/server/tests/unit/providers/cursor-provider.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CursorProvider } from '@/providers/cursor-provider.js';
+
+describe('cursor-provider.ts', () => {
+  describe('buildCliArgs', () => {
+    it('adds --resume when sdkSessionId is provided', () => {
+      const provider = Object.create(CursorProvider.prototype) as CursorProvider & {
+        cliPath?: string;
+      };
+      provider.cliPath = '/usr/local/bin/cursor-agent';
+
+      const args = provider.buildCliArgs({
+        prompt: 'Continue the task',
+        model: 'gpt-5',
+        cwd: '/tmp/project',
+        sdkSessionId: 'cursor-session-123',
+      });
+
+      const resumeIndex = args.indexOf('--resume');
+      expect(resumeIndex).toBeGreaterThan(-1);
+      expect(args[resumeIndex + 1]).toBe('cursor-session-123');
+    });
+
+    it('does not add --resume when sdkSessionId is omitted', () => {
+      const provider = Object.create(CursorProvider.prototype) as CursorProvider & {
+        cliPath?: string;
+      };
+      provider.cliPath = '/usr/local/bin/cursor-agent';
+
+      const args = provider.buildCliArgs({
+        prompt: 'Start a new task',
+        model: 'gpt-5',
+        cwd: '/tmp/project',
+      });
+
+      expect(args).not.toContain('--resume');
+    });
+  });
+
+  describe('normalizeEvent - result error handling', () => {
+    let provider: CursorProvider;
+
+    beforeEach(() => {
+      provider = Object.create(CursorProvider.prototype) as CursorProvider;
+    });
+
+    it('returns error message from resultEvent.error when is_error=true', () => {
+      const event = {
+        type: 'result',
+        is_error: true,
+        error: 'Rate limit exceeded',
+        result: '',
+        subtype: 'error',
+        duration_ms: 3000,
+        session_id: 'sess-123',
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.type).toBe('error');
+      expect(msg!.error).toBe('Rate limit exceeded');
+    });
+
+    it('falls back to resultEvent.result when error field is empty and is_error=true', () => {
+      const event = {
+        type: 'result',
+        is_error: true,
+        error: '',
+        result: 'Process terminated unexpectedly',
+        subtype: 'error',
+        duration_ms: 5000,
+        session_id: 'sess-456',
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.type).toBe('error');
+      expect(msg!.error).toBe('Process terminated unexpectedly');
+    });
+
+    it('builds diagnostic fallback when both error and result are empty and is_error=true', () => {
+      const event = {
+        type: 'result',
+        is_error: true,
+        error: '',
+        result: '',
+        subtype: 'error',
+        duration_ms: 5000,
+        session_id: 'sess-789',
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.type).toBe('error');
+      // Should contain diagnostic info rather than 'Unknown error'
+      expect(msg!.error).toContain('5000ms');
+      expect(msg!.error).toContain('sess-789');
+      expect(msg!.error).not.toBe('Unknown error');
+    });
+
+    it('preserves session_id in error message', () => {
+      const event = {
+        type: 'result',
+        is_error: true,
+        error: 'Timeout occurred',
+        result: '',
+        subtype: 'error',
+        duration_ms: 30000,
+        session_id: 'my-session-id',
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg!.session_id).toBe('my-session-id');
+    });
+
+    it('uses "none" when session_id is missing from diagnostic fallback', () => {
+      const event = {
+        type: 'result',
+        is_error: true,
+        error: '',
+        result: '',
+        subtype: 'error',
+        duration_ms: 5000,
+        // session_id intentionally omitted
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.type).toBe('error');
+      expect(msg!.error).toContain('none');
+      expect(msg!.error).not.toContain('undefined');
+    });
+
+    it('returns success result when is_error=false', () => {
+      const event = {
+        type: 'result',
+        is_error: false,
+        error: '',
+        result: 'Completed successfully',
+        subtype: 'success',
+        duration_ms: 2000,
+        session_id: 'sess-ok',
+      };
+
+      const msg = provider.normalizeEvent(event);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.type).toBe('result');
+      expect(msg!.subtype).toBe('success');
+    });
+  });
+});

apps/server/tests/unit/providers/gemini-provider.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { GeminiProvider } from '@/providers/gemini-provider.js';
+import type { ProviderMessage } from '@automaker/types';
+
+describe('gemini-provider.ts', () => {
+  let provider: GeminiProvider;
+
+  beforeEach(() => {
+    provider = new GeminiProvider();
+  });
+
+  describe('buildCliArgs', () => {
+    it('should include --prompt with empty string to force headless mode', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello from Gemini',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      const promptIndex = args.indexOf('--prompt');
+      expect(promptIndex).toBeGreaterThan(-1);
+      expect(args[promptIndex + 1]).toBe('');
+    });
+
+    it('should include --resume when sdkSessionId is provided', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+        sdkSessionId: 'gemini-session-123',
+      });
+
+      const resumeIndex = args.indexOf('--resume');
+      expect(resumeIndex).toBeGreaterThan(-1);
+      expect(args[resumeIndex + 1]).toBe('gemini-session-123');
+    });
+
+    it('should not include --resume when sdkSessionId is missing', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      expect(args).not.toContain('--resume');
+    });
+
+    it('should include --sandbox false for faster execution', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      const sandboxIndex = args.indexOf('--sandbox');
+      expect(sandboxIndex).toBeGreaterThan(-1);
+      expect(args[sandboxIndex + 1]).toBe('false');
+    });
+
+    it('should include --approval-mode yolo for non-interactive use', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      const approvalIndex = args.indexOf('--approval-mode');
+      expect(approvalIndex).toBeGreaterThan(-1);
+      expect(args[approvalIndex + 1]).toBe('yolo');
+    });
+
+    it('should include --output-format stream-json', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      const formatIndex = args.indexOf('--output-format');
+      expect(formatIndex).toBeGreaterThan(-1);
+      expect(args[formatIndex + 1]).toBe('stream-json');
+    });
+
+    it('should include --include-directories with cwd', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/my-project',
+      });
+
+      const dirIndex = args.indexOf('--include-directories');
+      expect(dirIndex).toBeGreaterThan(-1);
+      expect(args[dirIndex + 1]).toBe('/tmp/my-project');
+    });
+
+    it('should add gemini- prefix to bare model names', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: '2.5-flash',
+        cwd: '/tmp/project',
+      });
+
+      const modelIndex = args.indexOf('--model');
+      expect(modelIndex).toBeGreaterThan(-1);
+      expect(args[modelIndex + 1]).toBe('gemini-2.5-flash');
+    });
+
+    it('should not double-prefix model names that already have gemini-', () => {
+      const args = provider.buildCliArgs({
+        prompt: 'Hello',
+        model: 'gemini-2.5-pro',
+        cwd: '/tmp/project',
+      });
+
+      const modelIndex = args.indexOf('--model');
+      expect(modelIndex).toBeGreaterThan(-1);
+      expect(args[modelIndex + 1]).toBe('gemini-2.5-pro');
+    });
+  });
+
+  describe('normalizeEvent - error handling', () => {
+    it('returns error from result event when status=error and error field is set', () => {
+      const event = {
+        type: 'result',
+        status: 'error',
+        error: 'Model overloaded',
+        session_id: 'sess-gemini-1',
+        stats: { duration_ms: 4000, total_tokens: 0 },
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      expect(msg.error).toBe('Model overloaded');
+      expect(msg.session_id).toBe('sess-gemini-1');
+    });
+
+    it('builds diagnostic fallback when result event has status=error but empty error field', () => {
+      const event = {
+        type: 'result',
+        status: 'error',
+        error: '',
+        session_id: 'sess-gemini-2',
+        stats: { duration_ms: 7500, total_tokens: 0 },
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      // Diagnostic info should be present instead of 'Unknown error'
+      expect(msg.error).toContain('7500ms');
+      expect(msg.error).toContain('sess-gemini-2');
+      expect(msg.error).not.toBe('Unknown error');
+    });
+
+    it('builds fallback with "unknown" duration when stats are missing', () => {
+      const event = {
+        type: 'result',
+        status: 'error',
+        error: '',
+        session_id: 'sess-gemini-nostats',
+        // no stats field
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      expect(msg.error).toContain('unknown');
+    });
+
+    it('returns error from standalone error event with error field set', () => {
+      const event = {
+        type: 'error',
+        error: 'API key invalid',
+        session_id: 'sess-gemini-3',
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      expect(msg.error).toBe('API key invalid');
+    });
+
+    it('builds diagnostic fallback when standalone error event has empty error field', () => {
+      const event = {
+        type: 'error',
+        error: '',
+        session_id: 'sess-gemini-empty',
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      // Should include session_id, not just 'Unknown error'
+      expect(msg.error).toContain('sess-gemini-empty');
+      expect(msg.error).not.toBe('Unknown error');
+    });
+
+    it('builds fallback mentioning "none" when session_id is missing from error event', () => {
+      const event = {
+        type: 'error',
+        error: '',
+        // no session_id
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('error');
+      expect(msg.error).toContain('none');
+    });
+
+    it('uses consistent "Gemini agent failed" label for both result and error event fallbacks', () => {
+      const resultEvent = {
+        type: 'result',
+        status: 'error',
+        error: '',
+        session_id: 'sess-r',
+        stats: { duration_ms: 1000 },
+      };
+      const errorEvent = {
+        type: 'error',
+        error: '',
+        session_id: 'sess-e',
+      };
+
+      const resultMsg = provider.normalizeEvent(resultEvent) as ProviderMessage;
+      const errorMsg = provider.normalizeEvent(errorEvent) as ProviderMessage;
+
+      // Both fallback messages should use the same "Gemini agent failed" prefix
+      expect(resultMsg.error).toContain('Gemini agent failed');
+      expect(errorMsg.error).toContain('Gemini agent failed');
+    });
+
+    it('returns success result when result event has status=success', () => {
+      const event = {
+        type: 'result',
+        status: 'success',
+        error: '',
+        session_id: 'sess-gemini-ok',
+        stats: { duration_ms: 1200, total_tokens: 500 },
+      };
+
+      const msg = provider.normalizeEvent(event) as ProviderMessage;
+
+      expect(msg).not.toBeNull();
+      expect(msg.type).toBe('result');
+      expect(msg.subtype).toBe('success');
+    });
+  });
+});

apps/server/tests/unit/routes/backlog-plan/generate-plan.test.ts

@@ -0,0 +1,218 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { BacklogPlanResult, ProviderMessage } from '@automaker/types';
+
+const {
+  mockGetAll,
+  mockExecuteQuery,
+  mockSaveBacklogPlan,
+  mockSetRunningState,
+  mockSetRunningDetails,
+  mockGetPromptCustomization,
+  mockGetAutoLoadClaudeMdSetting,
+  mockGetUseClaudeCodeSystemPromptSetting,
+} = vi.hoisted(() => ({
+  mockGetAll: vi.fn(),
+  mockExecuteQuery: vi.fn(),
+  mockSaveBacklogPlan: vi.fn(),
+  mockSetRunningState: vi.fn(),
+  mockSetRunningDetails: vi.fn(),
+  mockGetPromptCustomization: vi.fn(),
+  mockGetAutoLoadClaudeMdSetting: vi.fn(),
+  mockGetUseClaudeCodeSystemPromptSetting: vi.fn(),
+}));
+
+vi.mock('@/services/feature-loader.js', () => ({
+  FeatureLoader: class {
+    getAll = mockGetAll;
+  },
+}));
+
+vi.mock('@/providers/provider-factory.js', () => ({
+  ProviderFactory: {
+    getProviderForModel: vi.fn(() => ({
+      executeQuery: mockExecuteQuery,
+    })),
+  },
+}));
+
+vi.mock('@/routes/backlog-plan/common.js', () => ({
+  logger: {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+  setRunningState: mockSetRunningState,
+  setRunningDetails: mockSetRunningDetails,
+  getErrorMessage: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+  saveBacklogPlan: mockSaveBacklogPlan,
+}));
+
+vi.mock('@/lib/settings-helpers.js', () => ({
+  getPromptCustomization: mockGetPromptCustomization,
+  getAutoLoadClaudeMdSetting: mockGetAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting: mockGetUseClaudeCodeSystemPromptSetting,
+  getPhaseModelWithOverrides: vi.fn(),
+}));
+
+import { generateBacklogPlan } from '@/routes/backlog-plan/generate-plan.js';
+
+function createMockEvents() {
+  return {
+    emit: vi.fn(),
+  };
+}
+
+describe('generateBacklogPlan', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockGetAll.mockResolvedValue([]);
+    mockGetPromptCustomization.mockResolvedValue({
+      backlogPlan: {
+        systemPrompt: 'System instructions',
+        userPromptTemplate:
+          'Current features:\n{{currentFeatures}}\n\nUser request:\n{{userRequest}}',
+      },
+    });
+    mockGetAutoLoadClaudeMdSetting.mockResolvedValue(false);
+    mockGetUseClaudeCodeSystemPromptSetting.mockResolvedValue(true);
+  });
+
+  it('salvages valid streamed JSON when Claude process exits with code 1', async () => {
+    const partialResult: BacklogPlanResult = {
+      changes: [
+        {
+          type: 'add',
+          feature: {
+            title: 'Add signup form',
+            description: 'Create signup UI and validation',
+            category: 'frontend',
+          },
+          reason: 'Required for user onboarding',
+        },
+      ],
+      summary: 'Adds signup feature to the backlog',
+      dependencyUpdates: [],
+    };
+
+    const responseJson = JSON.stringify(partialResult);
+
+    async function* streamWithExitError(): AsyncGenerator<ProviderMessage> {
+      yield {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: responseJson }],
+        },
+      };
+      throw new Error('Claude Code process exited with code 1');
+    }
+
+    mockExecuteQuery.mockReturnValueOnce(streamWithExitError());
+
+    const events = createMockEvents();
+    const abortController = new AbortController();
+
+    const result = await generateBacklogPlan(
+      '/tmp/project',
+      'Please add a signup feature',
+      events as any,
+      abortController,
+      undefined,
+      'claude-opus'
+    );
+
+    expect(mockExecuteQuery).toHaveBeenCalledTimes(1);
+    expect(result).toEqual(partialResult);
+    expect(mockSaveBacklogPlan).toHaveBeenCalledWith(
+      '/tmp/project',
+      expect.objectContaining({
+        prompt: 'Please add a signup feature',
+        model: 'claude-opus-4-6',
+        result: partialResult,
+      })
+    );
+    expect(events.emit).toHaveBeenCalledWith('backlog-plan:event', {
+      type: 'backlog_plan_complete',
+      result: partialResult,
+    });
+    expect(mockSetRunningState).toHaveBeenCalledWith(false, null);
+    expect(mockSetRunningDetails).toHaveBeenCalledWith(null);
+  });
+
+  it('prefers parseable provider result over longer non-JSON accumulated text on exit', async () => {
+    const recoveredResult: BacklogPlanResult = {
+      changes: [
+        {
+          type: 'add',
+          feature: {
+            title: 'Add reset password flow',
+            description: 'Implement reset password request and token validation UI',
+            category: 'frontend',
+          },
+          reason: 'Supports account recovery',
+        },
+      ],
+      summary: 'Adds password reset capability',
+      dependencyUpdates: [],
+    };
+
+    const validProviderResult = JSON.stringify(recoveredResult);
+    const invalidAccumulatedText = `${validProviderResult}\n\nAdditional commentary that breaks raw JSON parsing.`;
+
+    async function* streamWithResultThenExit(): AsyncGenerator<ProviderMessage> {
+      yield {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: invalidAccumulatedText }],
+        },
+      };
+      yield {
+        type: 'result',
+        subtype: 'success',
+        duration_ms: 10,
+        duration_api_ms: 10,
+        is_error: false,
+        num_turns: 1,
+        result: validProviderResult,
+        session_id: 'session-1',
+        total_cost_usd: 0,
+        usage: {
+          input_tokens: 10,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          output_tokens: 10,
+          server_tool_use: {
+            web_search_requests: 0,
+          },
+          service_tier: 'standard',
+        },
+      };
+      throw new Error('Claude Code process exited with code 1');
+    }
+
+    mockExecuteQuery.mockReturnValueOnce(streamWithResultThenExit());
+
+    const events = createMockEvents();
+    const abortController = new AbortController();
+
+    const result = await generateBacklogPlan(
+      '/tmp/project',
+      'Add password reset support',
+      events as any,
+      abortController,
+      undefined,
+      'claude-opus'
+    );
+
+    expect(result).toEqual(recoveredResult);
+    expect(mockSaveBacklogPlan).toHaveBeenCalledWith(
+      '/tmp/project',
+      expect.objectContaining({
+        result: recoveredResult,
+      })
+    );
+  });
+});

apps/server/tests/unit/services/agent-executor.test.ts

@@ -685,6 +685,309 @@ describe('AgentExecutor', () => {
       await expect(executor.execute(options, callbacks)).rejects.toThrow('API rate limit exceeded');
     });
 
+    it('should throw "Unknown error" when provider stream yields error with empty message', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'error',
+            error: '',
+            session_id: 'sess-123',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      await expect(executor.execute(options, callbacks)).rejects.toThrow('Unknown error');
+    });
+
+    it('should throw with sanitized error when provider yields ANSI-decorated error', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'error',
+            // ANSI color codes + "Error: " prefix that should be stripped
+            error: '\x1b[31mError: Connection refused\x1b[0m',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      // Should strip ANSI codes and "Error: " prefix
+      await expect(executor.execute(options, callbacks)).rejects.toThrow('Connection refused');
+    });
+
+    it('should throw when result subtype is error_max_turns', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'assistant',
+            message: {
+              content: [{ type: 'text', text: 'Working on it...' }],
+            },
+          };
+          yield {
+            type: 'result',
+            subtype: 'error_max_turns',
+            session_id: 'sess-456',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      await expect(executor.execute(options, callbacks)).rejects.toThrow(
+        'Agent execution ended with: error_max_turns'
+      );
+    });
+
+    it('should throw when result subtype is error_during_execution', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'result',
+            subtype: 'error_during_execution',
+            session_id: 'sess-789',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      await expect(executor.execute(options, callbacks)).rejects.toThrow(
+        'Agent execution ended with: error_during_execution'
+      );
+    });
+
+    it('should throw when result subtype is error_max_structured_output_retries', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'result',
+            subtype: 'error_max_structured_output_retries',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      await expect(executor.execute(options, callbacks)).rejects.toThrow(
+        'Agent execution ended with: error_max_structured_output_retries'
+      );
+    });
+
+    it('should throw when result subtype is error_max_budget_usd', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'result',
+            subtype: 'error_max_budget_usd',
+            session_id: 'sess-budget',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      await expect(executor.execute(options, callbacks)).rejects.toThrow(
+        'Agent execution ended with: error_max_budget_usd'
+      );
+    });
+
+    it('should NOT throw when result subtype is success', async () => {
+      const executor = new AgentExecutor(
+        mockEventBus,
+        mockFeatureStateManager,
+        mockPlanApprovalService,
+        mockSettingsService
+      );
+
+      const mockProvider = {
+        getName: () => 'mock',
+        executeQuery: vi.fn().mockImplementation(function* () {
+          yield {
+            type: 'assistant',
+            message: {
+              content: [{ type: 'text', text: 'Done!' }],
+            },
+          };
+          yield {
+            type: 'result',
+            subtype: 'success',
+            session_id: 'sess-ok',
+          };
+        }),
+      } as unknown as BaseProvider;
+
+      const options: AgentExecutionOptions = {
+        workDir: '/test',
+        featureId: 'test-feature',
+        prompt: 'Test prompt',
+        projectPath: '/project',
+        abortController: new AbortController(),
+        provider: mockProvider,
+        effectiveBareModel: 'claude-sonnet-4-6',
+        planningMode: 'skip',
+      };
+
+      const callbacks = {
+        waitForApproval: vi.fn().mockResolvedValue({ approved: true }),
+        saveFeatureSummary: vi.fn(),
+        updateFeatureSummary: vi.fn(),
+        buildTaskPrompt: vi.fn().mockReturnValue('task prompt'),
+      };
+
+      // Should resolve without throwing
+      const result = await executor.execute(options, callbacks);
+      expect(result.aborted).toBe(false);
+      expect(result.responseText).toContain('Done!');
+    });
+
     it('should throw error when authentication fails in response', async () => {
       const executor = new AgentExecutor(
         mockEventBus,

apps/server/tests/unit/services/agent-output-validation.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Contract tests verifying the tool marker format used by agent-executor
+ * (which writes agent output) and execution-service (which reads it to
+ * determine if the agent did meaningful work).
+ *
+ * The agent-executor writes: `\n🔧 Tool: ${block.name}\n`
+ * The execution-service checks: `agentOutput.includes('🔧 Tool:')`
+ *
+ * These tests ensure the marker format contract stays consistent and
+ * document the exact detection logic used for status determination.
+ */
+
+// The exact marker prefix that execution-service searches for
+const TOOL_MARKER = '🔧 Tool:';
+
+// Minimum output length threshold for "meaningful work"
+const MIN_OUTPUT_LENGTH = 200;
+
+/**
+ * Simulates the agent-executor's tool_use output format.
+ * See: agent-executor.ts line ~293
+ */
+function formatToolUseBlock(toolName: string, input?: Record<string, unknown>): string {
+  let output = `\n${TOOL_MARKER} ${toolName}\n`;
+  if (input) output += `Input: ${JSON.stringify(input, null, 2)}\n`;
+  return output;
+}
+
+/**
+ * Simulates the execution-service's output validation logic.
+ * See: execution-service.ts lines ~427-429
+ */
+function validateAgentOutput(
+  agentOutput: string,
+  skipTests: boolean
+): 'verified' | 'waiting_approval' {
+  const hasToolUsage = agentOutput.includes(TOOL_MARKER);
+  const hasMinimalOutput = agentOutput.trim().length < MIN_OUTPUT_LENGTH;
+  const agentDidWork = hasToolUsage && !hasMinimalOutput;
+
+  if (skipTests) return 'waiting_approval';
+  if (!agentDidWork) return 'waiting_approval';
+  return 'verified';
+}
+
+describe('Agent Output Validation - Contract Tests', () => {
+  describe('tool marker format contract', () => {
+    it('agent-executor tool format contains the expected marker', () => {
+      const toolOutput = formatToolUseBlock('Read', { file_path: '/src/index.ts' });
+      expect(toolOutput).toContain(TOOL_MARKER);
+    });
+
+    it('agent-executor tool format includes tool name after marker', () => {
+      const toolOutput = formatToolUseBlock('Edit', {
+        file_path: '/src/app.ts',
+        old_string: 'foo',
+        new_string: 'bar',
+      });
+      expect(toolOutput).toContain('🔧 Tool: Edit');
+    });
+
+    it('agent-executor tool format includes JSON input', () => {
+      const input = { file_path: '/src/index.ts' };
+      const toolOutput = formatToolUseBlock('Read', input);
+      expect(toolOutput).toContain('Input: ');
+      expect(toolOutput).toContain('"file_path": "/src/index.ts"');
+    });
+
+    it('agent-executor tool format works without input', () => {
+      const toolOutput = formatToolUseBlock('Bash');
+      expect(toolOutput).toContain('🔧 Tool: Bash');
+      expect(toolOutput).not.toContain('Input:');
+    });
+
+    it('marker includes colon and space to avoid false positives', () => {
+      // Ensure the marker is specific enough to avoid matching other emoji patterns
+      expect(TOOL_MARKER).toBe('🔧 Tool:');
+      expect(TOOL_MARKER).toContain(':');
+    });
+  });
+
+  describe('output validation logic', () => {
+    it('verified: tool usage + sufficient output', () => {
+      const output =
+        'Starting implementation of the new feature...\n' +
+        formatToolUseBlock('Read', { file_path: '/src/index.ts' }) +
+        'I can see the existing code. Let me make the needed changes.\n' +
+        formatToolUseBlock('Edit', { file_path: '/src/index.ts' }) +
+        'Changes complete. The implementation adds new validation logic and tests.';
+      expect(output.trim().length).toBeGreaterThanOrEqual(MIN_OUTPUT_LENGTH);
+
+      expect(validateAgentOutput(output, false)).toBe('verified');
+    });
+
+    it('waiting_approval: no tool markers regardless of length', () => {
+      const longOutput = 'I analyzed the codebase. '.repeat(50);
+      expect(longOutput.trim().length).toBeGreaterThan(MIN_OUTPUT_LENGTH);
+
+      expect(validateAgentOutput(longOutput, false)).toBe('waiting_approval');
+    });
+
+    it('waiting_approval: tool markers but insufficient length', () => {
+      const shortOutput = formatToolUseBlock('Read', { file_path: '/src/a.ts' });
+      expect(shortOutput.trim().length).toBeLessThan(MIN_OUTPUT_LENGTH);
+
+      expect(validateAgentOutput(shortOutput, false)).toBe('waiting_approval');
+    });
+
+    it('waiting_approval: empty output', () => {
+      expect(validateAgentOutput('', false)).toBe('waiting_approval');
+    });
+
+    it('waiting_approval: skipTests always overrides', () => {
+      const goodOutput =
+        'Starting...\n' +
+        formatToolUseBlock('Read', { file_path: '/src/index.ts' }) +
+        formatToolUseBlock('Edit', { file_path: '/src/index.ts' }) +
+        'Done implementing. '.repeat(15);
+      expect(goodOutput.trim().length).toBeGreaterThanOrEqual(MIN_OUTPUT_LENGTH);
+
+      expect(validateAgentOutput(goodOutput, true)).toBe('waiting_approval');
+    });
+
+    it('boundary: exactly MIN_OUTPUT_LENGTH chars with tool is verified', () => {
+      const tool = formatToolUseBlock('Read');
+      const padding = 'x'.repeat(MIN_OUTPUT_LENGTH - tool.trim().length);
+      const output = tool + padding;
+      expect(output.trim().length).toBeGreaterThanOrEqual(MIN_OUTPUT_LENGTH);
+
+      expect(validateAgentOutput(output, false)).toBe('verified');
+    });
+
+    it('boundary: MIN_OUTPUT_LENGTH - 1 chars with tool is waiting_approval', () => {
+      const marker = `${TOOL_MARKER} Read\n`;
+      const padding = 'x'.repeat(MIN_OUTPUT_LENGTH - 1 - marker.length);
+      const output = marker + padding;
+      expect(output.trim().length).toBe(MIN_OUTPUT_LENGTH - 1);
+
+      expect(validateAgentOutput(output, false)).toBe('waiting_approval');
+    });
+  });
+
+  describe('realistic provider scenarios', () => {
+    it('Claude SDK agent with multiple tools → verified', () => {
+      let output = "I'll implement the feature.\n\n";
+      output += formatToolUseBlock('Read', { file_path: '/src/components/App.tsx' });
+      output += 'I see the component. Let me update it.\n\n';
+      output += formatToolUseBlock('Edit', {
+        file_path: '/src/components/App.tsx',
+        old_string: 'const App = () => {',
+        new_string: 'const App: React.FC = () => {',
+      });
+      output += 'Done. The component is now typed correctly.\n';
+
+      expect(validateAgentOutput(output, false)).toBe('verified');
+    });
+
+    it('Cursor CLI quick exit (no tools) → waiting_approval', () => {
+      const output = 'Task received. Processing...\nResult: completed successfully.';
+      expect(validateAgentOutput(output, false)).toBe('waiting_approval');
+    });
+
+    it('Codex CLI with brief acknowledgment → waiting_approval', () => {
+      const output = 'Understood the task. Starting implementation.\nDone.';
+      expect(validateAgentOutput(output, false)).toBe('waiting_approval');
+    });
+
+    it('Agent that only reads but makes no edits (single Read tool, short output) → waiting_approval', () => {
+      const output = formatToolUseBlock('Read', { file_path: '/src/index.ts' }) + 'File read.';
+      expect(output.trim().length).toBeLessThan(MIN_OUTPUT_LENGTH);
+      expect(validateAgentOutput(output, false)).toBe('waiting_approval');
+    });
+
+    it('Agent with extensive tool usage and explanation → verified', () => {
+      let output = 'Analyzing the codebase for the authentication feature.\n\n';
+      for (let i = 0; i < 5; i++) {
+        output += formatToolUseBlock('Read', { file_path: `/src/auth/handler${i}.ts` });
+        output += `Found handler ${i}. `;
+      }
+      output += formatToolUseBlock('Edit', {
+        file_path: '/src/auth/handler0.ts',
+        old_string: 'function login() {}',
+        new_string: 'async function login(creds: Credentials) { ... }',
+      });
+      output += 'Implementation complete with all authentication changes applied.\n';
+
+      expect(validateAgentOutput(output, false)).toBe('verified');
+    });
+  });
+});

apps/server/tests/unit/services/agent-service.test.ts

@@ -188,6 +188,125 @@ describe('agent-service.ts', () => {
       expect(mockEvents.emit).toHaveBeenCalled();
     });
 
+    it('should emit tool_result events from provider stream', async () => {
+      const mockProvider = {
+        getName: () => 'gemini',
+        executeQuery: async function* () {
+          yield {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [
+                {
+                  type: 'tool_use',
+                  name: 'Read',
+                  tool_use_id: 'tool-1',
+                  input: { file_path: 'README.md' },
+                },
+              ],
+            },
+          };
+          yield {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [
+                {
+                  type: 'tool_result',
+                  tool_use_id: 'tool-1',
+                  content: 'File contents here',
+                },
+              ],
+            },
+          };
+          yield {
+            type: 'result',
+            subtype: 'success',
+          };
+        },
+      };
+
+      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);
+
+      vi.mocked(promptBuilder.buildPromptWithImages).mockResolvedValue({
+        content: 'Hello',
+        hasImages: false,
+      });
+
+      await service.sendMessage({
+        sessionId: 'session-1',
+        message: 'Hello',
+      });
+
+      expect(mockEvents.emit).toHaveBeenCalledWith(
+        'agent:stream',
+        expect.objectContaining({
+          sessionId: 'session-1',
+          type: 'tool_result',
+          tool: {
+            name: 'Read',
+            input: {
+              toolUseId: 'tool-1',
+              content: 'File contents here',
+            },
+          },
+        })
+      );
+    });
+
+    it('should emit tool_result with unknown tool name for unregistered tool_use_id', async () => {
+      const mockProvider = {
+        getName: () => 'gemini',
+        executeQuery: async function* () {
+          // Yield tool_result WITHOUT a preceding tool_use (unregistered tool_use_id)
+          yield {
+            type: 'assistant',
+            message: {
+              role: 'assistant',
+              content: [
+                {
+                  type: 'tool_result',
+                  tool_use_id: 'unregistered-id',
+                  content: 'Some result content',
+                },
+              ],
+            },
+          };
+          yield {
+            type: 'result',
+            subtype: 'success',
+          };
+        },
+      };
+
+      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);
+
+      vi.mocked(promptBuilder.buildPromptWithImages).mockResolvedValue({
+        content: 'Hello',
+        hasImages: false,
+      });
+
+      await service.sendMessage({
+        sessionId: 'session-1',
+        message: 'Hello',
+      });
+
+      expect(mockEvents.emit).toHaveBeenCalledWith(
+        'agent:stream',
+        expect.objectContaining({
+          sessionId: 'session-1',
+          type: 'tool_result',
+          tool: {
+            name: 'unknown',
+            input: {
+              toolUseId: 'unregistered-id',
+              content: 'Some result content',
+            },
+          },
+        })
+      );
+    });
+
     it('should handle images in message', async () => {
       const mockProvider = {
         getName: () => 'claude',
@@ -303,6 +422,36 @@ describe('agent-service.ts', () => {
 
       expect(fs.writeFile).toHaveBeenCalled();
     });
+
+    it('should include context/history preparation for Gemini requests', async () => {
+      let capturedOptions: any;
+      const mockProvider = {
+        getName: () => 'gemini',
+        executeQuery: async function* (options: any) {
+          capturedOptions = options;
+          yield {
+            type: 'result',
+            subtype: 'success',
+          };
+        },
+      };
+
+      vi.mocked(ProviderFactory.getProviderForModelName).mockReturnValue('gemini');
+      vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);
+      vi.mocked(promptBuilder.buildPromptWithImages).mockResolvedValue({
+        content: 'Hello',
+        hasImages: false,
+      });
+
+      await service.sendMessage({
+        sessionId: 'session-1',
+        message: 'Hello',
+        model: 'gemini-2.5-flash',
+      });
+
+      expect(contextLoader.loadContextFiles).toHaveBeenCalled();
+      expect(capturedOptions).toBeDefined();
+    });
   });
 
   describe('stopExecution', () => {

apps/server/tests/unit/services/event-hook-service.test.ts

@@ -116,6 +116,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: true,
@@ -144,6 +145,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: false,
@@ -171,6 +173,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: true,
@@ -200,6 +203,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: false,
@@ -217,6 +221,55 @@ describe('EventHookService', () => {
       // Error field should be populated for error triggers
       expect(storeCall.error).toBe('Feature stopped by user');
     });
+
+    it('should ignore feature complete events without explicit auto execution mode', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'auto_mode_feature_complete',
+        featureId: 'feat-1',
+        featureName: 'Manual Feature',
+        passes: true,
+        message: 'Manually verified',
+        projectPath: '/test/project',
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(mockEventHistoryService.storeEvent).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('event mapping - feature:completed', () => {
+    it('should map manual completion to feature_success', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      mockEmitter.simulateEvent('feature:completed', {
+        featureId: 'feat-1',
+        featureName: 'Manual Feature',
+        projectPath: '/test/project',
+        passes: true,
+        executionMode: 'manual',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalled();
+      });
+
+      const storeCall = (mockEventHistoryService.storeEvent as ReturnType<typeof vi.fn>).mock
+        .calls[0][0];
+      expect(storeCall.trigger).toBe('feature_success');
+      expect(storeCall.passes).toBe(true);
+    });
   });
 
   describe('event mapping - auto_mode_error', () => {
@@ -400,6 +453,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: true,
@@ -420,7 +474,6 @@ describe('EventHookService', () => {
     it('should NOT execute error hooks when feature completes successfully', async () => {
       // This is the key regression test for the bug:
       // "Error event hook fired when a feature completes successfully"
-      const errorHookCommand = vi.fn();
       const hooks = [
         {
           id: 'hook-error',
@@ -444,6 +497,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Test Feature',
         passes: true,
@@ -480,6 +534,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         passes: true,
         message: 'Done',
@@ -507,6 +562,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         featureName: 'Fallback Name',
         passes: true,
@@ -524,6 +580,204 @@ describe('EventHookService', () => {
     });
   });
 
+  describe('event mapping - feature_status_changed (non-auto-mode completion)', () => {
+    it('should trigger feature_success when status changes to verified', async () => {
+      mockFeatureLoader = createMockFeatureLoader({
+        'feat-1': { title: 'Manual Feature' },
+      });
+
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-1',
+        projectPath: '/test/project',
+        status: 'verified',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalled();
+      });
+
+      const storeCall = (mockEventHistoryService.storeEvent as ReturnType<typeof vi.fn>).mock
+        .calls[0][0];
+      expect(storeCall.trigger).toBe('feature_success');
+      expect(storeCall.featureName).toBe('Manual Feature');
+      expect(storeCall.passes).toBe(true);
+    });
+
+    it('should trigger feature_success when status changes to waiting_approval', async () => {
+      mockFeatureLoader = createMockFeatureLoader({
+        'feat-1': { title: 'Manual Feature' },
+      });
+
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-1',
+        projectPath: '/test/project',
+        status: 'waiting_approval',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalled();
+      });
+
+      const storeCall = (mockEventHistoryService.storeEvent as ReturnType<typeof vi.fn>).mock
+        .calls[0][0];
+      expect(storeCall.trigger).toBe('feature_success');
+      expect(storeCall.passes).toBe(true);
+      expect(storeCall.featureName).toBe('Manual Feature');
+    });
+
+    it('should NOT trigger hooks for non-completion status changes', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-1',
+        projectPath: '/test/project',
+        status: 'in_progress',
+      });
+
+      // Give it time to process
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(mockEventHistoryService.storeEvent).not.toHaveBeenCalled();
+    });
+
+    it('should NOT double-fire hooks when auto_mode_feature_complete already fired', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      // First: auto_mode_feature_complete fires (auto-mode path)
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
+        featureId: 'feat-1',
+        featureName: 'Auto Feature',
+        passes: true,
+        message: 'Feature completed',
+        projectPath: '/test/project',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(1);
+      });
+
+      // Then: feature_status_changed fires for the same feature
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-1',
+        projectPath: '/test/project',
+        status: 'verified',
+      });
+
+      // Give it time to process
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // Should still only have been called once (from auto_mode_feature_complete)
+      expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it('should NOT double-fire hooks when auto_mode_error already fired for feature', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      // First: auto_mode_error fires for a feature
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'auto_mode_error',
+        featureId: 'feat-1',
+        error: 'Something failed',
+        errorType: 'execution',
+        projectPath: '/test/project',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(1);
+      });
+
+      // Then: feature_status_changed fires for the same feature (e.g., reset to backlog)
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-1',
+        projectPath: '/test/project',
+        status: 'verified', // unlikely after error, but tests the dedup
+      });
+
+      // Give it time to process
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // Should still only have been called once
+      expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it('should fire hooks for different features independently', async () => {
+      service.initialize(
+        mockEmitter,
+        mockSettingsService,
+        mockEventHistoryService,
+        mockFeatureLoader
+      );
+
+      // Auto-mode completion for feat-1
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
+        featureId: 'feat-1',
+        passes: true,
+        message: 'Done',
+        projectPath: '/test/project',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(1);
+      });
+
+      // Manual completion for feat-2 (different feature)
+      mockEmitter.simulateEvent('auto-mode:event', {
+        type: 'feature_status_changed',
+        featureId: 'feat-2',
+        projectPath: '/test/project',
+        status: 'verified',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockEventHistoryService.storeEvent).toHaveBeenCalledTimes(2);
+      });
+
+      // feat-2 should have triggered feature_success
+      const secondCall = (mockEventHistoryService.storeEvent as ReturnType<typeof vi.fn>).mock
+        .calls[1][0];
+      expect(secondCall.trigger).toBe('feature_success');
+      expect(secondCall.featureId).toBe('feat-2');
+    });
+  });
+
   describe('error context for error events', () => {
     it('should use payload.error when available for error triggers', async () => {
       service.initialize(
@@ -561,6 +815,7 @@ describe('EventHookService', () => {
 
       mockEmitter.simulateEvent('auto-mode:event', {
         type: 'auto_mode_feature_complete',
+        executionMode: 'auto',
         featureId: 'feat-1',
         passes: false,
         message: 'Feature stopped by user',

apps/server/tests/unit/services/execution-service.test.ts

@@ -34,6 +34,7 @@ import { getFeatureDir } from '@automaker/platform';
 import {
   getPromptCustomization,
   getAutoLoadClaudeMdSetting,
+  getUseClaudeCodeSystemPromptSetting,
   filterClaudeMdFromContext,
 } from '../../../src/lib/settings-helpers.js';
 import { extractSummary } from '../../../src/services/spec-parser.js';
@@ -67,6 +68,7 @@ vi.mock('../../../src/lib/settings-helpers.js', () => ({
     },
   }),
   getAutoLoadClaudeMdSetting: vi.fn().mockResolvedValue(true),
+  getUseClaudeCodeSystemPromptSetting: vi.fn().mockResolvedValue(true),
   filterClaudeMdFromContext: vi.fn().mockReturnValue('context prompt'),
 }));
 
@@ -209,7 +211,14 @@ describe('execution-service.ts', () => {
     });
 
     // Default mocks for secureFs
-    vi.mocked(secureFs.readFile).mockResolvedValue('Agent output content');
+    // Include tool usage markers to simulate meaningful agent output.
+    // The execution service checks for '🔧 Tool:' markers and minimum
+    // output length to determine if the agent did real work.
+    vi.mocked(secureFs.readFile).mockResolvedValue(
+      'Starting implementation...\n\n🔧 Tool: Read\nInput: {"file_path": "/src/index.ts"}\n\n' +
+        '🔧 Tool: Edit\nInput: {"file_path": "/src/index.ts", "old_string": "foo", "new_string": "bar"}\n\n' +
+        'Implementation complete. Updated the code as requested.'
+    );
     vi.mocked(secureFs.access).mockResolvedValue(undefined);
 
     // Re-setup platform mocks
@@ -230,6 +239,7 @@ describe('execution-service.ts', () => {
       },
     } as Awaited<ReturnType<typeof getPromptCustomization>>);
     vi.mocked(getAutoLoadClaudeMdSetting).mockResolvedValue(true);
+    vi.mocked(getUseClaudeCodeSystemPromptSetting).mockResolvedValue(true);
     vi.mocked(filterClaudeMdFromContext).mockReturnValue('context prompt');
 
     // Re-setup spec-parser mock
@@ -1266,6 +1276,34 @@ describe('execution-service.ts', () => {
 
       expect(mockConcurrencyManager.release).toHaveBeenCalledWith('feature-1', { force: true });
     });
+
+    it('immediately updates feature status to interrupted before subprocess terminates', async () => {
+      const runningFeature = createRunningFeature('feature-1');
+      vi.mocked(mockConcurrencyManager.getRunningFeature).mockReturnValue(runningFeature);
+
+      await service.stopFeature('feature-1');
+
+      // Should update to 'interrupted' immediately so the UI reflects the stop
+      // without waiting for the CLI subprocess to fully terminate
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'interrupted'
+      );
+    });
+
+    it('still aborts and releases even if status update fails', async () => {
+      const runningFeature = createRunningFeature('feature-1');
+      const abortSpy = vi.spyOn(runningFeature.abortController, 'abort');
+      vi.mocked(mockConcurrencyManager.getRunningFeature).mockReturnValue(runningFeature);
+      vi.mocked(mockUpdateFeatureStatusFn).mockRejectedValueOnce(new Error('disk error'));
+
+      const result = await service.stopFeature('feature-1');
+
+      expect(result).toBe(true);
+      expect(abortSpy).toHaveBeenCalled();
+      expect(mockConcurrencyManager.release).toHaveBeenCalledWith('feature-1', { force: true });
+    });
   });
 
   describe('worktree resolution', () => {
@@ -1402,4 +1440,439 @@ describe('execution-service.ts', () => {
       );
     });
   });
+
+  describe('executeFeature - agent output validation', () => {
+    // Helper to generate realistic agent output with tool markers
+    const makeAgentOutput = (toolCount: number, extraText = ''): string => {
+      let output = 'Starting implementation...\n\n';
+      for (let i = 0; i < toolCount; i++) {
+        output += `🔧 Tool: Edit\nInput: {"file_path": "/src/file${i}.ts", "old_string": "old${i}", "new_string": "new${i}"}\n\n`;
+      }
+      output += `Implementation complete. ${extraText}`;
+      return output;
+    };
+
+    const createServiceWithMocks = () => {
+      return new ExecutionService(
+        mockEventBus,
+        mockConcurrencyManager,
+        mockWorktreeResolver,
+        mockSettingsService,
+        mockRunAgentFn,
+        mockExecutePipelineFn,
+        mockUpdateFeatureStatusFn,
+        mockLoadFeatureFn,
+        mockGetPlanningPromptPrefixFn,
+        mockSaveFeatureSummaryFn,
+        mockRecordLearningsFn,
+        mockContextExistsFn,
+        mockResumeFeatureFn,
+        mockTrackFailureFn,
+        mockSignalPauseFn,
+        mockRecordSuccessFn,
+        mockSaveExecutionStateFn,
+        mockLoadContextFilesFn
+      );
+    };
+
+    it('sets verified when agent output has tool usage and sufficient length', async () => {
+      const output = makeAgentOutput(3, 'Updated authentication module with new login flow.');
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      await service.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'verified'
+      );
+    });
+
+    it('sets waiting_approval when agent output is empty', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('sets waiting_approval when agent output has no tool usage markers', async () => {
+      // Long output but no tool markers - agent printed text but didn't use tools
+      const longOutputNoTools = 'I analyzed the codebase and found several issues. '.repeat(20);
+      vi.mocked(secureFs.readFile).mockResolvedValue(longOutputNoTools);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('sets waiting_approval when agent output has tool markers but is too short', async () => {
+      // Has a tool marker but total output is under 200 chars
+      const shortWithTool = '🔧 Tool: Read\nInput: {"file_path": "/src/index.ts"}\nDone.';
+      expect(shortWithTool.trim().length).toBeLessThan(200);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(shortWithTool);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('sets waiting_approval when agent output file is missing (ENOENT)', async () => {
+      vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('sets waiting_approval when agent output is only whitespace', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('   \n\n\t  \n  ');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('sets verified when output is exactly at the 200 char threshold with tool usage', async () => {
+      // Create output that's exactly 200 chars trimmed with tool markers
+      const toolMarker = '🔧 Tool: Edit\nInput: {"file_path": "/src/index.ts"}\n';
+      const padding = 'x'.repeat(200 - toolMarker.length);
+      const output = toolMarker + padding;
+      expect(output.trim().length).toBeGreaterThanOrEqual(200);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'verified'
+      );
+    });
+
+    it('sets waiting_approval when output is 199 chars with tool usage (below threshold)', async () => {
+      const toolMarker = '🔧 Tool: Read\n';
+      const padding = 'x'.repeat(199 - toolMarker.length);
+      const output = toolMarker + padding;
+      expect(output.trim().length).toBe(199);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('skipTests always takes priority over output validation', async () => {
+      // Meaningful output with tool usage - would normally be 'verified'
+      const output = makeAgentOutput(5, 'All changes applied successfully.');
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      mockLoadFeatureFn = vi.fn().mockResolvedValue({ ...testFeature, skipTests: true });
+      const svc = createServiceWithMocks();
+
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // skipTests=true always means waiting_approval regardless of output quality
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('skipTests with empty output still results in waiting_approval', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+
+      mockLoadFeatureFn = vi.fn().mockResolvedValue({ ...testFeature, skipTests: true });
+      const svc = createServiceWithMocks();
+
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('still records success even when output validation fails', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // recordSuccess should still be called - the agent ran without errors
+      expect(mockRecordSuccessFn).toHaveBeenCalled();
+    });
+
+    it('still extracts summary when output has content but no tool markers', async () => {
+      const outputNoTools = 'A '.repeat(150); // > 200 chars but no tool markers
+      vi.mocked(secureFs.readFile).mockResolvedValue(outputNoTools);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Summary extraction still runs even though status is waiting_approval
+      expect(extractSummary).toHaveBeenCalledWith(outputNoTools);
+      expect(mockSaveFeatureSummaryFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'Test summary'
+      );
+    });
+
+    it('emits feature_complete with passes=true even when output validation routes to waiting_approval', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1', false, true);
+
+      // The agent ran without error - it's still a "pass" from the execution perspective
+      expect(mockEventBus.emitAutoModeEvent).toHaveBeenCalledWith(
+        'auto_mode_feature_complete',
+        expect.objectContaining({ passes: true })
+      );
+    });
+
+    it('handles realistic Cursor CLI output that exits quickly', async () => {
+      // Simulates a Cursor CLI that prints a brief message and exits
+      const cursorQuickExit = 'Task received. Processing...\nResult: completed successfully.';
+      expect(cursorQuickExit.includes('🔧 Tool:')).toBe(false);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(cursorQuickExit);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // No tool usage = waiting_approval
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('handles realistic Claude SDK output with multiple tool uses', async () => {
+      // Simulates a Claude SDK agent that does real work
+      const claudeOutput =
+        "I'll implement the requested feature.\n\n" +
+        '🔧 Tool: Read\nInput: {"file_path": "/src/components/App.tsx"}\n\n' +
+        'I can see the existing component structure. Let me modify it.\n\n' +
+        '🔧 Tool: Edit\nInput: {"file_path": "/src/components/App.tsx", "old_string": "const App = () => {", "new_string": "const App: React.FC = () => {"}\n\n' +
+        '🔧 Tool: Write\nInput: {"file_path": "/src/components/NewFeature.tsx"}\n\n' +
+        "I've created the new component and updated the existing one. The feature is now implemented with proper TypeScript types.";
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(claudeOutput);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Real work = verified
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'verified'
+      );
+    });
+
+    it('reads agent output from the correct path with utf-8 encoding', async () => {
+      const output = makeAgentOutput(2, 'Done with changes.');
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Verify readFile was called with the correct path derived from getFeatureDir
+      expect(secureFs.readFile).toHaveBeenCalledWith(
+        '/test/project/.automaker/features/feature-1/agent-output.md',
+        'utf-8'
+      );
+    });
+
+    it('completion message includes auto-verified when status is verified', async () => {
+      const output = makeAgentOutput(3, 'All changes applied.');
+      vi.mocked(secureFs.readFile).mockResolvedValue(output);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1', false, true);
+
+      expect(mockEventBus.emitAutoModeEvent).toHaveBeenCalledWith(
+        'auto_mode_feature_complete',
+        expect.objectContaining({
+          message: expect.stringContaining('auto-verified'),
+        })
+      );
+    });
+
+    it('completion message does NOT include auto-verified when status is waiting_approval', async () => {
+      // Empty output → waiting_approval
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1', false, true);
+
+      const completeCall = vi
+        .mocked(mockEventBus.emitAutoModeEvent)
+        .mock.calls.find((call) => call[0] === 'auto_mode_feature_complete');
+      expect(completeCall).toBeDefined();
+      expect((completeCall![1] as { message: string }).message).not.toContain('auto-verified');
+    });
+
+    it('uses same agentOutput for both status determination and summary extraction', async () => {
+      // Specific output that is long enough with tool markers (verified path)
+      // AND has content for summary extraction
+      const specificOutput =
+        '🔧 Tool: Read\nReading file...\n🔧 Tool: Edit\nEditing file...\n' +
+        'The implementation is complete. Here is a detailed description of what was done. '.repeat(
+          3
+        );
+      vi.mocked(secureFs.readFile).mockResolvedValue(specificOutput);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Status should be verified (has tools + long enough)
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'verified'
+      );
+      // extractSummary should receive the exact same output
+      expect(extractSummary).toHaveBeenCalledWith(specificOutput);
+      // recordLearnings should also receive the same output
+      expect(mockRecordLearningsFn).toHaveBeenCalledWith(
+        '/test/project',
+        testFeature,
+        specificOutput
+      );
+    });
+
+    it('does not call recordMemoryUsage when output is empty and memoryFiles is empty', async () => {
+      vi.mocked(secureFs.readFile).mockResolvedValue('');
+      const { recordMemoryUsage } = await import('@automaker/utils');
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // With empty output and empty memoryFiles, recordMemoryUsage should not be called
+      expect(recordMemoryUsage).not.toHaveBeenCalled();
+    });
+
+    it('handles output with special unicode characters correctly', async () => {
+      // Output with various unicode but includes tool markers
+      const unicodeOutput =
+        '🔧 Tool: Read\n' +
+        '🔧 Tool: Edit\n' +
+        'Añadiendo función de búsqueda con caracteres especiales: ñ, ü, ö, é, 日本語テスト. ' +
+        'Die Änderungen wurden erfolgreich implementiert. '.repeat(3);
+      vi.mocked(secureFs.readFile).mockResolvedValue(unicodeOutput);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Should still detect tool markers and sufficient length
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'verified'
+      );
+    });
+
+    it('treats output with only newlines and spaces around tool marker as insufficient', async () => {
+      // Has tool marker but surrounded by whitespace, total trimmed < 200
+      const sparseOutput = '\n\n  🔧 Tool: Read  \n\n';
+      expect(sparseOutput.trim().length).toBeLessThan(200);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(sparseOutput);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('detects tool marker substring correctly (partial match like "🔧 Tools:" does not count)', async () => {
+      // Output with a similar but not exact marker - "🔧 Tools:" instead of "🔧 Tool:"
+      const wrongMarker = '🔧 Tools: Read\n🔧 Tools: Edit\n' + 'Implementation done. '.repeat(20);
+      expect(wrongMarker.includes('🔧 Tool:')).toBe(false);
+
+      vi.mocked(secureFs.readFile).mockResolvedValue(wrongMarker);
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // "🔧 Tools:" is not the same as "🔧 Tool:" - should be waiting_approval
+      expect(mockUpdateFeatureStatusFn).toHaveBeenCalledWith(
+        '/test/project',
+        'feature-1',
+        'waiting_approval'
+      );
+    });
+
+    it('pipeline merge_conflict status short-circuits before output validation', async () => {
+      // Set up pipeline that results in merge_conflict
+      vi.mocked(pipelineService.getPipelineConfig).mockResolvedValue({
+        version: 1,
+        steps: [{ id: 'step-1', name: 'Step 1', order: 1, instructions: 'Do step 1' }] as any,
+      });
+
+      // After pipeline, loadFeature returns merge_conflict status
+      let loadCallCount = 0;
+      mockLoadFeatureFn = vi.fn().mockImplementation(() => {
+        loadCallCount++;
+        if (loadCallCount === 1) return testFeature; // initial load
+        // All subsequent loads (task check + pipeline refresh) return merge_conflict
+        return { ...testFeature, status: 'merge_conflict' };
+      });
+
+      const svc = createServiceWithMocks();
+      await svc.executeFeature('/test/project', 'feature-1');
+
+      // Should NOT have called updateFeatureStatusFn with 'verified' or 'waiting_approval'
+      // because pipeline merge_conflict short-circuits the method
+      const statusCalls = vi
+        .mocked(mockUpdateFeatureStatusFn)
+        .mock.calls.filter((call) => call[2] === 'verified' || call[2] === 'waiting_approval');
+      // The only non-in_progress status call should be absent since merge_conflict returns early
+      expect(statusCalls.length).toBe(0);
+    });
+  });
 });

apps/server/tests/unit/services/pipeline-orchestrator.test.ts

@@ -57,6 +57,7 @@ vi.mock('../../../src/lib/settings-helpers.js', () => ({
     },
   }),
   getAutoLoadClaudeMdSetting: vi.fn().mockResolvedValue(true),
+  getUseClaudeCodeSystemPromptSetting: vi.fn().mockResolvedValue(true),
   filterClaudeMdFromContext: vi.fn().mockReturnValue('context prompt'),
 }));
 

apps/server/tests/unit/services/settings-service.test.ts

@@ -740,8 +740,11 @@ describe('settings-service.ts', () => {
       // Legacy fields should be migrated to phaseModels with canonical IDs
       expect(settings.phaseModels.enhancementModel).toEqual({ model: 'claude-haiku' });
       expect(settings.phaseModels.validationModel).toEqual({ model: 'claude-opus' });
-      // Other fields should use defaults (canonical IDs)
-      expect(settings.phaseModels.specGenerationModel).toEqual({ model: 'claude-opus' });
+      // Other fields should use defaults (canonical IDs) - specGenerationModel includes thinkingLevel from DEFAULT_PHASE_MODELS
+      expect(settings.phaseModels.specGenerationModel).toEqual({
+        model: 'claude-opus',
+        thinkingLevel: 'adaptive',
+      });
     });
 
     it('should use default phase models when none are configured', async () => {
@@ -755,10 +758,13 @@ describe('settings-service.ts', () => {
 
       const settings = await settingsService.getGlobalSettings();
 
-      // Should use DEFAULT_PHASE_MODELS (with canonical IDs)
+      // Should use DEFAULT_PHASE_MODELS (with canonical IDs) - specGenerationModel includes thinkingLevel from DEFAULT_PHASE_MODELS
       expect(settings.phaseModels.enhancementModel).toEqual({ model: 'claude-sonnet' });
       expect(settings.phaseModels.fileDescriptionModel).toEqual({ model: 'claude-haiku' });
-      expect(settings.phaseModels.specGenerationModel).toEqual({ model: 'claude-opus' });
+      expect(settings.phaseModels.specGenerationModel).toEqual({
+        model: 'claude-opus',
+        thinkingLevel: 'adaptive',
+      });
     });
 
     it('should deep merge phaseModels on update', async () => {

apps/ui/nginx.conf

@@ -21,6 +21,8 @@ server {
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_buffering off;
+        proxy_read_timeout 3600s;
     }
 
     location / {

apps/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automaker/ui",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "An autonomous AI development studio that helps you build software faster using AI-powered agents",
   "homepage": "https://github.com/AutoMaker-Org/automaker",
   "repository": {
@@ -56,6 +56,7 @@
     "@codemirror/lang-xml": "6.1.0",
     "@codemirror/language": "^6.12.1",
     "@codemirror/legacy-modes": "^6.5.2",
+    "@codemirror/merge": "^6.12.0",
     "@codemirror/search": "^6.6.0",
     "@codemirror/state": "^6.5.4",
     "@codemirror/theme-one-dark": "6.1.3",

apps/ui/playwright.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig, devices } from '@playwright/test';
 
-const port = process.env.TEST_PORT || 3007;
-const serverPort = process.env.TEST_SERVER_PORT || 3008;
+const port = process.env.TEST_PORT || 3107;
+const serverPort = process.env.TEST_SERVER_PORT || 3108;
 const reuseServer = process.env.TEST_REUSE_SERVER === 'true';
 const useExternalBackend = !!process.env.VITE_SERVER_URL;
 // Always use mock agent for tests (disables rate limiting, uses mock Claude responses)
@@ -19,6 +19,7 @@ export default defineConfig({
     baseURL: `http://localhost:${port}`,
     trace: 'on-failure',
     screenshot: 'only-on-failure',
+    serviceWorkers: 'block',
   },
   // Global setup - authenticate before each test
   globalSetup: require.resolve('./tests/global-setup.ts'),
@@ -69,6 +70,10 @@ export default defineConfig({
             timeout: 120000,
             env: {
               ...process.env,
+              // Must set AUTOMAKER_WEB_PORT to match the port Playwright waits for
+              AUTOMAKER_WEB_PORT: String(port),
+              // Must set AUTOMAKER_SERVER_PORT so Vite proxy forwards to the correct backend port
+              AUTOMAKER_SERVER_PORT: String(serverPort),
               VITE_SKIP_SETUP: 'true',
               // Always skip electron plugin during tests - prevents duplicate server spawning
               VITE_SKIP_ELECTRON: 'true',

apps/ui/scripts/kill-test-servers.mjs

@@ -8,10 +8,11 @@ import { promisify } from 'util';
 
 const execAsync = promisify(exec);
 
-const SERVER_PORT = process.env.TEST_SERVER_PORT || 3008;
-const UI_PORT = process.env.TEST_PORT || 3007;
+const SERVER_PORT = process.env.TEST_SERVER_PORT || 3108;
+const UI_PORT = process.env.TEST_PORT || 3107;
 const USE_EXTERNAL_SERVER = !!process.env.VITE_SERVER_URL;
-
+console.log(`[KillTestServers] SERVER_PORT ${SERVER_PORT}`);
+console.log(`[KillTestServers] UI_PORT ${UI_PORT}`);
 async function killProcessOnPort(port) {
   try {
     const hasLsof = await execAsync('command -v lsof').then(

apps/ui/src/components/dialogs/pr-comment-resolution-dialog.tsx

@@ -45,7 +45,7 @@ import { toast } from 'sonner';
 import type { PRReviewComment } from '@/lib/electron';
 import type { Feature } from '@/store/app-store';
 import type { PhaseModelEntry } from '@automaker/types';
-import { supportsReasoningEffort, isAdaptiveThinkingModel } from '@automaker/types';
+import { supportsReasoningEffort, normalizeThinkingLevelForModel } from '@automaker/types';
 import { resolveModelString } from '@automaker/model-resolver';
 import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults';
 
@@ -590,20 +590,10 @@ export function PRCommentResolutionDialog({
   const wasOpenRef = useRef(false);
 
   const handleModelChange = useCallback((entry: PhaseModelEntry) => {
-    // Normalize thinking level when switching between adaptive and non-adaptive models
-    const isNewModelAdaptive =
-      typeof entry.model === 'string' && isAdaptiveThinkingModel(entry.model);
-    const currentLevel = entry.thinkingLevel || 'none';
+    const modelId = typeof entry.model === 'string' ? entry.model : '';
+    const normalizedThinkingLevel = normalizeThinkingLevelForModel(modelId, entry.thinkingLevel);
 
-    if (isNewModelAdaptive && currentLevel !== 'none' && currentLevel !== 'adaptive') {
-      // Switching TO an adaptive model with a manual level -> auto-switch to 'adaptive'
-      setModelEntry({ ...entry, thinkingLevel: 'adaptive' });
-    } else if (!isNewModelAdaptive && currentLevel === 'adaptive') {
-      // Switching FROM an adaptive model with adaptive -> auto-switch to 'high'
-      setModelEntry({ ...entry, thinkingLevel: 'high' });
-    } else {
-      setModelEntry(entry);
-    }
+    setModelEntry({ ...entry, thinkingLevel: normalizedThinkingLevel });
   }, []);
 
   // Fetch PR review comments

apps/ui/src/components/layout/project-switcher/project-switcher.tsx

@@ -40,14 +40,12 @@ export function ProjectSwitcher() {
   const location = useLocation();
   const { hideWiki } = SIDEBAR_FEATURE_FLAGS;
   const isWikiActive = location.pathname === '/wiki';
-  const {
-    projects,
-    currentProject,
-    setCurrentProject,
-    upsertAndSetCurrentProject,
-    specCreatingForProject,
-    setSpecCreatingForProject,
-  } = useAppStore();
+  const projects = useAppStore((s) => s.projects);
+  const currentProject = useAppStore((s) => s.currentProject);
+  const setCurrentProject = useAppStore((s) => s.setCurrentProject);
+  const upsertAndSetCurrentProject = useAppStore((s) => s.upsertAndSetCurrentProject);
+  const specCreatingForProject = useAppStore((s) => s.specCreatingForProject);
+  const setSpecCreatingForProject = useAppStore((s) => s.setSpecCreatingForProject);
   const [contextMenuProject, setContextMenuProject] = useState<Project | null>(null);
   const [contextMenuPosition, setContextMenuPosition] = useState<{ x: number; y: number } | null>(
     null
@@ -104,6 +102,10 @@ export function ProjectSwitcher() {
 
   const handleProjectClick = useCallback(
     async (project: Project) => {
+      if (project.id === currentProject?.id) {
+        navigate({ to: '/board' });
+        return;
+      }
       try {
         // Ensure .automaker directory structure exists before switching
         await initializeProject(project.path);
@@ -124,7 +126,7 @@ export function ProjectSwitcher() {
         navigate({ to: '/board' });
       });
     },
-    [setCurrentProject, navigate]
+    [currentProject?.id, setCurrentProject, navigate]
   );
 
   const handleNewProject = () => {

apps/ui/src/components/layout/sidebar/components/project-selector-with-options.tsx

@@ -1,4 +1,4 @@
-import { useCallback } from 'react';
+import { useCallback, startTransition } from 'react';
 import {
   Folder,
   ChevronDown,
@@ -78,21 +78,22 @@ export function ProjectSelectorWithOptions({
   setShowDeleteProjectDialog,
   setShowRemoveFromAutomakerDialog,
 }: ProjectSelectorWithOptionsProps) {
-  const {
-    projects,
-    currentProject,
-    projectHistory,
-    setCurrentProject,
-    reorderProjects,
-    cyclePrevProject,
-    cycleNextProject,
-    clearProjectHistory,
-  } = useAppStore();
+  const projects = useAppStore((s) => s.projects);
+  const currentProject = useAppStore((s) => s.currentProject);
+  const projectHistory = useAppStore((s) => s.projectHistory);
+  const setCurrentProject = useAppStore((s) => s.setCurrentProject);
+  const reorderProjects = useAppStore((s) => s.reorderProjects);
+  const cyclePrevProject = useAppStore((s) => s.cyclePrevProject);
+  const cycleNextProject = useAppStore((s) => s.cycleNextProject);
+  const clearProjectHistory = useAppStore((s) => s.clearProjectHistory);
 
   const shortcuts = useKeyboardShortcutsConfig();
   // Wrap setCurrentProject to ensure .automaker is initialized before switching
   const setCurrentProjectWithInit = useCallback(
     async (p: Project) => {
+      if (p.id === currentProject?.id) {
+        return;
+      }
       try {
         // Ensure .automaker directory structure exists before switching
         await initializeProject(p.path);
@@ -101,9 +102,12 @@ export function ProjectSelectorWithOptions({
         // Continue with switch even if initialization fails -
         // the project may already be initialized
       }
-      setCurrentProject(p);
+      // Defer project switch update to avoid synchronous render cascades.
+      startTransition(() => {
+        setCurrentProject(p);
+      });
     },
-    [setCurrentProject]
+    [currentProject?.id, setCurrentProject]
   );
 
   const {

apps/ui/src/components/layout/sidebar/components/sidebar-header.tsx

@@ -1,4 +1,4 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, startTransition } from 'react';
 import { useNavigate } from '@tanstack/react-router';
 import { ChevronsUpDown, Folder, Plus, FolderOpen, LogOut } from 'lucide-react';
 import * as LucideIcons from 'lucide-react';
@@ -6,6 +6,7 @@ import type { LucideIcon } from 'lucide-react';
 import { cn, isMac } from '@/lib/utils';
 import { formatShortcut } from '@/store/app-store';
 import { isElectron, type Project } from '@/lib/electron';
+import { initializeProject } from '@/lib/project-init';
 import { MACOS_ELECTRON_TOP_PADDING_CLASS } from '../constants';
 import { getAuthenticatedImageUrl } from '@/lib/api-fetch';
 import { useAppStore } from '@/store/app-store';
@@ -36,7 +37,8 @@ export function SidebarHeader({
   setShowRemoveFromAutomakerDialog,
 }: SidebarHeaderProps) {
   const navigate = useNavigate();
-  const { projects, setCurrentProject } = useAppStore();
+  const projects = useAppStore((s) => s.projects);
+  const setCurrentProject = useAppStore((s) => s.setCurrentProject);
   const [dropdownOpen, setDropdownOpen] = useState(false);
 
   const handleLogoClick = useCallback(() => {
@@ -44,12 +46,29 @@ export function SidebarHeader({
   }, [navigate]);
 
   const handleProjectSelect = useCallback(
-    (project: Project) => {
-      setCurrentProject(project);
-      setDropdownOpen(false);
-      navigate({ to: '/board' });
+    async (project: Project) => {
+      if (project.id === currentProject?.id) {
+        setDropdownOpen(false);
+        navigate({ to: '/board' });
+        return;
+      }
+      try {
+        // Ensure .automaker directory structure exists before switching
+        await initializeProject(project.path);
+      } catch (error) {
+        console.error('Failed to initialize project during switch:', error);
+        // Continue with switch even if initialization fails -
+        // the project may already be initialized
+      }
+
+      // Batch project switch + navigation to prevent multi-render cascades.
+      startTransition(() => {
+        setCurrentProject(project);
+        setDropdownOpen(false);
+        navigate({ to: '/board' });
+      });
     },
-    [setCurrentProject, navigate]
+    [currentProject?.id, setCurrentProject, navigate]
   );
 
   const getIconComponent = (project: Project): LucideIcon => {

apps/ui/src/components/layout/sidebar/sidebar.tsx

@@ -1,4 +1,4 @@
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, startTransition } from 'react';
 import { createLogger } from '@automaker/utils/logger';
 import { useNavigate, useLocation } from '@tanstack/react-router';
 import { PanelLeftClose, ChevronDown } from 'lucide-react';
@@ -281,6 +281,27 @@ export function Sidebar() {
   // Register keyboard shortcuts
   useKeyboardShortcuts(navigationShortcuts);
 
+  const switchProjectSafely = useCallback(
+    async (targetProject: Project) => {
+      // Ensure .automaker directory structure exists before switching
+      const initResult = await initializeProject(targetProject.path);
+      if (!initResult.success) {
+        logger.error('Failed to initialize project during switch:', initResult.error);
+        toast.warning(
+          `Could not fully initialize project: ${initResult.error ?? 'Unknown error'}. Some features may not work correctly.`
+        );
+        // Continue with switch despite init failure — project may already be partially initialized
+      }
+
+      // Batch project switch + navigation to prevent multi-render cascades.
+      startTransition(() => {
+        setCurrentProject(targetProject);
+        navigate({ to: '/board' });
+      });
+    },
+    [setCurrentProject, navigate]
+  );
+
   // Keyboard shortcuts for project switching (1-9, 0)
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {
@@ -305,15 +326,14 @@ export function Sidebar() {
       if (projectIndex !== null && projectIndex < projects.length) {
         const targetProject = projects[projectIndex];
         if (targetProject && targetProject.id !== currentProject?.id) {
-          setCurrentProject(targetProject);
-          navigate({ to: '/board' });
+          void switchProjectSafely(targetProject);
         }
       }
     };
 
     window.addEventListener('keydown', handleKeyDown);
     return () => window.removeEventListener('keydown', handleKeyDown);
-  }, [projects, currentProject, setCurrentProject, navigate]);
+  }, [projects, currentProject, switchProjectSafely]);
 
   const isActiveRoute = (id: string) => {
     const routePath = id === 'welcome' ? '/' : `/${id}`;

apps/ui/src/components/session-manager.tsx

@@ -310,6 +310,8 @@ export function SessionManager({
         });
         if (activeSessionsList.length > 0) {
           onSelectSession(activeSessionsList[0].id);
+        } else {
+          onSelectSession(null);
         }
       }
     }

apps/ui/src/components/shared/use-model-override.ts

@@ -29,8 +29,13 @@ export interface UseModelOverrideResult {
 
 /**
  * Normalize PhaseModelEntry or string to PhaseModelEntry
+ * Handles undefined/null gracefully (e.g., when phaseModels from server settings
+ * is missing a recently-added phase key)
  */
-function normalizeEntry(entry: PhaseModelEntry | string): PhaseModelEntry {
+function normalizeEntry(entry: PhaseModelEntry | string | undefined | null): PhaseModelEntry {
+  if (!entry) {
+    return { model: 'claude-sonnet' as ModelId };
+  }
   if (typeof entry === 'string') {
     return { model: entry as ModelId };
   }

apps/ui/src/components/ui/codemirror-diff-view.tsx

@@ -0,0 +1,220 @@
+/**
+ * CodeMirror-based unified diff viewer.
+ *
+ * Uses @codemirror/merge's `unifiedMergeView` extension to display a
+ * syntax-highlighted inline diff between the original and modified file content.
+ * The viewer is read-only and collapses unchanged regions.
+ */
+
+import { useMemo, useRef, useEffect } from 'react';
+import { EditorView } from '@codemirror/view';
+import { EditorState, type Extension } from '@codemirror/state';
+import { HighlightStyle, syntaxHighlighting } from '@codemirror/language';
+import { tags as t } from '@lezer/highlight';
+import { unifiedMergeView } from '@codemirror/merge';
+import { getLanguageExtension } from '@/lib/codemirror-languages';
+import { reconstructFilesFromDiff } from '@/lib/diff-utils';
+import { cn } from '@/lib/utils';
+
+// Reuse the same syntax highlighting from the code editor
+const syntaxColors = HighlightStyle.define([
+  { tag: t.keyword, color: 'var(--chart-4, oklch(0.7 0.15 280))' },
+  { tag: t.string, color: 'var(--chart-1, oklch(0.646 0.222 41.116))' },
+  { tag: t.number, color: 'var(--chart-3, oklch(0.7 0.15 150))' },
+  { tag: t.bool, color: 'var(--chart-4, oklch(0.7 0.15 280))' },
+  { tag: t.null, color: 'var(--chart-4, oklch(0.7 0.15 280))' },
+  { tag: t.comment, color: 'var(--muted-foreground)', fontStyle: 'italic' },
+  { tag: t.propertyName, color: 'var(--chart-2, oklch(0.6 0.118 184.704))' },
+  { tag: t.variableName, color: 'var(--chart-2, oklch(0.6 0.118 184.704))' },
+  { tag: t.function(t.variableName), color: 'var(--primary)' },
+  { tag: t.typeName, color: 'var(--chart-5, oklch(0.65 0.2 30))' },
+  { tag: t.className, color: 'var(--chart-5, oklch(0.65 0.2 30))' },
+  { tag: t.definition(t.variableName), color: 'var(--chart-2, oklch(0.6 0.118 184.704))' },
+  { tag: t.operator, color: 'var(--muted-foreground)' },
+  { tag: t.bracket, color: 'var(--muted-foreground)' },
+  { tag: t.punctuation, color: 'var(--muted-foreground)' },
+  { tag: t.attributeName, color: 'var(--chart-5, oklch(0.65 0.2 30))' },
+  { tag: t.attributeValue, color: 'var(--chart-1, oklch(0.646 0.222 41.116))' },
+  { tag: t.tagName, color: 'var(--chart-4, oklch(0.7 0.15 280))' },
+  { tag: t.heading, color: 'var(--foreground)', fontWeight: 'bold' },
+  { tag: t.emphasis, fontStyle: 'italic' },
+  { tag: t.strong, fontWeight: 'bold' },
+  { tag: t.link, color: 'var(--primary)', textDecoration: 'underline' },
+  { tag: t.content, color: 'var(--foreground)' },
+  { tag: t.regexp, color: 'var(--chart-1, oklch(0.646 0.222 41.116))' },
+  { tag: t.meta, color: 'var(--muted-foreground)' },
+]);
+
+const diffViewTheme = EditorView.theme(
+  {
+    '&': {
+      fontSize: '12px',
+      fontFamily:
+        'var(--font-mono, ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace)',
+      backgroundColor: 'var(--background)',
+      color: 'var(--foreground)',
+    },
+    '.cm-scroller': {
+      overflow: 'auto',
+      fontFamily:
+        'var(--font-mono, ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace)',
+    },
+    '.cm-content': {
+      padding: '0',
+      minHeight: 'auto',
+    },
+    '.cm-line': {
+      padding: '0 0.5rem',
+    },
+    '&.cm-focused': {
+      outline: 'none',
+    },
+    '.cm-gutters': {
+      backgroundColor: 'transparent',
+      color: 'var(--muted-foreground)',
+      border: 'none',
+      borderRight: '1px solid var(--border)',
+      paddingRight: '0.25rem',
+    },
+    '.cm-lineNumbers .cm-gutterElement': {
+      minWidth: '3rem',
+      textAlign: 'right',
+      paddingRight: '0.5rem',
+      fontSize: '11px',
+    },
+
+    // --- GitHub-style diff colors (dark mode) ---
+
+    // Added/changed lines: green background
+    '&.cm-merge-b .cm-changedLine': {
+      backgroundColor: 'rgba(46, 160, 67, 0.15)',
+    },
+    // Highlighted text within added/changed lines: stronger green
+    '&.cm-merge-b .cm-changedText': {
+      background: 'rgba(46, 160, 67, 0.4)',
+    },
+
+    // Deleted chunk container: red background
+    '.cm-deletedChunk': {
+      backgroundColor: 'rgba(248, 81, 73, 0.1)',
+      paddingLeft: '6px',
+    },
+    // Individual deleted lines within the chunk
+    '.cm-deletedChunk .cm-deletedLine': {
+      backgroundColor: 'rgba(248, 81, 73, 0.15)',
+    },
+    // Highlighted text within deleted lines: stronger red
+    '.cm-deletedChunk .cm-deletedText': {
+      background: 'rgba(248, 81, 73, 0.4)',
+    },
+    // Remove strikethrough from deleted text (GitHub doesn't use it)
+    '.cm-insertedLine, .cm-deletedLine, .cm-deletedLine del': {
+      textDecoration: 'none',
+    },
+
+    // Gutter markers for changed lines (green bar)
+    '&.cm-merge-b .cm-changedLineGutter': {
+      background: '#3fb950',
+    },
+    // Gutter markers for deleted lines (red bar)
+    '.cm-deletedLineGutter': {
+      background: '#f85149',
+    },
+
+    // Collapse button styling
+    '.cm-collapsedLines': {
+      color: 'var(--muted-foreground)',
+      backgroundColor: 'var(--muted)',
+      borderTop: '1px solid var(--border)',
+      borderBottom: '1px solid var(--border)',
+      cursor: 'pointer',
+      padding: '2px 8px',
+      fontSize: '11px',
+    },
+
+    // Selection styling
+    '&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection': {
+      backgroundColor: 'oklch(0.55 0.25 265 / 0.3)',
+    },
+  },
+  { dark: true }
+);
+
+interface CodeMirrorDiffViewProps {
+  /** The unified diff text for a single file */
+  fileDiff: string;
+  /** File path for language detection */
+  filePath: string;
+  /** Max height of the diff view (CSS value) */
+  maxHeight?: string;
+  className?: string;
+}
+
+export function CodeMirrorDiffView({
+  fileDiff,
+  filePath,
+  maxHeight = '400px',
+  className,
+}: CodeMirrorDiffViewProps) {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const viewRef = useRef<EditorView | null>(null);
+
+  const { oldContent, newContent } = useMemo(() => reconstructFilesFromDiff(fileDiff), [fileDiff]);
+
+  const extensions = useMemo(() => {
+    const exts: Extension[] = [
+      EditorView.darkTheme.of(true),
+      diffViewTheme,
+      syntaxHighlighting(syntaxColors),
+      EditorView.editable.of(false),
+      EditorState.readOnly.of(true),
+      EditorView.lineWrapping,
+      unifiedMergeView({
+        original: oldContent,
+        highlightChanges: true,
+        gutter: true,
+        syntaxHighlightDeletions: true,
+        mergeControls: false,
+        collapseUnchanged: { margin: 3, minSize: 4 },
+      }),
+    ];
+
+    const langExt = getLanguageExtension(filePath);
+    if (langExt) {
+      exts.push(langExt);
+    }
+
+    return exts;
+  }, [oldContent, filePath]);
+
+  useEffect(() => {
+    if (!containerRef.current) return;
+
+    // Clean up previous view
+    if (viewRef.current) {
+      viewRef.current.destroy();
+      viewRef.current = null;
+    }
+
+    const state = EditorState.create({
+      doc: newContent,
+      extensions,
+    });
+
+    const view = new EditorView({
+      state,
+      parent: containerRef.current,
+    });
+
+    viewRef.current = view;
+
+    return () => {
+      view.destroy();
+      viewRef.current = null;
+    };
+  }, [newContent, extensions]);
+
+  return (
+    <div ref={containerRef} className={cn('overflow-auto', className)} style={{ maxHeight }} />
+  );
+}

apps/ui/src/components/ui/git-diff-panel.tsx

@@ -17,10 +17,13 @@ import {
 } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { TruncatedFilePath } from '@/components/ui/truncated-file-path';
+import { CodeMirrorDiffView } from '@/components/ui/codemirror-diff-view';
 import { Button } from './button';
 import { useWorktreeDiffs, useGitDiffs } from '@/hooks/queries';
 import { getElectronAPI } from '@/lib/electron';
 import { toast } from 'sonner';
+import { parseDiff, splitDiffByFile } from '@/lib/diff-utils';
+import type { ParsedFileDiff } from '@/lib/diff-utils';
 import type { FileStatus, MergeStateInfo } from '@/types/electron';
 
 interface GitDiffPanelProps {
@@ -37,23 +40,6 @@ interface GitDiffPanelProps {
   worktreePath?: string;
 }
 
-interface ParsedDiffHunk {
-  header: string;
-  lines: {
-    type: 'context' | 'addition' | 'deletion' | 'header';
-    content: string;
-    lineNumber?: { old?: number; new?: number };
-  }[];
-}
-
-interface ParsedFileDiff {
-  filePath: string;
-  hunks: ParsedDiffHunk[];
-  isNew?: boolean;
-  isDeleted?: boolean;
-  isRenamed?: boolean;
-}
-
 const getFileIcon = (status: string) => {
   switch (status) {
     case 'A':
@@ -129,174 +115,6 @@ function getStagingState(file: FileStatus): 'staged' | 'unstaged' | 'partial' {
   return 'unstaged';
 }
 
-/**
- * Parse unified diff format into structured data
- */
-function parseDiff(diffText: string): ParsedFileDiff[] {
-  if (!diffText) return [];
-
-  const files: ParsedFileDiff[] = [];
-  const lines = diffText.split('\n');
-  let currentFile: ParsedFileDiff | null = null;
-  let currentHunk: ParsedDiffHunk | null = null;
-  let oldLineNum = 0;
-  let newLineNum = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-
-    // New file diff
-    if (line.startsWith('diff --git')) {
-      if (currentFile) {
-        if (currentHunk) {
-          currentFile.hunks.push(currentHunk);
-        }
-        files.push(currentFile);
-      }
-      // Extract file path from diff header
-      const match = line.match(/diff --git a\/(.*?) b\/(.*)/);
-      currentFile = {
-        filePath: match ? match[2] : 'unknown',
-        hunks: [],
-      };
-      currentHunk = null;
-      continue;
-    }
-
-    // New file indicator
-    if (line.startsWith('new file mode')) {
-      if (currentFile) currentFile.isNew = true;
-      continue;
-    }
-
-    // Deleted file indicator
-    if (line.startsWith('deleted file mode')) {
-      if (currentFile) currentFile.isDeleted = true;
-      continue;
-    }
-
-    // Renamed file indicator
-    if (line.startsWith('rename from') || line.startsWith('rename to')) {
-      if (currentFile) currentFile.isRenamed = true;
-      continue;
-    }
-
-    // Skip index, ---/+++ lines
-    if (line.startsWith('index ') || line.startsWith('--- ') || line.startsWith('+++ ')) {
-      continue;
-    }
-
-    // Hunk header
-    if (line.startsWith('@@')) {
-      if (currentHunk && currentFile) {
-        currentFile.hunks.push(currentHunk);
-      }
-      // Parse line numbers from @@ -old,count +new,count @@
-      const hunkMatch = line.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-      oldLineNum = hunkMatch ? parseInt(hunkMatch[1], 10) : 1;
-      newLineNum = hunkMatch ? parseInt(hunkMatch[2], 10) : 1;
-      currentHunk = {
-        header: line,
-        lines: [{ type: 'header', content: line }],
-      };
-      continue;
-    }
-
-    // Diff content lines
-    if (currentHunk) {
-      if (line.startsWith('+')) {
-        currentHunk.lines.push({
-          type: 'addition',
-          content: line.substring(1),
-          lineNumber: { new: newLineNum },
-        });
-        newLineNum++;
-      } else if (line.startsWith('-')) {
-        currentHunk.lines.push({
-          type: 'deletion',
-          content: line.substring(1),
-          lineNumber: { old: oldLineNum },
-        });
-        oldLineNum++;
-      } else if (line.startsWith(' ') || line === '') {
-        currentHunk.lines.push({
-          type: 'context',
-          content: line.substring(1) || '',
-          lineNumber: { old: oldLineNum, new: newLineNum },
-        });
-        oldLineNum++;
-        newLineNum++;
-      }
-    }
-  }
-
-  // Don't forget the last file and hunk
-  if (currentFile) {
-    if (currentHunk) {
-      currentFile.hunks.push(currentHunk);
-    }
-    files.push(currentFile);
-  }
-
-  return files;
-}
-
-function DiffLine({
-  type,
-  content,
-  lineNumber,
-}: {
-  type: 'context' | 'addition' | 'deletion' | 'header';
-  content: string;
-  lineNumber?: { old?: number; new?: number };
-}) {
-  const bgClass = {
-    context: 'bg-transparent',
-    addition: 'bg-green-500/10',
-    deletion: 'bg-red-500/10',
-    header: 'bg-blue-500/10',
-  };
-
-  const textClass = {
-    context: 'text-foreground-secondary',
-    addition: 'text-green-400',
-    deletion: 'text-red-400',
-    header: 'text-blue-400',
-  };
-
-  const prefix = {
-    context: ' ',
-    addition: '+',
-    deletion: '-',
-    header: '',
-  };
-
-  if (type === 'header') {
-    return (
-      <div className={cn('px-2 py-1 font-mono text-xs', bgClass[type], textClass[type])}>
-        {content}
-      </div>
-    );
-  }
-
-  return (
-    <div className={cn('flex font-mono text-xs', bgClass[type])}>
-      <span className="w-12 flex-shrink-0 text-right pr-2 text-muted-foreground select-none border-r border-border-glass">
-        {lineNumber?.old ?? ''}
-      </span>
-      <span className="w-12 flex-shrink-0 text-right pr-2 text-muted-foreground select-none border-r border-border-glass">
-        {lineNumber?.new ?? ''}
-      </span>
-      <span className={cn('w-4 flex-shrink-0 text-center select-none', textClass[type])}>
-        {prefix[type]}
-      </span>
-      <span className={cn('flex-1 px-2 whitespace-pre-wrap break-all', textClass[type])}>
-        {content || '\u00A0'}
-      </span>
-    </div>
-  );
-}
-
 function StagingBadge({ state }: { state: 'staged' | 'unstaged' | 'partial' }) {
   if (state === 'staged') {
     return (
@@ -401,6 +219,7 @@ function MergeStateBanner({ mergeState }: { mergeState: MergeStateInfo }) {
 
 function FileDiffSection({
   fileDiff,
+  rawDiff,
   isExpanded,
   onToggle,
   fileStatus,
@@ -410,6 +229,8 @@ function FileDiffSection({
   isStagingFile,
 }: {
   fileDiff: ParsedFileDiff;
+  /** Raw unified diff string for this file, used by CodeMirror merge view */
+  rawDiff?: string;
   isExpanded: boolean;
   onToggle: () => void;
   fileStatus?: FileStatus;
@@ -418,14 +239,8 @@ function FileDiffSection({
   onUnstage?: (filePath: string) => void;
   isStagingFile?: boolean;
 }) {
-  const additions = fileDiff.hunks.reduce(
-    (acc, hunk) => acc + hunk.lines.filter((l) => l.type === 'addition').length,
-    0
-  );
-  const deletions = fileDiff.hunks.reduce(
-    (acc, hunk) => acc + hunk.lines.filter((l) => l.type === 'deletion').length,
-    0
-  );
+  const additions = fileDiff.additions;
+  const deletions = fileDiff.deletions;
 
   const stagingState = fileStatus ? getStagingState(fileStatus) : undefined;
 
@@ -521,20 +336,9 @@ function FileDiffSection({
           )}
         </div>
       </div>
-      {isExpanded && (
-        <div className="bg-background border-t border-border max-h-[400px] overflow-y-auto scrollbar-visible">
-          {fileDiff.hunks.map((hunk, hunkIndex) => (
-            <div key={hunkIndex} className="border-b border-border-glass last:border-b-0">
-              {hunk.lines.map((line, lineIndex) => (
-                <DiffLine
-                  key={lineIndex}
-                  type={line.type}
-                  content={line.content}
-                  lineNumber={line.lineNumber}
-                />
-              ))}
-            </div>
-          ))}
+      {isExpanded && rawDiff && (
+        <div className="bg-background border-t border-border">
+          <CodeMirrorDiffView fileDiff={rawDiff} filePath={fileDiff.filePath} maxHeight="400px" />
         </div>
       )}
     </div>
@@ -619,6 +423,16 @@ export function GitDiffPanel({
     return diffs;
   }, [diffContent, mergeState, fileStatusMap]);
 
+  // Build a map from file path to raw diff string for CodeMirror merge view
+  const fileDiffMap = useMemo(() => {
+    const map = new Map<string, string>();
+    const perFileDiffs = splitDiffByFile(diffContent);
+    for (const entry of perFileDiffs) {
+      map.set(entry.filePath, entry.diff);
+    }
+    return map;
+  }, [diffContent]);
+
   const toggleFile = (filePath: string) => {
     setExpandedFiles((prev) => {
       const next = new Set(prev);
@@ -822,25 +636,9 @@ export function GitDiffPanel({
     return { staged, partial, unstaged, total: files.length };
   }, [enableStaging, files]);
 
-  // Total stats
-  const totalAdditions = parsedDiffs.reduce(
-    (acc, file) =>
-      acc +
-      file.hunks.reduce(
-        (hAcc, hunk) => hAcc + hunk.lines.filter((l) => l.type === 'addition').length,
-        0
-      ),
-    0
-  );
-  const totalDeletions = parsedDiffs.reduce(
-    (acc, file) =>
-      acc +
-      file.hunks.reduce(
-        (hAcc, hunk) => hAcc + hunk.lines.filter((l) => l.type === 'deletion').length,
-        0
-      ),
-    0
-  );
+  // Total stats (pre-computed by shared parseDiff)
+  const totalAdditions = parsedDiffs.reduce((acc, file) => acc + file.additions, 0);
+  const totalDeletions = parsedDiffs.reduce((acc, file) => acc + file.deletions, 0);
 
   return (
     <div
@@ -1053,6 +851,7 @@ export function GitDiffPanel({
                   <FileDiffSection
                     key={fileDiff.filePath}
                     fileDiff={fileDiff}
+                    rawDiff={fileDiffMap.get(fileDiff.filePath)}
                     isExpanded={expandedFiles.has(fileDiff.filePath)}
                     onToggle={() => toggleFile(fileDiff.filePath)}
                     fileStatus={fileStatusMap.get(fileDiff.filePath)}

apps/ui/src/components/views/agent-view.tsx

@@ -1,6 +1,5 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
 import { useAppStore } from '@/store/app-store';
-import type { PhaseModelEntry } from '@automaker/types';
 import { useElectronAgent } from '@/hooks/use-electron-agent';
 import { SessionManager } from '@/components/session-manager';
 
@@ -46,8 +45,6 @@ export function AgentView() {
     return () => window.removeEventListener('resize', updateVisibility);
   }, []);
 
-  const [modelSelection, setModelSelection] = useState<PhaseModelEntry>({ model: 'claude-sonnet' });
-
   // Input ref for auto-focus
   const inputRef = useRef<HTMLTextAreaElement>(null);
 
@@ -57,10 +54,12 @@ export function AgentView() {
   const createSessionInFlightRef = useRef(false);
 
   // Session management hook - scoped to current worktree
-  const { currentSessionId, handleSelectSession } = useAgentSession({
-    projectPath: currentProject?.path,
-    workingDirectory: effectiveWorkingDirectory,
-  });
+  // Also handles model selection persistence per session
+  const { currentSessionId, handleSelectSession, modelSelection, setModelSelection } =
+    useAgentSession({
+      projectPath: currentProject?.path,
+      workingDirectory: effectiveWorkingDirectory,
+    });
 
   // Use the Electron agent hook (only if we have a session)
   const {

apps/ui/src/components/views/agent-view/hooks/use-agent-session.ts

@@ -1,9 +1,14 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { createLogger } from '@automaker/utils/logger';
+import type { PhaseModelEntry } from '@automaker/types';
 import { useAppStore } from '@/store/app-store';
+import { useShallow } from 'zustand/react/shallow';
 
 const logger = createLogger('AgentSession');
 
+// Default model selection when none is persisted
+const DEFAULT_MODEL_SELECTION: PhaseModelEntry = { model: 'claude-sonnet' };
+
 interface UseAgentSessionOptions {
   projectPath: string | undefined;
   workingDirectory?: string; // Current worktree path for per-worktree session persistence
@@ -12,14 +17,31 @@ interface UseAgentSessionOptions {
 interface UseAgentSessionResult {
   currentSessionId: string | null;
   handleSelectSession: (sessionId: string | null) => void;
+  // Model selection persistence
+  modelSelection: PhaseModelEntry;
+  setModelSelection: (model: PhaseModelEntry) => void;
 }
 
 export function useAgentSession({
   projectPath,
   workingDirectory,
 }: UseAgentSessionOptions): UseAgentSessionResult {
-  const { setLastSelectedSession, getLastSelectedSession } = useAppStore();
+  const {
+    setLastSelectedSession,
+    getLastSelectedSession,
+    setAgentModelForSession,
+    getAgentModelForSession,
+  } = useAppStore(
+    useShallow((state) => ({
+      setLastSelectedSession: state.setLastSelectedSession,
+      getLastSelectedSession: state.getLastSelectedSession,
+      setAgentModelForSession: state.setAgentModelForSession,
+      getAgentModelForSession: state.getAgentModelForSession,
+    }))
+  );
   const [currentSessionId, setCurrentSessionId] = useState<string | null>(null);
+  const [modelSelection, setModelSelectionState] =
+    useState<PhaseModelEntry>(DEFAULT_MODEL_SELECTION);
 
   // Track if initial session has been loaded
   const initialSessionLoadedRef = useRef(false);
@@ -27,6 +49,22 @@ export function useAgentSession({
   // Use workingDirectory as the persistence key so sessions are scoped per worktree
   const persistenceKey = workingDirectory || projectPath;
 
+  /**
+   * Fetch persisted model for sessionId and update local state, or fall back to default.
+   */
+  const restoreModelForSession = useCallback(
+    (sessionId: string) => {
+      const persistedModel = getAgentModelForSession(sessionId);
+      if (persistedModel) {
+        logger.debug('Restoring model selection for session:', sessionId, persistedModel);
+        setModelSelectionState(persistedModel);
+      } else {
+        setModelSelectionState(DEFAULT_MODEL_SELECTION);
+      }
+    },
+    [getAgentModelForSession]
+  );
+
   // Handle session selection with persistence
   const handleSelectSession = useCallback(
     (sessionId: string | null) => {
@@ -35,16 +73,52 @@ export function useAgentSession({
       if (persistenceKey) {
         setLastSelectedSession(persistenceKey, sessionId);
       }
+      // Restore model selection for this session if available
+      if (sessionId) {
+        restoreModelForSession(sessionId);
+      }
     },
-    [persistenceKey, setLastSelectedSession]
+    [persistenceKey, setLastSelectedSession, restoreModelForSession]
   );
 
+  // Wrapper for setModelSelection that also persists
+  const setModelSelection = useCallback(
+    (model: PhaseModelEntry) => {
+      setModelSelectionState(model);
+      // Persist model selection for current session.
+      // If currentSessionId is null (no active session), we only update local state
+      // and skip persistence — this is intentional because the model picker should be
+      // disabled (or hidden) in the UI whenever there is no active session, so this
+      // path is only reached if the UI allows selection before a session is established.
+      if (currentSessionId) {
+        setAgentModelForSession(currentSessionId, model);
+      }
+    },
+    [currentSessionId, setAgentModelForSession]
+  );
+
+  // Track the previous persistence key to detect actual changes
+  const prevPersistenceKeyRef = useRef(persistenceKey);
+
   // Restore last selected session when switching to Agent view or when worktree changes
   useEffect(() => {
-    if (!persistenceKey) {
-      // No project, reset
-      setCurrentSessionId(null);
+    // Detect if persistenceKey actually changed (worktree/project switch)
+    const persistenceKeyChanged = prevPersistenceKeyRef.current !== persistenceKey;
+
+    if (persistenceKeyChanged) {
+      // Reset state when switching worktree/project
+      prevPersistenceKeyRef.current = persistenceKey;
       initialSessionLoadedRef.current = false;
+      setCurrentSessionId(null);
+      setModelSelectionState(DEFAULT_MODEL_SELECTION);
+
+      if (!persistenceKey) {
+        // No project, nothing to restore
+        return;
+      }
+    }
+
+    if (!persistenceKey) {
       return;
     }
 
@@ -54,19 +128,17 @@ export function useAgentSession({
 
     const lastSessionId = getLastSelectedSession(persistenceKey);
     if (lastSessionId) {
-      logger.info('Restoring last selected session:', lastSessionId);
+      logger.debug('Restoring last selected session:', lastSessionId);
       setCurrentSessionId(lastSessionId);
+      // Also restore model selection for this session
+      restoreModelForSession(lastSessionId);
     }
-  }, [persistenceKey, getLastSelectedSession]);
-
-  // Reset when worktree/project changes - clear current session and allow restore
-  useEffect(() => {
-    initialSessionLoadedRef.current = false;
-    setCurrentSessionId(null);
-  }, [persistenceKey]);
+  }, [persistenceKey, getLastSelectedSession, restoreModelForSession]);
 
   return {
     currentSessionId,
     handleSelectSession,
+    modelSelection,
+    setModelSelection,
   };
 }

apps/ui/src/components/views/board-view.tsx

@@ -27,10 +27,14 @@ class DialogAwarePointerSensor extends PointerSensor {
     },
   ];
 }
-import { useAppStore, Feature } from '@/store/app-store';
+import { useAppStore, Feature, type ModelAlias, type ThinkingLevel } from '@/store/app-store';
 import { getElectronAPI } from '@/lib/electron';
 import { getHttpApiClient } from '@/lib/http-api-client';
-import type { BacklogPlanResult, FeatureStatusWithPipeline } from '@automaker/types';
+import type {
+  BacklogPlanResult,
+  FeatureStatusWithPipeline,
+  FeatureTemplate,
+} from '@automaker/types';
 import { pathsEqual } from '@/lib/utils';
 import { toast } from 'sonner';
 import {
@@ -58,6 +62,8 @@ import {
   FollowUpDialog,
   PlanApprovalDialog,
   MergeRebaseDialog,
+  QuickAddDialog,
+  ChangePRNumberDialog,
 } from './board-view/dialogs';
 import type { DependencyLinkType } from './board-view/dialogs';
 import { PipelineSettingsDialog } from './board-view/dialogs/pipeline-settings-dialog';
@@ -75,6 +81,7 @@ import type {
   StashPopConflictInfo,
   StashApplyConflictInfo,
 } from './board-view/worktree-panel/types';
+import { BoardErrorBoundary } from './board-view/board-error-boundary';
 import { COLUMNS, getColumnsWithPipeline } from './board-view/constants';
 import {
   useBoardFeatures,
@@ -99,6 +106,7 @@ import { useQueryClient } from '@tanstack/react-query';
 import { queryKeys } from '@/lib/query-keys';
 import { useAutoModeQueryInvalidation } from '@/hooks/use-query-invalidation';
 import { useUpdateGlobalSettings } from '@/hooks/mutations/use-settings-mutations';
+import { forceSyncSettingsToServer } from '@/hooks/use-settings-sync';
 
 // Stable empty array to avoid infinite loop in selector
 const EMPTY_WORKTREES: ReturnType<ReturnType<typeof useAppStore.getState>['getWorktrees']> = [];
@@ -114,7 +122,7 @@ export function BoardView() {
     pendingPlanApproval,
     setPendingPlanApproval,
     updateFeature,
-    getCurrentWorktree,
+    batchUpdateFeatures,
     setCurrentWorktree,
     getWorktrees,
     setWorktrees,
@@ -123,6 +131,7 @@ export function BoardView() {
     isPrimaryWorktreeBranch,
     getPrimaryWorktreeBranch,
     setPipelineConfig,
+    featureTemplates,
   } = useAppStore(
     useShallow((state) => ({
       currentProject: state.currentProject,
@@ -132,7 +141,7 @@ export function BoardView() {
       pendingPlanApproval: state.pendingPlanApproval,
       setPendingPlanApproval: state.setPendingPlanApproval,
       updateFeature: state.updateFeature,
-      getCurrentWorktree: state.getCurrentWorktree,
+      batchUpdateFeatures: state.batchUpdateFeatures,
       setCurrentWorktree: state.setCurrentWorktree,
       getWorktrees: state.getWorktrees,
       setWorktrees: state.setWorktrees,
@@ -141,8 +150,11 @@ export function BoardView() {
       isPrimaryWorktreeBranch: state.isPrimaryWorktreeBranch,
       getPrimaryWorktreeBranch: state.getPrimaryWorktreeBranch,
       setPipelineConfig: state.setPipelineConfig,
+      featureTemplates: state.featureTemplates,
     }))
   );
+  // Also get keyboard shortcuts for the add feature shortcut
+  const keyboardShortcuts = useAppStore((state) => state.keyboardShortcuts);
   // Fetch pipeline config via React Query
   const { data: pipelineConfig } = usePipelineConfig(currentProject?.path);
   const queryClient = useQueryClient();
@@ -164,6 +176,7 @@ export function BoardView() {
   } = useBoardFeatures({ currentProject });
   const [editingFeature, setEditingFeature] = useState<Feature | null>(null);
   const [showAddDialog, setShowAddDialog] = useState(false);
+  const [showQuickAddDialog, setShowQuickAddDialog] = useState(false);
   const [isMounted, setIsMounted] = useState(false);
   const [showOutputModal, setShowOutputModal] = useState(false);
   const [outputFeature, setOutputFeature] = useState<Feature | null>(null);
@@ -186,6 +199,7 @@ export function BoardView() {
   const [showDeleteWorktreeDialog, setShowDeleteWorktreeDialog] = useState(false);
   const [showCommitWorktreeDialog, setShowCommitWorktreeDialog] = useState(false);
   const [showCreatePRDialog, setShowCreatePRDialog] = useState(false);
+  const [showChangePRNumberDialog, setShowChangePRNumberDialog] = useState(false);
   const [showCreateBranchDialog, setShowCreateBranchDialog] = useState(false);
   const [showMergeRebaseDialog, setShowMergeRebaseDialog] = useState(false);
   const [showPRCommentDialog, setShowPRCommentDialog] = useState(false);
@@ -411,61 +425,55 @@ export function BoardView() {
     currentProject,
   });
 
+  // Shared helper: batch-reset branch assignment and persist for each affected feature.
+  // Used when worktrees are deleted or branches are removed during merge.
+  const batchResetBranchFeatures = useCallback(
+    (branchName: string) => {
+      const affectedIds = hookFeatures.filter((f) => f.branchName === branchName).map((f) => f.id);
+      if (affectedIds.length === 0) return;
+      const updates: Partial<Feature> = { branchName: undefined };
+      batchUpdateFeatures(affectedIds, updates);
+      for (const id of affectedIds) {
+        persistFeatureUpdate(id, updates).catch((err: unknown) => {
+          console.error(
+            `[batchResetBranchFeatures] Failed to persist update for feature ${id}:`,
+            err
+          );
+        });
+      }
+    },
+    [hookFeatures, batchUpdateFeatures, persistFeatureUpdate]
+  );
+
   // Memoize the removed worktrees handler to prevent infinite loops
   const handleRemovedWorktrees = useCallback(
     (removedWorktrees: Array<{ path: string; branch: string }>) => {
-      // Reset features that were assigned to the removed worktrees (by branch)
-      hookFeatures.forEach((feature) => {
-        const matchesRemovedWorktree = removedWorktrees.some((removed) => {
-          // Match by branch name since worktreePath is no longer stored
-          return feature.branchName === removed.branch;
-        });
-
-        if (matchesRemovedWorktree) {
-          // Reset the feature's branch assignment - update both local state and persist
-          const updates = { branchName: null as unknown as string | undefined };
-          updateFeature(feature.id, updates);
-          persistFeatureUpdate(feature.id, updates);
-        }
-      });
+      for (const { branch } of removedWorktrees) {
+        batchResetBranchFeatures(branch);
+      }
     },
-    [hookFeatures, updateFeature, persistFeatureUpdate]
+    [batchResetBranchFeatures]
   );
 
-  // Get current worktree info (path) for filtering features
-  // This needs to be before useBoardActions so we can pass currentWorktreeBranch
-  const currentWorktreeInfo = currentProject ? getCurrentWorktree(currentProject.path) : null;
+  const currentProjectPath = currentProject?.path;
+
+  // Get current worktree info (path/branch) for filtering features.
+  // Subscribe to the selected project's current worktree value directly so worktree
+  // switches trigger an immediate re-render and instant kanban/list re-filtering.
+  const currentWorktreeInfo = useAppStore(
+    useCallback(
+      (s) => (currentProjectPath ? (s.currentWorktreeByProject[currentProjectPath] ?? null) : null),
+      [currentProjectPath]
+    )
+  );
   const currentWorktreePath = currentWorktreeInfo?.path ?? null;
 
-  // Track the previous worktree path to detect worktree switches
-  const prevWorktreePathRef = useRef<string | null | undefined>(undefined);
-
-  // When the active worktree changes, invalidate feature queries to ensure
-  // feature cards (especially their todo lists / planSpec tasks) render fresh data.
-  // Without this, cards that unmount when filtered out and remount when the user
-  // switches back may show stale or missing todo list data until the next polling cycle.
-  useEffect(() => {
-    // Skip the initial mount (prevWorktreePathRef starts as undefined)
-    if (prevWorktreePathRef.current === undefined) {
-      prevWorktreePathRef.current = currentWorktreePath;
-      return;
-    }
-    // Only invalidate when the worktree actually changed
-    if (prevWorktreePathRef.current !== currentWorktreePath && currentProject?.path) {
-      queryClient.invalidateQueries({
-        queryKey: queryKeys.features.all(currentProject.path),
-      });
-    }
-    prevWorktreePathRef.current = currentWorktreePath;
-  }, [currentWorktreePath, currentProject?.path, queryClient]);
-
   // Select worktrees for the current project directly from the store.
   // Using a project-scoped selector prevents re-renders when OTHER projects'
   // worktrees change (the old selector subscribed to the entire worktreesByProject
   // object, causing unnecessary re-renders that cascaded into selectedWorktree →
   // useAutoMode → refreshStatus → setAutoModeRunning → store update → re-render loop
   // that could trigger React error #185 on initial project open).
-  const currentProjectPath = currentProject?.path;
   const worktrees = useAppStore(
     useCallback(
       (s) =>
@@ -647,6 +655,15 @@ export function BoardView() {
     );
   }, [hookFeatures, worktrees]);
 
+  // Recovery handler for BoardErrorBoundary: reset worktree selection to main
+  // so the board can re-render without the stale worktree state that caused the crash.
+  const handleBoardRecover = useCallback(() => {
+    if (!currentProject) return;
+    const mainWorktree = worktrees.find((w) => w.isMain);
+    const mainBranch = mainWorktree?.branch || 'main';
+    setCurrentWorktree(currentProject.path, null, mainBranch);
+  }, [currentProject, worktrees, setCurrentWorktree]);
+
   // Helper function to add and select a worktree
   const addAndSelectWorktree = useCallback(
     (worktreeResult: { path: string; branch: string }) => {
@@ -997,6 +1014,89 @@ export function BoardView() {
     [handleAddFeature, handleStartImplementation]
   );
 
+  // Handler for Quick Add - creates a feature with minimal data using defaults
+  const handleQuickAdd = useCallback(
+    async (
+      description: string,
+      modelEntry: { model: string; thinkingLevel?: string; reasoningEffort?: string }
+    ) => {
+      // Generate a title from the first line of the description
+      const title = description.split('\n')[0].substring(0, 100);
+
+      await handleAddFeature({
+        title,
+        description,
+        category: '',
+        images: [],
+        imagePaths: [],
+        skipTests: defaultSkipTests,
+        model: resolveModelString(modelEntry.model) as ModelAlias,
+        thinkingLevel: (modelEntry.thinkingLevel as ThinkingLevel) || 'none',
+        reasoningEffort: modelEntry.reasoningEffort,
+        branchName: addFeatureUseSelectedWorktreeBranch ? selectedWorktreeBranch : undefined,
+        priority: 2,
+        planningMode: useAppStore.getState().defaultPlanningMode ?? 'skip',
+        requirePlanApproval: useAppStore.getState().defaultRequirePlanApproval ?? false,
+        dependencies: [],
+        workMode: addFeatureUseSelectedWorktreeBranch ? 'custom' : 'current',
+      });
+    },
+    [
+      handleAddFeature,
+      defaultSkipTests,
+      addFeatureUseSelectedWorktreeBranch,
+      selectedWorktreeBranch,
+    ]
+  );
+
+  // Handler for Quick Add & Start - creates and immediately starts a feature
+  const handleQuickAddAndStart = useCallback(
+    async (
+      description: string,
+      modelEntry: { model: string; thinkingLevel?: string; reasoningEffort?: string }
+    ) => {
+      // Generate a title from the first line of the description
+      const title = description.split('\n')[0].substring(0, 100);
+
+      await handleAddAndStartFeature({
+        title,
+        description,
+        category: '',
+        images: [],
+        imagePaths: [],
+        skipTests: defaultSkipTests,
+        model: resolveModelString(modelEntry.model) as ModelAlias,
+        thinkingLevel: (modelEntry.thinkingLevel as ThinkingLevel) || 'none',
+        reasoningEffort: modelEntry.reasoningEffort,
+        branchName: addFeatureUseSelectedWorktreeBranch ? selectedWorktreeBranch : undefined,
+        priority: 2,
+        planningMode: useAppStore.getState().defaultPlanningMode ?? 'skip',
+        requirePlanApproval: useAppStore.getState().defaultRequirePlanApproval ?? false,
+        dependencies: [],
+        workMode: addFeatureUseSelectedWorktreeBranch ? 'custom' : 'current',
+        initialStatus: 'in_progress',
+      });
+    },
+    [
+      handleAddAndStartFeature,
+      defaultSkipTests,
+      addFeatureUseSelectedWorktreeBranch,
+      selectedWorktreeBranch,
+    ]
+  );
+
+  // Handler for template selection - creates a feature from a template
+  const handleTemplateSelect = useCallback(
+    async (template: FeatureTemplate) => {
+      const modelEntry = template.model ||
+        useAppStore.getState().defaultFeatureModel || { model: 'claude-opus' };
+
+      // Start the template immediately (same behavior as clicking "Make")
+      await handleQuickAddAndStart(template.prompt, modelEntry);
+    },
+    [handleQuickAddAndStart]
+  );
+
   // Handler for managing PR comments - opens the PR Comment Resolution dialog
   const handleAddressPRComments = useCallback((worktree: WorktreeInfo, prInfo: PRInfo) => {
     setPRCommentDialogPRInfo({
@@ -1566,157 +1666,163 @@ export function BoardView() {
         onViewModeChange={setViewMode}
       />
 
-      {/* DndContext wraps both WorktreePanel and main content area to enable drag-to-worktree */}
-      <DndContext
-        sensors={sensors}
-        collisionDetection={collisionDetectionStrategy}
-        onDragStart={handleDragStart}
-        onDragEnd={handleDragEnd}
-      >
-        {/* Worktree Panel - conditionally rendered based on visibility setting */}
-        {(worktreePanelVisibleByProject[currentProject.path] ?? true) && (
-          <WorktreePanel
-            refreshTrigger={worktreeRefreshKey}
-            projectPath={currentProject.path}
-            onCreateWorktree={() => setShowCreateWorktreeDialog(true)}
-            onDeleteWorktree={(worktree) => {
-              setSelectedWorktreeForAction(worktree);
-              setShowDeleteWorktreeDialog(true);
-            }}
-            onCommit={(worktree) => {
-              setSelectedWorktreeForAction(worktree);
-              setShowCommitWorktreeDialog(true);
-            }}
-            onCreatePR={(worktree) => {
-              setSelectedWorktreeForAction(worktree);
-              setShowCreatePRDialog(true);
-            }}
-            onCreateBranch={(worktree) => {
-              setSelectedWorktreeForAction(worktree);
-              setShowCreateBranchDialog(true);
-            }}
-            onAddressPRComments={handleAddressPRComments}
-            onAutoAddressPRComments={handleAutoAddressPRComments}
-            onResolveConflicts={handleResolveConflicts}
-            onCreateMergeConflictResolutionFeature={handleCreateMergeConflictResolutionFeature}
-            onBranchSwitchConflict={handleBranchSwitchConflict}
-            onStashPopConflict={handleStashPopConflict}
-            onStashApplyConflict={handleStashApplyConflict}
-            onBranchDeletedDuringMerge={(branchName) => {
-              // Reset features that were assigned to the deleted branch (same logic as onDeleted in DeleteWorktreeDialog)
-              hookFeatures.forEach((feature) => {
-                if (feature.branchName === branchName) {
-                  // Reset the feature's branch assignment - update both local state and persist
-                  const updates = {
-                    branchName: null as unknown as string | undefined,
-                  };
-                  updateFeature(feature.id, updates);
-                  persistFeatureUpdate(feature.id, updates);
-                }
-              });
-              setWorktreeRefreshKey((k) => k + 1);
-            }}
-            onRemovedWorktrees={handleRemovedWorktrees}
-            runningFeatureIds={runningAutoTasksAllWorktrees}
-            branchCardCounts={branchCardCounts}
-            features={hookFeatures.map((f) => ({
-              id: f.id,
-              branchName: f.branchName,
-            }))}
-          />
-        )}
-
-        {/* Main Content Area */}
-        <div className="flex-1 flex flex-col overflow-hidden">
-          {/* View Content - Kanban Board or List View */}
-          {isListView ? (
-            <ListView
-              columnFeaturesMap={columnFeaturesMap}
-              allFeatures={hookFeatures}
-              sortConfig={sortConfig}
-              onSortChange={setSortColumn}
-              actionHandlers={{
-                onEdit: (feature) => setEditingFeature(feature),
-                onDelete: (featureId) => handleDeleteFeature(featureId),
-                onViewOutput: handleViewOutput,
-                onVerify: handleVerifyFeature,
-                onResume: handleResumeFeature,
-                onForceStop: handleForceStopFeature,
-                onManualVerify: handleManualVerify,
-                onFollowUp: handleOpenFollowUp,
-                onImplement: handleStartImplementation,
-                onComplete: handleCompleteFeature,
-                onViewPlan: (feature) => setViewPlanFeature(feature),
-                onApprovePlan: handleOpenApprovalDialog,
-                onSpawnTask: (feature) => {
-                  setSpawnParentFeature(feature);
-                  setShowAddDialog(true);
-                },
-                onDuplicate: (feature) => handleDuplicateFeature(feature, false),
-                onDuplicateAsChild: (feature) => handleDuplicateFeature(feature, true),
-                onDuplicateAsChildMultiple: (feature) => setDuplicateMultipleFeature(feature),
+      {/* BoardErrorBoundary catches render errors during worktree switches (e.g. React
+          error #185 re-render cascades on mobile Safari PWA) and provides a recovery UI
+          that resets to main branch instead of crashing the entire page. */}
+      <BoardErrorBoundary onRecover={handleBoardRecover}>
+        {/* DndContext wraps both WorktreePanel and main content area to enable drag-to-worktree */}
+        <DndContext
+          sensors={sensors}
+          collisionDetection={collisionDetectionStrategy}
+          onDragStart={handleDragStart}
+          onDragEnd={handleDragEnd}
+        >
+          {/* Worktree Panel - conditionally rendered based on visibility setting */}
+          {(worktreePanelVisibleByProject[currentProject.path] ?? true) && (
+            <WorktreePanel
+              refreshTrigger={worktreeRefreshKey}
+              projectPath={currentProject.path}
+              onCreateWorktree={() => setShowCreateWorktreeDialog(true)}
+              onDeleteWorktree={(worktree) => {
+                setSelectedWorktreeForAction(worktree);
+                setShowDeleteWorktreeDialog(true);
               }}
-              runningAutoTasks={runningAutoTasksAllWorktrees}
-              pipelineConfig={pipelineConfig}
-              onAddFeature={() => setShowAddDialog(true)}
-              isSelectionMode={isSelectionMode}
-              selectedFeatureIds={selectedFeatureIds}
-              onToggleFeatureSelection={toggleFeatureSelection}
-              onRowClick={(feature) => {
-                if (feature.status === 'backlog') {
-                  setEditingFeature(feature);
-                } else {
-                  handleViewOutput(feature);
-                }
+              onCommit={(worktree) => {
+                setSelectedWorktreeForAction(worktree);
+                setShowCommitWorktreeDialog(true);
               }}
-              className="transition-opacity duration-200"
-            />
-          ) : (
-            <KanbanBoard
-              activeFeature={activeFeature}
-              getColumnFeatures={getColumnFeatures}
-              backgroundImageStyle={backgroundImageStyle}
-              backgroundSettings={backgroundSettings}
-              onEdit={(feature) => setEditingFeature(feature)}
-              onDelete={(featureId) => handleDeleteFeature(featureId)}
-              onViewOutput={handleViewOutput}
-              onVerify={handleVerifyFeature}
-              onResume={handleResumeFeature}
-              onForceStop={handleForceStopFeature}
-              onManualVerify={handleManualVerify}
-              onMoveBackToInProgress={handleMoveBackToInProgress}
-              onFollowUp={handleOpenFollowUp}
-              onComplete={handleCompleteFeature}
-              onImplement={handleStartImplementation}
-              onViewPlan={(feature) => setViewPlanFeature(feature)}
-              onApprovePlan={handleOpenApprovalDialog}
-              onSpawnTask={(feature) => {
-                setSpawnParentFeature(feature);
-                setShowAddDialog(true);
+              onCreatePR={(worktree) => {
+                setSelectedWorktreeForAction(worktree);
+                setShowCreatePRDialog(true);
               }}
-              onDuplicate={(feature) => handleDuplicateFeature(feature, false)}
-              onDuplicateAsChild={(feature) => handleDuplicateFeature(feature, true)}
-              onDuplicateAsChildMultiple={(feature) => setDuplicateMultipleFeature(feature)}
-              featuresWithContext={featuresWithContext}
-              runningAutoTasks={runningAutoTasksAllWorktrees}
-              onArchiveAllVerified={() => setShowArchiveAllVerifiedDialog(true)}
-              onAddFeature={() => setShowAddDialog(true)}
-              onShowCompletedModal={() => setShowCompletedModal(true)}
-              completedCount={completedFeatures.length}
-              pipelineConfig={pipelineConfig ?? null}
-              onOpenPipelineSettings={() => setShowPipelineSettings(true)}
-              isSelectionMode={isSelectionMode}
-              selectionTarget={selectionTarget}
-              selectedFeatureIds={selectedFeatureIds}
-              onToggleFeatureSelection={toggleFeatureSelection}
-              onToggleSelectionMode={toggleSelectionMode}
-              isDragging={activeFeature !== null}
-              onAiSuggest={() => setShowPlanDialog(true)}
-              className="transition-opacity duration-200"
+              onChangePRNumber={(worktree) => {
+                setSelectedWorktreeForAction(worktree);
+                setShowChangePRNumberDialog(true);
+              }}
+              onCreateBranch={(worktree) => {
+                setSelectedWorktreeForAction(worktree);
+                setShowCreateBranchDialog(true);
+              }}
+              onAddressPRComments={handleAddressPRComments}
+              onAutoAddressPRComments={handleAutoAddressPRComments}
+              onResolveConflicts={handleResolveConflicts}
+              onCreateMergeConflictResolutionFeature={handleCreateMergeConflictResolutionFeature}
+              onBranchSwitchConflict={handleBranchSwitchConflict}
+              onStashPopConflict={handleStashPopConflict}
+              onStashApplyConflict={handleStashApplyConflict}
+              onBranchDeletedDuringMerge={(branchName) => {
+                batchResetBranchFeatures(branchName);
+                setWorktreeRefreshKey((k) => k + 1);
+              }}
+              onRemovedWorktrees={handleRemovedWorktrees}
+              runningFeatureIds={runningAutoTasksAllWorktrees}
+              branchCardCounts={branchCardCounts}
+              features={hookFeatures.map((f) => ({
+                id: f.id,
+                branchName: f.branchName,
+              }))}
             />
           )}
-        </div>
-      </DndContext>
+
+          {/* Main Content Area */}
+          <div className="flex-1 flex flex-col overflow-hidden">
+            {/* View Content - Kanban Board or List View */}
+            {isListView ? (
+              <ListView
+                columnFeaturesMap={columnFeaturesMap}
+                allFeatures={hookFeatures}
+                sortConfig={sortConfig}
+                onSortChange={setSortColumn}
+                actionHandlers={{
+                  onEdit: (feature) => setEditingFeature(feature),
+                  onDelete: (featureId) => handleDeleteFeature(featureId),
+                  onViewOutput: handleViewOutput,
+                  onVerify: handleVerifyFeature,
+                  onResume: handleResumeFeature,
+                  onForceStop: handleForceStopFeature,
+                  onManualVerify: handleManualVerify,
+                  onFollowUp: handleOpenFollowUp,
+                  onImplement: handleStartImplementation,
+                  onComplete: handleCompleteFeature,
+                  onViewPlan: (feature) => setViewPlanFeature(feature),
+                  onApprovePlan: handleOpenApprovalDialog,
+                  onSpawnTask: (feature) => {
+                    setSpawnParentFeature(feature);
+                    setShowAddDialog(true);
+                  },
+                  onDuplicate: (feature) => handleDuplicateFeature(feature, false),
+                  onDuplicateAsChild: (feature) => handleDuplicateFeature(feature, true),
+                  onDuplicateAsChildMultiple: (feature) => setDuplicateMultipleFeature(feature),
+                }}
+                runningAutoTasks={runningAutoTasksAllWorktrees}
+                pipelineConfig={pipelineConfig}
+                onAddFeature={() => setShowAddDialog(true)}
+                onQuickAdd={() => setShowQuickAddDialog(true)}
+                onTemplateSelect={handleTemplateSelect}
+                templates={featureTemplates}
+                isSelectionMode={isSelectionMode}
+                selectedFeatureIds={selectedFeatureIds}
+                onToggleFeatureSelection={toggleFeatureSelection}
+                onRowClick={(feature) => {
+                  if (feature.status === 'backlog') {
+                    setEditingFeature(feature);
+                  } else {
+                    handleViewOutput(feature);
+                  }
+                }}
+                className="transition-opacity duration-200"
+              />
+            ) : (
+              <KanbanBoard
+                activeFeature={activeFeature}
+                getColumnFeatures={getColumnFeatures}
+                backgroundImageStyle={backgroundImageStyle}
+                backgroundSettings={backgroundSettings}
+                onEdit={(feature) => setEditingFeature(feature)}
+                onDelete={(featureId) => handleDeleteFeature(featureId)}
+                onViewOutput={handleViewOutput}
+                onVerify={handleVerifyFeature}
+                onResume={handleResumeFeature}
+                onForceStop={handleForceStopFeature}
+                onManualVerify={handleManualVerify}
+                onMoveBackToInProgress={handleMoveBackToInProgress}
+                onFollowUp={handleOpenFollowUp}
+                onComplete={handleCompleteFeature}
+                onImplement={handleStartImplementation}
+                onViewPlan={(feature) => setViewPlanFeature(feature)}
+                onApprovePlan={handleOpenApprovalDialog}
+                onSpawnTask={(feature) => {
+                  setSpawnParentFeature(feature);
+                  setShowAddDialog(true);
+                }}
+                onDuplicate={(feature) => handleDuplicateFeature(feature, false)}
+                onDuplicateAsChild={(feature) => handleDuplicateFeature(feature, true)}
+                onDuplicateAsChildMultiple={(feature) => setDuplicateMultipleFeature(feature)}
+                featuresWithContext={featuresWithContext}
+                runningAutoTasks={runningAutoTasksAllWorktrees}
+                onArchiveAllVerified={() => setShowArchiveAllVerifiedDialog(true)}
+                onAddFeature={() => setShowAddDialog(true)}
+                onQuickAdd={() => setShowQuickAddDialog(true)}
+                onTemplateSelect={handleTemplateSelect}
+                templates={featureTemplates}
+                addFeatureShortcut={keyboardShortcuts.addFeature}
+                onShowCompletedModal={() => setShowCompletedModal(true)}
+                completedCount={completedFeatures.length}
+                pipelineConfig={pipelineConfig ?? null}
+                onOpenPipelineSettings={() => setShowPipelineSettings(true)}
+                isSelectionMode={isSelectionMode}
+                selectionTarget={selectionTarget}
+                selectedFeatureIds={selectedFeatureIds}
+                onToggleFeatureSelection={toggleFeatureSelection}
+                onToggleSelectionMode={toggleSelectionMode}
+                isDragging={activeFeature !== null}
+                onAiSuggest={() => setShowPlanDialog(true)}
+                className="transition-opacity duration-200"
+              />
+            )}
+          </div>
+        </DndContext>
+      </BoardErrorBoundary>
 
       {/* Selection Action Bar */}
       {isSelectionMode && (
@@ -1812,6 +1918,14 @@ export function BoardView() {
         forceCurrentBranchMode={!addFeatureUseSelectedWorktreeBranch}
       />
 
+      {/* Quick Add Dialog */}
+      <QuickAddDialog
+        open={showQuickAddDialog}
+        onOpenChange={setShowQuickAddDialog}
+        onAdd={handleQuickAdd}
+        onAddAndStart={handleQuickAddAndStart}
+      />
+
       {/* Dependency Link Dialog */}
       <DependencyLinkDialog
         open={Boolean(pendingDependencyLink)}
@@ -1990,31 +2104,81 @@ export function BoardView() {
         }
         defaultDeleteBranch={getDefaultDeleteBranch(currentProject.path)}
         onDeleted={(deletedWorktree, _deletedBranch) => {
-          // If the deleted worktree was currently selected, immediately reset to main
-          // to prevent the UI from trying to render a non-existent worktree view
-          if (
-            currentWorktreePath !== null &&
-            pathsEqual(currentWorktreePath, deletedWorktree.path)
-          ) {
-            const mainBranch = worktrees.find((w) => w.isMain)?.branch || 'main';
-            setCurrentWorktree(currentProject.path, null, mainBranch);
-          }
+          // 1. Reset current worktree to main FIRST. This must happen
+          //    BEFORE removing from the list to ensure downstream hooks
+          //    (useAutoMode, useBoardFeatures) see a valid worktree and
+          //    never try to render the deleted worktree.
+          const mainBranch = worktrees.find((w) => w.isMain)?.branch || 'main';
+          setCurrentWorktree(currentProject.path, null, mainBranch);
 
-          // Reset features that were assigned to the deleted worktree (by branch)
-          hookFeatures.forEach((feature) => {
-            // Match by branch name since worktreePath is no longer stored
-            if (feature.branchName === deletedWorktree.branch) {
-              // Reset the feature's branch assignment - update both local state and persist
-              const updates = {
-                branchName: null as unknown as string | undefined,
+          // 2. Immediately remove the deleted worktree from the store's
+          //    worktree list so the UI never renders a stale tab/dropdown
+          //    item that can be clicked and cause a crash.
+          const remainingWorktrees = worktrees.filter(
+            (w) => !pathsEqual(w.path, deletedWorktree.path)
+          );
+          setWorktrees(currentProject.path, remainingWorktrees);
+
+          // 3. Cancel any in-flight worktree queries, then optimistically
+          //    update the React Query cache so the worktree disappears
+          //    from the dropdown immediately. Cancelling first prevents a
+          //    pending refetch from overwriting our optimistic update with
+          //    stale server data.
+          const worktreeQueryKey = queryKeys.worktrees.all(currentProject.path);
+          void queryClient.cancelQueries({ queryKey: worktreeQueryKey });
+          queryClient.setQueryData(
+            worktreeQueryKey,
+            (
+              old:
+                | {
+                    worktrees: WorktreeInfo[];
+                    removedWorktrees: Array<{ path: string; branch: string }>;
+                  }
+                | undefined
+            ) => {
+              if (!old) return old;
+              return {
+                ...old,
+                worktrees: old.worktrees.filter(
+                  (w: WorktreeInfo) => !pathsEqual(w.path, deletedWorktree.path)
+                ),
               };
-              updateFeature(feature.id, updates);
-              persistFeatureUpdate(feature.id, updates);
+            }
+          );
+
+          // 4. Batch-reset features assigned to the deleted worktree in one
+          //    store mutation to avoid N individual updateFeature calls that
+          //    cascade into React error #185.
+          batchResetBranchFeatures(deletedWorktree.branch);
+
+          // 5. Schedule a deferred refetch to reconcile with the server.
+          //    The server has already completed the deletion, so this
+          //    refetch will return data without the deleted worktree.
+          //    This protects against stale in-flight polling responses
+          //    that may slip through the cancelQueries window and
+          //    overwrite the optimistic update above.
+          const projectPathForRefetch = currentProject.path;
+          setTimeout(() => {
+            queryClient.invalidateQueries({
+              queryKey: queryKeys.worktrees.all(projectPathForRefetch),
+            });
+          }, 1500);
+
+          setSelectedWorktreeForAction(null);
+
+          // 6. Force-sync settings immediately so the reset worktree
+          //    selection is persisted before any potential page reload.
+          //    Without this, the debounced sync (1s) may not complete
+          //    in time and the stale worktree path survives in
+          //    server settings, causing the deleted worktree to
+          //    reappear on next load.
+          forceSyncSettingsToServer().then((ok) => {
+            if (!ok) {
+              logger.warn(
+                'forceSyncSettingsToServer failed after worktree deletion; stale path may reappear on reload'
+              );
             }
           });
-
-          setWorktreeRefreshKey((k) => k + 1);
-          setSelectedWorktreeForAction(null);
         }}
       />
 
@@ -2073,6 +2237,18 @@ export function BoardView() {
         }}
       />
 
+      {/* Change PR Number Dialog */}
+      <ChangePRNumberDialog
+        open={showChangePRNumberDialog}
+        onOpenChange={setShowChangePRNumberDialog}
+        worktree={selectedWorktreeForAction}
+        projectPath={currentProject?.path || null}
+        onChanged={() => {
+          setWorktreeRefreshKey((k) => k + 1);
+          setSelectedWorktreeForAction(null);
+        }}
+      />
+
       {/* Create Branch Dialog */}
       <CreateBranchDialog
         open={showCreateBranchDialog}

apps/ui/src/components/views/board-view/board-error-boundary.tsx

@@ -0,0 +1,74 @@
+import { Component, type ReactNode, type ErrorInfo } from 'react';
+import { createLogger } from '@automaker/utils/logger';
+import { AlertCircle, RefreshCw } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+
+const logger = createLogger('BoardErrorBoundary');
+
+interface Props {
+  children: ReactNode;
+  /** Called when the user clicks "Recover" - should reset worktree to main */
+  onRecover?: () => void;
+}
+
+interface State {
+  hasError: boolean;
+  error: Error | null;
+}
+
+/**
+ * Error boundary for the board's content area (WorktreePanel + KanbanBoard/ListView).
+ *
+ * Catches render errors caused by stale worktree state during worktree switches
+ * (e.g. re-render cascades that trigger React error #185 on mobile Safari PWA).
+ * Instead of crashing the entire page, this shows a recovery UI that resets
+ * the worktree selection to main and retries rendering.
+ */
+export class BoardErrorBoundary extends Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+
+  static getDerivedStateFromError(error: Error): State {
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, errorInfo: ErrorInfo) {
+    logger.error('Board content crashed:', {
+      error: error.message,
+      stack: error.stack,
+      componentStack: errorInfo.componentStack,
+    });
+  }
+
+  handleRecover = () => {
+    this.setState({ hasError: false, error: null });
+    this.props.onRecover?.();
+  };
+
+  render() {
+    if (this.state.hasError) {
+      return (
+        <div className="flex-1 flex flex-col items-center justify-center gap-4 p-6 text-center">
+          <div className="w-12 h-12 rounded-full bg-destructive/10 flex items-center justify-center">
+            <AlertCircle className="w-6 h-6 text-destructive" />
+          </div>
+          <div className="space-y-2">
+            <h3 className="text-lg font-semibold text-foreground">Board crashed</h3>
+            <p className="text-sm text-muted-foreground max-w-sm">
+              A rendering error occurred, possibly during a worktree switch. Click recover to reset
+              to the main branch and retry.
+            </p>
+          </div>
+          <Button variant="outline" size="sm" onClick={this.handleRecover} className="gap-2">
+            <RefreshCw className="w-4 h-4" />
+            Recover
+          </Button>
+        </div>
+      );
+    }
+
+    return this.props.children;
+  }
+}

apps/ui/src/components/views/board-view/components/add-feature-button.tsx

@@ -0,0 +1,188 @@
+import { useState } from 'react';
+import { Button } from '@/components/ui/button';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+import { Plus, ChevronDown, Zap, FileText } from 'lucide-react';
+import type { FeatureTemplate } from '@automaker/types';
+import { cn } from '@/lib/utils';
+
+interface AddFeatureButtonProps {
+  /** Handler for the primary "Add Feature" action (opens full dialog) */
+  onAddFeature: () => void;
+  /** Handler for Quick Add submission */
+  onQuickAdd: () => void;
+  /** Handler for template selection */
+  onTemplateSelect: (template: FeatureTemplate) => void;
+  /** Available templates (filtered to enabled ones) */
+  templates: FeatureTemplate[];
+  /** Whether to show as a small icon button or full button */
+  compact?: boolean;
+  /** Whether the button should take full width */
+  fullWidth?: boolean;
+  /** Additional className */
+  className?: string;
+  /** Test ID prefix */
+  testIdPrefix?: string;
+  /** Shortcut text to display (optional) */
+  shortcut?: string;
+}
+
+export function AddFeatureButton({
+  onAddFeature,
+  onQuickAdd,
+  onTemplateSelect,
+  templates,
+  compact = false,
+  fullWidth = false,
+  className,
+  testIdPrefix = 'add-feature',
+  shortcut,
+}: AddFeatureButtonProps) {
+  const [dropdownOpen, setDropdownOpen] = useState(false);
+
+  // Filter to only enabled templates and sort by order
+  const enabledTemplates = templates
+    .filter((t) => t.enabled !== false)
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+
+  const handleTemplateClick = (template: FeatureTemplate) => {
+    setDropdownOpen(false);
+    onTemplateSelect(template);
+  };
+
+  if (compact) {
+    // Compact mode: Three small icon segments
+    return (
+      <div className={cn('flex', className)}>
+        {/* Segment 1: Add Feature */}
+        <Button
+          variant="default"
+          size="sm"
+          className="h-6 w-6 p-0 rounded-r-none"
+          onClick={onAddFeature}
+          title="Add Feature"
+          data-testid={`${testIdPrefix}-button`}
+        >
+          <Plus className="w-3.5 h-3.5" />
+        </Button>
+        {/* Segment 2: Quick Add */}
+        <Button
+          variant="default"
+          size="sm"
+          className="h-6 w-6 p-0 rounded-none border-l border-primary-foreground/20"
+          onClick={onQuickAdd}
+          title="Quick Add"
+          data-testid={`${testIdPrefix}-quick-add-button`}
+        >
+          <Zap className="w-3 h-3" />
+        </Button>
+        {/* Segment 3: Templates dropdown */}
+        {enabledTemplates.length > 0 && (
+          <DropdownMenu open={dropdownOpen} onOpenChange={setDropdownOpen}>
+            <DropdownMenuTrigger asChild>
+              <Button
+                variant="default"
+                size="sm"
+                className="h-6 w-4 p-0 rounded-l-none border-l border-primary-foreground/20"
+                title="Templates"
+                data-testid={`${testIdPrefix}-dropdown-trigger`}
+              >
+                <ChevronDown className="w-3 h-3" />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="start" sideOffset={4}>
+              {enabledTemplates.map((template) => (
+                <DropdownMenuItem
+                  key={template.id}
+                  onClick={() => handleTemplateClick(template)}
+                  data-testid={`template-menu-item-${template.id}`}
+                >
+                  <FileText className="w-4 h-4 mr-2" />
+                  <span className="truncate max-w-[200px]">{template.name}</span>
+                </DropdownMenuItem>
+              ))}
+            </DropdownMenuContent>
+          </DropdownMenu>
+        )}
+      </div>
+    );
+  }
+
+  // Full mode: Three-segment button
+  return (
+    <div className={cn('flex justify-center', fullWidth && 'w-full', className)}>
+      {/* Segment 1: Add Feature */}
+      <Button
+        variant="default"
+        size="sm"
+        className={cn('h-8 text-xs px-3 rounded-r-none', fullWidth && 'flex-1')}
+        onClick={onAddFeature}
+        data-testid={`${testIdPrefix}-button`}
+      >
+        <Plus className="w-3.5 h-3.5 mr-1.5" />
+        Add Feature
+        {shortcut && (
+          <span className="ml-auto pl-2 text-[10px] font-mono opacity-70 bg-black/20 px-1 py-0.5 rounded">
+            {shortcut}
+          </span>
+        )}
+      </Button>
+      {/* Segment 2: Quick Add */}
+      <Button
+        variant="default"
+        size="sm"
+        className={cn(
+          'h-8 text-xs px-2.5 rounded-none border-l border-primary-foreground/20',
+          fullWidth && 'flex-shrink-0'
+        )}
+        onClick={onQuickAdd}
+        data-testid={`${testIdPrefix}-quick-add-button`}
+      >
+        <Zap className="w-3.5 h-3.5 mr-1" />
+        Quick
+      </Button>
+      {/* Segment 3: Templates dropdown */}
+      <DropdownMenu open={dropdownOpen} onOpenChange={setDropdownOpen}>
+        <DropdownMenuTrigger asChild>
+          <Button
+            variant="default"
+            size="sm"
+            className={cn(
+              'h-8 rounded-l-none border-l border-primary-foreground/20',
+              enabledTemplates.length > 0 ? 'px-1.5' : 'w-7 p-0',
+              fullWidth && 'flex-shrink-0'
+            )}
+            aria-label="Templates"
+            title="Templates"
+            data-testid={`${testIdPrefix}-dropdown-trigger`}
+          >
+            <FileText className="w-3.5 h-3.5 mr-0.5" />
+            <ChevronDown className="w-2.5 h-2.5" />
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent align="end" sideOffset={4}>
+          {enabledTemplates.length > 0 ? (
+            enabledTemplates.map((template) => (
+              <DropdownMenuItem
+                key={template.id}
+                onClick={() => handleTemplateClick(template)}
+                data-testid={`template-menu-item-${template.id}`}
+              >
+                <FileText className="w-4 h-4 mr-2" />
+                <span className="truncate max-w-[200px]">{template.name}</span>
+              </DropdownMenuItem>
+            ))
+          ) : (
+            <DropdownMenuItem disabled className="text-muted-foreground">
+              No templates configured
+            </DropdownMenuItem>
+          )}
+        </DropdownMenuContent>
+      </DropdownMenu>
+    </div>
+  );
+}

apps/ui/src/components/views/board-view/components/list-view/list-view.tsx

@@ -5,12 +5,13 @@ import { Button } from '@/components/ui/button';
 import { getBlockingDependencies } from '@automaker/dependency-resolver';
 import { useAppStore, formatShortcut } from '@/store/app-store';
 import type { Feature } from '@/store/app-store';
-import type { PipelineConfig, FeatureStatusWithPipeline } from '@automaker/types';
+import type { PipelineConfig, FeatureStatusWithPipeline, FeatureTemplate } from '@automaker/types';
 import { ListHeader } from './list-header';
 import { ListRow, sortFeatures } from './list-row';
 import { createRowActionHandlers, type RowActionHandlers } from './row-actions';
 import { getStatusOrder } from './status-badge';
 import { getColumnsWithPipeline } from '../../constants';
+import { AddFeatureButton } from '../add-feature-button';
 import type { SortConfig, SortColumn } from '../../hooks/use-list-view-state';
 
 /** Empty set constant to avoid creating new instances on each render */
@@ -65,6 +66,12 @@ export interface ListViewProps {
   pipelineConfig?: PipelineConfig | null;
   /** Callback to add a new feature */
   onAddFeature?: () => void;
+  /** Callback for quick add */
+  onQuickAdd?: () => void;
+  /** Callback for template selection */
+  onTemplateSelect?: (template: FeatureTemplate) => void;
+  /** Available feature templates */
+  templates?: FeatureTemplate[];
   /** Whether selection mode is enabled */
   isSelectionMode?: boolean;
   /** Set of selected feature IDs */
@@ -125,7 +132,22 @@ const StatusGroupHeader = memo(function StatusGroupHeader({
 /**
  * EmptyState displays a message when there are no features
  */
-const EmptyState = memo(function EmptyState({ onAddFeature }: { onAddFeature?: () => void }) {
+const EmptyState = memo(function EmptyState({
+  onAddFeature,
+  onQuickAdd,
+  onTemplateSelect,
+  templates,
+  shortcut,
+}: {
+  onAddFeature?: () => void;
+  onQuickAdd?: () => void;
+  onTemplateSelect?: (template: FeatureTemplate) => void;
+  templates?: FeatureTemplate[];
+  shortcut?: string;
+}) {
+  // Only show AddFeatureButton if all required handlers are provided
+  const canShowSplitButton = onAddFeature && onQuickAdd && onTemplateSelect;
+
   return (
     <div
       className={cn(
@@ -135,12 +157,21 @@ const EmptyState = memo(function EmptyState({ onAddFeature }: { onAddFeature?: (
       data-testid="list-view-empty"
     >
       <p className="text-sm mb-4">No features to display</p>
-      {onAddFeature && (
+      {canShowSplitButton ? (
+        <AddFeatureButton
+          onAddFeature={onAddFeature}
+          onQuickAdd={onQuickAdd}
+          onTemplateSelect={onTemplateSelect}
+          templates={templates || []}
+          shortcut={shortcut}
+          testIdPrefix="list-view-empty-add-feature"
+        />
+      ) : onAddFeature ? (
         <Button variant="default" size="sm" onClick={onAddFeature}>
           <Plus className="w-4 h-4 mr-2" />
           Add Feature
         </Button>
-      )}
+      ) : null}
     </div>
   );
 });
@@ -190,6 +221,9 @@ export const ListView = memo(function ListView({
   runningAutoTasks,
   pipelineConfig = null,
   onAddFeature,
+  onQuickAdd,
+  onTemplateSelect,
+  templates = [],
   isSelectionMode = false,
   selectedFeatureIds = EMPTY_SET,
   onToggleFeatureSelection,
@@ -388,7 +422,13 @@ export const ListView = memo(function ListView({
   if (totalFeatures === 0) {
     return (
       <div className={cn('flex flex-col h-full bg-background', className)} data-testid="list-view">
-        <EmptyState onAddFeature={onAddFeature} />
+        <EmptyState
+          onAddFeature={onAddFeature}
+          onQuickAdd={onQuickAdd}
+          onTemplateSelect={onTemplateSelect}
+          templates={templates}
+          shortcut={formatShortcut(addFeatureShortcut, true)}
+        />
       </div>
     );
   }
@@ -452,21 +492,17 @@ export const ListView = memo(function ListView({
       </div>
 
       {/* Footer with Add Feature button, styled like board view */}
-      {onAddFeature && (
+      {onAddFeature && onQuickAdd && onTemplateSelect && (
         <div className="border-t border-border px-4 py-2">
-          <Button
-            variant="default"
-            size="sm"
-            onClick={onAddFeature}
-            className="w-full h-9 text-sm"
-            data-testid="list-view-add-feature"
-          >
-            <Plus className="w-4 h-4 mr-2" />
-            Add Feature
-            <span className="ml-auto pl-2 text-[10px] font-mono opacity-70 bg-black/20 px-1.5 py-0.5 rounded">
-              {formatShortcut(addFeatureShortcut, true)}
-            </span>
-          </Button>
+          <AddFeatureButton
+            onAddFeature={onAddFeature}
+            onQuickAdd={onQuickAdd}
+            onTemplateSelect={onTemplateSelect}
+            templates={templates}
+            fullWidth
+            shortcut={formatShortcut(addFeatureShortcut, true)}
+            testIdPrefix="list-view-add-feature"
+          />
         </div>
       )}
     </div>

apps/ui/src/components/views/board-view/dialogs/add-feature-dialog.tsx

@@ -26,9 +26,14 @@ import { useNavigate } from '@tanstack/react-router';
 import { toast } from 'sonner';
 import { cn } from '@/lib/utils';
 import { modelSupportsThinking } from '@/lib/utils';
-import { useAppStore, ThinkingLevel, FeatureImage, PlanningMode, Feature } from '@/store/app-store';
+import { useAppStore } from '@/store/app-store';
+import type { ThinkingLevel, PlanningMode, Feature, FeatureImage } from '@/store/types';
 import type { ReasoningEffort, PhaseModelEntry, AgentModel } from '@automaker/types';
-import { supportsReasoningEffort, isAdaptiveThinkingModel } from '@automaker/types';
+import {
+  supportsReasoningEffort,
+  normalizeThinkingLevelForModel,
+  getThinkingLevelsForModel,
+} from '@automaker/types';
 import {
   PrioritySelector,
   WorkModeSelector,
@@ -211,6 +216,7 @@ export function AddFeatureDialog({
     defaultRequirePlanApproval,
     useWorktrees,
     defaultFeatureModel,
+    defaultThinkingLevel,
     currentProject,
   } = useAppStore();
 
@@ -240,7 +246,22 @@ export function AddFeatureDialog({
       );
       setPlanningMode(defaultPlanningMode);
       setRequirePlanApproval(defaultRequirePlanApproval);
-      setModelEntry(effectiveDefaultFeatureModel);
+
+      // Apply defaultThinkingLevel from settings to the model entry.
+      // This ensures the "Quick-Select Defaults" thinking level setting is respected
+      // even when the user doesn't change the model in the dropdown.
+      const modelId =
+        typeof effectiveDefaultFeatureModel.model === 'string'
+          ? effectiveDefaultFeatureModel.model
+          : '';
+      const availableLevels = getThinkingLevelsForModel(modelId);
+      const effectiveThinkingLevel = availableLevels.includes(defaultThinkingLevel)
+        ? defaultThinkingLevel
+        : availableLevels[0];
+      setModelEntry({
+        ...effectiveDefaultFeatureModel,
+        thinkingLevel: effectiveThinkingLevel,
+      });
 
       // Initialize description history (empty for new feature)
       setDescriptionHistory([]);
@@ -269,6 +290,7 @@ export function AddFeatureDialog({
     defaultPlanningMode,
     defaultRequirePlanApproval,
     effectiveDefaultFeatureModel,
+    defaultThinkingLevel,
     useWorktrees,
     selectedNonMainWorktreeBranch,
     forceCurrentBranchMode,
@@ -287,20 +309,10 @@ export function AddFeatureDialog({
   }, [planningMode]);
 
   const handleModelChange = (entry: PhaseModelEntry) => {
-    // Normalize thinking level when switching between adaptive and non-adaptive models
-    const isNewModelAdaptive =
-      typeof entry.model === 'string' && isAdaptiveThinkingModel(entry.model);
-    const currentLevel = entry.thinkingLevel || 'none';
+    const modelId = typeof entry.model === 'string' ? entry.model : '';
+    const normalizedThinkingLevel = normalizeThinkingLevelForModel(modelId, entry.thinkingLevel);
 
-    if (isNewModelAdaptive && currentLevel !== 'none' && currentLevel !== 'adaptive') {
-      // Switching TO Opus 4.6 with a manual level -> auto-switch to 'adaptive'
-      setModelEntry({ ...entry, thinkingLevel: 'adaptive' });
-    } else if (!isNewModelAdaptive && currentLevel === 'adaptive') {
-      // Switching FROM Opus 4.6 with adaptive -> auto-switch to 'high'
-      setModelEntry({ ...entry, thinkingLevel: 'high' });
-    } else {
-      setModelEntry(entry);
-    }
+    setModelEntry({ ...entry, thinkingLevel: normalizedThinkingLevel });
   };
 
   const buildFeatureData = (): FeatureData | null => {
@@ -394,7 +406,19 @@ export function AddFeatureDialog({
     // When a non-main worktree is selected, use its branch name for custom mode
     setBranchName(selectedNonMainWorktreeBranch || '');
     setPriority(2);
-    setModelEntry(effectiveDefaultFeatureModel);
+    // Apply defaultThinkingLevel to the model entry (same logic as dialog open)
+    const resetModelId =
+      typeof effectiveDefaultFeatureModel.model === 'string'
+        ? effectiveDefaultFeatureModel.model
+        : '';
+    const resetAvailableLevels = getThinkingLevelsForModel(resetModelId);
+    const resetThinkingLevel = resetAvailableLevels.includes(defaultThinkingLevel)
+      ? defaultThinkingLevel
+      : resetAvailableLevels[0];
+    setModelEntry({
+      ...effectiveDefaultFeatureModel,
+      thinkingLevel: resetThinkingLevel,
+    });
     setWorkMode(
       getDefaultWorkMode(useWorktrees, selectedNonMainWorktreeBranch, forceCurrentBranchMode)
     );

apps/ui/src/components/views/board-view/dialogs/backlog-plan-dialog.tsx

@@ -29,7 +29,10 @@ import { useAppStore } from '@/store/app-store';
 /**
  * Normalize PhaseModelEntry or string to PhaseModelEntry
  */
-function normalizeEntry(entry: PhaseModelEntry | string): PhaseModelEntry {
+function normalizeEntry(entry: PhaseModelEntry | string | undefined | null): PhaseModelEntry {
+  if (!entry) {
+    return { model: 'claude-sonnet' as ModelAlias };
+  }
   if (typeof entry === 'string') {
     return { model: entry as ModelAlias | CursorModelId };
   }
@@ -110,7 +113,12 @@ export function BacklogPlanDialog({
     // Use model override if set, otherwise use global default (extract model string from PhaseModelEntry)
     const effectiveModelEntry = modelOverride || normalizeEntry(phaseModels.backlogPlanningModel);
     const effectiveModel = effectiveModelEntry.model;
-    const result = await api.backlogPlan.generate(projectPath, prompt, effectiveModel);
+    const result = await api.backlogPlan.generate(
+      projectPath,
+      prompt,
+      effectiveModel,
+      currentBranch
+    );
     if (!result.success) {
       logger.error('Backlog plan generation failed to start', {
         error: result.error,
@@ -131,7 +139,15 @@ export function BacklogPlanDialog({
     });
     setPrompt('');
     onClose();
-  }, [projectPath, prompt, modelOverride, phaseModels, setIsGeneratingPlan, onClose]);
+  }, [
+    projectPath,
+    prompt,
+    modelOverride,
+    phaseModels,
+    setIsGeneratingPlan,
+    onClose,
+    currentBranch,
+  ]);
 
   const handleApply = useCallback(async () => {
     if (!pendingPlanResult) return;

apps/ui/src/components/views/board-view/dialogs/change-pr-number-dialog.tsx

@@ -0,0 +1,197 @@
+import { useState, useEffect, useCallback } from 'react';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { GitPullRequest } from 'lucide-react';
+import { Spinner } from '@/components/ui/spinner';
+import { getElectronAPI } from '@/lib/electron';
+import { toast } from 'sonner';
+
+interface WorktreeInfo {
+  path: string;
+  branch: string;
+  isMain: boolean;
+  pr?: {
+    number: number;
+    url: string;
+    title: string;
+    state: string;
+    createdAt: string;
+  };
+}
+
+interface ChangePRNumberDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  worktree: WorktreeInfo | null;
+  projectPath: string | null;
+  onChanged: () => void;
+}
+
+export function ChangePRNumberDialog({
+  open,
+  onOpenChange,
+  worktree,
+  projectPath,
+  onChanged,
+}: ChangePRNumberDialogProps) {
+  const [prNumberInput, setPrNumberInput] = useState('');
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Initialize with current PR number when dialog opens
+  useEffect(() => {
+    if (open && worktree?.pr?.number) {
+      setPrNumberInput(String(worktree.pr.number));
+    } else if (open) {
+      setPrNumberInput('');
+    }
+    setError(null);
+  }, [open, worktree]);
+
+  const handleSubmit = useCallback(async () => {
+    if (!worktree) return;
+
+    const trimmed = prNumberInput.trim();
+    if (!/^\d+$/.test(trimmed)) {
+      setError('Please enter a valid positive PR number');
+      return;
+    }
+    const prNumber = Number(trimmed);
+    if (prNumber <= 0) {
+      setError('Please enter a valid positive PR number');
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const api = getElectronAPI();
+      if (!api?.worktree?.updatePRNumber) {
+        setError('Worktree API not available');
+        return;
+      }
+
+      const result = await api.worktree.updatePRNumber(
+        worktree.path,
+        prNumber,
+        projectPath || undefined
+      );
+
+      if (result.success) {
+        const prInfo = result.result?.prInfo;
+        toast.success('PR tracking updated', {
+          description: prInfo?.title
+            ? `Now tracking PR #${prNumber}: ${prInfo.title}`
+            : `Now tracking PR #${prNumber}`,
+        });
+        onOpenChange(false);
+        onChanged();
+      } else {
+        setError(result.error || 'Failed to update PR number');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to update PR number');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [worktree, prNumberInput, projectPath, onOpenChange, onChanged]);
+
+  const handleKeyDown = useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === 'Enter' && !isLoading) {
+        e.preventDefault();
+        handleSubmit();
+      }
+    },
+    [isLoading, handleSubmit]
+  );
+
+  if (!worktree) return null;
+
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(isOpen) => {
+        if (!isLoading) {
+          onOpenChange(isOpen);
+        }
+      }}
+    >
+      <DialogContent className="sm:max-w-[400px]" onKeyDown={handleKeyDown}>
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <GitPullRequest className="w-5 h-5" />
+            Change Tracked PR Number
+          </DialogTitle>
+          <DialogDescription>
+            Update which pull request number is tracked for{' '}
+            <code className="font-mono bg-muted px-1 rounded">{worktree.branch}</code>.
+            {worktree.pr && (
+              <span className="block mt-1 text-xs">
+                Currently tracking PR #{worktree.pr.number}
+              </span>
+            )}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="py-2 space-y-3">
+          <div className="space-y-2">
+            <Label htmlFor="pr-number">Pull Request Number</Label>
+            <div className="flex items-center gap-2">
+              <span className="text-muted-foreground text-sm">#</span>
+              <Input
+                id="pr-number"
+                type="text"
+                inputMode="numeric"
+                placeholder="e.g. 42"
+                value={prNumberInput}
+                onChange={(e) => {
+                  setPrNumberInput(e.target.value);
+                  setError(null);
+                }}
+                disabled={isLoading}
+                autoFocus
+                className="flex-1"
+              />
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Enter the GitHub PR number to associate with this worktree. The PR info will be
+              fetched from GitHub if available.
+            </p>
+          </div>
+
+          {error && <p className="text-sm text-destructive">{error}</p>}
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={isLoading}>
+            Cancel
+          </Button>
+          <Button onClick={handleSubmit} disabled={isLoading || !prNumberInput.trim()}>
+            {isLoading ? (
+              <>
+                <Spinner size="xs" className="mr-2" />
+                Updating...
+              </>
+            ) : (
+              <>
+                <GitPullRequest className="w-4 h-4 mr-2" />
+                Update PR
+              </>
+            )}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

apps/ui/src/components/views/board-view/dialogs/commit-worktree-dialog.tsx

@@ -1,4 +1,4 @@
-import { useState, useEffect, useMemo, useCallback } from 'react';
+import { useState, useEffect, useMemo, useCallback, useRef } from 'react';
 import {
   Dialog,
   DialogContent,
@@ -30,13 +30,17 @@ import {
   ChevronDown,
   ChevronRight,
   Upload,
+  RefreshCw,
 } from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { getElectronAPI } from '@/lib/electron';
+import { getHttpApiClient } from '@/lib/http-api-client';
 import { toast } from 'sonner';
 import { useAppStore } from '@/store/app-store';
+import { resolveModelString } from '@automaker/model-resolver';
 import { cn } from '@/lib/utils';
 import { TruncatedFilePath } from '@/components/ui/truncated-file-path';
+import { ModelOverrideTrigger, useModelOverride } from '@/components/shared';
 import type { FileStatus, MergeStateInfo } from '@/types/electron';
 import { parseDiff, type ParsedFileDiff } from '@/lib/diff-utils';
 
@@ -206,6 +210,11 @@ export function CommitWorktreeDialog({
   const [error, setError] = useState<string | null>(null);
   const enableAiCommitMessages = useAppStore((state) => state.enableAiCommitMessages);
 
+  // Commit message model override
+  const commitModelOverride = useModelOverride({ phase: 'commitMessageModel' });
+  const { effectiveModel: commitEffectiveModel, effectiveModelEntry: commitEffectiveModelEntry } =
+    commitModelOverride;
+
   // File selection state
   const [files, setFiles] = useState<FileStatus[]>([]);
   const [diffContent, setDiffContent] = useState('');
@@ -532,6 +541,46 @@ export function CommitWorktreeDialog({
     }
   };
 
+  // Generate AI commit message
+  const generateCommitMessage = useCallback(async () => {
+    if (!worktree) return;
+
+    setIsGenerating(true);
+    try {
+      const resolvedCommitModel = resolveModelString(commitEffectiveModel);
+      const api = getHttpApiClient();
+      const result = await api.worktree.generateCommitMessage(
+        worktree.path,
+        resolvedCommitModel,
+        commitEffectiveModelEntry?.thinkingLevel,
+        commitEffectiveModelEntry?.providerId
+      );
+
+      if (result.success && result.message) {
+        setMessage(result.message);
+      } else {
+        console.warn('Failed to generate commit message:', result.error);
+        toast.error('Failed to generate commit message', {
+          description: result.error || 'Unknown error',
+        });
+      }
+    } catch (err) {
+      console.warn('Error generating commit message:', err);
+      toast.error('Failed to generate commit message', {
+        description: err instanceof Error ? err.message : 'Unknown error',
+      });
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [worktree, commitEffectiveModel, commitEffectiveModelEntry]);
+
+  // Keep a stable ref to generateCommitMessage so the open-dialog effect
+  // doesn't re-fire (and erase user edits) when the model override changes.
+  const generateCommitMessageRef = useRef(generateCommitMessage);
+  useEffect(() => {
+    generateCommitMessageRef.current = generateCommitMessage;
+  });
+
   // Generate AI commit message when dialog opens (if enabled)
   useEffect(() => {
     if (open && worktree) {
@@ -543,45 +592,7 @@ export function CommitWorktreeDialog({
         return;
       }
 
-      setIsGenerating(true);
-      let cancelled = false;
-
-      const generateMessage = async () => {
-        try {
-          const api = getElectronAPI();
-          if (!api?.worktree?.generateCommitMessage) {
-            if (!cancelled) {
-              setIsGenerating(false);
-            }
-            return;
-          }
-
-          const result = await api.worktree.generateCommitMessage(worktree.path);
-
-          if (cancelled) return;
-
-          if (result.success && result.message) {
-            setMessage(result.message);
-          } else {
-            console.warn('Failed to generate commit message:', result.error);
-            setMessage('');
-          }
-        } catch (err) {
-          if (cancelled) return;
-          console.warn('Error generating commit message:', err);
-          setMessage('');
-        } finally {
-          if (!cancelled) {
-            setIsGenerating(false);
-          }
-        }
-      };
-
-      generateMessage();
-
-      return () => {
-        cancelled = true;
-      };
+      generateCommitMessageRef.current();
     }
   }, [open, worktree, enableAiCommitMessages]);
 
@@ -589,12 +600,12 @@ export function CommitWorktreeDialog({
 
   const allSelected = selectedFiles.size === files.length && files.length > 0;
 
-  // Prevent the dialog from being dismissed while a push is in progress.
+  // Prevent the dialog from being dismissed while a push or generation is in progress.
   // Overlay clicks and Escape key both route through onOpenChange(false); we
-  // intercept those here so the UI stays open until the push completes.
+  // intercept those here so the UI stays open until the operation completes.
   const handleOpenChange = (nextOpen: boolean) => {
-    if (!nextOpen && isPushing) {
-      // Ignore close requests during an active push.
+    if (!nextOpen && (isLoading || isPushing || isGenerating)) {
+      // Ignore close requests during an active commit, push, or generation.
       return;
     }
     onOpenChange(nextOpen);
@@ -813,15 +824,46 @@ export function CommitWorktreeDialog({
 
           {/* Commit Message */}
           <div className="grid gap-1.5">
-            <Label htmlFor="commit-message" className="flex items-center gap-2">
-              Commit Message
-              {isGenerating && (
-                <span className="flex items-center gap-1 text-xs text-muted-foreground">
-                  <Sparkles className="w-3 h-3 animate-pulse" />
-                  Generating...
-                </span>
-              )}
-            </Label>
+            <div className="flex items-center justify-between">
+              <Label htmlFor="commit-message" className="flex items-center gap-2">
+                Commit Message
+                {isGenerating && (
+                  <span className="flex items-center gap-1 text-xs text-muted-foreground">
+                    <Sparkles className="w-3 h-3 animate-pulse" />
+                    Generating...
+                  </span>
+                )}
+              </Label>
+              <div className="flex items-center gap-1">
+                {enableAiCommitMessages && (
+                  <>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={generateCommitMessage}
+                      disabled={isGenerating || isLoading}
+                      className="h-6 px-2 text-xs"
+                      title="Regenerate commit message"
+                    >
+                      {isGenerating ? (
+                        <Spinner size="xs" className="mr-1" />
+                      ) : (
+                        <RefreshCw className="w-3 h-3 mr-1" />
+                      )}
+                      Regenerate
+                    </Button>
+                    <ModelOverrideTrigger
+                      currentModelEntry={commitModelOverride.effectiveModelEntry}
+                      onModelChange={commitModelOverride.setOverride}
+                      phase="commitMessageModel"
+                      isOverridden={commitModelOverride.isOverridden}
+                      size="sm"
+                      variant="icon"
+                    />
+                  </>
+                )}
+              </div>
+            </div>
             <Textarea
               id="commit-message"
               placeholder={

apps/ui/src/components/views/board-view/dialogs/create-pr-dialog.tsx

@@ -26,6 +26,8 @@ import { getElectronAPI } from '@/lib/electron';
 import { getHttpApiClient } from '@/lib/http-api-client';
 import { toast } from 'sonner';
 import { useWorktreeBranches } from '@/hooks/queries';
+import { ModelOverrideTrigger, useModelOverride } from '@/components/shared';
+import { resolveModelString } from '@automaker/model-resolver';
 
 interface RemoteInfo {
   name: string;
@@ -92,6 +94,9 @@ export function CreatePRDialog({
   // Generate description state
   const [isGeneratingDescription, setIsGeneratingDescription] = useState(false);
 
+  // PR description model override
+  const prDescriptionModelOverride = useModelOverride({ phase: 'prDescriptionModel' });
+
   // Use React Query for branch fetching - only enabled when dialog is open
   const { data: branchesData, isLoading: isLoadingBranches } = useWorktreeBranches(
     open ? worktree?.path : undefined,
@@ -306,7 +311,13 @@ export function CreatePRDialog({
         resolvedRef !== baseBranch && resolvedRef.includes('/')
           ? resolvedRef.substring(resolvedRef.indexOf('/') + 1)
           : resolvedRef;
-      const result = await api.worktree.generatePRDescription(worktree.path, branchNameForApi);
+      const result = await api.worktree.generatePRDescription(
+        worktree.path,
+        branchNameForApi,
+        resolveModelString(prDescriptionModelOverride.effectiveModel),
+        prDescriptionModelOverride.effectiveModelEntry.thinkingLevel,
+        prDescriptionModelOverride.effectiveModelEntry.providerId
+      );
 
       if (result.success) {
         if (result.title) {
@@ -491,7 +502,7 @@ export function CreatePRDialog({
 
   return (
     <Dialog open={open} onOpenChange={handleClose}>
-      <DialogContent className="sm:max-w-[550px]">
+      <DialogContent className="sm:max-w-[550px] max-h-[85vh] flex flex-col">
         <DialogHeader>
           <DialogTitle className="flex items-center gap-2">
             <GitPullRequest className="w-5 h-5" />
@@ -565,7 +576,7 @@ export function CreatePRDialog({
           </div>
         ) : (
           <>
-            <div className="grid gap-4 py-4">
+            <div className="grid gap-4 py-4 overflow-y-auto min-h-0 flex-1">
               {worktree.hasChanges && (
                 <div className="grid gap-2">
                   <Label htmlFor="commit-message">
@@ -587,30 +598,40 @@ export function CreatePRDialog({
               <div className="grid gap-2">
                 <div className="flex items-center justify-between">
                   <Label htmlFor="pr-title">PR Title</Label>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={handleGenerateDescription}
-                    disabled={isGeneratingDescription || isLoading}
-                    className="h-6 px-2 text-xs"
-                    title={
-                      worktree.hasChanges
-                        ? 'Generate title and description from commits and uncommitted changes'
-                        : 'Generate title and description from commits'
-                    }
-                  >
-                    {isGeneratingDescription ? (
-                      <>
-                        <Spinner size="xs" className="mr-1" />
-                        Generating...
-                      </>
-                    ) : (
-                      <>
-                        <Sparkles className="w-3 h-3 mr-1" />
-                        Generate with AI
-                      </>
-                    )}
-                  </Button>
+                  <div className="flex items-center gap-1">
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={handleGenerateDescription}
+                      disabled={isGeneratingDescription || isLoading}
+                      className="h-6 px-2 text-xs"
+                      title={
+                        worktree.hasChanges
+                          ? 'Generate title and description from commits and uncommitted changes'
+                          : 'Generate title and description from commits'
+                      }
+                    >
+                      {isGeneratingDescription ? (
+                        <>
+                          <Spinner size="xs" className="mr-1" />
+                          Generating...
+                        </>
+                      ) : (
+                        <>
+                          <Sparkles className="w-3 h-3 mr-1" />
+                          Generate with AI
+                        </>
+                      )}
+                    </Button>
+                    <ModelOverrideTrigger
+                      currentModelEntry={prDescriptionModelOverride.effectiveModelEntry}
+                      onModelChange={prDescriptionModelOverride.setOverride}
+                      phase="prDescriptionModel"
+                      isOverridden={prDescriptionModelOverride.isOverridden}
+                      size="sm"
+                      variant="icon"
+                    />
+                  </div>
                 </div>
                 <Input
                   id="pr-title"
@@ -739,7 +760,7 @@ export function CreatePRDialog({
               {error && <p className="text-sm text-destructive">{error}</p>}
             </div>
 
-            <DialogFooter>
+            <DialogFooter className="shrink-0 pt-2 border-t">
               <Button variant="ghost" onClick={handleClose} disabled={isLoading}>
                 Cancel
               </Button>

apps/ui/src/components/views/board-view/dialogs/create-worktree-dialog.tsx

@@ -10,12 +10,27 @@ import {
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
-import { GitBranch, AlertCircle, ChevronDown, ChevronRight, Globe, RefreshCw } from 'lucide-react';
+import {
+  GitBranch,
+  AlertCircle,
+  ChevronDown,
+  ChevronRight,
+  Globe,
+  RefreshCw,
+  Cloud,
+} from 'lucide-react';
 import { Spinner } from '@/components/ui/spinner';
 import { getElectronAPI } from '@/lib/electron';
 import { getHttpApiClient } from '@/lib/http-api-client';
 import { BranchAutocomplete } from '@/components/ui/branch-autocomplete';
 import { toast } from 'sonner';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
 
 /**
  * Parse git/worktree error messages and return user-friendly versions
@@ -113,10 +128,19 @@ export function CreateWorktreeDialog({
   // allow free-form branch entry via allowCreate as a fallback.
   const [branchFetchError, setBranchFetchError] = useState<string | null>(null);
 
+  // Remote selection state
+  const [selectedRemote, setSelectedRemote] = useState<string>('local');
+  const [availableRemotes, setAvailableRemotes] = useState<Array<{ name: string; url: string }>>(
+    []
+  );
+  const [remoteBranches, setRemoteBranches] = useState<
+    Map<string, Array<{ name: string; fullRef: string }>>
+  >(new Map());
+
   // AbortController ref so in-flight branch fetches can be cancelled when the dialog closes
   const branchFetchAbortRef = useRef<AbortController | null>(null);
 
-  // Fetch available branches (local + remote) when the base branch section is expanded
+  // Fetch available branches and remotes when the base branch section is expanded
   const fetchBranches = useCallback(
     async (signal?: AbortSignal) => {
       if (!projectPath) return;
@@ -125,13 +149,16 @@ export function CreateWorktreeDialog({
       try {
         const api = getHttpApiClient();
 
-        // Fetch branches using the project path (use listBranches on the project root).
-        // Pass the AbortSignal so controller.abort() cancels the in-flight HTTP request.
-        const branchResult = await api.worktree.listBranches(projectPath, true, signal);
+        // Fetch both branches and remotes in parallel
+        const [branchResult, remotesResult] = await Promise.all([
+          api.worktree.listBranches(projectPath, true, signal),
+          api.worktree.listRemotes(projectPath),
+        ]);
 
         // If the fetch was aborted while awaiting, bail out to avoid stale state writes
         if (signal?.aborted) return;
 
+        // Process branches
         if (branchResult.success && branchResult.result) {
           setBranchFetchError(null);
           setAvailableBranches(
@@ -147,6 +174,30 @@ export function CreateWorktreeDialog({
           setBranchFetchError(message);
           setAvailableBranches([{ name: 'main', isRemote: false }]);
         }
+
+        // Process remotes
+        if (remotesResult.success && remotesResult.result) {
+          const remotes = remotesResult.result.remotes;
+          setAvailableRemotes(
+            remotes.map((r: { name: string; url: string; branches: unknown[] }) => ({
+              name: r.name,
+              url: r.url,
+            }))
+          );
+
+          // Build remote branches map for filtering
+          const branchesMap = new Map<string, Array<{ name: string; fullRef: string }>>();
+          remotes.forEach(
+            (r: {
+              name: string;
+              url: string;
+              branches: Array<{ name: string; fullRef: string }>;
+            }) => {
+              branchesMap.set(r.name, r.branches || []);
+            }
+          );
+          setRemoteBranches(branchesMap);
+        }
       } catch (err) {
         // If aborted, don't update state
         if (signal?.aborted) return;
@@ -160,6 +211,8 @@ export function CreateWorktreeDialog({
         // and enable free-form entry (allowCreate) so the user can still type
         // any branch name when the remote list is unavailable.
         setAvailableBranches([{ name: 'main', isRemote: false }]);
+        setAvailableRemotes([]);
+        setRemoteBranches(new Map());
       } finally {
         if (!signal?.aborted) {
           setIsLoadingBranches(false);
@@ -198,27 +251,30 @@ export function CreateWorktreeDialog({
       setAvailableBranches([]);
       setBranchFetchError(null);
       setIsLoadingBranches(false);
+      setSelectedRemote('local');
+      setAvailableRemotes([]);
+      setRemoteBranches(new Map());
     }
   }, [open]);
 
-  // Build branch name list for the autocomplete, with local branches first then remote
+  // Build branch name list for the autocomplete, filtered by selected remote
   const branchNames = useMemo(() => {
-    const local: string[] = [];
-    const remote: string[] = [];
-
-    for (const b of availableBranches) {
-      if (b.isRemote) {
-        // Skip bare remote refs without a branch name (e.g. "origin" by itself)
-        if (!b.name.includes('/')) continue;
-        remote.push(b.name);
-      } else {
-        local.push(b.name);
-      }
+    // If "local" is selected, show only local branches
+    if (selectedRemote === 'local') {
+      return availableBranches.filter((b) => !b.isRemote).map((b) => b.name);
     }
 
-    // Local branches first, then remote branches
-    return [...local, ...remote];
-  }, [availableBranches]);
+    // If a specific remote is selected, show only branches from that remote
+    const remoteBranchList = remoteBranches.get(selectedRemote);
+    if (remoteBranchList) {
+      return remoteBranchList.map((b) => b.fullRef);
+    }
+
+    // Fallback: filter from available branches by remote prefix
+    return availableBranches
+      .filter((b) => b.isRemote && b.name.startsWith(`${selectedRemote}/`))
+      .map((b) => b.name);
+  }, [availableBranches, selectedRemote, remoteBranches]);
 
   // Determine if the selected base branch is a remote branch.
   // Also detect manually entered remote-style names (e.g. "origin/feature")
@@ -418,6 +474,47 @@ export function CreateWorktreeDialog({
                   </div>
                 )}
 
+                {/* Remote Selector */}
+                <div className="grid gap-1.5">
+                  <Label htmlFor="remote-select" className="text-xs text-muted-foreground">
+                    Source
+                  </Label>
+                  <Select
+                    value={selectedRemote}
+                    onValueChange={(value) => {
+                      setSelectedRemote(value);
+                      // Clear base branch when switching remotes
+                      setBaseBranch('');
+                    }}
+                    disabled={isLoadingBranches}
+                  >
+                    <SelectTrigger id="remote-select" className="h-8">
+                      <SelectValue placeholder="Select source..." />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="local">
+                        <div className="flex items-center gap-2">
+                          <GitBranch className="w-3.5 h-3.5" />
+                          <span>Local Branches</span>
+                        </div>
+                      </SelectItem>
+                      {availableRemotes.map((remote) => (
+                        <SelectItem key={remote.name} value={remote.name}>
+                          <div className="flex items-center gap-2">
+                            <Cloud className="w-3.5 h-3.5" />
+                            <span>{remote.name}</span>
+                            {remote.url && (
+                              <span className="text-xs text-muted-foreground truncate max-w-[150px]">
+                                ({remote.url})
+                              </span>
+                            )}
+                          </div>
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </div>
+
                 <BranchAutocomplete
                   value={baseBranch}
                   onChange={(value) => {
@@ -425,9 +522,13 @@ export function CreateWorktreeDialog({
                     setError(null);
                   }}
                   branches={branchNames}
-                  placeholder="Select base branch (default: HEAD)..."
+                  placeholder={
+                    selectedRemote === 'local'
+                      ? 'Select local branch (default: HEAD)...'
+                      : `Select branch from ${selectedRemote}...`
+                  }
                   disabled={isLoadingBranches}
-                  allowCreate={!!branchFetchError}
+                  allowCreate={!!branchFetchError || selectedRemote === 'local'}
                 />
 
                 {isRemoteBaseBranch && (

apps/ui/src/components/views/board-view/dialogs/delete-worktree-dialog.tsx

@@ -72,9 +72,19 @@ export function DeleteWorktreeDialog({
             ? `Branch "${worktree.branch}" was also deleted`
             : `Branch "${worktree.branch}" was kept`,
         });
-        onDeleted(worktree, deleteBranch);
+        // Close the dialog first, then notify the parent.
+        // This ensures the dialog unmounts before the parent
+        // triggers potentially heavy state updates (feature branch
+        // resets, worktree refresh), reducing concurrent re-renders
+        // that can cascade into React error #185.
         onOpenChange(false);
         setDeleteBranch(false);
+        try {
+          onDeleted(worktree, deleteBranch);
+        } catch (error) {
+          // Prevent errors in onDeleted from propagating to the error boundary
+          console.error('onDeleted callback failed:', error);
+        }
       } else {
         toast.error('Failed to delete worktree', {
           description: result.error,

apps/ui/src/components/views/board-view/dialogs/index.ts

@@ -1,4 +1,5 @@
 export { AddFeatureDialog } from './add-feature-dialog';
+export { QuickAddDialog } from './quick-add-dialog';
 export { AgentOutputModal } from './agent-output-modal';
 export { BacklogPlanDialog } from './backlog-plan-dialog';
 export { CompletedFeaturesModal } from './completed-features-modal';
@@ -24,6 +25,7 @@ export { ViewStashesDialog } from './view-stashes-dialog';
 export { StashApplyConflictDialog } from './stash-apply-conflict-dialog';
 export { CherryPickDialog } from './cherry-pick-dialog';
 export { GitPullDialog } from './git-pull-dialog';
+export { ChangePRNumberDialog } from './change-pr-number-dialog';
 export {
   BranchConflictDialog,
   type BranchConflictData,

apps/ui/src/components/views/board-view/dialogs/quick-add-dialog.tsx

@@ -0,0 +1,139 @@
+import { useState, useRef, useEffect } from 'react';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { HotkeyButton } from '@/components/ui/hotkey-button';
+import { Textarea } from '@/components/ui/textarea';
+import { Play, Plus } from 'lucide-react';
+import type { PhaseModelEntry } from '@automaker/types';
+import { PhaseModelSelector } from '@/components/views/settings-view/model-defaults/phase-model-selector';
+import { useAppStore } from '@/store/app-store';
+
+interface QuickAddDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onAdd: (description: string, modelEntry: PhaseModelEntry) => void;
+  onAddAndStart: (description: string, modelEntry: PhaseModelEntry) => void;
+}
+
+export function QuickAddDialog({ open, onOpenChange, onAdd, onAddAndStart }: QuickAddDialogProps) {
+  const [description, setDescription] = useState('');
+  const [descriptionError, setDescriptionError] = useState(false);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+
+  // Get default feature model from store
+  const defaultFeatureModel = useAppStore((s) => s.defaultFeatureModel);
+  const currentProject = useAppStore((s) => s.currentProject);
+
+  // Use project-level default feature model if set, otherwise fall back to global
+  const effectiveDefaultFeatureModel = currentProject?.defaultFeatureModel ?? defaultFeatureModel;
+
+  const [modelEntry, setModelEntry] = useState<PhaseModelEntry>(
+    effectiveDefaultFeatureModel || { model: 'claude-opus' }
+  );
+
+  // Reset form when dialog opens (in useEffect to avoid state mutation during render)
+  useEffect(() => {
+    if (open) {
+      setDescription('');
+      setDescriptionError(false);
+      setModelEntry(effectiveDefaultFeatureModel || { model: 'claude-opus' });
+    }
+  }, [open, effectiveDefaultFeatureModel]);
+
+  const handleSubmit = (actionFn: (description: string, modelEntry: PhaseModelEntry) => void) => {
+    if (!description.trim()) {
+      setDescriptionError(true);
+      textareaRef.current?.focus();
+      return;
+    }
+
+    actionFn(description.trim(), modelEntry);
+    setDescription('');
+    setDescriptionError(false);
+    onOpenChange(false);
+  };
+
+  const handleAdd = () => handleSubmit(onAdd);
+  const handleAddAndStart = () => handleSubmit(onAddAndStart);
+
+  const handleDescriptionChange = (value: string) => {
+    setDescription(value);
+    if (value.trim()) {
+      setDescriptionError(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent
+        compact
+        className="sm:max-w-md"
+        data-testid="quick-add-dialog"
+        onOpenAutoFocus={(e) => {
+          e.preventDefault();
+          textareaRef.current?.focus();
+        }}
+      >
+        <DialogHeader>
+          <DialogTitle>Quick Add Feature</DialogTitle>
+          <DialogDescription>
+            Create a new feature with minimal configuration. All other settings use defaults.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="py-4 space-y-4">
+          {/* Description Input */}
+          <div className="space-y-2">
+            <label htmlFor="quick-add-description" className="text-sm font-medium">
+              Description
+            </label>
+            <Textarea
+              ref={textareaRef}
+              id="quick-add-description"
+              value={description}
+              onChange={(e) => handleDescriptionChange(e.target.value)}
+              placeholder="Describe what you want to build..."
+              className={
+                descriptionError ? 'border-destructive focus-visible:ring-destructive' : ''
+              }
+              rows={3}
+              data-testid="quick-add-description-input"
+            />
+            {descriptionError && (
+              <p className="text-xs text-destructive">Description is required</p>
+            )}
+          </div>
+
+          {/* Model Selection */}
+          <PhaseModelSelector value={modelEntry} onChange={setModelEntry} compact align="end" />
+        </div>
+
+        <DialogFooter className="gap-2">
+          <Button variant="ghost" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button variant="secondary" onClick={handleAdd} data-testid="quick-add-button">
+            <Plus className="w-4 h-4 mr-2" />
+            Add
+          </Button>
+          <HotkeyButton
+            onClick={handleAddAndStart}
+            hotkey={{ key: 'Enter', cmdCtrl: true }}
+            hotkeyActive={open}
+            data-testid="quick-add-and-start-button"
+          >
+            <Play className="w-4 h-4 mr-2" />
+            Make
+          </HotkeyButton>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

apps/ui/src/components/views/board-view/hooks/use-board-actions.ts

@@ -1,5 +1,6 @@
 // @ts-nocheck - feature update logic with partial updates and image/file handling
 import { useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
 import {
   Feature,
   FeatureImage,
@@ -18,11 +19,29 @@ import { useVerifyFeature, useResumeFeature } from '@/hooks/mutations';
 import { truncateDescription } from '@/lib/utils';
 import { getBlockingDependencies } from '@automaker/dependency-resolver';
 import { createLogger } from '@automaker/utils/logger';
+import { queryKeys } from '@/lib/query-keys';
 
 const logger = createLogger('BoardActions');
 
 const MAX_DUPLICATES = 50;
 
+/**
+ * Removes a running task from all worktrees for a given project.
+ * Used when stopping features to ensure the task is removed from all worktree contexts,
+ * not just the current one.
+ */
+function removeRunningTaskFromAllWorktrees(projectId: string, featureId: string): void {
+  const store = useAppStore.getState();
+  const prefix = `${projectId}::`;
+  for (const [key, worktreeState] of Object.entries(store.autoModeByWorktree)) {
+    if (key.startsWith(prefix) && worktreeState.runningTasks?.includes(featureId)) {
+      const branchPart = key.slice(prefix.length);
+      const branch = branchPart === '__main__' ? null : branchPart;
+      store.removeRunningTask(projectId, branch, featureId);
+    }
+  }
+}
+
 interface UseBoardActionsProps {
   currentProject: { path: string; id: string } | null;
   features: Feature[];
@@ -84,17 +103,21 @@ export function useBoardActions({
   onWorktreeAutoSelect,
   currentWorktreeBranch,
 }: UseBoardActionsProps) {
-  const {
-    addFeature,
-    updateFeature,
-    removeFeature,
-    moveFeature,
-    useWorktrees,
-    enableDependencyBlocking,
-    skipVerificationInAutoMode,
-    isPrimaryWorktreeBranch,
-    getPrimaryWorktreeBranch,
-  } = useAppStore();
+  const queryClient = useQueryClient();
+
+  // IMPORTANT: Use individual selectors instead of bare useAppStore() to prevent
+  // subscribing to the entire store. Bare useAppStore() causes the host component
+  // (BoardView) to re-render on EVERY store change, which cascades through effects
+  // and triggers React error #185 (maximum update depth exceeded).
+  const addFeature = useAppStore((s) => s.addFeature);
+  const updateFeature = useAppStore((s) => s.updateFeature);
+  const removeFeature = useAppStore((s) => s.removeFeature);
+  const moveFeature = useAppStore((s) => s.moveFeature);
+  const worktreesEnabled = useAppStore((s) => s.useWorktrees);
+  const enableDependencyBlocking = useAppStore((s) => s.enableDependencyBlocking);
+  const skipVerificationInAutoMode = useAppStore((s) => s.skipVerificationInAutoMode);
+  const isPrimaryWorktreeBranch = useAppStore((s) => s.isPrimaryWorktreeBranch);
+  const getPrimaryWorktreeBranch = useAppStore((s) => s.getPrimaryWorktreeBranch);
   const autoMode = useAutoMode();
 
   // React Query mutations for feature operations
@@ -501,6 +524,10 @@ export function useBoardActions({
       if (isRunning) {
         try {
           await autoMode.stopFeature(featureId);
+          // Remove from all worktrees
+          if (currentProject) {
+            removeRunningTaskFromAllWorktrees(currentProject.id, featureId);
+          }
           toast.success('Agent stopped', {
             description: `Stopped and deleted: ${truncateDescription(feature.description)}`,
           });
@@ -531,7 +558,7 @@ export function useBoardActions({
       removeFeature(featureId);
       await persistFeatureDelete(featureId);
     },
-    [features, runningAutoTasks, autoMode, removeFeature, persistFeatureDelete]
+    [features, runningAutoTasks, autoMode, removeFeature, persistFeatureDelete, currentProject]
   );
 
   const handleRunFeature = useCallback(
@@ -549,7 +576,7 @@ export function useBoardActions({
       const result = await api.autoMode.runFeature(
         currentProject.path,
         feature.id,
-        useWorktrees
+        worktreesEnabled
         // No worktreePath - server derives from feature.branchName
       );
 
@@ -560,7 +587,7 @@ export function useBoardActions({
         throw new Error(result.error || 'Failed to start feature');
       }
     },
-    [currentProject, useWorktrees]
+    [currentProject, worktreesEnabled]
   );
 
   const handleStartImplementation = useCallback(
@@ -693,9 +720,9 @@ export function useBoardActions({
         logger.error('No current project');
         return;
       }
-      resumeFeatureMutation.mutate({ featureId: feature.id, useWorktrees });
+      resumeFeatureMutation.mutate({ featureId: feature.id, useWorktrees: worktreesEnabled });
     },
-    [currentProject, resumeFeatureMutation, useWorktrees]
+    [currentProject, resumeFeatureMutation, worktreesEnabled]
   );
 
   const handleManualVerify = useCallback(
@@ -780,7 +807,7 @@ export function useBoardActions({
         followUpFeature.id,
         followUpPrompt,
         imagePaths,
-        useWorktrees
+        worktreesEnabled
       );
 
       if (!result.success) {
@@ -818,7 +845,7 @@ export function useBoardActions({
     setFollowUpPrompt,
     setFollowUpImagePaths,
     setFollowUpPreviewMap,
-    useWorktrees,
+    worktreesEnabled,
   ]);
 
   const handleCommitFeature = useCallback(
@@ -997,6 +1024,31 @@ export function useBoardActions({
             ? 'waiting_approval'
             : 'backlog';
 
+        // Remove the running task from ALL worktrees for this project.
+        // autoMode.stopFeature only removes from its scoped worktree (branchName),
+        // but the feature may be tracked under a different worktree branch.
+        // Without this, runningAutoTasksAllWorktrees still contains the feature
+        // and the board column logic forces it into in_progress.
+        if (currentProject) {
+          removeRunningTaskFromAllWorktrees(currentProject.id, feature.id);
+        }
+
+        // Optimistically update the React Query features cache so the board
+        // moves the card immediately. Without this, the card stays in
+        // "in_progress" until the next poll cycle (30s) because the async
+        // refetch races with the persistFeatureUpdate write.
+        if (currentProject) {
+          queryClient.setQueryData(
+            queryKeys.features.all(currentProject.path),
+            (oldFeatures: Feature[] | undefined) => {
+              if (!oldFeatures) return oldFeatures;
+              return oldFeatures.map((f) =>
+                f.id === feature.id ? { ...f, status: targetStatus } : f
+              );
+            }
+          );
+        }
+
         if (targetStatus !== feature.status) {
           moveFeature(feature.id, targetStatus);
           // Must await to ensure file is written before user can restart
@@ -1018,7 +1070,7 @@ export function useBoardActions({
         });
       }
     },
-    [autoMode, moveFeature, persistFeatureUpdate]
+    [autoMode, moveFeature, persistFeatureUpdate, currentProject, queryClient]
   );
 
   const handleStartNextFeatures = useCallback(async () => {
@@ -1135,6 +1187,12 @@ export function useBoardActions({
           })
         )
       );
+      // Remove from all worktrees
+      if (currentProject) {
+        for (const feature of runningVerified) {
+          removeRunningTaskFromAllWorktrees(currentProject.id, feature.id);
+        }
+      }
     }
 
     // Use bulk update API for a single server request instead of N individual calls

apps/ui/src/components/views/board-view/hooks/use-board-drag-drop.ts

@@ -33,7 +33,12 @@ export function useBoardDragDrop({
   const [pendingDependencyLink, setPendingDependencyLink] = useState<PendingDependencyLink | null>(
     null
   );
-  const { moveFeature, updateFeature } = useAppStore();
+  // IMPORTANT: Use individual selectors instead of bare useAppStore() to prevent
+  // subscribing to the entire store. Bare useAppStore() causes the host component
+  // (BoardView) to re-render on EVERY store change, which cascades through effects
+  // and triggers React error #185 (maximum update depth exceeded).
+  const moveFeature = useAppStore((s) => s.moveFeature);
+  const updateFeature = useAppStore((s) => s.updateFeature);
   const autoMode = useAutoMode();
 
   // Note: getOrCreateWorktreeForFeature removed - worktrees are now created server-side

apps/ui/src/components/views/board-view/hooks/use-board-persistence.ts

@@ -14,7 +14,11 @@ interface UseBoardPersistenceProps {
 }
 
 export function useBoardPersistence({ currentProject }: UseBoardPersistenceProps) {
-  const { updateFeature } = useAppStore();
+  // IMPORTANT: Use individual selector instead of bare useAppStore() to prevent
+  // subscribing to the entire store. Bare useAppStore() causes the host component
+  // (BoardView) to re-render on EVERY store change, which cascades through effects
+  // and triggers React error #185 (maximum update depth exceeded).
+  const updateFeature = useAppStore((s) => s.updateFeature);
   const queryClient = useQueryClient();
 
   // Persist feature update to API (replaces saveFeatures)

apps/ui/src/components/views/board-view/kanban-board.tsx

@@ -13,11 +13,20 @@ import { SortableContext, verticalListSortingStrategy } from '@dnd-kit/sortable'
 import { Button } from '@/components/ui/button';
 import { KanbanColumn, KanbanCard, EmptyStateCard } from './components';
 import { Feature, useAppStore, formatShortcut } from '@/store/app-store';
-import { Archive, Settings2, CheckSquare, GripVertical, Plus, CheckCircle2 } from 'lucide-react';
+import {
+  Archive,
+  Settings2,
+  CheckSquare,
+  GripVertical,
+  Plus,
+  CheckCircle2,
+  Zap,
+} from 'lucide-react';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
 import { useResponsiveKanban } from '@/hooks/use-responsive-kanban';
 import { getColumnsWithPipeline, type ColumnId } from './constants';
-import type { PipelineConfig } from '@automaker/types';
+import type { PipelineConfig, FeatureTemplate } from '@automaker/types';
+import { AddFeatureButton } from './components/add-feature-button';
 import { cn } from '@/lib/utils';
 interface KanbanBoardProps {
   activeFeature: Feature | null;
@@ -53,6 +62,10 @@ interface KanbanBoardProps {
   runningAutoTasks: string[];
   onArchiveAllVerified: () => void;
   onAddFeature: () => void;
+  onQuickAdd: () => void;
+  onTemplateSelect: (template: FeatureTemplate) => void;
+  templates: FeatureTemplate[];
+  addFeatureShortcut?: string;
   onShowCompletedModal: () => void;
   completedCount: number;
   pipelineConfig: PipelineConfig | null;
@@ -292,6 +305,10 @@ export function KanbanBoard({
   runningAutoTasks,
   onArchiveAllVerified,
   onAddFeature,
+  onQuickAdd,
+  onTemplateSelect,
+  templates,
+  addFeatureShortcut: addFeatureShortcutProp,
   onShowCompletedModal,
   completedCount,
   pipelineConfig,
@@ -311,7 +328,7 @@ export function KanbanBoard({
 
   // Get the keyboard shortcut for adding features
   const keyboardShortcuts = useAppStore((state) => state.keyboardShortcuts);
-  const addFeatureShortcut = keyboardShortcuts.addFeature || 'N';
+  const addFeatureShortcut = addFeatureShortcutProp || keyboardShortcuts.addFeature || 'N';
 
   // Use responsive column widths based on window size
   // containerStyle handles centering and ensures columns fit without horizontal scroll in Electron
@@ -408,16 +425,28 @@ export function KanbanBoard({
                       </div>
                     ) : column.id === 'backlog' ? (
                       <div className="flex items-center gap-1">
-                        <Button
-                          variant="default"
-                          size="sm"
-                          className="h-6 w-6 p-0"
-                          onClick={onAddFeature}
-                          title="Add Feature"
-                          data-testid="add-feature-button"
-                        >
-                          <Plus className="w-3.5 h-3.5" />
-                        </Button>
+                        <div className="flex items-center">
+                          <Button
+                            variant="default"
+                            size="sm"
+                            className="h-6 w-6 p-0 rounded-r-none"
+                            onClick={onAddFeature}
+                            title="Add Feature"
+                            data-testid="add-feature-button"
+                          >
+                            <Plus className="w-3.5 h-3.5" />
+                          </Button>
+                          <Button
+                            variant="default"
+                            size="sm"
+                            className="h-6 w-6 p-0 rounded-l-none border-l border-primary-foreground/20"
+                            onClick={onQuickAdd}
+                            title="Quick Add Feature"
+                            data-testid="quick-add-feature-button"
+                          >
+                            <Zap className="w-3.5 h-3.5" />
+                          </Button>
+                        </div>
                         <Button
                           variant="ghost"
                           size="sm"
@@ -494,19 +523,14 @@ export function KanbanBoard({
                   }
                   footerAction={
                     column.id === 'backlog' ? (
-                      <Button
-                        variant="default"
-                        size="sm"
-                        className="w-full h-9 text-sm"
-                        onClick={onAddFeature}
-                        data-testid="add-feature-floating-button"
-                      >
-                        <Plus className="w-4 h-4 mr-2" />
-                        Add Feature
-                        <span className="ml-auto pl-2 text-[10px] font-mono opacity-70 bg-black/20 px-1.5 py-0.5 rounded">
-                          {formatShortcut(addFeatureShortcut, true)}
-                        </span>
-                      </Button>
+                      <AddFeatureButton
+                        onAddFeature={onAddFeature}
+                        onQuickAdd={onQuickAdd}
+                        onTemplateSelect={onTemplateSelect}
+                        templates={templates}
+                        fullWidth
+                        shortcut={formatShortcut(addFeatureShortcut, true)}
+                      />
                     ) : undefined
                   }
                 >

apps/ui/src/components/views/board-view/shared/enhancement/enhance-with-ai.tsx

@@ -6,13 +6,21 @@ import {
   DropdownMenu,
   DropdownMenuContent,
   DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu';
 import { Sparkles, ChevronDown, ChevronRight } from 'lucide-react';
 import { toast } from 'sonner';
 import { getElectronAPI } from '@/lib/electron';
 import { ModelOverrideTrigger, useModelOverride } from '@/components/shared';
-import { EnhancementMode, ENHANCEMENT_MODE_LABELS } from './enhancement-constants';
+import {
+  EnhancementMode,
+  ENHANCEMENT_MODE_LABELS,
+  REWRITE_MODES,
+  ADDITIVE_MODES,
+  isAdditiveMode,
+} from './enhancement-constants';
 import { useAppStore } from '@/store/app-store';
 
 const logger = createLogger('EnhanceWithAI');
@@ -79,7 +87,10 @@ export function EnhanceWithAI({
 
       if (result?.success && result.enhancedText) {
         const originalText = value;
-        const enhancedText = result.enhancedText;
+        // For additive modes, prepend the original description above the AI-generated content
+        const enhancedText = isAdditiveMode(enhancementMode)
+          ? `${originalText.trim()}\n\n${result.enhancedText.trim()}`
+          : result.enhancedText;
         onChange(enhancedText);
 
         // Track in history if callback provided (includes original for restoration)
@@ -119,13 +130,19 @@ export function EnhanceWithAI({
               </Button>
             </DropdownMenuTrigger>
             <DropdownMenuContent align="start">
-              {(Object.entries(ENHANCEMENT_MODE_LABELS) as [EnhancementMode, string][]).map(
-                ([mode, label]) => (
-                  <DropdownMenuItem key={mode} onClick={() => setEnhancementMode(mode)}>
-                    {label}
-                  </DropdownMenuItem>
-                )
-              )}
+              <DropdownMenuLabel>Rewrite</DropdownMenuLabel>
+              {REWRITE_MODES.map((mode) => (
+                <DropdownMenuItem key={mode} onClick={() => setEnhancementMode(mode)}>
+                  {ENHANCEMENT_MODE_LABELS[mode]}
+                </DropdownMenuItem>
+              ))}
+              <DropdownMenuSeparator />
+              <DropdownMenuLabel>Append Details</DropdownMenuLabel>
+              {ADDITIVE_MODES.map((mode) => (
+                <DropdownMenuItem key={mode} onClick={() => setEnhancementMode(mode)}>
+                  {ENHANCEMENT_MODE_LABELS[mode]}
+                </DropdownMenuItem>
+              ))}
             </DropdownMenuContent>
           </DropdownMenu>
 

apps/ui/src/components/views/board-view/shared/enhancement/enhancement-constants.ts

@@ -1,5 +1,5 @@
-/** Enhancement mode options for AI-powered prompt improvement */
-export type EnhancementMode = 'improve' | 'technical' | 'simplify' | 'acceptance' | 'ux-reviewer';
+import type { EnhancementMode } from '@automaker/types';
+export type { EnhancementMode } from '@automaker/types';
 
 /** Labels for enhancement modes displayed in the UI */
 export const ENHANCEMENT_MODE_LABELS: Record<EnhancementMode, string> = {
@@ -18,3 +18,14 @@ export const ENHANCEMENT_MODE_DESCRIPTIONS: Record<EnhancementMode, string> = {
   acceptance: 'Add specific acceptance criteria and test cases',
   'ux-reviewer': 'Add user experience considerations and flows',
 };
+
+/** Modes that rewrite/replace the entire description */
+export const REWRITE_MODES: EnhancementMode[] = ['improve', 'simplify'];
+
+/** Modes that append additional content below the original description */
+export const ADDITIVE_MODES: EnhancementMode[] = ['technical', 'acceptance', 'ux-reviewer'];
+
+/** Check if a mode appends content rather than replacing */
+export function isAdditiveMode(mode: EnhancementMode): boolean {
+  return ADDITIVE_MODES.includes(mode);
+}

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-actions-dropdown.tsx

@@ -14,6 +14,7 @@ import {
 import {
   Trash2,
   MoreHorizontal,
+  GitBranch,
   GitCommit,
   GitPullRequest,
   Download,
@@ -42,6 +43,9 @@ import {
   XCircle,
   CheckCircle,
   Settings2,
+  ArrowLeftRight,
+  Check,
+  Hash,
 } from 'lucide-react';
 import { toast } from 'sonner';
 import { cn } from '@/lib/utils';
@@ -104,6 +108,7 @@ interface WorktreeActionsDropdownProps {
   onDiscardChanges: (worktree: WorktreeInfo) => void;
   onCommit: (worktree: WorktreeInfo) => void;
   onCreatePR: (worktree: WorktreeInfo) => void;
+  onChangePRNumber?: (worktree: WorktreeInfo) => void;
   onAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onAutoAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onResolveConflicts: (worktree: WorktreeInfo) => void;
@@ -138,6 +143,97 @@ interface WorktreeActionsDropdownProps {
   onRunTerminalScript?: (worktree: WorktreeInfo, command: string) => void;
   /** Callback to open the script editor UI */
   onEditScripts?: () => void;
+  /** Whether sync is in progress */
+  isSyncing?: boolean;
+  /** Sync (pull + push) callback */
+  onSync?: (worktree: WorktreeInfo) => void;
+  /** Sync with a specific remote */
+  onSyncWithRemote?: (worktree: WorktreeInfo, remote: string) => void;
+  /** Set tracking branch to a specific remote */
+  onSetTracking?: (worktree: WorktreeInfo, remote: string) => void;
+  /** List of remote names that have a branch matching the current branch name */
+  remotesWithBranch?: string[];
+  /** Available worktrees for swapping into this slot (non-main only) */
+  availableWorktreesForSwap?: WorktreeInfo[];
+  /** The slot index for this tab in the pinned list (0-based, excluding main) */
+  slotIndex?: number;
+  /** Callback when user swaps this slot to a different worktree */
+  onSwapWorktree?: (slotIndex: number, newBranch: string) => void;
+  /** List of currently pinned branch names (to show which are pinned in the swap dropdown) */
+  pinnedBranches?: string[];
+}
+
+/**
+ * A remote item that either renders as a split-button with "Set as Tracking Branch"
+ * sub-action, or a plain menu item if onSetTracking is not provided.
+ */
+function RemoteActionMenuItem({
+  remote,
+  icon: Icon,
+  trackingRemote,
+  isDisabled,
+  isGitOpsAvailable,
+  onAction,
+  onSetTracking,
+}: {
+  remote: { name: string; url: string };
+  icon: typeof Download;
+  trackingRemote?: string;
+  isDisabled: boolean;
+  isGitOpsAvailable: boolean;
+  onAction: () => void;
+  onSetTracking?: () => void;
+}) {
+  if (onSetTracking) {
+    return (
+      <DropdownMenuSub key={remote.name}>
+        <div className="flex items-center">
+          <DropdownMenuItem
+            onClick={onAction}
+            disabled={isDisabled || !isGitOpsAvailable}
+            className="text-xs flex-1 pr-0 rounded-r-none"
+          >
+            <Icon className="w-3.5 h-3.5 mr-2" />
+            {remote.name}
+            {trackingRemote === remote.name && (
+              <span className="ml-auto text-[10px] bg-muted text-muted-foreground px-1.5 py-0.5 rounded mr-2">
+                tracking
+              </span>
+            )}
+          </DropdownMenuItem>
+          <DropdownMenuSubTrigger
+            className="text-xs px-1 rounded-l-none border-l border-border/30 h-8"
+            disabled={!isGitOpsAvailable}
+          />
+        </div>
+        <DropdownMenuSubContent>
+          <DropdownMenuItem
+            onClick={onSetTracking}
+            disabled={!isGitOpsAvailable}
+            className="text-xs"
+          >
+            <GitBranch className="w-3.5 h-3.5 mr-2" />
+            Set as Tracking Branch
+          </DropdownMenuItem>
+        </DropdownMenuSubContent>
+      </DropdownMenuSub>
+    );
+  }
+
+  return (
+    <DropdownMenuItem
+      key={remote.name}
+      onClick={onAction}
+      disabled={isDisabled || !isGitOpsAvailable}
+      className="text-xs"
+    >
+      <Icon className="w-3.5 h-3.5 mr-2" />
+      {remote.name}
+      <span className="ml-auto text-[10px] text-muted-foreground max-w-[100px] truncate">
+        {remote.url}
+      </span>
+    </DropdownMenuItem>
+  );
 }
 
 export function WorktreeActionsDropdown({
@@ -175,6 +271,7 @@ export function WorktreeActionsDropdown({
   onDiscardChanges,
   onCommit,
   onCreatePR,
+  onChangePRNumber,
   onAddressPRComments,
   onAutoAddressPRComments,
   onResolveConflicts,
@@ -198,6 +295,15 @@ export function WorktreeActionsDropdown({
   terminalScripts,
   onRunTerminalScript,
   onEditScripts,
+  isSyncing = false,
+  onSync,
+  onSyncWithRemote,
+  onSetTracking,
+  remotesWithBranch,
+  availableWorktreesForSwap,
+  slotIndex,
+  onSwapWorktree,
+  pinnedBranches,
 }: WorktreeActionsDropdownProps) {
   // Get available editors for the "Open In" submenu
   const { editors } = useAvailableEditors();
@@ -242,6 +348,21 @@ export function WorktreeActionsDropdown({
         ? 'Repository has no commits yet'
         : null;
 
+  // Check if the branch exists on remotes other than the tracking remote.
+  // This indicates the branch was pushed to a different remote than the one being tracked,
+  // so the ahead/behind counts may be misleading.
+  const otherRemotesWithBranch = useMemo(() => {
+    if (!remotesWithBranch || remotesWithBranch.length === 0) return [];
+    if (!trackingRemote) return remotesWithBranch;
+    return remotesWithBranch.filter((r) => r !== trackingRemote);
+  }, [remotesWithBranch, trackingRemote]);
+
+  // True when branch exists on a different remote but NOT on the tracking remote
+  const isOnDifferentRemote =
+    otherRemotesWithBranch.length > 0 &&
+    trackingRemote &&
+    !remotesWithBranch?.includes(trackingRemote);
+
   // Determine if the changes/PR section has any visible items
   // Show Create PR when no existing PR is linked
   const showCreatePR = !hasPR;
@@ -699,11 +820,17 @@ export function WorktreeActionsDropdown({
                   {!isGitOpsAvailable && (
                     <AlertCircle className="w-3 h-3 ml-auto text-muted-foreground" />
                   )}
-                  {isGitOpsAvailable && behindCount > 0 && (
+                  {isGitOpsAvailable && !isOnDifferentRemote && behindCount > 0 && (
                     <span className="ml-auto text-[10px] bg-muted px-1.5 py-0.5 rounded">
                       {behindCount} behind
                     </span>
                   )}
+                  {isGitOpsAvailable && isOnDifferentRemote && (
+                    <span className="ml-auto inline-flex items-center gap-0.5 text-[10px] bg-blue-500/20 text-blue-600 dark:text-blue-400 px-1.5 py-0.5 rounded">
+                      <Globe className="w-2.5 h-2.5" />
+                      on {otherRemotesWithBranch.join(', ')}
+                    </span>
+                  )}
                 </DropdownMenuItem>
                 <DropdownMenuSubTrigger
                   className={cn(
@@ -719,18 +846,20 @@ export function WorktreeActionsDropdown({
                 </DropdownMenuLabel>
                 <DropdownMenuSeparator />
                 {remotes.map((remote) => (
-                  <DropdownMenuItem
+                  <RemoteActionMenuItem
                     key={remote.name}
-                    onClick={() => isGitOpsAvailable && onPullWithRemote(worktree, remote.name)}
-                    disabled={isPulling || !isGitOpsAvailable}
-                    className="text-xs"
-                  >
-                    <Download className="w-3.5 h-3.5 mr-2" />
-                    {remote.name}
-                    <span className="ml-auto text-[10px] text-muted-foreground max-w-[100px] truncate">
-                      {remote.url}
-                    </span>
-                  </DropdownMenuItem>
+                    remote={remote}
+                    icon={Download}
+                    trackingRemote={trackingRemote}
+                    isDisabled={isPulling}
+                    isGitOpsAvailable={isGitOpsAvailable}
+                    onAction={() => isGitOpsAvailable && onPullWithRemote(worktree, remote.name)}
+                    onSetTracking={
+                      onSetTracking
+                        ? () => isGitOpsAvailable && onSetTracking(worktree, remote.name)
+                        : undefined
+                    }
+                  />
                 ))}
               </DropdownMenuSubContent>
             </DropdownMenuSub>
@@ -746,11 +875,17 @@ export function WorktreeActionsDropdown({
               {!isGitOpsAvailable && (
                 <AlertCircle className="w-3 h-3 ml-auto text-muted-foreground" />
               )}
-              {isGitOpsAvailable && behindCount > 0 && (
+              {isGitOpsAvailable && !isOnDifferentRemote && behindCount > 0 && (
                 <span className="ml-auto text-[10px] bg-muted px-1.5 py-0.5 rounded">
                   {behindCount} behind
                 </span>
               )}
+              {isGitOpsAvailable && isOnDifferentRemote && (
+                <span className="ml-auto inline-flex items-center gap-0.5 text-[10px] bg-blue-500/20 text-blue-600 dark:text-blue-400 px-1.5 py-0.5 rounded">
+                  <Globe className="w-2.5 h-2.5" />
+                  on {otherRemotesWithBranch.join(', ')}
+                </span>
+              )}
             </DropdownMenuItem>
           )}
         </TooltipWrapper>
@@ -770,7 +905,9 @@ export function WorktreeActionsDropdown({
                     }
                   }}
                   disabled={
-                    isPushing || (hasRemoteBranch && aheadCount === 0) || !isGitOpsAvailable
+                    isPushing ||
+                    (hasRemoteBranch && !isOnDifferentRemote && aheadCount === 0) ||
+                    !isGitOpsAvailable
                   }
                   className={cn(
                     'text-xs flex-1 pr-0 rounded-r-none',
@@ -788,21 +925,33 @@ export function WorktreeActionsDropdown({
                       local only
                     </span>
                   )}
-                  {isGitOpsAvailable && hasRemoteBranch && aheadCount > 0 && (
-                    <span className="ml-auto text-[10px] bg-primary/20 text-primary px-1.5 py-0.5 rounded">
-                      {aheadCount} ahead
-                    </span>
-                  )}
-                  {isGitOpsAvailable && hasRemoteBranch && trackingRemote && (
-                    <span
-                      className={cn(
-                        'text-[10px] bg-muted text-muted-foreground px-1.5 py-0.5 rounded',
-                        aheadCount > 0 ? 'ml-1' : 'ml-auto'
-                      )}
-                    >
-                      {trackingRemote}
+                  {isGitOpsAvailable && hasRemoteBranch && isOnDifferentRemote && (
+                    <span className="ml-auto inline-flex items-center gap-0.5 text-[10px] bg-blue-500/20 text-blue-600 dark:text-blue-400 px-1.5 py-0.5 rounded">
+                      <Globe className="w-2.5 h-2.5" />
+                      on {otherRemotesWithBranch.join(', ')}
                     </span>
                   )}
+                  {isGitOpsAvailable &&
+                    hasRemoteBranch &&
+                    !isOnDifferentRemote &&
+                    aheadCount > 0 && (
+                      <span className="ml-auto text-[10px] bg-primary/20 text-primary px-1.5 py-0.5 rounded">
+                        {aheadCount} ahead
+                      </span>
+                    )}
+                  {isGitOpsAvailable &&
+                    hasRemoteBranch &&
+                    !isOnDifferentRemote &&
+                    trackingRemote && (
+                      <span
+                        className={cn(
+                          'text-[10px] bg-muted text-muted-foreground px-1.5 py-0.5 rounded',
+                          aheadCount > 0 ? 'ml-1' : 'ml-auto'
+                        )}
+                      >
+                        {trackingRemote}
+                      </span>
+                    )}
                 </DropdownMenuItem>
                 <DropdownMenuSubTrigger
                   className={cn(
@@ -818,18 +967,20 @@ export function WorktreeActionsDropdown({
                 </DropdownMenuLabel>
                 <DropdownMenuSeparator />
                 {remotes.map((remote) => (
-                  <DropdownMenuItem
+                  <RemoteActionMenuItem
                     key={remote.name}
-                    onClick={() => isGitOpsAvailable && onPushWithRemote(worktree, remote.name)}
-                    disabled={isPushing || !isGitOpsAvailable}
-                    className="text-xs"
-                  >
-                    <Upload className="w-3.5 h-3.5 mr-2" />
-                    {remote.name}
-                    <span className="ml-auto text-[10px] text-muted-foreground max-w-[100px] truncate">
-                      {remote.url}
-                    </span>
-                  </DropdownMenuItem>
+                    remote={remote}
+                    icon={Upload}
+                    trackingRemote={trackingRemote}
+                    isDisabled={isPushing}
+                    isGitOpsAvailable={isGitOpsAvailable}
+                    onAction={() => isGitOpsAvailable && onPushWithRemote(worktree, remote.name)}
+                    onSetTracking={
+                      onSetTracking
+                        ? () => isGitOpsAvailable && onSetTracking(worktree, remote.name)
+                        : undefined
+                    }
+                  />
                 ))}
               </DropdownMenuSubContent>
             </DropdownMenuSub>
@@ -844,7 +995,11 @@ export function WorktreeActionsDropdown({
                   onPush(worktree);
                 }
               }}
-              disabled={isPushing || (hasRemoteBranch && aheadCount === 0) || !isGitOpsAvailable}
+              disabled={
+                isPushing ||
+                (hasRemoteBranch && !isOnDifferentRemote && aheadCount === 0) ||
+                !isGitOpsAvailable
+              }
               className={cn('text-xs', !isGitOpsAvailable && 'opacity-50 cursor-not-allowed')}
             >
               <Upload className={cn('w-3.5 h-3.5 mr-2', isPushing && 'animate-pulse')} />
@@ -858,12 +1013,18 @@ export function WorktreeActionsDropdown({
                   local only
                 </span>
               )}
-              {isGitOpsAvailable && hasRemoteBranch && aheadCount > 0 && (
+              {isGitOpsAvailable && hasRemoteBranch && isOnDifferentRemote && (
+                <span className="ml-auto inline-flex items-center gap-0.5 text-[10px] bg-blue-500/20 text-blue-600 dark:text-blue-400 px-1.5 py-0.5 rounded">
+                  <Globe className="w-2.5 h-2.5" />
+                  on {otherRemotesWithBranch.join(', ')}
+                </span>
+              )}
+              {isGitOpsAvailable && hasRemoteBranch && !isOnDifferentRemote && aheadCount > 0 && (
                 <span className="ml-auto text-[10px] bg-primary/20 text-primary px-1.5 py-0.5 rounded">
                   {aheadCount} ahead
                 </span>
               )}
-              {isGitOpsAvailable && hasRemoteBranch && trackingRemote && (
+              {isGitOpsAvailable && hasRemoteBranch && !isOnDifferentRemote && trackingRemote && (
                 <span
                   className={cn(
                     'text-[10px] bg-muted text-muted-foreground px-1.5 py-0.5 rounded',
@@ -876,6 +1037,72 @@ export function WorktreeActionsDropdown({
             </DropdownMenuItem>
           )}
         </TooltipWrapper>
+        {onSync && (
+          <TooltipWrapper
+            showTooltip={!!gitOpsDisabledReason}
+            tooltipContent={gitOpsDisabledReason}
+          >
+            {remotes && remotes.length > 1 && onSyncWithRemote ? (
+              <DropdownMenuSub>
+                <div className="flex items-center">
+                  <DropdownMenuItem
+                    onClick={() => isGitOpsAvailable && onSync(worktree)}
+                    disabled={isSyncing || !isGitOpsAvailable}
+                    className={cn(
+                      'text-xs flex-1 pr-0 rounded-r-none',
+                      !isGitOpsAvailable && 'opacity-50 cursor-not-allowed'
+                    )}
+                  >
+                    <RefreshCw className={cn('w-3.5 h-3.5 mr-2', isSyncing && 'animate-spin')} />
+                    {isSyncing ? 'Syncing...' : 'Sync'}
+                    {!isGitOpsAvailable && (
+                      <AlertCircle className="w-3 h-3 ml-auto text-muted-foreground" />
+                    )}
+                  </DropdownMenuItem>
+                  <DropdownMenuSubTrigger
+                    className={cn(
+                      'text-xs px-1 rounded-l-none border-l border-border/30 h-8',
+                      (!isGitOpsAvailable || isSyncing) && 'opacity-50 cursor-not-allowed'
+                    )}
+                    disabled={!isGitOpsAvailable || isSyncing}
+                  />
+                </div>
+                <DropdownMenuSubContent>
+                  <DropdownMenuLabel className="text-xs text-muted-foreground font-normal">
+                    Sync with remote
+                  </DropdownMenuLabel>
+                  <DropdownMenuSeparator />
+                  {remotes.map((remote) => (
+                    <DropdownMenuItem
+                      key={`sync-${remote.name}`}
+                      onClick={() => isGitOpsAvailable && onSyncWithRemote(worktree, remote.name)}
+                      disabled={isSyncing || !isGitOpsAvailable}
+                      className="text-xs"
+                    >
+                      <RefreshCw className="w-3.5 h-3.5 mr-2" />
+                      {remote.name}
+                      <span className="ml-auto text-[10px] text-muted-foreground max-w-[100px] truncate">
+                        {remote.url}
+                      </span>
+                    </DropdownMenuItem>
+                  ))}
+                </DropdownMenuSubContent>
+              </DropdownMenuSub>
+            ) : (
+              <DropdownMenuItem
+                onClick={() => isGitOpsAvailable && onSync(worktree)}
+                disabled={isSyncing || !isGitOpsAvailable}
+                className={cn('text-xs', !isGitOpsAvailable && 'opacity-50 cursor-not-allowed')}
+              >
+                <RefreshCw className={cn('w-3.5 h-3.5 mr-2', isSyncing && 'animate-spin')} />
+                {isSyncing ? 'Syncing...' : 'Sync'}
+                {!isGitOpsAvailable && (
+                  <AlertCircle className="w-3 h-3 ml-auto text-muted-foreground" />
+                )}
+              </DropdownMenuItem>
+            )}
+          </TooltipWrapper>
+        )}
         <TooltipWrapper showTooltip={!!gitOpsDisabledReason} tooltipContent={gitOpsDisabledReason}>
           <DropdownMenuItem
             onClick={() => isGitOpsAvailable && onResolveConflicts(worktree)}
@@ -1124,6 +1351,12 @@ export function WorktreeActionsDropdown({
                 <Zap className="w-3.5 h-3.5 mr-2" />
                 Address PR Comments
               </DropdownMenuItem>
+              {onChangePRNumber && (
+                <DropdownMenuItem onClick={() => onChangePRNumber(worktree)} className="text-xs">
+                  <Hash className="w-3.5 h-3.5 mr-2" />
+                  Change PR Number
+                </DropdownMenuItem>
+              )}
             </DropdownMenuSubContent>
           </DropdownMenuSub>
         )}
@@ -1149,6 +1382,36 @@ export function WorktreeActionsDropdown({
             </DropdownMenuItem>
           </TooltipWrapper>
         )}
+        {/* Swap Worktree submenu - only shown for non-main slots when there are other worktrees to swap to */}
+        {!worktree.isMain &&
+          availableWorktreesForSwap &&
+          availableWorktreesForSwap.length > 1 &&
+          slotIndex !== undefined &&
+          onSwapWorktree && (
+            <DropdownMenuSub>
+              <DropdownMenuSubTrigger className="text-xs">
+                <ArrowLeftRight className="w-3.5 h-3.5 mr-2" />
+                Swap Worktree
+              </DropdownMenuSubTrigger>
+              <DropdownMenuSubContent className="w-64 max-h-80 overflow-y-auto">
+                {availableWorktreesForSwap
+                  .filter((wt) => wt.branch !== worktree.branch)
+                  .map((wt) => {
+                    const isPinned = pinnedBranches?.includes(wt.branch);
+                    return (
+                      <DropdownMenuItem
+                        key={wt.path}
+                        onSelect={() => onSwapWorktree(slotIndex, wt.branch)}
+                        className="flex items-center gap-2 cursor-pointer font-mono text-xs"
+                      >
+                        <span className="truncate flex-1">{wt.branch}</span>
+                        {isPinned && <Check className="w-3 h-3 shrink-0 text-muted-foreground" />}
+                      </DropdownMenuItem>
+                    );
+                  })}
+              </DropdownMenuSubContent>
+            </DropdownMenuSub>
+          )}
         {!worktree.isMain && (
           <DropdownMenuItem
             onClick={() => onDeleteWorktree(worktree)}

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-dropdown.tsx

@@ -102,6 +102,7 @@ export interface WorktreeDropdownProps {
   onDiscardChanges: (worktree: WorktreeInfo) => void;
   onCommit: (worktree: WorktreeInfo) => void;
   onCreatePR: (worktree: WorktreeInfo) => void;
+  onChangePRNumber?: (worktree: WorktreeInfo) => void;
   onAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onAutoAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onResolveConflicts: (worktree: WorktreeInfo) => void;
@@ -138,6 +139,18 @@ export interface WorktreeDropdownProps {
   onRunTerminalScript?: (worktree: WorktreeInfo, command: string) => void;
   /** Callback to open the script editor UI */
   onEditScripts?: () => void;
+  /** Whether sync is in progress */
+  isSyncing?: boolean;
+  /** Sync (pull + push) callback */
+  onSync?: (worktree: WorktreeInfo) => void;
+  /** Sync with a specific remote */
+  onSyncWithRemote?: (worktree: WorktreeInfo, remote: string) => void;
+  /** Set tracking branch to a specific remote */
+  onSetTracking?: (worktree: WorktreeInfo, remote: string) => void;
+  /** List of remote names that have a branch matching the current branch name */
+  remotesWithBranch?: string[];
+  /** When false, the trigger button uses a subdued style instead of the primary highlight. Defaults to true. */
+  highlightTrigger?: boolean;
 }
 
 /**
@@ -205,6 +218,7 @@ export function WorktreeDropdown({
   onDiscardChanges,
   onCommit,
   onCreatePR,
+  onChangePRNumber,
   onAddressPRComments,
   onAutoAddressPRComments,
   onResolveConflicts,
@@ -230,10 +244,18 @@ export function WorktreeDropdown({
   terminalScripts,
   onRunTerminalScript,
   onEditScripts,
+  isSyncing = false,
+  onSync,
+  onSyncWithRemote,
+  onSetTracking,
+  remotesWithBranch,
+  highlightTrigger = true,
 }: WorktreeDropdownProps) {
   // Find the currently selected worktree to display in the trigger
   const selectedWorktree = worktrees.find((w) => isWorktreeSelected(w));
-  const displayBranch = selectedWorktree?.branch || 'Select worktree';
+  const displayBranch =
+    selectedWorktree?.branch ??
+    (worktrees.length > 0 ? `+${worktrees.length} more` : 'Select worktree');
   const { truncated: truncatedBranch, isTruncated: isBranchNameTruncated } = truncateBranchName(
     displayBranch,
     MAX_TRIGGER_BRANCH_NAME_LENGTH
@@ -277,15 +299,28 @@ export function WorktreeDropdown({
   const triggerButton = useMemo(
     () => (
       <Button
-        variant="outline"
+        variant={selectedWorktree && highlightTrigger ? 'default' : 'outline'}
         size="sm"
         className={cn(
-          'h-7 px-3 gap-1.5 font-mono text-xs bg-secondary/50 hover:bg-secondary min-w-0 border-r-0 rounded-r-none'
+          'h-7 px-3 gap-1.5 font-mono text-xs min-w-0',
+          selectedWorktree &&
+            highlightTrigger &&
+            'bg-primary text-primary-foreground border-r-0 rounded-l-md rounded-r-none',
+          selectedWorktree &&
+            !highlightTrigger &&
+            'bg-secondary/50 hover:bg-secondary border-r-0 rounded-l-md rounded-r-none',
+          !selectedWorktree && 'bg-secondary/50 hover:bg-secondary rounded-md'
         )}
         disabled={isActivating}
       >
         {/* Running/Activating indicator */}
-        {(selectedStatus.isRunning || isActivating) && <Spinner size="xs" className="shrink-0" />}
+        {(selectedStatus.isRunning || isActivating) && (
+          <Spinner
+            size="xs"
+            className="shrink-0"
+            variant={selectedWorktree && highlightTrigger ? 'foreground' : 'primary'}
+          />
+        )}
 
         {/* Branch icon */}
         <GitBranch className="w-3.5 h-3.5 shrink-0" />
@@ -388,7 +423,14 @@ export function WorktreeDropdown({
         <ChevronDown className="w-3 h-3 shrink-0 ml-auto" />
       </Button>
     ),
-    [isActivating, selectedStatus, truncatedBranch, selectedWorktree, branchCardCounts]
+    [
+      isActivating,
+      selectedStatus,
+      truncatedBranch,
+      selectedWorktree,
+      branchCardCounts,
+      highlightTrigger,
+    ]
   );
 
   // Wrap trigger button with dropdown trigger first to ensure ref is passed correctly
@@ -475,7 +517,7 @@ export function WorktreeDropdown({
       {selectedWorktree?.isMain && (
         <BranchSwitchDropdown
           worktree={selectedWorktree}
-          isSelected={true}
+          isSelected={highlightTrigger}
           branches={branches}
           filteredBranches={filteredBranches}
           branchFilter={branchFilter}
@@ -492,7 +534,7 @@ export function WorktreeDropdown({
       {selectedWorktree && (
         <WorktreeActionsDropdown
           worktree={selectedWorktree}
-          isSelected={true}
+          isSelected={highlightTrigger}
           aheadCount={aheadCount}
           behindCount={behindCount}
           hasRemoteBranch={hasRemoteBranch}
@@ -526,6 +568,7 @@ export function WorktreeDropdown({
           onDiscardChanges={onDiscardChanges}
           onCommit={onCommit}
           onCreatePR={onCreatePR}
+          onChangePRNumber={onChangePRNumber}
           onAddressPRComments={onAddressPRComments}
           onAutoAddressPRComments={onAutoAddressPRComments}
           onResolveConflicts={onResolveConflicts}
@@ -549,6 +592,11 @@ export function WorktreeDropdown({
           terminalScripts={terminalScripts}
           onRunTerminalScript={onRunTerminalScript}
           onEditScripts={onEditScripts}
+          isSyncing={isSyncing}
+          onSync={onSync}
+          onSyncWithRemote={onSyncWithRemote}
+          onSetTracking={onSetTracking}
+          remotesWithBranch={remotesWithBranch}
         />
       )}
     </div>

apps/ui/src/components/views/board-view/worktree-panel/components/worktree-tab.tsx

@@ -66,6 +66,7 @@ interface WorktreeTabProps {
   onDiscardChanges: (worktree: WorktreeInfo) => void;
   onCommit: (worktree: WorktreeInfo) => void;
   onCreatePR: (worktree: WorktreeInfo) => void;
+  onChangePRNumber?: (worktree: WorktreeInfo) => void;
   onAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onAutoAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onResolveConflicts: (worktree: WorktreeInfo) => void;
@@ -108,6 +109,24 @@ interface WorktreeTabProps {
   onRunTerminalScript?: (worktree: WorktreeInfo, command: string) => void;
   /** Callback to open the script editor UI */
   onEditScripts?: () => void;
+  /** Whether sync is in progress */
+  isSyncing?: boolean;
+  /** Sync (pull + push) callback */
+  onSync?: (worktree: WorktreeInfo) => void;
+  /** Sync with a specific remote */
+  onSyncWithRemote?: (worktree: WorktreeInfo, remote: string) => void;
+  /** Set tracking branch to a specific remote */
+  onSetTracking?: (worktree: WorktreeInfo, remote: string) => void;
+  /** List of remote names that have a branch matching the current branch name */
+  remotesWithBranch?: string[];
+  /** Available worktrees for swapping into this slot (non-main only) */
+  availableWorktreesForSwap?: WorktreeInfo[];
+  /** The slot index for this tab in the pinned list (0-based, excluding main) */
+  slotIndex?: number;
+  /** Callback when user swaps this slot to a different worktree */
+  onSwapWorktree?: (slotIndex: number, newBranch: string) => void;
+  /** List of currently pinned branch names (to show which are pinned in the swap dropdown) */
+  pinnedBranches?: string[];
 }
 
 export function WorktreeTab({
@@ -154,6 +173,7 @@ export function WorktreeTab({
   onDiscardChanges,
   onCommit,
   onCreatePR,
+  onChangePRNumber,
   onAddressPRComments,
   onAutoAddressPRComments,
   onResolveConflicts,
@@ -181,6 +201,15 @@ export function WorktreeTab({
   terminalScripts,
   onRunTerminalScript,
   onEditScripts,
+  isSyncing = false,
+  onSync,
+  onSyncWithRemote,
+  onSetTracking,
+  remotesWithBranch,
+  availableWorktreesForSwap,
+  slotIndex,
+  onSwapWorktree,
+  pinnedBranches,
 }: WorktreeTabProps) {
   // Make the worktree tab a drop target for feature cards
   const { setNodeRef, isOver } = useDroppable({
@@ -527,6 +556,7 @@ export function WorktreeTab({
         onDiscardChanges={onDiscardChanges}
         onCommit={onCommit}
         onCreatePR={onCreatePR}
+        onChangePRNumber={onChangePRNumber}
         onAddressPRComments={onAddressPRComments}
         onAutoAddressPRComments={onAutoAddressPRComments}
         onResolveConflicts={onResolveConflicts}
@@ -550,6 +580,15 @@ export function WorktreeTab({
         terminalScripts={terminalScripts}
         onRunTerminalScript={onRunTerminalScript}
         onEditScripts={onEditScripts}
+        isSyncing={isSyncing}
+        onSync={onSync}
+        onSyncWithRemote={onSyncWithRemote}
+        onSetTracking={onSetTracking}
+        remotesWithBranch={remotesWithBranch}
+        availableWorktreesForSwap={availableWorktreesForSwap}
+        slotIndex={slotIndex}
+        onSwapWorktree={onSwapWorktree}
+        pinnedBranches={pinnedBranches}
       />
     </div>
   );

apps/ui/src/components/views/board-view/worktree-panel/hooks/use-branches.ts

@@ -17,6 +17,8 @@ export interface UseBranchesReturn {
   trackingRemote: string | undefined;
   /** Per-worktree tracking remote lookup — avoids stale values when multiple panels share the hook */
   getTrackingRemote: (worktreePath: string) => string | undefined;
+  /** List of remote names that have a branch matching the current branch name */
+  remotesWithBranch: string[];
   isLoadingBranches: boolean;
   branchFilter: string;
   setBranchFilter: (filter: string) => void;
@@ -49,6 +51,7 @@ export function useBranches(): UseBranchesReturn {
   const behindCount = branchData?.behindCount ?? 0;
   const hasRemoteBranch = branchData?.hasRemoteBranch ?? false;
   const trackingRemote = branchData?.trackingRemote;
+  const remotesWithBranch = branchData?.remotesWithBranch ?? [];
 
   // Per-worktree tracking remote cache: keeps results from previous fetchBranches()
   // calls so multiple WorktreePanel instances don't all share a single stale value.
@@ -119,6 +122,7 @@ export function useBranches(): UseBranchesReturn {
     hasRemoteBranch,
     trackingRemote,
     getTrackingRemote,
+    remotesWithBranch,
     isLoadingBranches,
     branchFilter,
     setBranchFilter,

apps/ui/src/components/views/board-view/worktree-panel/hooks/use-worktree-actions.ts

@@ -8,6 +8,8 @@ import {
   useSwitchBranch,
   usePullWorktree,
   usePushWorktree,
+  useSyncWorktree,
+  useSetTracking,
   useOpenInEditor,
 } from '@/hooks/mutations';
 import type { WorktreeInfo } from '../types';
@@ -51,6 +53,8 @@ export function useWorktreeActions(options?: UseWorktreeActionsOptions) {
   });
   const pullMutation = usePullWorktree();
   const pushMutation = usePushWorktree();
+  const syncMutation = useSyncWorktree();
+  const setTrackingMutation = useSetTracking();
   const openInEditorMutation = useOpenInEditor();
 
   /**
@@ -150,6 +154,28 @@ export function useWorktreeActions(options?: UseWorktreeActionsOptions) {
     [pushMutation]
   );
 
+  const handleSync = useCallback(
+    async (worktree: WorktreeInfo, remote?: string) => {
+      if (syncMutation.isPending) return;
+      syncMutation.mutate({
+        worktreePath: worktree.path,
+        remote,
+      });
+    },
+    [syncMutation]
+  );
+
+  const handleSetTracking = useCallback(
+    async (worktree: WorktreeInfo, remote: string) => {
+      if (setTrackingMutation.isPending) return;
+      setTrackingMutation.mutate({
+        worktreePath: worktree.path,
+        remote,
+      });
+    },
+    [setTrackingMutation]
+  );
+
   const handleOpenInIntegratedTerminal = useCallback(
     (worktree: WorktreeInfo, mode?: 'tab' | 'split') => {
       // Navigate to the terminal view with the worktree path and branch name
@@ -215,12 +241,15 @@ export function useWorktreeActions(options?: UseWorktreeActionsOptions) {
   return {
     isPulling: pullMutation.isPending,
     isPushing: pushMutation.isPending,
+    isSyncing: syncMutation.isPending,
     isSwitching: switchBranchMutation.isPending,
     isActivating,
     setIsActivating,
     handleSwitchBranch,
     handlePull,
     handlePush,
+    handleSync,
+    handleSetTracking,
     handleOpenInIntegratedTerminal,
     handleRunTerminalScript,
     handleOpenInEditor,

apps/ui/src/components/views/board-view/worktree-panel/hooks/use-worktrees.ts

@@ -1,4 +1,4 @@
-import { useEffect, useCallback, useRef } from 'react';
+import { useEffect, useCallback, useRef, startTransition } from 'react';
 import { useQueryClient } from '@tanstack/react-query';
 import { useAppStore } from '@/store/app-store';
 import { useWorktrees as useWorktreesQuery } from '@/hooks/queries';
@@ -93,7 +93,15 @@ export function useWorktrees({
         // Fallback to "main" only if worktrees haven't loaded yet
         const mainWorktree = worktrees.find((w) => w.isMain);
         const mainBranch = mainWorktree?.branch || 'main';
-        setCurrentWorktree(projectPath, null, mainBranch);
+        // Note: Zustand uses useSyncExternalStore so setCurrentWorktree updates
+        // are flushed synchronously. The real guard against React error #185 is
+        // dependency isolation — currentWorktree is intentionally excluded from
+        // the validation effect deps below (via currentWorktreeRef) so we don't
+        // create a feedback loop. startTransition may still help batch unrelated
+        // React state updates but does NOT defer or prevent Zustand-driven cascades.
+        startTransition(() => {
+          setCurrentWorktree(projectPath, null, mainBranch);
+        });
       }
     }
   }, [worktrees, projectPath, setCurrentWorktree]);
@@ -109,15 +117,28 @@ export function useWorktrees({
 
       if (isSameWorktree) return;
 
-      setCurrentWorktree(projectPath, worktree.isMain ? null : worktree.path, worktree.branch);
-
-      // Invalidate feature queries when switching worktrees to ensure fresh data.
-      // Without this, feature cards that remount after the worktree switch may have stale
-      // or missing planSpec/task data, causing todo lists to appear empty until the next
-      // polling cycle or user interaction triggers a re-render.
-      queryClient.invalidateQueries({
-        queryKey: queryKeys.features.all(projectPath),
+      // Note: Zustand uses useSyncExternalStore so setCurrentWorktree updates are
+      // flushed synchronously — startTransition does NOT prevent Zustand-driven
+      // cascades. The actual protection against React error #185 is dependency
+      // isolation via currentWorktreeRef (currentWorktree is excluded from the
+      // validation effect's dependency array). startTransition may still help
+      // batch unrelated concurrent React state updates but should not be relied
+      // upon for Zustand update ordering.
+      startTransition(() => {
+        setCurrentWorktree(projectPath, worktree.isMain ? null : worktree.path, worktree.branch);
       });
+
+      // Defer feature query invalidation so the store update and client-side
+      // re-filtering happen in the current render cycle first. The features
+      // list is the same regardless of worktree (filtering is client-side),
+      // so the board updates instantly. The deferred invalidation ensures
+      // feature card details (planSpec, todo lists) are refreshed in the
+      // background without blocking the worktree switch.
+      setTimeout(() => {
+        queryClient.invalidateQueries({
+          queryKey: queryKeys.features.all(projectPath),
+        });
+      }, 100);
     },
     [projectPath, setCurrentWorktree, queryClient, currentWorktreePath]
   );

apps/ui/src/components/views/board-view/worktree-panel/types.ts

@@ -120,6 +120,7 @@ export interface WorktreePanelProps {
   onDeleteWorktree: (worktree: WorktreeInfo) => void;
   onCommit: (worktree: WorktreeInfo) => void;
   onCreatePR: (worktree: WorktreeInfo) => void;
+  onChangePRNumber?: (worktree: WorktreeInfo) => void;
   onCreateBranch: (worktree: WorktreeInfo) => void;
   onAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;
   onAutoAddressPRComments: (worktree: WorktreeInfo, prInfo: PRInfo) => void;

apps/ui/src/components/views/board-view/worktree-panel/worktree-panel.tsx

@@ -26,11 +26,11 @@ import {
 } from './hooks';
 import {
   WorktreeTab,
+  WorktreeDropdown,
   DevServerLogsPanel,
   WorktreeMobileDropdown,
   WorktreeActionsDropdown,
   BranchSwitchDropdown,
-  WorktreeDropdown,
 } from './components';
 import { useAppStore } from '@/store/app-store';
 import {
@@ -50,8 +50,9 @@ import type { SelectRemoteOperation } from '../dialogs';
 import { TestLogsPanel } from '@/components/ui/test-logs-panel';
 import { getElectronAPI } from '@/lib/electron';
 
-/** Threshold for switching from tabs to dropdown layout (number of worktrees) */
-const WORKTREE_DROPDOWN_THRESHOLD = 3;
+// Stable empty array to avoid creating a new [] reference on every render
+// when pinnedWorktreeBranchesByProject[projectPath] is undefined
+const EMPTY_BRANCHES: string[] = [];
 
 export function WorktreePanel({
   projectPath,
@@ -59,6 +60,7 @@ export function WorktreePanel({
   onDeleteWorktree,
   onCommit,
   onCreatePR,
+  onChangePRNumber,
   onCreateBranch,
   onAddressPRComments,
   onAutoAddressPRComments,
@@ -99,8 +101,8 @@ export function WorktreePanel({
     aheadCount,
     behindCount,
     hasRemoteBranch,
-    trackingRemote,
     getTrackingRemote,
+    remotesWithBranch,
     isLoadingBranches,
     branchFilter,
     setBranchFilter,
@@ -113,11 +115,14 @@ export function WorktreePanel({
   const {
     isPulling,
     isPushing,
+    isSyncing,
     isSwitching,
     isActivating,
     handleSwitchBranch,
     handlePull: _handlePull,
     handlePush,
+    handleSync,
+    handleSetTracking,
     handleOpenInIntegratedTerminal,
     handleRunTerminalScript,
     handleOpenInEditor,
@@ -135,13 +140,107 @@ export function WorktreePanel({
     features,
   });
 
+  // Pinned worktrees count from store
+  const pinnedWorktreesCount = useAppStore(
+    (state) => state.pinnedWorktreesCountByProject[projectPath] ?? 0
+  );
+  const pinnedWorktreeBranchesRaw = useAppStore(
+    (state) => state.pinnedWorktreeBranchesByProject[projectPath]
+  );
+  const pinnedWorktreeBranches = pinnedWorktreeBranchesRaw ?? EMPTY_BRANCHES;
+  const setPinnedWorktreeBranches = useAppStore((state) => state.setPinnedWorktreeBranches);
+  const swapPinnedWorktreeBranch = useAppStore((state) => state.swapPinnedWorktreeBranch);
+
+  // Resolve pinned worktrees from explicit branch assignments
+  // Shows exactly pinnedWorktreesCount slots, each with a specific worktree.
+  // Main worktree is always slot 0. Other slots can be swapped by the user.
+  const pinnedWorktrees = useMemo(() => {
+    const mainWt = worktrees.find((w) => w.isMain);
+    const otherWts = worktrees.filter((w) => !w.isMain);
+
+    // Slot 0 is always main worktree
+    const result: WorktreeInfo[] = mainWt ? [mainWt] : [];
+
+    // pinnedWorktreesCount represents only non-main worktrees; main is always shown separately
+    const otherSlotCount = Math.max(0, pinnedWorktreesCount);
+
+    if (otherSlotCount > 0 && otherWts.length > 0) {
+      // Use explicit branch assignments if available
+      const assignedBranches = pinnedWorktreeBranches;
+      const usedBranches = new Set<string>();
+
+      for (let i = 0; i < otherSlotCount; i++) {
+        const assignedBranch = assignedBranches[i];
+        let wt: WorktreeInfo | undefined;
+
+        // Try to find the explicitly assigned worktree
+        if (assignedBranch) {
+          wt = otherWts.find((w) => w.branch === assignedBranch && !usedBranches.has(w.branch));
+        }
+
+        // Fall back to next available worktree if assigned one doesn't exist
+        if (!wt) {
+          wt = otherWts.find((w) => !usedBranches.has(w.branch));
+        }
+
+        if (wt) {
+          result.push(wt);
+          usedBranches.add(wt.branch);
+        }
+      }
+    }
+
+    return result;
+  }, [worktrees, pinnedWorktreesCount, pinnedWorktreeBranches]);
+
+  // All non-main worktrees available for swapping into slots
+  const availableWorktreesForSwap = useMemo(() => {
+    return worktrees.filter((w) => !w.isMain);
+  }, [worktrees]);
+
+  // Handle swapping a worktree in a specific slot
+  const handleSwapWorktreeSlot = useCallback(
+    (slotIndex: number, newBranch: string) => {
+      swapPinnedWorktreeBranch(projectPath, slotIndex, newBranch);
+    },
+    [projectPath, swapPinnedWorktreeBranch]
+  );
+
+  // Initialize pinned branch assignments when worktrees change
+  // This ensures new worktrees get default slot assignments
+  // Read store state directly inside the effect to avoid a dependency cycle
+  // (the effect writes to the same state it would otherwise depend on)
+  useEffect(() => {
+    const mainWt = worktrees.find((w) => w.isMain);
+    const otherWts = worktrees.filter((w) => !w.isMain);
+    const otherSlotCount = Math.max(0, pinnedWorktreesCount);
+
+    const storedBranches = useAppStore.getState().pinnedWorktreeBranchesByProject[projectPath];
+    if (otherSlotCount > 0 && otherWts.length > 0) {
+      const existing = storedBranches ?? [];
+      if (existing.length < otherSlotCount) {
+        const used = new Set(existing.filter(Boolean));
+        const filled = [...existing];
+        for (const wt of otherWts) {
+          if (filled.length >= otherSlotCount) break;
+          if (!used.has(wt.branch)) {
+            filled.push(wt.branch);
+            used.add(wt.branch);
+          }
+        }
+        if (filled.length > 0) {
+          setPinnedWorktreeBranches(projectPath, filled);
+        }
+      }
+    }
+  }, [worktrees, pinnedWorktreesCount, projectPath, setPinnedWorktreeBranches]);
+
   // Auto-mode state management using the store
   // Use separate selectors to avoid creating new object references on each render
   const autoModeByWorktree = useAppStore((state) => state.autoModeByWorktree);
   const currentProject = useAppStore((state) => state.currentProject);
   const setAutoModeRunning = useAppStore((state) => state.setAutoModeRunning);
   const getMaxConcurrencyForWorktree = useAppStore((state) => state.getMaxConcurrencyForWorktree);
-
   // Helper to generate worktree key for auto-mode (inlined to avoid selector issues)
   const getAutoModeWorktreeKey = useCallback(
     (projectId: string, branchName: string | null): string => {
@@ -463,20 +562,8 @@ export function WorktreePanel({
 
   const isMobile = useIsMobile();
 
-  // Periodic interval check (30 seconds) to detect branch changes on disk
-  // Reduced polling to lessen repeated worktree list calls while keeping UI reasonably fresh
-  const intervalRef = useRef<NodeJS.Timeout | null>(null);
-  useEffect(() => {
-    intervalRef.current = setInterval(() => {
-      fetchWorktrees({ silent: true });
-    }, 30000);
-
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-      }
-    };
-  }, [fetchWorktrees]);
+  // NOTE: Periodic polling is handled by React Query's refetchInterval
+  // in hooks/queries/use-worktrees.ts (30s). No separate setInterval needed.
 
   // Prune stale tracking-remote cache entries and remotes cache when worktrees change
   useEffect(() => {
@@ -659,18 +746,6 @@ export function WorktreePanel({
     // Keep logPanelWorktree set for smooth close animation
   }, []);
 
-  // Wrap handleStartDevServer to auto-open the logs panel so the user
-  // can see output immediately (including failure reasons)
-  const handleStartDevServerAndShowLogs = useCallback(
-    async (worktree: WorktreeInfo) => {
-      // Open logs panel immediately so output is visible from the start
-      setLogPanelWorktree(worktree);
-      setLogPanelOpen(true);
-      await handleStartDevServer(worktree);
-    },
-    [handleStartDevServer]
-  );
-
   // Handle opening the push to remote dialog
   const handlePushNewBranch = useCallback((worktree: WorktreeInfo) => {
     setPushToRemoteWorktree(worktree);
@@ -828,6 +903,30 @@ export function WorktreePanel({
     [handlePush, fetchBranches, fetchWorktrees]
   );
 
+  // Handle sync (pull + push) with optional remote selection
+  const handleSyncWithRemoteSelection = useCallback(
+    (worktree: WorktreeInfo) => {
+      handleSync(worktree);
+    },
+    [handleSync]
+  );
+
+  // Handle sync with a specific remote selected from the submenu
+  const handleSyncWithSpecificRemote = useCallback(
+    (worktree: WorktreeInfo, remote: string) => {
+      handleSync(worktree, remote);
+    },
+    [handleSync]
+  );
+
+  // Handle set tracking branch for a specific remote
+  const handleSetTrackingForRemote = useCallback(
+    (worktree: WorktreeInfo, remote: string) => {
+      handleSetTracking(worktree, remote);
+    },
+    [handleSetTracking]
+  );
+
   // Handle confirming the push to remote dialog
   const handleConfirmPushToRemote = useCallback(
     async (worktree: WorktreeInfo, remote: string) => {
@@ -871,7 +970,6 @@ export function WorktreePanel({
   );
 
   const mainWorktree = worktrees.find((w) => w.isMain);
-  const nonMainWorktrees = worktrees.filter((w) => !w.isMain);
 
   // Mobile view: single dropdown for all worktrees
   if (isMobile) {
@@ -936,6 +1034,11 @@ export function WorktreePanel({
             onPushNewBranch={handlePushNewBranch}
             onPullWithRemote={handlePullWithSpecificRemote}
             onPushWithRemote={handlePushWithSpecificRemote}
+            isSyncing={isSyncing}
+            onSync={handleSyncWithRemoteSelection}
+            onSyncWithRemote={handleSyncWithSpecificRemote}
+            onSetTracking={handleSetTrackingForRemote}
+            remotesWithBranch={remotesWithBranch}
             onOpenInEditor={handleOpenInEditor}
             onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
             onOpenInExternalTerminal={handleOpenInExternalTerminal}
@@ -944,12 +1047,13 @@ export function WorktreePanel({
             onDiscardChanges={handleDiscardChanges}
             onCommit={onCommit}
             onCreatePR={onCreatePR}
+            onChangePRNumber={onChangePRNumber}
             onAddressPRComments={onAddressPRComments}
             onAutoAddressPRComments={onAutoAddressPRComments}
             onResolveConflicts={onResolveConflicts}
             onMerge={handleMerge}
             onDeleteWorktree={onDeleteWorktree}
-            onStartDevServer={handleStartDevServerAndShowLogs}
+            onStartDevServer={handleStartDevServer}
             onStopDevServer={handleStopDevServer}
             onOpenDevServerUrl={handleOpenDevServerUrl}
             onViewDevServerLogs={handleViewDevServerLogs}
@@ -1124,62 +1228,135 @@ export function WorktreePanel({
     );
   }
 
-  // Use dropdown layout when worktree count meets or exceeds the threshold
-  const useDropdownLayout = worktrees.length >= WORKTREE_DROPDOWN_THRESHOLD;
+  // Desktop view: pinned worktrees as individual tabs (each slot can be swapped)
 
-  // Desktop view: full tabs layout or dropdown layout depending on worktree count
   return (
-    <div className="flex items-center gap-2 px-4 py-2 border-b border-border bg-glass/50 backdrop-blur-sm">
-      <GitBranch className="w-4 h-4 text-muted-foreground" />
-      <span className="text-sm text-muted-foreground mr-2">
-        {useDropdownLayout ? 'Worktree:' : 'Branch:'}
-      </span>
+    <div className="flex flex-wrap items-center gap-2 px-4 py-2.5 border-b border-border bg-glass/50 backdrop-blur-sm">
+      <GitBranch className="w-4 h-4 text-muted-foreground shrink-0" />
+      <span className="text-sm text-muted-foreground mr-2 shrink-0">Worktree:</span>
 
-      {/* Dropdown layout for 3+ worktrees */}
-      {useDropdownLayout ? (
-        <>
-          <WorktreeDropdown
-            worktrees={worktrees}
-            isWorktreeSelected={isWorktreeSelected}
-            hasRunningFeatures={hasRunningFeatures}
+      {/* When only 1 pinned slot (main only) and there are other worktrees,
+          use a compact dropdown to switch between them without highlighting main */}
+      {pinnedWorktreesCount === 0 && availableWorktreesForSwap.length > 0 ? (
+        <WorktreeDropdown
+          worktrees={worktrees}
+          isWorktreeSelected={isWorktreeSelected}
+          hasRunningFeatures={hasRunningFeatures}
+          isActivating={isActivating}
+          branchCardCounts={branchCardCounts}
+          isDevServerRunning={isDevServerRunning}
+          getDevServerInfo={getDevServerInfo}
+          isAutoModeRunningForWorktree={isAutoModeRunningForWorktree}
+          isTestRunningForWorktree={isTestRunningForWorktree}
+          getTestSessionInfo={getTestSessionInfo}
+          onSelectWorktree={handleSelectWorktree}
+          branches={branches}
+          filteredBranches={filteredBranches}
+          branchFilter={branchFilter}
+          isLoadingBranches={isLoadingBranches}
+          isSwitching={isSwitching}
+          onBranchDropdownOpenChange={handleBranchDropdownOpenChange}
+          onBranchFilterChange={setBranchFilter}
+          onSwitchBranch={handleSwitchBranch}
+          onCreateBranch={onCreateBranch}
+          isPulling={isPulling}
+          isPushing={isPushing}
+          isStartingDevServer={isStartingDevServer}
+          aheadCount={aheadCount}
+          behindCount={behindCount}
+          hasRemoteBranch={hasRemoteBranch}
+          getTrackingRemote={getTrackingRemote}
+          gitRepoStatus={gitRepoStatus}
+          hasTestCommand={hasTestCommand}
+          isStartingTests={isStartingTests}
+          hasInitScript={hasInitScript}
+          onActionsDropdownOpenChange={handleActionsDropdownOpenChange}
+          onPull={handlePullWithRemoteSelection}
+          onPush={handlePushWithRemoteSelection}
+          onPushNewBranch={handlePushNewBranch}
+          onPullWithRemote={handlePullWithSpecificRemote}
+          onPushWithRemote={handlePushWithSpecificRemote}
+          remotesCache={remotesCache}
+          onOpenInEditor={handleOpenInEditor}
+          onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
+          onOpenInExternalTerminal={handleOpenInExternalTerminal}
+          onViewChanges={handleViewChanges}
+          onViewCommits={handleViewCommits}
+          onDiscardChanges={handleDiscardChanges}
+          onCommit={onCommit}
+          onCreatePR={onCreatePR}
+          onChangePRNumber={onChangePRNumber}
+          onAddressPRComments={onAddressPRComments}
+          onAutoAddressPRComments={onAutoAddressPRComments}
+          onResolveConflicts={onResolveConflicts}
+          onMerge={handleMerge}
+          onDeleteWorktree={onDeleteWorktree}
+          onStartDevServer={handleStartDevServer}
+          onStopDevServer={handleStopDevServer}
+          onOpenDevServerUrl={handleOpenDevServerUrl}
+          onViewDevServerLogs={handleViewDevServerLogs}
+          onRunInitScript={handleRunInitScript}
+          onToggleAutoMode={handleToggleAutoMode}
+          onStartTests={handleStartTests}
+          onStopTests={handleStopTests}
+          onViewTestLogs={handleViewTestLogs}
+          onStashChanges={handleStashChanges}
+          onViewStashes={handleViewStashes}
+          onCherryPick={handleCherryPick}
+          onAbortOperation={handleAbortOperation}
+          onContinueOperation={handleContinueOperation}
+          terminalScripts={terminalScripts}
+          onRunTerminalScript={handleRunTerminalScript}
+          onEditScripts={handleEditScripts}
+          highlightTrigger={false}
+        />
+      ) : pinnedWorktreesCount === 0 ? (
+        /* Only main worktree, no others exist - render main tab without highlight */
+        mainWorktree && (
+          <WorktreeTab
+            worktree={mainWorktree}
+            cardCount={branchCardCounts?.[mainWorktree.branch]}
+            hasChanges={mainWorktree.hasChanges}
+            changedFilesCount={mainWorktree.changedFilesCount}
+            isSelected={false}
+            isRunning={hasRunningFeatures(mainWorktree)}
             isActivating={isActivating}
-            branchCardCounts={branchCardCounts}
-            isDevServerRunning={isDevServerRunning}
-            getDevServerInfo={getDevServerInfo}
-            isAutoModeRunningForWorktree={isAutoModeRunningForWorktree}
-            isTestRunningForWorktree={isTestRunningForWorktree}
-            getTestSessionInfo={getTestSessionInfo}
-            onSelectWorktree={handleSelectWorktree}
-            // Branch switching props
+            isDevServerRunning={isDevServerRunning(mainWorktree)}
+            devServerInfo={getDevServerInfo(mainWorktree)}
             branches={branches}
             filteredBranches={filteredBranches}
             branchFilter={branchFilter}
             isLoadingBranches={isLoadingBranches}
             isSwitching={isSwitching}
-            onBranchDropdownOpenChange={handleBranchDropdownOpenChange}
-            onBranchFilterChange={setBranchFilter}
-            onSwitchBranch={handleSwitchBranch}
-            onCreateBranch={onCreateBranch}
-            // Action dropdown props
             isPulling={isPulling}
             isPushing={isPushing}
             isStartingDevServer={isStartingDevServer}
             aheadCount={aheadCount}
             behindCount={behindCount}
             hasRemoteBranch={hasRemoteBranch}
-            trackingRemote={trackingRemote}
-            getTrackingRemote={getTrackingRemote}
+            trackingRemote={getTrackingRemote(mainWorktree.path)}
             gitRepoStatus={gitRepoStatus}
-            hasTestCommand={hasTestCommand}
+            isAutoModeRunning={isAutoModeRunningForWorktree(mainWorktree)}
             isStartingTests={isStartingTests}
-            hasInitScript={hasInitScript}
-            onActionsDropdownOpenChange={handleActionsDropdownOpenChange}
+            isTestRunning={isTestRunningForWorktree(mainWorktree)}
+            testSessionInfo={getTestSessionInfo(mainWorktree)}
+            onSelectWorktree={handleSelectWorktree}
+            onBranchDropdownOpenChange={handleBranchDropdownOpenChange(mainWorktree)}
+            onActionsDropdownOpenChange={handleActionsDropdownOpenChange(mainWorktree)}
+            onBranchFilterChange={setBranchFilter}
+            onSwitchBranch={handleSwitchBranch}
+            onCreateBranch={onCreateBranch}
             onPull={handlePullWithRemoteSelection}
             onPush={handlePushWithRemoteSelection}
             onPushNewBranch={handlePushNewBranch}
             onPullWithRemote={handlePullWithSpecificRemote}
             onPushWithRemote={handlePushWithSpecificRemote}
-            remotesCache={remotesCache}
+            isSyncing={isSyncing}
+            onSync={handleSyncWithRemoteSelection}
+            onSyncWithRemote={handleSyncWithSpecificRemote}
+            onSetTracking={handleSetTrackingForRemote}
+            remotesWithBranch={remotesWithBranch}
+            remotes={remotesCache[mainWorktree.path]}
             onOpenInEditor={handleOpenInEditor}
             onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
             onOpenInExternalTerminal={handleOpenInExternalTerminal}
@@ -1188,12 +1365,13 @@ export function WorktreePanel({
             onDiscardChanges={handleDiscardChanges}
             onCommit={onCommit}
             onCreatePR={onCreatePR}
+            onChangePRNumber={onChangePRNumber}
             onAddressPRComments={onAddressPRComments}
             onAutoAddressPRComments={onAutoAddressPRComments}
             onResolveConflicts={onResolveConflicts}
             onMerge={handleMerge}
             onDeleteWorktree={onDeleteWorktree}
-            onStartDevServer={handleStartDevServerAndShowLogs}
+            onStartDevServer={handleStartDevServer}
             onStopDevServer={handleStopDevServer}
             onOpenDevServerUrl={handleOpenDevServerUrl}
             onViewDevServerLogs={handleViewDevServerLogs}
@@ -1207,237 +1385,138 @@ export function WorktreePanel({
             onCherryPick={handleCherryPick}
             onAbortOperation={handleAbortOperation}
             onContinueOperation={handleContinueOperation}
+            hasInitScript={hasInitScript}
+            hasTestCommand={hasTestCommand}
             terminalScripts={terminalScripts}
             onRunTerminalScript={handleRunTerminalScript}
             onEditScripts={handleEditScripts}
           />
-
-          {useWorktreesEnabled && (
-            <>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
-                onClick={onCreateWorktree}
-                title="Create new worktree"
-              >
-                <Plus className="w-4 h-4" />
-              </Button>
-
-              <Button
-                variant="ghost"
-                size="sm"
-                className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
-                onClick={async () => {
-                  const removedWorktrees = await fetchWorktrees();
-                  if (removedWorktrees && removedWorktrees.length > 0 && onRemovedWorktrees) {
-                    onRemovedWorktrees(removedWorktrees);
-                  }
-                }}
-                disabled={isLoading}
-                title="Refresh worktrees"
-              >
-                {isLoading ? <Spinner size="xs" /> : <RefreshCw className="w-3.5 h-3.5" />}
-              </Button>
-            </>
-          )}
-        </>
+        )
       ) : (
-        /* Standard tabs layout for 1-2 worktrees */
+        /* Multiple pinned slots - show individual tabs */
+        pinnedWorktrees.map((worktree, index) => {
+          const hasOtherWorktrees = worktrees.length > 1;
+          const effectiveIsSelected =
+            isWorktreeSelected(worktree) && (hasOtherWorktrees || !worktree.isMain);
+
+          // Slot index for swap (0-based, excluding main which is always slot 0)
+          const slotIndex = worktree.isMain ? -1 : index - (pinnedWorktrees[0]?.isMain ? 1 : 0);
+
+          return (
+            <WorktreeTab
+              key={worktree.path}
+              worktree={worktree}
+              cardCount={branchCardCounts?.[worktree.branch]}
+              hasChanges={worktree.hasChanges}
+              changedFilesCount={worktree.changedFilesCount}
+              isSelected={effectiveIsSelected}
+              isRunning={hasRunningFeatures(worktree)}
+              isActivating={isActivating}
+              isDevServerRunning={isDevServerRunning(worktree)}
+              devServerInfo={getDevServerInfo(worktree)}
+              branches={branches}
+              filteredBranches={filteredBranches}
+              branchFilter={branchFilter}
+              isLoadingBranches={isLoadingBranches}
+              isSwitching={isSwitching}
+              isPulling={isPulling}
+              isPushing={isPushing}
+              isStartingDevServer={isStartingDevServer}
+              aheadCount={aheadCount}
+              behindCount={behindCount}
+              hasRemoteBranch={hasRemoteBranch}
+              trackingRemote={getTrackingRemote(worktree.path)}
+              gitRepoStatus={gitRepoStatus}
+              isAutoModeRunning={isAutoModeRunningForWorktree(worktree)}
+              isStartingTests={isStartingTests}
+              isTestRunning={isTestRunningForWorktree(worktree)}
+              testSessionInfo={getTestSessionInfo(worktree)}
+              onSelectWorktree={handleSelectWorktree}
+              onBranchDropdownOpenChange={handleBranchDropdownOpenChange(worktree)}
+              onActionsDropdownOpenChange={handleActionsDropdownOpenChange(worktree)}
+              onBranchFilterChange={setBranchFilter}
+              onSwitchBranch={handleSwitchBranch}
+              onCreateBranch={onCreateBranch}
+              onPull={handlePullWithRemoteSelection}
+              onPush={handlePushWithRemoteSelection}
+              onPushNewBranch={handlePushNewBranch}
+              onPullWithRemote={handlePullWithSpecificRemote}
+              onPushWithRemote={handlePushWithSpecificRemote}
+              remotes={remotesCache[worktree.path]}
+              onOpenInEditor={handleOpenInEditor}
+              onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
+              onOpenInExternalTerminal={handleOpenInExternalTerminal}
+              onViewChanges={handleViewChanges}
+              onViewCommits={handleViewCommits}
+              onDiscardChanges={handleDiscardChanges}
+              onCommit={onCommit}
+              onCreatePR={onCreatePR}
+              onChangePRNumber={onChangePRNumber}
+              onAddressPRComments={onAddressPRComments}
+              onAutoAddressPRComments={onAutoAddressPRComments}
+              onResolveConflicts={onResolveConflicts}
+              onMerge={handleMerge}
+              onDeleteWorktree={onDeleteWorktree}
+              onStartDevServer={handleStartDevServer}
+              onStopDevServer={handleStopDevServer}
+              onOpenDevServerUrl={handleOpenDevServerUrl}
+              onViewDevServerLogs={handleViewDevServerLogs}
+              onRunInitScript={handleRunInitScript}
+              onToggleAutoMode={handleToggleAutoMode}
+              onStartTests={handleStartTests}
+              onStopTests={handleStopTests}
+              onViewTestLogs={handleViewTestLogs}
+              onStashChanges={handleStashChanges}
+              onViewStashes={handleViewStashes}
+              onCherryPick={handleCherryPick}
+              onAbortOperation={handleAbortOperation}
+              onContinueOperation={handleContinueOperation}
+              hasInitScript={hasInitScript}
+              hasTestCommand={hasTestCommand}
+              terminalScripts={terminalScripts}
+              onRunTerminalScript={handleRunTerminalScript}
+              onEditScripts={handleEditScripts}
+              availableWorktreesForSwap={!worktree.isMain ? availableWorktreesForSwap : undefined}
+              slotIndex={slotIndex >= 0 ? slotIndex : undefined}
+              onSwapWorktree={slotIndex >= 0 ? handleSwapWorktreeSlot : undefined}
+              pinnedBranches={pinnedWorktrees.map((w) => w.branch)}
+              isSyncing={isSyncing}
+              onSync={handleSyncWithRemoteSelection}
+              onSyncWithRemote={handleSyncWithSpecificRemote}
+              onSetTracking={handleSetTrackingForRemote}
+            />
+          );
+        })
+      )}
+
+      {/* Create and refresh buttons */}
+      {useWorktreesEnabled && (
         <>
-          <div className="flex items-center gap-2">
-            {mainWorktree && (
-              <WorktreeTab
-                key={mainWorktree.path}
-                worktree={mainWorktree}
-                cardCount={branchCardCounts?.[mainWorktree.branch]}
-                hasChanges={mainWorktree.hasChanges}
-                changedFilesCount={mainWorktree.changedFilesCount}
-                isSelected={isWorktreeSelected(mainWorktree)}
-                isRunning={hasRunningFeatures(mainWorktree)}
-                isActivating={isActivating}
-                isDevServerRunning={isDevServerRunning(mainWorktree)}
-                devServerInfo={getDevServerInfo(mainWorktree)}
-                branches={branches}
-                filteredBranches={filteredBranches}
-                branchFilter={branchFilter}
-                isLoadingBranches={isLoadingBranches}
-                isSwitching={isSwitching}
-                isPulling={isPulling}
-                isPushing={isPushing}
-                isStartingDevServer={isStartingDevServer}
-                aheadCount={aheadCount}
-                behindCount={behindCount}
-                hasRemoteBranch={hasRemoteBranch}
-                trackingRemote={getTrackingRemote(mainWorktree.path)}
-                gitRepoStatus={gitRepoStatus}
-                isAutoModeRunning={isAutoModeRunningForWorktree(mainWorktree)}
-                isStartingTests={isStartingTests}
-                isTestRunning={isTestRunningForWorktree(mainWorktree)}
-                testSessionInfo={getTestSessionInfo(mainWorktree)}
-                onSelectWorktree={handleSelectWorktree}
-                onBranchDropdownOpenChange={handleBranchDropdownOpenChange(mainWorktree)}
-                onActionsDropdownOpenChange={handleActionsDropdownOpenChange(mainWorktree)}
-                onBranchFilterChange={setBranchFilter}
-                onSwitchBranch={handleSwitchBranch}
-                onCreateBranch={onCreateBranch}
-                onPull={handlePullWithRemoteSelection}
-                onPush={handlePushWithRemoteSelection}
-                onPushNewBranch={handlePushNewBranch}
-                onPullWithRemote={handlePullWithSpecificRemote}
-                onPushWithRemote={handlePushWithSpecificRemote}
-                remotes={remotesCache[mainWorktree.path]}
-                onOpenInEditor={handleOpenInEditor}
-                onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
-                onOpenInExternalTerminal={handleOpenInExternalTerminal}
-                onViewChanges={handleViewChanges}
-                onViewCommits={handleViewCommits}
-                onDiscardChanges={handleDiscardChanges}
-                onCommit={onCommit}
-                onCreatePR={onCreatePR}
-                onAddressPRComments={onAddressPRComments}
-                onAutoAddressPRComments={onAutoAddressPRComments}
-                onResolveConflicts={onResolveConflicts}
-                onMerge={handleMerge}
-                onDeleteWorktree={onDeleteWorktree}
-                onStartDevServer={handleStartDevServerAndShowLogs}
-                onStopDevServer={handleStopDevServer}
-                onOpenDevServerUrl={handleOpenDevServerUrl}
-                onViewDevServerLogs={handleViewDevServerLogs}
-                onRunInitScript={handleRunInitScript}
-                onToggleAutoMode={handleToggleAutoMode}
-                onStartTests={handleStartTests}
-                onStopTests={handleStopTests}
-                onViewTestLogs={handleViewTestLogs}
-                onStashChanges={handleStashChanges}
-                onViewStashes={handleViewStashes}
-                onCherryPick={handleCherryPick}
-                onAbortOperation={handleAbortOperation}
-                onContinueOperation={handleContinueOperation}
-                hasInitScript={hasInitScript}
-                hasTestCommand={hasTestCommand}
-                terminalScripts={terminalScripts}
-                onRunTerminalScript={handleRunTerminalScript}
-                onEditScripts={handleEditScripts}
-              />
-            )}
-          </div>
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
+            onClick={onCreateWorktree}
+            title="Create new worktree"
+          >
+            <Plus className="w-4 h-4" />
+          </Button>
 
-          {/* Worktrees section - only show if enabled and not using dropdown layout */}
-          {useWorktreesEnabled && (
-            <>
-              <div className="w-px h-5 bg-border mx-2" />
-              <GitBranch className="w-4 h-4 text-muted-foreground" />
-              <span className="text-sm text-muted-foreground mr-2">Worktrees:</span>
-
-              <div className="flex items-center gap-2 flex-wrap">
-                {nonMainWorktrees.map((worktree) => {
-                  const cardCount = branchCardCounts?.[worktree.branch];
-                  return (
-                    <WorktreeTab
-                      key={worktree.path}
-                      worktree={worktree}
-                      cardCount={cardCount}
-                      hasChanges={worktree.hasChanges}
-                      changedFilesCount={worktree.changedFilesCount}
-                      isSelected={isWorktreeSelected(worktree)}
-                      isRunning={hasRunningFeatures(worktree)}
-                      isActivating={isActivating}
-                      isDevServerRunning={isDevServerRunning(worktree)}
-                      devServerInfo={getDevServerInfo(worktree)}
-                      branches={branches}
-                      filteredBranches={filteredBranches}
-                      branchFilter={branchFilter}
-                      isLoadingBranches={isLoadingBranches}
-                      isSwitching={isSwitching}
-                      isPulling={isPulling}
-                      isPushing={isPushing}
-                      isStartingDevServer={isStartingDevServer}
-                      aheadCount={aheadCount}
-                      behindCount={behindCount}
-                      hasRemoteBranch={hasRemoteBranch}
-                      trackingRemote={getTrackingRemote(worktree.path)}
-                      gitRepoStatus={gitRepoStatus}
-                      isAutoModeRunning={isAutoModeRunningForWorktree(worktree)}
-                      isStartingTests={isStartingTests}
-                      isTestRunning={isTestRunningForWorktree(worktree)}
-                      testSessionInfo={getTestSessionInfo(worktree)}
-                      onSelectWorktree={handleSelectWorktree}
-                      onBranchDropdownOpenChange={handleBranchDropdownOpenChange(worktree)}
-                      onActionsDropdownOpenChange={handleActionsDropdownOpenChange(worktree)}
-                      onBranchFilterChange={setBranchFilter}
-                      onSwitchBranch={handleSwitchBranch}
-                      onCreateBranch={onCreateBranch}
-                      onPull={handlePullWithRemoteSelection}
-                      onPush={handlePushWithRemoteSelection}
-                      onPushNewBranch={handlePushNewBranch}
-                      onPullWithRemote={handlePullWithSpecificRemote}
-                      onPushWithRemote={handlePushWithSpecificRemote}
-                      remotes={remotesCache[worktree.path]}
-                      onOpenInEditor={handleOpenInEditor}
-                      onOpenInIntegratedTerminal={handleOpenInIntegratedTerminal}
-                      onOpenInExternalTerminal={handleOpenInExternalTerminal}
-                      onViewChanges={handleViewChanges}
-                      onViewCommits={handleViewCommits}
-                      onDiscardChanges={handleDiscardChanges}
-                      onCommit={onCommit}
-                      onCreatePR={onCreatePR}
-                      onAddressPRComments={onAddressPRComments}
-                      onAutoAddressPRComments={onAutoAddressPRComments}
-                      onResolveConflicts={onResolveConflicts}
-                      onMerge={handleMerge}
-                      onDeleteWorktree={onDeleteWorktree}
-                      onStartDevServer={handleStartDevServerAndShowLogs}
-                      onStopDevServer={handleStopDevServer}
-                      onOpenDevServerUrl={handleOpenDevServerUrl}
-                      onViewDevServerLogs={handleViewDevServerLogs}
-                      onRunInitScript={handleRunInitScript}
-                      onToggleAutoMode={handleToggleAutoMode}
-                      onStartTests={handleStartTests}
-                      onStopTests={handleStopTests}
-                      onViewTestLogs={handleViewTestLogs}
-                      onStashChanges={handleStashChanges}
-                      onViewStashes={handleViewStashes}
-                      onCherryPick={handleCherryPick}
-                      onAbortOperation={handleAbortOperation}
-                      onContinueOperation={handleContinueOperation}
-                      hasInitScript={hasInitScript}
-                      hasTestCommand={hasTestCommand}
-                      terminalScripts={terminalScripts}
-                      onRunTerminalScript={handleRunTerminalScript}
-                      onEditScripts={handleEditScripts}
-                    />
-                  );
-                })}
-
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
-                  onClick={onCreateWorktree}
-                  title="Create new worktree"
-                >
-                  <Plus className="w-4 h-4" />
-                </Button>
-
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
-                  onClick={async () => {
-                    const removedWorktrees = await fetchWorktrees();
-                    if (removedWorktrees && removedWorktrees.length > 0 && onRemovedWorktrees) {
-                      onRemovedWorktrees(removedWorktrees);
-                    }
-                  }}
-                  disabled={isLoading}
-                  title="Refresh worktrees"
-                >
-                  {isLoading ? <Spinner size="xs" /> : <RefreshCw className="w-3.5 h-3.5" />}
-                </Button>
-              </div>
-            </>
-          )}
+          <Button
+            variant="ghost"
+            size="sm"
+            className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
+            onClick={async () => {
+              const removedWorktrees = await fetchWorktrees();
+              if (removedWorktrees && removedWorktrees.length > 0 && onRemovedWorktrees) {
+                onRemovedWorktrees(removedWorktrees);
+              }
+            }}
+            disabled={isLoading}
+            title="Refresh worktrees"
+          >
+            {isLoading ? <Spinner size="xs" /> : <RefreshCw className="w-3.5 h-3.5" />}
+          </Button>
         </>
       )}
 

apps/ui/src/components/views/file-editor-view/components/code-editor.tsx

@@ -1,34 +1,13 @@
 import { useMemo, useEffect, useRef, forwardRef, useImperativeHandle } from 'react';
 import CodeMirror, { type ReactCodeMirrorRef } from '@uiw/react-codemirror';
-import { EditorView, keymap } from '@codemirror/view';
-import { Extension } from '@codemirror/state';
+import { EditorView, keymap, Decoration, WidgetType } from '@codemirror/view';
+import { Extension, RangeSetBuilder, StateField } from '@codemirror/state';
 import { undo as cmUndo, redo as cmRedo } from '@codemirror/commands';
 import { HighlightStyle, syntaxHighlighting } from '@codemirror/language';
 import { tags as t } from '@lezer/highlight';
 import { search, openSearchPanel } from '@codemirror/search';
 
-// Language imports
-import { javascript } from '@codemirror/lang-javascript';
-import { html } from '@codemirror/lang-html';
-import { css } from '@codemirror/lang-css';
-import { json } from '@codemirror/lang-json';
-import { markdown } from '@codemirror/lang-markdown';
-import { python } from '@codemirror/lang-python';
-import { java } from '@codemirror/lang-java';
-import { rust } from '@codemirror/lang-rust';
-import { cpp } from '@codemirror/lang-cpp';
-import { sql } from '@codemirror/lang-sql';
-import { php } from '@codemirror/lang-php';
-import { xml } from '@codemirror/lang-xml';
-import { StreamLanguage } from '@codemirror/language';
-import { shell } from '@codemirror/legacy-modes/mode/shell';
-import { yaml } from '@codemirror/legacy-modes/mode/yaml';
-import { toml } from '@codemirror/legacy-modes/mode/toml';
-import { dockerFile } from '@codemirror/legacy-modes/mode/dockerfile';
-import { go } from '@codemirror/legacy-modes/mode/go';
-import { ruby } from '@codemirror/legacy-modes/mode/ruby';
-import { swift } from '@codemirror/legacy-modes/mode/swift';
-
+import { getLanguageExtension } from '@/lib/codemirror-languages';
 import { cn } from '@/lib/utils';
 import { useIsMobile } from '@/hooks/use-media-query';
 import { DEFAULT_FONT_VALUE } from '@/config/ui-font-options';
@@ -55,6 +34,8 @@ export interface CodeEditorHandle {
   undo: () => void;
   /** Redoes the last undone edit */
   redo: () => void;
+  /** Returns the current text selection with line range, or null if nothing is selected */
+  getSelection: () => { text: string; fromLine: number; toLine: number } | null;
 }
 
 interface CodeEditorProps {
@@ -72,133 +53,10 @@ interface CodeEditorProps {
   className?: string;
   /** When true, scrolls the cursor into view (e.g. after virtual keyboard opens) */
   scrollCursorIntoView?: boolean;
-}
-
-/** Detect language extension based on file extension */
-function getLanguageExtension(filePath: string): Extension | null {
-  const name = filePath.split('/').pop()?.toLowerCase() || '';
-  const dotIndex = name.lastIndexOf('.');
-  // Files without an extension (no dot, or dotfile with dot at position 0)
-  const ext = dotIndex > 0 ? name.slice(dotIndex + 1) : '';
-
-  // Handle files by name first
-  switch (name) {
-    case 'dockerfile':
-    case 'dockerfile.dev':
-    case 'dockerfile.prod':
-      return StreamLanguage.define(dockerFile);
-    case 'makefile':
-    case 'gnumakefile':
-      return StreamLanguage.define(shell);
-    case '.gitignore':
-    case '.dockerignore':
-    case '.npmignore':
-    case '.eslintignore':
-      return StreamLanguage.define(shell); // close enough for ignore files
-    case '.env':
-    case '.env.local':
-    case '.env.development':
-    case '.env.production':
-      return StreamLanguage.define(shell);
-  }
-
-  switch (ext) {
-    // JavaScript/TypeScript
-    case 'js':
-    case 'mjs':
-    case 'cjs':
-      return javascript();
-    case 'jsx':
-      return javascript({ jsx: true });
-    case 'ts':
-    case 'mts':
-    case 'cts':
-      return javascript({ typescript: true });
-    case 'tsx':
-      return javascript({ jsx: true, typescript: true });
-
-    // Web
-    case 'html':
-    case 'htm':
-    case 'svelte':
-    case 'vue':
-      return html();
-    case 'css':
-    case 'scss':
-    case 'less':
-      return css();
-    case 'json':
-    case 'jsonc':
-    case 'json5':
-      return json();
-    case 'xml':
-    case 'svg':
-    case 'xsl':
-    case 'xslt':
-    case 'plist':
-      return xml();
-
-    // Markdown
-    case 'md':
-    case 'mdx':
-    case 'markdown':
-      return markdown();
-
-    // Python
-    case 'py':
-    case 'pyx':
-    case 'pyi':
-      return python();
-
-    // Java/Kotlin
-    case 'java':
-    case 'kt':
-    case 'kts':
-      return java();
-
-    // Systems
-    case 'rs':
-      return rust();
-    case 'c':
-    case 'h':
-      return cpp();
-    case 'cpp':
-    case 'cc':
-    case 'cxx':
-    case 'hpp':
-    case 'hxx':
-      return cpp();
-    case 'go':
-      return StreamLanguage.define(go);
-    case 'swift':
-      return StreamLanguage.define(swift);
-
-    // Scripting
-    case 'rb':
-    case 'erb':
-      return StreamLanguage.define(ruby);
-    case 'php':
-      return php();
-    case 'sh':
-    case 'bash':
-    case 'zsh':
-    case 'fish':
-      return StreamLanguage.define(shell);
-
-    // Data
-    case 'sql':
-    case 'mysql':
-    case 'pgsql':
-      return sql();
-    case 'yaml':
-    case 'yml':
-      return StreamLanguage.define(yaml);
-    case 'toml':
-      return StreamLanguage.define(toml);
-
-    default:
-      return null; // Plain text fallback
-  }
+  /** Raw unified diff string for the file, used to highlight added/removed lines */
+  diffContent?: string | null;
+  /** Fires when the text selection state changes (true = non-empty selection) */
+  onSelectionChange?: (hasSelection: boolean) => void;
 }
 
 /** Get a human-readable language name */
@@ -295,6 +153,215 @@ export function getLanguageName(filePath: string): string {
   }
 }
 
+// ─── Inline Diff Decorations ─────────────────────────────────────────────
+
+/** Parsed diff info: added line numbers and groups of deleted lines with content */
+interface DiffInfo {
+  addedLines: Set<number>;
+  /**
+   * Groups of consecutive deleted lines keyed by the new-file line number
+   * they appear before. E.g. key=3 means the deleted lines were removed
+   * just before line 3 in the current file.
+   */
+  deletedGroups: Map<number, string[]>;
+}
+
+/** Parse a unified diff to extract added lines and groups of deleted lines */
+function parseUnifiedDiff(diffContent: string): DiffInfo {
+  const addedLines = new Set<number>();
+  const deletedGroups = new Map<number, string[]>();
+  const lines = diffContent.split('\n');
+
+  let currentNewLine = 0;
+  let inHunk = false;
+  let pendingDeletions: string[] = [];
+
+  const flushDeletions = () => {
+    if (pendingDeletions.length > 0) {
+      const existing = deletedGroups.get(currentNewLine);
+      if (existing) {
+        existing.push(...pendingDeletions);
+      } else {
+        deletedGroups.set(currentNewLine, [...pendingDeletions]);
+      }
+      pendingDeletions = [];
+    }
+  };
+
+  for (const line of lines) {
+    // Parse hunk header: @@ -oldStart,oldCount +newStart,newCount @@ ...
+    if (line.startsWith('@@')) {
+      flushDeletions();
+      const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (match) {
+        currentNewLine = parseInt(match[1], 10);
+        inHunk = true;
+      }
+      continue;
+    }
+
+    if (!inHunk) continue;
+
+    // Skip diff header lines
+    if (
+      line.startsWith('--- ') ||
+      line.startsWith('+++ ') ||
+      line.startsWith('diff ') ||
+      line.startsWith('index ')
+    ) {
+      continue;
+    }
+
+    if (line.startsWith('+')) {
+      flushDeletions();
+      addedLines.add(currentNewLine);
+      currentNewLine++;
+    } else if (line.startsWith('-')) {
+      // Accumulate deleted lines to show as a group
+      pendingDeletions.push(line.substring(1));
+    } else if (line.startsWith(' ') || line === '') {
+      flushDeletions();
+      currentNewLine++;
+    }
+  }
+
+  flushDeletions();
+  return { addedLines, deletedGroups };
+}
+
+/** Widget that renders a block of deleted lines inline in the editor */
+class DeletedLinesWidget extends WidgetType {
+  constructor(readonly lines: string[]) {
+    super();
+  }
+
+  toDOM() {
+    const container = document.createElement('div');
+    container.className = 'cm-diff-deleted-widget';
+    container.style.cssText =
+      'background-color: oklch(0.55 0.22 25 / 0.1); border-left: 3px solid oklch(0.55 0.22 25 / 0.5);';
+
+    for (const line of this.lines) {
+      const lineEl = document.createElement('div');
+      lineEl.style.cssText =
+        'text-decoration: line-through; color: oklch(0.55 0.22 25 / 0.8); background-color: oklch(0.55 0.22 25 / 0.15); padding: 0 0.5rem; padding-left: calc(0.5rem - 3px); white-space: pre; font-family: inherit;';
+      lineEl.textContent = line || ' ';
+      container.appendChild(lineEl);
+    }
+
+    return container;
+  }
+
+  eq(other: WidgetType) {
+    if (!(other instanceof DeletedLinesWidget)) return false;
+    return (
+      this.lines.length === other.lines.length && this.lines.every((l, i) => l === other.lines[i])
+    );
+  }
+
+  ignoreEvent() {
+    return true;
+  }
+}
+
+/** Create a CodeMirror extension that decorates lines based on diff */
+function createDiffDecorations(diffContent: string | null | undefined): Extension {
+  if (!diffContent) {
+    return [];
+  }
+
+  const { addedLines, deletedGroups } = parseUnifiedDiff(diffContent);
+  if (addedLines.size === 0 && deletedGroups.size === 0) {
+    return [];
+  }
+
+  const addedLineDecoration = Decoration.line({
+    class: 'cm-diff-added-line',
+    attributes: { style: 'background-color: oklch(0.65 0.2 145 / 0.15);' },
+  });
+
+  const extensions: Extension[] = [];
+
+  // Line decorations for added lines
+  if (addedLines.size > 0) {
+    extensions.push(
+      EditorView.decorations.of((view) => {
+        const builder = new RangeSetBuilder<Decoration>();
+        const doc = view.state.doc;
+
+        for (const lineNum of addedLines) {
+          if (lineNum >= 1 && lineNum <= doc.lines) {
+            const linePos = doc.line(lineNum).from;
+            builder.add(linePos, linePos, addedLineDecoration);
+          }
+        }
+
+        return builder.finish();
+      })
+    );
+  }
+
+  // Widget decorations for deleted line groups.
+  // Block decorations MUST be provided via a StateField (not a plugin/function).
+  if (deletedGroups.size > 0) {
+    const buildDeletedDecorations = (doc: {
+      lines: number;
+      line(n: number): { from: number; to: number };
+    }) => {
+      const builder = new RangeSetBuilder<Decoration>();
+      const positions = [...deletedGroups.keys()].sort((a, b) => a - b);
+
+      for (const pos of positions) {
+        const deletedLines = deletedGroups.get(pos)!;
+        if (pos >= 1 && pos <= doc.lines) {
+          const linePos = doc.line(pos).from;
+          builder.add(
+            linePos,
+            linePos,
+            Decoration.widget({
+              widget: new DeletedLinesWidget(deletedLines),
+              block: true,
+              side: -1,
+            })
+          );
+        } else {
+          const lastLinePos = doc.line(doc.lines).to;
+          builder.add(
+            lastLinePos,
+            lastLinePos,
+            Decoration.widget({
+              widget: new DeletedLinesWidget(deletedLines),
+              block: true,
+              side: 1,
+            })
+          );
+        }
+      }
+
+      return builder.finish();
+    };
+
+    extensions.push(
+      StateField.define({
+        create(state) {
+          return buildDeletedDecorations(state.doc);
+        },
+        update(decorations, tr) {
+          if (tr.docChanged) {
+            return decorations.map(tr.changes);
+          }
+          return decorations;
+        },
+        provide: (f) => EditorView.decorations.from(f),
+      })
+    );
+  }
+
+  return extensions;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+
 // Syntax highlighting using CSS variables for theme compatibility
 const syntaxColors = HighlightStyle.define([
   { tag: t.keyword, color: 'var(--chart-4, oklch(0.7 0.15 280))' },
@@ -338,6 +405,8 @@ export const CodeEditor = forwardRef<CodeEditorHandle, CodeEditorProps>(function
     onSave,
     className,
     scrollCursorIntoView = false,
+    diffContent,
+    onSelectionChange,
   },
   ref
 ) {
@@ -347,12 +416,17 @@ export const CodeEditor = forwardRef<CodeEditorHandle, CodeEditorProps>(function
   // Stable refs for callbacks to avoid frequent extension rebuilds
   const onSaveRef = useRef(onSave);
   const onCursorChangeRef = useRef(onCursorChange);
+  const onSelectionChangeRef = useRef(onSelectionChange);
+  const lastHasSelectionRef = useRef(false);
   useEffect(() => {
     onSaveRef.current = onSave;
   }, [onSave]);
   useEffect(() => {
     onCursorChangeRef.current = onCursorChange;
   }, [onCursorChange]);
+  useEffect(() => {
+    onSelectionChangeRef.current = onSelectionChange;
+  }, [onSelectionChange]);
 
   // Expose imperative methods to parent components
   useImperativeHandle(
@@ -381,6 +455,16 @@ export const CodeEditor = forwardRef<CodeEditorHandle, CodeEditorProps>(function
           cmRedo(editorRef.current.view);
         }
       },
+      getSelection: () => {
+        const view = editorRef.current?.view;
+        if (!view) return null;
+        const { from, to } = view.state.selection.main;
+        if (from === to) return null;
+        const text = view.state.sliceDoc(from, to);
+        const fromLine = view.state.doc.lineAt(from).number;
+        const toLine = view.state.doc.lineAt(to).number;
+        return { text, fromLine, toLine };
+      },
     }),
     []
   );
@@ -537,10 +621,20 @@ export const CodeEditor = forwardRef<CodeEditorHandle, CodeEditorProps>(function
       editorTheme,
       search(),
       EditorView.updateListener.of((update) => {
-        if (update.selectionSet && onCursorChangeRef.current) {
-          const pos = update.state.selection.main.head;
-          const line = update.state.doc.lineAt(pos);
-          onCursorChangeRef.current(line.number, pos - line.from + 1);
+        if (update.selectionSet) {
+          if (onCursorChangeRef.current) {
+            const pos = update.state.selection.main.head;
+            const line = update.state.doc.lineAt(pos);
+            onCursorChangeRef.current(line.number, pos - line.from + 1);
+          }
+          if (onSelectionChangeRef.current) {
+            const { from, to } = update.state.selection.main;
+            const hasSelection = from !== to;
+            if (hasSelection !== lastHasSelectionRef.current) {
+              lastHasSelectionRef.current = hasSelection;
+              onSelectionChangeRef.current(hasSelection);
+            }
+          }
         }
       }),
     ];
@@ -572,8 +666,13 @@ export const CodeEditor = forwardRef<CodeEditorHandle, CodeEditorProps>(function
       exts.push(langExt);
     }
 
+    // Add inline diff decorations if diff content is provided
+    if (diffContent) {
+      exts.push(createDiffDecorations(diffContent));
+    }
+
     return exts;
-  }, [filePath, wordWrap, tabSize, editorTheme]);
+  }, [filePath, wordWrap, tabSize, editorTheme, diffContent]);
 
   return (
     <div className={cn('h-full w-full', className)}>

apps/ui/src/components/views/file-editor-view/components/editor-tabs.tsx

@@ -1,4 +1,5 @@
-import { X, Circle, MoreHorizontal, Save } from 'lucide-react';
+import { useRef, useEffect, useCallback } from 'react';
+import { X, Circle, MoreHorizontal, Save, ChevronLeft, ChevronRight } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import type { EditorTab } from '../use-file-editor-store';
 import {
@@ -84,61 +85,105 @@ export function EditorTabs({
   isDirty,
   showSaveButton,
 }: EditorTabsProps) {
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const activeTabRef = useRef<HTMLDivElement>(null);
+
+  // Scroll the active tab into view when it changes
+  useEffect(() => {
+    if (activeTabRef.current) {
+      activeTabRef.current.scrollIntoView({
+        behavior: 'smooth',
+        block: 'nearest',
+        inline: 'nearest',
+      });
+    }
+  }, [activeTabId]);
+
+  const scrollBy = useCallback((direction: 'left' | 'right') => {
+    if (!scrollRef.current) return;
+    const amount = direction === 'left' ? -200 : 200;
+    scrollRef.current.scrollBy({ left: amount, behavior: 'smooth' });
+  }, []);
+
   if (tabs.length === 0) return null;
 
   return (
-    <div
-      className="flex items-center border-b border-border bg-muted/30 overflow-x-auto"
-      data-testid="editor-tabs"
-    >
-      {tabs.map((tab) => {
-        const isActive = tab.id === activeTabId;
-        const fileColor = getFileColor(tab.fileName);
+    <div className="flex items-center border-b border-border bg-muted/30" data-testid="editor-tabs">
+      {/* Scroll left arrow */}
+      <button
+        onClick={() => scrollBy('left')}
+        className="shrink-0 p-1 text-muted-foreground hover:text-foreground hover:bg-muted/50 transition-colors"
+        title="Scroll tabs left"
+      >
+        <ChevronLeft className="w-4 h-4" />
+      </button>
 
-        return (
-          <div
-            key={tab.id}
-            className={cn(
-              'group flex items-center gap-1.5 px-3 py-1.5 cursor-pointer border-r border-border min-w-0 max-w-[200px] text-sm transition-colors',
-              isActive
-                ? 'bg-background text-foreground border-b-2 border-b-primary'
-                : 'text-muted-foreground hover:text-foreground hover:bg-muted/50'
-            )}
-            onClick={() => onTabSelect(tab.id)}
-            title={tab.filePath}
-          >
-            {/* Dirty indicator */}
-            {tab.isDirty ? (
-              <Circle className="w-2 h-2 shrink-0 fill-current text-primary" />
-            ) : (
-              <span className={cn('w-2 h-2 rounded-full shrink-0', fileColor)} />
-            )}
+      {/* Scrollable tab area */}
+      <div
+        ref={scrollRef}
+        className="flex items-center overflow-x-auto flex-1 min-w-0 scrollbar-none"
+      >
+        {tabs.map((tab) => {
+          const isActive = tab.id === activeTabId;
+          const fileColor = getFileColor(tab.fileName);
 
-            {/* File name */}
-            <span className="truncate">{tab.fileName}</span>
-
-            {/* Close button */}
-            <button
-              onClick={(e) => {
-                e.stopPropagation();
-                onTabClose(tab.id);
-              }}
+          return (
+            <div
+              key={tab.id}
+              ref={isActive ? activeTabRef : undefined}
               className={cn(
-                'p-0.5 rounded shrink-0 transition-colors',
-                'opacity-0 group-hover:opacity-100',
-                isActive && 'opacity-60',
-                'hover:bg-accent'
+                'group flex items-center gap-1.5 px-3 py-1.5 cursor-pointer border-r border-border min-w-0 max-w-[200px] shrink-0 text-sm transition-colors',
+                isActive
+                  ? 'bg-background text-foreground border-b-2 border-b-primary'
+                  : 'text-muted-foreground hover:text-foreground hover:bg-muted/50'
               )}
-              title="Close"
+              onClick={() => onTabSelect(tab.id)}
+              title={tab.filePath}
             >
-              <X className="w-3 h-3" />
-            </button>
-          </div>
-        );
-      })}
+              {/* Dirty indicator */}
+              {tab.isDirty ? (
+                <Circle className="w-2 h-2 shrink-0 fill-current text-primary" />
+              ) : (
+                <span
+                  className={cn('w-2 h-2 rounded-full shrink-0', fileColor.replace('text-', 'bg-'))}
+                />
+              )}
+
+              {/* File name */}
+              <span className="truncate">{tab.fileName}</span>
+
+              {/* Close button */}
+              <button
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onTabClose(tab.id);
+                }}
+                className={cn(
+                  'p-0.5 rounded shrink-0 transition-colors',
+                  'opacity-0 group-hover:opacity-100',
+                  isActive && 'opacity-60',
+                  'hover:bg-accent'
+                )}
+                title="Close"
+              >
+                <X className="w-3 h-3" />
+              </button>
+            </div>
+          );
+        })}
+      </div>
+
+      {/* Scroll right arrow */}
+      <button
+        onClick={() => scrollBy('right')}
+        className="shrink-0 p-1 text-muted-foreground hover:text-foreground hover:bg-muted/50 transition-colors"
+        title="Scroll tabs right"
+      >
+        <ChevronRight className="w-4 h-4" />
+      </button>
 
       {/* Tab actions: save button (mobile) + close-all dropdown */}
-      <div className="ml-auto shrink-0 flex items-center px-1 gap-0.5">
+      <div className="shrink-0 flex items-center px-1 gap-0.5 border-l border-border">
         {/* Save button — shown in the tab bar on mobile */}
         {showSaveButton && onSave && (
           <button