Fix concurrency limits and remote branch fetching issues

apps/server/src/routes/auto-mode/routes/run-feature.ts

@@ -26,23 +26,9 @@ export function createRunFeatureHandler(autoModeService: AutoModeServiceCompat)
         return;
       }
 
-      // Check per-worktree capacity before starting
-      const capacity = await autoModeService.checkWorktreeCapacity(projectPath, featureId);
-      if (!capacity.hasCapacity) {
-        const worktreeDesc = capacity.branchName
-          ? `worktree "${capacity.branchName}"`
-          : 'main worktree';
-        res.status(429).json({
-          success: false,
-          error: `Agent limit reached for ${worktreeDesc} (${capacity.currentAgents}/${capacity.maxAgents}). Wait for running tasks to complete or increase the limit.`,
-          details: {
-            currentAgents: capacity.currentAgents,
-            maxAgents: capacity.maxAgents,
-            branchName: capacity.branchName,
-          },
-        });
-        return;
-      }
+      // Note: No concurrency limit check here. Manual feature starts always run
+      // immediately and bypass the concurrency limit. Their presence IS counted
+      // by the auto-loop coordinator when deciding whether to dispatch new auto-mode tasks.
 
       // Start execution in background
       // executeFeature derives workDir from feature.branchName

apps/server/src/routes/git/routes/diffs.ts

