feat: implement running agents view and enhance auto mode functionality

- Added a new `RunningAgentsView` component to display currently active agents working on features.
- Implemented auto-refresh functionality for the running agents list every 2 seconds.
- Enhanced the auto mode service to support project-specific operations, including starting and stopping auto mode for individual projects.
- Updated IPC handlers to manage auto mode status and running agents more effectively.
- Introduced audio settings to mute notifications when agents complete tasks.
- Refactored existing components to accommodate new features and improve overall user experience.

app/electron/services/claude-cli-detector.js

@@ -303,6 +303,30 @@ class ClaudeCliDetector {
     };
   }
 
+  /**
+   * Get installation info and recommendations
+   * @returns {Object} Installation status and recommendations
+   */
+  static getInstallationInfo() {
+    const detection = this.detectClaudeInstallation();
+
+    if (detection.installed) {
+      return {
+        status: 'installed',
+        method: detection.method,
+        version: detection.version,
+        path: detection.path,
+        recommendation: 'Claude Code CLI is ready for ultrathink'
+      };
+    }
+
+    return {
+      status: 'not_installed',
+      recommendation: 'Install Claude Code CLI for optimal ultrathink performance',
+      installCommands: this.getInstallCommands()
+    };
+  }
+
   /**
    * Get installation commands for different platforms
    * @returns {Object} Installation commands

app/electron/services/feature-suggestions-service.js

@@ -11,10 +11,14 @@ class FeatureSuggestionsService {
 
   /**
    * Generate feature suggestions by analyzing the project
+   * @param {string} projectPath - Path to the project
+   * @param {Function} sendToRenderer - Function to send events to renderer
+   * @param {Object} execution - Execution context with abort controller
+   * @param {string} suggestionType - Type of suggestions: "features", "refactoring", "security", "performance"
    */
