Merge pull request #354 from AutoMaker-Org/ideation

feat: implement ideation feature for brainstorming and idea management

.claude/.gitignore

@@ -0,0 +1 @@
+hans/

.dockerignore

@@ -0,0 +1 @@
+node_modules/

.gitignore

@@ -81,6 +81,7 @@ blob-report/
 
 docker-compose.override.yml
 .claude/docker-compose.override.yml
+.claude/hans/
 
 pnpm-lock.yaml
 yarn.lock

.husky/pre-commit

@@ -1 +1,34 @@
-npx lint-staged
+#!/usr/bin/env sh
+
+# Try to load nvm if available (optional - works without it too)
+if [ -z "$NVM_DIR" ]; then
+  # Check for Herd's nvm first (macOS with Herd)
+  if [ -s "$HOME/Library/Application Support/Herd/config/nvm/nvm.sh" ]; then
+    export NVM_DIR="$HOME/Library/Application Support/Herd/config/nvm"
+  # Then check standard nvm location
+  elif [ -s "$HOME/.nvm/nvm.sh" ]; then
+    export NVM_DIR="$HOME/.nvm"
+  fi
+fi
+
+# Source nvm if found (silently skip if not available)
+[ -n "$NVM_DIR" ] && [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" 2>/dev/null
+
+# Load node version from .nvmrc if using nvm (silently skip if nvm not available)
+[ -f .nvmrc ] && command -v nvm >/dev/null 2>&1 && nvm use >/dev/null 2>&1
+
+# Ensure common system paths are in PATH (for systems without nvm)
+# This helps find node/npm installed via Homebrew, system packages, etc.
+export PATH="$PATH:/usr/local/bin:/opt/homebrew/bin:/usr/bin"
+
+# Run lint-staged - works with or without nvm
+# Prefer npx, fallback to npm exec, both work with system-installed Node.js
+if command -v npx >/dev/null 2>&1; then
+  npx lint-staged
+elif command -v npm >/dev/null 2>&1; then
+  npm exec -- lint-staged
+else
+  echo "Error: Neither npx nor npm found in PATH."
+  echo "Please ensure Node.js is installed (via nvm, Homebrew, system package manager, etc.)"
+  exit 1
+fi

README.md

@@ -120,29 +120,37 @@ npm install
 # 3. Build shared packages (Now can be skipped npm install / run dev does it automaticly)
 npm run build:packages
 
-# 4. Set up authentication (skip if using Claude Code CLI)
-# If using Claude Code CLI: credentials are detected automatically
-# If using API key directly, choose one method:
-
-# Option A: Environment variable
-export ANTHROPIC_API_KEY="sk-ant-..."
-
-# Option B: Create .env file in project root
-echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
-
-# 5. Start Automaker (interactive launcher)
-npm run dev
+# 4. Start Automaker (production mode)
+npm run start
 # Choose between:
 #   1. Web Application (browser at localhost:3007)
 #   2. Desktop Application (Electron - recommended)
 ```
 
-**Note:** The `npm run dev` command will:
+**Note:** The `npm run start` command will:
 
 - Check for dependencies and install if needed
-- Install Playwright browsers for E2E tests
+- Build the application if needed
 - Kill any processes on ports 3007/3008
 - Present an interactive menu to choose your run mode
+- Run in production mode (no hot reload)
+
+**Authentication Setup:** On first run, Automaker will automatically show a setup wizard where you can configure authentication. You can choose to:
+
+- Use **Claude Code CLI** (recommended) - Automaker will detect your CLI credentials automatically
+- Enter an **API key** directly in the wizard
+
+If you prefer to set up authentication before running (e.g., for headless deployments or CI/CD), you can set it manually:
+
+```bash
+# Option A: Environment variable
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Option B: Create .env file in project root
+echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
+```
+
+**For Development:** If you want to develop on Automaker with Vite live reload and hot module replacement, use `npm run dev` instead. This will start the development server with fast refresh and instant updates as you make changes.
 
 ## How to Run
 

TODO.md

@@ -0,0 +1,17 @@
+# Bugs
+
+- Setting the default model does not seem like it works.
+
+# UX
+
+- Consolidate all models to a single place in the settings instead of having AI profiles and all this other stuff
+- Simplify the create feature modal. It should just be one page. I don't need nessa tabs and all these nested buttons. It's too complex.
+- added to do's list checkbox directly into the card so as it's going through if there's any to do items we can see those update live
+- When the feature is done, I want to see a summary of the LLM. That's the first thing I should see when I double click the card.
+- I went away to mass edit all my features. For example, when I created a new project, it added auto testing on every single feature card. Now I have to manually go through one by one and change those. Have a way to mass edit those, the configuration of all them.
+- Double check and debug if there's memory leaks. It seems like the memory of automaker grows like 3 gigabytes. It's 5gb right now and I'm running three different cursor cli features implementing at the same time.
+- Typing in the text area of the plan mode was super laggy.
+- When I have a bunch of features running at the same time, it seems like I cannot edit the features in the backlog. Like they don't persist their file changes and I think this is because of the secure FS file has an internal queue to prevent hitting that file open write limit. We may have to reconsider refactoring away from file system and do Postgres or SQLite or something.
+- modals are not scrollable if height of the screen is small enough
+- and the Agent Runner add an archival button for the new sessions.
+- investigate a potential issue with the feature cards not refreshing. I see a lock icon on the feature card But it doesn't go away until I open the card and edit it and I turn the testing mode off. I think there's like a refresh sync issue.

apps/server/src/index.ts

@@ -58,6 +58,8 @@ import { createMCPRoutes } from './routes/mcp/index.js';
 import { MCPTestService } from './services/mcp-test-service.js';
 import { createPipelineRoutes } from './routes/pipeline/index.js';
 import { pipelineService } from './services/pipeline-service.js';
+import { createIdeationRoutes } from './routes/ideation/index.js';
+import { IdeationService } from './services/ideation-service.js';
 
 // Load environment variables
 dotenv.config();
@@ -162,6 +164,7 @@ const featureLoader = new FeatureLoader();
 const autoModeService = new AutoModeService(events, settingsService);
 const claudeUsageService = new ClaudeUsageService();
 const mcpTestService = new MCPTestService(settingsService);
+const ideationService = new IdeationService(events, settingsService, featureLoader);
 
 // Initialize services
 (async () => {
@@ -215,6 +218,7 @@ app.use('/api/context', createContextRoutes(settingsService));
 app.use('/api/backlog-plan', createBacklogPlanRoutes(events, settingsService));
 app.use('/api/mcp', createMCPRoutes(mcpTestService));
 app.use('/api/pipeline', createPipelineRoutes(pipelineService));
+app.use('/api/ideation', createIdeationRoutes(events, ideationService, featureLoader));
 
 // Create HTTP server
 const server = createServer(app);

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

@@ -252,10 +252,14 @@ export function getModelForUseCase(
 
 /**
  * Base options that apply to all SDK calls
+ *
+ * AUTONOMOUS MODE: Always bypass permissions and allow dangerous operations
+ * for fully autonomous operation without user prompts.
  */
 function getBaseOptions(): Partial<Options> {
   return {
-    permissionMode: 'acceptEdits',
+    permissionMode: 'bypassPermissions',
+    allowDangerouslySkipPermissions: true,
   };
 }
 
@@ -276,31 +280,27 @@ interface McpPermissionOptions {
  * Centralizes the logic for determining permission modes and tool restrictions
  * when MCP servers are configured.
  *
+ * AUTONOMOUS MODE: Always bypass permissions for fully autonomous operation.
+ * Always allow unrestricted tools when MCP servers are configured.
+ *
  * @param config - The SDK options config
  * @returns Object with MCP permission settings to spread into final options
  */
 function buildMcpOptions(config: CreateSdkOptionsConfig): McpPermissionOptions {
   const hasMcpServers = config.mcpServers && Object.keys(config.mcpServers).length > 0;
-  // Default to true for autonomous workflow. Security is enforced when adding servers
-  // via the security warning dialog that explains the risks.
-  const mcpAutoApprove = config.mcpAutoApproveTools ?? true;
-  const mcpUnrestricted = config.mcpUnrestrictedTools ?? true;
 
-  // Determine if we should bypass permissions based on settings
-  const shouldBypassPermissions = hasMcpServers && mcpAutoApprove;
-  // Determine if we should restrict tools (only when no MCP or unrestricted is disabled)
-  const shouldRestrictTools = !hasMcpServers || !mcpUnrestricted;
+  // AUTONOMOUS MODE: Always bypass permissions and allow unrestricted tools
+  // Only restrict tools when no MCP servers are configured
+  const shouldRestrictTools = !hasMcpServers;
 
   return {
     shouldRestrictTools,
-    // Only include bypass options when MCP is configured and auto-approve is enabled
-    bypassOptions: shouldBypassPermissions
-      ? {
-          permissionMode: 'bypassPermissions' as const,
-          // Required flag when using bypassPermissions mode
-          allowDangerouslySkipPermissions: true,
-        }
-      : {},
+    // AUTONOMOUS MODE: Always include bypass options (though base options already set this)
+    bypassOptions: {
+      permissionMode: 'bypassPermissions' as const,
+      // Required flag when using bypassPermissions mode
+      allowDangerouslySkipPermissions: true,
+    },
     // Include MCP servers if configured
     mcpServerOptions: config.mcpServers ? { mcpServers: config.mcpServers } : {},
   };
@@ -392,12 +392,6 @@ export interface CreateSdkOptionsConfig {
 
   /** MCP servers to make available to the agent */
   mcpServers?: Record<string, McpServerConfig>;
-
-  /** Auto-approve MCP tool calls without permission prompts */
-  mcpAutoApproveTools?: boolean;
-
-  /** Allow unrestricted tools when MCP servers are enabled */
-  mcpUnrestrictedTools?: boolean;
 }
 
 // Re-export MCP types from @automaker/types for convenience
@@ -426,10 +420,7 @@ export function createSpecGenerationOptions(config: CreateSdkOptionsConfig): Opt
 
   return {
     ...getBaseOptions(),
-    // Override permissionMode - spec generation only needs read-only tools
-    // Using "acceptEdits" can cause Claude to write files to unexpected locations
-    // See: https://github.com/AutoMaker-Org/automaker/issues/149
-    permissionMode: 'default',
+    // AUTONOMOUS MODE: Base options already set bypassPermissions and allowDangerouslySkipPermissions
     model: getModelForUseCase('spec', config.model),
     maxTurns: MAX_TURNS.maximum,
     cwd: config.cwd,
@@ -458,8 +449,7 @@ export function createFeatureGenerationOptions(config: CreateSdkOptionsConfig):
 
   return {
     ...getBaseOptions(),
-    // Override permissionMode - feature generation only needs read-only tools
-    permissionMode: 'default',
+    // AUTONOMOUS MODE: Base options already set bypassPermissions and allowDangerouslySkipPermissions
     model: getModelForUseCase('features', config.model),
     maxTurns: MAX_TURNS.quick,
     cwd: config.cwd,

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

@@ -191,41 +191,6 @@ export async function getMCPServersFromSettings(
   }
 }
 
-/**
- * Get MCP permission settings from global settings.
- *
- * @param settingsService - Optional settings service instance
- * @param logPrefix - Prefix for log messages (e.g., '[AgentService]')
- * @returns Promise resolving to MCP permission settings
- */
-export async function getMCPPermissionSettings(
-  settingsService?: SettingsService | null,
-  logPrefix = '[SettingsHelper]'
-): Promise<{ mcpAutoApproveTools: boolean; mcpUnrestrictedTools: boolean }> {
-  // Default to true for autonomous workflow. Security is enforced when adding servers
-  // via the security warning dialog that explains the risks.
-  const defaults = { mcpAutoApproveTools: true, mcpUnrestrictedTools: true };
-
-  if (!settingsService) {
-    return defaults;
-  }
-
-  try {
-    const globalSettings = await settingsService.getGlobalSettings();
-    const result = {
-      mcpAutoApproveTools: globalSettings.mcpAutoApproveTools ?? true,
-      mcpUnrestrictedTools: globalSettings.mcpUnrestrictedTools ?? true,
-    };
-    logger.info(
-      `${logPrefix} MCP permission settings: autoApprove=${result.mcpAutoApproveTools}, unrestricted=${result.mcpUnrestrictedTools}`
-    );
-    return result;
-  } catch (error) {
-    logger.error(`${logPrefix} Failed to load MCP permission settings:`, error);
-    return defaults;
-  }
-}
-
 /**
  * Convert a settings MCPServerConfig to SDK McpServerConfig format.
  * Validates required fields and throws informative errors if missing.

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

@@ -63,20 +63,13 @@ export class ClaudeProvider extends BaseProvider {
     } = options;
 
     // Build Claude SDK options
-    // MCP permission logic - determines how to handle tool permissions when MCP servers are configured.
-    // This logic mirrors buildMcpOptions() in sdk-options.ts but is applied here since
-    // the provider is the final point where SDK options are constructed.
+    // AUTONOMOUS MODE: Always bypass permissions for fully autonomous operation
     const hasMcpServers = options.mcpServers && Object.keys(options.mcpServers).length > 0;
-    // Default to true for autonomous workflow. Security is enforced when adding servers
-    // via the security warning dialog that explains the risks.
-    const mcpAutoApprove = options.mcpAutoApproveTools ?? true;
-    const mcpUnrestricted = options.mcpUnrestrictedTools ?? true;
     const defaultTools = ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch'];
 
-    // Determine permission mode based on settings
-    const shouldBypassPermissions = hasMcpServers && mcpAutoApprove;
-    // Determine if we should restrict tools (only when no MCP or unrestricted is disabled)
-    const shouldRestrictTools = !hasMcpServers || !mcpUnrestricted;
+    // AUTONOMOUS MODE: Always bypass permissions and allow unrestricted tools
+    // Only restrict tools when no MCP servers are configured
+    const shouldRestrictTools = !hasMcpServers;
 
     const sdkOptions: Options = {
       model,
@@ -88,10 +81,9 @@ export class ClaudeProvider extends BaseProvider {
       // Only restrict tools if explicitly set OR (no MCP / unrestricted disabled)
       ...(allowedTools && shouldRestrictTools && { allowedTools }),
       ...(!allowedTools && shouldRestrictTools && { allowedTools: defaultTools }),
-      // When MCP servers are configured and auto-approve is enabled, use bypassPermissions
-      permissionMode: shouldBypassPermissions ? 'bypassPermissions' : 'default',
-      // Required when using bypassPermissions mode
-      ...(shouldBypassPermissions && { allowDangerouslySkipPermissions: true }),
+      // AUTONOMOUS MODE: Always bypass permissions and allow dangerous operations
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
       abortController,
       // Resume existing SDK session if we have a session ID
       ...(sdkSessionId && conversationHistory && conversationHistory.length > 0

apps/server/src/routes/features/routes/generate-title.ts

@@ -96,7 +96,7 @@ export function createGenerateTitleHandler(): (req: Request, res: Response) => P
           systemPrompt: SYSTEM_PROMPT,
           maxTurns: 1,
           allowedTools: [],
-          permissionMode: 'acceptEdits',
+          permissionMode: 'default',
         },
       });
 

apps/server/src/routes/ideation/common.ts

@@ -0,0 +1,12 @@
+/**
+ * Common utilities for ideation routes
+ */
+
+import { createLogger } from '@automaker/utils';
+import { getErrorMessage as getErrorMessageShared, createLogError } from '../common.js';
+
+const logger = createLogger('Ideation');
+
+// Re-export shared utilities
+export { getErrorMessageShared as getErrorMessage };
+export const logError = createLogError(logger);

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

@@ -0,0 +1,109 @@
+/**
+ * Ideation routes - HTTP API for brainstorming and idea management
+ */
+
+import { Router } from 'express';
+import type { EventEmitter } from '../../lib/events.js';
+import { validatePathParams } from '../../middleware/validate-paths.js';
+import type { IdeationService } from '../../services/ideation-service.js';
+import type { FeatureLoader } from '../../services/feature-loader.js';
+
+// Route handlers
+import { createSessionStartHandler } from './routes/session-start.js';
+import { createSessionMessageHandler } from './routes/session-message.js';
+import { createSessionStopHandler } from './routes/session-stop.js';
+import { createSessionGetHandler } from './routes/session-get.js';
+import { createIdeasListHandler } from './routes/ideas-list.js';
+import { createIdeasCreateHandler } from './routes/ideas-create.js';
+import { createIdeasGetHandler } from './routes/ideas-get.js';
+import { createIdeasUpdateHandler } from './routes/ideas-update.js';
+import { createIdeasDeleteHandler } from './routes/ideas-delete.js';
+import { createAnalyzeHandler, createGetAnalysisHandler } from './routes/analyze.js';
+import { createConvertHandler } from './routes/convert.js';
+import { createAddSuggestionHandler } from './routes/add-suggestion.js';
+import { createPromptsHandler, createPromptsByCategoryHandler } from './routes/prompts.js';
+import { createSuggestionsGenerateHandler } from './routes/suggestions-generate.js';
+
+export function createIdeationRoutes(
+  events: EventEmitter,
+  ideationService: IdeationService,
+  featureLoader: FeatureLoader
+): Router {
+  const router = Router();
+
+  // Session management
+  router.post(
+    '/session/start',
+    validatePathParams('projectPath'),
+    createSessionStartHandler(ideationService)
+  );
+  router.post('/session/message', createSessionMessageHandler(ideationService));
+  router.post('/session/stop', createSessionStopHandler(events, ideationService));
+  router.post(
+    '/session/get',
+    validatePathParams('projectPath'),
+    createSessionGetHandler(ideationService)
+  );
+
+  // Ideas CRUD
+  router.post(
+    '/ideas/list',
+    validatePathParams('projectPath'),
+    createIdeasListHandler(ideationService)
+  );
+  router.post(
+    '/ideas/create',
+    validatePathParams('projectPath'),
+    createIdeasCreateHandler(events, ideationService)
+  );
+  router.post(
+    '/ideas/get',
+    validatePathParams('projectPath'),
+    createIdeasGetHandler(ideationService)
+  );
+  router.post(
+    '/ideas/update',
+    validatePathParams('projectPath'),
+    createIdeasUpdateHandler(events, ideationService)
+  );
+  router.post(
+    '/ideas/delete',
+    validatePathParams('projectPath'),
+    createIdeasDeleteHandler(events, ideationService)
+  );
+
+  // Project analysis
+  router.post('/analyze', validatePathParams('projectPath'), createAnalyzeHandler(ideationService));
+  router.post(
+    '/analysis',
+    validatePathParams('projectPath'),
+    createGetAnalysisHandler(ideationService)
+  );
+
+  // Convert to feature
+  router.post(
+    '/convert',
+    validatePathParams('projectPath'),
+    createConvertHandler(events, ideationService, featureLoader)
+  );
+
+  // Add suggestion to board as a feature
+  router.post(
+    '/add-suggestion',
+    validatePathParams('projectPath'),
+    createAddSuggestionHandler(ideationService, featureLoader)
+  );
+
+  // Guided prompts (no validation needed - static data)
+  router.get('/prompts', createPromptsHandler(ideationService));
+  router.get('/prompts/:category', createPromptsByCategoryHandler(ideationService));
+
+  // Generate suggestions (structured output)
+  router.post(
+    '/suggestions/generate',
+    validatePathParams('projectPath'),
+    createSuggestionsGenerateHandler(ideationService)
+  );
+
+  return router;
+}

apps/server/src/routes/ideation/routes/add-suggestion.ts

@@ -0,0 +1,70 @@
+/**
+ * POST /add-suggestion - Add an analysis suggestion to the board as a feature
+ *
+ * This endpoint converts an AnalysisSuggestion to a Feature using the
+ * IdeationService's mapIdeaCategoryToFeatureCategory for consistent category mapping.
+ * This ensures a single source of truth for the conversion logic.
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { FeatureLoader } from '../../../services/feature-loader.js';
+import type { AnalysisSuggestion } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createAddSuggestionHandler(
+  ideationService: IdeationService,
+  featureLoader: FeatureLoader
+) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, suggestion } = req.body as {
+        projectPath: string;
+        suggestion: AnalysisSuggestion;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!suggestion) {
+        res.status(400).json({ success: false, error: 'suggestion is required' });
+        return;
+      }
+
+      if (!suggestion.title) {
+        res.status(400).json({ success: false, error: 'suggestion.title is required' });
+        return;
+      }
+
+      if (!suggestion.category) {
+        res.status(400).json({ success: false, error: 'suggestion.category is required' });
+        return;
+      }
+
+      // Build description with rationale if provided
+      const description = suggestion.rationale
+        ? `${suggestion.description}\n\n**Rationale:** ${suggestion.rationale}`
+        : suggestion.description;
+
+      // Use the service's category mapping for consistency
+      const featureCategory = ideationService.mapSuggestionCategoryToFeatureCategory(
+        suggestion.category
+      );
+
+      // Create the feature
+      const feature = await featureLoader.create(projectPath, {
+        title: suggestion.title,
+        description,
+        category: featureCategory,
+        status: 'backlog',
+      });
+
+      res.json({ success: true, featureId: feature.id });
+    } catch (error) {
+      logError(error, 'Add suggestion to board failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/analyze.ts

@@ -0,0 +1,49 @@
+/**
+ * POST /analyze - Analyze project and generate suggestions
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createAnalyzeHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      // Start analysis - results come via WebSocket events
+      ideationService.analyzeProject(projectPath).catch((error) => {
+        logError(error, 'Analyze project failed (async)');
+      });
+
+      res.json({ success: true, message: 'Analysis started' });
+    } catch (error) {
+      logError(error, 'Analyze project failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}
+
+export function createGetAnalysisHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      const result = await ideationService.getCachedAnalysis(projectPath);
+      res.json({ success: true, result });
+    } catch (error) {
+      logError(error, 'Get analysis failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/convert.ts

@@ -0,0 +1,77 @@
+/**
+ * POST /convert - Convert an idea to a feature
+ */
+
+import type { Request, Response } from 'express';
+import type { EventEmitter } from '../../../lib/events.js';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { FeatureLoader } from '../../../services/feature-loader.js';
+import type { ConvertToFeatureOptions } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createConvertHandler(
+  events: EventEmitter,
+  ideationService: IdeationService,
+  featureLoader: FeatureLoader
+) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, ideaId, keepIdea, column, dependencies, tags } = req.body as {
+        projectPath: string;
+        ideaId: string;
+      } & ConvertToFeatureOptions;
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!ideaId) {
+        res.status(400).json({ success: false, error: 'ideaId is required' });
+        return;
+      }
+
+      // Convert idea to feature structure
+      const featureData = await ideationService.convertToFeature(projectPath, ideaId);
+
+      // Apply any options from the request
+      if (column) {
+        featureData.status = column;
+      }
+      if (dependencies && dependencies.length > 0) {
+        featureData.dependencies = dependencies;
+      }
+      if (tags && tags.length > 0) {
+        featureData.tags = tags;
+      }
+
+      // Create the feature using FeatureLoader
+      const feature = await featureLoader.create(projectPath, featureData);
+
+      // Delete the idea unless keepIdea is explicitly true
+      if (!keepIdea) {
+        await ideationService.deleteIdea(projectPath, ideaId);
+
+        // Emit idea deleted event
+        events.emit('ideation:idea-deleted', {
+          projectPath,
+          ideaId,
+        });
+      }
+
+      // Emit idea converted event to notify frontend
+      events.emit('ideation:idea-converted', {
+        projectPath,
+        ideaId,
+        featureId: feature.id,
+        keepIdea: !!keepIdea,
+      });
+
+      // Return featureId as expected by the frontend API interface
+      res.json({ success: true, featureId: feature.id });
+    } catch (error) {
+      logError(error, 'Convert to feature failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/ideas-create.ts

@@ -0,0 +1,51 @@
+/**
+ * POST /ideas/create - Create a new idea
+ */
+
+import type { Request, Response } from 'express';
+import type { EventEmitter } from '../../../lib/events.js';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { CreateIdeaInput } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createIdeasCreateHandler(events: EventEmitter, ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, idea } = req.body as {
+        projectPath: string;
+        idea: CreateIdeaInput;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!idea) {
+        res.status(400).json({ success: false, error: 'idea is required' });
+        return;
+      }
+
+      if (!idea.title || !idea.description || !idea.category) {
+        res.status(400).json({
+          success: false,
+          error: 'idea must have title, description, and category',
+        });
+        return;
+      }
+
+      const created = await ideationService.createIdea(projectPath, idea);
+
+      // Emit idea created event for frontend notification
+      events.emit('ideation:idea-created', {
+        projectPath,
+        idea: created,
+      });
+
+      res.json({ success: true, idea: created });
+    } catch (error) {
+      logError(error, 'Create idea failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/ideas-delete.ts

@@ -0,0 +1,42 @@
+/**
+ * POST /ideas/delete - Delete an idea
+ */
+
+import type { Request, Response } from 'express';
+import type { EventEmitter } from '../../../lib/events.js';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createIdeasDeleteHandler(events: EventEmitter, ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, ideaId } = req.body as {
+        projectPath: string;
+        ideaId: string;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!ideaId) {
+        res.status(400).json({ success: false, error: 'ideaId is required' });
+        return;
+      }
+
+      await ideationService.deleteIdea(projectPath, ideaId);
+
+      // Emit idea deleted event for frontend notification
+      events.emit('ideation:idea-deleted', {
+        projectPath,
+        ideaId,
+      });
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, 'Delete idea failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/ideas-get.ts

@@ -0,0 +1,39 @@
+/**
+ * POST /ideas/get - Get a single idea
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createIdeasGetHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, ideaId } = req.body as {
+        projectPath: string;
+        ideaId: string;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!ideaId) {
+        res.status(400).json({ success: false, error: 'ideaId is required' });
+        return;
+      }
+
+      const idea = await ideationService.getIdea(projectPath, ideaId);
+      if (!idea) {
+        res.status(404).json({ success: false, error: 'Idea not found' });
+        return;
+      }
+
+      res.json({ success: true, idea });
+    } catch (error) {
+      logError(error, 'Get idea failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/ideas-list.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /ideas/list - List all ideas for a project
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createIdeasListHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      const ideas = await ideationService.getIdeas(projectPath);
+      res.json({ success: true, ideas });
+    } catch (error) {
+      logError(error, 'List ideas failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/ideas-update.ts

@@ -0,0 +1,54 @@
+/**
+ * POST /ideas/update - Update an idea
+ */
+
+import type { Request, Response } from 'express';
+import type { EventEmitter } from '../../../lib/events.js';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { UpdateIdeaInput } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createIdeasUpdateHandler(events: EventEmitter, ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, ideaId, updates } = req.body as {
+        projectPath: string;
+        ideaId: string;
+        updates: UpdateIdeaInput;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!ideaId) {
+        res.status(400).json({ success: false, error: 'ideaId is required' });
+        return;
+      }
+
+      if (!updates) {
+        res.status(400).json({ success: false, error: 'updates is required' });
+        return;
+      }
+
+      const idea = await ideationService.updateIdea(projectPath, ideaId, updates);
+      if (!idea) {
+        res.status(404).json({ success: false, error: 'Idea not found' });
+        return;
+      }
+
+      // Emit idea updated event for frontend notification
+      events.emit('ideation:idea-updated', {
+        projectPath,
+        ideaId,
+        idea,
+      });
+
+      res.json({ success: true, idea });
+    } catch (error) {
+      logError(error, 'Update idea failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/prompts.ts

@@ -0,0 +1,42 @@
+/**
+ * GET /prompts - Get all guided prompts
+ * GET /prompts/:category - Get prompts for a specific category
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { IdeaCategory } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createPromptsHandler(ideationService: IdeationService) {
+  return async (_req: Request, res: Response): Promise<void> => {
+    try {
+      const prompts = ideationService.getAllPrompts();
+      const categories = ideationService.getPromptCategories();
+      res.json({ success: true, prompts, categories });
+    } catch (error) {
+      logError(error, 'Get prompts failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}
+
+export function createPromptsByCategoryHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { category } = req.params as { category: string };
+
+      const validCategories = ideationService.getPromptCategories().map((c) => c.id);
+      if (!validCategories.includes(category as IdeaCategory)) {
+        res.status(400).json({ success: false, error: 'Invalid category' });
+        return;
+      }
+
+      const prompts = ideationService.getPromptsByCategory(category as IdeaCategory);
+      res.json({ success: true, prompts });
+    } catch (error) {
+      logError(error, 'Get prompts by category failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/session-get.ts

@@ -0,0 +1,45 @@
+/**
+ * POST /session/get - Get an ideation session with messages
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createSessionGetHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, sessionId } = req.body as {
+        projectPath: string;
+        sessionId: string;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!sessionId) {
+        res.status(400).json({ success: false, error: 'sessionId is required' });
+        return;
+      }
+
+      const session = await ideationService.getSession(projectPath, sessionId);
+      if (!session) {
+        res.status(404).json({ success: false, error: 'Session not found' });
+        return;
+      }
+
+      const isRunning = ideationService.isSessionRunning(sessionId);
+
+      res.json({
+        success: true,
+        session: { ...session, isRunning },
+        messages: session.messages,
+      });
+    } catch (error) {
+      logError(error, 'Get session failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/session-message.ts

@@ -0,0 +1,40 @@
+/**
+ * POST /session/message - Send a message in an ideation session
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { SendMessageOptions } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createSessionMessageHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId, message, options } = req.body as {
+        sessionId: string;
+        message: string;
+        options?: SendMessageOptions;
+      };
+
+      if (!sessionId) {
+        res.status(400).json({ success: false, error: 'sessionId is required' });
+        return;
+      }
+
+      if (!message) {
+        res.status(400).json({ success: false, error: 'message is required' });
+        return;
+      }
+
+      // This is async but we don't await - responses come via WebSocket
+      ideationService.sendMessage(sessionId, message, options).catch((error) => {
+        logError(error, 'Send message failed (async)');
+      });
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, 'Send message failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/session-start.ts

@@ -0,0 +1,30 @@
+/**
+ * POST /session/start - Start a new ideation session
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import type { StartSessionOptions } from '@automaker/types';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createSessionStartHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, options } = req.body as {
+        projectPath: string;
+        options?: StartSessionOptions;
+      };
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      const session = await ideationService.startSession(projectPath, options);
+      res.json({ success: true, session });
+    } catch (error) {
+      logError(error, 'Start session failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/session-stop.ts

@@ -0,0 +1,39 @@
+/**
+ * POST /session/stop - Stop an ideation session
+ */
+
+import type { Request, Response } from 'express';
+import type { EventEmitter } from '../../../lib/events.js';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { getErrorMessage, logError } from '../common.js';
+
+export function createSessionStopHandler(events: EventEmitter, ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId, projectPath } = req.body as {
+        sessionId: string;
+        projectPath?: string;
+      };
+
+      if (!sessionId) {
+        res.status(400).json({ success: false, error: 'sessionId is required' });
+        return;
+      }
+
+      await ideationService.stopSession(sessionId);
+
+      // Emit session stopped event for frontend notification
+      // Note: The service also emits 'ideation:session-ended' internally,
+      // but we emit here as well for route-level consistency with other routes
+      events.emit('ideation:session-ended', {
+        sessionId,
+        projectPath,
+      });
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, 'Stop session failed');
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/ideation/routes/suggestions-generate.ts

@@ -0,0 +1,56 @@
+/**
+ * Generate suggestions route - Returns structured AI suggestions for a prompt
+ */
+
+import type { Request, Response } from 'express';
+import type { IdeationService } from '../../../services/ideation-service.js';
+import { createLogger } from '@automaker/utils';
+import { getErrorMessage, logError } from '../common.js';
+
+const logger = createLogger('ideation:suggestions-generate');
+
+export function createSuggestionsGenerateHandler(ideationService: IdeationService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, promptId, category, count } = req.body;
+
+      if (!projectPath) {
+        res.status(400).json({ success: false, error: 'projectPath is required' });
+        return;
+      }
+
+      if (!promptId) {
+        res.status(400).json({ success: false, error: 'promptId is required' });
+        return;
+      }
+
+      if (!category) {
+        res.status(400).json({ success: false, error: 'category is required' });
+        return;
+      }
+
+      // Default to 10 suggestions, allow 1-20
+      const suggestionCount = Math.min(Math.max(count || 10, 1), 20);
+
+      logger.info(`Generating ${suggestionCount} suggestions for prompt: ${promptId}`);
+
+      const suggestions = await ideationService.generateSuggestions(
+        projectPath,
+        promptId,
+        category,
+        suggestionCount
+      );
+
+      res.json({
+        success: true,
+        suggestions,
+      });
+    } catch (error) {
+      logError(error, 'Failed to generate suggestions');
+      res.status(500).json({
+        success: false,
+        error: getErrorMessage(error),
+      });
+    }
+  };
+}

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

@@ -23,7 +23,6 @@ import {
   getEnableSandboxModeSetting,
   filterClaudeMdFromContext,
   getMCPServersFromSettings,
-  getMCPPermissionSettings,
   getPromptCustomization,
 } from '../lib/settings-helpers.js';
 
@@ -235,9 +234,6 @@ export class AgentService {
       // Load MCP servers from settings (global setting only)
       const mcpServers = await getMCPServersFromSettings(this.settingsService, '[AgentService]');
 
-      // Load MCP permission settings (global setting only)
-      const mcpPermissions = await getMCPPermissionSettings(this.settingsService, '[AgentService]');
-
       // Load project context files (CLAUDE.md, CODE_QUALITY.md, etc.)
       const contextResult = await loadContextFiles({
         projectPath: effectiveWorkDir,
@@ -264,8 +260,6 @@ export class AgentService {
         autoLoadClaudeMd,
         enableSandboxMode,
         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
-        mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools,
-        mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools,
       });
 
       // Extract model, maxTurns, and allowedTools from SDK options
@@ -290,8 +284,6 @@ export class AgentService {
         sandbox: sdkOptions.sandbox, // Pass sandbox configuration
         sdkSessionId: session.sdkSessionId, // Pass SDK session ID for resuming
         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined, // Pass MCP servers configuration
-        mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools, // Pass MCP auto-approve setting
-        mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools, // Pass MCP unrestricted tools setting
       };
 
       // Build prompt content with images

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

@@ -38,7 +38,6 @@ import {
   getEnableSandboxModeSetting,
   filterClaudeMdFromContext,
   getMCPServersFromSettings,
-  getMCPPermissionSettings,
   getPromptCustomization,
 } from '../lib/settings-helpers.js';
 
@@ -2003,9 +2002,6 @@ This mock response was generated because AUTOMAKER_MOCK_AGENT=true was set.
     // Load MCP servers from settings (global setting only)
     const mcpServers = await getMCPServersFromSettings(this.settingsService, '[AutoMode]');
 
-    // Load MCP permission settings (global setting only)
-    const mcpPermissions = await getMCPPermissionSettings(this.settingsService, '[AutoMode]');
-
     // Build SDK options using centralized configuration for feature implementation
     const sdkOptions = createAutoModeOptions({
       cwd: workDir,
@@ -2014,8 +2010,6 @@ This mock response was generated because AUTOMAKER_MOCK_AGENT=true was set.
       autoLoadClaudeMd,
       enableSandboxMode,
       mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
-      mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools,
-      mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools,
     });
 
     // Extract model, maxTurns, and allowedTools from SDK options
@@ -2058,8 +2052,6 @@ This mock response was generated because AUTOMAKER_MOCK_AGENT=true was set.
       settingSources: sdkOptions.settingSources,
       sandbox: sdkOptions.sandbox, // Pass sandbox configuration
       mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined, // Pass MCP servers configuration
-      mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools, // Pass MCP auto-approve setting
-      mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools, // Pass MCP unrestricted tools setting
     };
 
     // Execute via provider
@@ -2291,8 +2283,6 @@ After generating the revised spec, output:
                         allowedTools: allowedTools,
                         abortController,
                         mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
-                        mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools,
-                        mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools,
                       });
 
                       let revisionText = '';
@@ -2431,8 +2421,6 @@ After generating the revised spec, output:
                     allowedTools: allowedTools,
                     abortController,
                     mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
-                    mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools,
-                    mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools,
                   });
 
                   let taskOutput = '';
@@ -2523,8 +2511,6 @@ Implement all the changes described in the plan above.`;
                   allowedTools: allowedTools,
                   abortController,
                   mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,
-                  mcpAutoApproveTools: mcpPermissions.mcpAutoApproveTools,
-                  mcpUnrestrictedTools: mcpPermissions.mcpUnrestrictedTools,
                 });
 
                 for await (const msg of continuationStream) {

apps/server/tests/unit/lib/sdk-options.test.ts

@@ -234,7 +234,7 @@ describe('sdk-options.ts', () => {
       expect(options.cwd).toBe('/test/path');
       expect(options.maxTurns).toBe(MAX_TURNS.maximum);
       expect(options.allowedTools).toEqual([...TOOL_PRESETS.specGeneration]);
-      expect(options.permissionMode).toBe('default');
+      expect(options.permissionMode).toBe('bypassPermissions');
     });
 
     it('should include system prompt when provided', async () => {

apps/server/tests/unit/lib/settings-helpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getMCPServersFromSettings, getMCPPermissionSettings } from '@/lib/settings-helpers.js';
+import { getMCPServersFromSettings } from '@/lib/settings-helpers.js';
 import type { SettingsService } from '@/services/settings-service.js';
 
 // Mock the logger
@@ -286,93 +286,4 @@ describe('settings-helpers.ts', () => {
       });
     });
   });