@@ -23,6 +23,7 @@ export function createDiffsHandler() {
           diff: result.diff,
           files: result.files,
           hasChanges: result.hasChanges,
+          ...(result.mergeState ? { mergeState: result.mergeState } : {}),
         });
       } catch (innerError) {
         logError(innerError, 'Git diff failed');

apps/server/src/routes/worktree/routes/checkout-branch.ts

@@ -22,6 +22,36 @@ import { getErrorMessage, logError, isValidBranchName } from '../common.js';
 import { execGitCommand } from '../../../lib/git.js';
 import type { EventEmitter } from '../../../lib/events.js';
 import { performCheckoutBranch } from '../../../services/checkout-branch-service.js';
+import { createLogger } from '@automaker/utils';
+
+const logger = createLogger('CheckoutBranchRoute');
+
+/** Timeout for git fetch operations (30 seconds) */
+const FETCH_TIMEOUT_MS = 30_000;
+
+/**
+ * Fetch latest from all remotes (silently, with timeout).
+ * Non-fatal: fetch errors are logged and swallowed so the workflow continues.
+ */
+async function fetchRemotes(cwd: string): Promise<void> {
+  const controller = new AbortController();
+  const timerId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    await execGitCommand(['fetch', '--all', '--quiet'], cwd, undefined, controller);
+  } catch (error) {
+    if (error instanceof Error && error.message === 'Process aborted') {
+      logger.warn(
+        `fetchRemotes timed out after ${FETCH_TIMEOUT_MS}ms - continuing without latest remote refs`
+      );
+    } else {
+      logger.warn(`fetchRemotes failed: ${getErrorMessage(error)} - continuing with local refs`);
+    }
+    // Non-fatal: continue with locally available refs
+  } finally {
+    clearTimeout(timerId);
+  }
+}
 
 export function createCheckoutBranchHandler(events?: EventEmitter) {
   return async (req: Request, res: Response): Promise<void> => {
@@ -127,6 +157,10 @@ export function createCheckoutBranchHandler(events?: EventEmitter) {
       }
 
       // Original simple flow (no stash handling)
+      // Fetch latest remote refs before creating the branch so that
+      // base branch validation works for remote references like "origin/main"
+      await fetchRemotes(resolvedPath);
+
       const currentBranchOutput = await execGitCommand(
         ['rev-parse', '--abbrev-ref', 'HEAD'],
         resolvedPath

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

@@ -30,6 +30,9 @@ import { runInitScript } from '../../../services/init-script-service.js';
 
 const logger = createLogger('Worktree');
 
+/** Timeout for git fetch operations (30 seconds) */
+const FETCH_TIMEOUT_MS = 30_000;
+
 const execAsync = promisify(exec);
 
 /**
@@ -83,41 +86,6 @@ async function findExistingWorktreeForBranch(
   }
 }
 
-/**
- * Detect whether a base branch reference is a remote branch (e.g. "origin/main").
- * Returns the remote name if it matches a known remote, otherwise null.
- */
-async function detectRemoteBranch(
-  projectPath: string,
-  baseBranch: string
-): Promise<{ remote: string; branch: string } | null> {
-  const slashIndex = baseBranch.indexOf('/');
-  if (slashIndex <= 0) return null;
-
-  const possibleRemote = baseBranch.substring(0, slashIndex);
-
-  try {
-    // Check if this is actually a remote name by listing remotes
-    const stdout = await execGitCommand(['remote'], projectPath);
-    const remotes = stdout
-      .trim()
-      .split('\n')
-      .map((r: string) => r.trim())
-      .filter(Boolean);
-
-    if (remotes.includes(possibleRemote)) {
-      return {
-        remote: possibleRemote,
-        branch: baseBranch.substring(slashIndex + 1),
-      };
-    }
-  } catch {
-    // Not a git repo or no remotes — fall through
-  }
-
-  return null;
-}
-
 export function createCreateHandler(events: EventEmitter, settingsService?: SettingsService) {
   const worktreeService = new WorktreeService();
 
@@ -206,26 +174,23 @@ export function createCreateHandler(events: EventEmitter, settingsService?: Sett
       // Create worktrees directory if it doesn't exist
       await secureFs.mkdir(worktreesDir, { recursive: true });
 
-      // If a base branch is specified and it's a remote branch, fetch from that remote first
-      // This ensures we have the latest refs before creating the worktree
-      if (baseBranch && baseBranch !== 'HEAD') {
-        const remoteBranchInfo = await detectRemoteBranch(projectPath, baseBranch);
-        if (remoteBranchInfo) {
-          logger.info(
-            `Fetching from remote "${remoteBranchInfo.remote}" before creating worktree (base: ${baseBranch})`
-          );
-          try {
-            await execGitCommand(
-              ['fetch', remoteBranchInfo.remote, remoteBranchInfo.branch],
-              projectPath
-            );
-          } catch (fetchErr) {
-            // Non-fatal: log but continue — the ref might already be cached locally
-            logger.warn(
-              `Failed to fetch from remote "${remoteBranchInfo.remote}": ${getErrorMessage(fetchErr)}`
-            );
-          }
+      // Fetch latest from all remotes before creating the worktree.
+      // This ensures remote refs are up-to-date for:
+      // - Remote base branches (e.g. "origin/main")
+      // - Existing remote branches being checked out as worktrees
+      // - Branch existence checks against fresh remote state
+      logger.info('Fetching from all remotes before creating worktree');
+      try {
+        const controller = new AbortController();
+        const timerId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        try {
+          await execGitCommand(['fetch', '--all', '--quiet'], projectPath, undefined, controller);
+        } finally {
+          clearTimeout(timerId);
         }
+      } catch (fetchErr) {
+        // Non-fatal: log but continue — refs might already be cached locally
+        logger.warn(`Failed to fetch from remotes: ${getErrorMessage(fetchErr)}`);
       }
 
       // Check if branch exists (using array arguments to prevent injection)

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

@@ -34,6 +34,7 @@ export function createDiffsHandler() {
           diff: result.diff,
           files: result.files,
           hasChanges: result.hasChanges,
+          ...(result.mergeState ? { mergeState: result.mergeState } : {}),
         });
         return;
       }
@@ -55,6 +56,7 @@ export function createDiffsHandler() {
           diff: result.diff,
           files: result.files,
           hasChanges: result.hasChanges,
+          ...(result.mergeState ? { mergeState: result.mergeState } : {}),
         });
       } catch (innerError) {
         // Worktree doesn't exist - fallback to main project path
@@ -71,6 +73,7 @@ export function createDiffsHandler() {
             diff: result.diff,
             files: result.files,
             hasChanges: result.hasChanges,
+            ...(result.mergeState ? { mergeState: result.mergeState } : {}),
           });
         } catch (fallbackError) {
           logError(fallbackError, 'Fallback to main project also failed');

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

@@ -83,6 +83,9 @@ function mapResultToResponse(res: Response, result: PullResult): void {
       stashed: result.stashed,
       stashRestored: result.stashRestored,
       message: result.message,
+      isMerge: result.isMerge,
+      isFastForward: result.isFastForward,
+      mergeAffectedFiles: result.mergeAffectedFiles,
     },
   });
 }