-  async generateSuggestions(projectPath, sendToRenderer, execution) {
+  async generateSuggestions(projectPath, sendToRenderer, execution, suggestionType = "features") {
     console.log(
-      `[FeatureSuggestions] Generating suggestions for: ${projectPath}`
+      `[FeatureSuggestions] Generating ${suggestionType} suggestions for: ${projectPath}`
     );
 
     try {
@@ -23,7 +27,7 @@ class FeatureSuggestionsService {
 
       const options = {
         model: "claude-sonnet-4-20250514",
-        systemPrompt: this.getSystemPrompt(),
+        systemPrompt: this.getSystemPrompt(suggestionType),
         maxTurns: 50,
         cwd: projectPath,
         allowedTools: ["Read", "Glob", "Grep", "Bash"],
@@ -35,7 +39,7 @@ class FeatureSuggestionsService {
         abortController: abortController,
       };
 
-      const prompt = this.buildAnalysisPrompt();
+      const prompt = this.buildAnalysisPrompt(suggestionType);
 
       sendToRenderer({
         type: "suggestions_progress",
@@ -163,36 +167,102 @@ class FeatureSuggestionsService {
 
   /**
    * Get the system prompt for feature suggestion analysis
+   * @param {string} suggestionType - Type of suggestions: "features", "refactoring", "security", "performance"
    */
-  getSystemPrompt() {
-    return `You are an expert software architect and product manager. Your job is to analyze a codebase and suggest missing features that would improve the application.
+  getSystemPrompt(suggestionType = "features") {
+    const basePrompt = `You are an expert software architect. Your job is to analyze a codebase and provide actionable suggestions.
 
-You should:
-1. Thoroughly analyze the project structure, code, and any existing documentation
-2. Identify what the application does and what features it currently has (look at the .automaker/app_spec.txt file as well if it exists)
-3. Generate a comprehensive list of missing features that would be valuable to users
-4. Prioritize features by impact and complexity
-5. Provide clear, actionable descriptions and implementation steps
+You have access to file reading and search tools. Use them to understand the codebase.
 
 When analyzing, look at:
 - README files and documentation
 - Package.json, cargo.toml, or similar config files for tech stack
 - Source code structure and organization
-- Existing features and their implementation patterns
-- Common patterns in similar applications
-- User experience improvements
-- Developer experience improvements
-- Performance optimizations
-- Security enhancements
+- Existing code patterns and implementation styles`;
 
-You have access to file reading and search tools. Use them to understand the codebase.`;
+    switch (suggestionType) {
+      case "refactoring":
+        return `${basePrompt}
+
+Your specific focus is on **refactoring suggestions**. You should:
+1. Identify code smells and areas that need cleanup
+2. Find duplicated code that could be consolidated
+3. Spot overly complex functions or classes that should be broken down
+4. Look for inconsistent naming conventions or coding patterns
+5. Find opportunities to improve code organization and modularity
+6. Identify violations of SOLID principles or common design patterns
+7. Look for dead code or unused dependencies
+
+Prioritize suggestions by:
+- Impact on maintainability
+- Risk level (lower risk refactorings first)
+- Complexity of the refactoring`;
+
+      case "security":
+        return `${basePrompt}
+
+Your specific focus is on **security vulnerabilities and improvements**. You should:
+1. Identify potential security vulnerabilities (OWASP Top 10)
+2. Look for hardcoded secrets, API keys, or credentials
+3. Check for proper input validation and sanitization
+4. Identify SQL injection, XSS, or command injection risks
+5. Review authentication and authorization patterns
+6. Check for secure communication (HTTPS, encryption)
+7. Look for insecure dependencies or outdated packages
+8. Review error handling that might leak sensitive information
+9. Check for proper session management
+10. Identify insecure file handling or path traversal risks
+
+Prioritize by severity:
+- Critical: Exploitable vulnerabilities with high impact
+- High: Security issues that could lead to data exposure
+- Medium: Best practice violations that weaken security
+- Low: Minor improvements to security posture`;
+
+      case "performance":
+        return `${basePrompt}
+
+Your specific focus is on **performance issues and optimizations**. You should:
+1. Identify N+1 query problems or inefficient database access
+2. Look for unnecessary re-renders in React/frontend code
+3. Find opportunities for caching or memoization
+4. Identify large bundle sizes or unoptimized imports
+5. Look for blocking operations that could be async
+6. Find memory leaks or inefficient memory usage
+7. Identify slow algorithms or data structure choices
+8. Look for missing indexes in database schemas
+9. Find opportunities for lazy loading or code splitting
+10. Identify unnecessary network requests or API calls
+
+Prioritize by:
+- Impact on user experience
+- Frequency of the slow path
+- Ease of implementation`;
+
+      default: // "features"
+        return `${basePrompt}
+
+Your specific focus is on **missing features and improvements**. You should:
+1. Identify what the application does and what features it currently has
+2. Look at the .automaker/app_spec.txt file if it exists
+3. Generate a comprehensive list of missing features that would be valuable to users
+4. Consider user experience improvements
+5. Consider developer experience improvements
+6. Look at common patterns in similar applications
+
+Prioritize features by:
+- Impact on users
+- Alignment with project goals
+- Complexity of implementation`;
+    }
   }
 
   /**
    * Build the prompt for analyzing the project
+   * @param {string} suggestionType - Type of suggestions: "features", "refactoring", "security", "performance"
    */
-  buildAnalysisPrompt() {
-    return `Analyze this project and generate a list of suggested features that are missing or would improve the application.
+  buildAnalysisPrompt(suggestionType = "features") {
+    const commonIntro = `Analyze this project and generate a list of actionable suggestions.
 
 **Your Task:**
 
@@ -200,13 +270,89 @@ You have access to file reading and search tools. Use them to understand the cod
    - Read README.md, package.json, or similar config files
    - Scan the source code directory structure
    - Identify the tech stack and frameworks used
-   - Look at existing features and how they're implemented
+   - Look at existing code and how it's implemented
 
 2. Identify what the application does:
    - What is the main purpose?
-   - What features are already implemented?
    - What patterns and conventions are used?
+`;
 
+    const commonOutput = `
+**CRITICAL: Output your suggestions as a JSON array** at the end of your response, formatted like this:
+
+\`\`\`json
+[
+  {
+    "category": "Category Name",
+    "description": "Clear description of the suggestion",
+    "steps": [
+      "Step 1 to implement",
+      "Step 2 to implement",
+      "Step 3 to implement"
+    ],
+    "priority": 1,
+    "reasoning": "Why this is important"
+  }
+]
+\`\`\`
+
+**Important Guidelines:**
+- Generate at least 10-15 suggestions
+- Order them by priority (1 = highest priority)
+- Each suggestion should have clear, actionable steps
+- Be specific about what files might need to be modified
+- Consider the existing tech stack and patterns
+
+Begin by exploring the project structure.`;
+
+    switch (suggestionType) {
+      case "refactoring":
+        return `${commonIntro}
+3. Look for refactoring opportunities:
+   - Find code duplication across the codebase
+   - Identify functions or classes that are too long or complex
+   - Look for inconsistent patterns or naming conventions
+   - Find tightly coupled code that should be decoupled
+   - Identify opportunities to extract reusable utilities
+   - Look for dead code or unused exports
+   - Check for proper separation of concerns
+
+Categories to use: "Code Smell", "Duplication", "Complexity", "Architecture", "Naming", "Dead Code", "Coupling", "Testing"
+${commonOutput}`;
+
+      case "security":
+        return `${commonIntro}
+3. Look for security issues:
+   - Check for hardcoded secrets or API keys
+   - Look for potential injection vulnerabilities (SQL, XSS, command)
+   - Review authentication and authorization code
+   - Check input validation and sanitization
+   - Look for insecure dependencies
+   - Review error handling for information leakage
+   - Check for proper HTTPS/TLS usage
+   - Look for insecure file operations
+
+Categories to use: "Critical", "High", "Medium", "Low" (based on severity)
+${commonOutput}`;
+
+      case "performance":
+        return `${commonIntro}
+3. Look for performance issues:
+   - Find N+1 queries or inefficient database access patterns
+   - Look for unnecessary re-renders in React components
+   - Identify missing memoization opportunities
+   - Check bundle size and import patterns
+   - Look for synchronous operations that could be async
+   - Find potential memory leaks
+   - Identify slow algorithms or data structures
+   - Look for missing caching opportunities
+   - Check for unnecessary network requests
+
+Categories to use: "Database", "Rendering", "Memory", "Bundle Size", "Caching", "Algorithm", "Network"
+${commonOutput}`;
+
+      default: // "features"
+        return `${commonIntro}
 3. Generate feature suggestions:
    - Think about what's missing compared to similar applications
    - Consider user experience improvements
@@ -214,45 +360,9 @@ You have access to file reading and search tools. Use them to understand the cod
    - Think about performance, security, and reliability
    - Consider testing and documentation improvements
 
-4. **CRITICAL: Output your suggestions as a JSON array** at the end of your response, formatted like this:
-
-\`\`\`json
-[
-  {
-    "category": "User Experience",
-    "description": "Add dark mode support with system preference detection",
-    "steps": [
-      "Create a ThemeProvider context to manage theme state",
-      "Add a toggle component in the settings or header",
-      "Implement CSS variables for theme colors",
-      "Add localStorage persistence for user preference"
-    ],
-    "priority": 1,
-    "reasoning": "Dark mode is a standard feature that improves accessibility and user comfort"
-  },
-  {
-    "category": "Performance",
-    "description": "Implement lazy loading for heavy components",
-    "steps": [
-      "Identify components that are heavy or rarely used",
-      "Use React.lazy() and Suspense for code splitting",
-      "Add loading states for lazy-loaded components"
-    ],
-    "priority": 2,
-    "reasoning": "Improves initial load time and reduces bundle size"
-  }
-]
-\`\`\`
-
-**Important Guidelines:**
-- Generate at least 10-20 feature suggestions
-- Order them by priority (1 = highest priority)
-- Each feature should have clear, actionable steps
-- Categories should be meaningful (e.g., "User Experience", "Performance", "Security", "Testing", "Documentation", "Developer Experience", "Accessibility", etc.)
-- Be specific about what files might need to be created or modified
-- Consider the existing tech stack and patterns when suggesting implementation steps
-
-Begin by exploring the project structure.`;
+Categories to use: "User Experience", "Performance", "Security", "Testing", "Documentation", "Developer Experience", "Accessibility", etc.
+${commonOutput}`;
+    }
   }
 
   /**

app/electron/services/model-provider.js

@@ -251,7 +251,7 @@ class ClaudeProvider extends ModelProvider {
 
   async detectInstallation() {
     const claudeCliDetector = require('./claude-cli-detector');
-    return claudeCliDetector.getInstallationInfo();
+    return claudeCliDetector.getFullStatus();
   }
 
   getAvailableModels() {