vibeteam 0.5.4 → 0.6.0

package/dist/server/server/index.js

@@ -1412,6 +1412,110 @@ function broadcastKanbanTasks(projectId) {
 
 const IDEATION_DIR = resolve(expandHome('~/.vibeteam/data/ideation'));
 
+// ============================================================================
+// Custom Ideation Categories
+// ============================================================================
+
+const DEFAULT_CATEGORIES = [
+    { id: 'code_improvements', label: 'Code Improvements', color: '#4ade80', icon: '🔧', isDefault: true },
+    { id: 'ui_ux', label: 'UI/UX', color: '#60a5fa', icon: '🎨', isDefault: true },
+    { id: 'security', label: 'Security', color: '#f87171', icon: '🔒', isDefault: true },
+    { id: 'performance', label: 'Performance', color: '#fbbf24', icon: '⚡', isDefault: true },
+    { id: 'documentation', label: 'Documentation', color: '#a78bfa', icon: '📝', isDefault: true },
+    { id: 'code_quality', label: 'Code Quality', color: '#22d3d8', icon: '✨', isDefault: true },
+    { id: 'new_features', label: 'New Features', color: '#a855f7', icon: '🚀', isDefault: true },
+];
+
+const CUSTOM_CATEGORIES_FILE = resolve(expandHome('~/.vibeteam/data/custom-categories.json'));
+
+class CustomCategoryManager {
+    constructor() {
+        this.categories = []; // Array of { id, label, color, icon, isCustom: true }
+        this.load();
+    }
+
+    load() {
+        try {
+            if (existsSync(CUSTOM_CATEGORIES_FILE)) {
+                this.categories = JSON.parse(readFileSync(CUSTOM_CATEGORIES_FILE, 'utf8'));
+            }
+        } catch (e) {
+            log(`Failed to load custom categories: ${e.message}`);
+            this.categories = [];
+        }
+    }
+
+    save() {
+        try {
+            const dir = resolve(expandHome('~/.vibeteam/data'));
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(CUSTOM_CATEGORIES_FILE, JSON.stringify(this.categories, null, 2));
+        } catch (e) {
+            log(`Failed to save custom categories: ${e.message}`);
+        }
+    }
+
+    getAll() {
+        return [...DEFAULT_CATEGORIES, ...this.categories];
+    }
+
+    _slugify(label) {
+        return label
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+
+    addCategory(category) {
+        const { label, color, icon } = category;
+        if (!label || !color || !icon) {
+            throw new Error('label, color, and icon are required');
+        }
+        const slug = this._slugify(label);
+        const suffix = Math.random().toString(36).substring(2, 6);
+        const id = `${slug}_${suffix}`;
+        const newCat = { id, label, color, icon, isCustom: true };
+        this.categories.push(newCat);
+        this.save();
+        return newCat;
+    }
+
+    updateCategory(id, updates) {
+        // Can't update default categories
+        if (DEFAULT_CATEGORIES.some(c => c.id === id)) {
+            throw new Error('Cannot update default categories');
+        }
+        const cat = this.categories.find(c => c.id === id);
+        if (!cat) {
+            throw new Error('Category not found');
+        }
+        if (updates.label !== undefined) cat.label = updates.label;
+        if (updates.color !== undefined) cat.color = updates.color;
+        if (updates.icon !== undefined) cat.icon = updates.icon;
+        this.save();
+        return cat;
+    }
+
+    deleteCategory(id) {
+        if (DEFAULT_CATEGORIES.some(c => c.id === id)) {
+            throw new Error('Cannot delete default categories');
+        }
+        const idx = this.categories.findIndex(c => c.id === id);
+        if (idx === -1) {
+            throw new Error('Category not found');
+        }
+        const removed = this.categories.splice(idx, 1)[0];
+        this.save();
+        return removed;
+    }
+
+    isValidCategory(categoryId) {
+        return this.getAll().some(c => c.id === categoryId);
+    }
+}
+
 class IdeationManager {
     constructor() {
         this.sessions = new Map(); // projectId -> session
@@ -1450,6 +1554,44 @@ class IdeationManager {
         }
     }
 
+    loadAllSessions() {
+        try {
+            if (!existsSync(IDEATION_DIR)) return;
+            const files = readdirSync(IDEATION_DIR).filter(f => f.endsWith('.json'));
+            let loaded = 0;
+            for (const file of files) {
+                try {
+                    const filePath = join(IDEATION_DIR, file);
+                    const data = JSON.parse(readFileSync(filePath, 'utf8'));
+                    const projectId = file.replace(/\.json$/, '');
+                    this.sessions.set(projectId, data);
+                    loaded++;
+                } catch (e) {
+                    log(`Failed to load ideation file ${file}: ${e.message}`);
+                }
+            }
+            // Reset any sessions stuck in generating/streaming from a previous server run
+            let reset = 0;
+            for (const [pid, sess] of this.sessions) {
+                if (sess.status === 'generating' || sess.status === 'streaming') {
+                    sess.status = 'error';
+                    sess.error = 'Generation was interrupted (server restart). Please retry.';
+                    sess.updatedAt = Date.now();
+                    this.save(pid);
+                    reset++;
+                }
+            }
+            if (reset > 0) {
+                log(`Reset ${reset} stale ideation session(s) from generating/streaming to error`);
+            }
+            if (loaded > 0) {
+                log(`Loaded ${loaded} ideation session(s) from disk`);
+            }
+        } catch (e) {
+            log(`Failed to load ideation sessions: ${e.message}`);
+        }
+    }
+
     getSession(projectId) {
         if (!this.sessions.has(projectId)) {
             this.loadSession(projectId);
@@ -1504,10 +1646,7 @@ class IdeationManager {
                 id: sessionId,
                 projectId,
                 ideas: [],
-                enabledCategories: enabledCategories || [
-                    'code_improvements', 'ui_ux', 'security', 'performance',
-                    'documentation', 'code_quality', 'new_features'
-                ],
+                enabledCategories: enabledCategories || DEFAULT_CATEGORIES.map(c => c.id),
                 status: 'generating',
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
@@ -1527,15 +1666,63 @@ class IdeationManager {
         });
 
         try {
-            const categoryList = (session.enabledCategories || []).join(', ');
+            const enabledCats = session.enabledCategories || DEFAULT_CATEGORIES.map(c => c.id);
+            const allCategories = customCategoryManager.getAll();
+            const enabledCategoryDetails = enabledCats.map(catId => {
+                const cat = allCategories.find(c => c.id === catId);
+                return cat ? `${catId} (${cat.label})` : catId;
+            });
+            const categoryList = enabledCats.join(', ');
+            const categoryDetailList = enabledCategoryDetails.join(', ');
+            // Try to read CLAUDE.md or README for project context
+            let projectContext = '';
+            try {
+                const possibleDocs = ['CLAUDE.md', 'README.md', 'readme.md'];
+                for (const docFile of possibleDocs) {
+                    const docPath = join(projectPath, docFile);
+                    if (existsSync(docPath)) {
+                        const content = readFileSync(docPath, 'utf8').slice(0, 3000);
+                        projectContext = `\n\nProject documentation (${docFile}):\n${content}\n`;
+                        break;
+                    }
+                }
+            } catch (e) {
+                // ignore
+            }
+
+            // Detect project type from common markers
+            let projectTypeHint = '';
+            try {
+                const entries = readdirSync(projectPath);
+                if (entries.includes('Assets') && entries.includes('ProjectSettings')) {
+                    projectTypeHint = '\nThis is a Unity project. Focus ONLY on files in Assets/ (especially Scripts/). IGNORE: Library/, Logs/, Temp/, Packages/, obj/, .vs/, *.meta files, and any auto-generated Unity files.';
+                } else if (entries.includes('Cargo.toml')) {
+                    projectTypeHint = '\nThis is a Rust project. Focus on src/ directory.';
+                } else if (entries.includes('go.mod')) {
+                    projectTypeHint = '\nThis is a Go project. Focus on .go files.';
+                } else if (entries.includes('Podfile') || entries.some(e => e.endsWith('.xcodeproj'))) {
+                    projectTypeHint = '\nThis is an iOS/macOS project. Focus on source code, not Pods/ or build artifacts.';
+                } else if (entries.includes('build.gradle') || entries.includes('build.gradle.kts')) {
+                    projectTypeHint = '\nThis is a Java/Kotlin/Android project. Focus on src/ directories, not build/ or .gradle/.';
+                }
+            } catch (e) {
+                // ignore
+            }
+
             const prompt = `You are an expert code analyst. Analyze this project's codebase and generate improvement ideas.
+${projectContext}${projectTypeHint}
+Categories to analyze: ${categoryDetailList}
 
-Categories to analyze: ${categoryList}
+IMPORTANT INSTRUCTIONS:
+1. First, if there is a CLAUDE.md file, read it to understand the project structure and conventions.
+2. Explore ONLY the project's source code directories — skip libraries, dependencies, build outputs, and auto-generated files.
+3. Read a few key source files to understand patterns and quality.
+4. Then output your analysis.
 
 You MUST output your response as a valid JSON array of idea objects. No other text, no markdown, no code blocks. ONLY a JSON array.
 
 Each idea object must have these fields:
-- "category": one of: code_improvements, ui_ux, security, performance, documentation, code_quality, new_features
+- "category": one of: ${categoryList}
 - "title": short descriptive title (under 80 chars)
 - "description": 1-3 sentence description of the specific improvement
 - "effort": one of: trivial, small, medium, large, complex
@@ -1543,12 +1730,10 @@ Each idea object must have these fields:
 
 Rules:
 - Generate 15-30 ideas total across the requested categories
-- Only generate ideas for the categories listed above
+- Only generate ideas for the categories listed above, using the EXACT category IDs provided
 - Focus on actionable, specific improvements (reference real files/functions when possible)
 - effort: trivial (<1hr), small (1-4hr), medium (1-2 days), large (3-5 days), complex (1+ weeks)
-- impact: low (nice to have), medium (noticeable improvement), high (significant value), critical (essential/blocking)
-
-Start by exploring the project structure and reading key files, then output the JSON array.`;
+- impact: low (nice to have), medium (noticeable improvement), high (significant value), critical (essential/blocking)`;
 
             // Use claude CLI in --print mode for reliable output capture
             // spawn() with array args prevents shell injection
@@ -1558,6 +1743,7 @@ Start by exploring the project structure and reading key files, then output the
                 '--output-format', 'text',
                 '--dangerously-skip-permissions',
                 '--model', 'sonnet',
+                '--max-turns', '5',
                 prompt,
             ];
 
@@ -1587,10 +1773,12 @@ Start by exploring the project structure and reading key files, then output the
             });
 
             // Track this generation with 5-minute timeout
+            let timedOut = false;
             const generationTimeout = setTimeout(() => {
                 log(`Ideation generation timed out for project ${projectId}`);
+                timedOut = true;
                 child.kill('SIGTERM');
-                this._finishGeneration(projectId, 'error', 'Generation timed out (5 min)');
+                // Don't call _finishGeneration here - let the close handler do it
             }, 5 * 60 * 1000);
 
             this.activeGenerations.set(projectId, {
@@ -1611,15 +1799,49 @@ Start by exploring the project structure and reading key files, then output the
             });
 
             child.on('close', (code) => {
-                log(`Ideation: claude --print exited with code ${code} for project ${projectId}`);
+                log(`Ideation: claude --print exited with code ${code} for project ${projectId} (timedOut=${timedOut})`);
+
+                if (timedOut) {
+                    // If we got partial output before timeout, try to parse it
+                    if (stdout.trim()) {
+                        this._parseAndAddIdeas(projectId, stdout);
+                        const session = this.sessions.get(projectId);
+                        const ideaCount = session?.ideas?.length || 0;
+                        if (ideaCount > 0) {
+                            this._finishGeneration(projectId, 'done');
+                            return;
+                        }
+                    }
+                    this._finishGeneration(projectId, 'error', 'Generation timed out — the project may be too large. Try selecting fewer categories.');
+                    return;
+                }
 
-                if (code !== 0 && !stdout.trim()) {
-                    this._finishGeneration(projectId, 'error', `Claude exited with code ${code}: ${stderr.slice(0, 200)}`);
+                if (code !== 0) {
+                    // Non-zero exit: try to salvage ideas from partial stdout
+                    if (stdout.trim()) {
+                        this._parseAndAddIdeas(projectId, stdout);
+                        const session = this.sessions.get(projectId);
+                        const ideaCount = session?.ideas?.length || 0;
+                        if (ideaCount > 0) {
+                            log(`Ideation: Claude exited with code ${code} but salvaged ${ideaCount} ideas`);
+                            this._finishGeneration(projectId, 'done');
+                            return;
+                        }
+                    }
+                    const hint = code === 143 ? ' (process was killed — may need more time or memory)' : '';
+                    this._finishGeneration(projectId, 'error', `Claude exited with code ${code}${hint}: ${stderr.slice(0, 200)}`);
                     return;
                 }
 
                 // Final parse of complete output
                 this._parseAndAddIdeas(projectId, stdout);
+                const session = this.sessions.get(projectId);
+                const ideaCount = session?.ideas?.length || 0;
+                if (ideaCount === 0) {
+                    log(`Ideation: Claude returned no parseable ideas. stdout length=${stdout.length}, stderr=${stderr.slice(0, 300)}`);
+                    this._finishGeneration(projectId, 'error', 'Claude did not return any ideas. This may happen if the AI response was not in the expected format. Try again.');
+                    return;
+                }
                 this._finishGeneration(projectId, 'done');
             });
 
@@ -1713,9 +1935,13 @@ Start by exploring the project structure and reading key files, then output the
             return;
         }
 
-        const validCategories = ['code_improvements', 'ui_ux', 'security', 'performance', 'documentation', 'code_quality', 'new_features'];
-        if (!validCategories.includes(ideaData.category)) {
-            return;
+        // Validate against all categories (default + custom)
+        if (!customCategoryManager.isValidCategory(ideaData.category)) {
+            // Also accept if category matches an enabled category in the session (in case custom was added during generation)
+            const session = this.sessions.get(projectId);
+            if (!session?.enabledCategories?.includes(ideaData.category)) {
+                return;
+            }
         }
 
         const idea = {
@@ -1777,6 +2003,7 @@ Start by exploring the project structure and reading key files, then output the
 }
 
 const ideationManager = new IdeationManager();
+const customCategoryManager = new CustomCategoryManager();
 
 // ============================================================================
 // Planning Pipeline Manager
@@ -1978,8 +2205,15 @@ class PlanningPipelineManager {
     async createPipeline(taskId, projectId, projectPath, title, description, attachments) {
         // Check for existing pipeline for this task
         for (const p of this.pipelines.values()) {
-            if (p.taskId === taskId && p.status === 'running') {
-                throw new Error(`Task already has an active pipeline`);
+            if (p.taskId === taskId) {
+                if (p.status === 'running') {
+                    throw new Error(`Task already has an active pipeline`);
+                }
+                // Remove old completed/failed/cancelled pipeline to allow re-execution
+                log(`Pipeline ${taskId.slice(0, 8)}: Removing old pipeline (status: ${p.status}) for re-execution`);
+                this.pipelines.delete(p.id);
+                this.save();
+                break;
             }
         }
 
@@ -3505,11 +3739,20 @@ function pollTerminalForClient(ws, sessionId, tmuxSession, forceUpdate = false)
                 lastTerminalOutput.set(sessionId, stdout);
 
                 if (ws.readyState === WebSocket.OPEN) {
+                    // Compute delta: append if new output starts with old, otherwise full
+                    let delta;
+                    if (!forceUpdate && lastOutput && stdout.startsWith(lastOutput)) {
+                        delta = { type: 'append', data: stdout.slice(lastOutput.length) };
+                    } else {
+                        delta = { type: 'full', data: stdout };
+                    }
+
                     ws.send(JSON.stringify({
                         type: 'terminal_output',
                         payload: {
                             sessionId,
-                            data: stdout
+                            version: 2,
+                            delta
                         }
                     }));
                 }
@@ -3557,11 +3800,20 @@ function pollAllTerminals(onEachComplete, terminalSnapshot) {
                         lastTerminalOutput.set(sessionId, stdout);
 
                         if (ws.readyState === WebSocket.OPEN) {
+                            // Compute delta: append if new output starts with old, otherwise full
+                            let delta;
+                            if (lastOutput && stdout.startsWith(lastOutput)) {
+                                delta = { type: 'append', data: stdout.slice(lastOutput.length) };
+                            } else {
+                                delta = { type: 'full', data: stdout };
+                            }
+
                             ws.send(JSON.stringify({
                                 type: 'terminal_output',
                                 payload: {
                                     sessionId,
-                                    data: stdout
+                                    version: 2,
+                                    delta
                                 }
                             }));
                         }
@@ -4911,6 +5163,72 @@ function watchEventsFile() {
     });
     log(`Watching events file: ${EVENTS_FILE}`);
 }
+// ============================================================================
+// Relay Connection (Mobile Remote Control)
+// ============================================================================
+let relayWs = null;
+let relaySessionToken = null;
+let relayConnected = false;
+
+// Send message to relay (wrapping in envelope)
+function sendToRelay(data) {
+    if (relayWs && relayWs.readyState === 1) {
+        try {
+            relayWs.send(JSON.stringify({
+                type: 'relay_message',
+                from: 'host',
+                payload: data,
+                timestamp: Date.now(),
+                seq: 0,
+            }));
+        } catch (e) {
+            console.error('[relay] Failed to send:', e);
+        }
+    }
+}
+
+// Handle REST-over-relay requests from mobile
+async function handleRelayRequest(request, ws) {
+    const { method, path, body } = request;
+    if (!method || !path) return;
+
+    try {
+        // Route the request internally
+        const url = `http://localhost:${PORT}${path}`;
+        const options = {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+        };
+        if (body && method !== 'GET') {
+            options.body = JSON.stringify(body);
+        }
+
+        const response = await fetch(url, options);
+        const responseBody = await response.json().catch(() => null);
+
+        // Send response back through relay
+        if (ws.readyState === 1) {
+            ws.send(JSON.stringify({
+                type: 'relay_message',
+                from: 'host',
+                payload: { status: response.status, body: responseBody },
+                timestamp: Date.now(),
+                seq: 0,
+            }));
+        }
+    } catch (err) {
+        if (ws.readyState === 1) {
+            ws.send(JSON.stringify({
+                type: 'relay_message',
+                from: 'host',
+                payload: { status: 500, body: { error: err.message } },
+                timestamp: Date.now(),
+                seq: 0,
+            }));
+        }
+    }
+}
+
 // ============================================================================
 // WebSocket
 // ============================================================================
@@ -4921,6 +5239,8 @@ function broadcast(message) {
             client.send(data);
         }
     }
+    // Forward to relay for mobile clients
+    sendToRelay(message);
 }
 function handleClientMessage(ws, message) {
     switch (message.type) {
@@ -5997,6 +6317,25 @@ async function handleHttpRequest(req, res) {
                     res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
                     return;
                 }
+                // When moving back to ideas, reset pipeline fields on the task and remove old pipeline
+                if (toColumn === 'ideas') {
+                    const existingPipeline = pipelineManager.pipelines.get(taskId);
+                    if (existingPipeline && existingPipeline.status !== 'running') {
+                        log(`Task ${taskId.slice(0, 8)} moved to ideas: clearing old pipeline (status: ${existingPipeline.status})`);
+                        pipelineManager.pipelines.delete(taskId);
+                        pipelineManager.save();
+                        broadcast({ type: 'pipeline_removed', payload: { pipelineId: taskId } });
+                        // Reset pipeline fields on the task
+                        kanbanManager.updateTask(taskId, {
+                            pipelineId: undefined,
+                            pipelinePhase: null,
+                            pipelineStatus: undefined,
+                            pipelineLog: undefined,
+                            reviewFeedback: undefined,
+                            reviewStatus: undefined,
+                        });
+                    }
+                }
                 broadcast({ type: 'kanban_task_moved', payload: { taskId, toColumn, position: task.position, task } });
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ ok: true, task }));
@@ -7164,6 +7503,193 @@ async function handleHttpRequest(req, res) {
     // Ideation Endpoints
     // ============================================================================
 
+    // GET /ideation/categories - Get all categories (default + custom)
+    if (req.method === 'GET' && req.url === '/ideation/categories') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, categories: customCategoryManager.getAll() }));
+        return;
+    }
+
+    // POST /ideation/categories - Create a custom category
+    if (req.method === 'POST' && req.url === '/ideation/categories') {
+        collectRequestBody(req).then((rawBody) => {
+            try {
+                const body = JSON.parse(rawBody);
+                const { label, color, icon } = body;
+                if (!label || !color || !icon) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'label, color, and icon are required' }));
+                    return;
+                }
+                const category = customCategoryManager.addCategory({ label, color, icon });
+                broadcast({ type: 'ideation_categories', payload: { categories: customCategoryManager.getAll() } });
+                res.writeHead(201, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, category }));
+            } catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        }).catch(() => {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request body too large' }));
+        });
+        return;
+    }
+
+    // POST /ideation/categories/suggest - AI-powered category suggestions
+    if (req.method === 'POST' && req.url === '/ideation/categories/suggest') {
+        collectRequestBody(req).then(async (rawBody) => {
+            try {
+                const body = JSON.parse(rawBody);
+                const { projectId, projectPath } = body;
+                if (!projectId || !projectPath) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'projectId and projectPath are required' }));
+                    return;
+                }
+
+                const existingLabels = customCategoryManager.getAll().map(c => c.label).join(', ');
+                const suggestPrompt = `You are a project analyst. Analyze this project and suggest 5-8 domain-specific ideation categories that would be useful for generating improvement ideas.
+
+The project is located at: ${projectPath}
+
+Existing categories (do NOT suggest duplicates of these): ${existingLabels}
+
+You MUST output your response as a valid JSON array. No other text, no markdown, no code blocks. ONLY a JSON array.
+
+Each category object must have:
+- "label": descriptive name for the category (2-4 words, Title Case)
+- "color": hex color string (e.g., "#ff6b6b") - pick visually distinct colors
+- "icon": a single emoji that represents the category
+
+Consider what kind of project this is (web app, API, game, mobile app, CLI tool, library, etc.) and suggest categories specific to its domain. For example:
+- A game project might get: Game Mechanics, Level Design, Player Experience
+- A web app might get: Accessibility, SEO, State Management
+- An API might get: Rate Limiting, Error Handling, API Design
+
+Explore the project structure and key files to understand what it does, then output the JSON array.`;
+
+                const claudePath = 'claude';
+                const args = [
+                    '--print',
+                    '--output-format', 'text',
+                    '--dangerously-skip-permissions',
+                    '--model', 'sonnet',
+                    suggestPrompt,
+                ];
+
+                const childEnv = { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'vibeteam-category-suggest' };
+                delete childEnv.CLAUDECODE;
+
+                const child = spawn(claudePath, args, {
+                    cwd: projectPath,
+                    env: childEnv,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+
+                let stdout = '';
+                let stderr = '';
+
+                child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+                child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+
+                const timeout = setTimeout(() => {
+                    child.kill('SIGTERM');
+                }, 3 * 60 * 1000);
+
+                child.on('close', (code) => {
+                    clearTimeout(timeout);
+                    if (code !== 0 && !stdout.trim()) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: `Claude exited with code ${code}: ${stderr.slice(0, 200)}` }));
+                        return;
+                    }
+
+                    try {
+                        let output = stdout.trim();
+                        output = output.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '');
+                        const arrayStart = output.indexOf('[');
+                        const arrayEnd = output.lastIndexOf(']');
+                        if (arrayStart !== -1 && arrayEnd !== -1 && arrayEnd > arrayStart) {
+                            output = output.substring(arrayStart, arrayEnd + 1);
+                        }
+                        const suggestions = JSON.parse(output);
+                        if (!Array.isArray(suggestions)) {
+                            throw new Error('Output is not an array');
+                        }
+                        // Validate and clean suggestions
+                        const cleaned = suggestions
+                            .filter(s => s.label && s.color && s.icon)
+                            .map(s => ({ label: s.label, color: s.color, icon: s.icon }));
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        // Add temporary IDs so frontend can track them
+                        const withIds = cleaned.map(s => ({
+                            ...s,
+                            id: `suggestion_${Math.random().toString(36).substring(2, 8)}`,
+                            isCustom: true,
+                        }));
+                        res.end(JSON.stringify({ ok: true, categories: withIds }));
+                    } catch (e) {
+                        log(`Category suggest: Failed to parse output: ${e.message}`);
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'Failed to parse AI suggestions' }));
+                    }
+                });
+
+                child.on('error', (err) => {
+                    clearTimeout(timeout);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: err.message }));
+                });
+            } catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        }).catch(() => {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request body too large' }));
+        });
+        return;
+    }
+
+    // PUT /ideation/categories/:id - Update a custom category
+    if (req.method === 'PUT' && req.url?.match(/^\/ideation\/categories\/[^/]+$/)) {
+        const id = req.url.split('/ideation/categories/')[1]?.split('?')[0];
+        collectRequestBody(req).then((rawBody) => {
+            try {
+                const body = JSON.parse(rawBody);
+                const category = customCategoryManager.updateCategory(id, body);
+                broadcast({ type: 'ideation_categories', payload: { categories: customCategoryManager.getAll() } });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, category }));
+            } catch (e) {
+                const status = e.message.includes('not found') ? 404 : e.message.includes('Cannot update') ? 403 : 500;
+                res.writeHead(status, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        }).catch(() => {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request body too large' }));
+        });
+        return;
+    }
+
+    // DELETE /ideation/categories/:id - Delete a custom category
+    if (req.method === 'DELETE' && req.url?.match(/^\/ideation\/categories\/[^/]+$/)) {
+        const id = req.url.split('/ideation/categories/')[1]?.split('?')[0];
+        try {
+            customCategoryManager.deleteCategory(id);
+            broadcast({ type: 'ideation_categories', payload: { categories: customCategoryManager.getAll() } });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+        } catch (e) {
+            const status = e.message.includes('not found') ? 404 : e.message.includes('Cannot delete') ? 403 : 500;
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+        return;
+    }
+
     // POST /ideation/generate - Generate ideas for a project
     if (req.method === 'POST' && req.url === '/ideation/generate') {
         collectRequestBody(req).then(async (rawBody) => {
@@ -7303,10 +7829,7 @@ async function handleHttpRequest(req, res) {
                         id: sessionId,
                         projectId,
                         ideas: [],
-                        enabledCategories: [
-                            'code_improvements', 'ui_ux', 'security', 'performance',
-                            'documentation', 'code_quality', 'new_features'
-                        ],
+                        enabledCategories: DEFAULT_CATEGORIES.map(c => c.id),
                         status: 'done',
                         createdAt: Date.now(),
                         updatedAt: Date.now(),
@@ -7496,6 +8019,139 @@ async function handleHttpRequest(req, res) {
     }
 
     // API Documentation
+    // ========================================================================
+    // Relay connection management (Mobile Remote Control)
+    // ========================================================================
+    if (req.method === 'POST' && req.url === '/relay/connect') {
+        collectRequestBody(req).then(body => {
+            try {
+                const { code, relayUrl = 'wss://vibeteam-relay.fly.dev/connect' } = JSON.parse(body) || {};
+
+                if (!code) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Pairing code required' }));
+                    return;
+                }
+
+                // Close existing relay connection
+                if (relayWs) {
+                    try { relayWs.close(); } catch {}
+                    relayWs = null;
+                }
+
+                try {
+                    const url = `${relayUrl}?code=${encodeURIComponent(code)}&role=host`;
+                    const ws = new WebSocket(url);
+
+                    ws.on('open', () => {
+                        console.log('[relay] Connected to relay server');
+                        relayConnected = true;
+                        broadcast({ type: 'relay_status', payload: { connected: true } });
+                    });
+
+                    ws.on('message', (data) => {
+                        try {
+                            const msg = JSON.parse(data.toString());
+
+                            // Handle relay control messages
+                            if (msg.type === 'paired') {
+                                relaySessionToken = msg.payload?.sessionToken;
+                                console.log('[relay] Paired with mobile device');
+                                broadcast({ type: 'relay_status', payload: { connected: true, paired: true } });
+
+                                // Send current state to mobile via relay
+                                const sessionsData = getSessions();
+                                sendToRelay({ type: 'sessions', payload: sessionsData });
+
+                                // Send projects
+                                sendToRelay({ type: 'projects', payload: projectsManager.getProjects() });
+                                return;
+                            }
+
+                            if (msg.type === 'waiting') {
+                                console.log('[relay] Waiting for mobile device to connect...');
+                                if (msg.payload?.sessionToken) {
+                                    relaySessionToken = msg.payload.sessionToken;
+                                }
+                                broadcast({ type: 'relay_status', payload: { connected: true, paired: false, waiting: true } });
+                                return;
+                            }
+
+                            if (msg.type === 'ping') {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({ type: 'pong', from: 'host', timestamp: Date.now(), seq: 0 }));
+                                }
+                                return;
+                            }
+
+                            if (msg.type === 'mobile_disconnected') {
+                                console.log('[relay] Mobile device disconnected');
+                                broadcast({ type: 'relay_status', payload: { connected: true, paired: false } });
+                                return;
+                            }
+
+                            // Handle relay_message from mobile (REST-over-relay)
+                            if (msg.type === 'relay_message' && msg.payload) {
+                                handleRelayRequest(msg.payload, ws);
+                                return;
+                            }
+                        } catch (e) {
+                            console.error('[relay] Error processing message:', e);
+                        }
+                    });
+
+                    ws.on('close', () => {
+                        console.log('[relay] Disconnected from relay server');
+                        relayWs = null;
+                        relayConnected = false;
+                        relaySessionToken = null;
+                        broadcast({ type: 'relay_status', payload: { connected: false } });
+                    });
+
+                    ws.on('error', (err) => {
+                        console.error('[relay] WebSocket error:', err.message);
+                    });
+
+                    relayWs = ws;
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true, message: 'Connecting to relay...' }));
+                } catch (err) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Failed to connect to relay', details: err.message }));
+                }
+            } catch (e) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            }
+        }).catch(() => {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request body too large' }));
+        });
+        return;
+    }
+
+    if (req.method === 'GET' && req.url === '/relay/status') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            connected: relayConnected,
+            sessionToken: relaySessionToken ? '***' : null,
+        }));
+        return;
+    }
+
+    if (req.method === 'POST' && req.url === '/relay/disconnect') {
+        if (relayWs) {
+            try { relayWs.close(); } catch {}
+            relayWs = null;
+        }
+        relayConnected = false;
+        relaySessionToken = null;
+        broadcast({ type: 'relay_status', payload: { connected: false } });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true }));
+        return;
+    }
+
     if (req.method === 'GET' && req.url === '/api/docs/openapi.json') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(openapiSpec));
@@ -7642,6 +8298,8 @@ function main() {
     loadSessions();
     // Load saved text tiles
     loadTiles();
+    // Load saved ideation sessions
+    ideationManager.loadAllSessions();
     // Start git status tracking with adaptive polling
     gitStatusManager.setUpdateHandler(({ sessionId, status }) => {
         const session = managedSessions.get(sessionId);
@@ -7707,6 +8365,8 @@ function main() {
             payload: { tasks: kanbanManager.getTasks() },
         };
         ws.send(JSON.stringify(kanbanMsg));
+        // Send ideation categories (default + custom)
+        ws.send(JSON.stringify({ type: 'ideation_categories', payload: { categories: customCategoryManager.getAll() } }));
         // Send ideation sessions for all projects
         for (const [, session] of ideationManager.sessions) {
             ws.send(JSON.stringify({ type: 'ideation_session', payload: { session } }));