apps/server/src/routes/worktree/routes/switch-branch.ts

@@ -9,7 +9,7 @@
  * For remote branches (e.g., "origin/feature"), automatically creates a
  * local tracking branch and checks it out.
  *
- * Also fetches the latest remote refs after switching.
+ * Also fetches the latest remote refs before switching to ensure accurate branch detection.
  *
  * Git business logic is delegated to worktree-branch-service.ts.
  * Events are emitted at key lifecycle points for WebSocket subscribers.

apps/server/src/services/auto-loop-coordinator.ts

@@ -163,6 +163,10 @@ export class AutoLoopCoordinator {
     const { projectPath, branchName } = projectState.config;
     while (projectState.isRunning && !projectState.abortController.signal.aborted) {
       try {
+        // Count ALL running features (both auto and manual) against the concurrency limit.
+        // This ensures auto mode is aware of the total system load and does not over-subscribe
+        // resources. Manual tasks always bypass the limit and run immediately, but their
+        // presence is accounted for when deciding whether to dispatch new auto-mode tasks.
         const runningCount = await this.getRunningCountForWorktree(projectPath, branchName);
         if (runningCount >= projectState.config.maxConcurrency) {
           await this.sleep(5000, projectState.abortController.signal);
@@ -298,11 +302,17 @@ export class AutoLoopCoordinator {
     return Array.from(activeProjects);
   }
 
+  /**
+   * Get the number of running features for a worktree.
+   * By default counts ALL running features (both auto-mode and manual).
+   * Pass `autoModeOnly: true` to count only auto-mode features.
+   */
   async getRunningCountForWorktree(
     projectPath: string,
-    branchName: string | null
+    branchName: string | null,
+    options?: { autoModeOnly?: boolean }
   ): Promise<number> {
-    return this.concurrencyManager.getRunningCountForWorktree(projectPath, branchName);
+    return this.concurrencyManager.getRunningCountForWorktree(projectPath, branchName, options);
   }
 
   trackFailureAndCheckPauseForProject(

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

@@ -334,6 +334,23 @@ export class AutoModeServiceFacade {
       async (pPath) => featureLoader.getAll(pPath)
     );
 
+    /**
+     * Iterate all active worktrees for this project, falling back to the
+     * main worktree (null) when none are active.
+     */
+    const forEachProjectWorktree = (fn: (branchName: string | null) => void): void => {
+      const projectWorktrees = autoLoopCoordinator
+        .getActiveWorktrees()
+        .filter((w) => w.projectPath === projectPath);
+      if (projectWorktrees.length === 0) {
+        fn(null);
+      } else {
+        for (const w of projectWorktrees) {
+          fn(w.branchName);
+        }
+      }
+    };
+
     // ExecutionService - runAgentFn delegates to AgentExecutor via shared helper
     const executionService = new ExecutionService(
       eventBus,
@@ -357,11 +374,36 @@ export class AutoModeServiceFacade {
       (pPath, featureId) => getFacade().contextExists(featureId),
       (pPath, featureId, useWorktrees, _calledInternally) =>
         getFacade().resumeFeature(featureId, useWorktrees, _calledInternally),
-      (errorInfo) =>
-        autoLoopCoordinator.trackFailureAndCheckPauseForProject(projectPath, null, errorInfo),
-      (errorInfo) => autoLoopCoordinator.signalShouldPauseForProject(projectPath, null, errorInfo),
+      (errorInfo) => {
+        // Track failure against ALL active worktrees for this project.
+        // The ExecutionService callbacks don't receive branchName, so we
+        // iterate all active worktrees. Uses a for-of loop (not .some()) to
+        // ensure every worktree's failure counter is incremented.
+        let shouldPause = false;
+        forEachProjectWorktree((branchName) => {
+          if (
+            autoLoopCoordinator.trackFailureAndCheckPauseForProject(
+              projectPath,
+              branchName,
+              errorInfo
+            )
+          ) {
+            shouldPause = true;
+          }
+        });
+        return shouldPause;
+      },
+      (errorInfo) => {
+        forEachProjectWorktree((branchName) =>
+          autoLoopCoordinator.signalShouldPauseForProject(projectPath, branchName, errorInfo)
+        );
+      },
       () => {
-        /* recordSuccess - no-op */
+        // Record success to clear failure tracking. This prevents failures
+        // from accumulating over time and incorrectly pausing auto mode.
+        forEachProjectWorktree((branchName) =>
+          autoLoopCoordinator.recordSuccessForProject(projectPath, branchName)
+        );
       },
       (_pPath) => getFacade().saveExecutionState(),
       loadContextFiles

apps/server/src/services/checkout-branch-service.ts

@@ -10,6 +10,7 @@
  * Follows the same pattern as worktree-branch-service.ts (performSwitchBranch).
  *
  * The workflow:
+ * 0. Fetch latest from all remotes (ensures remote refs are up-to-date)
  * 1. Validate inputs (branch name, base branch)
  * 2. Get current branch name
  * 3. Check if target branch already exists
@@ -19,11 +20,51 @@
  * 7. Handle error recovery (restore stash if checkout fails)
  */
 
-import { getErrorMessage } from '@automaker/utils';
+import { createLogger, getErrorMessage } from '@automaker/utils';
 import { execGitCommand } from '../lib/git.js';
 import type { EventEmitter } from '../lib/events.js';
 import { hasAnyChanges, stashChanges, popStash, localBranchExists } from './branch-utils.js';
 
+const logger = createLogger('CheckoutBranchService');
+
+// ============================================================================
+// Local Helpers
+// ============================================================================
+
+/** Timeout for git fetch operations (30 seconds) */
+const FETCH_TIMEOUT_MS = 30_000;
+
+/**
+ * Fetch latest from all remotes (silently, with timeout).
+ *
+ * A process-level timeout is enforced via an AbortController so that a
+ * slow or unresponsive remote does not block the branch creation flow
+ * indefinitely.  Timeout errors are logged and treated as non-fatal
+ * (the same as network-unavailable errors) so the rest of the workflow
+ * continues normally.  This is called before creating the new branch to
+ * ensure remote refs are up-to-date when a remote base branch is used.
+ */
+async function fetchRemotes(cwd: string): Promise<void> {
+  const controller = new AbortController();
+  const timerId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    await execGitCommand(['fetch', '--all', '--quiet'], cwd, undefined, controller);
+  } catch (error) {
+    if (controller.signal.aborted) {
+      // Fetch timed out - log and continue; callers should not be blocked by a slow remote
+      logger.warn(
+        `fetchRemotes timed out after ${FETCH_TIMEOUT_MS}ms - continuing without latest remote refs`
+      );
+    } else {
+      logger.warn(`fetchRemotes failed: ${getErrorMessage(error)} - continuing with local refs`);
+    }
+    // Non-fatal: continue with locally available refs regardless of failure type
+  } finally {
+    clearTimeout(timerId);
+  }
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -78,6 +119,11 @@ export async function performCheckoutBranch(
   // Emit start event
   events?.emit('switch:start', { worktreePath, branchName, operation: 'checkout' });
 
+  // 0. Fetch latest from all remotes before creating the branch
+  //    This ensures remote refs are up-to-date so that base branch validation
+  //    works correctly for remote branch references (e.g. "origin/main").
+  await fetchRemotes(worktreePath);
+
   // 1. Get current branch
   let previousBranch: string;
   try {