feat: enhance auto mode functionality with worktree support

- Updated auto mode handlers to support branch-specific operations, allowing for better management of features across different worktrees.
- Introduced normalization of branch names to handle undefined values gracefully.
- Enhanced status and response messages to reflect the current worktree context.
- Updated the auto mode service to manage state and concurrency settings per worktree, improving user experience and flexibility.
- Added UI elements to display current max concurrency for auto mode in both board and mobile views.

This update aims to streamline the auto mode experience, making it more intuitive for users working with multiple branches and worktrees.

apps/server/src/routes/auto-mode/routes/start.ts

@@ -12,8 +12,9 @@ const logger = createLogger('AutoMode');
 export function createStartHandler(autoModeService: AutoModeService) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { projectPath, maxConcurrency } = req.body as {
+      const { projectPath, branchName, maxConcurrency } = req.body as {
         projectPath: string;
+        branchName?: string | null;
         maxConcurrency?: number;
       };
 
@@ -25,26 +26,38 @@ export function createStartHandler(autoModeService: AutoModeService) {
         return;
       }
 
+      // Normalize branchName: undefined becomes null
+      const normalizedBranchName = branchName ?? null;
+      const worktreeDesc = normalizedBranchName
+        ? `worktree ${normalizedBranchName}`
+        : 'main worktree';
+
       // Check if already running
-      if (autoModeService.isAutoLoopRunningForProject(projectPath)) {
+      if (autoModeService.isAutoLoopRunningForProject(projectPath, normalizedBranchName)) {
         res.json({
           success: true,
-          message: 'Auto mode is already running for this project',
+          message: `Auto mode is already running for ${worktreeDesc}`,
           alreadyRunning: true,
+          branchName: normalizedBranchName,
         });
         return;
       }
 
-      // Start the auto loop for this project
-      await autoModeService.startAutoLoopForProject(projectPath, maxConcurrency ?? 3);
+      // Start the auto loop for this project/worktree
+      const resolvedMaxConcurrency = await autoModeService.startAutoLoopForProject(
+        projectPath,
+        normalizedBranchName,
+        maxConcurrency
+      );
 
       logger.info(
-        `Started auto loop for project: ${projectPath} with maxConcurrency: ${maxConcurrency ?? 3}`
+        `Started auto loop for ${worktreeDesc} in project: ${projectPath} with maxConcurrency: ${resolvedMaxConcurrency}`
       );
 
       res.json({
         success: true,
-        message: `Auto mode started with max ${maxConcurrency ?? 3} concurrent features`,
+        message: `Auto mode started with max ${resolvedMaxConcurrency} concurrent features`,
+        branchName: normalizedBranchName,
       });
     } catch (error) {
       logError(error, 'Start auto mode failed');

apps/server/src/routes/auto-mode/routes/status.ts

@@ -12,11 +12,19 @@ import { getErrorMessage, logError } from '../common.js';
 export function createStatusHandler(autoModeService: AutoModeService) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { projectPath } = req.body as { projectPath?: string };
+      const { projectPath, branchName } = req.body as {
+        projectPath?: string;
+        branchName?: string | null;
+      };
 
-      // If projectPath is provided, return per-project status
+      // If projectPath is provided, return per-project/worktree status
       if (projectPath) {
-        const projectStatus = autoModeService.getStatusForProject(projectPath);
+        // Normalize branchName: undefined becomes null
+        const normalizedBranchName = branchName ?? null;
+        const projectStatus = autoModeService.getStatusForProject(
+          projectPath,
+          normalizedBranchName
+        );
         res.json({
           success: true,
           isRunning: projectStatus.runningCount > 0,
@@ -25,6 +33,7 @@ export function createStatusHandler(autoModeService: AutoModeService) {
           runningCount: projectStatus.runningCount,
           maxConcurrency: projectStatus.maxConcurrency,
           projectPath,
+          branchName: normalizedBranchName,
         });
         return;
       }
@@ -32,10 +41,12 @@ export function createStatusHandler(autoModeService: AutoModeService) {
       // Fall back to global status for backward compatibility
       const status = autoModeService.getStatus();
       const activeProjects = autoModeService.getActiveAutoLoopProjects();
+      const activeWorktrees = autoModeService.getActiveAutoLoopWorktrees();
       res.json({
         success: true,
         ...status,
         activeAutoLoopProjects: activeProjects,
+        activeAutoLoopWorktrees: activeWorktrees,
       });
     } catch (error) {
       logError(error, 'Get status failed');

apps/server/src/routes/auto-mode/routes/stop.ts

@@ -12,8 +12,9 @@ const logger = createLogger('AutoMode');
 export function createStopHandler(autoModeService: AutoModeService) {
   return async (req: Request, res: Response): Promise<void> => {
     try {
-      const { projectPath } = req.body as {
+      const { projectPath, branchName } = req.body as {
         projectPath: string;
+        branchName?: string | null;
       };
 
       if (!projectPath) {
@@ -24,27 +25,38 @@ export function createStopHandler(autoModeService: AutoModeService) {
         return;
       }
 
+      // Normalize branchName: undefined becomes null
+      const normalizedBranchName = branchName ?? null;
+      const worktreeDesc = normalizedBranchName
+        ? `worktree ${normalizedBranchName}`
+        : 'main worktree';
+
       // Check if running
-      if (!autoModeService.isAutoLoopRunningForProject(projectPath)) {
+      if (!autoModeService.isAutoLoopRunningForProject(projectPath, normalizedBranchName)) {
         res.json({
           success: true,
-          message: 'Auto mode is not running for this project',
+          message: `Auto mode is not running for ${worktreeDesc}`,
           wasRunning: false,
+          branchName: normalizedBranchName,
         });
         return;
       }
 
-      // Stop the auto loop for this project
-      const runningCount = await autoModeService.stopAutoLoopForProject(projectPath);
+      // Stop the auto loop for this project/worktree
+      const runningCount = await autoModeService.stopAutoLoopForProject(
+        projectPath,
+        normalizedBranchName
+      );
 
       logger.info(
-        `Stopped auto loop for project: ${projectPath}, ${runningCount} features still running`
+        `Stopped auto loop for ${worktreeDesc} in project: ${projectPath}, ${runningCount} features still running`
       );
 
       res.json({
         success: true,
         message: 'Auto mode stopped',
         runningFeaturesCount: runningCount,
+        branchName: normalizedBranchName,
       });
     } catch (error) {
       logError(error, 'Stop auto mode failed');