-
-  describe('getMCPPermissionSettings', () => {
-    beforeEach(() => {
-      vi.clearAllMocks();
-    });
-
-    it('should return defaults when settingsService is null', async () => {
-      const result = await getMCPPermissionSettings(null);
-      expect(result).toEqual({
-        mcpAutoApproveTools: true,
-        mcpUnrestrictedTools: true,
-      });
-    });
-
-    it('should return defaults when settingsService is undefined', async () => {
-      const result = await getMCPPermissionSettings(undefined);
-      expect(result).toEqual({
-        mcpAutoApproveTools: true,
-        mcpUnrestrictedTools: true,
-      });
-    });
-
-    it('should return settings from service', async () => {
-      const mockSettingsService = {
-        getGlobalSettings: vi.fn().mockResolvedValue({
-          mcpAutoApproveTools: false,
-          mcpUnrestrictedTools: false,
-        }),
-      } as unknown as SettingsService;
-
-      const result = await getMCPPermissionSettings(mockSettingsService);
-      expect(result).toEqual({
-        mcpAutoApproveTools: false,
-        mcpUnrestrictedTools: false,
-      });
-    });
-
-    it('should default to true when settings are undefined', async () => {
-      const mockSettingsService = {
-        getGlobalSettings: vi.fn().mockResolvedValue({}),
-      } as unknown as SettingsService;
-
-      const result = await getMCPPermissionSettings(mockSettingsService);
-      expect(result).toEqual({
-        mcpAutoApproveTools: true,
-        mcpUnrestrictedTools: true,
-      });
-    });
-
-    it('should handle mixed settings', async () => {
-      const mockSettingsService = {
-        getGlobalSettings: vi.fn().mockResolvedValue({
-          mcpAutoApproveTools: true,
-          mcpUnrestrictedTools: false,
-        }),
-      } as unknown as SettingsService;
-
-      const result = await getMCPPermissionSettings(mockSettingsService);
-      expect(result).toEqual({
-        mcpAutoApproveTools: true,
-        mcpUnrestrictedTools: false,
-      });
-    });
-
-    it('should return defaults and log error on exception', async () => {
-      const mockSettingsService = {
-        getGlobalSettings: vi.fn().mockRejectedValue(new Error('Settings error')),
-      } as unknown as SettingsService;
-
-      const result = await getMCPPermissionSettings(mockSettingsService, '[Test]');
-      expect(result).toEqual({
-        mcpAutoApproveTools: true,
-        mcpUnrestrictedTools: true,
-      });
-      // Logger will be called with error, but we don't need to assert it
-    });
-
-    it('should use custom log prefix', async () => {
-      const mockSettingsService = {
-        getGlobalSettings: vi.fn().mockResolvedValue({
-          mcpAutoApproveTools: true,
-          mcpUnrestrictedTools: true,
-        }),
-      } as unknown as SettingsService;
-
-      await getMCPPermissionSettings(mockSettingsService, '[CustomPrefix]');
-      // Logger will be called with custom prefix, but we don't need to assert it
-    });
-  });
 });

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

@@ -73,7 +73,8 @@ describe('claude-provider.ts', () => {
           maxTurns: 10,
           cwd: '/test/dir',
           allowedTools: ['Read', 'Write'],
-          permissionMode: 'default',
+          permissionMode: 'bypassPermissions',
+          allowDangerouslySkipPermissions: true,
         }),
       });
     });

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

@@ -0,0 +1,788 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { IdeationService } from '@/services/ideation-service.js';
+import type { EventEmitter } from '@/lib/events.js';
+import type { SettingsService } from '@/services/settings-service.js';
+import type { FeatureLoader } from '@/services/feature-loader.js';
+import * as secureFs from '@/lib/secure-fs.js';
+import * as platform from '@automaker/platform';
+import * as utils from '@automaker/utils';
+import type {
+  CreateIdeaInput,
+  UpdateIdeaInput,
+  Idea,
+  IdeationSession,
+  StartSessionOptions,
+} from '@automaker/types';
+import { ProviderFactory } from '@/providers/provider-factory.js';
+
+// Create a shared mock logger instance for assertions using vi.hoisted
+const mockLogger = vi.hoisted(() => ({
+  info: vi.fn(),
+  error: vi.fn(),
+  warn: vi.fn(),
+  debug: vi.fn(),
+}));
+
+// Mock dependencies
+vi.mock('@/lib/secure-fs.js');
+vi.mock('@automaker/platform');
+vi.mock('@automaker/utils', async () => {
+  const actual = await vi.importActual<typeof import('@automaker/utils')>('@automaker/utils');
+  return {
+    ...actual,
+    createLogger: vi.fn(() => mockLogger),
+    loadContextFiles: vi.fn(),
+    isAbortError: vi.fn(),
+  };
+});
+vi.mock('@/providers/provider-factory.js');
+vi.mock('@/lib/sdk-options.js', () => ({
+  createChatOptions: vi.fn(() => ({
+    model: 'claude-sonnet-4-20250514',
+    systemPrompt: 'test prompt',
+  })),
+  validateWorkingDirectory: vi.fn(),
+}));
+
+describe('IdeationService', () => {
+  let service: IdeationService;
+  let mockEvents: EventEmitter;
+  let mockSettingsService: SettingsService;
+  let mockFeatureLoader: FeatureLoader;
+  const testProjectPath = '/test/project';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Create mock event emitter
+    mockEvents = {
+      emit: vi.fn(),
+      on: vi.fn(),
+      off: vi.fn(),
+      removeAllListeners: vi.fn(),
+    } as unknown as EventEmitter;
+
+    // Create mock settings service
+    mockSettingsService = {} as SettingsService;
+
+    // Create mock feature loader
+    mockFeatureLoader = {
+      getAll: vi.fn().mockResolvedValue([]),
+    } as unknown as FeatureLoader;
+
+    // Mock platform functions
+    vi.mocked(platform.ensureIdeationDir).mockResolvedValue(undefined);
+    vi.mocked(platform.getIdeaDir).mockReturnValue(
+      '/test/project/.automaker/ideation/ideas/idea-123'
+    );
+    vi.mocked(platform.getIdeaPath).mockReturnValue(
+      '/test/project/.automaker/ideation/ideas/idea-123/idea.json'
+    );
+    vi.mocked(platform.getIdeasDir).mockReturnValue('/test/project/.automaker/ideation/ideas');
+    vi.mocked(platform.getIdeationSessionPath).mockReturnValue(
+      '/test/project/.automaker/ideation/sessions/session-123.json'
+    );
+    vi.mocked(platform.getIdeationSessionsDir).mockReturnValue(
+      '/test/project/.automaker/ideation/sessions'
+    );
+    vi.mocked(platform.getIdeationAnalysisPath).mockReturnValue(
+      '/test/project/.automaker/ideation/analysis.json'
+    );
+
+    // Mock utils (already mocked above, but reset return values)
+    vi.mocked(utils.loadContextFiles).mockResolvedValue({
+      formattedPrompt: 'Test context',
+      files: [],
+    });
+    vi.mocked(utils.isAbortError).mockReturnValue(false);
+
+    service = new IdeationService(mockEvents, mockSettingsService, mockFeatureLoader);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // ============================================================================
+  // Session Management Tests
+  // ============================================================================
+
+  describe('Session Management', () => {
+    describe('startSession', () => {
+      it('should create a new session with default options', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const session = await service.startSession(testProjectPath);
+
+        expect(session).toBeDefined();
+        expect(session.id).toMatch(/^session-/);
+        expect(session.projectPath).toBe(testProjectPath);
+        expect(session.status).toBe('active');
+        expect(session.createdAt).toBeDefined();
+        expect(session.updatedAt).toBeDefined();
+        expect(platform.ensureIdeationDir).toHaveBeenCalledWith(testProjectPath);
+        expect(secureFs.writeFile).toHaveBeenCalled();
+        expect(mockEvents.emit).toHaveBeenCalledWith('ideation:session-started', {
+          sessionId: session.id,
+          projectPath: testProjectPath,
+        });
+      });
+
+      it('should create session with custom options', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const options: StartSessionOptions = {
+          promptCategory: 'features',
+          promptId: 'new-features',
+        };
+
+        const session = await service.startSession(testProjectPath, options);
+
+        expect(session.promptCategory).toBe('features');
+        expect(session.promptId).toBe('new-features');
+      });
+
+      it('should send initial message if provided in options', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify({ features: [] }));
+
+        // Mock provider
+        const mockProvider = {
+          executeQuery: vi.fn().mockReturnValue({
+            async *[Symbol.asyncIterator]() {
+              yield {
+                type: 'result',
+                subtype: 'success',
+                result: 'AI response',
+              };
+            },
+          }),
+        };
+        vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);
+
+        const options: StartSessionOptions = {
+          initialMessage: 'Hello, AI!',
+        };
+
+        await service.startSession(testProjectPath, options);
+
+        // Give time for the async message to process
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        expect(mockProvider.executeQuery).toHaveBeenCalled();
+      });
+    });
+
+    describe('getSession', () => {
+      it('should return null for non-existent session', async () => {
+        vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+        const result = await service.getSession(testProjectPath, 'non-existent');
+
+        expect(result).toBeNull();
+      });
+
+      it('should return active session from memory', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const session = await service.startSession(testProjectPath);
+        const retrieved = await service.getSession(testProjectPath, session.id);
+
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe(session.id);
+        expect(retrieved?.messages).toEqual([]);
+      });
+
+      it('should load session from disk if not in memory', async () => {
+        const mockSession: IdeationSession = {
+          id: 'session-123',
+          projectPath: testProjectPath,
+          status: 'active',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        const sessionData = {
+          session: mockSession,
+          messages: [],
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(sessionData));
+
+        const result = await service.getSession(testProjectPath, 'session-123');
+
+        expect(result).toBeDefined();
+        expect(result?.id).toBe('session-123');
+      });
+    });
+
+    describe('stopSession', () => {
+      it('should stop an active session', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const session = await service.startSession(testProjectPath);
+        await service.stopSession(session.id);
+
+        expect(mockEvents.emit).toHaveBeenCalledWith('ideation:session-ended', {
+          sessionId: session.id,
+        });
+      });
+
+      it('should handle stopping non-existent session gracefully', async () => {
+        await expect(service.stopSession('non-existent')).resolves.not.toThrow();
+      });
+    });
+
+    describe('isSessionRunning', () => {
+      it('should return false for non-existent session', () => {
+        expect(service.isSessionRunning('non-existent')).toBe(false);
+      });
+
+      it('should return false for idle session', async () => {
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const session = await service.startSession(testProjectPath);
+        expect(service.isSessionRunning(session.id)).toBe(false);
+      });
+    });
+  });
+
+  // ============================================================================
+  // Ideas CRUD Tests
+  // ============================================================================
+
+  describe('Ideas CRUD', () => {
+    describe('createIdea', () => {
+      it('should create a new idea with required fields', async () => {
+        vi.mocked(secureFs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const input: CreateIdeaInput = {
+          title: 'Test Idea',
+          description: 'This is a test idea',
+          category: 'features',
+        };
+
+        const idea = await service.createIdea(testProjectPath, input);
+
+        expect(idea).toBeDefined();
+        expect(idea.id).toMatch(/^idea-/);
+        expect(idea.title).toBe('Test Idea');
+        expect(idea.description).toBe('This is a test idea');
+        expect(idea.category).toBe('features');
+        expect(idea.status).toBe('raw');
+        expect(idea.impact).toBe('medium');
+        expect(idea.effort).toBe('medium');
+        expect(secureFs.mkdir).toHaveBeenCalled();
+        expect(secureFs.writeFile).toHaveBeenCalled();
+      });
+
+      it('should create idea with all optional fields', async () => {
+        vi.mocked(secureFs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const input: CreateIdeaInput = {
+          title: 'Full Idea',
+          description: 'Complete idea',
+          category: 'features',
+          status: 'refined',
+          impact: 'high',
+          effort: 'low',
+          conversationId: 'conv-123',
+          sourcePromptId: 'prompt-123',
+          userStories: ['Story 1', 'Story 2'],
+          notes: 'Additional notes',
+        };
+
+        const idea = await service.createIdea(testProjectPath, input);
+
+        expect(idea.status).toBe('refined');
+        expect(idea.impact).toBe('high');
+        expect(idea.effort).toBe('low');
+        expect(idea.conversationId).toBe('conv-123');
+        expect(idea.sourcePromptId).toBe('prompt-123');
+        expect(idea.userStories).toEqual(['Story 1', 'Story 2']);
+        expect(idea.notes).toBe('Additional notes');
+      });
+    });
+
+    describe('getIdeas', () => {
+      it('should return empty array when ideas directory does not exist', async () => {
+        vi.mocked(secureFs.access).mockRejectedValue(new Error('ENOENT'));
+
+        const ideas = await service.getIdeas(testProjectPath);
+
+        expect(ideas).toEqual([]);
+      });
+
+      it('should load all ideas from disk', async () => {
+        vi.mocked(secureFs.access).mockResolvedValue(undefined);
+        vi.mocked(secureFs.readdir).mockResolvedValue([
+          { name: 'idea-1', isDirectory: () => true } as any,
+          { name: 'idea-2', isDirectory: () => true } as any,
+        ]);
+
+        const idea1: Idea = {
+          id: 'idea-1',
+          title: 'Idea 1',
+          description: 'First idea',
+          category: 'features',
+          status: 'raw',
+          impact: 'medium',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        const idea2: Idea = {
+          id: 'idea-2',
+          title: 'Idea 2',
+          description: 'Second idea',
+          category: 'bugs',
+          status: 'refined',
+          impact: 'high',
+          effort: 'low',
+          createdAt: '2024-01-02T00:00:00.000Z',
+          updatedAt: '2024-01-02T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile)
+          .mockResolvedValueOnce(JSON.stringify(idea1))
+          .mockResolvedValueOnce(JSON.stringify(idea2));
+
+        const ideas = await service.getIdeas(testProjectPath);
+
+        expect(ideas).toHaveLength(2);
+        expect(ideas[0].id).toBe('idea-2'); // Sorted by updatedAt descending
+        expect(ideas[1].id).toBe('idea-1');
+      });
+
+      it('should skip invalid idea files', async () => {
+        vi.mocked(secureFs.access).mockResolvedValue(undefined);
+        vi.mocked(secureFs.readdir).mockResolvedValue([
+          { name: 'idea-1', isDirectory: () => true } as any,
+          { name: 'idea-2', isDirectory: () => true } as any,
+        ]);
+
+        const validIdea: Idea = {
+          id: 'idea-1',
+          title: 'Valid Idea',
+          description: 'Valid',
+          category: 'features',
+          status: 'raw',
+          impact: 'medium',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile)
+          .mockResolvedValueOnce(JSON.stringify(validIdea))
+          .mockRejectedValueOnce(new Error('Invalid JSON'));
+
+        const ideas = await service.getIdeas(testProjectPath);
+
+        expect(ideas).toHaveLength(1);
+        expect(ideas[0].id).toBe('idea-1');
+      });
+    });
+
+    describe('getIdea', () => {
+      it('should return idea by id', async () => {
+        const mockIdea: Idea = {
+          id: 'idea-123',
+          title: 'Test Idea',
+          description: 'Test',
+          category: 'features',
+          status: 'raw',
+          impact: 'medium',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(mockIdea));
+
+        const idea = await service.getIdea(testProjectPath, 'idea-123');
+
+        expect(idea).toBeDefined();
+        expect(idea?.id).toBe('idea-123');
+      });
+
+      it('should return null for non-existent idea', async () => {
+        vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+        const idea = await service.getIdea(testProjectPath, 'non-existent');
+
+        expect(idea).toBeNull();
+      });
+    });
+
+    describe('updateIdea', () => {
+      it('should update idea fields', async () => {
+        const existingIdea: Idea = {
+          id: 'idea-123',
+          title: 'Original Title',
+          description: 'Original',
+          category: 'features',
+          status: 'raw',
+          impact: 'medium',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(existingIdea));
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const updates: UpdateIdeaInput = {
+          title: 'Updated Title',
+          status: 'refined',
+        };
+
+        const updated = await service.updateIdea(testProjectPath, 'idea-123', updates);
+
+        expect(updated).toBeDefined();
+        expect(updated?.title).toBe('Updated Title');
+        expect(updated?.status).toBe('refined');
+        expect(updated?.description).toBe('Original'); // Unchanged
+        expect(updated?.updatedAt).not.toBe('2024-01-01T00:00:00.000Z'); // Should be updated
+      });
+
+      it('should return null for non-existent idea', async () => {
+        vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+        const updated = await service.updateIdea(testProjectPath, 'non-existent', {
+          title: 'New Title',
+        });
+
+        expect(updated).toBeNull();
+      });
+    });
+
+    describe('deleteIdea', () => {
+      it('should delete idea directory', async () => {
+        vi.mocked(secureFs.rm).mockResolvedValue(undefined);
+
+        await service.deleteIdea(testProjectPath, 'idea-123');
+
+        expect(secureFs.rm).toHaveBeenCalledWith(
+          expect.stringContaining('idea-123'),
+          expect.objectContaining({ recursive: true })
+        );
+      });
+
+      it('should handle non-existent idea gracefully', async () => {
+        vi.mocked(secureFs.rm).mockRejectedValue(new Error('ENOENT'));
+
+        await expect(service.deleteIdea(testProjectPath, 'non-existent')).resolves.not.toThrow();
+      });
+    });
+
+    describe('archiveIdea', () => {
+      it('should set idea status to archived', async () => {
+        const existingIdea: Idea = {
+          id: 'idea-123',
+          title: 'Test',
+          description: 'Test',
+          category: 'features',
+          status: 'raw',
+          impact: 'medium',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(existingIdea));
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+
+        const archived = await service.archiveIdea(testProjectPath, 'idea-123');
+
+        expect(archived).toBeDefined();
+        expect(archived?.status).toBe('archived');
+      });
+    });
+  });
+
+  // ============================================================================
+  // Conversion Tests
+  // ============================================================================
+
+  describe('Idea to Feature Conversion', () => {
+    describe('convertToFeature', () => {
+      it('should convert idea to feature with basic fields', async () => {
+        const mockIdea: Idea = {
+          id: 'idea-123',
+          title: 'Add Dark Mode',
+          description: 'Implement dark mode theme',
+          category: 'feature',
+          status: 'refined',
+          impact: 'high',
+          effort: 'medium',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(mockIdea));
+
+        const feature = await service.convertToFeature(testProjectPath, 'idea-123');
+
+        expect(feature).toBeDefined();
+        expect(feature.id).toMatch(/^feature-/);
+        expect(feature.title).toBe('Add Dark Mode');
+        expect(feature.description).toBe('Implement dark mode theme');
+        expect(feature.category).toBe('ui'); // features -> ui mapping
+        expect(feature.status).toBe('backlog');
+      });
+
+      it('should include user stories in feature description', async () => {
+        const mockIdea: Idea = {
+          id: 'idea-123',
+          title: 'Test',
+          description: 'Base description',
+          category: 'features',
+          status: 'refined',
+          impact: 'medium',
+          effort: 'medium',
+          userStories: ['As a user, I want X', 'As a user, I want Y'],
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(mockIdea));
+
+        const feature = await service.convertToFeature(testProjectPath, 'idea-123');
+
+        expect(feature.description).toContain('Base description');
+        expect(feature.description).toContain('## User Stories');
+        expect(feature.description).toContain('As a user, I want X');
+        expect(feature.description).toContain('As a user, I want Y');
+      });
+
+      it('should include notes in feature description', async () => {
+        const mockIdea: Idea = {
+          id: 'idea-123',
+          title: 'Test',
+          description: 'Base description',
+          category: 'features',
+          status: 'refined',
+          impact: 'medium',
+          effort: 'medium',
+          notes: 'Important implementation notes',
+          createdAt: '2024-01-01T00:00:00.000Z',
+          updatedAt: '2024-01-01T00:00:00.000Z',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(mockIdea));
+
+        const feature = await service.convertToFeature(testProjectPath, 'idea-123');
+
+        expect(feature.description).toContain('Base description');
+        expect(feature.description).toContain('## Notes');
+        expect(feature.description).toContain('Important implementation notes');
+      });
+
+      it('should throw error for non-existent idea', async () => {
+        vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+        await expect(service.convertToFeature(testProjectPath, 'non-existent')).rejects.toThrow(
+          'Idea non-existent not found'
+        );
+      });
+    });
+  });
+
+  // ============================================================================
+  // Project Analysis Tests
+  // ============================================================================
+
+  describe('Project Analysis', () => {
+    describe('analyzeProject', () => {
+      it('should analyze project and generate suggestions', async () => {
+        vi.mocked(secureFs.readFile).mockResolvedValue(
+          JSON.stringify({
+            name: 'test-project',
+            dependencies: {},
+          })
+        );
+        vi.mocked(secureFs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(secureFs.access).mockResolvedValue(undefined);
+        vi.mocked(secureFs.readdir).mockResolvedValue([]);
+
+        const result = await service.analyzeProject(testProjectPath);
+
+        expect(result).toBeDefined();
+        expect(result.projectPath).toBe(testProjectPath);
+        expect(result.analyzedAt).toBeDefined();
+        expect(result.suggestions).toBeDefined();
+        expect(Array.isArray(result.suggestions)).toBe(true);
+        expect(mockEvents.emit).toHaveBeenCalledWith(
+          'ideation:analysis',
+          expect.objectContaining({
+            type: 'ideation:analysis-started',
+          })
+        );
+        expect(mockEvents.emit).toHaveBeenCalledWith(
+          'ideation:analysis',
+          expect.objectContaining({
+            type: 'ideation:analysis-complete',
+          })
+        );
+      });
+
+      it('should emit error event on failure', async () => {
+        // Mock writeFile to fail (this is called after gatherProjectStructure and isn't caught)
+        vi.mocked(secureFs.readFile).mockResolvedValue(
+          JSON.stringify({
+            name: 'test-project',
+            dependencies: {},
+          })
+        );
+        vi.mocked(secureFs.writeFile).mockRejectedValue(new Error('Write failed'));
+
+        await expect(service.analyzeProject(testProjectPath)).rejects.toThrow();
+
+        expect(mockEvents.emit).toHaveBeenCalledWith(
+          'ideation:analysis',
+          expect.objectContaining({
+            type: 'ideation:analysis-error',
+          })
+        );
+      });
+    });
+
+    describe('getCachedAnalysis', () => {
+      it('should return cached analysis if exists', async () => {
+        const mockAnalysis = {
+          projectPath: testProjectPath,
+          analyzedAt: '2024-01-01T00:00:00.000Z',
+          totalFiles: 10,
+          suggestions: [],
+          summary: 'Test summary',
+        };
+
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify(mockAnalysis));
+
+        const result = await service.getCachedAnalysis(testProjectPath);
+
+        expect(result).toEqual(mockAnalysis);
+      });
+
+      it('should return null if cache does not exist', async () => {
+        vi.mocked(secureFs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+        const result = await service.getCachedAnalysis(testProjectPath);
+
+        expect(result).toBeNull();
+      });
+    });
+  });
+
+  // ============================================================================
+  // Prompt Management Tests
+  // ============================================================================
+
+  describe('Prompt Management', () => {
+    describe('getPromptCategories', () => {
+      it('should return list of prompt categories', () => {
+        const categories = service.getPromptCategories();
+
+        expect(Array.isArray(categories)).toBe(true);
+        expect(categories.length).toBeGreaterThan(0);
+        expect(categories[0]).toHaveProperty('id');
+        expect(categories[0]).toHaveProperty('name');
+      });
+    });
+
+    describe('getAllPrompts', () => {
+      it('should return all guided prompts', () => {
+        const prompts = service.getAllPrompts();
+
+        expect(Array.isArray(prompts)).toBe(true);
+        expect(prompts.length).toBeGreaterThan(0);
+        expect(prompts[0]).toHaveProperty('id');
+        expect(prompts[0]).toHaveProperty('category');
+        expect(prompts[0]).toHaveProperty('title');
+        expect(prompts[0]).toHaveProperty('prompt');
+      });
+    });
+
+    describe('getPromptsByCategory', () => {
+      it('should return prompts filtered by category', () => {
+        const allPrompts = service.getAllPrompts();
+        const firstCategory = allPrompts[0].category;
+
+        const filtered = service.getPromptsByCategory(firstCategory);
+
+        expect(Array.isArray(filtered)).toBe(true);
+        filtered.forEach((prompt) => {
+          expect(prompt.category).toBe(firstCategory);
+        });
+      });
+
+      it('should return empty array for non-existent category', () => {
+        const filtered = service.getPromptsByCategory('non-existent-category' as any);
+
+        expect(filtered).toEqual([]);
+      });
+    });
+  });
+
+  // ============================================================================
+  // Suggestions Generation Tests
+  // ============================================================================
+
+  describe('Suggestion Generation', () => {
+    describe('generateSuggestions', () => {
+      it('should generate suggestions for a prompt', async () => {
+        vi.mocked(secureFs.readFile).mockResolvedValue(JSON.stringify({}));
+
+        const mockProvider = {
+          executeQuery: vi.fn().mockReturnValue({
+            async *[Symbol.asyncIterator]() {
+              yield {
+                type: 'result',
+                subtype: 'success',
+                result: JSON.stringify([
+                  {
+                    title: 'Add user authentication',
+                    description: 'Implement auth',
+                    category: 'security',
+                    impact: 'high',
+                    effort: 'high',
+                  },
+                ]),
+              };
+            },
+          }),
+        };
+
+        vi.mocked(ProviderFactory.getProviderForModel).mockReturnValue(mockProvider as any);
+
+        const prompts = service.getAllPrompts();
+        const firstPrompt = prompts[0];
+
+        const suggestions = await service.generateSuggestions(
+          testProjectPath,
+          firstPrompt.id,
+          'features',
+          5
+        );
+
+        expect(Array.isArray(suggestions)).toBe(true);
+        expect(mockEvents.emit).toHaveBeenCalledWith(
+          'ideation:suggestions',
+          expect.objectContaining({
+            type: 'started',
+          })
+        );
+      });
+
+      it('should throw error for non-existent prompt', async () => {
+        await expect(
+          service.generateSuggestions(testProjectPath, 'non-existent', 'features', 5)
+        ).rejects.toThrow('Prompt non-existent not found');
+      });
+    });
+  });
+});

apps/ui/src/app.tsx

@@ -1,4 +1,4 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useEffect } from 'react';
 import { RouterProvider } from '@tanstack/react-router';
 import { router } from './utils/router';
 import { SplashScreen } from './components/splash-screen';
@@ -15,6 +15,19 @@ export default function App() {
     return true;
   });
 
+  // Clear accumulated PerformanceMeasure entries to prevent memory leak in dev mode
+  // React's internal scheduler creates performance marks/measures that accumulate without cleanup
+  useEffect(() => {
+    if (import.meta.env.DEV) {
+      const clearPerfEntries = () => {
+        performance.clearMarks();
+        performance.clearMeasures();
+      };
+      const interval = setInterval(clearPerfEntries, 5000);
+      return () => clearInterval(interval);
+    }
+  }, []);
+
   // Run settings migration on startup (localStorage -> file storage)
   const migrationState = useSettingsMigration();
   if (migrationState.migrated) {

apps/ui/src/components/layout/sidebar/hooks/use-navigation.ts

@@ -10,6 +10,7 @@ import {
   CircleDot,
   GitPullRequest,
   Zap,
+  Lightbulb,
 } from 'lucide-react';
 import type { NavSection, NavItem } from '../types';
 import type { KeyboardShortcut } from '@/hooks/use-keyboard-shortcuts';
@@ -30,6 +31,9 @@ interface UseNavigationProps {
     agent: string;
     terminal: string;
     settings: string;
+    ideation: string;
+    githubIssues: string;
+    githubPrs: string;
   };
   hideSpecEditor: boolean;
   hideContext: boolean;
@@ -92,6 +96,12 @@ export function useNavigation({
   // Build navigation sections
   const navSections: NavSection[] = useMemo(() => {
     const allToolsItems: NavItem[] = [
+      {
+        id: 'ideation',
+        label: 'Ideation',
+        icon: Lightbulb,
+        shortcut: shortcuts.ideation,
+      },
       {
         id: 'spec',
         label: 'Spec Editor',
@@ -172,12 +182,14 @@ export function useNavigation({
             id: 'github-issues',
             label: 'Issues',
             icon: CircleDot,
+            shortcut: shortcuts.githubIssues,
             count: unviewedValidationsCount,
           },
           {
             id: 'github-prs',
             label: 'Pull Requests',
             icon: GitPullRequest,
+            shortcut: shortcuts.githubPrs,
           },
         ],
       });

apps/ui/src/components/ui/keyboard-map.tsx

@@ -90,6 +90,9 @@ const SHORTCUT_LABELS: Record<keyof KeyboardShortcuts, string> = {
   settings: 'Settings',
   profiles: 'AI Profiles',
   terminal: 'Terminal',
+  ideation: 'Ideation',
+  githubIssues: 'GitHub Issues',
+  githubPrs: 'Pull Requests',
   toggleSidebar: 'Toggle Sidebar',
   addFeature: 'Add Feature',
   addContextFile: 'Add Context File',
@@ -115,6 +118,9 @@ const SHORTCUT_CATEGORIES: Record<keyof KeyboardShortcuts, 'navigation' | 'ui' |
   settings: 'navigation',
   profiles: 'navigation',
   terminal: 'navigation',
+  ideation: 'navigation',
+  githubIssues: 'navigation',
+  githubPrs: 'navigation',
   toggleSidebar: 'ui',
   addFeature: 'action',
   addContextFile: 'action',

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

@@ -33,7 +33,6 @@ import {
   ArchiveAllVerifiedDialog,
   DeleteCompletedFeatureDialog,
   EditFeatureDialog,
-  FeatureSuggestionsDialog,
   FollowUpDialog,
   PlanApprovalDialog,
 } from './board-view/dialogs';
@@ -56,7 +55,6 @@ import {
   useBoardBackground,
   useBoardPersistence,
   useFollowUpState,
-  useSuggestionsState,
 } from './board-view/hooks';
 
 // Stable empty array to avoid infinite loop in selector
@@ -153,19 +151,6 @@ export function BoardView() {
     handleFollowUpDialogChange,
   } = useFollowUpState();
 
-  // Suggestions state hook
-  const {
-    showSuggestionsDialog,
-    suggestionsCount,
-    featureSuggestions,
-    isGeneratingSuggestions,
-    setShowSuggestionsDialog,
-    setSuggestionsCount,
-    setFeatureSuggestions,
-    setIsGeneratingSuggestions,
-    updateSuggestions,
-    closeSuggestionsDialog,
-  } = useSuggestionsState();
   // Search filter for Kanban cards
   const [searchQuery, setSearchQuery] = useState('');
   // Plan approval loading state
@@ -200,9 +185,6 @@ export function BoardView() {
     currentProject,
     specCreatingForProject,
     setSpecCreatingForProject,
-    setSuggestionsCount,
-    setFeatureSuggestions,
-    setIsGeneratingSuggestions,
     checkContextExists,
     features: hookFeatures,
     isLoading,
@@ -1119,8 +1101,6 @@ export function BoardView() {
             runningAutoTasks={runningAutoTasks}
             shortcuts={shortcuts}
             onStartNextFeatures={handleStartNextFeatures}
-            onShowSuggestions={() => setShowSuggestionsDialog(true)}
-            suggestionsCount={suggestionsCount}
             onArchiveAllVerified={() => setShowArchiveAllVerifiedDialog(true)}
             pipelineConfig={
               currentProject?.path ? pipelineConfigByProject[currentProject.path] || null : null
@@ -1269,17 +1249,6 @@ export function BoardView() {
         isMaximized={isMaximized}
       />
 
-      {/* Feature Suggestions Dialog */}
-      <FeatureSuggestionsDialog
-        open={showSuggestionsDialog}
-        onClose={closeSuggestionsDialog}
-        projectPath={currentProject.path}
-        suggestions={featureSuggestions}
-        setSuggestions={updateSuggestions}
-        isGenerating={isGeneratingSuggestions}
-        setIsGenerating={setIsGeneratingSuggestions}
-      />
-
       {/* Backlog Plan Dialog */}
       <BacklogPlanDialog
         open={showPlanDialog}

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

@@ -1,575 +0,0 @@
-import { useEffect, useRef, useState, useCallback } 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 { Checkbox } from '@/components/ui/checkbox';
-import { Label } from '@/components/ui/label';
-import {
-  Loader2,
-  Lightbulb,
-  Download,
-  StopCircle,
-  ChevronDown,
-  ChevronRight,
-  RefreshCw,
-  Shield,
-  Zap,
-  List,
-  FileText,
-} from 'lucide-react';
-import {
-  getElectronAPI,
-  FeatureSuggestion,
-  SuggestionsEvent,
-  SuggestionType,
-} from '@/lib/electron';
-import { useAppStore, Feature } from '@/store/app-store';
-import { toast } from 'sonner';
-import { LogViewer } from '@/components/ui/log-viewer';
-
-interface FeatureSuggestionsDialogProps {
-  open: boolean;
-  onClose: () => void;
-  projectPath: string;
-  // Props to persist state across dialog open/close
-  suggestions: FeatureSuggestion[];
-  setSuggestions: (suggestions: FeatureSuggestion[]) => void;
-  isGenerating: boolean;
-  setIsGenerating: (generating: boolean) => void;
-}
-
-// Configuration for each suggestion type
-const suggestionTypeConfig: Record<
-  SuggestionType,
-  {
-    label: string;
-    icon: React.ComponentType<{ className?: string }>;
-    description: string;
-    color: string;
-  }
-> = {
-  features: {
-    label: 'Feature Suggestions',
-    icon: Lightbulb,
-    description: 'Discover missing features and improvements',
-    color: 'text-yellow-500',
-  },
-  refactoring: {
-    label: 'Refactoring Suggestions',
-    icon: RefreshCw,
-    description: 'Find code smells and refactoring opportunities',
-    color: 'text-blue-500',
-  },
-  security: {
-    label: 'Security Suggestions',
-    icon: Shield,
-    description: 'Identify security vulnerabilities and issues',
-    color: 'text-red-500',
-  },
-  performance: {
-    label: 'Performance Suggestions',
-    icon: Zap,
-    description: 'Discover performance bottlenecks and optimizations',
-    color: 'text-green-500',
-  },
-};
-
-export function FeatureSuggestionsDialog({
-  open,
-  onClose,
-  projectPath,
-  suggestions,
-  setSuggestions,
-  isGenerating,
-  setIsGenerating,
-}: FeatureSuggestionsDialogProps) {
-  const [progress, setProgress] = useState<string[]>([]);
-  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
-  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
-  const [isImporting, setIsImporting] = useState(false);
-  const [currentSuggestionType, setCurrentSuggestionType] = useState<SuggestionType | null>(null);
-  const [viewMode, setViewMode] = useState<'parsed' | 'raw'>('parsed');
-  const scrollRef = useRef<HTMLDivElement>(null);
-  const autoScrollRef = useRef(true);
-
-  const { features, setFeatures } = useAppStore();
-
-  // Initialize selectedIds when suggestions change
-  useEffect(() => {
-    if (suggestions.length > 0 && selectedIds.size === 0) {
-      setSelectedIds(new Set(suggestions.map((s) => s.id)));
-    }
-  }, [suggestions, selectedIds.size]);
-
-  // Auto-scroll progress when new content arrives
-  useEffect(() => {
-    if (autoScrollRef.current && scrollRef.current && isGenerating) {
-      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
-    }
-  }, [progress, isGenerating]);
-
-  // Listen for suggestion events when dialog is open
-  useEffect(() => {
-    if (!open) return;
-
-    const api = getElectronAPI();
-    if (!api?.suggestions) return;
-
-    const unsubscribe = api.suggestions.onEvent((event: SuggestionsEvent) => {
-      if (event.type === 'suggestions_progress') {
-        setProgress((prev) => [...prev, event.content || '']);
-      } else if (event.type === 'suggestions_tool') {
-        const toolName = event.tool || 'Unknown Tool';
-        const toolInput = event.input ? JSON.stringify(event.input, null, 2) : '';
-        const formattedTool = `\n🔧 Tool: ${toolName}\n${toolInput ? `Input: ${toolInput}\n` : ''}`;
-        setProgress((prev) => [...prev, formattedTool]);
-      } else if (event.type === 'suggestions_complete') {
-        setIsGenerating(false);
-        if (event.suggestions && event.suggestions.length > 0) {
-          setSuggestions(event.suggestions);
-          // Select all by default
-          setSelectedIds(new Set(event.suggestions.map((s) => s.id)));
-          const typeLabel = currentSuggestionType
-            ? suggestionTypeConfig[currentSuggestionType].label.toLowerCase()
-            : 'suggestions';
-          toast.success(`Generated ${event.suggestions.length} ${typeLabel}!`);
-        } else {
-          toast.info('No suggestions generated. Try again.');
-        }
-      } else if (event.type === 'suggestions_error') {
-        setIsGenerating(false);
-        toast.error(`Error: ${event.error}`);
-      }
-    });
-
-    return () => {
-      unsubscribe();
-    };
-  }, [open, setSuggestions, setIsGenerating, currentSuggestionType]);
-
-  // Start generating suggestions for a specific type
-  const handleGenerate = useCallback(
-    async (suggestionType: SuggestionType) => {
-      const api = getElectronAPI();
-      if (!api?.suggestions) {
-        toast.error('Suggestions API not available');
-        return;
-      }
-
-      setIsGenerating(true);
-      setProgress([]);
-      setSuggestions([]);
-      setSelectedIds(new Set());
-      setCurrentSuggestionType(suggestionType);
-
-      try {
-        const result = await api.suggestions.generate(projectPath, suggestionType);
-        if (!result.success) {
-          toast.error(result.error || 'Failed to start generation');
-          setIsGenerating(false);
-        }
-      } catch (error) {
-        console.error('Failed to generate suggestions:', error);
-        toast.error('Failed to start generation');
-        setIsGenerating(false);
-      }
-    },
-    [projectPath, setIsGenerating, setSuggestions]
-  );
-
-  // Stop generating
-  const handleStop = useCallback(async () => {
-    const api = getElectronAPI();
-    if (!api?.suggestions) return;
-
-    try {
-      await api.suggestions.stop();
-      setIsGenerating(false);
-      toast.info('Generation stopped');
-    } catch (error) {
-      console.error('Failed to stop generation:', error);
-    }
-  }, [setIsGenerating]);
-
-  // Toggle suggestion selection
-  const toggleSelection = useCallback((id: string) => {
-    setSelectedIds((prev) => {
-      const next = new Set(prev);
-      if (next.has(id)) {
-        next.delete(id);
-      } else {
-        next.add(id);
-      }
-      return next;
-    });
-  }, []);
-
-  // Toggle expand/collapse for a suggestion
-  const toggleExpanded = useCallback((id: string) => {
-    setExpandedIds((prev) => {
-      const next = new Set(prev);
-      if (next.has(id)) {
-        next.delete(id);
-      } else {
-        next.add(id);
-      }
-      return next;
-    });
-  }, []);
-
-  // Select/deselect all
-  const toggleSelectAll = useCallback(() => {
-    if (selectedIds.size === suggestions.length) {
-      setSelectedIds(new Set());
-    } else {
-      setSelectedIds(new Set(suggestions.map((s) => s.id)));
-    }
-  }, [selectedIds.size, suggestions]);
-
-  // Import selected suggestions as features
-  const handleImport = useCallback(async () => {
-    if (selectedIds.size === 0) {
-      toast.warning('No suggestions selected');
-      return;
-    }
-
-    setIsImporting(true);
-
-    try {
-      const api = getElectronAPI();
-      const selectedSuggestions = suggestions.filter((s) => selectedIds.has(s.id));
-
-      // Create new features from selected suggestions
-      const newFeatures: Feature[] = selectedSuggestions.map((s) => ({
-        id: `feature-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        category: s.category,
-        description: s.description,
-        steps: [], // Required empty steps array for new features
-        status: 'backlog' as const,
-        skipTests: true, // As specified, testing mode true
-        priority: s.priority, // Preserve priority from suggestion
-      }));
-
-      // Create each new feature using the features API
-      if (api.features) {
-        for (const feature of newFeatures) {
-          await api.features.create(projectPath, feature);
-        }
-      }
-
-      // Merge with existing features for store update
-      const updatedFeatures = [...features, ...newFeatures];
-
-      // Update store
-      setFeatures(updatedFeatures);
-
-      toast.success(`Imported ${newFeatures.length} features to backlog!`);
-
-      // Clear suggestions after importing
-      setSuggestions([]);
-      setSelectedIds(new Set());
-      setProgress([]);
-      setCurrentSuggestionType(null);
-
-      onClose();
-    } catch (error) {
-      console.error('Failed to import features:', error);
-      toast.error('Failed to import features');
-    } finally {
-      setIsImporting(false);
-    }
-  }, [selectedIds, suggestions, features, setFeatures, setSuggestions, projectPath, onClose]);
-
-  // Handle scroll to detect if user scrolled up
-  const handleScroll = () => {
-    if (!scrollRef.current) return;
-
-    const { scrollTop, scrollHeight, clientHeight } = scrollRef.current;
-    const isAtBottom = scrollHeight - scrollTop - clientHeight < 50;
-    autoScrollRef.current = isAtBottom;
-  };
-
-  // Go back to type selection
-  const handleBackToSelection = useCallback(() => {
-    setSuggestions([]);
-    setSelectedIds(new Set());
-    setProgress([]);
-    setCurrentSuggestionType(null);
-  }, [setSuggestions]);
-
-  const hasStarted = isGenerating || progress.length > 0 || suggestions.length > 0;
-  const hasSuggestions = suggestions.length > 0;
-  const currentConfig = currentSuggestionType ? suggestionTypeConfig[currentSuggestionType] : null;
-
-  return (
-    <Dialog open={open} onOpenChange={onClose}>
-      <DialogContent
-        className="w-[70vw] max-w-[70vw] max-h-[85vh] flex flex-col"
-        data-testid="feature-suggestions-dialog"
-      >
-        <DialogHeader className="flex-shrink-0">
-          <DialogTitle className="flex items-center gap-2">
-            {currentConfig ? (
-              <>
-                <currentConfig.icon className={`w-5 h-5 ${currentConfig.color}`} />
-                {currentConfig.label}
-              </>
-            ) : (
-              <>
-                <Lightbulb className="w-5 h-5 text-yellow-500" />
-                AI Suggestions
-              </>
-            )}
-          </DialogTitle>
-          <DialogDescription>
-            {currentConfig
-              ? currentConfig.description
-              : 'Analyze your project to discover improvements. Choose a suggestion type below.'}
-          </DialogDescription>
-        </DialogHeader>
-
-        {!hasStarted ? (
-          // Initial state - show suggestion type buttons
-          <div className="flex-1 flex flex-col items-center justify-center py-8">
-            <p className="text-muted-foreground text-center max-w-lg mb-8">
-              Our AI will analyze your project and generate actionable suggestions. Choose what type
-              of analysis you want to perform:
-            </p>
-            <div className="grid grid-cols-2 gap-4 w-full max-w-2xl">
-              {(
-                Object.entries(suggestionTypeConfig) as [
-                  SuggestionType,
-                  (typeof suggestionTypeConfig)[SuggestionType],
-                ][]
-              ).map(([type, config]) => {
-                const Icon = config.icon;
-                return (
-                  <Button
-                    key={type}
-                    variant="outline"
-                    className="h-auto py-6 px-6 flex flex-col items-center gap-3 hover:border-primary/50 transition-colors"
-                    onClick={() => handleGenerate(type)}
-                    data-testid={`generate-${type}-btn`}
-                  >
-                    <Icon className={`w-8 h-8 ${config.color}`} />
-                    <div className="text-center">
-                      <div className="font-semibold">
-                        {config.label.replace(' Suggestions', '')}
-                      </div>
-                      <div className="text-xs text-muted-foreground mt-1">{config.description}</div>
-                    </div>
-                  </Button>
-                );
-              })}
-            </div>
-          </div>
-        ) : isGenerating ? (
-          // Generating state - show progress
-          <div className="flex-1 flex flex-col min-h-0">
-            <div className="flex items-center justify-between mb-2">
-              <div className="flex items-center gap-2 text-sm text-muted-foreground">
-                <Loader2 className="w-4 h-4 animate-spin" />
-                Analyzing project...
-              </div>
-              <div className="flex items-center gap-2">
-                <div className="flex items-center gap-1 bg-muted rounded-lg p-1">
-                  <button
-                    onClick={() => setViewMode('parsed')}
-                    className={`flex items-center gap-1.5 px-2 py-1 rounded-md text-xs font-medium transition-all ${
-                      viewMode === 'parsed'
-                        ? 'bg-primary/20 text-primary shadow-sm'
-                        : 'text-muted-foreground hover:text-foreground hover:bg-accent'
-                    }`}
-                    data-testid="view-mode-parsed"
-                  >
-                    <List className="w-3 h-3" />
-                    Logs
-                  </button>
-                  <button
-                    onClick={() => setViewMode('raw')}
-                    className={`flex items-center gap-1.5 px-2 py-1 rounded-md text-xs font-medium transition-all ${
-                      viewMode === 'raw'
-                        ? 'bg-primary/20 text-primary shadow-sm'
-                        : 'text-muted-foreground hover:text-foreground hover:bg-accent'
-                    }`}
-                    data-testid="view-mode-raw"
-                  >
-                    <FileText className="w-3 h-3" />
-                    Raw
-                  </button>
-                </div>
-                <Button variant="destructive" size="sm" onClick={handleStop}>
-                  <StopCircle className="w-4 h-4 mr-2" />
-                  Stop
-                </Button>
-              </div>
-            </div>
-            <div
-              ref={scrollRef}
-              onScroll={handleScroll}
-              className="flex-1 overflow-y-auto bg-zinc-950 rounded-lg p-4 font-mono text-xs min-h-[200px] max-h-[400px]"
-            >
-              {progress.length === 0 ? (
-                <div className="flex items-center justify-center min-h-[168px] text-muted-foreground">
-                  <Loader2 className="w-6 h-6 animate-spin mr-2" />
-                  Waiting for AI response...
-                </div>
-              ) : viewMode === 'parsed' ? (
-                <LogViewer output={progress.join('')} />
-              ) : (
-                <div className="whitespace-pre-wrap break-words text-zinc-300">
-                  {progress.join('')}
-                </div>
-              )}
-            </div>
-          </div>
-        ) : hasSuggestions ? (
-          // Results state - show suggestions list
-          <div className="flex-1 flex flex-col min-h-0">
-            <div className="flex items-center justify-between mb-3">
-              <div className="flex items-center gap-4">
-                <span className="text-sm text-muted-foreground">
-                  {suggestions.length} suggestions generated
-                </span>
-                <Button variant="ghost" size="sm" onClick={toggleSelectAll}>
-                  {selectedIds.size === suggestions.length ? 'Deselect All' : 'Select All'}
-                </Button>
-              </div>
-              <span className="text-sm font-medium">{selectedIds.size} selected</span>
-            </div>
-
-            <div
-              ref={scrollRef}
-              className="flex-1 overflow-y-auto space-y-2 min-h-[200px] max-h-[400px] pr-2"
-            >
-              {suggestions.map((suggestion) => {
-                const isSelected = selectedIds.has(suggestion.id);
-                const isExpanded = expandedIds.has(suggestion.id);
-
-                return (
-                  <div
-                    key={suggestion.id}
-                    className={`border rounded-lg p-3 transition-colors ${
-                      isSelected
-                        ? 'border-primary bg-primary/5'
-                        : 'border-border hover:border-primary/50'
-                    }`}
-                    data-testid={`suggestion-${suggestion.id}`}
-                  >
-                    <div className="flex items-start gap-3">
-                      <Checkbox
-                        id={suggestion.id}
-                        checked={isSelected}
-                        onCheckedChange={() => toggleSelection(suggestion.id)}
-                        className="mt-1"
-                      />
-                      <div className="flex-1 min-w-0">
-                        <div className="flex items-center gap-2 mb-1">
-                          <button
-                            onClick={() => toggleExpanded(suggestion.id)}
-                            className="flex items-center gap-1 text-muted-foreground hover:text-foreground"
-                          >
-                            {isExpanded ? (
-                              <ChevronDown className="w-4 h-4" />
-                            ) : (
-                              <ChevronRight className="w-4 h-4" />
-                            )}
-                          </button>
-                          <span className="text-xs px-2 py-0.5 rounded-full bg-primary/20 text-primary font-medium">
-                            #{suggestion.priority}
-                          </span>
-                          <span className="text-xs px-2 py-0.5 rounded-full bg-secondary text-secondary-foreground">
-                            {suggestion.category}
-                          </span>
-                        </div>
-                        <Label
-                          htmlFor={suggestion.id}
-                          className="text-sm font-medium cursor-pointer"
-                        >
-                          {suggestion.description}
-                        </Label>
-
-                        {isExpanded && suggestion.reasoning && (
-                          <div className="mt-3 text-sm">
-                            <p className="text-muted-foreground italic">{suggestion.reasoning}</p>
-                          </div>
-                        )}
-                      </div>
-                    </div>
-                  </div>
-                );
-              })}
-            </div>
-          </div>
-        ) : (
-          // No results state
-          <div className="flex-1 flex flex-col items-center justify-center py-8 text-center">
-            <p className="text-muted-foreground mb-4">
-              No suggestions were generated. Try running the analysis again.
-            </p>
-            <div className="flex gap-2">
-              <Button variant="outline" onClick={handleBackToSelection}>
-                Back to Selection
-              </Button>
-              {currentSuggestionType && (
-                <Button onClick={() => handleGenerate(currentSuggestionType)}>
-                  <Lightbulb className="w-4 h-4 mr-2" />
-                  Try Again
-                </Button>
-              )}
-            </div>
-          </div>
-        )}
-
-        <DialogFooter className="flex-shrink-0">
-          {hasSuggestions && (
-            <div className="flex gap-2 w-full justify-between">
-              <div className="flex gap-2">
-                <Button variant="outline" onClick={handleBackToSelection}>
-                  Back
-                </Button>
-                {currentSuggestionType && (
-                  <Button variant="outline" onClick={() => handleGenerate(currentSuggestionType)}>
-                    {currentConfig && <currentConfig.icon className="w-4 h-4 mr-2" />}
-                    Regenerate
-                  </Button>
-                )}
-              </div>
-              <div className="flex gap-2">
-                <Button variant="ghost" onClick={onClose}>
-                  Cancel
-                </Button>
-                <HotkeyButton
-                  onClick={handleImport}
-                  disabled={selectedIds.size === 0 || isImporting}
-                  hotkey={{ key: 'Enter', cmdCtrl: true }}
-                  hotkeyActive={open && hasSuggestions}
-                >
-                  {isImporting ? (
-                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
-                  ) : (
-                    <Download className="w-4 h-4 mr-2" />
-                  )}
-                  Import {selectedIds.size} Feature
-                  {selectedIds.size !== 1 ? 's' : ''}
-                </HotkeyButton>
-              </div>
-            </div>
-          )}
-          {!hasSuggestions && !isGenerating && hasStarted && (
-            <Button variant="ghost" onClick={onClose}>
-              Close
-            </Button>
-          )}
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}

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

@@ -5,6 +5,5 @@ export { CompletedFeaturesModal } from './completed-features-modal';
 export { ArchiveAllVerifiedDialog } from './archive-all-verified-dialog';
 export { DeleteCompletedFeatureDialog } from './delete-completed-feature-dialog';
 export { EditFeatureDialog } from './edit-feature-dialog';
-export { FeatureSuggestionsDialog } from './feature-suggestions-dialog';
 export { FollowUpDialog } from './follow-up-dialog';
 export { PlanApprovalDialog } from './plan-approval-dialog';

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

@@ -7,4 +7,3 @@ export { useBoardEffects } from './use-board-effects';
 export { useBoardBackground } from './use-board-background';
 export { useBoardPersistence } from './use-board-persistence';
 export { useFollowUpState } from './use-follow-up-state';
-export { useSuggestionsState } from './use-suggestions-state';

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

@@ -6,9 +6,6 @@ interface UseBoardEffectsProps {
   currentProject: { path: string; id: string } | null;
   specCreatingForProject: string | null;
   setSpecCreatingForProject: (path: string | null) => void;
-  setSuggestionsCount: (count: number) => void;
-  setFeatureSuggestions: (suggestions: any[]) => void;
-  setIsGeneratingSuggestions: (generating: boolean) => void;
   checkContextExists: (featureId: string) => Promise<boolean>;
   features: any[];
   isLoading: boolean;
@@ -20,9 +17,6 @@ export function useBoardEffects({
   currentProject,
   specCreatingForProject,
   setSpecCreatingForProject,
-  setSuggestionsCount,
-  setFeatureSuggestions,
-  setIsGeneratingSuggestions,
   checkContextExists,
   features,
   isLoading,
@@ -44,26 +38,6 @@ export function useBoardEffects({
     };
   }, [currentProject]);
 
-  // Listen for suggestions events to update count (persists even when dialog is closed)
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.suggestions) return;
-
-    const unsubscribe = api.suggestions.onEvent((event) => {
-      if (event.type === 'suggestions_complete' && event.suggestions) {
-        setSuggestionsCount(event.suggestions.length);
-        setFeatureSuggestions(event.suggestions);
-        setIsGeneratingSuggestions(false);
-      } else if (event.type === 'suggestions_error') {
-        setIsGeneratingSuggestions(false);
-      }
-    });
-
-    return () => {
-      unsubscribe();
-    };
-  }, [setSuggestionsCount, setFeatureSuggestions, setIsGeneratingSuggestions]);
-
   // Subscribe to spec regeneration events to clear creating state on completion
   useEffect(() => {
     const api = getElectronAPI();

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

@@ -1,34 +0,0 @@
-import { useState, useCallback } from 'react';
-import type { FeatureSuggestion } from '@/lib/electron';
-
-export function useSuggestionsState() {
-  const [showSuggestionsDialog, setShowSuggestionsDialog] = useState(false);
-  const [suggestionsCount, setSuggestionsCount] = useState(0);
-  const [featureSuggestions, setFeatureSuggestions] = useState<FeatureSuggestion[]>([]);
-  const [isGeneratingSuggestions, setIsGeneratingSuggestions] = useState(false);
-
-  const updateSuggestions = useCallback((suggestions: FeatureSuggestion[]) => {
-    setFeatureSuggestions(suggestions);
-    setSuggestionsCount(suggestions.length);
-  }, []);
-
-  const closeSuggestionsDialog = useCallback(() => {
-    setShowSuggestionsDialog(false);
-  }, []);
-
-  return {
-    // State
-    showSuggestionsDialog,
-    suggestionsCount,
-    featureSuggestions,
-    isGeneratingSuggestions,
-    // Setters
-    setShowSuggestionsDialog,
-    setSuggestionsCount,
-    setFeatureSuggestions,
-    setIsGeneratingSuggestions,
-    // Helpers
-    updateSuggestions,
-    closeSuggestionsDialog,
-  };
-}

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

@@ -5,7 +5,7 @@ import { Button } from '@/components/ui/button';
 import { HotkeyButton } from '@/components/ui/hotkey-button';
 import { KanbanColumn, KanbanCard } from './components';
 import { Feature } from '@/store/app-store';
-import { FastForward, Lightbulb, Archive, Plus, Settings2 } from 'lucide-react';
+import { FastForward, Archive, Plus, Settings2 } from 'lucide-react';
 import { useKeyboardShortcutsConfig } from '@/hooks/use-keyboard-shortcuts';
 import { useResponsiveKanban } from '@/hooks/use-responsive-kanban';
 import { getColumnsWithPipeline, type Column, type ColumnId } from './constants';
@@ -47,8 +47,6 @@ interface KanbanBoardProps {
   runningAutoTasks: string[];
   shortcuts: ReturnType<typeof useKeyboardShortcutsConfig>;
   onStartNextFeatures: () => void;
-  onShowSuggestions: () => void;
-  suggestionsCount: number;
   onArchiveAllVerified: () => void;
   pipelineConfig: PipelineConfig | null;
   onOpenPipelineSettings?: () => void;
@@ -82,8 +80,6 @@ export function KanbanBoard({
   runningAutoTasks,
   shortcuts,
   onStartNextFeatures,
-  onShowSuggestions,
-  suggestionsCount,
   onArchiveAllVerified,
   pipelineConfig,
   onOpenPipelineSettings,
@@ -130,40 +126,20 @@ export function KanbanBoard({
                       Complete All
                     </Button>
                   ) : column.id === 'backlog' ? (
-                    <div className="flex items-center gap-1">
-                      <Button
+                    columnFeatures.length > 0 && (
+                      <HotkeyButton
                         variant="ghost"
                         size="sm"
-                        className="h-6 w-6 p-0 text-yellow-500 hover:text-yellow-400 hover:bg-yellow-500/10 relative"
-                        onClick={onShowSuggestions}
-                        title="Feature Suggestions"
-                        data-testid="feature-suggestions-button"
+                        className="h-6 px-2 text-xs text-primary hover:text-primary hover:bg-primary/10"
+                        onClick={onStartNextFeatures}
+                        hotkey={shortcuts.startNext}
+                        hotkeyActive={false}
+                        data-testid="start-next-button"
                       >
-                        <Lightbulb className="w-3.5 h-3.5" />
-                        {suggestionsCount > 0 && (
-                          <span
-                            className="absolute -top-1 -right-1 w-4 h-4 text-[9px] font-mono rounded-full bg-yellow-500 text-black flex items-center justify-center"
-                            data-testid="suggestions-count"
-                          >
-                            {suggestionsCount}
-                          </span>
-                        )}
-                      </Button>
-                      {columnFeatures.length > 0 && (
-                        <HotkeyButton
-                          variant="ghost"
-                          size="sm"
-                          className="h-6 px-2 text-xs text-primary hover:text-primary hover:bg-primary/10"
-                          onClick={onStartNextFeatures}
-                          hotkey={shortcuts.startNext}
-                          hotkeyActive={false}
-                          data-testid="start-next-button"
-                        >
-                          <FastForward className="w-3 h-3 mr-1" />
-                          Make
-                        </HotkeyButton>
-                      )}
-                    </div>
+                        <FastForward className="w-3 h-3 mr-1" />
+                        Make
+                      </HotkeyButton>
+                    )
                   ) : column.id === 'in_progress' ? (
                     <Button
                       variant="ghost"

apps/ui/src/components/views/ideation-view/components/ideation-dashboard.tsx

@@ -0,0 +1,340 @@
+/**
+ * IdeationDashboard - Main dashboard showing all generated suggestions
+ * First page users see - shows all ideas ready for accept/reject
+ */
+
+import { useState, useMemo } from 'react';
+import { Loader2, AlertCircle, Plus, X, Sparkles, Lightbulb } from 'lucide-react';
+import { Card, CardContent } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Badge } from '@/components/ui/badge';
+import { useIdeationStore, type GenerationJob } from '@/store/ideation-store';
+import { useAppStore } from '@/store/app-store';
+import { getElectronAPI } from '@/lib/electron';
+import { toast } from 'sonner';
+import { cn } from '@/lib/utils';
+import type { AnalysisSuggestion } from '@automaker/types';
+
+interface IdeationDashboardProps {
+  onGenerateIdeas: () => void;
+}
+
+function SuggestionCard({
+  suggestion,
+  job,
+  onAccept,
+  onRemove,
+  isAdding,
+}: {
+  suggestion: AnalysisSuggestion;
+  job: GenerationJob;
+  onAccept: () => void;
+  onRemove: () => void;
+  isAdding: boolean;
+}) {
+  return (
+    <Card className="transition-all hover:border-primary/50">
+      <CardContent className="p-4">
+        <div className="flex items-start gap-4">
+          <div className="flex-1 min-w-0">
+            <div className="flex items-center gap-2 mb-1">
+              <h4 className="font-medium">{suggestion.title}</h4>
+              <Badge variant="outline" className="text-xs">
+                {suggestion.priority}
+              </Badge>
+              <Badge variant="secondary" className="text-xs">
+                {job.prompt.title}
+              </Badge>
+            </div>
+            <p className="text-sm text-muted-foreground">{suggestion.description}</p>
+            {suggestion.rationale && (
+              <p className="text-xs text-muted-foreground mt-2 italic">{suggestion.rationale}</p>
+            )}
+          </div>
+          <div className="flex items-center gap-2 shrink-0">
+            <Button
+              size="sm"
+              variant="ghost"
+              onClick={onRemove}
+              disabled={isAdding}
+              className="text-muted-foreground hover:text-destructive"
+            >
+              <X className="w-4 h-4" />
+            </Button>
+            <Button size="sm" onClick={onAccept} disabled={isAdding} className="gap-1">
+              {isAdding ? (
+                <Loader2 className="w-4 h-4 animate-spin" />
+              ) : (
+                <>
+                  <Plus className="w-4 h-4" />
+                  Accept
+                </>
+              )}
+            </Button>
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
+
+function GeneratingCard({ job }: { job: GenerationJob }) {
+  const { removeJob } = useIdeationStore();
+  const isError = job.status === 'error';
+
+  return (
+    <Card className={cn('transition-all', isError ? 'border-red-500/50' : 'border-blue-500/50')}>
+      <CardContent className="p-4">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-3">
+            {isError ? (
+              <AlertCircle className="w-5 h-5 text-red-500" />
+            ) : (
+              <Loader2 className="w-5 h-5 text-blue-500 animate-spin" />
+            )}
+            <div>
+              <p className="font-medium">{job.prompt.title}</p>
+              <p className="text-sm text-muted-foreground">
+                {isError ? job.error || 'Failed to generate' : 'Generating ideas...'}
+              </p>
+            </div>
+          </div>
+          <Button
+            variant="ghost"
+            size="sm"
+            onClick={() => removeJob(job.id)}
+            className="text-muted-foreground hover:text-destructive"
+          >
+            <X className="w-4 h-4" />
+          </Button>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
+
+function TagFilter({
+  tags,
+  tagCounts,
+  selectedTags,
+  onToggleTag,
+}: {
+  tags: string[];
+  tagCounts: Record<string, number>;
+  selectedTags: Set<string>;
+  onToggleTag: (tag: string) => void;
+}) {
+  if (tags.length === 0) return null;
+
+  return (
+    <div className="flex flex-wrap gap-2">
+      {tags.map((tag) => {
+        const isSelected = selectedTags.has(tag);
+        const count = tagCounts[tag] || 0;
+        return (
+          <button
+            key={tag}
+            onClick={() => onToggleTag(tag)}
+            className={cn(
+              'px-3 py-1.5 text-sm rounded-full border transition-all flex items-center gap-1.5',
+              isSelected
+                ? 'bg-primary text-primary-foreground border-primary'
+                : 'bg-secondary/50 text-muted-foreground border-border hover:border-primary/50 hover:text-foreground'
+            )}
+          >
+            {tag}
+            <span
+              className={cn(
+                'text-xs',
+                isSelected ? 'text-primary-foreground/70' : 'text-muted-foreground/70'
+              )}
+            >
+              ({count})
+            </span>
+          </button>
+        );
+      })}
+      {selectedTags.size > 0 && (
+        <button
+          onClick={() => selectedTags.forEach((tag) => onToggleTag(tag))}
+          className="px-3 py-1.5 text-sm text-muted-foreground hover:text-foreground transition-colors"
+        >
+          Clear filters
+        </button>
+      )}
+    </div>
+  );
+}
+
+export function IdeationDashboard({ onGenerateIdeas }: IdeationDashboardProps) {
+  const currentProject = useAppStore((s) => s.currentProject);
+  const { generationJobs, removeSuggestionFromJob } = useIdeationStore();
+  const [addingId, setAddingId] = useState<string | null>(null);
+  const [selectedTags, setSelectedTags] = useState<Set<string>>(new Set());
+
+  // Separate generating/error jobs from ready jobs with suggestions
+  const activeJobs = generationJobs.filter(
+    (j) => j.status === 'generating' || j.status === 'error'
+  );
+  const readyJobs = generationJobs.filter((j) => j.status === 'ready' && j.suggestions.length > 0);
+
+  // Flatten all suggestions with their parent job
+  const allSuggestions = useMemo(
+    () => readyJobs.flatMap((job) => job.suggestions.map((suggestion) => ({ suggestion, job }))),
+    [readyJobs]
+  );
+
+  // Extract unique tags and counts from all suggestions
+  const { availableTags, tagCounts } = useMemo(() => {
+    const counts: Record<string, number> = {};
+    allSuggestions.forEach(({ job }) => {
+      const tag = job.prompt.title;
+      counts[tag] = (counts[tag] || 0) + 1;
+    });
+    return {
+      availableTags: Object.keys(counts).sort(),
+      tagCounts: counts,
+    };
+  }, [allSuggestions]);
+
+  // Filter suggestions based on selected tags
+  const filteredSuggestions = useMemo(() => {
+    if (selectedTags.size === 0) return allSuggestions;
+    return allSuggestions.filter(({ job }) => selectedTags.has(job.prompt.title));
+  }, [allSuggestions, selectedTags]);
+
+  const generatingCount = generationJobs.filter((j) => j.status === 'generating').length;
+
+  const handleToggleTag = (tag: string) => {
+    setSelectedTags((prev) => {
+      const next = new Set(prev);
+      if (next.has(tag)) {
+        next.delete(tag);
+      } else {
+        next.add(tag);
+      }
+      return next;
+    });
+  };
+
+  const handleAccept = async (suggestion: AnalysisSuggestion, jobId: string) => {
+    if (!currentProject?.path) {
+      toast.error('No project selected');
+      return;
+    }
+
+    setAddingId(suggestion.id);
+
+    try {
+      const api = getElectronAPI();
+      const result = await api.ideation?.addSuggestionToBoard(currentProject.path, suggestion);
+
+      if (result?.success) {
+        toast.success(`Added "${suggestion.title}" to board`);
+        removeSuggestionFromJob(jobId, suggestion.id);
+      } else {
+        toast.error(result?.error || 'Failed to add to board');
+      }
+    } catch (error) {
+      console.error('Failed to add to board:', error);
+      toast.error((error as Error).message);
+    } finally {
+      setAddingId(null);
+    }
+  };
+
+  const handleRemove = (suggestionId: string, jobId: string) => {
+    removeSuggestionFromJob(jobId, suggestionId);
+    toast.info('Idea removed');
+  };
+
+  const isEmpty = allSuggestions.length === 0 && activeJobs.length === 0;
+
+  return (
+    <div className="flex-1 flex flex-col p-6 overflow-auto">
+      <div className="max-w-3xl w-full mx-auto space-y-4">
+        {/* Status text */}
+        {(generatingCount > 0 || allSuggestions.length > 0) && (
+          <p className="text-sm text-muted-foreground">
+            {generatingCount > 0
+              ? `Generating ${generatingCount} idea${generatingCount > 1 ? 's' : ''}...`
+              : selectedTags.size > 0
+                ? `Showing ${filteredSuggestions.length} of ${allSuggestions.length} ideas`
+                : `${allSuggestions.length} idea${allSuggestions.length > 1 ? 's' : ''} ready for review`}
+          </p>
+        )}
+
+        {/* Tag Filters */}
+        {availableTags.length > 0 && (
+          <TagFilter
+            tags={availableTags}
+            tagCounts={tagCounts}
+            selectedTags={selectedTags}
+            onToggleTag={handleToggleTag}
+          />
+        )}
+
+        {/* Generating/Error Jobs */}
+        {activeJobs.length > 0 && (
+          <div className="space-y-3">
+            {activeJobs.map((job) => (
+              <GeneratingCard key={job.id} job={job} />
+            ))}
+          </div>
+        )}
+
+        {/* Suggestions List */}
+        {filteredSuggestions.length > 0 && (
+          <div className="space-y-3">
+            {filteredSuggestions.map(({ suggestion, job }) => (
+              <SuggestionCard
+                key={suggestion.id}
+                suggestion={suggestion}
+                job={job}
+                onAccept={() => handleAccept(suggestion, job.id)}
+                onRemove={() => handleRemove(suggestion.id, job.id)}
+                isAdding={addingId === suggestion.id}
+              />
+            ))}
+          </div>
+        )}
+
+        {/* No results after filtering */}
+        {filteredSuggestions.length === 0 && allSuggestions.length > 0 && (
+          <Card>
+            <CardContent className="py-8">
+              <div className="text-center text-muted-foreground">
+                <p>No ideas match the selected filters</p>
+                <button
+                  onClick={() => setSelectedTags(new Set())}
+                  className="text-primary hover:underline mt-2"
+                >
+                  Clear filters
+                </button>
+              </div>
+            </CardContent>
+          </Card>
+        )}
+
+        {/* Empty State */}
+        {isEmpty && (
+          <Card>
+            <CardContent className="py-16">
+              <div className="text-center">
+                <Sparkles className="w-12 h-12 mx-auto text-muted-foreground/50 mb-4" />
+                <h3 className="text-lg font-medium mb-2">No ideas yet</h3>
+                <p className="text-muted-foreground mb-6">
+                  Generate ideas by selecting a category and prompt type
+                </p>
+                <Button onClick={onGenerateIdeas} size="lg" className="gap-2">
+                  <Lightbulb className="w-5 h-5" />
+                  Generate Ideas
+                </Button>
+              </div>
+            </CardContent>
+          </Card>
+        )}
+      </div>
+    </div>
+  );
+}

apps/ui/src/components/views/ideation-view/components/prompt-category-grid.tsx

@@ -0,0 +1,94 @@
+/**
+ * PromptCategoryGrid - Grid of prompt categories to select from
+ */
+
+import {
+  ArrowLeft,
+  Zap,
+  Palette,
+  Code,
+  TrendingUp,
+  Cpu,
+  Shield,
+  Gauge,
+  Accessibility,
+  BarChart3,
+  Loader2,
+} from 'lucide-react';
+import { Card, CardContent } from '@/components/ui/card';
+import { useGuidedPrompts } from '@/hooks/use-guided-prompts';
+import type { IdeaCategory } from '@automaker/types';
+
+interface PromptCategoryGridProps {
+  onSelect: (category: IdeaCategory) => void;
+  onBack: () => void;
+}
+
+const iconMap: Record<string, typeof Zap> = {
+  Zap,
+  Palette,
+  Code,
+  TrendingUp,
+  Cpu,
+  Shield,
+  Gauge,
+  Accessibility,
+  BarChart3,
+};
+
+export function PromptCategoryGrid({ onSelect, onBack }: PromptCategoryGridProps) {
+  const { categories, isLoading, error } = useGuidedPrompts();
+
+  return (
+    <div className="flex-1 flex flex-col p-6 overflow-auto">
+      <div className="max-w-4xl w-full mx-auto space-y-4">
+        {/* Back link */}
+        <button
+          onClick={onBack}
+          className="flex items-center gap-2 text-muted-foreground hover:text-foreground transition-colors"
+        >
+          <ArrowLeft className="w-4 h-4" />
+          <span>Back</span>
+        </button>
+
+        {isLoading && (
+          <div className="flex items-center justify-center py-12">
+            <Loader2 className="w-6 h-6 animate-spin text-muted-foreground" />
+            <span className="ml-2 text-muted-foreground">Loading categories...</span>
+          </div>
+        )}
+        {error && (
+          <div className="text-center py-12 text-destructive">
+            <p>Failed to load categories: {error}</p>
+          </div>
+        )}
+        {!isLoading && !error && (
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+            {categories.map((category) => {
+              const Icon = iconMap[category.icon] || Zap;
+              return (
+                <Card
+                  key={category.id}
+                  className="cursor-pointer transition-all hover:border-primary hover:shadow-md"
+                  onClick={() => onSelect(category.id)}
+                >
+                  <CardContent className="p-6">
+                    <div className="flex flex-col items-center text-center gap-3">
+                      <div className="p-4 rounded-full bg-primary/10">
+                        <Icon className="w-8 h-8 text-primary" />
+                      </div>
+                      <div>
+                        <h3 className="font-semibold text-lg">{category.name}</h3>
+                        <p className="text-muted-foreground text-sm mt-1">{category.description}</p>
+                      </div>
+                    </div>
+                  </CardContent>
+                </Card>
+              );
+            })}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

apps/ui/src/components/views/ideation-view/components/prompt-list.tsx

@@ -0,0 +1,180 @@
+/**
+ * PromptList - List of prompts for a specific category
+ */
+
+import { useState } from 'react';
+import { ArrowLeft, Lightbulb, Loader2, CheckCircle2 } from 'lucide-react';
+import { Card, CardContent } from '@/components/ui/card';
+import { useGuidedPrompts } from '@/hooks/use-guided-prompts';
+import { useIdeationStore } from '@/store/ideation-store';
+import { useAppStore } from '@/store/app-store';
+import { getElectronAPI } from '@/lib/electron';
+import { toast } from 'sonner';
+import { useNavigate } from '@tanstack/react-router';
+import type { IdeaCategory, IdeationPrompt } from '@automaker/types';
+
+interface PromptListProps {
+  category: IdeaCategory;
+  onBack: () => void;
+}
+
+export function PromptList({ category, onBack }: PromptListProps) {
+  const currentProject = useAppStore((s) => s.currentProject);
+  const { setMode, addGenerationJob, updateJobStatus, generationJobs } = useIdeationStore();
+  const [loadingPromptId, setLoadingPromptId] = useState<string | null>(null);
+  const [startedPrompts, setStartedPrompts] = useState<Set<string>>(new Set());
+  const navigate = useNavigate();
+  const {
+    getPromptsByCategory,
+    isLoading: isLoadingPrompts,
+    error: promptsError,
+  } = useGuidedPrompts();
+
+  const prompts = getPromptsByCategory(category);
+
+  // Check which prompts are already generating
+  const generatingPromptIds = new Set(
+    generationJobs.filter((j) => j.status === 'generating').map((j) => j.prompt.id)
+  );
+
+  const handleSelectPrompt = async (prompt: IdeationPrompt) => {
+    if (!currentProject?.path) {
+      toast.error('No project selected');
+      return;
+    }
+
+    if (loadingPromptId || generatingPromptIds.has(prompt.id)) return;
+
+    setLoadingPromptId(prompt.id);
+
+    // Add a job and navigate to dashboard
+    const jobId = addGenerationJob(prompt);
+    setStartedPrompts((prev) => new Set(prev).add(prompt.id));
+
+    // Show toast and navigate to dashboard
+    toast.info(`Generating ideas for "${prompt.title}"...`);
+    setMode('dashboard');
+
+    try {
+      const api = getElectronAPI();
+      const result = await api.ideation?.generateSuggestions(
+        currentProject.path,
+        prompt.id,
+        category
+      );
+
+      if (result?.success && result.suggestions) {
+        updateJobStatus(jobId, 'ready', result.suggestions);
+        toast.success(`Generated ${result.suggestions.length} ideas for "${prompt.title}"`, {
+          duration: 10000,
+          action: {
+            label: 'View Ideas',
+            onClick: () => {
+              setMode('dashboard');
+              navigate({ to: '/ideation' });
+            },
+          },
+        });
+      } else {
+        updateJobStatus(
+          jobId,
+          'error',
+          undefined,
+          result?.error || 'Failed to generate suggestions'
+        );
+        toast.error(result?.error || 'Failed to generate suggestions');
+      }
+    } catch (error) {
+      console.error('Failed to generate suggestions:', error);
+      updateJobStatus(jobId, 'error', undefined, (error as Error).message);
+      toast.error((error as Error).message);
+    } finally {
+      setLoadingPromptId(null);
+    }
+  };
+
+  return (
+    <div className="flex-1 flex flex-col p-6 overflow-auto">
+      <div className="max-w-3xl w-full mx-auto space-y-4">
+        {/* Back link */}
+        <button
+          onClick={onBack}
+          className="flex items-center gap-2 text-muted-foreground hover:text-foreground transition-colors"
+        >
+          <ArrowLeft className="w-4 h-4" />
+          <span>Back</span>
+        </button>
+
+        <div className="space-y-3">
+          {isLoadingPrompts && (
+            <div className="flex items-center justify-center py-8">
+              <Loader2 className="w-6 h-6 animate-spin text-muted-foreground" />
+              <span className="ml-2 text-muted-foreground">Loading prompts...</span>
+            </div>
+          )}
+          {promptsError && (
+            <div className="text-center py-8 text-destructive">
+              <p>Failed to load prompts: {promptsError}</p>
+            </div>
+          )}
+          {!isLoadingPrompts &&
+            !promptsError &&
+            prompts.map((prompt) => {
+              const isLoading = loadingPromptId === prompt.id;
+              const isGenerating = generatingPromptIds.has(prompt.id);
+              const isStarted = startedPrompts.has(prompt.id);
+              const isDisabled = loadingPromptId !== null || isGenerating;
+
+              return (
+                <Card
+                  key={prompt.id}
+                  className={`transition-all ${
+                    isDisabled
+                      ? 'opacity-60 cursor-not-allowed'
+                      : 'cursor-pointer hover:border-primary hover:shadow-md'
+                  } ${isLoading || isGenerating ? 'border-blue-500 ring-1 ring-blue-500' : ''} ${
+                    isStarted && !isGenerating ? 'border-green-500/50' : ''
+                  }`}
+                  onClick={() => !isDisabled && handleSelectPrompt(prompt)}
+                >
+                  <CardContent className="p-5">
+                    <div className="flex items-start gap-4">
+                      <div
+                        className={`p-2 rounded-lg mt-0.5 ${
+                          isLoading || isGenerating
+                            ? 'bg-blue-500/10'
+                            : isStarted
+                              ? 'bg-green-500/10'
+                              : 'bg-primary/10'
+                        }`}
+                      >
+                        {isLoading || isGenerating ? (
+                          <Loader2 className="w-4 h-4 text-blue-500 animate-spin" />
+                        ) : isStarted ? (
+                          <CheckCircle2 className="w-4 h-4 text-green-500" />
+                        ) : (
+                          <Lightbulb className="w-4 h-4 text-primary" />
+                        )}
+                      </div>
+                      <div className="flex-1 min-w-0">
+                        <h3 className="font-semibold">{prompt.title}</h3>
+                        <p className="text-muted-foreground text-sm mt-1">{prompt.description}</p>
+                        {(isLoading || isGenerating) && (
+                          <p className="text-blue-500 text-sm mt-2">Generating in dashboard...</p>
+                        )}
+                        {isStarted && !isGenerating && (
+                          <p className="text-green-500 text-sm mt-2">
+                            Already generated - check dashboard
+                          </p>
+                        )}
+                      </div>
+                    </div>
+                  </CardContent>
+                </Card>
+              );
+            })}
+        </div>
+      </div>
+    </div>
+  );
+}

apps/ui/src/components/views/ideation-view/index.tsx

@@ -0,0 +1,211 @@
+/**
+ * IdeationView - Main view for brainstorming and idea management
+ * Dashboard-first design with Generate Ideas flow
+ */
+
+import { useCallback } from 'react';
+import { useIdeationStore } from '@/store/ideation-store';
+import { useAppStore } from '@/store/app-store';
+import { PromptCategoryGrid } from './components/prompt-category-grid';
+import { PromptList } from './components/prompt-list';
+import { IdeationDashboard } from './components/ideation-dashboard';
+import { useGuidedPrompts } from '@/hooks/use-guided-prompts';
+import { Button } from '@/components/ui/button';
+import { ArrowLeft, ChevronRight, Lightbulb } from 'lucide-react';
+import type { IdeaCategory } from '@automaker/types';
+import type { IdeationMode } from '@/store/ideation-store';
+
+// Breadcrumb component - compact inline breadcrumbs
+function IdeationBreadcrumbs({
+  currentMode,
+  selectedCategory,
+  onNavigate,
+}: {
+  currentMode: IdeationMode;
+  selectedCategory: IdeaCategory | null;
+  onNavigate: (mode: IdeationMode, category?: IdeaCategory | null) => void;
+}) {
+  const { getCategoryById } = useGuidedPrompts();
+  const categoryInfo = selectedCategory ? getCategoryById(selectedCategory) : null;
+
+  // On dashboard, no breadcrumbs needed (it's the root)
+  if (currentMode === 'dashboard') {
+    return null;
+  }
+
+  return (
+    <nav className="flex items-center gap-1 text-sm text-muted-foreground">
+      <button
+        onClick={() => onNavigate('dashboard')}
+        className="hover:text-foreground transition-colors"
+      >
+        Dashboard
+      </button>
+      <ChevronRight className="w-3 h-3" />
+      {selectedCategory && categoryInfo ? (
+        <>
+          <button
+            onClick={() => onNavigate('prompts', null)}
+            className="hover:text-foreground transition-colors"
+          >
+            Generate Ideas
+          </button>
+          <ChevronRight className="w-3 h-3" />
+          <span className="text-foreground">{categoryInfo.name}</span>
+        </>
+      ) : (
+        <span className="text-foreground">Generate Ideas</span>
+      )}
+    </nav>
+  );
+}
+
+// Header shown on all pages - matches other view headers
+function IdeationHeader({
+  currentMode,
+  selectedCategory,
+  onNavigate,
+  onGenerateIdeas,
+  onBack,
+}: {
+  currentMode: IdeationMode;
+  selectedCategory: IdeaCategory | null;
+  onNavigate: (mode: IdeationMode, category?: IdeaCategory | null) => void;
+  onGenerateIdeas: () => void;
+  onBack: () => void;
+}) {
+  const { getCategoryById } = useGuidedPrompts();
+  const showBackButton = currentMode === 'prompts';
+
+  // Get subtitle text based on current mode
+  const getSubtitle = (): string => {
+    if (currentMode === 'dashboard') {
+      return 'Review and accept generated ideas';
+    }
+    if (currentMode === 'prompts') {
+      if (selectedCategory) {
+        const categoryInfo = getCategoryById(selectedCategory);
+        return `Select a prompt from ${categoryInfo?.name || 'category'}`;
+      }
+      return 'Select a category to generate ideas';
+    }
+    return '';
+  };
+
+  const subtitle = getSubtitle();
+
+  return (
+    <div className="flex items-center justify-between p-4 border-b border-border bg-glass backdrop-blur-md">
+      <div className="flex items-center gap-3">
+        {showBackButton && (
+          <Button variant="ghost" size="icon" onClick={onBack}>
+            <ArrowLeft className="w-5 h-5" />
+          </Button>
+        )}
+        <div>
+          <div className="flex items-center gap-2">
+            <Lightbulb className="w-5 h-5 text-primary" />
+            <h1 className="text-xl font-bold">Ideation</h1>
+          </div>
+          {currentMode === 'dashboard' ? (
+            <p className="text-sm text-muted-foreground">{subtitle}</p>
+          ) : (
+            <IdeationBreadcrumbs
+              currentMode={currentMode}
+              selectedCategory={selectedCategory}
+              onNavigate={onNavigate}
+            />
+          )}
+        </div>
+      </div>
+
+      <div className="flex gap-2 items-center">
+        <Button onClick={onGenerateIdeas} className="gap-2">
+          <Lightbulb className="w-4 h-4" />
+          Generate Ideas
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+export function IdeationView() {
+  const currentProject = useAppStore((s) => s.currentProject);
+  const { currentMode, selectedCategory, setMode, setCategory } = useIdeationStore();
+
+  const handleNavigate = useCallback(
+    (mode: IdeationMode, category?: IdeaCategory | null) => {
+      setMode(mode);
+      if (category !== undefined) {
+        setCategory(category);
+      } else if (mode !== 'prompts') {
+        setCategory(null);
+      }
+    },
+    [setMode, setCategory]
+  );
+
+  const handleSelectCategory = useCallback(
+    (category: IdeaCategory) => {
+      setCategory(category);
+    },
+    [setCategory]
+  );
+
+  const handleBackFromPrompts = useCallback(() => {
+    // If viewing a category, go back to category grid
+    if (selectedCategory) {
+      setCategory(null);
+      return;
+    }
+    // Otherwise, go back to dashboard
+    setMode('dashboard');
+  }, [selectedCategory, setCategory, setMode]);
+
+  const handleGenerateIdeas = useCallback(() => {
+    setMode('prompts');
+    setCategory(null);
+  }, [setMode, setCategory]);
+
+  if (!currentProject) {
+    return (
+      <div
+        className="flex-1 flex items-center justify-center content-bg"
+        data-testid="ideation-view"
+      >
+        <div className="text-center text-muted-foreground">
+          <p>Open a project to start brainstorming ideas</p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      className="flex-1 flex flex-col content-bg min-h-0 overflow-hidden"
+      data-testid="ideation-view"
+    >
+      {/* Header with breadcrumbs - always shown */}
+      <IdeationHeader
+        currentMode={currentMode}
+        selectedCategory={selectedCategory}
+        onNavigate={handleNavigate}
+        onGenerateIdeas={handleGenerateIdeas}
+        onBack={handleBackFromPrompts}
+      />
+
+      {/* Dashboard - main view */}
+      {currentMode === 'dashboard' && <IdeationDashboard onGenerateIdeas={handleGenerateIdeas} />}
+
+      {/* Prompts - category selection */}
+      {currentMode === 'prompts' && !selectedCategory && (
+        <PromptCategoryGrid onSelect={handleSelectCategory} onBack={handleBackFromPrompts} />
+      )}
+
+      {/* Prompts - prompt selection within category */}
+      {currentMode === 'prompts' && selectedCategory && (
+        <PromptList category={selectedCategory} onBack={handleBackFromPrompts} />
+      )}
+    </div>
+  );
+}

apps/ui/src/components/views/settings-view/mcp-servers/components/index.ts

@@ -1,4 +1,3 @@
 export { MCPServerHeader } from './mcp-server-header';
-export { MCPPermissionSettings } from './mcp-permission-settings';
 export { MCPToolsWarning } from './mcp-tools-warning';
 export { MCPServerCard } from './mcp-server-card';

apps/ui/src/components/views/settings-view/mcp-servers/components/mcp-permission-settings.tsx

@@ -1,96 +0,0 @@
-import { ShieldAlert } from 'lucide-react';
-import { Label } from '@/components/ui/label';
-import { Switch } from '@/components/ui/switch';
-import { syncSettingsToServer } from '@/hooks/use-settings-migration';
-import { cn } from '@/lib/utils';
-
-interface MCPPermissionSettingsProps {
-  mcpAutoApproveTools: boolean;
-  mcpUnrestrictedTools: boolean;
-  onAutoApproveChange: (checked: boolean) => void;
-  onUnrestrictedChange: (checked: boolean) => void;
-}
-
-export function MCPPermissionSettings({
-  mcpAutoApproveTools,
-  mcpUnrestrictedTools,
-  onAutoApproveChange,
-  onUnrestrictedChange,
-}: MCPPermissionSettingsProps) {
-  const hasAnyEnabled = mcpAutoApproveTools || mcpUnrestrictedTools;
-
-  return (
-    <div className="px-6 py-4 border-b border-border/50 bg-muted/20">
-      <div className="space-y-4">
-        <div className="flex items-start gap-3">
-          <Switch
-            id="mcp-auto-approve"
-            checked={mcpAutoApproveTools}
-            onCheckedChange={async (checked) => {
-              onAutoApproveChange(checked);
-              await syncSettingsToServer();
-            }}
-            data-testid="mcp-auto-approve-toggle"
-            className="mt-0.5"
-          />
-          <div className="space-y-1 flex-1">
-            <Label htmlFor="mcp-auto-approve" className="text-sm font-medium cursor-pointer">
-              Auto-approve MCP tool calls
-            </Label>
-            <p className="text-xs text-muted-foreground">
-              When enabled, the AI agent can use MCP tools without permission prompts.
-            </p>
-            {mcpAutoApproveTools && (
-              <p className="text-xs text-amber-600 flex items-center gap-1 mt-1">
-                <ShieldAlert className="h-3 w-3" />
-                Bypasses normal permission checks
-              </p>
-            )}
-          </div>
-        </div>
-
-        <div className="flex items-start gap-3">
-          <Switch
-            id="mcp-unrestricted"
-            checked={mcpUnrestrictedTools}
-            onCheckedChange={async (checked) => {
-              onUnrestrictedChange(checked);
-              await syncSettingsToServer();
-            }}
-            data-testid="mcp-unrestricted-toggle"
-            className="mt-0.5"
-          />
-          <div className="space-y-1 flex-1">
-            <Label htmlFor="mcp-unrestricted" className="text-sm font-medium cursor-pointer">
-              Unrestricted tool access
-            </Label>
-            <p className="text-xs text-muted-foreground">
-              When enabled, the AI agent can use any tool, not just the default set.
-            </p>
-            {mcpUnrestrictedTools && (
-              <p className="text-xs text-amber-600 flex items-center gap-1 mt-1">
-                <ShieldAlert className="h-3 w-3" />
-                Agent has full tool access including file writes and bash
-              </p>
-            )}
-          </div>
-        </div>
-
-        {hasAnyEnabled && (
-          <div
-            className={cn(
-              'rounded-md border border-amber-500/30 bg-amber-500/10 p-3 mt-2',
-              'text-xs text-amber-700 dark:text-amber-400'
-            )}
-          >
-            <p className="font-medium mb-1">Security Note</p>
-            <p>
-              These settings reduce security restrictions for MCP tool usage. Only enable if you
-              trust all configured MCP servers.
-            </p>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

apps/ui/src/components/views/settings-view/mcp-servers/hooks/use-mcp-servers.ts

@@ -21,16 +21,7 @@ interface PendingServerData {
 }
 
 export function useMCPServers() {
-  const {
-    mcpServers,
-    addMCPServer,
-    updateMCPServer,
-    removeMCPServer,
-    mcpAutoApproveTools,
-    mcpUnrestrictedTools,
-    setMcpAutoApproveTools,
-    setMcpUnrestrictedTools,
-  } = useAppStore();
+  const { mcpServers, addMCPServer, updateMCPServer, removeMCPServer } = useAppStore();
 
   // State
   const [isAddDialogOpen, setIsAddDialogOpen] = useState(false);
@@ -938,10 +929,6 @@ export function useMCPServers() {
   return {
     // Store state
     mcpServers,
-    mcpAutoApproveTools,
-    mcpUnrestrictedTools,
-    setMcpAutoApproveTools,
-    setMcpUnrestrictedTools,
 
     // Dialog state
     isAddDialogOpen,

apps/ui/src/components/views/settings-view/mcp-servers/mcp-servers-section.tsx

@@ -1,12 +1,7 @@
 import { Plug } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useMCPServers } from './hooks';
-import {
-  MCPServerHeader,
-  MCPPermissionSettings,
-  MCPToolsWarning,
-  MCPServerCard,
-} from './components';
+import { MCPServerHeader, MCPToolsWarning, MCPServerCard } from './components';
 import {
   AddEditServerDialog,
   DeleteServerDialog,
@@ -20,10 +15,6 @@ export function MCPServersSection() {
   const {
     // Store state
     mcpServers,
-    mcpAutoApproveTools,
-    mcpUnrestrictedTools,
-    setMcpAutoApproveTools,
-    setMcpUnrestrictedTools,
 
     // Dialog state
     isAddDialogOpen,
@@ -98,15 +89,6 @@ export function MCPServersSection() {
         onAdd={handleOpenAddDialog}
       />
 
-      {mcpServers.length > 0 && (
-        <MCPPermissionSettings
-          mcpAutoApproveTools={mcpAutoApproveTools}
-          mcpUnrestrictedTools={mcpUnrestrictedTools}
-          onAutoApproveChange={setMcpAutoApproveTools}
-          onUnrestrictedChange={setMcpUnrestrictedTools}
-        />
-      )}
-
       {showToolsWarning && <MCPToolsWarning totalTools={totalToolsCount} />}
 
       <div className="p-6">

apps/ui/src/hooks/index.ts

@@ -1,6 +1,7 @@
 export { useAutoMode } from './use-auto-mode';
 export { useBoardBackgroundSettings } from './use-board-background-settings';
 export { useElectronAgent } from './use-electron-agent';
+export { useGuidedPrompts } from './use-guided-prompts';
 export { useKeyboardShortcuts } from './use-keyboard-shortcuts';
 export { useMessageQueue } from './use-message-queue';
 export { useOSDetection, type OperatingSystem, type OSDetectionResult } from './use-os-detection';

apps/ui/src/hooks/use-guided-prompts.ts

@@ -0,0 +1,86 @@
+/**
+ * Hook for fetching guided prompts from the backend API
+ *
+ * This hook provides the single source of truth for guided prompts,
+ * fetched from the backend /api/ideation/prompts endpoint.
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import type { IdeationPrompt, PromptCategory, IdeaCategory } from '@automaker/types';
+import { getElectronAPI } from '@/lib/electron';
+
+interface UseGuidedPromptsReturn {
+  prompts: IdeationPrompt[];
+  categories: PromptCategory[];
+  isLoading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+  getPromptsByCategory: (category: IdeaCategory) => IdeationPrompt[];
+  getPromptById: (id: string) => IdeationPrompt | undefined;
+  getCategoryById: (id: IdeaCategory) => PromptCategory | undefined;
+}
+
+export function useGuidedPrompts(): UseGuidedPromptsReturn {
+  const [prompts, setPrompts] = useState<IdeationPrompt[]>([]);
+  const [categories, setCategories] = useState<PromptCategory[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchPrompts = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const api = getElectronAPI();
+      const result = await api.ideation?.getPrompts();
+
+      if (result?.success) {
+        setPrompts(result.prompts || []);
+        setCategories(result.categories || []);
+      } else {
+        setError(result?.error || 'Failed to fetch prompts');
+      }
+    } catch (err) {
+      console.error('Failed to fetch guided prompts:', err);
+      setError(err instanceof Error ? err.message : 'Failed to fetch prompts');
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchPrompts();
+  }, [fetchPrompts]);
+
+  const getPromptsByCategory = useCallback(
+    (category: IdeaCategory): IdeationPrompt[] => {
+      return prompts.filter((p) => p.category === category);
+    },
+    [prompts]
+  );
+
+  const getPromptById = useCallback(
+    (id: string): IdeationPrompt | undefined => {
+      return prompts.find((p) => p.id === id);
+    },
+    [prompts]
+  );
+
+  const getCategoryById = useCallback(
+    (id: IdeaCategory): PromptCategory | undefined => {
+      return categories.find((c) => c.id === id);
+    },
+    [categories]
+  );
+
+  return {
+    prompts,
+    categories,
+    isLoading,
+    error,
+    refetch: fetchPrompts,
+    getPromptsByCategory,
+    getPromptById,
+    getCategoryById,
+  };
+}

apps/ui/src/hooks/use-keyboard-shortcuts.ts

@@ -1,5 +1,5 @@
-import { useEffect, useCallback } from 'react';
-import { useAppStore, parseShortcut } from '@/store/app-store';
+import { useEffect, useCallback, useMemo } from 'react';
+import { useAppStore, parseShortcut, DEFAULT_KEYBOARD_SHORTCUTS } from '@/store/app-store';
 
 export interface KeyboardShortcut {
   key: string; // Can be simple "K" or with modifiers "Shift+N", "Cmd+K"
@@ -237,8 +237,18 @@ export function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]) {
 /**
  * Hook to get current keyboard shortcuts from store
  * This replaces the static constants and allows customization
+ * Merges with defaults to ensure new shortcuts are always available
  */
 export function useKeyboardShortcutsConfig() {
   const keyboardShortcuts = useAppStore((state) => state.keyboardShortcuts);
-  return keyboardShortcuts;
+
+  // Merge with defaults to ensure new shortcuts are available
+  // even if user's persisted state predates them
+  return useMemo(
+    () => ({
+      ...DEFAULT_KEYBOARD_SHORTCUTS,
+      ...keyboardShortcuts,
+    }),
+    [keyboardShortcuts]
+  );
 }

apps/ui/src/hooks/use-settings-migration.ts

@@ -230,8 +230,6 @@ export async function syncSettingsToServer(): Promise<boolean> {
       keyboardShortcuts: state.keyboardShortcuts,
       aiProfiles: state.aiProfiles,
       mcpServers: state.mcpServers,
-      mcpAutoApproveTools: state.mcpAutoApproveTools,
-      mcpUnrestrictedTools: state.mcpUnrestrictedTools,
       promptCustomization: state.promptCustomization,
       projects: state.projects,
       trashedProjects: state.trashedProjects,
@@ -336,12 +334,10 @@ export async function loadMCPServersFromServer(): Promise<boolean> {
     }
 
     const mcpServers = result.settings.mcpServers || [];
-    const mcpAutoApproveTools = result.settings.mcpAutoApproveTools ?? true;
-    const mcpUnrestrictedTools = result.settings.mcpUnrestrictedTools ?? true;
 
     // Clear existing and add all from server
     // We need to update the store directly since we can't use hooks here
-    useAppStore.setState({ mcpServers, mcpAutoApproveTools, mcpUnrestrictedTools });
+    useAppStore.setState({ mcpServers });
 
     console.log(`[Settings Load] Loaded ${mcpServers.length} MCP servers from server`);
     return true;

apps/ui/src/lib/electron.ts

@@ -13,6 +13,18 @@ import type {
   AgentModel,
   GitHubComment,
   IssueCommentsResult,
+  Idea,
+  IdeaCategory,
+  IdeationSession,
+  IdeationMessage,
+  IdeationPrompt,
+  PromptCategory,
+  ProjectAnalysisResult,
+  AnalysisSuggestion,
+  StartSessionOptions,
+  CreateIdeaInput,
+  UpdateIdeaInput,
+  ConvertToFeatureOptions,
 } from '@automaker/types';
 import { getJSON, setJSON, removeItem } from './storage';
 
@@ -30,6 +42,104 @@ export type {
   IssueCommentsResult,
 };
 
+// Re-export ideation types
+export type {
+  Idea,
+  IdeaCategory,
+  IdeationSession,
+  IdeationMessage,
+  IdeationPrompt,
+  PromptCategory,
+  ProjectAnalysisResult,
+  AnalysisSuggestion,
+  StartSessionOptions,
+  CreateIdeaInput,
+  UpdateIdeaInput,
+  ConvertToFeatureOptions,
+};
+
+// Ideation API interface
+export interface IdeationAPI {
+  // Session management
+  startSession: (
+    projectPath: string,
+    options?: StartSessionOptions
+  ) => Promise<{ success: boolean; session?: IdeationSession; error?: string }>;
+  getSession: (
+    projectPath: string,
+    sessionId: string
+  ) => Promise<{
+    success: boolean;
+    session?: IdeationSession;
+    messages?: IdeationMessage[];
+    error?: string;
+  }>;
+  sendMessage: (
+    sessionId: string,
+    message: string,
+    options?: { imagePaths?: string[]; model?: string }
+  ) => Promise<{ success: boolean; error?: string }>;
+  stopSession: (sessionId: string) => Promise<{ success: boolean; error?: string }>;
+
+  // Ideas CRUD
+  listIdeas: (projectPath: string) => Promise<{ success: boolean; ideas?: Idea[]; error?: string }>;
+  createIdea: (
+    projectPath: string,
+    idea: CreateIdeaInput
+  ) => Promise<{ success: boolean; idea?: Idea; error?: string }>;
+  getIdea: (
+    projectPath: string,
+    ideaId: string
+  ) => Promise<{ success: boolean; idea?: Idea; error?: string }>;
+  updateIdea: (
+    projectPath: string,
+    ideaId: string,
+    updates: UpdateIdeaInput
+  ) => Promise<{ success: boolean; idea?: Idea; error?: string }>;
+  deleteIdea: (
+    projectPath: string,
+    ideaId: string
+  ) => Promise<{ success: boolean; error?: string }>;
+
+  // Project analysis
+  analyzeProject: (
+    projectPath: string
+  ) => Promise<{ success: boolean; analysis?: ProjectAnalysisResult; error?: string }>;
+
+  // Generate suggestions from a prompt
+  generateSuggestions: (
+    projectPath: string,
+    promptId: string,
+    category: IdeaCategory,
+    count?: number
+  ) => Promise<{ success: boolean; suggestions?: AnalysisSuggestion[]; error?: string }>;
+
+  // Convert to feature
+  convertToFeature: (
+    projectPath: string,
+    ideaId: string,
+    options?: ConvertToFeatureOptions
+  ) => Promise<{ success: boolean; feature?: any; featureId?: string; error?: string }>;
+
+  // Add suggestion directly to board as feature
+  addSuggestionToBoard: (
+    projectPath: string,
+    suggestion: AnalysisSuggestion
+  ) => Promise<{ success: boolean; featureId?: string; error?: string }>;
+
+  // Get guided prompts (single source of truth from backend)
+  getPrompts: () => Promise<{
+    success: boolean;
+    prompts?: IdeationPrompt[];
+    categories?: PromptCategory[];
+    error?: string;
+  }>;
+
+  // Event subscriptions
+  onStream: (callback: (event: any) => void) => () => void;
+  onAnalysisEvent: (callback: (event: any) => void) => () => void;
+}
+
 export interface FileEntry {
   name: string;
   isDirectory: boolean;
@@ -647,6 +757,7 @@ export interface ElectronAPI {
       error?: string;
     }>;
   };
+  ideation?: IdeationAPI;
 }
 
 // Note: Window interface is declared in @/types/electron.d.ts

apps/ui/src/lib/http-api-client.ts

@@ -26,6 +26,13 @@ import type {
   GitHubPR,
   IssueValidationInput,
   IssueValidationEvent,
+  IdeationAPI,
+  IdeaCategory,
+  AnalysisSuggestion,
+  StartSessionOptions,
+  CreateIdeaInput,
+  UpdateIdeaInput,
+  ConvertToFeatureOptions,
 } from './electron';
 import type { Message, SessionListItem } from '@/types/electron';
 import type { Feature, ClaudeUsageResponse } from '@/store/app-store';
@@ -368,7 +375,9 @@ type EventType =
   | 'suggestions:event'
   | 'spec-regeneration:event'
   | 'issue-validation:event'
-  | 'backlog-plan:event';
+  | 'backlog-plan:event'
+  | 'ideation:stream'
+  | 'ideation:analysis';
 
 type EventCallback = (payload: unknown) => void;
 
@@ -1438,8 +1447,6 @@ export class HttpApiClient implements ElectronAPI {
           headers?: Record<string, string>;
           enabled?: boolean;
         }>;
-        mcpAutoApproveTools?: boolean;
-        mcpUnrestrictedTools?: boolean;
       };
       error?: string;
     }> => this.get('/api/settings/global'),
@@ -1640,6 +1647,66 @@ export class HttpApiClient implements ElectronAPI {
     },
   };
 
+  // Ideation API - brainstorming and idea management
+  ideation: IdeationAPI = {
+    startSession: (projectPath: string, options?: StartSessionOptions) =>
+      this.post('/api/ideation/session/start', { projectPath, options }),
+
+    getSession: (projectPath: string, sessionId: string) =>
+      this.post('/api/ideation/session/get', { projectPath, sessionId }),
+
+    sendMessage: (
+      sessionId: string,
+      message: string,
+      options?: { imagePaths?: string[]; model?: string }
+    ) => this.post('/api/ideation/session/message', { sessionId, message, options }),
+
+    stopSession: (sessionId: string) => this.post('/api/ideation/session/stop', { sessionId }),
+
+    listIdeas: (projectPath: string) => this.post('/api/ideation/ideas/list', { projectPath }),
+
+    createIdea: (projectPath: string, idea: CreateIdeaInput) =>
+      this.post('/api/ideation/ideas/create', { projectPath, idea }),
+
+    getIdea: (projectPath: string, ideaId: string) =>
+      this.post('/api/ideation/ideas/get', { projectPath, ideaId }),
+
+    updateIdea: (projectPath: string, ideaId: string, updates: UpdateIdeaInput) =>
+      this.post('/api/ideation/ideas/update', { projectPath, ideaId, updates }),
+
+    deleteIdea: (projectPath: string, ideaId: string) =>
+      this.post('/api/ideation/ideas/delete', { projectPath, ideaId }),
+
+    analyzeProject: (projectPath: string) => this.post('/api/ideation/analyze', { projectPath }),
+
+    generateSuggestions: (
+      projectPath: string,
+      promptId: string,
+      category: IdeaCategory,
+      count?: number
+    ) =>
+      this.post('/api/ideation/suggestions/generate', { projectPath, promptId, category, count }),
+
+    convertToFeature: (projectPath: string, ideaId: string, options?: ConvertToFeatureOptions) =>
+      this.post('/api/ideation/convert', { projectPath, ideaId, ...options }),
+
+    addSuggestionToBoard: (
+      projectPath: string,
+      suggestion: AnalysisSuggestion
+    ): Promise<{ success: boolean; featureId?: string; error?: string }> =>
+      this.post('/api/ideation/add-suggestion', { projectPath, suggestion }),
+
+    getPrompts: () => this.get('/api/ideation/prompts'),
+
+    onStream: (callback: (event: any) => void): (() => void) => {
+      return this.subscribeToEvent('ideation:stream', callback as EventCallback);
+    },
+
+    onAnalysisEvent: (callback: (event: any) => void): (() => void) => {
+      return this.subscribeToEvent('ideation:analysis', callback as EventCallback);
+    },
+  };
+
   // MCP API - Test MCP server connections and list tools
   // SECURITY: Only accepts serverId, not arbitrary serverConfig, to prevent
   // drive-by command execution attacks. Servers must be saved first.

apps/ui/src/routes/ideation.tsx

@@ -0,0 +1,6 @@
+import { createFileRoute } from '@tanstack/react-router';
+import { IdeationView } from '@/components/views/ideation-view';
+
+export const Route = createFileRoute('/ideation')({
+  component: IdeationView,
+});

apps/ui/src/store/app-store.ts

@@ -29,7 +29,8 @@ export type ViewMode =
   | 'profiles'
   | 'running-agents'
   | 'terminal'
-  | 'wiki';
+  | 'wiki'
+  | 'ideation';
 
 export type ThemeMode =
   | 'light'
@@ -154,6 +155,9 @@ export interface KeyboardShortcuts {
   settings: string;
   profiles: string;
   terminal: string;
+  ideation: string;
+  githubIssues: string;
+  githubPrs: string;
 
   // UI shortcuts
   toggleSidebar: string;
@@ -186,6 +190,9 @@ export const DEFAULT_KEYBOARD_SHORTCUTS: KeyboardShortcuts = {
   settings: 'S',
   profiles: 'M',
   terminal: 'T',
+  ideation: 'I',
+  githubIssues: 'G',
+  githubPrs: 'R',
 
   // UI
   toggleSidebar: '`',
@@ -491,8 +498,6 @@ export interface AppState {
 
   // MCP Servers
   mcpServers: MCPServerConfig[]; // List of configured MCP servers for agent use
-  mcpAutoApproveTools: boolean; // Auto-approve MCP tool calls without permission prompts
-  mcpUnrestrictedTools: boolean; // Allow unrestricted tools when MCP servers are enabled
 
   // Prompt Customization
   promptCustomization: PromptCustomization; // Custom prompts for Auto Mode, Agent, Backlog Plan, Enhancement
@@ -777,8 +782,6 @@ export interface AppActions {
   setAutoLoadClaudeMd: (enabled: boolean) => Promise<void>;
   setEnableSandboxMode: (enabled: boolean) => Promise<void>;
   setSkipSandboxWarning: (skip: boolean) => Promise<void>;
-  setMcpAutoApproveTools: (enabled: boolean) => Promise<void>;
-  setMcpUnrestrictedTools: (enabled: boolean) => Promise<void>;
 
   // Prompt Customization actions
   setPromptCustomization: (customization: PromptCustomization) => Promise<void>;
@@ -980,8 +983,6 @@ const initialState: AppState = {
   enableSandboxMode: false, // Default to disabled (can be enabled for additional security)
   skipSandboxWarning: false, // Default to disabled (show sandbox warning dialog)
   mcpServers: [], // No MCP servers configured by default
-  mcpAutoApproveTools: true, // Default to enabled - bypass permission prompts for MCP tools
-  mcpUnrestrictedTools: true, // Default to enabled - don't filter allowedTools when MCP enabled
   promptCustomization: {}, // Empty by default - all prompts use built-in defaults
   aiProfiles: DEFAULT_AI_PROFILES,
   projectAnalysis: null,
@@ -1632,19 +1633,6 @@ export const useAppStore = create<AppState & AppActions>()(
         const { syncSettingsToServer } = await import('@/hooks/use-settings-migration');
         await syncSettingsToServer();
       },
-      setMcpAutoApproveTools: async (enabled) => {
-        set({ mcpAutoApproveTools: enabled });
-        // Sync to server settings file
-        const { syncSettingsToServer } = await import('@/hooks/use-settings-migration');
-        await syncSettingsToServer();
-      },
-      setMcpUnrestrictedTools: async (enabled) => {
-        set({ mcpUnrestrictedTools: enabled });
-        // Sync to server settings file
-        const { syncSettingsToServer } = await import('@/hooks/use-settings-migration');
-        await syncSettingsToServer();
-      },
-
       // Prompt Customization actions
       setPromptCustomization: async (customization) => {
         set({ promptCustomization: customization });
@@ -2933,8 +2921,6 @@ export const useAppStore = create<AppState & AppActions>()(
           skipSandboxWarning: state.skipSandboxWarning,
           // MCP settings
           mcpServers: state.mcpServers,
-          mcpAutoApproveTools: state.mcpAutoApproveTools,
-          mcpUnrestrictedTools: state.mcpUnrestrictedTools,
           // Prompt customization
           promptCustomization: state.promptCustomization,
           // Profiles and sessions

apps/ui/src/store/ideation-store.ts

@@ -0,0 +1,324 @@
+/**
+ * Ideation Store - State management for brainstorming and idea management
+ */
+
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import type {
+  Idea,
+  IdeaCategory,
+  IdeaStatus,
+  IdeationPrompt,
+  AnalysisSuggestion,
+  ProjectAnalysisResult,
+} from '@automaker/types';
+
+// ============================================================================
+// Generation Job Types
+// ============================================================================
+
+export type GenerationJobStatus = 'generating' | 'ready' | 'error';
+
+export interface GenerationJob {
+  id: string;
+  prompt: IdeationPrompt;
+  status: GenerationJobStatus;
+  suggestions: AnalysisSuggestion[];
+  error: string | null;
+  startedAt: string;
+  completedAt: string | null;
+}
+
+// ============================================================================
+// State Interface
+// ============================================================================
+
+export type IdeationMode = 'dashboard' | 'prompts';
+
+interface IdeationState {
+  // Ideas (saved for later)
+  ideas: Idea[];
+  selectedIdeaId: string | null;
+
+  // Generation jobs (multiple concurrent generations)
+  generationJobs: GenerationJob[];
+  selectedJobId: string | null;
+
+  // Legacy - keep for backwards compat during transition
+  suggestions: AnalysisSuggestion[];
+  selectedPrompt: IdeationPrompt | null;
+  isGenerating: boolean;
+  generatingError: string | null;
+
+  // Analysis
+  analysisResult: ProjectAnalysisResult | null;
+  isAnalyzing: boolean;
+  analysisProgress: number;
+  analysisMessage: string;
+
+  // UI state
+  currentMode: IdeationMode;
+  selectedCategory: IdeaCategory | null;
+  filterStatus: IdeaStatus | 'all';
+}
+
+// ============================================================================
+// Actions Interface
+// ============================================================================
+
+interface IdeationActions {
+  // Ideas
+  setIdeas: (ideas: Idea[]) => void;
+  addIdea: (idea: Idea) => void;
+  updateIdea: (id: string, updates: Partial<Idea>) => void;
+  removeIdea: (id: string) => void;
+  setSelectedIdea: (id: string | null) => void;
+  getSelectedIdea: () => Idea | null;
+
+  // Generation Jobs
+  addGenerationJob: (prompt: IdeationPrompt) => string;
+  updateJobStatus: (
+    jobId: string,
+    status: GenerationJobStatus,
+    suggestions?: AnalysisSuggestion[],
+    error?: string
+  ) => void;
+  removeJob: (jobId: string) => void;
+  clearCompletedJobs: () => void;
+  setSelectedJob: (jobId: string | null) => void;
+  getJob: (jobId: string) => GenerationJob | null;
+  removeSuggestionFromJob: (jobId: string, suggestionId: string) => void;
+  appendSuggestionsToJob: (jobId: string, suggestions: AnalysisSuggestion[]) => void;
+  setJobGenerating: (jobId: string, generating: boolean) => void;
+
+  // Legacy Suggestions (kept for backwards compat)
+  setSuggestions: (suggestions: AnalysisSuggestion[]) => void;
+  clearSuggestions: () => void;
+  removeSuggestion: (id: string) => void;
+  setSelectedPrompt: (prompt: IdeationPrompt | null) => void;
+  setIsGenerating: (isGenerating: boolean) => void;
+  setGeneratingError: (error: string | null) => void;
+
+  // Analysis
+  setAnalysisResult: (result: ProjectAnalysisResult | null) => void;
+  setIsAnalyzing: (isAnalyzing: boolean) => void;
+  setAnalysisProgress: (progress: number, message?: string) => void;
+
+  // UI
+  setMode: (mode: IdeationMode) => void;
+  setCategory: (category: IdeaCategory | null) => void;
+  setFilterStatus: (status: IdeaStatus | 'all') => void;
+
+  // Reset
+  reset: () => void;
+  resetSuggestions: () => void;
+}
+
+// ============================================================================
+// Initial State
+// ============================================================================
+
+const initialState: IdeationState = {
+  ideas: [],
+  selectedIdeaId: null,
+  generationJobs: [],
+  selectedJobId: null,
+  suggestions: [],
+  selectedPrompt: null,
+  isGenerating: false,
+  generatingError: null,
+  analysisResult: null,
+  isAnalyzing: false,
+  analysisProgress: 0,
+  analysisMessage: '',
+  currentMode: 'dashboard',
+  selectedCategory: null,
+  filterStatus: 'all',
+};
+
+// ============================================================================
+// Store
+// ============================================================================
+
+export const useIdeationStore = create<IdeationState & IdeationActions>()(
+  persist(
+    (set, get) => ({
+      ...initialState,
+
+      // Ideas
+      setIdeas: (ideas) => set({ ideas }),
+
+      addIdea: (idea) =>
+        set((state) => ({
+          ideas: [idea, ...state.ideas],
+        })),
+
+      updateIdea: (id, updates) =>
+        set((state) => ({
+          ideas: state.ideas.map((idea) => (idea.id === id ? { ...idea, ...updates } : idea)),
+        })),
+
+      removeIdea: (id) =>
+        set((state) => ({
+          ideas: state.ideas.filter((idea) => idea.id !== id),
+          selectedIdeaId: state.selectedIdeaId === id ? null : state.selectedIdeaId,
+        })),
+
+      setSelectedIdea: (id) => set({ selectedIdeaId: id }),
+
+      getSelectedIdea: () => {
+        const state = get();
+        return state.ideas.find((idea) => idea.id === state.selectedIdeaId) || null;
+      },
+
+      // Generation Jobs
+      addGenerationJob: (prompt) => {
+        const jobId = `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const job: GenerationJob = {
+          id: jobId,
+          prompt,
+          status: 'generating',
+          suggestions: [],
+          error: null,
+          startedAt: new Date().toISOString(),
+          completedAt: null,
+        };
+        set((state) => ({
+          generationJobs: [job, ...state.generationJobs],
+        }));
+        return jobId;
+      },
+
+      updateJobStatus: (jobId, status, suggestions, error) =>
+        set((state) => ({
+          generationJobs: state.generationJobs.map((job) =>
+            job.id === jobId
+              ? {
+                  ...job,
+                  status,
+                  suggestions: suggestions || job.suggestions,
+                  error: error || null,
+                  completedAt: status !== 'generating' ? new Date().toISOString() : null,
+                }
+              : job
+          ),
+        })),
+
+      removeJob: (jobId) =>
+        set((state) => ({
+          generationJobs: state.generationJobs.filter((job) => job.id !== jobId),
+          selectedJobId: state.selectedJobId === jobId ? null : state.selectedJobId,
+        })),
+
+      clearCompletedJobs: () =>
+        set((state) => ({
+          generationJobs: state.generationJobs.filter((job) => job.status === 'generating'),
+        })),
+
+      setSelectedJob: (jobId) => set({ selectedJobId: jobId }),
+
+      getJob: (jobId) => {
+        const state = get();
+        return state.generationJobs.find((job) => job.id === jobId) || null;
+      },
+
+      removeSuggestionFromJob: (jobId, suggestionId) =>
+        set((state) => ({
+          generationJobs: state.generationJobs.map((job) =>
+            job.id === jobId
+              ? {
+                  ...job,
+                  suggestions: job.suggestions.filter((s) => s.id !== suggestionId),
+                }
+              : job
+          ),
+        })),
+
+      appendSuggestionsToJob: (jobId, suggestions) =>
+        set((state) => ({
+          generationJobs: state.generationJobs.map((job) =>
+            job.id === jobId
+              ? {
+                  ...job,
+                  suggestions: [...job.suggestions, ...suggestions],
+                  status: 'ready' as const,
+                }
+              : job
+          ),
+        })),
+
+      setJobGenerating: (jobId, generating) =>
+        set((state) => ({
+          generationJobs: state.generationJobs.map((job) =>
+            job.id === jobId
+              ? {
+                  ...job,
+                  status: generating ? ('generating' as const) : ('ready' as const),
+                }
+              : job
+          ),
+        })),
+
+      // Suggestions (legacy)
+      setSuggestions: (suggestions) => set({ suggestions }),
+
+      clearSuggestions: () => set({ suggestions: [], generatingError: null }),
+
+      removeSuggestion: (id) =>
+        set((state) => ({
+          suggestions: state.suggestions.filter((s) => s.id !== id),
+        })),
+
+      setSelectedPrompt: (prompt) => set({ selectedPrompt: prompt }),
+
+      setIsGenerating: (isGenerating) => set({ isGenerating }),
+
+      setGeneratingError: (error) => set({ generatingError: error }),
+
+      // Analysis
+      setAnalysisResult: (result) => set({ analysisResult: result }),
+
+      setIsAnalyzing: (isAnalyzing) =>
+        set({
+          isAnalyzing,
+          analysisProgress: isAnalyzing ? 0 : get().analysisProgress,
+          analysisMessage: isAnalyzing ? 'Starting analysis...' : '',
+        }),
+
+      setAnalysisProgress: (progress, message) =>
+        set({
+          analysisProgress: progress,
+          analysisMessage: message || get().analysisMessage,
+        }),
+
+      // UI
+      setMode: (mode) => set({ currentMode: mode }),
+
+      setCategory: (category) => set({ selectedCategory: category }),
+
+      setFilterStatus: (status) => set({ filterStatus: status }),
+
+      // Reset
+      reset: () => set(initialState),
+
+      resetSuggestions: () =>
+        set({
+          suggestions: [],
+          selectedPrompt: null,
+          isGenerating: false,
+          generatingError: null,
+        }),
+    }),
+    {
+      name: 'automaker-ideation-store',
+      version: 3,
+      partialize: (state) => ({
+        // Only persist these fields
+        ideas: state.ideas,
+        generationJobs: state.generationJobs,
+        analysisResult: state.analysisResult,
+        filterStatus: state.filterStatus,
+      }),
+    }
+  )
+);

dev.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Automaker - Development Mode Launch Script
+ *
+ * This script starts the application in development mode with hot reloading.
+ * It uses Vite dev server for fast HMR during development.
+ *
+ * Usage: npm run dev
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+import {
+  createRestrictedFs,
+  log,
+  runNpm,
+  runNpmAndWait,
+  printHeader,
+  printModeMenu,
+  resolvePortConfiguration,
+  createCleanupHandler,
+  setupSignalHandlers,
+  startServerAndWait,
+  ensureDependencies,
+  prompt,
+} from './scripts/launcher-utils.mjs';
+
+const require = createRequire(import.meta.url);
+const crossSpawn = require('cross-spawn');
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create restricted fs for this script's directory
+const fs = createRestrictedFs(__dirname, 'dev.mjs');
+
+// Track background processes for cleanup
+const processes = {
+  server: null,
+  web: null,
+  electron: null,
+  docker: null,
+};
+
+/**
+ * Install Playwright browsers (dev-only dependency)
+ */
+async function installPlaywrightBrowsers() {
+  log('Checking Playwright browsers...', 'yellow');
+  try {
+    const exitCode = await new Promise((resolve) => {
+      const playwright = crossSpawn('npx', ['playwright', 'install', 'chromium'], {
+        stdio: 'inherit',
+        cwd: path.join(__dirname, 'apps', 'ui'),
+      });
+      playwright.on('close', (code) => resolve(code));
+      playwright.on('error', () => resolve(1));
+    });
+
+    if (exitCode === 0) {
+      log('Playwright browsers ready', 'green');
+    } else {
+      log('Playwright installation failed (browser automation may not work)', 'yellow');
+    }
+  } catch {
+    log('Playwright installation skipped', 'yellow');
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  // Change to script directory
+  process.chdir(__dirname);
+
+  printHeader('Automaker Development Environment');
+
+  // Ensure dependencies are installed
+  await ensureDependencies(fs, __dirname);
+
+  // Install Playwright browsers (dev-only)
+  await installPlaywrightBrowsers();
+
+  // Resolve port configuration (check/kill/change ports)
+  const { webPort, serverPort, corsOriginEnv } = await resolvePortConfiguration();
+
+  // Show mode selection menu
+  printModeMenu();
+
+  // Setup cleanup handlers
+  const cleanup = createCleanupHandler(processes);
+  setupSignalHandlers(cleanup);
+
+  // Prompt for choice
+  while (true) {
+    const choice = await prompt('Enter your choice (1, 2, or 3): ');
+
+    if (choice === '1') {
+      console.log('');
+      log('Launching Web Application (Development Mode)...', 'blue');
+
+      // Build shared packages once
+      log('Building shared packages...', 'blue');
+      await runNpmAndWait(['run', 'build:packages'], { stdio: 'inherit' }, __dirname);
+
+      // Start the backend server in dev mode
+      processes.server = await startServerAndWait({
+        serverPort,
+        corsOriginEnv,
+        npmArgs: ['run', '_dev:server'],
+        cwd: __dirname,
+        fs,
+        baseDir: __dirname,
+      });
+
+      if (!processes.server) {
+        await cleanup();
+        process.exit(1);
+      }
+
+      log(`The application will be available at: http://localhost:${webPort}`, 'green');
+      console.log('');
+
+      // Start web app with Vite dev server (HMR enabled)
+      processes.web = runNpm(
+        ['run', '_dev:web'],
+        {
+          stdio: 'inherit',
+          env: {
+            TEST_PORT: String(webPort),
+            VITE_SERVER_URL: `http://localhost:${serverPort}`,
+          },
+        },
+        __dirname
+      );
+
+      await new Promise((resolve) => {
+        processes.web.on('close', resolve);
+      });
+
+      break;
+    } else if (choice === '2') {
+      console.log('');
+      log('Launching Desktop Application (Development Mode)...', 'blue');
+      log('(Electron will start its own backend server)', 'yellow');
+      console.log('');
+
+      // Pass selected ports through to Vite + Electron backend
+      processes.electron = runNpm(
+        ['run', 'dev:electron'],
+        {
+          stdio: 'inherit',
+          env: {
+            TEST_PORT: String(webPort),
+            PORT: String(serverPort),
+            VITE_SERVER_URL: `http://localhost:${serverPort}`,
+            CORS_ORIGIN: corsOriginEnv,
+          },
+        },
+        __dirname
+      );
+
+      await new Promise((resolve) => {
+        processes.electron.on('close', resolve);
+      });
+
+      break;
+    } else if (choice === '3') {
+      console.log('');
+      log('Launching Docker Container (Isolated Mode)...', 'blue');
+      log('Building and starting Docker containers...', 'yellow');
+      console.log('');
+
+      // Check if ANTHROPIC_API_KEY is set
+      if (!process.env.ANTHROPIC_API_KEY) {
+        log('Warning: ANTHROPIC_API_KEY environment variable is not set.', 'yellow');
+        log('The server will require an API key to function.', 'yellow');
+        log('Set it with: export ANTHROPIC_API_KEY=your-key', 'yellow');
+        console.log('');
+      }
+
+      // Build and start containers with docker-compose
+      processes.docker = crossSpawn('docker', ['compose', 'up', '--build'], {
+        stdio: 'inherit',
+        cwd: __dirname,
+        env: {
+          ...process.env,
+        },
+      });
+
+      log('Docker containers starting...', 'blue');
+      log('UI will be available at: http://localhost:3007', 'green');
+      log('API will be available at: http://localhost:3008', 'green');
+      console.log('');
+      log('Press Ctrl+C to stop the containers.', 'yellow');
+
+      await new Promise((resolve) => {
+        processes.docker.on('close', resolve);
+      });
+
+      break;
+    } else {
+      log('Invalid choice. Please enter 1, 2, or 3.', 'red');
+    }
+  }
+}
+
+// Run main function
+main().catch(async (err) => {
+  console.error(err);
+  const cleanup = createCleanupHandler(processes);
+  try {
+    await cleanup();
+  } catch (cleanupErr) {
+    console.error('Cleanup error:', cleanupErr);
+  }
+  process.exit(1);
+});

init.mjs

@@ -1,649 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Automaker - Cross-Platform Development Environment Setup and Launch Script
- *
- * This script works on Windows, macOS, and Linux.
- *
- * SECURITY NOTE: This script uses a restricted fs wrapper that only allows
- * operations within the script's directory (__dirname). This is a standalone
- * launch script that runs before the platform library is available.
- */
-
-import { execSync } from 'child_process';
-import fsNative from 'fs';
-import http from 'http';
-import path from 'path';
-import readline from 'readline';
-import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-const treeKill = require('tree-kill');
-const crossSpawn = require('cross-spawn');
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// =============================================================================
-// Restricted fs wrapper - only allows operations within __dirname
-// =============================================================================
-
-/**
- * Validate that a path is within the script's directory
- * @param {string} targetPath - Path to validate
- * @returns {string} - Resolved path if valid
- * @throws {Error} - If path is outside __dirname
- */
-function validateScriptPath(targetPath) {
-  const resolved = path.resolve(__dirname, targetPath);
-  const normalizedBase = path.resolve(__dirname);
-  if (!resolved.startsWith(normalizedBase + path.sep) && resolved !== normalizedBase) {
-    throw new Error(
-      `[init.mjs] Security: Path access denied outside script directory: ${targetPath}`
-    );
-  }
-  return resolved;
-}
-
-/**
- * Restricted fs operations - only within script directory
- */
-const fs = {
-  existsSync(targetPath) {
-    const validated = validateScriptPath(targetPath);
-    return fsNative.existsSync(validated);
-  },
-  mkdirSync(targetPath, options) {
-    const validated = validateScriptPath(targetPath);
-    return fsNative.mkdirSync(validated, options);
-  },
-  createWriteStream(targetPath) {
-    const validated = validateScriptPath(targetPath);
-    return fsNative.createWriteStream(validated);
-  },
-};
-
-// Colors for terminal output (works on modern terminals including Windows)
-const colors = {
-  green: '\x1b[0;32m',
-  blue: '\x1b[0;34m',
-  yellow: '\x1b[1;33m',
-  red: '\x1b[0;31m',
-  reset: '\x1b[0m',
-};
-
-const isWindows = process.platform === 'win32';
-
-// Track background processes for cleanup
-let serverProcess = null;
-let webProcess = null;
-let electronProcess = null;
-
-/**
- * Print colored output
- */
-function log(message, color = 'reset') {
-  console.log(`${colors[color]}${message}${colors.reset}`);
-}
-
-/**
- * Print the header banner
- */
-function printHeader() {
-  console.log('╔═══════════════════════════════════════════════════════╗');
-  console.log('║        Automaker Development Environment              ║');
-  console.log('╚═══════════════════════════════════════════════════════╝');
-  console.log('');
-}
-
-/**
- * Execute a command synchronously and return stdout
- */
-function execCommand(command, options = {}) {
-  try {
-    return execSync(command, {
-      encoding: 'utf8',
-      stdio: 'pipe',
-      ...options,
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get process IDs using a specific port (cross-platform)
- */
-function getProcessesOnPort(port) {
-  const pids = new Set();
-
-  if (isWindows) {
-    // Windows: Use netstat to find PIDs
-    try {
-      const output = execCommand(`netstat -ano | findstr :${port}`);
-      if (output) {
-        const lines = output.split('\n');
-        for (const line of lines) {
-          // Match lines with LISTENING or ESTABLISHED on our port
-          const match = line.match(/:\d+\s+.*?(\d+)\s*$/);
-          if (match) {
-            const pid = parseInt(match[1], 10);
-            if (pid > 0) pids.add(pid);
-          }
-        }
-      }
-    } catch {
-      // Ignore errors
-    }
-  } else {
-    // Unix: Use lsof
-    try {
-      const output = execCommand(`lsof -ti:${port}`);
-      if (output) {
-        output.split('\n').forEach((pid) => {
-          const parsed = parseInt(pid.trim(), 10);
-          if (parsed > 0) pids.add(parsed);
-        });
-      }
-    } catch {
-      // Ignore errors
-    }
-  }
-
-  return Array.from(pids);
-}
-
-/**
- * Kill a process by PID (cross-platform)
- */
-function killProcess(pid) {
-  try {
-    if (isWindows) {
-      execCommand(`taskkill /F /PID ${pid}`);
-    } else {
-      process.kill(pid, 'SIGKILL');
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if a port is in use (without killing)
- */
-function isPortInUse(port) {
-  const pids = getProcessesOnPort(port);
-  return pids.length > 0;
-}
-
-/**
- * Kill processes on a port and wait for it to be freed
- */
-async function killPort(port) {
-  const pids = getProcessesOnPort(port);
-
-  if (pids.length === 0) {
-    log(`✓ Port ${port} is available`, 'green');
-    return true;
-  }
-
-  log(`Killing process(es) on port ${port}: ${pids.join(', ')}`, 'yellow');
-
-  for (const pid of pids) {
-    killProcess(pid);
-  }
-
-  // Wait for port to be freed (max 5 seconds)
-  for (let i = 0; i < 10; i++) {
-    await sleep(500);
-    const remainingPids = getProcessesOnPort(port);
-    if (remainingPids.length === 0) {
-      log(`✓ Port ${port} is now free`, 'green');
-      return true;
-    }
-  }
-
-  log(`Warning: Port ${port} may still be in use`, 'red');
-  return false;
-}
-
-/**
- * Sleep for a given number of milliseconds
- */
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Check if the server health endpoint is responding
- */
-function checkHealth(port = 3008) {
-  return new Promise((resolve) => {
-    const req = http.get(`http://localhost:${port}/api/health`, (res) => {
-      resolve(res.statusCode === 200);
-    });
-    req.on('error', () => resolve(false));
-    req.setTimeout(2000, () => {
-      req.destroy();
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Prompt the user for input
- */
-function prompt(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-/**
- * Run npm command using cross-spawn for Windows compatibility
- */
-function runNpm(args, options = {}) {
-  const { env, ...restOptions } = options;
-  const spawnOptions = {
-    stdio: 'inherit',
-    cwd: __dirname,
-    ...restOptions,
-    // Ensure environment variables are properly merged with process.env
-    env: {
-      ...process.env,
-      ...(env || {}),
-    },
-  };
-  // cross-spawn handles Windows .cmd files automatically
-  return crossSpawn('npm', args, spawnOptions);
-}
-
-/**
- * Run an npm command and wait for completion
- */
-function runNpmAndWait(args, options = {}) {
-  const child = runNpm(args, options);
-  return new Promise((resolve, reject) => {
-    child.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`npm ${args.join(' ')} failed with code ${code}`));
-    });
-    child.on('error', (err) => reject(err));
-  });
-}
-
-/**
- * Run npx command using cross-spawn for Windows compatibility
- */
-function runNpx(args, options = {}) {
-  const spawnOptions = {
-    stdio: 'inherit',
-    cwd: __dirname,
-    ...options,
-  };
-  // cross-spawn handles Windows .cmd files automatically
-  return crossSpawn('npx', args, spawnOptions);
-}
-
-/**
- * Kill a process tree using tree-kill
- */
-function killProcessTree(pid) {
-  return new Promise((resolve) => {
-    if (!pid) {
-      resolve();
-      return;
-    }
-    treeKill(pid, 'SIGTERM', (err) => {
-      if (err) {
-        // Try force kill if graceful termination fails
-        treeKill(pid, 'SIGKILL', () => resolve());
-      } else {
-        resolve();
-      }
-    });
-  });
-}
-
-/**
- * Cleanup function to kill all spawned processes
- */
-async function cleanup() {
-  console.log('\nCleaning up...');
-
-  const killPromises = [];
-
-  if (serverProcess && !serverProcess.killed && serverProcess.pid) {
-    killPromises.push(killProcessTree(serverProcess.pid));
-  }
-
-  if (webProcess && !webProcess.killed && webProcess.pid) {
-    killPromises.push(killProcessTree(webProcess.pid));
-  }
-
-  if (electronProcess && !electronProcess.killed && electronProcess.pid) {
-    killPromises.push(killProcessTree(electronProcess.pid));
-  }
-
-  await Promise.all(killPromises);
-}
-
-/**
- * Main function
- */
-async function main() {
-  // Change to script directory
-  process.chdir(__dirname);
-
-  printHeader();
-
-  // Check if node_modules exists
-  if (!fs.existsSync(path.join(__dirname, 'node_modules'))) {
-    log('Installing dependencies...', 'blue');
-    const install = runNpm(['install'], { stdio: 'inherit' });
-    await new Promise((resolve, reject) => {
-      install.on('close', (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`npm install failed with code ${code}`));
-      });
-    });
-  }
-
-  // Install Playwright browsers from apps/ui where @playwright/test is installed
-  log('Checking Playwright browsers...', 'yellow');
-  try {
-    const exitCode = await new Promise((resolve) => {
-      const playwright = crossSpawn('npx', ['playwright', 'install', 'chromium'], {
-        stdio: 'inherit',
-        cwd: path.join(__dirname, 'apps', 'ui'),
-      });
-      playwright.on('close', (code) => resolve(code));
-      playwright.on('error', () => resolve(1));
-    });
-
-    if (exitCode === 0) {
-      log('Playwright browsers ready', 'green');
-    } else {
-      log('Playwright installation failed (browser automation may not work)', 'yellow');
-    }
-  } catch {
-    log('Playwright installation skipped', 'yellow');
-  }
-
-  // Check for processes on required ports and prompt user
-  log('Checking for processes on ports 3007 and 3008...', 'yellow');
-
-  const webPortInUse = isPortInUse(3007);
-  const serverPortInUse = isPortInUse(3008);
-
-  let webPort = 3007;
-  let serverPort = 3008;
-  let corsOriginEnv = process.env.CORS_ORIGIN || '';
-
-  if (webPortInUse || serverPortInUse) {
-    console.log('');
-    if (webPortInUse) {
-      const pids = getProcessesOnPort(3007);
-      log(`⚠ Port 3007 is in use by process(es): ${pids.join(', ')}`, 'yellow');
-    }
-    if (serverPortInUse) {
-      const pids = getProcessesOnPort(3008);
-      log(`⚠ Port 3008 is in use by process(es): ${pids.join(', ')}`, 'yellow');
-    }
-    console.log('');
-
-    while (true) {
-      const choice = await prompt(
-        'What would you like to do? (k)ill processes, (u)se different ports, or (c)ancel: '
-      );
-      const lowerChoice = choice.toLowerCase();
-
-      if (lowerChoice === 'k' || lowerChoice === 'kill') {
-        if (webPortInUse) {
-          await killPort(3007);
-        } else {
-          log(`✓ Port 3007 is available`, 'green');
-        }
-        if (serverPortInUse) {
-          await killPort(3008);
-        } else {
-          log(`✓ Port 3008 is available`, 'green');
-        }
-        break;
-      } else if (lowerChoice === 'u' || lowerChoice === 'use') {
-        // Prompt for new ports
-        while (true) {
-          const newWebPort = await prompt('Enter web port (default 3007): ');
-          const parsedWebPort = newWebPort.trim() ? parseInt(newWebPort.trim(), 10) : 3007;
-
-          if (isNaN(parsedWebPort) || parsedWebPort < 1024 || parsedWebPort > 65535) {
-            log('Invalid port. Please enter a number between 1024 and 65535.', 'red');
-            continue;
-          }
-
-          if (isPortInUse(parsedWebPort)) {
-            const pids = getProcessesOnPort(parsedWebPort);
-            log(
-              `Port ${parsedWebPort} is already in use by process(es): ${pids.join(', ')}`,
-              'red'
-            );
-            const useAnyway = await prompt('Use this port anyway? (y/n): ');
-            if (useAnyway.toLowerCase() !== 'y' && useAnyway.toLowerCase() !== 'yes') {
-              continue;
-            }
-          }
-
-          webPort = parsedWebPort;
-          break;
-        }
-
-        while (true) {
-          const newServerPort = await prompt('Enter server port (default 3008): ');
-          const parsedServerPort = newServerPort.trim() ? parseInt(newServerPort.trim(), 10) : 3008;
-
-          if (isNaN(parsedServerPort) || parsedServerPort < 1024 || parsedServerPort > 65535) {
-            log('Invalid port. Please enter a number between 1024 and 65535.', 'red');
-            continue;
-          }
-
-          if (parsedServerPort === webPort) {
-            log('Server port cannot be the same as web port.', 'red');
-            continue;
-          }
-
-          if (isPortInUse(parsedServerPort)) {
-            const pids = getProcessesOnPort(parsedServerPort);
-            log(
-              `Port ${parsedServerPort} is already in use by process(es): ${pids.join(', ')}`,
-              'red'
-            );
-            const useAnyway = await prompt('Use this port anyway? (y/n): ');
-            if (useAnyway.toLowerCase() !== 'y' && useAnyway.toLowerCase() !== 'yes') {
-              continue;
-            }
-          }
-
-          serverPort = parsedServerPort;
-          break;
-        }
-
-        log(`Using ports: Web=${webPort}, Server=${serverPort}`, 'blue');
-        break;
-      } else if (lowerChoice === 'c' || lowerChoice === 'cancel') {
-        log('Cancelled.', 'yellow');
-        process.exit(0);
-      } else {
-        log(
-          'Invalid choice. Please enter k (kill), u (use different ports), or c (cancel).',
-          'red'
-        );
-      }
-    }
-  } else {
-    log(`✓ Port 3007 is available`, 'green');
-    log(`✓ Port 3008 is available`, 'green');
-  }
-
-  // Ensure backend CORS allows whichever UI port we ended up using.
-  // If CORS_ORIGIN is set, server enforces it strictly (see apps/server/src/index.ts),
-  // so we must include the selected web origin(s) in that list.
-  {
-    const existing = (process.env.CORS_ORIGIN || '')
-      .split(',')
-      .map((o) => o.trim())
-      .filter(Boolean)
-      .filter((o) => o !== '*');
-    const origins = new Set(existing);
-    origins.add(`http://localhost:${webPort}`);
-    origins.add(`http://127.0.0.1:${webPort}`);
-    corsOriginEnv = Array.from(origins).join(',');
-  }
-  console.log('');
-
-  // Show menu
-  console.log('═══════════════════════════════════════════════════════');
-  console.log('  Select Application Mode:');
-  console.log('═══════════════════════════════════════════════════════');
-  console.log('  1) Web Application (Browser)');
-  console.log('  2) Desktop Application (Electron)');
-  console.log('═══════════════════════════════════════════════════════');
-  console.log('');
-
-  // Setup cleanup handlers
-  let cleaningUp = false;
-  const handleExit = async (signal) => {
-    if (cleaningUp) return;
-    cleaningUp = true;
-    await cleanup();
-    process.exit(0);
-  };
-
-  process.on('SIGINT', () => handleExit('SIGINT'));
-  process.on('SIGTERM', () => handleExit('SIGTERM'));
-
-  // Prompt for choice
-  while (true) {
-    const choice = await prompt('Enter your choice (1 or 2): ');
-
-    if (choice === '1') {
-      console.log('');
-      log('Launching Web Application...', 'blue');
-
-      // Build shared packages once (dev:server and dev:web both do this at the root level)
-      log('Building shared packages...', 'blue');
-      await runNpmAndWait(['run', 'build:packages'], { stdio: 'inherit' });
-
-      // Start the backend server
-      log(`Starting backend server on port ${serverPort}...`, 'blue');
-
-      // Create logs directory
-      if (!fs.existsSync(path.join(__dirname, 'logs'))) {
-        fs.mkdirSync(path.join(__dirname, 'logs'), { recursive: true });
-      }
-
-      // Start server in background, showing output in console AND logging to file
-      const logStream = fs.createWriteStream(path.join(__dirname, 'logs', 'server.log'));
-      serverProcess = runNpm(['run', '_dev:server'], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: {
-          PORT: String(serverPort),
-          CORS_ORIGIN: corsOriginEnv,
-        },
-      });
-
-      // Pipe to both log file and console so user can see API key
-      serverProcess.stdout?.on('data', (data) => {
-        process.stdout.write(data);
-        logStream.write(data);
-      });
-      serverProcess.stderr?.on('data', (data) => {
-        process.stderr.write(data);
-        logStream.write(data);
-      });
-
-      log('Waiting for server to be ready...', 'yellow');
-
-      // Wait for server health check
-      const maxRetries = 30;
-      let serverReady = false;
-
-      for (let i = 0; i < maxRetries; i++) {
-        if (await checkHealth(serverPort)) {
-          serverReady = true;
-          break;
-        }
-        process.stdout.write('.');
-        await sleep(1000);
-      }
-
-      console.log('');
-
-      if (!serverReady) {
-        log('Error: Server failed to start', 'red');
-        console.log('Check logs/server.log for details');
-        cleanup();
-        process.exit(1);
-      }
-
-      log('✓ Server is ready!', 'green');
-      log(`The application will be available at: http://localhost:${webPort}`, 'green');
-      console.log('');
-
-      // Start web app
-      webProcess = runNpm(['run', '_dev:web'], {
-        stdio: 'inherit',
-        env: {
-          TEST_PORT: String(webPort),
-          VITE_SERVER_URL: `http://localhost:${serverPort}`,
-        },
-      });
-      await new Promise((resolve) => {
-        webProcess.on('close', resolve);
-      });
-
-      break;
-    } else if (choice === '2') {
-      console.log('');
-      log('Launching Desktop Application...', 'blue');
-      log('(Electron will start its own backend server)', 'yellow');
-      console.log('');
-
-      // Pass selected ports through to Vite + Electron backend
-      // - TEST_PORT controls Vite dev server port (see apps/ui/vite.config.mts)
-      // - PORT controls backend server port (see apps/server/src/index.ts)
-      electronProcess = runNpm(['run', 'dev:electron'], {
-        stdio: 'inherit',
-        env: {
-          TEST_PORT: String(webPort),
-          PORT: String(serverPort),
-          VITE_SERVER_URL: `http://localhost:${serverPort}`,
-          CORS_ORIGIN: corsOriginEnv,
-        },
-      });
-      await new Promise((resolve) => {
-        electronProcess.on('close', resolve);
-      });
-
-      break;
-    } else {
-      log('Invalid choice. Please enter 1 or 2.', 'red');
-    }
-  }
-}
-
-// Run main function
-main().catch((err) => {
-  console.error(err);
-  cleanup();
-  process.exit(1);
-});

libs/platform/src/index.ts

@@ -23,6 +23,17 @@ export {
   getCredentialsPath,
   getProjectSettingsPath,
   ensureDataDir,
+  // Ideation paths
+  getIdeationDir,
+  getIdeasDir,
+  getIdeaDir,
+  getIdeaPath,
+  getIdeaAttachmentsDir,
+  getIdeationSessionsDir,
+  getIdeationSessionPath,
+  getIdeationDraftsDir,
+  getIdeationAnalysisPath,
+  ensureIdeationDir,
 } from './paths.js';
 
 // Subprocess management

libs/platform/src/paths.ts

@@ -188,6 +188,140 @@ export async function ensureAutomakerDir(projectPath: string): Promise<string> {
   return automakerDir;
 }
 
+// ============================================================================
+// Ideation Paths
+// ============================================================================
+
+/**
+ * Get the ideation directory for a project
+ *
+ * Contains ideas, sessions, and drafts for brainstorming.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Absolute path to {projectPath}/.automaker/ideation
+ */
+export function getIdeationDir(projectPath: string): string {
+  return path.join(getAutomakerDir(projectPath), 'ideation');
+}
+
+/**
+ * Get the ideas directory for a project
+ *
+ * Contains subdirectories for each idea, keyed by ideaId.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Absolute path to {projectPath}/.automaker/ideation/ideas
+ */
+export function getIdeasDir(projectPath: string): string {
+  return path.join(getIdeationDir(projectPath), 'ideas');
+}
+
+/**
+ * Get the directory for a specific idea
+ *
+ * Contains idea metadata and attachments.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @param ideaId - Idea identifier
+ * @returns Absolute path to {projectPath}/.automaker/ideation/ideas/{ideaId}
+ */
+export function getIdeaDir(projectPath: string, ideaId: string): string {
+  return path.join(getIdeasDir(projectPath), ideaId);
+}
+
+/**
+ * Get the idea metadata file path
+ *
+ * Stores the idea JSON data.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @param ideaId - Idea identifier
+ * @returns Absolute path to {projectPath}/.automaker/ideation/ideas/{ideaId}/idea.json
+ */
+export function getIdeaPath(projectPath: string, ideaId: string): string {
+  return path.join(getIdeaDir(projectPath, ideaId), 'idea.json');
+}
+
+/**
+ * Get the idea attachments directory
+ *
+ * Stores images and other attachments for an idea.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @param ideaId - Idea identifier
+ * @returns Absolute path to {projectPath}/.automaker/ideation/ideas/{ideaId}/attachments
+ */
+export function getIdeaAttachmentsDir(projectPath: string, ideaId: string): string {
+  return path.join(getIdeaDir(projectPath, ideaId), 'attachments');
+}
+
+/**
+ * Get the ideation sessions directory for a project
+ *
+ * Contains conversation history for ideation sessions.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Absolute path to {projectPath}/.automaker/ideation/sessions
+ */
+export function getIdeationSessionsDir(projectPath: string): string {
+  return path.join(getIdeationDir(projectPath), 'sessions');
+}
+
+/**
+ * Get the session file path for an ideation session
+ *
+ * Stores the session messages and metadata.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @param sessionId - Session identifier
+ * @returns Absolute path to {projectPath}/.automaker/ideation/sessions/{sessionId}.json
+ */
+export function getIdeationSessionPath(projectPath: string, sessionId: string): string {
+  return path.join(getIdeationSessionsDir(projectPath), `${sessionId}.json`);
+}
+
+/**
+ * Get the ideation drafts directory for a project
+ *
+ * Stores unsaved conversation drafts.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Absolute path to {projectPath}/.automaker/ideation/drafts
+ */
+export function getIdeationDraftsDir(projectPath: string): string {
+  return path.join(getIdeationDir(projectPath), 'drafts');
+}
+
+/**
+ * Get the project analysis result file path
+ *
+ * Stores the cached project analysis result.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Absolute path to {projectPath}/.automaker/ideation/analysis.json
+ */
+export function getIdeationAnalysisPath(projectPath: string): string {
+  return path.join(getIdeationDir(projectPath), 'analysis.json');
+}
+
+/**
+ * Create the ideation directory structure for a project if it doesn't exist
+ *
+ * Creates {projectPath}/.automaker/ideation with all subdirectories.
+ * Safe to call multiple times - uses recursive: true.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Promise resolving to the created ideation directory path
+ */
+export async function ensureIdeationDir(projectPath: string): Promise<string> {
+  const ideationDir = getIdeationDir(projectPath);
+  await secureFs.mkdir(ideationDir, { recursive: true });
+  await secureFs.mkdir(getIdeasDir(projectPath), { recursive: true });
+  await secureFs.mkdir(getIdeationSessionsDir(projectPath), { recursive: true });
+  await secureFs.mkdir(getIdeationDraftsDir(projectPath), { recursive: true });
+  return ideationDir;
+}
+
 // ============================================================================
 // Global Settings Paths (stored in DATA_DIR from app.getPath('userData'))
 // ============================================================================

libs/types/src/event.ts

@@ -26,6 +26,19 @@ export type EventType =
   | 'project:analysis-error'
   | 'suggestions:event'
   | 'spec-regeneration:event'
-  | 'issue-validation:event';
+  | 'issue-validation:event'
+  | 'ideation:stream'
+  | 'ideation:session-started'
+  | 'ideation:session-ended'
+  | 'ideation:analysis'
+  | 'ideation:analysis-started'
+  | 'ideation:analysis-progress'
+  | 'ideation:analysis-complete'
+  | 'ideation:analysis-error'
+  | 'ideation:suggestions'
+  | 'ideation:idea-created'
+  | 'ideation:idea-updated'
+  | 'ideation:idea-deleted'
+  | 'ideation:idea-converted';
 
 export type EventCallback = (type: EventType, payload: unknown) => void;

libs/types/src/ideation.ts

@@ -0,0 +1,230 @@
+/**
+ * Ideation types for AutoMaker brainstorming and idea management
+ */
+
+// ============================================================================
+// Core Types
+// ============================================================================
+
+export type IdeaCategory =
+  | 'feature'
+  | 'ux-ui'
+  | 'dx'
+  | 'growth'
+  | 'technical'
+  | 'security'
+  | 'performance'
+  | 'accessibility'
+  | 'analytics';
+export type IdeaStatus = 'raw' | 'refined' | 'ready' | 'archived';
+export type ImpactLevel = 'low' | 'medium' | 'high';
+export type EffortLevel = 'low' | 'medium' | 'high';
+
+// ============================================================================
+// Idea Entity
+// ============================================================================
+
+export interface IdeaAttachment {
+  id: string;
+  type: 'image' | 'link' | 'reference';
+  path?: string;
+  url?: string;
+  description?: string;
+  [key: string]: unknown;
+}
+
+export interface Idea {
+  id: string;
+  title: string;
+  description: string;
+  category: IdeaCategory;
+  status: IdeaStatus;
+  impact: ImpactLevel;
+  effort: EffortLevel;
+
+  // Conversation context
+  conversationId?: string;
+  sourcePromptId?: string;
+
+  // Content
+  attachments?: IdeaAttachment[];
+  userStories?: string[];
+  notes?: string;
+
+  // Metadata
+  createdAt: string;
+  updatedAt: string;
+  archivedAt?: string;
+
+  // Extensibility
+  [key: string]: unknown;
+}
+
+// ============================================================================
+// Ideation Session
+// ============================================================================
+
+export type IdeationSessionStatus = 'active' | 'completed' | 'abandoned';
+
+export interface IdeationSession {
+  id: string;
+  projectPath: string;
+  promptCategory?: IdeaCategory;
+  promptId?: string;
+  status: IdeationSessionStatus;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface IdeationMessage {
+  id: string;
+  role: 'user' | 'assistant';
+  content: string;
+  timestamp: string;
+  savedAsIdeaId?: string;
+}
+
+export interface IdeationSessionWithMessages extends IdeationSession {
+  messages: IdeationMessage[];
+}
+
+// ============================================================================
+// Guided Prompts
+// ============================================================================
+
+export interface PromptCategory {
+  id: IdeaCategory;
+  name: string;
+  icon: string;
+  description: string;
+}
+
+export interface IdeationPrompt {
+  id: string;
+  category: IdeaCategory;
+  title: string;
+  description: string;
+  prompt: string;
+  icon?: string;
+}
+
+// ============================================================================
+// Project Analysis
+// ============================================================================
+
+export interface AnalysisFileInfo {
+  path: string;
+  type: 'route' | 'component' | 'service' | 'model' | 'config' | 'test' | 'other';
+  name: string;
+}
+
+export interface AnalysisSuggestion {
+  id: string;
+  category: IdeaCategory;
+  title: string;
+  description: string;
+  rationale: string;
+  relatedFiles?: string[];
+  priority: 'high' | 'medium' | 'low';
+}
+
+export interface ProjectAnalysisResult {
+  projectPath: string;
+  analyzedAt: string;
+
+  // Structure analysis
+  totalFiles: number;
+  routes: AnalysisFileInfo[];
+  components: AnalysisFileInfo[];
+  services: AnalysisFileInfo[];
+
+  // Tech stack detection
+  framework?: string;
+  language?: string;
+  dependencies?: string[];
+
+  // AI-generated suggestions
+  suggestions: AnalysisSuggestion[];
+
+  // Summary
+  summary: string;
+}
+
+// ============================================================================
+// API Types
+// ============================================================================
+
+export interface StartSessionOptions {
+  promptId?: string;
+  promptCategory?: IdeaCategory;
+  initialMessage?: string;
+}
+
+export interface SendMessageOptions {
+  imagePaths?: string[];
+  model?: string;
+}
+
+export interface CreateIdeaInput {
+  title: string;
+  description: string;
+  category: IdeaCategory;
+  status?: IdeaStatus;
+  impact?: ImpactLevel;
+  effort?: EffortLevel;
+  conversationId?: string;
+  sourcePromptId?: string;
+  userStories?: string[];
+  notes?: string;
+}
+
+export interface UpdateIdeaInput {
+  title?: string;
+  description?: string;
+  category?: IdeaCategory;
+  status?: IdeaStatus;
+  impact?: ImpactLevel;
+  effort?: EffortLevel;
+  userStories?: string[];
+  notes?: string;
+}
+
+export interface ConvertToFeatureOptions {
+  column?: string;
+  dependencies?: string[];
+  tags?: string[];
+  keepIdea?: boolean;
+}
+
+// ============================================================================
+// Event Types
+// ============================================================================
+
+export type IdeationEventType =
+  | 'ideation:stream'
+  | 'ideation:session-started'
+  | 'ideation:session-ended'
+  | 'ideation:analysis-started'
+  | 'ideation:analysis-progress'
+  | 'ideation:analysis-complete'
+  | 'ideation:analysis-error';
+
+export interface IdeationStreamEvent {
+  type: 'ideation:stream';
+  sessionId: string;
+  content: string;
+  done: boolean;
+}
+
+export interface IdeationAnalysisEvent {
+  type:
+    | 'ideation:analysis-started'
+    | 'ideation:analysis-progress'
+    | 'ideation:analysis-complete'
+    | 'ideation:analysis-error';
+  projectPath: string;
+  progress?: number;
+  message?: string;
+  result?: ProjectAnalysisResult;
+  error?: string;
+}

libs/types/src/index.ts

@@ -143,3 +143,30 @@ export type {
 
 // Port configuration
 export { STATIC_PORT, SERVER_PORT, RESERVED_PORTS } from './ports.js';
+
+// Ideation types
+export type {
+  IdeaCategory,
+  IdeaStatus,
+  ImpactLevel,
+  EffortLevel,
+  IdeaAttachment,
+  Idea,
+  IdeationSessionStatus,
+  IdeationSession,
+  IdeationMessage,
+  IdeationSessionWithMessages,
+  PromptCategory,
+  IdeationPrompt,
+  AnalysisFileInfo,
+  AnalysisSuggestion,
+  ProjectAnalysisResult,
+  StartSessionOptions,
+  SendMessageOptions,
+  CreateIdeaInput,
+  UpdateIdeaInput,
+  ConvertToFeatureOptions,
+  IdeationEventType,
+  IdeationStreamEvent,
+  IdeationAnalysisEvent,
+} from './ideation.js';

libs/types/src/provider.ts

@@ -71,8 +71,6 @@ export interface ExecuteOptions {
   maxTurns?: number;
   allowedTools?: string[];
   mcpServers?: Record<string, McpServerConfig>;
-  mcpAutoApproveTools?: boolean; // Auto-approve MCP tool calls without permission prompts
-  mcpUnrestrictedTools?: boolean; // Allow unrestricted tools when MCP servers are enabled
   abortController?: AbortController;
   conversationHistory?: ConversationMessage[]; // Previous messages for context
   sdkSessionId?: string; // Claude SDK session ID for resuming conversations

libs/types/src/settings.ts

@@ -359,10 +359,6 @@ export interface GlobalSettings {
   // MCP Server Configuration
   /** List of configured MCP servers for agent use */
   mcpServers: MCPServerConfig[];
-  /** Auto-approve MCP tool calls without permission prompts (uses bypassPermissions mode) */
-  mcpAutoApproveTools?: boolean;
-  /** Allow unrestricted tools when MCP servers are enabled (don't filter allowedTools) */
-  mcpUnrestrictedTools?: boolean;
 
   // Prompt Customization
   /** Custom prompts for Auto Mode, Agent Runner, Backlog Planning, and Enhancements */
@@ -535,10 +531,6 @@ export const DEFAULT_GLOBAL_SETTINGS: GlobalSettings = {
   enableSandboxMode: false,
   skipSandboxWarning: false,
   mcpServers: [],
-  // Default to true for autonomous workflow. Security is enforced when adding servers
-  // via the security warning dialog that explains the risks.
-  mcpAutoApproveTools: true,
-  mcpUnrestrictedTools: true,
 };
 
 /** Default credentials (empty strings - user must provide API keys) */

package-lock.json

@@ -28,7 +28,7 @@
     },
     "apps/server": {
       "name": "@automaker/server",
-      "version": "0.7.1",
+      "version": "0.7.3",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@anthropic-ai/claude-agent-sdk": "0.1.76",
@@ -78,7 +78,7 @@
     },
     "apps/ui": {
       "name": "@automaker/ui",
-      "version": "0.7.1",
+      "version": "0.7.3",
       "hasInstallScript": true,
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {

package.json

@@ -12,7 +12,8 @@
   "scripts": {
     "postinstall": "node -e \"const fs=require('fs');if(process.platform==='darwin'){['darwin-arm64','darwin-x64'].forEach(a=>{const p='node_modules/node-pty/prebuilds/'+a+'/spawn-helper';if(fs.existsSync(p))fs.chmodSync(p,0o755)})}\" && node scripts/fix-lockfile-urls.mjs",
     "fix:lockfile": "node scripts/fix-lockfile-urls.mjs",
-    "dev": "node init.mjs",
+    "dev": "node dev.mjs",
+    "start": "node start.mjs",
     "_dev:web": "npm run dev:web --workspace=apps/ui",
     "_dev:electron": "npm run dev:electron --workspace=apps/ui",
     "_dev:electron:debug": "npm run dev:electron:debug --workspace=apps/ui",

scripts/launcher-utils.mjs

@@ -0,0 +1,664 @@
+/**
+ * Shared utilities for Automaker launcher scripts (dev.mjs and start.mjs)
+ *
+ * This module contains cross-platform utilities for:
+ * - Process management (ports, killing processes)
+ * - Terminal output (colors, logging)
+ * - npm/npx command execution
+ * - User prompts
+ * - Health checks
+ *
+ * SECURITY NOTE: Uses a restricted fs wrapper that only allows
+ * operations within a specified base directory.
+ */
+
+import { execSync } from 'child_process';
+import fsNative from 'fs';
+import http from 'http';
+import path from 'path';
+import readline from 'readline';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const treeKill = require('tree-kill');
+const crossSpawn = require('cross-spawn');
+
+// =============================================================================
+// Terminal Colors
+// =============================================================================
+
+export const colors = {
+  green: '\x1b[0;32m',
+  blue: '\x1b[0;34m',
+  yellow: '\x1b[1;33m',
+  red: '\x1b[0;31m',
+  reset: '\x1b[0m',
+};
+
+export const isWindows = process.platform === 'win32';
+
+// =============================================================================
+// Restricted fs wrapper - only allows operations within a base directory
+// =============================================================================
+
+/**
+ * Create a restricted fs wrapper for a given base directory
+ * @param {string} baseDir - The base directory to restrict operations to
+ * @param {string} scriptName - Name of the calling script for error messages
+ * @returns {object} - Restricted fs operations
+ */
+export function createRestrictedFs(baseDir, scriptName = 'launcher') {
+  const normalizedBase = path.resolve(baseDir);
+
+  function validatePath(targetPath) {
+    const resolved = path.resolve(baseDir, targetPath);
+    if (!resolved.startsWith(normalizedBase + path.sep) && resolved !== normalizedBase) {
+      throw new Error(
+        `[${scriptName}] Security: Path access denied outside script directory: ${targetPath}`
+      );
+    }
+    return resolved;
+  }
+
+  return {
+    existsSync(targetPath) {
+      const validated = validatePath(targetPath);
+      return fsNative.existsSync(validated);
+    },
+    mkdirSync(targetPath, options) {
+      const validated = validatePath(targetPath);
+      return fsNative.mkdirSync(validated, options);
+    },
+    createWriteStream(targetPath) {
+      const validated = validatePath(targetPath);
+      return fsNative.createWriteStream(validated);
+    },
+  };
+}
+
+// =============================================================================
+// Logging
+// =============================================================================
+
+/**
+ * Print colored output
+ * @param {string} message - Message to print
+ * @param {string} color - Color name (green, blue, yellow, red, reset)
+ */
+export function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+// =============================================================================
+// Command Execution
+// =============================================================================
+
+/**
+ * Execute a command synchronously and return stdout
+ * @param {string} command - Command to execute
+ * @param {object} options - execSync options
+ * @returns {string|null} - Command output or null on error
+ */
+export function execCommand(command, options = {}) {
+  try {
+    return execSync(command, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      ...options,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run npm command using cross-spawn for Windows compatibility
+ * @param {string[]} args - npm command arguments
+ * @param {object} options - spawn options
+ * @param {string} cwd - Working directory
+ * @returns {ChildProcess} - Spawned process
+ */
+export function runNpm(args, options = {}, cwd = process.cwd()) {
+  const { env, ...restOptions } = options;
+  const spawnOptions = {
+    stdio: 'inherit',
+    cwd,
+    ...restOptions,
+    env: {
+      ...process.env,
+      ...(env || {}),
+    },
+  };
+  return crossSpawn('npm', args, spawnOptions);
+}
+
+/**
+ * Run an npm command and wait for completion
+ * @param {string[]} args - npm command arguments
+ * @param {object} options - spawn options
+ * @param {string} cwd - Working directory
+ * @returns {Promise<void>}
+ */
+export function runNpmAndWait(args, options = {}, cwd = process.cwd()) {
+  const child = runNpm(args, options, cwd);
+  return new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`npm ${args.join(' ')} failed with code ${code}`));
+    });
+    child.on('error', (err) => reject(err));
+  });
+}
+
+/**
+ * Run npx command using cross-spawn for Windows compatibility
+ * @param {string[]} args - npx command arguments
+ * @param {object} options - spawn options
+ * @param {string} cwd - Working directory
+ * @returns {ChildProcess} - Spawned process
+ */
+export function runNpx(args, options = {}, cwd = process.cwd()) {
+  const { env, ...restOptions } = options;
+  const spawnOptions = {
+    stdio: 'inherit',
+    cwd,
+    ...restOptions,
+    env: {
+      ...process.env,
+      ...(env || {}),
+    },
+  };
+  return crossSpawn('npx', args, spawnOptions);
+}
+
+// =============================================================================
+// Process Management
+// =============================================================================
+
+/**
+ * Get process IDs using a specific port (cross-platform)
+ * @param {number} port - Port number to check
+ * @returns {number[]} - Array of PIDs using the port
+ */
+export function getProcessesOnPort(port) {
+  const pids = new Set();
+
+  if (isWindows) {
+    try {
+      const output = execCommand(`netstat -ano | findstr :${port}`);
+      if (output) {
+        const lines = output.split('\n');
+        for (const line of lines) {
+          const match = line.match(/:\d+\s+.*?(\d+)\s*$/);
+          if (match) {
+            const pid = parseInt(match[1], 10);
+            if (pid > 0) pids.add(pid);
+          }
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+  } else {
+    try {
+      const output = execCommand(`lsof -ti:${port}`);
+      if (output) {
+        output.split('\n').forEach((pid) => {
+          const parsed = parseInt(pid.trim(), 10);
+          if (parsed > 0) pids.add(parsed);
+        });
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  return Array.from(pids);
+}
+
+/**
+ * Kill a process by PID (cross-platform)
+ * @param {number} pid - Process ID to kill
+ * @returns {boolean} - Whether the kill succeeded
+ */
+export function killProcess(pid) {
+  try {
+    if (isWindows) {
+      execCommand(`taskkill /F /PID ${pid}`);
+    } else {
+      process.kill(pid, 'SIGKILL');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a port is in use (without killing)
+ * @param {number} port - Port number to check
+ * @returns {boolean} - Whether the port is in use
+ */
+export function isPortInUse(port) {
+  const pids = getProcessesOnPort(port);
+  return pids.length > 0;
+}
+
+/**
+ * Kill processes on a port and wait for it to be freed
+ * @param {number} port - Port number to free
+ * @returns {Promise<boolean>} - Whether the port was freed
+ */
+export async function killPort(port) {
+  const pids = getProcessesOnPort(port);
+
+  if (pids.length === 0) {
+    log(`✓ Port ${port} is available`, 'green');
+    return true;
+  }
+
+  log(`Killing process(es) on port ${port}: ${pids.join(', ')}`, 'yellow');
+
+  for (const pid of pids) {
+    killProcess(pid);
+  }
+
+  // Wait for port to be freed (max 5 seconds)
+  for (let i = 0; i < 10; i++) {
+    await sleep(500);
+    const remainingPids = getProcessesOnPort(port);
+    if (remainingPids.length === 0) {
+      log(`✓ Port ${port} is now free`, 'green');
+      return true;
+    }
+  }
+
+  log(`Warning: Port ${port} may still be in use`, 'red');
+  return false;
+}
+
+/**
+ * Kill a process tree using tree-kill
+ * @param {number} pid - Root process ID
+ * @returns {Promise<void>}
+ */
+export function killProcessTree(pid) {
+  return new Promise((resolve) => {
+    if (!pid) {
+      resolve();
+      return;
+    }
+    treeKill(pid, 'SIGTERM', (err) => {
+      if (err) {
+        treeKill(pid, 'SIGKILL', () => resolve());
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+// =============================================================================
+// Utilities
+// =============================================================================
+
+/**
+ * Sleep for a given number of milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if the server health endpoint is responding
+ * @param {number} port - Server port (default 3008)
+ * @returns {Promise<boolean>} - Whether the server is healthy
+ */
+export function checkHealth(port = 3008) {
+  return new Promise((resolve) => {
+    const req = http.get(`http://localhost:${port}/api/health`, (res) => {
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.setTimeout(2000, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * Prompt the user for input
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} - User's answer
+ */
+export function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// =============================================================================
+// Port Configuration Flow
+// =============================================================================
+
+/**
+ * Check ports and prompt user for resolution if in use
+ * @param {object} options - Configuration options
+ * @param {number} options.defaultWebPort - Default web port (3007)
+ * @param {number} options.defaultServerPort - Default server port (3008)
+ * @returns {Promise<{webPort: number, serverPort: number, corsOriginEnv: string}>}
+ */
+export async function resolvePortConfiguration({
+  defaultWebPort = 3007,
+  defaultServerPort = 3008,
+} = {}) {
+  log(`Checking for processes on ports ${defaultWebPort} and ${defaultServerPort}...`, 'yellow');
+
+  const webPortInUse = isPortInUse(defaultWebPort);
+  const serverPortInUse = isPortInUse(defaultServerPort);
+
+  let webPort = defaultWebPort;
+  let serverPort = defaultServerPort;
+
+  if (webPortInUse || serverPortInUse) {
+    console.log('');
+    if (webPortInUse) {
+      const pids = getProcessesOnPort(defaultWebPort);
+      log(`⚠ Port ${defaultWebPort} is in use by process(es): ${pids.join(', ')}`, 'yellow');
+    }
+    if (serverPortInUse) {
+      const pids = getProcessesOnPort(defaultServerPort);
+      log(`⚠ Port ${defaultServerPort} is in use by process(es): ${pids.join(', ')}`, 'yellow');
+    }
+    console.log('');
+
+    while (true) {
+      const choice = await prompt(
+        'What would you like to do? (k)ill processes, (u)se different ports, or (c)ancel: '
+      );
+      const lowerChoice = choice.toLowerCase();
+
+      if (lowerChoice === 'k' || lowerChoice === 'kill') {
+        if (webPortInUse) {
+          await killPort(defaultWebPort);
+        } else {
+          log(`✓ Port ${defaultWebPort} is available`, 'green');
+        }
+        if (serverPortInUse) {
+          await killPort(defaultServerPort);
+        } else {
+          log(`✓ Port ${defaultServerPort} is available`, 'green');
+        }
+        break;
+      } else if (lowerChoice === 'u' || lowerChoice === 'use') {
+        webPort = await promptForPort('web', defaultWebPort);
+        serverPort = await promptForPort('server', defaultServerPort, webPort);
+        log(`Using ports: Web=${webPort}, Server=${serverPort}`, 'blue');
+        break;
+      } else if (lowerChoice === 'c' || lowerChoice === 'cancel') {
+        log('Cancelled.', 'yellow');
+        process.exit(0);
+      } else {
+        log(
+          'Invalid choice. Please enter k (kill), u (use different ports), or c (cancel).',
+          'red'
+        );
+      }
+    }
+  } else {
+    log(`✓ Port ${defaultWebPort} is available`, 'green');
+    log(`✓ Port ${defaultServerPort} is available`, 'green');
+  }
+
+  // Build CORS origin env
+  const existing = (process.env.CORS_ORIGIN || '')
+    .split(',')
+    .map((o) => o.trim())
+    .filter(Boolean)
+    .filter((o) => o !== '*');
+  const origins = new Set(existing);
+  origins.add(`http://localhost:${webPort}`);
+  origins.add(`http://127.0.0.1:${webPort}`);
+  const corsOriginEnv = Array.from(origins).join(',');
+
+  console.log('');
+
+  return { webPort, serverPort, corsOriginEnv };
+}
+
+/**
+ * Prompt for a specific port with validation
+ * @param {string} name - Port name (web/server)
+ * @param {number} defaultPort - Default port value
+ * @param {number} excludePort - Port to exclude (optional)
+ * @returns {Promise<number>}
+ */
+async function promptForPort(name, defaultPort, excludePort = null) {
+  while (true) {
+    const input = await prompt(`Enter ${name} port (default ${defaultPort}): `);
+    const parsed = input.trim() ? parseInt(input.trim(), 10) : defaultPort;
+
+    if (isNaN(parsed) || parsed < 1024 || parsed > 65535) {
+      log('Invalid port. Please enter a number between 1024 and 65535.', 'red');
+      continue;
+    }
+
+    if (excludePort && parsed === excludePort) {
+      log(`${name} port cannot be the same as the other port.`, 'red');
+      continue;
+    }
+
+    if (isPortInUse(parsed)) {
+      const pids = getProcessesOnPort(parsed);
+      log(`Port ${parsed} is already in use by process(es): ${pids.join(', ')}`, 'red');
+      const useAnyway = await prompt('Use this port anyway? (y/n): ');
+      if (useAnyway.toLowerCase() !== 'y' && useAnyway.toLowerCase() !== 'yes') {
+        continue;
+      }
+    }
+
+    return parsed;
+  }
+}
+
+// =============================================================================
+// UI Components
+// =============================================================================
+
+/**
+ * Print the application header banner
+ * @param {string} title - Header title
+ */
+export function printHeader(title) {
+  console.log('╔═══════════════════════════════════════════════════════╗');
+  console.log(`║        ${title.padEnd(45)}║`);
+  console.log('╚═══════════════════════════════════════════════════════╝');
+  console.log('');
+}
+
+/**
+ * Print the application mode menu
+ */
+export function printModeMenu() {
+  console.log('═══════════════════════════════════════════════════════');
+  console.log('  Select Application Mode:');
+  console.log('═══════════════════════════════════════════════════════');
+  console.log('  1) Web Application (Browser)');
+  console.log('  2) Desktop Application (Electron)');
+  console.log('  3) Docker Container (Isolated)');
+  console.log('═══════════════════════════════════════════════════════');
+  console.log('');
+}
+
+// =============================================================================
+// Process Cleanup
+// =============================================================================
+
+/**
+ * Create a cleanup handler for spawned processes
+ * @param {object} processes - Object with process references {server, web, electron, docker}
+ * @returns {Function} - Cleanup function
+ */
+export function createCleanupHandler(processes) {
+  return async function cleanup() {
+    console.log('\nCleaning up...');
+
+    const killPromises = [];
+
+    if (processes.server && !processes.server.killed && processes.server.pid) {
+      killPromises.push(killProcessTree(processes.server.pid));
+    }
+
+    if (processes.web && !processes.web.killed && processes.web.pid) {
+      killPromises.push(killProcessTree(processes.web.pid));
+    }
+
+    if (processes.electron && !processes.electron.killed && processes.electron.pid) {
+      killPromises.push(killProcessTree(processes.electron.pid));
+    }
+
+    if (processes.docker && !processes.docker.killed && processes.docker.pid) {
+      killPromises.push(killProcessTree(processes.docker.pid));
+    }
+
+    await Promise.all(killPromises);
+  };
+}
+
+/**
+ * Setup signal handlers for graceful shutdown
+ * @param {Function} cleanup - Cleanup function
+ */
+export function setupSignalHandlers(cleanup) {
+  let cleaningUp = false;
+
+  const handleExit = async () => {
+    if (cleaningUp) return;
+    cleaningUp = true;
+    await cleanup();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => handleExit());
+  process.on('SIGTERM', () => handleExit());
+}
+
+// =============================================================================
+// Server Startup
+// =============================================================================
+
+/**
+ * Start the backend server and wait for it to be ready
+ * @param {object} options - Configuration options
+ * @returns {Promise<ChildProcess>} - Server process
+ */
+export async function startServerAndWait({ serverPort, corsOriginEnv, npmArgs, cwd, fs, baseDir }) {
+  log(`Starting backend server on port ${serverPort}...`, 'blue');
+
+  // Create logs directory
+  const logsDir = path.join(baseDir, 'logs');
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+
+  const logStream = fs.createWriteStream(path.join(baseDir, 'logs', 'server.log'));
+  const serverProcess = runNpm(
+    npmArgs,
+    {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        PORT: String(serverPort),
+        CORS_ORIGIN: corsOriginEnv,
+      },
+    },
+    cwd
+  );
+
+  // Pipe to both log file and console
+  serverProcess.stdout?.on('data', (data) => {
+    process.stdout.write(data);
+    logStream.write(data);
+  });
+  serverProcess.stderr?.on('data', (data) => {
+    process.stderr.write(data);
+    logStream.write(data);
+  });
+
+  log('Waiting for server to be ready...', 'yellow');
+
+  // Wait for server health check
+  const maxRetries = 30;
+  let serverReady = false;
+
+  for (let i = 0; i < maxRetries; i++) {
+    if (await checkHealth(serverPort)) {
+      serverReady = true;
+      break;
+    }
+    process.stdout.write('.');
+    await sleep(1000);
+  }
+
+  console.log('');
+
+  if (!serverReady) {
+    log('Error: Server failed to start', 'red');
+    console.log('Check logs/server.log for details');
+
+    // Clean up the spawned server process that failed health check
+    if (serverProcess && !serverProcess.killed && serverProcess.pid) {
+      log('Terminating failed server process...', 'yellow');
+      try {
+        await killProcessTree(serverProcess.pid);
+      } catch (killErr) {
+        // Fallback: try direct kill if tree-kill fails
+        try {
+          serverProcess.kill('SIGKILL');
+        } catch {
+          // Process may have already exited
+        }
+      }
+    }
+
+    // Close the log stream
+    logStream.end();
+
+    return null;
+  }
+
+  log('✓ Server is ready!', 'green');
+  return serverProcess;
+}
+
+// =============================================================================
+// Dependencies
+// =============================================================================
+
+/**
+ * Ensure node_modules exists, install if not
+ * @param {object} fs - Restricted fs object
+ * @param {string} baseDir - Base directory
+ */
+export async function ensureDependencies(fs, baseDir) {
+  if (!fs.existsSync(path.join(baseDir, 'node_modules'))) {
+    log('Installing dependencies...', 'blue');
+    const install = runNpm(['install'], { stdio: 'inherit' }, baseDir);
+    await new Promise((resolve, reject) => {
+      install.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`npm install failed with code ${code}`));
+      });
+    });
+  }
+}

start.mjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+
+/**
+ * Automaker - Production Mode Launch Script
+ *
+ * This script runs the application in production mode (no Vite dev server).
+ * It builds everything if needed, then serves static files via vite preview.
+ *
+ * Key differences from dev.mjs:
+ * - Uses pre-built static files instead of Vite dev server (faster startup)
+ * - No HMR or hot reloading
+ * - Server runs from compiled dist/ directory
+ * - Uses "vite preview" to serve static UI files
+ *
+ * Usage: npm run start
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { createRequire } from 'module';
+import {
+  createRestrictedFs,
+  log,
+  runNpm,
+  runNpmAndWait,
+  runNpx,
+  printHeader,
+  printModeMenu,
+  resolvePortConfiguration,
+  createCleanupHandler,
+  setupSignalHandlers,
+  startServerAndWait,
+  ensureDependencies,
+  prompt,
+  killProcessTree,
+  sleep,
+} from './scripts/launcher-utils.mjs';
+
+const require = createRequire(import.meta.url);
+const crossSpawn = require('cross-spawn');
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create restricted fs for this script's directory
+const fs = createRestrictedFs(__dirname, 'start.mjs');
+
+// Track background processes for cleanup
+const processes = {
+  server: null,
+  web: null,
+  electron: null,
+  docker: null,
+};
+
+/**
+ * Build all production artifacts
+ */
+async function ensureProductionBuilds() {
+  // Always build shared packages first to ensure they're up to date
+  log('Building shared packages...', 'blue');
+  try {
+    await runNpmAndWait(['run', 'build:packages'], { stdio: 'inherit' }, __dirname);
+    log('✓ Shared packages built', 'green');
+  } catch (error) {
+    log(`Failed to build shared packages: ${error.message}`, 'red');
+    process.exit(1);
+  }
+
+  // Always rebuild server to ensure it's in sync with packages
+  log('Building server...', 'blue');
+  try {
+    await runNpmAndWait(
+      ['run', 'build'],
+      { stdio: 'inherit' },
+      path.join(__dirname, 'apps', 'server')
+    );
+    log('✓ Server built', 'green');
+  } catch (error) {
+    log(`Failed to build server: ${error.message}`, 'red');
+    process.exit(1);
+  }
+
+  // Always rebuild UI to ensure it's in sync with latest code
+  log('Building UI...', 'blue');
+  try {
+    await runNpmAndWait(['run', 'build'], { stdio: 'inherit' }, __dirname);
+    log('✓ UI built', 'green');
+    console.log('');
+  } catch (error) {
+    log(`Failed to build UI: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  // Change to script directory
+  process.chdir(__dirname);
+
+  printHeader('Automaker Production Mode');
+
+  // Ensure dependencies are installed
+  await ensureDependencies(fs, __dirname);
+
+  // Build production artifacts if needed
+  await ensureProductionBuilds();
+
+  // Resolve port configuration (check/kill/change ports)
+  const { webPort, serverPort, corsOriginEnv } = await resolvePortConfiguration();
+
+  // Show mode selection menu
+  printModeMenu();
+
+  // Setup cleanup handlers
+  const cleanup = createCleanupHandler(processes);
+  setupSignalHandlers(cleanup);
+
+  // Prompt for choice
+  while (true) {
+    const choice = await prompt('Enter your choice (1, 2, or 3): ');
+
+    if (choice === '1') {
+      console.log('');
+      log('Launching Web Application (Production Mode)...', 'blue');
+
+      // Start the backend server in PRODUCTION mode
+      // Uses "npm run start" in apps/server which runs the compiled dist/
+      // NOT the Vite dev server (no HMR, faster startup)
+      processes.server = await startServerAndWait({
+        serverPort,
+        corsOriginEnv,
+        npmArgs: ['run', 'start'],
+        cwd: path.join(__dirname, 'apps', 'server'),
+        fs,
+        baseDir: __dirname,
+      });
+
+      if (!processes.server) {
+        await cleanup();
+        process.exit(1);
+      }
+
+      log(`Starting web server...`, 'blue');
+
+      // Start vite preview to serve pre-built static files
+      // This is NOT Vite dev server - it just serves the dist/ folder
+      // No HMR, no compilation, just static file serving
+      processes.web = runNpx(
+        ['vite', 'preview', '--port', String(webPort)],
+        {
+          stdio: 'inherit',
+          env: {
+            VITE_SERVER_URL: `http://localhost:${serverPort}`,
+          },
+        },
+        path.join(__dirname, 'apps', 'ui')
+      );
+
+      log(`The application is available at: http://localhost:${webPort}`, 'green');
+      console.log('');
+
+      await new Promise((resolve) => {
+        processes.web.on('close', resolve);
+      });
+
+      break;
+    } else if (choice === '2') {
+      console.log('');
+      log('Launching Desktop Application (Production Mode)...', 'blue');
+      log('(Electron will start its own backend server)', 'yellow');
+      console.log('');
+
+      // Run electron directly with the built main.js
+      const electronMainPath = path.join(__dirname, 'apps', 'ui', 'dist-electron', 'main.js');
+
+      if (!fs.existsSync(electronMainPath)) {
+        log('Error: Electron main process not built. Run build first.', 'red');
+        process.exit(1);
+      }
+
+      // Start vite preview to serve built static files for electron
+      // (Electron in non-packaged mode needs a server to load from)
+      log('Starting static file server...', 'blue');
+      processes.web = runNpx(
+        ['vite', 'preview', '--port', String(webPort)],
+        {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: {
+            VITE_SERVER_URL: `http://localhost:${serverPort}`,
+          },
+        },
+        path.join(__dirname, 'apps', 'ui')
+      );
+
+      // Wait for vite preview to start
+      await sleep(2000);
+
+      // Use electron from node_modules with NODE_ENV=production
+      // This ensures electron loads from the preview server, not Vite dev
+      processes.electron = runNpx(
+        ['electron', electronMainPath],
+        {
+          stdio: 'inherit',
+          env: {
+            TEST_PORT: String(webPort),
+            PORT: String(serverPort),
+            VITE_DEV_SERVER_URL: `http://localhost:${webPort}`,
+            VITE_SERVER_URL: `http://localhost:${serverPort}`,
+            CORS_ORIGIN: corsOriginEnv,
+            NODE_ENV: 'production',
+          },
+        },
+        path.join(__dirname, 'apps', 'ui')
+      );
+
+      await new Promise((resolve) => {
+        processes.electron.on('close', () => {
+          // Also kill vite preview when electron closes
+          if (processes.web && !processes.web.killed && processes.web.pid) {
+            killProcessTree(processes.web.pid);
+          }
+          resolve();
+        });
+      });
+
+      break;
+    } else if (choice === '3') {
+      console.log('');
+      log('Launching Docker Container (Isolated Mode)...', 'blue');
+      log('Building and starting Docker containers...', 'yellow');
+      console.log('');
+
+      // Check if ANTHROPIC_API_KEY is set
+      if (!process.env.ANTHROPIC_API_KEY) {
+        log('Warning: ANTHROPIC_API_KEY environment variable is not set.', 'yellow');
+        log('The server will require an API key to function.', 'yellow');
+        log('Set it with: export ANTHROPIC_API_KEY=your-key', 'yellow');
+        console.log('');
+      }
+
+      // Build and start containers with docker-compose
+      processes.docker = crossSpawn('docker', ['compose', 'up', '--build'], {
+        stdio: 'inherit',
+        cwd: __dirname,
+        env: {
+          ...process.env,
+        },
+      });
+
+      log('Docker containers starting...', 'blue');
+      log('UI will be available at: http://localhost:3007', 'green');
+      log('API will be available at: http://localhost:3008', 'green');
+      console.log('');
+      log('Press Ctrl+C to stop the containers.', 'yellow');
+
+      await new Promise((resolve) => {
+        processes.docker.on('close', resolve);
+      });
+
+      break;
+    } else {
+      log('Invalid choice. Please enter 1, 2, or 3.', 'red');
+    }
+  }
+}
+
+// Run main function
+main().catch(async (err) => {
+  console.error(err);
+  const cleanup = createCleanupHandler(processes);
+  try {
+    await cleanup();
+  } catch (cleanupErr) {
+    console.error('Cleanup error:', cleanupErr);
+  }
+  process.exit(1);
+});