vibeteam 0.2.2 → 0.2.4

package/dist/server/server/index.js

@@ -11,8 +11,8 @@
 import { createServer } from 'http';
 import { WebSocketServer, WebSocket } from 'ws';
 import { watch } from 'chokidar';
-import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync, unlinkSync, statSync } from 'fs';
-import { exec, execFile } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync, unlinkSync, statSync, readdirSync } from 'fs';
+import { exec, execFile, spawn } from 'child_process';
 import { dirname, resolve, join, extname } from 'path';
 import { hostname } from 'os';
 import { randomUUID, randomBytes } from 'crypto';
@@ -20,7 +20,6 @@ import { createClient, LiveTranscriptionEvents } from '@deepgram/sdk';
 import { DEFAULTS } from '../shared/defaults.js';
 import { GitStatusManager } from './GitStatusManager.js';
 import { ProjectsManager } from './ProjectsManager.js';
-import { CommitWatcher } from './CommitWatcher.js';
 import { fileURLToPath } from 'url';
 // ============================================================================
 // Version (read from package.json)
@@ -66,7 +65,7 @@ const TMUX_SESSION = process.env.VIBETEAM_TMUX_SESSION ?? DEFAULTS.TMUX_SESSION;
 const SESSIONS_FILE = resolve(expandHome(process.env.VIBETEAM_SESSIONS_FILE ?? DEFAULTS.SESSIONS_FILE));
 const TILES_FILE = resolve(expandHome(process.env.VIBETEAM_TILES_FILE ?? '~/.vibeteam/data/tiles.json'));
 /** Time before a "working" session auto-transitions to idle (failsafe for missed events) */
-const WORKING_TIMEOUT_MS = 120_000; // 2 minutes
+const WORKING_TIMEOUT_MS = 300_000; // 5 minutes (increased to accommodate long Claude thinking periods)
 /** Maximum request body size (1MB) - prevents DoS via memory exhaustion */
 const MAX_BODY_SIZE = 1024 * 1024;
 /** How often to check for stale "working" sessions */
@@ -193,20 +192,25 @@ function collectRequestBody(req, maxSize = MAX_BODY_SIZE) {
 async function sendToTmuxSafe(tmuxSession, text) {
     // Validate session name
     validateTmuxSession(tmuxSession);
+    // Use a unique named buffer to avoid race conditions with tmux's default buffer
+    const bufferName = `vt-${Date.now()}-${randomBytes(4).toString('hex')}`;
     // Create temp file with cryptographically secure random name
     const tempFile = `/tmp/vibeteam-prompt-${Date.now()}-${randomBytes(16).toString('hex')}.txt`;
     writeFileSync(tempFile, text);
     try {
-        // Load text into tmux buffer
-        await execFileAsync('tmux', ['load-buffer', tempFile]);
-        // Paste buffer into session
-        await execFileAsync('tmux', ['paste-buffer', '-t', tmuxSession]);
+        // Load text into a NAMED tmux buffer (not the default one, to avoid races)
+        log(`[sendToTmuxSafe] Loading buffer ${bufferName} for ${tmuxSession} (${text.length} chars)`);
+        await execFileAsync('tmux', ['load-buffer', '-b', bufferName, tempFile]);
+        // Paste named buffer into session
+        log(`[sendToTmuxSafe] Pasting buffer into ${tmuxSession}`);
+        await execFileAsync('tmux', ['paste-buffer', '-b', bufferName, '-t', tmuxSession]);
         // Send Enter to submit - longer delay for multi-line prompts to fully render
         await new Promise(r => setTimeout(r, 500));
         await execFileAsync('tmux', ['send-keys', '-t', tmuxSession, 'Enter']);
         // Second Enter as failsafe (Claude CLI sometimes needs it after large pastes)
         await new Promise(r => setTimeout(r, 100));
         await execFileAsync('tmux', ['send-keys', '-t', tmuxSession, 'Enter']);
+        log(`[sendToTmuxSafe] Complete for ${tmuxSession}`);
     }
     finally {
         // Clean up temp file
@@ -216,8 +220,180 @@ async function sendToTmuxSafe(tmuxSession, text) {
         catch {
             // Ignore cleanup errors
         }
+        // Clean up named buffer
+        try {
+            await execFileAsync('tmux', ['delete-buffer', '-b', bufferName]);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Fallback prompt sending method: uses tmux send-keys -l (literal) instead of paste-buffer.
+ * This is slower but more reliable as it doesn't depend on tmux's paste buffer mechanism.
+ */
+async function sendPromptFallback(session, prompt) {
+    try {
+        validateTmuxSession(session.tmuxSession);
+        log(`[sendPromptFallback] Sending via send-keys to ${session.tmuxSession} (${prompt.length} chars)`);
+        // Use send-keys with -l flag to send text literally (as keystrokes)
+        // For very long prompts, split into chunks to avoid tmux buffer limits
+        const CHUNK_SIZE = 500;
+        for (let i = 0; i < prompt.length; i += CHUNK_SIZE) {
+            const chunk = prompt.slice(i, i + CHUNK_SIZE);
+            await execFileAsync('tmux', ['send-keys', '-t', session.tmuxSession, '-l', chunk]);
+            // Small delay between chunks to let tmux process
+            if (i + CHUNK_SIZE < prompt.length) {
+                await new Promise(r => setTimeout(r, 50));
+            }
+        }
+        // Send Enter to submit
+        await new Promise(r => setTimeout(r, 300));
+        await execFileAsync('tmux', ['send-keys', '-t', session.tmuxSession, 'Enter']);
+        await new Promise(r => setTimeout(r, 100));
+        await execFileAsync('tmux', ['send-keys', '-t', session.tmuxSession, 'Enter']);
+
+        // Mark session as working
+        session.lastActivity = Date.now();
+        session.lastPromptTime = Date.now();
+        const prevStatus = session.status;
+        session.status = 'working';
+        session.currentTool = undefined;
+        if (prevStatus !== 'working') {
+            session.statusVersion = (session.statusVersion || 0) + 1;
+            broadcastSessions();
+        }
+        log(`[sendPromptFallback] Complete for ${session.tmuxSession}`);
+        return { ok: true };
+    } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log(`[sendPromptFallback] Failed for ${session.tmuxSession}: ${msg}`);
+        return { ok: false, error: msg };
+    }
+}
+
+/**
+ * Wait for a tmux session to be ready for input by polling the pane content.
+ * Claude CLI takes a variable amount of time to start rendering its UI.
+ * Returns true when ready, false if timed out.
+ */
+async function waitForSessionReady(tmuxSession, timeoutMs = 30000) {
+    const start = Date.now();
+    const pollInterval = 500;
+    log(`[waitForSessionReady] Polling ${tmuxSession} (timeout: ${timeoutMs}ms)`);
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const output = await new Promise((resolve, reject) => {
+                execFile('tmux', ['capture-pane', '-t', tmuxSession, '-p', '-S', '-50'],
+                    { ...EXEC_OPTIONS, maxBuffer: 1024 * 1024 },
+                    (error, stdout) => {
+                        if (error) reject(error);
+                        else resolve(stdout);
+                    }
+                );
+            });
+            // Check for Claude CLI's actual input prompt indicator (❯) or bypass permissions banner
+            // Just checking for "any content" triggers too early (shell startup output)
+            const hasPrompt = output.includes('❯') || output.includes('bypass permissions');
+            if (hasPrompt) {
+                const elapsed = Date.now() - start;
+                // Log last few lines to confirm what we saw
+                const lastLines = output.trim().split('\n').slice(-5).join(' | ');
+                log(`[waitForSessionReady] ${tmuxSession} ready after ${elapsed}ms. Last lines: ${lastLines}`);
+                // Buffer for the CLI to finish rendering (increased from 300ms)
+                await new Promise(r => setTimeout(r, 500));
+                return true;
+            }
+        } catch (e) {
+            log(`[waitForSessionReady] ${tmuxSession} poll error: ${e.message}`);
+        }
+        await new Promise(r => setTimeout(r, pollInterval));
+    }
+    log(`[waitForSessionReady] ${tmuxSession} TIMED OUT after ${timeoutMs}ms`);
+    return false;
+}
+
+/**
+ * Capture tmux pane content for verification.
+ */
+async function captureTmuxPane(tmuxSession) {
+    return new Promise((resolve) => {
+        execFile('tmux', ['capture-pane', '-t', tmuxSession, '-p', '-S', '-30'],
+            { ...EXEC_OPTIONS, maxBuffer: 1024 * 1024 },
+            (error, stdout) => {
+                resolve(error ? '' : stdout);
+            }
+        );
+    });
+}
+
+/**
+ * Wait for a session to be ready, send a prompt, and VERIFY it was received.
+ * Uses a verify-and-retry loop: after sending, checks if Claude CLI started
+ * processing. If it's still idle at the ❯ prompt, retries the send.
+ * Returns true if the prompt was verified as received, false otherwise.
+ */
+async function sendPromptWhenReady(session, prompt, label) {
+    const maxAttempts = 3;
+    log(`${label}: sendPromptWhenReady called for tmux:${session.tmuxSession} session:${session.id.slice(0, 8)}, prompt length: ${prompt.length}`);
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        log(`${label}: Attempt ${attempt}/${maxAttempts}`);
+
+        // Wait for Claude CLI to be ready (only on first attempt; later attempts already waited)
+        if (attempt === 1) {
+            const ready = await waitForSessionReady(session.tmuxSession);
+            log(`${label}: waitForSessionReady returned ${ready}`);
+            if (!ready) {
+                log(`${label}: Timed out waiting for session to be ready, trying to send anyway`);
+            }
+        } else {
+            // On retry, give the CLI a moment to stabilize
+            await new Promise(r => setTimeout(r, 2000));
+            // Re-check readiness
+            const ready = await waitForSessionReady(session.tmuxSession, 10000);
+            log(`${label}: Retry readiness check returned ${ready}`);
+        }
+
+        // Send the prompt (use fallback method on retries)
+        const useFallback = attempt > 1;
+        log(`${label}: Calling sendPromptToSession (attempt ${attempt})${useFallback ? ' [FALLBACK: send-keys]' : ''}`);
+        const result = useFallback
+            ? await sendPromptFallback(session, prompt)
+            : await sendPromptToSession(session.id, prompt);
+        log(`${label}: sendPromptToSession returned ok=${result.ok}${result.error ? ` error=${result.error}` : ''}`);
+
+        if (!result.ok) {
+            log(`${label}: Send failed: ${result.error}`);
+            continue; // Try again
+        }
+
+        // VERIFY: Wait then check if Claude CLI actually started processing
+        await new Promise(r => setTimeout(r, 3000));
+        const paneContent = await captureTmuxPane(session.tmuxSession);
+        const lastLines = paneContent.trim().split('\n').slice(-10).join('\n');
+
+        // Check if agent is still sitting idle at the ❯ prompt with placeholder text
+        const hasPlaceholder = paneContent.includes('Try "');
+        const hasActivity = paneContent.includes('⏺') || paneContent.includes('Thinking') ||
+                           paneContent.includes('thinking') || paneContent.includes('Reading') ||
+                           paneContent.includes('esc to interrupt');
+        const isStillIdle = hasPlaceholder && !hasActivity;
+
+        if (!isStillIdle) {
+            log(`${label}: VERIFIED - prompt received (attempt ${attempt}). Agent is active.`);
+            return true;
+        }
+
+        log(`${label}: VERIFICATION FAILED (attempt ${attempt}) - agent still idle at ❯ prompt`);
+        log(`${label}: Pane last lines:\n${lastLines}`);
     }
+
+    log(`${label}: All ${maxAttempts} attempts failed - prompt never received`);
+    return false;
 }
+
 // ============================================================================
 // Git Worktree Helpers
 // ============================================================================
@@ -375,7 +551,7 @@ async function listWorktreesFromDisk(repoPath) {
 function matchWorktreesWithAgents(worktrees, projectId) {
     // Get all agents for this project
     const projectAgents = Array.from(managedSessions.values())
-        .filter(s => s.projectId === projectId && !s.isLead);
+        .filter(s => s.projectId === projectId);
 
     return worktrees.map(wt => {
         // Find agent using this worktree
@@ -509,8 +685,7 @@ async function getTmuxSessionsInfo(projectId) {
             const projectPath = projectsManager.getProject(projectId)?.path;
             const filteredSessions = sessions.filter(s =>
                 s.agentId ||
-                (projectPath && s.cwd?.startsWith(projectPath)) ||
-                s.sessionName.includes('vibeteam')
+                (projectPath && s.cwd?.startsWith(projectPath))
             );
 
             resolve(filteredSessions);
@@ -570,7 +745,7 @@ async function getProjectState(project) {
 
     // Get agents for health summary
     const projectAgents = Array.from(managedSessions.values())
-        .filter(s => s.projectId === project.id && !s.isLead);
+        .filter(s => s.projectId === project.id);
 
     const healthSummary = {
         totalWorktrees: worktrees.length,
@@ -921,823 +1096,1222 @@ const textTiles = new Map();
 const gitStatusManager = new GitStatusManager();
 /** Project directories manager */
 const projectsManager = new ProjectsManager();
-/** Commit watcher for Lead agents */
-const commitWatcher = new CommitWatcher();
-/** Project leads registry: projectId -> leadId[] */
-const projectLeads = new Map();
-/** Lead work queues: leadId -> LeadWorkItem[] */
-const leadWorkQueues = new Map();
-/** Lead processing timers: leadId -> timeoutId (for cleanup on delete/pause) */
-const leadTimers = new Map();
-/** Lead roles with default prompts */
-const LEAD_ROLE_PROMPTS = {
-    security: `You are a Security Lead agent. Your role is to review code changes for security vulnerabilities.
-
-When triggered by a commit, analyze the changes for:
-- Exposed secrets, API keys, passwords, or tokens
-- SQL injection vulnerabilities
-- XSS (Cross-Site Scripting) risks
-- Command injection risks
-- Insecure dependencies
-- Authentication/authorization issues
-- Data exposure risks
-- Insecure file operations
-- CSRF vulnerabilities
-
-Provide a concise security assessment with:
-1. Severity rating (Critical, High, Medium, Low, None)
-2. Specific issues found with file/line references
-3. Recommended fixes
-
-Be thorough but concise. Focus on actionable findings.`,
-
-    build: `You are a Build Lead agent. Your role is to ensure builds and tests pass after code changes.
-
-When triggered by a commit:
-1. Run the project's build command (npm run build, cargo build, etc.)
-2. Run the test suite
-3. If failures occur:
-   - Analyze the error messages
-   - Identify the root cause
-   - Propose or implement fixes
-
-Report:
-1. Build status (Pass/Fail)
-2. Test results summary
-3. Any failures with details
-4. Actions taken or recommended
-
-Keep the codebase in a deployable state.`,
-
-    optimization: `You are an Optimization Lead agent. Your role is to review code changes for performance issues.
-
-When triggered by a commit, analyze the changes for:
-- N+1 query patterns
-- Unnecessary re-renders (React)
-- Memory leaks
-- Inefficient algorithms (O(n^2) when O(n) is possible)
-- Missing caching opportunities
-- Bundle size impacts
-- Unnecessary dependencies
-- Synchronous operations that could be async
-
-Provide an optimization assessment with:
-1. Performance impact rating (Critical, Significant, Minor, None)
-2. Specific issues with explanations
-3. Suggested optimizations with code examples if helpful
-
-Focus on impactful, practical improvements.`,
-
-    design: `You are a Design Lead agent. Your role is to review UI/UX changes for quality and consistency.
-
-When triggered by a commit affecting UI code, check for:
-- Accessibility issues (ARIA labels, keyboard navigation, color contrast)
-- Inconsistent styling or component usage
-- Responsive design issues
-- UX anti-patterns
-- Missing loading/error states
-- Inconsistent spacing or typography
-- Broken layouts
-
-Provide a design assessment with:
-1. Quality rating (Needs Work, Acceptable, Good, Excellent)
-2. Accessibility issues (must fix)
-3. Consistency issues
-4. UX recommendations
-
-Prioritize accessibility and user experience.`,
-
-    product_designer: `You are a Product Designer agent. When given a feature request:
-
-1. Analyze the requirements thoroughly
-2. Research the existing codebase to understand patterns and conventions
-3. Design a detailed implementation plan including:
-   - Component architecture
-   - Data flow and state management
-   - API changes needed
-   - UI/UX considerations
-   - File changes required
-
-4. Output actionable, step-by-step implementation instructions
-
-Your output will be handed off to an implementation agent. Make sure your plan is:
-- Clear and unambiguous
-- Follows existing project patterns
-- Includes specific file paths and code locations
-- Prioritizes tasks in logical order
-
-Focus on designing practical, implementable solutions.`,
-};
-/** Default trigger modes by role */
-const LEAD_TRIGGER_MODES = {
-    security: 'watching',
-    build: 'watching',
-    optimization: 'manual',
-    design: 'manual',
-    product_designer: 'interactive',
-};
 
 // ============================================================================
-// Pipeline System - Loop Prevention & Stage Management
+// Kanban Board - Task Management System
 // ============================================================================
 
-/** Pipeline data file paths */
-const PIPELINE_DATA_DIR = resolve(expandHome('~/.vibeteam/data'));
-const COMMIT_ORIGINS_FILE = resolve(PIPELINE_DATA_DIR, 'commit-origins.json');
-const PIPELINES_FILE = resolve(PIPELINE_DATA_DIR, 'pipelines.json');
-const PIPELINE_RUNS_FILE = resolve(PIPELINE_DATA_DIR, 'pipeline-runs.json');
-
-/** Default stage prompts */
-const PIPELINE_STAGE_PROMPTS = {
-    safety: `You are the Safety Check stage in an automated pipeline.
-
-Analyze this commit for security vulnerabilities, bugs, and code quality issues.
+const KANBAN_FILE = resolve(expandHome('~/.vibeteam/data/kanban-tasks.json'));
+const VALID_COLUMNS = ['ideas', 'planning', 'in_progress', 'ai_review', 'human_review', 'done'];
 
-If you find ANY issues:
-1. Fix them directly in the code
-2. Commit your fixes with: git commit -m "[pipeline] Fix: <description>"
-3. Push the changes
-
-If no issues found, report "No security issues found."
-
-Always complete your analysis - don't stop until you've reviewed all changed files.`,
+class KanbanManager {
+    constructor() {
+        this.tasks = new Map();
+        this.load();
+    }
 
-    build: `You are the Build Check stage in an automated pipeline.
+    load() {
+        try {
+            if (existsSync(KANBAN_FILE)) {
+                const data = JSON.parse(readFileSync(KANBAN_FILE, 'utf8'));
+                if (Array.isArray(data)) {
+                    data.forEach(t => this.tasks.set(t.id, t));
+                }
+            }
+        } catch (e) {
+            log(`Failed to load kanban tasks: ${e.message}`);
+        }
+    }
 
-Run the build and tests:
-1. npm run build (or appropriate build command)
-2. npm test (or appropriate test command)
+    save() {
+        try {
+            const dir = resolve(expandHome('~/.vibeteam/data'));
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(KANBAN_FILE, JSON.stringify(Array.from(this.tasks.values()), null, 2));
+        } catch (e) {
+            log(`Failed to save kanban tasks: ${e.message}`);
+        }
+    }
 
-If build/tests fail:
-1. Analyze the error
-2. Fix the code causing the failure
-3. Commit with: git commit -m "[pipeline] Fix: <description>"
-4. Re-run build/tests to verify
+    getTasks(projectId) {
+        if (!projectId) return Array.from(this.tasks.values());
+        return Array.from(this.tasks.values()).filter(t => t.projectId === projectId);
+    }
 
-Report: Build status, test results, what was fixed (if anything).`,
+    getTask(id) {
+        return this.tasks.get(id);
+    }
 
-    deploy: `You are the Deploy stage in an automated pipeline.
+    createTask(data) {
+        const task = {
+            id: randomUUID(),
+            projectId: data.projectId,
+            columnId: data.columnId || 'ideas',
+            title: data.title,
+            description: data.description || '',
+            priority: data.priority || 'medium',
+            assignedAgentId: data.assignedAgentId || undefined,
+            position: data.position ?? this.getNextPosition(data.projectId, data.columnId || 'ideas'),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            tags: data.tags || [],
+            attachments: Array.isArray(data.attachments) ? data.attachments : [],
+            archived: false,
+        };
+        this.tasks.set(task.id, task);
+        this.save();
+        return task;
+    }
 
-Deploy the application:
-1. Run: npx vercel --project vibeteam --yes
-2. Capture the preview URL
+    updateTask(id, updates) {
+        const task = this.tasks.get(id);
+        if (!task) return null;
+        const updated = { ...task, ...updates, updatedAt: Date.now() };
+        // Don't let arbitrary fields override id or projectId
+        updated.id = task.id;
+        updated.projectId = task.projectId;
+        this.tasks.set(id, updated);
+        this.save();
+        return updated;
+    }
 
-Report: Deployment status, preview URL.`,
-};
+    deleteTask(id) {
+        const task = this.tasks.get(id);
+        if (!task) return false;
+        this.tasks.delete(id);
+        this.normalizePositions(task.projectId, task.columnId);
+        this.save();
+        return true;
+    }
 
-/**
- * CommitOriginRegistry - Track agent-created commits to prevent loops
- * Persists to ~/.vibeteam/data/commit-origins.json
- */
-class CommitOriginRegistry {
-    /** Map of commit SHA -> origin info */
-    origins = new Map();
+    moveTask(id, toColumn, position) {
+        const task = this.tasks.get(id);
+        if (!task) return null;
+        if (!VALID_COLUMNS.includes(toColumn)) return null;
 
-    /** How long to keep entries (7 days) */
-    MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+        // Clamp position to valid range for target column
+        const targetTasks = Array.from(this.tasks.values())
+            .filter(t => t.projectId === task.projectId && t.columnId === toColumn && t.id !== id);
+        const validPosition = Math.max(0, Math.min(position, targetTasks.length));
 
-    constructor() {
-        this.load();
+        task.columnId = toColumn;
+        task.position = validPosition;
+        task.updatedAt = Date.now();
+        this.tasks.set(id, task);
+        this.normalizePositions(task.projectId, toColumn);
+        this.save();
+        return task;
+    }
+
+    normalizePositions(projectId, columnId) {
+        const columnTasks = Array.from(this.tasks.values())
+            .filter(t => t.projectId === projectId && t.columnId === columnId)
+            .sort((a, b) => a.position - b.position);
+        columnTasks.forEach((task, index) => {
+            if (task.position !== index) {
+                task.position = index;
+                task.updatedAt = Date.now();
+                this.tasks.set(task.id, task);
+            }
+        });
     }
 
-    /**
-     * Register an agent commit
-     * @param {string} sha - Commit SHA
-     * @param {string} agentId - Agent that made the commit
-     * @param {string} runId - Pipeline run ID
-     * @param {string} stageId - Stage ID (safety, build, deploy)
-     */
-    register(sha, agentId, runId, stageId) {
-        this.origins.set(sha, {
-            origin: 'pipeline',
-            agentId,
-            pipelineRunId: runId,
-            stageId,
-            timestamp: Date.now(),
+    getNextPosition(projectId, columnId) {
+        let max = -1;
+        this.tasks.forEach(t => {
+            if (t.projectId === projectId && t.columnId === columnId && t.position > max) {
+                max = t.position;
+            }
         });
-        this.save();
+        return max + 1;
     }
+}
 
-    /**
-     * Check if a commit was made by an agent
-     * @param {string} sha - Commit SHA
-     * @returns {boolean}
-     */
-    isAgentCommit(sha) {
-        return this.origins.has(sha);
-    }
+const kanbanManager = new KanbanManager();
 
-    /**
-     * Get origin info for a commit
-     * @param {string} sha - Commit SHA
-     * @returns {Object|null}
-     */
-    getOrigin(sha) {
-        return this.origins.get(sha) || null;
+function broadcastKanbanTasks(projectId) {
+    broadcast({
+        type: 'kanban_tasks',
+        payload: { tasks: kanbanManager.getTasks(projectId) },
+    });
+}
+
+// ============================================================================
+// Planning Pipeline Manager
+// ============================================================================
+
+const PIPELINES_DIR = resolve(expandHome('~/.vibeteam/data/pipelines'));
+const PIPELINE_PHASES = ['spec', 'plan', 'execute', 'review'];
+
+class PlanningPipelineManager {
+    constructor() {
+        this.pipelines = new Map();
+        this.agentToPipeline = new Map(); // agentId -> pipelineId
+        this._shipTimeouts = new Map(); // pipelineId -> setTimeout handle (kept off pipeline object to avoid circular JSON)
+        this.load();
     }
 
-    /**
-     * Prune entries older than MAX_AGE_MS
-     */
-    prune() {
-        const now = Date.now();
-        let pruned = 0;
-        for (const [sha, info] of this.origins) {
-            if (now - info.timestamp > this.MAX_AGE_MS) {
-                this.origins.delete(sha);
-                pruned++;
+    load() {
+        try {
+            const indexFile = join(PIPELINES_DIR, 'index.json');
+            if (existsSync(indexFile)) {
+                const data = JSON.parse(readFileSync(indexFile, 'utf8'));
+                if (Array.isArray(data)) {
+                    for (const entry of data) {
+                        // Load full state from per-pipeline file
+                        // Try worktreePath first (pipelines with worktrees save there), fall back to projectPath
+                        let pipelineFile = null;
+                        if (entry.worktreePath) {
+                            const worktreeFile = join(entry.worktreePath, '.vibeteam', 'plans', entry.taskId, 'pipeline.json');
+                            if (existsSync(worktreeFile)) pipelineFile = worktreeFile;
+                        }
+                        if (!pipelineFile) {
+                            const projectFile = join(entry.projectPath, '.vibeteam', 'plans', entry.taskId, 'pipeline.json');
+                            if (existsSync(projectFile)) pipelineFile = projectFile;
+                        }
+                        if (pipelineFile) {
+                            try {
+                                const pipeline = JSON.parse(readFileSync(pipelineFile, 'utf8'));
+                                // Backfill worktreeStatus for pipelines created before this field existed
+                                if (pipeline.worktreePath && !pipeline.worktreeStatus) {
+                                    pipeline.worktreeStatus = existsSync(pipeline.worktreePath) ? 'active' : 'cleaned';
+                                }
+                                this.pipelines.set(pipeline.id, pipeline);
+                                // Rebuild agent->pipeline mapping
+                                for (const phase of pipeline.phases) {
+                                    if (phase.agentId && (phase.status === 'running')) {
+                                        this.agentToPipeline.set(phase.agentId, pipeline.id);
+                                    }
+                                }
+                            } catch (e) {
+                                log(`Failed to load pipeline ${entry.taskId}: ${e.message}`);
+                            }
+                        }
+                    }
+                    log(`Loaded ${this.pipelines.size} pipeline(s) from index`);
+                }
             }
+        } catch (e) {
+            log(`Failed to load pipeline index: ${e.message}`);
         }
-        if (pruned > 0) {
-            debug(`Pruned ${pruned} old commit origins`);
-            this.save();
-        }
+        // Recovery: scan project worktree directories for pipeline files not in the index
+        this.scanForOrphanedPipelines();
     }
 
-    /**
-     * Load from disk
-     */
-    load() {
+    scanForOrphanedPipelines() {
         try {
-            if (existsSync(COMMIT_ORIGINS_FILE)) {
-                const data = JSON.parse(readFileSync(COMMIT_ORIGINS_FILE, 'utf-8'));
-                this.origins = new Map(Object.entries(data));
-                debug(`Loaded ${this.origins.size} commit origins`);
+            const projects = projectsManager.getProjects();
+            for (const project of projects) {
+                const repoName = project.path.split('/').filter(Boolean).pop() || 'repo';
+                const worktreesDir = resolve(project.path, '..', `.${repoName}-worktrees`);
+                if (!existsSync(worktreesDir)) continue;
+                // Scan worktree directories for pipeline files
+                const entries = readdirSync(worktreesDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || !entry.name.startsWith('pipeline-')) continue;
+                    const worktreePath = join(worktreesDir, entry.name);
+                    const plansDir = join(worktreePath, '.vibeteam', 'plans');
+                    if (!existsSync(plansDir)) continue;
+                    const taskDirs = readdirSync(plansDir, { withFileTypes: true });
+                    for (const taskDir of taskDirs) {
+                        if (!taskDir.isDirectory()) continue;
+                        const pipelineFile = join(plansDir, taskDir.name, 'pipeline.json');
+                        if (!existsSync(pipelineFile)) continue;
+                        try {
+                            const pipeline = JSON.parse(readFileSync(pipelineFile, 'utf8'));
+                            if (this.pipelines.has(pipeline.id)) continue; // Already loaded
+                            // Backfill worktreeStatus
+                            if (pipeline.worktreePath && !pipeline.worktreeStatus) {
+                                pipeline.worktreeStatus = existsSync(pipeline.worktreePath) ? 'active' : 'cleaned';
+                            }
+                            this.pipelines.set(pipeline.id, pipeline);
+                            // Rebuild agent->pipeline mapping for running phases
+                            for (const phase of (pipeline.phases || [])) {
+                                if (phase.agentId && phase.status === 'running') {
+                                    this.agentToPipeline.set(phase.agentId, pipeline.id);
+                                }
+                            }
+                            if (pipeline.shipAgentId) {
+                                this.agentToPipeline.set(pipeline.shipAgentId, pipeline.id);
+                            }
+                            log(`Recovered orphaned pipeline: ${pipeline.title?.slice(0, 40)} (${pipeline.id.slice(0, 8)})`);
+                        } catch (e) {
+                            // Ignore individual parse errors
+                        }
+                    }
+                }
+            }
+            if (this.pipelines.size > 0) {
+                // Re-save index with recovered pipelines
+                this.save();
             }
         } catch (e) {
-            console.error('Failed to load commit origins:', e);
+            log(`Pipeline recovery scan failed: ${e.message}`);
         }
     }
 
-    /**
-     * Save to disk
-     */
     save() {
         try {
-            if (!existsSync(PIPELINE_DATA_DIR)) {
-                mkdirSync(PIPELINE_DATA_DIR, { recursive: true });
+            if (!existsSync(PIPELINES_DIR)) {
+                mkdirSync(PIPELINES_DIR, { recursive: true });
             }
-            const data = Object.fromEntries(this.origins);
-            writeFileSync(COMMIT_ORIGINS_FILE, JSON.stringify(data, null, 2));
+            // Save lightweight index (include worktreePath so load() can find pipeline files in worktrees)
+            const index = Array.from(this.pipelines.values()).map(p => ({
+                id: p.id,
+                taskId: p.taskId,
+                projectId: p.projectId,
+                projectPath: p.projectPath,
+                worktreePath: p.worktreePath || undefined,
+                status: p.status,
+            }));
+            writeFileSync(join(PIPELINES_DIR, 'index.json'), JSON.stringify(index, null, 2));
         } catch (e) {
-            console.error('Failed to save commit origins:', e);
+            log(`Failed to save pipeline index: ${e.message}`);
         }
     }
-}
-
-/**
- * PipelineManager - Orchestrate pipeline execution
- */
-class PipelineManager {
-    /** Pipeline configs: pipelineId -> PipelineConfig */
-    pipelines = new Map();
-
-    /** Active/recent runs: runId -> PipelineRun */
-    runs = new Map();
-
-    /** Commit origin tracker */
-    commitRegistry = new CommitOriginRegistry();
-
-    /** Processing queue: runId -> { timeoutId, stageIndex } */
-    processing = new Map();
 
-    constructor() {
-        this.load();
-        // Prune old commit origins every hour
-        setInterval(() => this.commitRegistry.prune(), 60 * 60 * 1000);
+    savePipeline(pipeline) {
+        try {
+            const planDir = this.getPlanDir(pipeline);
+            if (!existsSync(planDir)) {
+                mkdirSync(planDir, { recursive: true });
+            }
+            const pipelineJson = JSON.stringify(pipeline, null, 2);
+            writeFileSync(join(planDir, 'pipeline.json'), pipelineJson);
+            // Also save at projectPath so load() can always find it (even if worktree is deleted)
+            if (pipeline.worktreePath && pipeline.projectPath) {
+                const projectPlanDir = join(pipeline.projectPath, '.vibeteam', 'plans', pipeline.taskId);
+                try {
+                    if (!existsSync(projectPlanDir)) {
+                        mkdirSync(projectPlanDir, { recursive: true });
+                    }
+                    writeFileSync(join(projectPlanDir, 'pipeline.json'), pipelineJson);
+                } catch (e) {
+                    // Non-fatal: worktree copy is the primary
+                }
+            }
+            this.save(); // Also save the index
+        } catch (e) {
+            log(`Failed to save pipeline ${pipeline.id}: ${e.message}`);
+        }
     }
 
-    /**
-     * Check if a commit is a pipeline commit (should be skipped)
-     * Three-layer protection:
-     * 1. Commit message prefix [pipeline]
-     * 2. Origin registry check
-     * 3. Co-Author check
-     * @param {Object} commitInfo
-     * @returns {boolean}
-     */
-    isPipelineCommit(commitInfo) {
-        // Layer 1: Message prefix
-        if (commitInfo.message.startsWith('[pipeline]')) {
-            debug(`Skipping pipeline commit (prefix): ${commitInfo.shortSha}`);
-            return true;
-        }
+    getPlanDir(pipeline) {
+        // Use worktree path if available (new pipelines), fall back to projectPath (legacy)
+        const basePath = pipeline.worktreePath || pipeline.projectPath;
+        return join(basePath, '.vibeteam', 'plans', pipeline.taskId);
+    }
 
-        // Layer 2: Origin registry
-        if (this.commitRegistry.isAgentCommit(commitInfo.sha)) {
-            debug(`Skipping pipeline commit (registry): ${commitInfo.shortSha}`);
-            return true;
+    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`);
+            }
         }
 
-        // Layer 3: Claude co-author
-        if (commitInfo.message.includes('Co-Authored-By: Claude')) {
-            debug(`Skipping pipeline commit (co-author): ${commitInfo.shortSha}`);
-            return true;
+        // Create a shared worktree branch for the pipeline
+        const safeName = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
+        const shortId = randomBytes(3).toString('hex');
+        const branch = `pipeline/${safeName}-${shortId}`;
+        let worktreePath;
+        try {
+            worktreePath = await createWorktree(projectPath, branch);
+            log(`Pipeline ${taskId.slice(0, 8)}: Created shared worktree at ${worktreePath} (branch: ${branch})`);
+        } catch (e) {
+            throw new Error(`Failed to create pipeline worktree: ${e.message}`);
         }
 
-        return false;
-    }
-
-    /**
-     * Create a new pipeline config for a project
-     * @param {string} projectId
-     * @param {Object} config
-     * @returns {Object} Created pipeline
-     */
-    createPipeline(projectId, config) {
         const pipeline = {
-            id: randomUUID(),
+            id: taskId, // 1:1 mapping
+            taskId,
             projectId,
-            name: config.name || 'Default Pipeline',
-            enabled: config.enabled !== false,
-            stages: config.stages || [
-                { id: 'safety', name: 'Safety Check', enabled: true, requiresApproval: false, maxRetries: 2 },
-                { id: 'build', name: 'Build Check', enabled: true, requiresApproval: false, maxRetries: 2 },
-                { id: 'deploy', name: 'Deploy', enabled: true, requiresApproval: true, maxRetries: 1 },
-            ],
-            triggerBranches: config.triggerBranches || ['main'],
+            projectPath,
+            worktreePath,  // Shared worktree for all pipeline agents
+            branch,        // Branch name for the worktree
+            worktreeStatus: 'active', // Track worktree lifecycle: 'active' | 'cleaned'
+            title,
+            description,
+            attachments: Array.isArray(attachments) ? attachments : [],
+            status: 'running',
+            currentPhase: null,
+            phases: PIPELINE_PHASES.map(phase => ({
+                phase,
+                status: 'pending',
+            })),
             createdAt: Date.now(),
+            updatedAt: Date.now(),
         };
 
-        this.pipelines.set(pipeline.id, pipeline);
-        this.save();
-        log(`Created pipeline: ${pipeline.name} for project ${projectId.slice(0, 8)}`);
-        return pipeline;
-    }
-
-    /**
-     * Get pipelines for a project
-     * @param {string} projectId
-     * @returns {Array}
-     */
-    getProjectPipelines(projectId) {
-        const result = [];
-        for (const pipeline of this.pipelines.values()) {
-            if (pipeline.projectId === projectId) {
-                result.push(pipeline);
-            }
+        // Create plan directory inside the worktree
+        const planDir = this.getPlanDir(pipeline);
+        if (!existsSync(planDir)) {
+            mkdirSync(planDir, { recursive: true });
         }
-        return result;
-    }
 
-    /**
-     * Get a pipeline by ID
-     * @param {string} pipelineId
-     * @returns {Object|null}
-     */
-    getPipeline(pipelineId) {
-        return this.pipelines.get(pipelineId) || null;
-    }
+        this.pipelines.set(pipeline.id, pipeline);
+        this.savePipeline(pipeline);
+
+        // Update kanban task
+        kanbanManager.updateTask(taskId, {
+            pipelineId: pipeline.id,
+            pipelineStatus: 'running',
+            pipelinePhase: 'spec',
+            columnId: 'planning',
+        });
+        const updatedTask = kanbanManager.getTask(taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+        }
 
-    /**
-     * Update a pipeline
-     * @param {string} pipelineId
-     * @param {Object} updates
-     * @returns {Object|null}
-     */
-    updatePipeline(pipelineId, updates) {
-        const pipeline = this.pipelines.get(pipelineId);
-        if (!pipeline) return null;
+        // Start first phase
+        await this.startPhase(pipeline.id, 'spec');
 
-        Object.assign(pipeline, updates);
-        this.save();
         return pipeline;
     }
 
-    /**
-     * Delete a pipeline
-     * @param {string} pipelineId
-     * @returns {boolean}
-     */
-    deletePipeline(pipelineId) {
-        const deleted = this.pipelines.delete(pipelineId);
-        if (deleted) {
-            this.save();
-        }
-        return deleted;
-    }
-
-    /**
-     * Create a pipeline run for a commit
-     * @param {string} pipelineId
-     * @param {Object} commitInfo
-     * @param {string} triggeredBy - 'commit' or 'manual'
-     * @returns {Object} Created run
-     */
-    createRun(pipelineId, commitInfo, triggeredBy = 'commit') {
+    async startPhase(pipelineId, phase) {
         const pipeline = this.pipelines.get(pipelineId);
-        if (!pipeline) throw new Error('Pipeline not found');
-
-        const run = {
-            id: randomUUID(),
-            pipelineId,
-            projectId: pipeline.projectId,
-            pipelineName: pipeline.name,
-            triggerCommit: commitInfo,
-            triggeredBy,
-            status: 'running',
-            stages: pipeline.stages.filter(s => s.enabled).map(s => ({
-                id: s.id,
-                name: s.name,
-                status: 'pending',
-                requiresApproval: s.requiresApproval,
-                maxRetries: s.maxRetries,
-                retryCount: 0,
-            })),
-            childCommits: [],
-            startedAt: Date.now(),
-            currentStageIndex: 0,
+        if (!pipeline) return;
+
+        const phaseRecord = pipeline.phases.find(p => p.phase === phase);
+        if (!phaseRecord) return;
+
+        pipeline.currentPhase = phase;
+        phaseRecord.status = 'running';
+        phaseRecord.startedAt = Date.now();
+        pipeline.updatedAt = Date.now();
+
+        // Update kanban column based on phase
+        const columnMap = {
+            spec: 'planning',
+            plan: 'planning',
+            execute: 'in_progress',
+            review: 'ai_review',
         };
+        const targetColumn = columnMap[phase];
+        if (targetColumn) {
+            kanbanManager.updateTask(pipeline.taskId, {
+                columnId: targetColumn,
+                pipelinePhase: phase,
+            });
+            const updatedTask = kanbanManager.getTask(pipeline.taskId);
+            if (updatedTask) {
+                broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+            }
+        }
 
-        this.runs.set(run.id, run);
-        this.saveRuns();
-        log(`Created pipeline run: ${run.id.slice(0, 8)} for commit ${commitInfo.shortSha}`);
+        // Generate prompt for this phase
+        const prompt = this.getPromptForPhase(pipeline, phase);
+        const planDir = this.getPlanDir(pipeline);
 
-        // Broadcast run created event
-        broadcast({
-            type: 'pipeline_run_created',
-            payload: { run },
-        });
+        // Agent naming
+        const namePrefix = { spec: 'Spec', plan: 'Plan', execute: 'Exec', review: 'Review' };
+        const agentName = `${namePrefix[phase]}: ${pipeline.title.slice(0, 30)}`;
 
-        return run;
-    }
+        try {
+            // Spawn agent in the shared pipeline worktree (isolated from main)
+            const session = await createSession({
+                name: agentName,
+                cwd: pipeline.worktreePath || pipeline.projectPath,
+                worktree: { enabled: false }, // Worktree already created at pipeline level
+                projectId: pipeline.projectId,
+            });
 
-    /**
-     * Get a pipeline run by ID
-     * @param {string} runId
-     * @returns {Object|null}
-     */
-    getRun(runId) {
-        return this.runs.get(runId) || null;
-    }
+            phaseRecord.agentId = session.id;
+            phaseRecord.agentName = agentName;
+            this.agentToPipeline.set(session.id, pipeline.id);
+
+            this.savePipeline(pipeline);
+            this.broadcastPipeline(pipeline);
+
+            // Wait for Claude CLI to be ready, then send prompt
+            const label = `Pipeline ${pipeline.id.slice(0, 8)} [${phase}]`;
+            sendPromptWhenReady(session, prompt, label).then(ok => {
+                if (!ok) {
+                    log(`${label}: Failed to start ${phase} phase - prompt not sent`);
+                    phaseRecord.status = 'failed';
+                    phaseRecord.error = 'Failed to send prompt to agent';
+                    pipeline.status = 'failed';
+                    pipeline.error = `Failed to send prompt for ${phase} phase`;
+                    pipeline.updatedAt = Date.now();
+                    this.savePipeline(pipeline);
+                    this.broadcastPipeline(pipeline);
+                }
+            }).catch(err => {
+                log(`${label}: UNHANDLED ERROR in sendPromptWhenReady: ${err.message}\n${err.stack}`);
+                phaseRecord.status = 'failed';
+                phaseRecord.error = `Unhandled error: ${err.message}`;
+                pipeline.status = 'failed';
+                pipeline.error = `Unhandled error in ${phase} phase: ${err.message}`;
+                pipeline.updatedAt = Date.now();
+                this.savePipeline(pipeline);
+                this.broadcastPipeline(pipeline);
+            });
 
-    /**
-     * Get runs for a pipeline
-     * @param {string} pipelineId
-     * @param {number} limit
-     * @returns {Array}
-     */
-    getPipelineRuns(pipelineId, limit = 10) {
-        const result = [];
-        for (const run of this.runs.values()) {
-            if (run.pipelineId === pipelineId) {
-                result.push(run);
+        } catch (e) {
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to start ${phase}: ${e.message}`);
+            phaseRecord.status = 'failed';
+            phaseRecord.error = e.message;
+            pipeline.status = 'failed';
+            pipeline.error = `Failed to start ${phase} phase: ${e.message}`;
+            pipeline.updatedAt = Date.now();
+            this.savePipeline(pipeline);
+            this.broadcastPipeline(pipeline);
+
+            // Update kanban
+            kanbanManager.updateTask(pipeline.taskId, { pipelineStatus: 'failed' });
+            const updatedTask = kanbanManager.getTask(pipeline.taskId);
+            if (updatedTask) {
+                broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
             }
         }
-        // Sort by startedAt descending
-        result.sort((a, b) => b.startedAt - a.startedAt);
-        return result.slice(0, limit);
     }
 
-    /**
-     * Start processing the next stage in a run
-     * @param {string} runId
-     */
-    async processNextStage(runId) {
-        const run = this.runs.get(runId);
-        if (!run || run.status !== 'running') return;
-
-        const stageIndex = run.currentStageIndex;
-        if (stageIndex >= run.stages.length) {
-            // All stages complete
-            this.completeRun(runId, 'passed');
-            return;
+    getPromptForPhase(pipeline, phase) {
+        const planDir = this.getPlanDir(pipeline);
+
+        // Build image attachment section if any images are attached
+        let imageSection = '';
+        if (Array.isArray(pipeline.attachments) && pipeline.attachments.length > 0) {
+            imageSection = '\n\n**Attached Images (visual reference - use Read tool to view):**\n' +
+                pipeline.attachments.map(a => `- ${a.path}`).join('\n');
         }
 
-        const stage = run.stages[stageIndex];
+        switch (phase) {
+            case 'spec':
+                return `You are a Specification Agent for a multi-agent planning pipeline.
 
-        // Check if approval is required
-        if (stage.requiresApproval && stage.status === 'pending') {
-            run.status = 'awaiting_approval';
-            stage.status = 'awaiting_approval';
-            this.saveRuns();
+**Task**: ${pipeline.title}
+**Description**: ${pipeline.description || 'No description provided.'}${imageSection}
 
-            broadcast({
-                type: 'pipeline_approval_required',
-                payload: { runId, stageId: stage.id, stageName: stage.name },
-            });
-            return;
-        }
+Your job is to explore the codebase and write a detailed specification document.
 
-        // Execute the stage
-        await this.executeStage(run, stage);
-    }
+**Instructions:**
+1. Explore the project structure and understand the codebase architecture
+2. Identify all files relevant to this task
+3. Analyze the current state of the code related to this task
+4. Write your specification to: ${planDir}/spec.md
 
-    /**
-     * Execute a pipeline stage
-     * @param {Object} run
-     * @param {Object} stage
-     */
-    async executeStage(run, stage) {
-        stage.status = 'running';
-        stage.startedAt = Date.now();
-        this.saveRuns();
-
-        broadcast({
-            type: 'pipeline_stage_started',
-            payload: { runId: run.id, stageId: stage.id, stageName: stage.name },
-        });
+**The spec.md must include:**
+- **Summary**: What needs to be done (1-2 paragraphs)
+- **Current State Analysis**: What exists today, how relevant code works
+- **Files Needing Changes**: List every file that will need modification
+- **Constraints**: Technical constraints, backwards compatibility concerns
+- **Acceptance Criteria**: Clear, testable criteria for completion
+- **Edge Cases**: Potential issues and how to handle them
 
-        try {
-            // Get the project
-            const project = projectsManager.getProject(run.projectId);
-            if (!project) throw new Error('Project not found');
+**IMPORTANT**: Do NOT implement anything. Only analyze and write the specification.
+Write the file to: ${planDir}/spec.md`;
 
-            // Build the prompt for the stage agent
-            const basePrompt = PIPELINE_STAGE_PROMPTS[stage.id] || 'Execute pipeline stage.';
-            const commitContext = `
-Commit being analyzed:
-- SHA: ${run.triggerCommit.sha}
-- Message: ${run.triggerCommit.message}
-- Author: ${run.triggerCommit.author}
-- Files changed: ${run.triggerCommit.filesChanged.join(', ')}
-- Lines: +${run.triggerCommit.additions} -${run.triggerCommit.deletions}
+            case 'plan': {
+                // Check for human review feedback
+                let humanFeedbackSection = '';
+                const humanReviewPath = join(planDir, 'human_review.md');
+                try {
+                    if (existsSync(humanReviewPath)) {
+                        const feedback = readFileSync(humanReviewPath, 'utf-8');
+                        humanFeedbackSection = `
 
-IMPORTANT: If you make any commits, prefix with [pipeline].
-Example: git commit -m "[pipeline] Fix: <description>"
+## IMPORTANT: Human Review Feedback
 
-When done, provide a clear summary of what was checked/done.`;
+The human reviewer has requested changes to the previous implementation. Address this feedback:
 
-            const fullPrompt = `${basePrompt}\n\n${commitContext}`;
+${feedback}
 
-            // Create a session for this stage
-            const sessionName = `Pipeline: ${stage.name} (${run.triggerCommit.shortSha})`;
-            const session = await createSession({
-                name: sessionName,
-                cwd: project.path,
-                projectId: run.projectId,
-                isPipelineAgent: true,
-                pipelineRunId: run.id,
-                pipelineStageId: stage.id,
-            });
+Revise the implementation plan to incorporate these changes. The specification (spec.md) is still valid, but the plan, execution, and review must be redone to address the feedback above.
+`;
+                    }
+                } catch (e) {
+                    log(`Failed to read human_review.md for pipeline ${pipeline.id}: ${e.message}`);
+                }
+
+                return `You are a Planning Agent for a multi-agent planning pipeline.
+
+**Task**: ${pipeline.title}
+**Description**: ${pipeline.description || 'No description provided.'}${imageSection}
+
+Read the specification document at: ${planDir}/spec.md
+
+Your job is to create a detailed implementation plan as a JSON file.
+
+**Instructions:**
+1. Read and understand the specification at ${planDir}/spec.md
+2. Break the work into ordered subtasks with clear dependencies
+3. Write your plan to: ${planDir}/implementation_plan.json${humanFeedbackSection}
+
+**The implementation_plan.json must follow this schema:**
+\`\`\`json
+{
+  "version": 1,
+  "taskTitle": "...",
+  "summary": "Brief overall approach",
+  "architecture": {
+    "approach": "High-level approach description",
+    "keyDecisions": ["Decision 1", "Decision 2"],
+    "risksAndMitigations": [{"risk": "...", "mitigation": "..."}]
+  },
+  "subtasks": [
+    {
+      "id": 1,
+      "title": "Short title",
+      "description": "What to do in detail",
+      "files": ["path/to/file.ts"],
+      "dependencies": [],
+      "verificationStrategy": "How to verify this subtask"
+    }
+  ],
+  "fileScope": ["all/files/that/will/be/touched.ts"],
+  "testStrategy": "Overall testing approach",
+  "estimatedComplexity": "low|medium|high"
+}
+\`\`\`
 
-            stage.agentId = session.id;
-            this.saveRuns();
+**IMPORTANT**: Do NOT implement anything. Only plan.
+Write the file to: ${planDir}/implementation_plan.json`;
+            }
 
-            // Send the prompt to the agent
-            await sendPromptToSession(session.id, fullPrompt);
+            case 'execute':
+                return `You are an Execution Agent for a multi-agent planning pipeline.
 
-            log(`Started pipeline stage: ${stage.name} for run ${run.id.slice(0, 8)}`);
-        } catch (err) {
-            this.stageFailed(run.id, stage.id, err.message);
-        }
-    }
+**Task**: ${pipeline.title}
 
-    /**
-     * Mark a stage as completed
-     * @param {string} runId
-     * @param {string} stageId
-     * @param {string} output
-     */
-    stageCompleted(runId, stageId, output = '') {
-        const run = this.runs.get(runId);
-        if (!run) return;
+Read these files before starting:
+- Specification: ${planDir}/spec.md
+- Implementation Plan: ${planDir}/implementation_plan.json
 
-        const stage = run.stages.find(s => s.id === stageId);
-        if (!stage) return;
+Your job is to implement ALL subtasks from the plan, in order.
 
-        stage.status = 'passed';
-        stage.completedAt = Date.now();
-        stage.output = output;
-        run.currentStageIndex++;
-        this.saveRuns();
+**Instructions:**
+1. Read the spec and plan files above
+2. Implement each subtask in the order specified, respecting dependencies
+3. After completing each subtask, verify it works as described in its verificationStrategy
+4. Document what you did in: ${planDir}/execution_log.md
 
-        log(`Pipeline stage completed: ${stage.name} for run ${runId.slice(0, 8)}`);
+**The execution_log.md should include for each subtask:**
+- Subtask ID and title
+- What was actually done (files modified, approach taken)
+- Any deviations from the plan and why
+- Verification result
 
-        broadcast({
-            type: 'pipeline_stage_completed',
-            payload: { runId, stageId, status: 'passed', output },
-        });
+**IMPORTANT**: Implement everything described in the plan. Be thorough.
+Write your execution log to: ${planDir}/execution_log.md`;
+
+            case 'review':
+                return `You are a Review Agent for a multi-agent planning pipeline.
 
-        // Process next stage
-        this.processNextStage(runId);
+**Task**: ${pipeline.title}
+
+Read these files before starting:
+- Specification: ${planDir}/spec.md
+- Implementation Plan: ${planDir}/implementation_plan.json
+- Execution Log: ${planDir}/execution_log.md
+
+Your job is to verify the implementation against the spec and plan.
+
+**Instructions:**
+1. Read all plan files above
+2. For each subtask in the plan, verify it was implemented correctly
+3. Check that acceptance criteria from the spec are met
+4. Look for bugs, missing edge cases, or incomplete work
+5. Write your review to: ${planDir}/review.md
+
+**The review.md must include:**
+- **Overall Assessment**: PASSED or NEEDS_CHANGES
+- **Subtask Reviews**: For each subtask, whether it was completed correctly
+- **Issues Found**: Any bugs, missing features, or concerns
+- **Suggestions**: Improvements for next iteration (if any)
+
+If the overall assessment is PASSED, the task is complete.
+If NEEDS_CHANGES, list specific items that need to be fixed.
+
+Write your review to: ${planDir}/review.md`;
+
+            default:
+                return '';
+        }
     }
 
-    /**
-     * Mark a stage as failed
-     * @param {string} runId
-     * @param {string} stageId
-     * @param {string} error
-     */
-    stageFailed(runId, stageId, error = '') {
-        const run = this.runs.get(runId);
-        if (!run) return;
-
-        const stage = run.stages.find(s => s.id === stageId);
-        if (!stage) return;
-
-        // Check if we should retry
-        if (stage.retryCount < stage.maxRetries) {
-            stage.retryCount++;
-            stage.status = 'retrying';
-            log(`Pipeline stage retrying (${stage.retryCount}/${stage.maxRetries}): ${stage.name}`);
-            this.saveRuns();
-
-            // Retry after a delay
-            setTimeout(() => this.executeStage(run, stage), 2000);
+    onAgentIdle(agentId) {
+        const pipelineId = this.agentToPipeline.get(agentId);
+        if (!pipelineId) return;
+
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline) return;
+
+        // Handle ship agent completion
+        if (pipeline.shipAgentId === agentId) {
+            if (pipeline.shipPromptPending) {
+                log(`Pipeline ${pipeline.id.slice(0, 8)}: Ship agent idle event received but prompt still pending, ignoring`);
+                return;
+            }
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Ship agent completed (event-driven)`);
+            this.forceCleanupShipAgent(pipeline);
             return;
         }
 
-        stage.status = 'failed';
-        stage.completedAt = Date.now();
-        stage.error = error;
-        run.status = 'failed';
-        run.completedAt = Date.now();
-        this.saveRuns();
+        // Remove mapping FIRST to prevent double-advancement from duplicate stop/session_end events
+        this.agentToPipeline.delete(agentId);
 
-        log(`Pipeline stage failed: ${stage.name} for run ${runId.slice(0, 8)}: ${error}`);
+        if (pipeline.status !== 'running') return;
 
-        broadcast({
-            type: 'pipeline_stage_completed',
-            payload: { runId, stageId, status: 'failed', error },
-        });
+        const currentPhaseRecord = pipeline.phases.find(p => p.agentId === agentId && p.status === 'running');
+        if (!currentPhaseRecord) return;
 
-        broadcast({
-            type: 'pipeline_run_completed',
-            payload: { runId, status: 'failed' },
-        });
+        log(`Pipeline ${pipeline.id.slice(0, 8)}: ${currentPhaseRecord.phase} phase completed (agent idle)`);
+
+        // Mark phase as completed
+        currentPhaseRecord.status = 'completed';
+        currentPhaseRecord.completedAt = Date.now();
+
+        // Persist before advancing so crash between phases doesn't lose state
+        this.savePipeline(pipeline);
+
+        // Update kanban task with phase output summary
+        try {
+            const planDir = this.getPlanDir(pipeline);
+            const phase = currentPhaseRecord.phase;
+            let summary = '';
+            let taskUpdates = {};
+
+            if (phase === 'spec') {
+                const specPath = join(planDir, 'spec.md');
+                if (existsSync(specPath)) {
+                    const content = readFileSync(specPath, 'utf8');
+                    // Extract first 2 paragraphs as summary
+                    const paragraphs = content.split(/\n\n+/).filter(p => p.trim()).slice(0, 2);
+                    summary = paragraphs.join(' ').slice(0, 200);
+                    taskUpdates.description = pipeline.description + '\n\n**Spec Summary:** ' + summary;
+                }
+            } else if (phase === 'plan') {
+                const planPath = join(planDir, 'implementation_plan.json');
+                if (existsSync(planPath)) {
+                    try {
+                        const planData = JSON.parse(readFileSync(planPath, 'utf8'));
+                        const subtaskCount = planData.subtasks?.length || 0;
+                        summary = `${planData.summary || 'Plan created'} (${subtaskCount} subtasks)`;
+                        taskUpdates.description = pipeline.description + '\n\n**Plan:** ' + summary;
+                    } catch (e) {
+                        summary = 'Plan file created';
+                    }
+                }
+            } else if (phase === 'execute') {
+                const execPath = join(planDir, 'execution_log.md');
+                if (existsSync(execPath)) {
+                    const content = readFileSync(execPath, 'utf8');
+                    // Extract first meaningful line as summary
+                    const lines = content.split('\n').filter(l => l.trim() && !l.startsWith('#'));
+                    summary = lines[0]?.slice(0, 200) || 'Execution completed';
+                }
+            } else if (phase === 'review') {
+                const reviewPath = join(planDir, 'review.md');
+                if (existsSync(reviewPath)) {
+                    const content = readFileSync(reviewPath, 'utf8');
+                    // Extract verdict
+                    const passMatch = content.match(/PASSED/i);
+                    const failMatch = content.match(/NEEDS_CHANGES/i);
+                    const verdict = passMatch ? 'PASSED' : failMatch ? 'NEEDS_CHANGES' : 'Unknown';
+                    summary = `Review verdict: ${verdict}`;
+                    taskUpdates.reviewFeedback = content.slice(0, 500);
+                    taskUpdates.reviewStatus = verdict === 'PASSED' ? 'passed' : 'failed';
+                }
+            }
+
+            if (summary) {
+                // Add to pipelineLog
+                const task = kanbanManager.getTask(pipeline.taskId);
+                const existingLog = task?.pipelineLog || [];
+                taskUpdates.pipelineLog = [...existingLog, { phase, summary, timestamp: Date.now() }];
+
+                kanbanManager.updateTask(pipeline.taskId, taskUpdates);
+                const updatedTask = kanbanManager.getTask(pipeline.taskId);
+                if (updatedTask) {
+                    broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+                }
+            }
+        } catch (e) {
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to update task after ${currentPhaseRecord.phase}: ${e.message}`);
+        }
+
+        // Advance to next phase
+        this.advancePhase(pipeline.id);
     }
 
-    /**
-     * Complete a pipeline run
-     * @param {string} runId
-     * @param {string} status
-     */
-    completeRun(runId, status) {
-        const run = this.runs.get(runId);
-        if (!run) return;
+    onAgentError(agentId) {
+        const pipelineId = this.agentToPipeline.get(agentId);
+        if (!pipelineId) return;
+
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline || pipeline.status !== 'running') return;
 
-        run.status = status;
-        run.completedAt = Date.now();
-        this.saveRuns();
+        const currentPhaseRecord = pipeline.phases.find(p => p.agentId === agentId && p.status === 'running');
+        if (!currentPhaseRecord) return;
 
-        log(`Pipeline run completed: ${runId.slice(0, 8)} with status ${status}`);
+        log(`Pipeline ${pipeline.id.slice(0, 8)}: ${currentPhaseRecord.phase} phase failed (agent offline)`);
 
-        broadcast({
-            type: 'pipeline_run_completed',
-            payload: { runId, status },
-        });
+        currentPhaseRecord.status = 'failed';
+        currentPhaseRecord.error = 'Agent went offline';
+        this.agentToPipeline.delete(agentId);
+
+        pipeline.status = 'failed';
+        pipeline.error = `${currentPhaseRecord.phase} phase failed: agent went offline`;
+        pipeline.updatedAt = Date.now();
+        this.savePipeline(pipeline);
+        this.broadcastPipeline(pipeline);
+
+        // Update kanban
+        kanbanManager.updateTask(pipeline.taskId, { pipelineStatus: 'failed' });
+        const updatedTask = kanbanManager.getTask(pipeline.taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+        }
+        this.cleanupAgents(pipeline);
+        this.cleanupWorktree(pipeline);
+        this.scheduleCleanup(pipeline.id);
     }
 
-    /**
-     * Approve a pending stage
-     * @param {string} runId
-     * @param {string} stageId
-     * @param {boolean} approved
-     */
-    approveStage(runId, stageId, approved) {
-        const run = this.runs.get(runId);
-        if (!run) return false;
-
-        const stage = run.stages.find(s => s.id === stageId);
-        if (!stage || stage.status !== 'awaiting_approval') return false;
-
-        if (approved) {
-            run.status = 'running';
-            stage.status = 'pending';
-            this.saveRuns();
-            this.executeStage(run, stage);
-        } else {
-            this.stageFailed(runId, stageId, 'Approval denied');
+    async advancePhase(pipelineId) {
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline || pipeline.status !== 'running') return;
+
+        const currentIdx = PIPELINE_PHASES.indexOf(pipeline.currentPhase);
+        const nextIdx = currentIdx + 1;
+
+        if (nextIdx >= PIPELINE_PHASES.length) {
+            // All phases complete
+            pipeline.status = 'completed';
+            pipeline.currentPhase = null;
+            pipeline.updatedAt = Date.now();
+            this.savePipeline(pipeline);
+            this.broadcastPipeline(pipeline);
+
+            // Move task to human_review
+            kanbanManager.updateTask(pipeline.taskId, {
+                columnId: 'human_review',
+                pipelineStatus: 'completed',
+                pipelinePhase: null,
+            });
+            const updatedTask = kanbanManager.getTask(pipeline.taskId);
+            if (updatedTask) {
+                broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+            }
+
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: All phases completed!`);
+            this.cleanupAgents(pipeline);
+            this.scheduleCleanup(pipeline.id);
+            return;
         }
 
-        return true;
+        const nextPhase = PIPELINE_PHASES[nextIdx];
+        this.savePipeline(pipeline);
+        this.broadcastPipeline(pipeline);
+
+        // Small delay before starting next phase
+        setTimeout(() => {
+            this.startPhase(pipelineId, nextPhase);
+        }, 3000);
     }
 
-    /**
-     * Cancel a pipeline run
-     * @param {string} runId
-     */
-    cancelRun(runId) {
-        const run = this.runs.get(runId);
-        if (!run || run.status === 'passed' || run.status === 'failed') return false;
+    async cancelPipeline(pipelineId) {
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline) return null;
 
-        run.status = 'cancelled';
-        run.completedAt = Date.now();
+        // Mark running phase as failed/cancelled
+        const runningPhase = pipeline.phases.find(p => p.status === 'running');
+        if (runningPhase) {
+            runningPhase.status = 'failed';
+            runningPhase.error = 'Cancelled';
+        }
 
-        // Mark pending stages as cancelled
-        for (const stage of run.stages) {
-            if (stage.status === 'pending' || stage.status === 'awaiting_approval') {
-                stage.status = 'cancelled';
-            }
+        // Mark remaining pending phases as skipped
+        pipeline.phases.forEach(p => {
+            if (p.status === 'pending') p.status = 'skipped';
+        });
+
+        pipeline.status = 'cancelled';
+        pipeline.currentPhase = null;
+        pipeline.updatedAt = Date.now();
+        this.savePipeline(pipeline);
+        this.broadcastPipeline(pipeline);
+
+        // Cleanup ALL agents from all phases
+        this.cleanupAgents(pipeline);
+
+        // Update kanban
+        kanbanManager.updateTask(pipeline.taskId, {
+            pipelineStatus: 'cancelled',
+            pipelinePhase: null,
+        });
+        const updatedTask = kanbanManager.getTask(pipeline.taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
         }
 
-        this.saveRuns();
+        log(`Pipeline ${pipelineId.slice(0, 8)}: Cancelled`);
+        this.cleanupWorktree(pipeline);
+        this.scheduleCleanup(pipeline.id);
+        return pipeline;
+    }
 
-        broadcast({
-            type: 'pipeline_run_completed',
-            payload: { runId, status: 'cancelled' },
+    async retryPipeline(pipelineId) {
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline || pipeline.status !== 'failed') return null;
+
+        // Find the failed phase
+        const failedPhase = pipeline.phases.find(p => p.status === 'failed');
+        if (!failedPhase) return null;
+
+        // Reset failed phase
+        failedPhase.status = 'pending';
+        failedPhase.error = undefined;
+        failedPhase.agentId = undefined;
+        failedPhase.agentName = undefined;
+        failedPhase.startedAt = undefined;
+        failedPhase.completedAt = undefined;
+
+        pipeline.status = 'running';
+        pipeline.error = undefined;
+        pipeline.updatedAt = Date.now();
+
+        // Update kanban
+        kanbanManager.updateTask(pipeline.taskId, {
+            pipelineStatus: 'running',
+            pipelinePhase: failedPhase.phase,
         });
+        const updatedTask = kanbanManager.getTask(pipeline.taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+        }
 
-        return true;
+        // Restart the failed phase
+        await this.startPhase(pipelineId, failedPhase.phase);
+
+        return pipeline;
     }
 
-    /**
-     * Register a commit made by a pipeline agent
-     * @param {string} sha
-     * @param {string} agentId
-     * @param {string} runId
-     * @param {string} stageId
-     */
-    registerAgentCommit(sha, agentId, runId, stageId) {
-        this.commitRegistry.register(sha, agentId, runId, stageId);
+    async requestChanges(pipelineId, feedback) {
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline || pipeline.status !== 'completed') return null;
+
+        // Write human feedback to plan directory
+        const planDir = this.getPlanDir(pipeline);
+        if (!existsSync(planDir)) {
+            mkdirSync(planDir, { recursive: true });
+        }
+        writeFileSync(join(planDir, 'human_review.md'), feedback);
+
+        // Reset plan, execute, review phases to pending (keep spec)
+        for (const phase of pipeline.phases) {
+            if (phase.phase !== 'spec') {
+                phase.status = 'pending';
+                phase.error = undefined;
+                phase.agentId = undefined;
+                phase.agentName = undefined;
+                phase.startedAt = undefined;
+                phase.completedAt = undefined;
+            }
+        }
 
-        // Also track in the run
-        const run = this.runs.get(runId);
-        if (run && !run.childCommits.includes(sha)) {
-            run.childCommits.push(sha);
-            this.saveRuns();
+        pipeline.status = 'running';
+        pipeline.currentPhase = 'plan';
+        pipeline.error = undefined;
+        pipeline.updatedAt = Date.now();
+
+        // Update kanban task
+        kanbanManager.updateTask(pipeline.taskId, {
+            columnId: 'planning',
+            pipelineStatus: 'running',
+            pipelinePhase: 'plan',
+            humanNotes: feedback,
+        });
+        const updatedTask = kanbanManager.getTask(pipeline.taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
         }
+
+        this.savePipeline(pipeline);
+        this.broadcastPipeline(pipeline);
+
+        // Restart from plan phase
+        await this.startPhase(pipelineId, 'plan');
+
+        return pipeline;
     }
 
-    /**
-     * Handle agent session ending (stage completion detection)
-     * @param {string} sessionId
-     */
-    handleAgentSessionEnd(sessionId) {
-        // Find the run/stage for this agent
-        for (const run of this.runs.values()) {
-            for (const stage of run.stages) {
-                if (stage.agentId === sessionId && stage.status === 'running') {
-                    // Agent finished - mark stage as complete
-                    // In a real implementation, we'd check the actual outcome
-                    this.stageCompleted(run.id, stage.id, 'Stage completed');
-                    return;
+    async shipToMain(pipelineId, targetBranch) {
+        const pipeline = this.getPipeline(pipelineId);
+        if (!pipeline) return null;
+        if (pipeline.status !== 'completed') {
+            throw new Error('Pipeline must be completed before shipping');
+        }
+        if (pipeline.shipAgentId) {
+            throw new Error('Ship agent already running');
+        }
+
+        const mergeTo = targetBranch || 'main';
+        const pipelineBranch = pipeline.branch || 'main';
+        const worktreeCwd = pipeline.worktreePath || pipeline.projectPath;
+
+        const prompt = `You are a Ship Agent. Your job is to commit the work done in the pipeline worktree for task "${pipeline.title}", then merge it into ${mergeTo}.
+
+You are running in the pipeline worktree at: ${worktreeCwd}
+The pipeline branch is: ${pipelineBranch}
+The target branch to merge into is: ${mergeTo}
+
+Steps:
+1. Run \`git status\` to see all changes in this worktree
+2. Stage all relevant changes (avoid .vibeteam/ directory)
+3. Create a descriptive commit message based on the task: "${pipeline.title}"
+4. Commit the changes to the pipeline branch
+5. Now switch to the main repo and merge into ${mergeTo}:
+   - Run \`git -C ${pipeline.projectPath} checkout ${mergeTo}\` (if the branch doesn't exist, create it with \`git -C ${pipeline.projectPath} checkout -b ${mergeTo}\`)
+   - Run \`git -C ${pipeline.projectPath} merge ${pipelineBranch}\`
+6. Push ${mergeTo}: \`git -C ${pipeline.projectPath} push origin ${mergeTo}\`
+7. If there are merge conflicts, resolve them
+
+After pushing, your work is done.`;
+
+        try {
+            const session = await createSession({
+                name: `Ship: ${pipeline.title.slice(0, 30)}`,
+                cwd: worktreeCwd, // Run in the pipeline worktree so it can see & commit the changes
+                worktree: { enabled: false }, // Don't create another worktree
+                projectId: pipeline.projectId,
+            });
+
+            pipeline.shipAgentId = session.id;
+            this.agentToPipeline.set(session.id, pipeline.id);
+            pipeline.updatedAt = Date.now();
+
+            // Watchdog: force-cleanup ship agent after 5 minutes if event-driven cleanup never fires
+            // Store timeout handle in a separate Map (NOT on pipeline object) to avoid
+            // circular reference errors when JSON.stringify serializes the pipeline.
+            const shipTimeoutHandle = setTimeout(() => {
+                if (pipeline.shipAgentId === session.id) {
+                    log(`Pipeline ${pipeline.id.slice(0, 8)}: Ship agent timed out after 5 minutes, forcing cleanup`);
+                    pipeline.shipPromptPending = false; // Clear stuck flag so cleanup can proceed
+                    this.forceCleanupShipAgent(pipeline);
                 }
-            }
+            }, 300_000); // 5 minutes
+            this._shipTimeouts.set(pipeline.id, shipTimeoutHandle);
+
+            this.savePipeline(pipeline);
+            this.broadcastPipeline(pipeline);
+
+            // Use sendPromptWhenReady — the SAME proven function that works for all phases
+            // (spec, plan, execute, review). It polls for the ❯ prompt before sending.
+            const label = `Pipeline ${pipeline.id.slice(0, 8)} [ship]`;
+            pipeline.shipPromptPending = true;
+
+            sendPromptWhenReady(session, prompt, label).then(ok => {
+                pipeline.shipPromptPending = false;
+                if (!ok) {
+                    log(`${label}: Failed to deliver ship prompt after all attempts`);
+                    // Don't cleanup — leave the agent alive so user can manually send prompt
+                }
+            }).catch(err => {
+                pipeline.shipPromptPending = false;
+                log(`${label}: UNHANDLED ERROR in ship sendPromptWhenReady: ${err.message}\n${err.stack}`);
+            });
+
+            return pipeline;
+        } catch (e) {
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to start ship agent: ${e.message}`);
+            throw e;
+        }
+    }
+
+    getPipeline(id) {
+        let pipeline = this.pipelines.get(id);
+        if (!pipeline) {
+            pipeline = this.loadPipelineFromDisk(id);
         }
+        return pipeline;
     }
 
     /**
-     * Load pipelines from disk
+     * Try to reload a pipeline from disk that was cleaned up from memory.
+     * Pipeline ID === task ID, so we look up the task to get the project path.
      */
-    load() {
+    loadPipelineFromDisk(pipelineId) {
         try {
-            if (existsSync(PIPELINES_FILE)) {
-                const data = JSON.parse(readFileSync(PIPELINES_FILE, 'utf-8'));
-                if (Array.isArray(data)) {
-                    for (const p of data) {
-                        this.pipelines.set(p.id, p);
+            const task = kanbanManager.getTask(pipelineId);
+            if (!task?.projectId) return null;
+            const project = projectsManager.getProject(task.projectId);
+            if (!project?.path) return null;
+
+            // Check main project path first
+            const pipelineFile = join(project.path, '.vibeteam', 'plans', pipelineId, 'pipeline.json');
+            if (existsSync(pipelineFile)) {
+                const pipeline = JSON.parse(readFileSync(pipelineFile, 'utf8'));
+                this.pipelines.set(pipeline.id, pipeline);
+                log(`Pipeline ${pipelineId.slice(0, 8)}: Reloaded from disk`);
+                return pipeline;
+            }
+
+            // Check worktree directories (pipelines run in worktrees store files there)
+            const repoName = getRepoName(project.path);
+            const worktreesDir = resolve(project.path, '..', `.${repoName}-worktrees`);
+            if (existsSync(worktreesDir)) {
+                const entries = readdirSync(worktreesDir);
+                for (const entry of entries) {
+                    const wtPipelineFile = join(worktreesDir, entry, '.vibeteam', 'plans', pipelineId, 'pipeline.json');
+                    if (existsSync(wtPipelineFile)) {
+                        const pipeline = JSON.parse(readFileSync(wtPipelineFile, 'utf8'));
+                        this.pipelines.set(pipeline.id, pipeline);
+                        log(`Pipeline ${pipelineId.slice(0, 8)}: Reloaded from worktree disk`);
+                        return pipeline;
                     }
                 }
-                debug(`Loaded ${this.pipelines.size} pipelines`);
             }
+
+            return null;
         } catch (e) {
-            console.error('Failed to load pipelines:', e);
+            log(`Failed to reload pipeline ${pipelineId.slice(0, 8)} from disk: ${e.message}`);
+            return null;
         }
+    }
 
-        // Load runs
-        try {
-            if (existsSync(PIPELINE_RUNS_FILE)) {
-                const data = JSON.parse(readFileSync(PIPELINE_RUNS_FILE, 'utf-8'));
-                if (Array.isArray(data)) {
-                    for (const r of data) {
-                        this.runs.set(r.id, r);
-                    }
-                }
-                debug(`Loaded ${this.runs.size} pipeline runs`);
+    getPipelines(projectId) {
+        if (!projectId) return Array.from(this.pipelines.values());
+        return Array.from(this.pipelines.values()).filter(p => p.projectId === projectId);
+    }
+
+    getActivePipelines() {
+        return Array.from(this.pipelines.values()).filter(p => p.status === 'running');
+    }
+
+    /**
+     * Called when a session is manually deleted. If the session is a ship agent,
+     * clear pipeline.shipAgentId and cancel the watchdog.
+     */
+    onSessionDeleted(sessionId) {
+        const pipelineId = this.agentToPipeline.get(sessionId);
+        if (!pipelineId) return;
+
+        const pipeline = this.pipelines.get(pipelineId);
+        if (!pipeline) return;
+
+        this.agentToPipeline.delete(sessionId);
+
+        if (pipeline.shipAgentId === sessionId) {
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Ship agent manually deleted, clearing shipAgentId`);
+            const th = this._shipTimeouts.get(pipeline.id);
+            if (th) {
+                clearTimeout(th);
+                this._shipTimeouts.delete(pipeline.id);
             }
-        } catch (e) {
-            console.error('Failed to load pipeline runs:', e);
+            pipeline.shipAgentId = undefined;
+            pipeline.updatedAt = Date.now();
+            this.savePipeline(pipeline);
+            this.broadcastPipeline(pipeline);
         }
     }
 
     /**
-     * Save pipelines to disk
+     * Force-cleanup a ship agent. Called by onAgentIdle (event-driven) or the timeout watchdog.
+     * Idempotent: returns early if shipAgentId is already cleared.
      */
-    save() {
-        try {
-            if (!existsSync(PIPELINE_DATA_DIR)) {
-                mkdirSync(PIPELINE_DATA_DIR, { recursive: true });
+    forceCleanupShipAgent(pipeline) {
+        if (!pipeline.shipAgentId) return;
+
+        const agentId = pipeline.shipAgentId;
+        log(`Pipeline ${pipeline.id.slice(0, 8)}: Cleaning up ship agent (${agentId.slice(0, 8)})`);
+
+        // Clear the watchdog timeout if it exists
+        const timeoutHandle = this._shipTimeouts.get(pipeline.id);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            this._shipTimeouts.delete(pipeline.id);
+        }
+
+        // Remove agent-to-pipeline mapping
+        this.agentToPipeline.delete(agentId);
+
+        // Move task to done
+        const task = kanbanManager.getTask(pipeline.taskId);
+        const existingLog = task?.pipelineLog || [];
+        kanbanManager.updateTask(pipeline.taskId, {
+            columnId: 'done',
+            pipelineLog: [...existingLog, { phase: 'ship', summary: 'Changes committed and pushed', timestamp: Date.now() }],
+        });
+        const updatedTask = kanbanManager.getTask(pipeline.taskId);
+        if (updatedTask) {
+            broadcast({ type: 'kanban_task_updated', payload: { task: updatedTask } });
+        }
+
+        // Delete the ship agent session
+        deleteSession(agentId).catch(e => {
+            log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to cleanup ship agent: ${e.message}`);
+        });
+
+        // Cleanup all phase agents
+        this.cleanupAgents(pipeline);
+
+        // NOTE: Do NOT call cleanupWorktree - worktree deletion is manual per spec
+
+        // Clear shipAgentId and broadcast - preserve worktree for user inspection
+        pipeline.shipAgentId = undefined;
+        pipeline.worktreeStatus = 'active';
+        pipeline.updatedAt = Date.now();
+        this.savePipeline(pipeline);
+        this.broadcastPipeline(pipeline);
+    }
+
+    broadcastPipeline(pipeline) {
+        broadcast({ type: 'pipeline_updated', payload: { pipeline } });
+    }
+
+    async cleanupAgents(pipeline) {
+        for (const phase of pipeline.phases) {
+            if (phase.agentId) {
+                this.agentToPipeline.delete(phase.agentId);
+                deleteSession(phase.agentId).catch(e => {
+                    log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to cleanup ${phase.phase} agent: ${e.message}`);
+                });
             }
-            const data = Array.from(this.pipelines.values());
-            writeFileSync(PIPELINES_FILE, JSON.stringify(data, null, 2));
-        } catch (e) {
-            console.error('Failed to save pipelines:', e);
+        }
+        // Also clean up the ship agent if present
+        if (pipeline.shipAgentId) {
+            this.agentToPipeline.delete(pipeline.shipAgentId);
+            deleteSession(pipeline.shipAgentId).catch(e => {
+                log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to cleanup ship agent: ${e.message}`);
+            });
         }
     }
 
     /**
-     * Save pipeline runs to disk
+     * Remove the pipeline's shared worktree (called after ship or cancel).
      */
-    saveRuns() {
-        try {
-            if (!existsSync(PIPELINE_DATA_DIR)) {
-                mkdirSync(PIPELINE_DATA_DIR, { recursive: true });
-            }
-            // Only save recent runs (last 50)
-            const runs = Array.from(this.runs.values())
-                .sort((a, b) => b.startedAt - a.startedAt)
-                .slice(0, 50);
-            writeFileSync(PIPELINE_RUNS_FILE, JSON.stringify(runs, null, 2));
-        } catch (e) {
-            console.error('Failed to save pipeline runs:', e);
+    cleanupWorktree(pipeline) {
+        if (pipeline.worktreePath && pipeline.projectPath) {
+            removeWorktree(pipeline.projectPath, pipeline.worktreePath).catch(e => {
+                log(`Pipeline ${pipeline.id.slice(0, 8)}: Failed to remove worktree: ${e.message}`);
+            });
         }
+        pipeline.worktreeStatus = 'cleaned';
+    }
+
+    /**
+     * Schedule cleanup of a terminal-state pipeline from memory.
+     * Keeps it in memory for 5 minutes for debugging/UI display, then removes.
+     * The on-disk pipeline.json persists permanently for history.
+     */
+    scheduleCleanup(pipelineId) {
+        setTimeout(() => {
+            const pipeline = this.pipelines.get(pipelineId);
+            if (pipeline && pipeline.status !== 'running') {
+                this.pipelines.delete(pipelineId);
+                this.save(); // Update index.json
+                log(`Pipeline ${pipelineId.slice(0, 8)}: Cleaned up from memory`);
+            }
+        }, 300_000); // 5 minutes
     }
 }
 
-/** Pipeline manager instance */
-const pipelineManager = new PipelineManager();
+const pipelineManager = new PlanningPipelineManager();
 
 /** Active voice transcription sessions (WebSocket client → Deepgram connection) */
 const voiceSessions = new Map();
@@ -1952,6 +2526,9 @@ function pollOutput(session) {
             if (response && response !== tracker.lastResponse) {
                 tracker.lastResponse = response;
 
+                // Update lastActivity when output is streaming - prevents false working timeouts
+                session.lastActivity = Date.now();
+
                 // Broadcast output to clients
                 broadcast({
                     type: 'output',
@@ -2328,7 +2905,7 @@ function pollPermissions(sessionId, tmuxSession) {
             // Update session status
             const session = managedSessions.get(sessionId);
             if (session) {
-                session.status = 'waiting';
+                session.status = 'needs_attention';
                 session.currentTool = prompt.tool;
                 broadcastSessions();
             }
@@ -2344,7 +2921,7 @@ function pollPermissions(sessionId, tmuxSession) {
             });
             // Reset session status
             const session = managedSessions.get(sessionId);
-            if (session && session.status === 'waiting') {
+            if (session && session.status === 'needs_attention') {
                 session.status = 'working';
                 session.currentTool = undefined;
                 broadcastSessions();
@@ -2450,7 +3027,9 @@ async function createSession(options = {}) {
     // Use project's defaultWorktree setting if not explicitly specified
     let worktreeInfo = null;
     let worktreeOpts = options.worktree;
-    if (!worktreeOpts && project?.defaultWorktree) {
+    // Only apply project default if no explicit worktree choice was made
+    // (worktree not in request at all, vs explicitly { enabled: false })
+    if (worktreeOpts === undefined && project?.defaultWorktree) {
         worktreeOpts = { enabled: true };
     }
     if (worktreeOpts?.enabled) {
@@ -2572,6 +3151,7 @@ async function createSession(options = {}) {
                 name,
                 tmuxSession,
                 status: 'idle',
+                statusVersion: 0,
                 createdAt: Date.now(),
                 lastActivity: Date.now(),
                 cwd,
@@ -2603,11 +3183,6 @@ function getSessions() {
         ...session,
         gitStatus: gitStatusManager.getStatus(session.id) ?? undefined,
         projectId: session.projectId ?? undefined,
-        // Lead-specific fields
-        isLead: session.isLead ?? undefined,
-        leadConfig: session.leadConfig ?? undefined,
-        workQueue: session.workQueue ?? undefined,
-        lastProcessedCommit: session.lastProcessedCommit ?? undefined,
     }));
 }
 /**
@@ -2684,8 +3259,10 @@ async function deleteSession(id) {
 async function sendPromptToSession(id, prompt) {
     const session = managedSessions.get(id);
     if (!session) {
+        log(`[sendPromptToSession] Session ${id.slice(0, 8)} NOT FOUND in managedSessions`);
         return { ok: false, error: 'Session not found' };
     }
+    log(`[sendPromptToSession] Found session ${session.name} (${id.slice(0, 8)}), tmux:${session.tmuxSession}`);
     // Clear stale Claude link before sending prompt so next event can re-link
     const timeSinceActivity = Date.now() - session.lastActivity;
     if (session.claudeSessionId && timeSinceActivity > 60000) { // 1 minute stale
@@ -2703,6 +3280,7 @@ async function sendPromptToSession(id, prompt) {
         session.status = 'working';
         session.currentTool = undefined;
         if (prevStatus !== 'working') {
+            session.statusVersion = (session.statusVersion || 0) + 1;
             broadcastSessions();
         }
         log(`Prompt sent to ${session.name}: ${prompt.slice(0, 50)}...`);
@@ -2718,7 +3296,8 @@ async function sendPromptToSession(id, prompt) {
  * Check if tmux sessions are still alive and update status
  */
 function checkSessionHealth() {
-    exec('tmux list-sessions -F "#{session_name}"', EXEC_OPTIONS, (error, stdout) => {
+    // Get both tmux session list and pane process info
+    execFile('tmux', ['list-sessions', '-F', '#{session_name}'], EXEC_OPTIONS, (error, stdout) => {
         if (error) {
             // tmux might not be running
             for (const session of managedSessions.values()) {
@@ -2732,15 +3311,71 @@ function checkSessionHealth() {
         let changed = false;
         for (const session of managedSessions.values()) {
             const isAlive = activeSessions.has(session.tmuxSession);
-            const newStatus = isAlive ? (session.status === 'offline' ? 'idle' : session.status) : 'offline';
-            if (session.status !== newStatus) {
-                session.status = newStatus;
+            if (!isAlive) {
+                if (session.status !== 'offline') {
+                    session.status = 'offline';
+                    session.statusVersion = (session.statusVersion || 0) + 1;
+                    changed = true;
+                    // Notify pipeline manager of agent going offline
+                    pipelineManager.onAgentError(session.id);
+                }
+            } else if (session.status === 'offline') {
+                // Recover from offline: check if session was recently active
+                // If lastActivity is recent (within timeout), preserve working state
+                const timeSinceActivity = Date.now() - session.lastActivity;
+                if (timeSinceActivity < WORKING_TIMEOUT_MS) {
+                    session.status = 'working';
+                } else {
+                    session.status = 'idle';
+                }
+                session.statusVersion = (session.statusVersion || 0) + 1;
+                changed = true;
+            }
+        }
+        if (changed) {
+            broadcastSessions();
+            saveSessions();
+        }
+        // Also check if the Claude process inside each live tmux pane is still running
+        // This detects frozen sessions where tmux is alive but Claude has died
+        checkTmuxPaneProcesses(activeSessions);
+    });
+}
+/**
+ * Check if the Claude process inside each tmux pane is still alive.
+ * Detects frozen sessions where tmux is alive but Claude has died or is unresponsive.
+ */
+function checkTmuxPaneProcesses(activeSessions) {
+    execFile('tmux', ['list-panes', '-a', '-F', '#{session_name} #{pane_pid} #{pane_dead}'], EXEC_OPTIONS, (error, stdout) => {
+        if (error) return;
+        const paneInfo = new Map();
+        for (const line of stdout.trim().split('\n')) {
+            const parts = line.split(' ');
+            const sessionName = parts[0];
+            const panePid = parts[1];
+            const paneDead = parts[2];
+            if (sessionName && panePid) {
+                paneInfo.set(sessionName, { pid: parseInt(panePid, 10), dead: paneDead === '1' });
+            }
+        }
+        let changed = false;
+        for (const session of managedSessions.values()) {
+            if (!activeSessions.has(session.tmuxSession)) continue;
+            if (session.status === 'offline' || session.status === 'stopped') continue;
+            const pane = paneInfo.get(session.tmuxSession);
+            if (!pane) continue;
+            if (pane.dead) {
+                // Pane process died but tmux session is alive — mark offline
+                log(`Session "${session.name}" pane process is dead (pid ${pane.pid}), marking offline`);
+                session.status = 'offline';
+                session.statusVersion = (session.statusVersion || 0) + 1;
+                session.currentTool = undefined;
                 changed = true;
             }
         }
         if (changed) {
             broadcastSessions();
-            saveSessions(); // Persist state changes
+            saveSessions();
         }
     });
 }
@@ -2757,6 +3392,7 @@ function checkWorkingTimeout() {
             if (timeSinceActivity > WORKING_TIMEOUT_MS) {
                 log(`Session "${session.name}" timed out after ${Math.round(timeSinceActivity / 1000)}s of no activity`);
                 session.status = 'idle';
+                session.statusVersion = (session.statusVersion || 0) + 1;
                 session.currentTool = undefined;
                 changed = true;
             }
@@ -2799,12 +3435,8 @@ function loadSessions() {
         if (Array.isArray(data.sessions)) {
             for (const session of data.sessions) {
                 // Mark all as offline initially - health check will update
-                // For leads, set to watching; for regular sessions, set to offline
-                if (session.isLead) {
-                    session.status = 'watching';
-                } else {
-                    session.status = 'offline';
-                }
+                session.status = 'offline';
+                session.statusVersion = 0; // Reset version on load
                 session.currentTool = undefined;
                 managedSessions.set(session.id, session);
                 // Track git status if session has a cwd (pass worktree info for proper ahead/behind tracking)
@@ -2841,6 +3473,7 @@ function broadcastSessions() {
     const stateHash = JSON.stringify(sessions.map(s => ({
         id: s.id,
         status: s.status,
+        statusVersion: s.statusVersion,
         currentTool: s.currentTool,
         currentActivity: s.currentActivity,
         lastActivity: s.lastActivity,
@@ -2874,26 +3507,6 @@ function broadcastProjects() {
     });
 }
 
-/**
- * Broadcast pipelines to all clients
- */
-function broadcastPipelines() {
-    broadcast({
-        type: 'pipelines',
-        payload: Array.from(pipelineManager.pipelines.values()),
-    });
-}
-
-/**
- * Broadcast pipeline runs to all clients
- */
-function broadcastPipelineRuns() {
-    broadcast({
-        type: 'pipeline_runs',
-        payload: Array.from(pipelineManager.runs.values()),
-    });
-}
-
 // ============================================================================
 // Text Tiles (Grid Labels)
 // ============================================================================
@@ -3041,635 +3654,24 @@ function linkClaudeSession(claudeSessionId, managedSessionId) {
     claudeToManagedMap.set(claudeSessionId, managedSessionId);
 }
 
-// ============================================================================
-// Lead Agent Management
-// ============================================================================
-
 /**
- * Create a new lead agent for a project
+ * Find managed session by Claude Code session ID
  */
-async function createLeadAgent(projectId, role, options = {}) {
-    const project = projectsManager.getProject(projectId);
-    if (!project) {
-        throw new Error('Project not found');
-    }
-
-    // Determine trigger mode: options > role default
-    const triggerMode = options.triggerMode || LEAD_TRIGGER_MODES[role] || 'manual';
-
-    // Create session with lead configuration
-    const leadConfig = {
-        role,
-        enabled: true,
-        priority: options.priority || 1,
-        triggerMode,
-        autoTrigger: triggerMode === 'watching', // Backward compatibility
-        systemPrompt: options.systemPrompt || LEAD_ROLE_PROMPTS[role],
-    };
-
-    const roleNames = {
-        security: 'Security',
-        build: 'Build',
-        optimization: 'Optimization',
-        design: 'Design',
-        product_designer: 'Product Designer',
-    };
-
-    // Create the session with project name included
-    const roleName = roleNames[role] || role;
-    const leadName = options.name || `${roleName} Lead · ${project.name}`;
-
-    const session = await createSession({
-        name: leadName,
-        cwd: project.path,
-        projectId,
-        flags: { skipPermissions: true },
-    });
-
-    // Add lead configuration to session
-    session.isLead = true;
-    session.leadConfig = leadConfig;
-    session.status = 'watching'; // Leads start in watching mode
-    session.workQueue = [];
-    session.lastProcessedCommit = null;
-
-    // Register lead with project
-    if (!projectLeads.has(projectId)) {
-        projectLeads.set(projectId, []);
-    }
-    projectLeads.get(projectId).push(session.id);
-
-    // Initialize work queue
-    leadWorkQueues.set(session.id, []);
-
-    // Start watching commits for this project if not already
-    if (!commitWatcher.isTracking(projectId)) {
-        commitWatcher.track(projectId, project.path, 'main');
+function findManagedSession(claudeSessionId) {
+    const managedId = claudeToManagedMap.get(claudeSessionId);
+    if (managedId) {
+        return managedSessions.get(managedId);
     }
-
-    log(`Created lead agent: ${session.name} (${role}) for project ${project.name}`);
-    broadcastSessions();
-    saveSessions();
-    saveLeadState();
-
-    return session;
-}
-
-/**
- * Get all leads for a project
- */
-function getProjectLeads(projectId) {
-    const leadIds = projectLeads.get(projectId) || [];
-    return leadIds.map(id => managedSessions.get(id)).filter(Boolean);
+    return undefined;
 }
-
+// ============================================================================
+// Event Processing
+// ============================================================================
+/** Maximum length for tool output before truncation */
+const MAX_TOOL_OUTPUT_LENGTH = 5000;
 /**
- * Trigger a lead to process a commit
- */
-async function triggerLead(leadId, commitInfo) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) {
-        log(`Cannot trigger: ${leadId} is not a lead`);
-        return false;
-    }
-
-    // Create work item
-    const workItem = {
-        id: randomUUID(),
-        leadId,
-        commit: commitInfo,
-        status: 'pending',
-        queuedAt: Date.now(),
-    };
-
-    // Add to work queue
-    const queue = leadWorkQueues.get(leadId) || [];
-    queue.push(workItem);
-    leadWorkQueues.set(leadId, queue);
-
-    // Update session
-    session.workQueue = queue;
-
-    log(`Queued work item for ${session.name}: commit ${commitInfo.shortSha}`);
-
-    // Broadcast updates
-    broadcast({
-        type: 'lead_queue_update',
-        payload: { leadId, queue },
-    });
-    broadcastSessions();
-
-    // Process queue if not already processing
-    processLeadQueue(leadId);
-
-    return true;
-}
-
-/**
- * Trigger an interactive lead with user input (no commit)
- */
-async function triggerInteractiveLead(leadId, input) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) {
-        log(`Cannot trigger: ${leadId} is not a lead`);
-        return { ok: false, error: 'Lead not found' };
-    }
-
-    if (session.leadConfig?.triggerMode !== 'interactive') {
-        log(`Cannot trigger interactively: ${session.name} is not an interactive lead`);
-        return { ok: false, error: 'Lead is not in interactive mode' };
-    }
-
-    // Create work item (no commit for interactive leads)
-    const workItem = {
-        id: randomUUID(),
-        leadId,
-        status: 'pending',
-        queuedAt: Date.now(),
-        input,
-    };
-
-    // Add to work queue
-    const queue = leadWorkQueues.get(leadId) || [];
-    queue.push(workItem);
-    leadWorkQueues.set(leadId, queue);
-
-    // Update session
-    session.workQueue = queue;
-
-    log(`Queued interactive work item for ${session.name}: "${input.slice(0, 50)}..."`);
-
-    // Broadcast updates
-    broadcast({
-        type: 'lead_queue_update',
-        payload: { leadId, queue },
-    });
-    broadcastSessions();
-
-    // Process queue if not already processing
-    processInteractiveLeadQueue(leadId);
-
-    return { ok: true, workItem };
-}
-
-/**
- * Process the next item in an interactive lead's work queue
- */
-async function processInteractiveLeadQueue(leadId) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return;
-
-    const queue = leadWorkQueues.get(leadId) || [];
-    const pendingItem = queue.find(item => item.status === 'pending');
-
-    if (!pendingItem) {
-        // No pending items
-        if (session.status !== 'idle') {
-            session.status = 'idle';
-            broadcastSessions();
-        }
-        return;
-    }
-
-    // Check if already processing or awaiting handoff
-    const busyItem = queue.find(item =>
-        item.status === 'processing' || item.status === 'awaiting_handoff'
-    );
-    if (busyItem) {
-        return; // Already busy
-    }
-
-    // Start processing
-    pendingItem.status = 'processing';
-    pendingItem.startedAt = Date.now();
-    session.status = 'working';
-
-    // Build prompt for interactive lead (uses input instead of commit)
-    const systemPrompt = session.leadConfig.systemPrompt || LEAD_ROLE_PROMPTS[session.leadConfig.role] || '';
-    const prompt = `${systemPrompt}
-
----
-
-**Feature Request:**
-${pendingItem.input}
-
-Please analyze this request and provide a detailed implementation plan.`;
-
-    log(`Interactive lead ${session.name} processing: "${pendingItem.input.slice(0, 50)}..."`);
-
-    // Broadcast updates
-    broadcast({
-        type: 'lead_triggered',
-        payload: { leadId, workItem: pendingItem },
-    });
-    broadcastSessions();
-
-    // Send the prompt to the session
-    try {
-        const result = await sendPromptToSession(leadId, prompt);
-        if (!result.ok) {
-            pendingItem.status = 'failed';
-            pendingItem.completedAt = Date.now();
-            log(`Interactive lead ${session.name} failed: ${result.error}`);
-            session.status = 'idle';
-            broadcastSessions();
-            saveLeadState();
-        }
-        // Note: Actual completion is tracked via stop/session_end events
-    } catch (err) {
-        pendingItem.status = 'failed';
-        pendingItem.completedAt = Date.now();
-        log(`Interactive lead ${session.name} error: ${err.message}`);
-        session.status = 'idle';
-        broadcastSessions();
-        saveLeadState();
-    }
-}
-
-/**
- * Process the next item in a lead's work queue
- */
-async function processLeadQueue(leadId) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return;
-
-    const queue = leadWorkQueues.get(leadId) || [];
-    const pendingItem = queue.find(item => item.status === 'pending');
-
-    if (!pendingItem) {
-        // No pending items, return to watching
-        if (session.status !== 'watching') {
-            session.status = 'watching';
-            broadcastSessions();
-        }
-        return;
-    }
-
-    // Check if already processing
-    const processingItem = queue.find(item => item.status === 'processing');
-    if (processingItem) {
-        return; // Already processing an item
-    }
-
-    // Start processing
-    pendingItem.status = 'processing';
-    pendingItem.startedAt = Date.now();
-    session.status = 'working';
-
-    // Build the prompt
-    const prompt = buildLeadPrompt(session.leadConfig, pendingItem.commit);
-
-    log(`Lead ${session.name} processing commit ${pendingItem.commit.shortSha}`);
-
-    // Broadcast updates
-    broadcast({
-        type: 'lead_triggered',
-        payload: { leadId, workItem: pendingItem },
-    });
-    broadcastSessions();
-
-    // Send the prompt to the session
-    let failed = false;
-    try {
-        const result = await sendPromptToSession(leadId, prompt);
-        if (!result.ok) {
-            pendingItem.status = 'failed';
-            pendingItem.completedAt = Date.now();
-            failed = true;
-            log(`Lead ${session.name} failed to process: ${result.error}`);
-        }
-        // Note: Actual completion is tracked via stop/session_end events
-    } catch (err) {
-        pendingItem.status = 'failed';
-        pendingItem.completedAt = Date.now();
-        failed = true;
-        log(`Lead ${session.name} error: ${err.message}`);
-    }
-
-    // Update queue
-    session.workQueue = queue;
-    broadcast({
-        type: 'lead_queue_update',
-        payload: { leadId, queue },
-    });
-
-    // If failed, return to watching and try next item
-    if (failed) {
-        session.status = 'watching';
-        broadcastSessions();
-        saveLeadState();
-        // Process next item if any (with delay)
-        const timer = setTimeout(() => {
-            leadTimers.delete(leadId);
-            processLeadQueue(leadId);
-        }, 1000);
-        leadTimers.set(leadId, timer);
-    }
-}
-
-/**
- * Build the prompt for a lead to analyze a commit
- */
-function buildLeadPrompt(leadConfig, commitInfo) {
-    const systemPrompt = leadConfig.systemPrompt || LEAD_ROLE_PROMPTS[leadConfig.role] || '';
-
-    const commitDetails = `
-## New Commit Detected
-
-**SHA:** ${commitInfo.sha}
-**Author:** ${commitInfo.author}
-**Message:** ${commitInfo.message}
-**Branch:** ${commitInfo.branch}
-**Files Changed:** ${commitInfo.filesChanged.length}
-- ${commitInfo.filesChanged.slice(0, 20).join('\n- ')}${commitInfo.filesChanged.length > 20 ? '\n- ... and more' : ''}
-**Changes:** +${commitInfo.additions} / -${commitInfo.deletions}
-
-Please analyze this commit according to your role and provide your assessment.
-`;
-
-    return `${systemPrompt}\n\n${commitDetails}`;
-}
-
-/**
- * Mark a lead's current work item as completed
- */
-function completeLeadWorkItem(leadId, result = null) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return;
-
-    const queue = leadWorkQueues.get(leadId) || [];
-    const processingItem = queue.find(item => item.status === 'processing');
-
-    if (processingItem) {
-        // For interactive leads, set to awaiting_handoff; otherwise completed
-        const isInteractive = session.leadConfig?.triggerMode === 'interactive';
-        processingItem.status = isInteractive ? 'awaiting_handoff' : 'completed';
-        processingItem.completedAt = Date.now();
-        if (result) {
-            processingItem.result = result;
-        }
-        if (processingItem.commit) {
-            session.lastProcessedCommit = processingItem.commit.sha;
-        }
-
-        const itemDesc = processingItem.commit
-            ? `commit ${processingItem.commit.shortSha}`
-            : `work item ${processingItem.id.slice(0, 8)}`;
-        log(`Lead ${session.name} ${isInteractive ? 'awaiting handoff for' : 'completed'} ${itemDesc}`);
-
-        // Broadcast completion or handoff ready
-        if (isInteractive) {
-            broadcast({
-                type: 'lead_handoff_ready',
-                payload: {
-                    leadId,
-                    leadName: session.name,
-                    workItemId: processingItem.id,
-                    result: processingItem.result || '',
-                    input: processingItem.input,
-                },
-            });
-        } else {
-            broadcast({
-                type: 'lead_completed',
-                payload: { leadId, workItem: processingItem },
-            });
-        }
-    }
-
-    // Update session
-    session.workQueue = queue;
-    // Interactive leads stay idle until handoff is actioned; others return to watching
-    const isInteractive = session.leadConfig?.triggerMode === 'interactive';
-    session.status = isInteractive ? 'idle' : 'watching';
-
-    // Save state
-    saveLeadState();
-    broadcastSessions();
-
-    // For non-interactive leads, process next item if any
-    if (!isInteractive) {
-        const timer = setTimeout(() => {
-            leadTimers.delete(leadId);
-            processLeadQueue(leadId);
-        }, 1000);
-        leadTimers.set(leadId, timer);
-    }
-}
-
-/**
- * Pause a lead (stop watching)
- */
-function pauseLead(leadId) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return false;
-
-    // Clear any pending processing timer
-    const timer = leadTimers.get(leadId);
-    if (timer) {
-        clearTimeout(timer);
-        leadTimers.delete(leadId);
-    }
-
-    session.leadConfig.enabled = false;
-    session.status = 'idle';
-
-    log(`Paused lead: ${session.name}`);
-    broadcastSessions();
-    saveLeadState();
-
-    return true;
-}
-
-/**
- * Resume a lead (start watching)
- */
-function resumeLead(leadId) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return false;
-
-    session.leadConfig.enabled = true;
-    session.status = 'watching';
-
-    log(`Resumed lead: ${session.name}`);
-    broadcastSessions();
-    saveLeadState();
-
-    return true;
-}
-
-/**
- * Delete a lead agent
- */
-async function deleteLead(leadId) {
-    const session = managedSessions.get(leadId);
-    if (!session || !session.isLead) return false;
-
-    // Remove from project leads
-    if (session.projectId) {
-        const leads = projectLeads.get(session.projectId) || [];
-        const index = leads.indexOf(leadId);
-        if (index !== -1) {
-            leads.splice(index, 1);
-        }
-
-        // Stop watching if no more leads for this project
-        if (leads.length === 0) {
-            commitWatcher.untrack(session.projectId);
-            projectLeads.delete(session.projectId);
-        }
-    }
-
-    // Clean up pending timer
-    const timer = leadTimers.get(leadId);
-    if (timer) {
-        clearTimeout(timer);
-        leadTimers.delete(leadId);
-    }
-
-    // Clean up work queue
-    leadWorkQueues.delete(leadId);
-
-    // Delete the session
-    await deleteSession(leadId);
-
-    saveLeadState();
-    return true;
-}
-
-/**
- * Handle new commit detected by CommitWatcher
- */
-function handleNewCommit(projectId, commitInfo) {
-    log(`New commit detected in project ${projectId.slice(0, 8)}: ${commitInfo.shortSha} - "${commitInfo.message}"`);
-
-    // LOOP PREVENTION: Check if this is a pipeline commit (should be skipped)
-    if (pipelineManager.isPipelineCommit(commitInfo)) {
-        log(`Skipping pipeline commit: ${commitInfo.shortSha}`);
-        return;
-    }
-
-    // Broadcast commit detection
-    broadcast({
-        type: 'commit_detected',
-        payload: { projectId, commit: commitInfo },
-    });
-
-    // Trigger pipelines for this project
-    const pipelines = pipelineManager.getProjectPipelines(projectId);
-    for (const pipeline of pipelines) {
-        if (pipeline.enabled && pipeline.triggerBranches.includes(commitInfo.branch)) {
-            log(`Triggering pipeline: ${pipeline.name} for commit ${commitInfo.shortSha}`);
-            try {
-                const run = pipelineManager.createRun(pipeline.id, commitInfo, 'commit');
-                // Start processing the first stage
-                pipelineManager.processNextStage(run.id);
-            } catch (err) {
-                log(`Failed to trigger pipeline ${pipeline.name}: ${err.message}`);
-            }
-        }
-    }
-
-    // Trigger all enabled leads for this project with 'watching' trigger mode
-    // (kept for backward compatibility, but pipelines are preferred)
-    const leads = projectLeads.get(projectId) || [];
-    for (const leadId of leads) {
-        const session = managedSessions.get(leadId);
-        // Only trigger leads with watching mode (auto-trigger on commits)
-        const shouldTrigger = session?.isLead &&
-            session.leadConfig?.enabled &&
-            session.leadConfig?.triggerMode === 'watching';
-        if (shouldTrigger) {
-            triggerLead(leadId, commitInfo);
-        }
-    }
-}
-
-/**
- * Save lead state to disk
- */
-function saveLeadState() {
-    try {
-        const leadsFile = resolve(expandHome('~/.vibeteam/data/leads.json'));
-        const dir = dirname(leadsFile);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-
-        const data = {
-            projectLeads: Array.from(projectLeads.entries()),
-            leadWorkQueues: Array.from(leadWorkQueues.entries()),
-        };
-
-        writeFileSync(leadsFile, JSON.stringify(data, null, 2));
-        debug(`Saved lead state to ${leadsFile}`);
-    } catch (e) {
-        console.error('Failed to save lead state:', e);
-    }
-}
-
-/**
- * Load lead state from disk
- */
-function loadLeadState() {
-    const leadsFile = resolve(expandHome('~/.vibeteam/data/leads.json'));
-    if (!existsSync(leadsFile)) {
-        debug('No saved leads file found');
-        return;
-    }
-
-    try {
-        const content = readFileSync(leadsFile, 'utf-8');
-        const data = JSON.parse(content);
-
-        // Restore project leads mapping
-        if (Array.isArray(data.projectLeads)) {
-            for (const [projectId, leadIds] of data.projectLeads) {
-                projectLeads.set(projectId, leadIds);
-
-                // Start watching for commits
-                const project = projectsManager.getProject(projectId);
-                if (project && leadIds.length > 0) {
-                    commitWatcher.track(projectId, project.path, 'main');
-                }
-            }
-        }
-
-        // Restore work queues
-        if (Array.isArray(data.leadWorkQueues)) {
-            for (const [leadId, queue] of data.leadWorkQueues) {
-                leadWorkQueues.set(leadId, queue);
-                // Update session with queue
-                const session = managedSessions.get(leadId);
-                if (session) {
-                    session.workQueue = queue;
-                }
-            }
-        }
-
-        log(`Loaded lead state: ${projectLeads.size} projects with leads`);
-    } catch (e) {
-        console.error('Failed to load lead state:', e);
-    }
-}
-/**
- * Find managed session by Claude Code session ID
- */
-function findManagedSession(claudeSessionId) {
-    const managedId = claudeToManagedMap.get(claudeSessionId);
-    if (managedId) {
-        return managedSessions.get(managedId);
-    }
-    return undefined;
-}
-// ============================================================================
-// Event Processing
-// ============================================================================
-/** Maximum length for tool output before truncation */
-const MAX_TOOL_OUTPUT_LENGTH = 5000;
-/**
- * Parse and format tool output for frontend display.
- * Truncates large outputs and determines success/error status.
+ * Parse and format tool output for frontend display.
+ * Truncates large outputs and determines success/error status.
  */
 function formatToolOutput(result) {
     if (!result) return undefined;
@@ -3794,20 +3796,20 @@ function addEvent(event) {
                 break;
             case 'stop':
             case 'session_end':
-                // For lead agents, complete work item and return to watching
-                if (managedSession.isLead) {
-                    completeLeadWorkItem(managedSession.id);
-                } else {
-                    managedSession.status = 'idle';
-                }
+                managedSession.status = 'idle';
                 managedSession.currentTool = undefined;
+                // Check if this agent is part of a planning pipeline
+                pipelineManager.onAgentIdle(managedSession.id);
                 break;
         }
-        // Broadcast and persist if status changed
+        // Increment statusVersion on actual status changes for ordering resolution
         if (managedSession.status !== prevStatus) {
+            managedSession.statusVersion = (managedSession.statusVersion || 0) + 1;
             broadcastSessions();
             saveSessions();
         }
+        // Include statusVersion in event payload for frontend version tracking
+        processed.statusVersion = managedSession.statusVersion || 0;
     }
     // Broadcast to all clients
     broadcast({ type: 'event', payload: processed });
@@ -4481,6 +4483,34 @@ async function handleHttpRequest(req, res) {
         }
     }
 
+    // GET /projects/:id/branches - List local branches for the project
+    const branchesMatch = req.url?.match(/^\/projects\/([a-f0-9-]+)\/branches$/);
+    if (req.method === 'GET' && branchesMatch) {
+        const projectId = branchesMatch[1];
+        const project = projectsManager.getProject(projectId);
+        if (!project) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Project not found' }));
+            return;
+        }
+        try {
+            const branches = await new Promise((resolve, reject) => {
+                execFile('git', ['branch', '--sort=-committerdate', '--format=%(refname:short)'], { cwd: project.path, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+                    if (error) return reject(error);
+                    const list = stdout.split('\n').map(b => b.trim()).filter(Boolean).slice(0, 50);
+                    resolve(list);
+                });
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, branches }));
+        } catch (err) {
+            log(`Error listing branches: ${err.message}`);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: err.message }));
+        }
+        return;
+    }
+
     // Project orphaned worktrees cleanup: /projects/:id/worktrees/orphaned
     const orphanedMatch = req.url?.match(/^\/projects\/([a-f0-9-]+)\/worktrees\/orphaned$/);
     if (orphanedMatch) {
@@ -4633,92 +4663,215 @@ async function handleHttpRequest(req, res) {
         return;
     }
 
-    // ============================================================================
-    // Pipeline API - Safety & Deploy Pipeline System
-    // ============================================================================
-
-    // POST /projects/:id/pipelines - Create pipeline for project
-    const projectPipelinesMatch = req.url?.match(/^\/projects\/([a-f0-9-]+)\/pipelines$/);
-    if (projectPipelinesMatch && req.method === 'POST') {
-        const projectId = projectPipelinesMatch[1];
-        const project = projectsManager.getProject(projectId);
-        if (!project) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok: false, error: 'Project not found' }));
+    // GET /kanban-image?path=... - Serve a kanban task image from disk
+    if (req.method === 'GET' && req.url?.startsWith('/kanban-image')) {
+        const urlObj = new URL(req.url, 'http://localhost');
+        const imagePath = urlObj.searchParams.get('path');
+        if (!imagePath) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'path parameter required' }));
             return;
         }
+        // SECURITY: Only serve files from .vibeteam-images directories
+        const canonicalPath = resolve(imagePath);
+        if (!canonicalPath.includes('/.vibeteam-images/')) {
+            res.writeHead(403, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Access denied' }));
+            return;
+        }
+        try {
+            if (!existsSync(canonicalPath)) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Image not found' }));
+                return;
+            }
+            const data = readFileSync(canonicalPath);
+            const ext = canonicalPath.split('.').pop()?.toLowerCase();
+            const mimeTypes = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp' };
+            const contentType = mimeTypes[ext] || 'application/octet-stream';
+            res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'public, max-age=86400' });
+            res.end(data);
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Failed to read image' }));
+        }
+        return;
+    }
 
-        collectRequestBody(req).then((body) => {
+    // ============================================================================
+    // Kanban Board API
+    // ============================================================================
+
+    // GET /kanban/tasks?projectId=X - List tasks for project
+    if (req.method === 'GET' && req.url?.startsWith('/kanban/tasks')) {
+        const urlObj = new URL(req.url, `http://localhost`);
+        const projectId = urlObj.searchParams.get('projectId');
+        const tasks = kanbanManager.getTasks(projectId || undefined);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, tasks }));
+        return;
+    }
+
+    // POST /kanban/images - Upload image for kanban task
+    if (req.method === 'POST' && req.url === '/kanban/images') {
+        collectRequestBody(req, 10 * 1024 * 1024).then(async (body) => {
             try {
-                const config = body ? JSON.parse(body) : {};
-                const pipeline = pipelineManager.createPipeline(projectId, config);
+                const { image, projectId } = JSON.parse(body);
+                if (!image || !image.startsWith('data:image/')) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Invalid image data. Only image files are supported.' }));
+                    return;
+                }
+                if (!projectId) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'projectId is required' }));
+                    return;
+                }
+                // Parse base64 image
+                const matches = image.match(/^data:image\/(\w+);base64,(.+)$/);
+                if (!matches) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Could not parse image data' }));
+                    return;
+                }
+                const ext = matches[1] === 'jpeg' ? 'jpg' : matches[1];
+                const mimeType = `image/${matches[1]}`;
+                const base64Data = matches[2];
+                const buffer = Buffer.from(base64Data, 'base64');
 
-                // Start watching for commits if not already
-                if (!commitWatcher.isTracking(projectId)) {
-                    commitWatcher.track(projectId, project.path, 'main');
+                // Check size (10MB limit)
+                if (buffer.length > 10 * 1024 * 1024) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Image must be under 10MB' }));
+                    return;
                 }
 
-                // Broadcast updated pipelines to all clients
-                broadcastPipelines();
+                // Determine save directory from project path
+                const project = projectsManager.getProject(projectId);
+                if (!project) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Project not found' }));
+                    return;
+                }
 
-                res.writeHead(201, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, pipeline }));
+                // SECURITY: Validate and canonicalize paths to prevent path traversal
+                const canonicalProjectPath = resolve(project.path);
+                const imagesDir = join(canonicalProjectPath, '.vibeteam-images');
+                const canonicalImagesDir = resolve(imagesDir);
+                if (!canonicalImagesDir.startsWith(canonicalProjectPath + '/') && canonicalImagesDir !== canonicalProjectPath) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Invalid directory path' }));
+                    return;
+                }
+                if (!existsSync(canonicalImagesDir)) {
+                    mkdirSync(canonicalImagesDir, { recursive: true });
+                }
+                const timestamp = Date.now();
+                const hex = randomBytes(4).toString('hex');
+                const filename = `image-${timestamp}-${hex}.${ext}`;
+                const filepath = join(canonicalImagesDir, filename);
+                const canonicalFilepath = resolve(filepath);
+                // Double-check the final filepath is still within the images directory
+                if (!canonicalFilepath.startsWith(canonicalImagesDir + '/')) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Invalid file path' }));
+                    return;
+                }
+                writeFileSync(canonicalFilepath, buffer);
+                log(`Kanban image saved: ${canonicalFilepath}`);
+
+                const attachment = {
+                    id: `img-${timestamp}-${hex}`,
+                    filename,
+                    path: canonicalFilepath,
+                    size: buffer.length,
+                    mimeType,
+                    createdAt: timestamp,
+                };
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, attachment }));
             } catch (e) {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: e.message }));
+                res.end(JSON.stringify({ ok: false, error: e.message || 'Failed to process image' }));
             }
         }).catch(() => {
             res.writeHead(413, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Request body too large' }));
+            res.end(JSON.stringify({ error: 'Image too large (max 10MB)' }));
         });
         return;
     }
 
-    // GET /projects/:id/pipelines - List pipelines for project
-    if (projectPipelinesMatch && req.method === 'GET') {
-        const projectId = projectPipelinesMatch[1];
-        const pipelines = pipelineManager.getProjectPipelines(projectId);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, pipelines }));
+    // POST /kanban/tasks - Create task
+    if (req.method === 'POST' && req.url === '/kanban/tasks') {
+        collectRequestBody(req).then((body) => {
+            try {
+                const data = JSON.parse(body);
+                if (!data.title || !data.projectId) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'title and projectId are required' }));
+                    return;
+                }
+                if (typeof data.title !== 'string' || data.title.length > 500) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Title must be a string under 500 characters' }));
+                    return;
+                }
+                if (data.description && (typeof data.description !== 'string' || data.description.length > 5000)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Description must be under 5000 characters' }));
+                    return;
+                }
+                if (data.tags && (!Array.isArray(data.tags) || data.tags.length > 20)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Tags must be an array with at most 20 items' }));
+                    return;
+                }
+                if (data.columnId && !VALID_COLUMNS.includes(data.columnId)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Invalid columnId' }));
+                    return;
+                }
+                const task = kanbanManager.createTask(data);
+                broadcast({ type: 'kanban_task_created', payload: { task } });
+                res.writeHead(201, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, task }));
+            } 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;
     }
 
-    // Pipeline-specific endpoints: /pipelines/:id
-    const pipelineMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)(?:\/(.+))?$/);
-    if (pipelineMatch) {
-        const pipelineId = pipelineMatch[1];
-        const action = pipelineMatch[2];
+    // Kanban task-specific endpoints: /kanban/tasks/:id
+    const kanbanTaskMatch = req.url?.match(/^\/kanban\/tasks\/([a-f0-9-]+)$/);
+    if (kanbanTaskMatch) {
+        const taskId = kanbanTaskMatch[1];
 
-        // GET /pipelines/:id - Get pipeline details
-        if (req.method === 'GET' && !action) {
-            const pipeline = pipelineManager.getPipeline(pipelineId);
-            if (pipeline) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, pipeline }));
-            } else {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
-            }
-            return;
-        }
-
-        // PUT /pipelines/:id - Update pipeline
-        if (req.method === 'PUT' && !action) {
+        // PUT /kanban/tasks/:id - Update task
+        if (req.method === 'PUT') {
             collectRequestBody(req).then((body) => {
                 try {
                     const updates = JSON.parse(body);
-                    const pipeline = pipelineManager.updatePipeline(pipelineId, updates);
-                    if (pipeline) {
-                        // Broadcast updated pipelines to all clients
-                        broadcastPipelines();
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, pipeline }));
-                    } else {
+                    if (updates.columnId && !VALID_COLUMNS.includes(updates.columnId)) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'Invalid columnId' }));
+                        return;
+                    }
+                    const task = kanbanManager.updateTask(taskId, updates);
+                    if (!task) {
                         res.writeHead(404, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
+                        res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
+                        return;
                     }
+                    broadcast({ type: 'kanban_task_updated', payload: { task } });
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, task }));
                 } catch (e) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: e.message }));
                 }
             }).catch(() => {
@@ -4728,157 +4881,129 @@ async function handleHttpRequest(req, res) {
             return;
         }
 
-        // DELETE /pipelines/:id - Delete pipeline
-        if (req.method === 'DELETE' && !action) {
-            const deleted = pipelineManager.deletePipeline(pipelineId);
-            if (deleted) {
-                // Broadcast updated pipelines to all clients
-                broadcastPipelines();
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-            } else {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
-            }
-            return;
-        }
-
-        // POST /pipelines/:id/trigger - Manual trigger
-        if (req.method === 'POST' && action === 'trigger') {
-            const pipeline = pipelineManager.getPipeline(pipelineId);
-            if (!pipeline) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
-                return;
-            }
-
-            collectRequestBody(req).then(async (body) => {
+        // DELETE /kanban/tasks/:id - Delete task
+        if (req.method === 'DELETE') {
+            // Cancel active pipeline before deleting task
+            const pipeline = pipelineManager.getPipeline(taskId);
+            if (pipeline && (pipeline.status === 'running' || pipeline.status === 'pending')) {
                 try {
-                    const { commitSha } = body ? JSON.parse(body) : {};
-
-                    // Get commit info (either specified or latest)
-                    const project = projectsManager.getProject(pipeline.projectId);
-                    if (!project) {
-                        throw new Error('Project not found');
-                    }
-
-                    let commitInfo;
-                    if (commitSha) {
-                        commitInfo = await commitWatcher.getCommitInfoForPath(project.path, commitSha);
-                    } else {
-                        commitInfo = await commitWatcher.forceCheck(pipeline.projectId);
-                    }
-
-                    if (!commitInfo) {
-                        throw new Error('Could not get commit info');
-                    }
-
-                    const run = pipelineManager.createRun(pipelineId, commitInfo, 'manual');
-                    pipelineManager.processNextStage(run.id);
-
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, run }));
+                    await pipelineManager.cancelPipeline(taskId);
                 } catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: e.message }));
+                    log(`Failed to cancel pipeline on task delete: ${e.message}`);
                 }
-            }).catch(() => {
-                res.writeHead(413, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Request body too large' }));
-            });
-            return;
-        }
-
-        // GET /pipelines/:id/runs - List pipeline runs
-        if (req.method === 'GET' && action === 'runs') {
-            const runs = pipelineManager.getPipelineRuns(pipelineId);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok: true, runs }));
-            return;
-        }
-
-        // GET /pipelines/:id/runs/:runId - Get run details
-        const runMatch = action?.match(/^runs\/([a-f0-9-]+)$/);
-        if (req.method === 'GET' && runMatch) {
-            const runId = runMatch[1];
-            const run = pipelineManager.getRun(runId);
-            if (run) {
+            }
+            const existed = kanbanManager.deleteTask(taskId);
+            if (existed) {
+                broadcast({ type: 'kanban_task_deleted', payload: { taskId } });
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, run }));
+                res.end(JSON.stringify({ ok: true }));
             } else {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Run not found' }));
+                res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
             }
             return;
         }
+    }
 
-        // POST /pipelines/:id/runs/:runId/approve - Approve stage
-        const approveMatch = action?.match(/^runs\/([a-f0-9-]+)\/approve$/);
-        if (req.method === 'POST' && approveMatch) {
-            const runId = approveMatch[1];
-            collectRequestBody(req).then((body) => {
-                try {
-                    const { stageId, approved } = JSON.parse(body);
-                    if (!stageId || typeof approved !== 'boolean') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'stageId and approved required' }));
-                        return;
-                    }
-
-                    const success = pipelineManager.approveStage(runId, stageId, approved);
-                    if (success) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true }));
-                    } else {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Stage not awaiting approval' }));
-                    }
-                } catch (e) {
+    // POST /kanban/tasks/:id/move - Move task to column
+    const kanbanMoveMatch = req.url?.match(/^\/kanban\/tasks\/([a-f0-9-]+)\/move$/);
+    if (req.method === 'POST' && kanbanMoveMatch) {
+        const taskId = kanbanMoveMatch[1];
+        collectRequestBody(req).then((body) => {
+            try {
+                const { toColumn, position } = JSON.parse(body);
+                if (!toColumn || !VALID_COLUMNS.includes(toColumn)) {
                     res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: e.message }));
+                    res.end(JSON.stringify({ ok: false, error: 'Invalid toColumn' }));
+                    return;
                 }
-            }).catch(() => {
-                res.writeHead(413, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Request body too large' }));
-            });
-            return;
-        }
-
-        // POST /pipelines/:id/runs/:runId/cancel - Cancel run
-        const cancelMatch = action?.match(/^runs\/([a-f0-9-]+)\/cancel$/);
-        if (req.method === 'POST' && cancelMatch) {
-            const runId = cancelMatch[1];
-            const success = pipelineManager.cancelRun(runId);
-            if (success) {
+                const task = kanbanManager.moveTask(taskId, toColumn, position ?? 0);
+                if (!task) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
+                    return;
+                }
+                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 }));
-            } else {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Cannot cancel run' }));
+                res.end(JSON.stringify({ ok: true, task }));
+            } 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 /kanban/tasks/:id/ai-review - Trigger AI review for task
+    const kanbanReviewMatch = req.url?.match(/^\/kanban\/tasks\/([a-f0-9-]+)\/ai-review$/);
+    if (req.method === 'POST' && kanbanReviewMatch) {
+        const taskId = kanbanReviewMatch[1];
+        const task = kanbanManager.getTask(taskId);
+        if (!task) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
             return;
         }
+        // Mark as pending review
+        kanbanManager.updateTask(taskId, { reviewStatus: 'pending' });
+        broadcast({ type: 'kanban_task_updated', payload: { task: kanbanManager.getTask(taskId) } });
+
+        // Spawn a review agent
+        try {
+            const reviewPrompt = `You are reviewing the following task:\n\nTitle: ${task.title}\nDescription: ${task.description}\n\nReview the work and provide feedback. If the implementation looks good, say "REVIEW: PASSED" at the end. If there are issues, say "REVIEW: FAILED" followed by the issues.`;
+            const reviewSession = await createSession({
+                name: `review-${task.title.slice(0, 20)}`,
+                cwd: undefined,
+                projectId: task.projectId,
+            });
+            // Send review prompt
+            await sendPromptToSession(reviewSession.id, reviewPrompt);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, reviewSessionId: reviewSession.id }));
+        } catch (e) {
+            // If spawning fails, just mark as needing manual review
+            kanbanManager.updateTask(taskId, { reviewStatus: 'failed', reviewFeedback: 'Failed to spawn review agent: ' + e.message });
+            broadcast({ type: 'kanban_task_updated', payload: { task: kanbanManager.getTask(taskId) } });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, manualReview: true }));
+        }
+        return;
     }
 
     // ============================================================================
-    // Lead Agents API
+    // Planning Pipeline API
     // ============================================================================
 
-    // POST /projects/:id/leads - Create lead for project
-    const projectLeadsMatch = req.url?.match(/^\/projects\/([a-f0-9-]+)\/leads$/);
-    if (projectLeadsMatch && req.method === 'POST') {
-        const projectId = projectLeadsMatch[1];
+    // POST /pipelines - Start a new pipeline
+    if (req.method === 'POST' && req.url === '/pipelines') {
         collectRequestBody(req).then(async (body) => {
             try {
-                const { role, name, priority, autoTrigger, triggerMode, systemPrompt } = JSON.parse(body);
-                if (!role || !['security', 'build', 'optimization', 'design', 'product_designer'].includes(role)) {
+                const { taskId, projectId } = JSON.parse(body);
+                if (!taskId || !projectId) {
                     res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: 'Invalid or missing role. Must be: security, build, optimization, design, or product_designer' }));
+                    res.end(JSON.stringify({ ok: false, error: 'taskId and projectId are required' }));
+                    return;
+                }
+                const task = kanbanManager.getTask(taskId);
+                if (!task) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Task not found' }));
                     return;
                 }
-                const lead = await createLeadAgent(projectId, role, { name, priority, autoTrigger, triggerMode, systemPrompt });
+                const project = projectsManager.getProject(projectId);
+                if (!project) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Project not found' }));
+                    return;
+                }
+                const pipeline = await pipelineManager.createPipeline(
+                    taskId, projectId, project.path, task.title, task.description || '', task.attachments || []
+                );
                 res.writeHead(201, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, lead }));
+                res.end(JSON.stringify({ ok: true, pipeline }));
             } catch (e) {
                 res.writeHead(500, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ ok: false, error: e.message }));
@@ -4890,315 +5015,285 @@ async function handleHttpRequest(req, res) {
         return;
     }
 
-    // GET /projects/:id/leads - List leads for project
-    if (projectLeadsMatch && req.method === 'GET') {
-        const projectId = projectLeadsMatch[1];
-        const leads = getProjectLeads(projectId);
+    // GET /pipelines?projectId=X - List pipelines
+    if (req.method === 'GET' && req.url?.startsWith('/pipelines') && !req.url.includes('/pipelines/')) {
+        const urlObj = new URL(req.url, 'http://localhost');
+        const projectId = urlObj.searchParams.get('projectId');
+        const pipelines = pipelineManager.getPipelines(projectId || undefined);
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, leads }));
+        res.end(JSON.stringify({ ok: true, pipelines }));
         return;
     }
 
-    // Lead-specific endpoints: /leads/:id
-    const leadMatch = req.url?.match(/^\/leads\/([a-f0-9-]+)(?:\/(.+))?$/);
-    if (leadMatch) {
-        const leadId = leadMatch[1];
-        const action = leadMatch[2];
+    // Pipeline-specific endpoints: /pipelines/:id
+    const pipelineMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)$/);
+    if (pipelineMatch) {
+        const pipelineId = pipelineMatch[1];
 
-        // DELETE /leads/:id - Remove lead
-        if (req.method === 'DELETE' && !action) {
-            const deleted = await deleteLead(leadId);
-            if (deleted) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-            } else {
+        // GET /pipelines/:id - Get pipeline
+        if (req.method === 'GET') {
+            const pipeline = pipelineManager.getPipeline(pipelineId);
+            if (!pipeline) {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
+                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
+                return;
             }
-            return;
-        }
-
-        // GET /leads/:id/queue - Get work queue
-        if (req.method === 'GET' && action === 'queue') {
-            const queue = leadWorkQueues.get(leadId) || [];
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok: true, queue }));
+            res.end(JSON.stringify({ ok: true, pipeline }));
             return;
         }
+    }
 
-        // POST /leads/:id/trigger - Manual trigger
-        if (req.method === 'POST' && action === 'trigger') {
-            const session = managedSessions.get(leadId);
-            if (!session || !session.isLead) {
+    // POST /pipelines/:id/cancel - Cancel pipeline
+    const pipelineCancelMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/cancel$/);
+    if (req.method === 'POST' && pipelineCancelMatch) {
+        const pipelineId = pipelineCancelMatch[1];
+        try {
+            const pipeline = await pipelineManager.cancelPipeline(pipelineId);
+            if (!pipeline) {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
+                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
                 return;
             }
-
-            collectRequestBody(req).then(async (body) => {
-                try {
-                    const { commitSha } = body ? JSON.parse(body) : {};
-
-                    // Get commit info - either specific commit or latest
-                    let commitInfo;
-                    if (commitSha) {
-                        // Get specific commit info
-                        const project = projectsManager.getProject(session.projectId);
-                        if (project) {
-                            commitInfo = await commitWatcher.getCommitInfo?.(project.path, commitSha);
-                        }
-                    } else {
-                        // Get latest commit
-                        commitInfo = await commitWatcher.forceCheck(session.projectId);
-                    }
-
-                    if (!commitInfo) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Could not get commit info' }));
-                        return;
-                    }
-
-                    await triggerLead(leadId, commitInfo);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, commit: commitInfo }));
-                } 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 /leads/:id/pause - Pause lead
-        if (req.method === 'POST' && action === 'pause') {
-            const paused = pauseLead(leadId);
-            if (paused) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-            } else {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
-            }
-            return;
-        }
-
-        // POST /leads/:id/resume - Resume lead
-        if (req.method === 'POST' && action === 'resume') {
-            const resumed = resumeLead(leadId);
-            if (resumed) {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-            } else {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
-            }
-            return;
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, pipeline }));
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: e.message }));
         }
+        return;
+    }
 
-        // POST /leads/:id/trigger-interactive - Trigger interactive lead with user input
-        if (req.method === 'POST' && action === 'trigger-interactive') {
-            const session = managedSessions.get(leadId);
-            if (!session || !session.isLead) {
+    // POST /pipelines/:id/retry - Retry failed pipeline
+    const pipelineRetryMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/retry$/);
+    if (req.method === 'POST' && pipelineRetryMatch) {
+        const pipelineId = pipelineRetryMatch[1];
+        try {
+            const pipeline = await pipelineManager.retryPipeline(pipelineId);
+            if (!pipeline) {
                 res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
-                return;
-            }
-
-            if (session.leadConfig?.triggerMode !== 'interactive') {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead is not in interactive mode' }));
+                res.end(JSON.stringify({ ok: false, error: 'Pipeline not found or not failed' }));
                 return;
             }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, pipeline }));
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+        return;
+    }
 
-            collectRequestBody(req).then(async (body) => {
-                try {
-                    const { input } = JSON.parse(body);
-                    if (!input || typeof input !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Input is required' }));
-                        return;
-                    }
-
-                    const result = await triggerInteractiveLead(leadId, input);
-                    if (result.ok) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, workItem: result.workItem }));
-                    } else {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: result.error }));
-                    }
-                } 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' }));
-            });
+    // POST /pipelines/:id/advance - Force-advance a stuck pipeline to the next phase
+    const pipelineAdvanceMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/advance$/);
+    if (req.method === 'POST' && pipelineAdvanceMatch) {
+        const pipelineId = pipelineAdvanceMatch[1];
+        const pipeline = pipelineManager.getPipeline(pipelineId);
+        if (!pipeline) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
             return;
         }
-
-        // POST /leads/:id/handoff - Execute handoff to target agent
-        if (req.method === 'POST' && action === 'handoff') {
-            const session = managedSessions.get(leadId);
-            if (!session || !session.isLead) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'Lead not found' }));
-                return;
+        if (pipeline.status !== 'running') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: `Pipeline is ${pipeline.status}, not running` }));
+            return;
+        }
+        // Mark current phase as completed if still running
+        const currentPhaseRecord = pipeline.phases.find(p => p.phase === pipeline.currentPhase && p.status === 'running');
+        if (currentPhaseRecord) {
+            currentPhaseRecord.status = 'completed';
+            currentPhaseRecord.completedAt = Date.now();
+            // Cleanup agent mapping
+            if (currentPhaseRecord.agentId) {
+                pipelineManager.agentToPipeline.delete(currentPhaseRecord.agentId);
             }
+            pipelineManager.savePipeline(pipeline);
+        }
+        try {
+            await pipelineManager.advancePhase(pipelineId);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, pipeline }));
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+        return;
+    }
 
-            collectRequestBody(req).then(async (body) => {
-                try {
-                    const { workItemId, type, agentId, agentName, prompt } = JSON.parse(body);
-
-                    // Find the work item
-                    const queue = leadWorkQueues.get(leadId) || [];
-                    const workItem = queue.find(w => w.id === workItemId);
-
-                    if (!workItem) {
-                        res.writeHead(404, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Work item not found' }));
-                        return;
-                    }
 
-                    if (workItem.status !== 'awaiting_handoff') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Work item is not awaiting handoff' }));
-                        return;
-                    }
 
-                    // Build the handoff prompt
-                    const handoffPrompt = prompt || workItem.result || '';
-                    let targetAgentId;
-
-                    if (type === 'spawn') {
-                        // Create a new agent
-                        const project = projectsManager.getProject(session.projectId);
-                        const newName = agentName || `Implementation Agent`;
-                        const newSession = await createSession({
-                            name: newName,
-                            cwd: project?.path || session.cwd,
-                            projectId: session.projectId,
-                        });
-                        targetAgentId = newSession.id;
-                        log(`Handoff: Spawned new agent ${newName} (${targetAgentId.slice(0, 8)})`);
-                    } else if (type === 'existing') {
-                        if (!agentId) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: false, error: 'agentId required for existing type' }));
-                            return;
-                        }
-                        const targetSession = managedSessions.get(agentId);
-                        if (!targetSession) {
-                            res.writeHead(404, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: false, error: 'Target agent not found' }));
-                            return;
-                        }
-                        targetAgentId = agentId;
-                        log(`Handoff: Using existing agent ${targetSession.name} (${agentId.slice(0, 8)})`);
-                    } else {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Invalid type. Must be: spawn or existing' }));
-                        return;
-                    }
+    // POST /pipelines/:id/ship - Ship to target branch (commit + push)
+    const pipelineShipMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/ship$/);
+    if (req.method === 'POST' && pipelineShipMatch) {
+        const pipelineId = pipelineShipMatch[1];
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+            try {
+                let targetBranch;
+                if (body) {
+                    try {
+                        const parsed = JSON.parse(body);
+                        targetBranch = parsed.targetBranch;
+                    } catch (_) { /* ignore parse errors, use default */ }
+                }
+                const pipeline = await pipelineManager.shipToMain(pipelineId, targetBranch);
+                if (!pipeline) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                // Exclude non-serializable fields (like timeout handles) from response
+                const { _shipTimeout, ...safePipeline } = pipeline;
+                res.end(JSON.stringify({ ok: true, pipeline: safePipeline }));
+            } catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        });
+        return;
+    }
 
-                    // Update work item status
-                    workItem.status = 'handed_off';
-                    workItem.handoffTarget = {
-                        type,
-                        agentId: targetAgentId,
-                        agentName: agentName || managedSessions.get(targetAgentId)?.name,
-                    };
-
-                    // Save state
-                    session.workQueue = queue;
-                    saveLeadState();
-                    broadcastSessions();
+    // POST /pipelines/:id/request-changes - Request changes with human feedback
+    const pipelineRequestChangesMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/request-changes$/);
+    if (req.method === 'POST' && pipelineRequestChangesMatch) {
+        const pipelineId = pipelineRequestChangesMatch[1];
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+            try {
+                const { feedback } = JSON.parse(body);
+                if (!feedback || typeof feedback !== 'string') {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Feedback is required' }));
+                    return;
+                }
+                const pipeline = await pipelineManager.requestChanges(pipelineId, feedback);
+                if (!pipeline) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Pipeline not found or not completed' }));
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, pipeline }));
+            } catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        });
+        return;
+    }
 
-                    // Send prompt to target agent
-                    const result = await sendPromptToSession(targetAgentId, handoffPrompt);
-                    if (!result.ok) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: `Failed to send prompt: ${result.error}` }));
-                        return;
-                    }
+    // POST /pipelines/:id/cleanup-worktree - Manually remove worktree and optionally delete branch
+    const pipelineCleanupMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/cleanup-worktree$/);
+    if (req.method === 'POST' && pipelineCleanupMatch) {
+        const pipelineId = pipelineCleanupMatch[1];
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', async () => {
+            try {
+                const { deleteBranch } = body ? JSON.parse(body) : {};
+                const pipeline = pipelineManager.getPipeline(pipelineId);
+                if (!pipeline) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
+                    return;
+                }
 
-                    log(`Handoff complete: ${session.name} -> ${workItem.handoffTarget.agentName}`);
+                // Idempotent: if already cleaned, return success
+                if (pipeline.worktreeStatus === 'cleaned') {
                     res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        ok: true,
-                        targetAgentId,
-                        targetAgentName: workItem.handoffTarget.agentName,
-                    }));
-
-                    // Broadcast queue update
-                    broadcast({
-                        type: 'lead_queue_update',
-                        payload: { leadId, queue },
-                    });
-
-                } catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: e.message }));
+                    res.end(JSON.stringify({ ok: true, alreadyCleaned: true }));
+                    return;
                 }
-            }).catch(() => {
-                res.writeHead(413, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Request body too large' }));
-            });
-            return;
-        }
-
-        // POST /leads/:id/dismiss-handoff - Dismiss a pending handoff
-        if (req.method === 'POST' && action === 'dismiss-handoff') {
-            collectRequestBody(req).then(async (body) => {
-                try {
-                    const { workItemId } = JSON.parse(body);
 
-                    const queue = leadWorkQueues.get(leadId) || [];
-                    const workItem = queue.find(w => w.id === workItemId);
-
-                    if (!workItem) {
-                        res.writeHead(404, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Work item not found' }));
-                        return;
+                // Remove worktree (handle case where directory was already manually deleted)
+                if (pipeline.worktreePath && pipeline.projectPath) {
+                    try {
+                        await removeWorktree(pipeline.projectPath, pipeline.worktreePath);
+                        log(`Pipeline ${pipelineId.slice(0, 8)}: Worktree manually cleaned up`);
+                    } catch (e) {
+                        log(`Pipeline ${pipelineId.slice(0, 8)}: Worktree removal warning: ${e.message}`);
+                        // Continue anyway — directory may already be gone
                     }
+                }
 
-                    if (workItem.status !== 'awaiting_handoff') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'Work item is not awaiting handoff' }));
-                        return;
+                // Optionally delete the local branch
+                if (deleteBranch && pipeline.branch && pipeline.projectPath) {
+                    try {
+                        await new Promise((resolve, reject) => {
+                            execFile('git', ['-C', pipeline.projectPath, 'branch', '-D', pipeline.branch], EXEC_OPTIONS, (error) => {
+                                if (error) reject(error);
+                                else resolve();
+                            });
+                        });
+                        log(`Pipeline ${pipelineId.slice(0, 8)}: Branch ${pipeline.branch} deleted`);
+                    } catch (e) {
+                        log(`Pipeline ${pipelineId.slice(0, 8)}: Branch deletion warning: ${e.message}`);
+                        // Continue — branch may already be gone
                     }
+                }
 
-                    // Mark as completed (dismissed)
-                    workItem.status = 'completed';
-                    const session = managedSessions.get(leadId);
-                    if (session) {
-                        session.workQueue = queue;
-                    }
-                    saveLeadState();
-                    broadcastSessions();
+                // Update pipeline state
+                pipeline.worktreeStatus = 'cleaned';
+                pipeline.updatedAt = Date.now();
+                pipelineManager.savePipeline(pipeline);
+                pipelineManager.broadcastPipeline(pipeline);
 
-                    broadcast({
-                        type: 'lead_queue_update',
-                        payload: { leadId, queue },
-                    });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+            } catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+            }
+        });
+        return;
+    }
 
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true }));
-                } 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' }));
-            });
+    // GET /pipelines/:id/files/:filename - Read plan file
+    // GET /pipelines/:id/files/:filename - Read plan file (strict whitelist)
+    const pipelineFileMatch = req.url?.match(/^\/pipelines\/([a-f0-9-]+)\/files\/([a-z_]+(?:\.[a-z]+)?)$/);
+    if (req.method === 'GET' && pipelineFileMatch) {
+        const pipelineId = pipelineFileMatch[1];
+        const filename = pipelineFileMatch[2];
+        const pipeline = pipelineManager.getPipeline(pipelineId);
+        if (!pipeline) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Pipeline not found' }));
+            return;
+        }
+        // Strict whitelist — only exact plan file names allowed
+        const allowedFiles = ['spec.md', 'implementation_plan.json', 'execution_log.md', 'review.md', 'human_review.md', 'pipeline.json'];
+        if (!allowedFiles.includes(filename)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Invalid filename' }));
+            return;
+        }
+        // Double-check: reject any path traversal chars (defense in depth)
+        if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Invalid filename' }));
             return;
         }
+        const filePath = join(pipelineManager.getPlanDir(pipeline), filename);
+        if (!existsSync(filePath)) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'File not found' }));
+            return;
+        }
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, content, filename }));
+        } catch (e) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+        return;
     }
+
     // ============================================================================
     // Claude Usage API
     // ============================================================================
@@ -5330,6 +5425,8 @@ async function handleHttpRequest(req, res) {
         if (req.method === 'DELETE' && !action) {
             deleteSession(sessionId).then((deleted) => {
                 if (deleted) {
+                    // If the deleted session was a ship agent, clear pipeline state
+                    pipelineManager.onSessionDeleted(sessionId);
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: true }));
                 }
@@ -5443,15 +5540,33 @@ async function handleHttpRequest(req, res) {
                 res.end(JSON.stringify({ ok: false, error: 'Invalid tmux session name' }));
                 return;
             }
+            // Send Ctrl+C, then verify the process responded after a short delay
             execFile('tmux', ['send-keys', '-t', session.tmuxSession, 'C-c'], EXEC_OPTIONS, (error) => {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
                 if (error) {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: error.message }));
+                    return;
                 }
-                else {
-                    log(`Sent Ctrl+C to ${session.name}`);
-                    res.end(JSON.stringify({ ok: true }));
-                }
+                log(`Sent Ctrl+C to ${session.name}`);
+                // Check if process is responsive after 2 seconds
+                // If the pane process died, the session is frozen — force kill it
+                setTimeout(() => {
+                    execFile('tmux', ['list-panes', '-t', session.tmuxSession, '-F', '#{pane_pid} #{pane_dead}'], EXEC_OPTIONS, (err2, stdout2) => {
+                        if (err2 || !stdout2) return;
+                        const parts = stdout2.trim().split(' ');
+                        const panePid = parseInt(parts[0], 10);
+                        const paneDead = parts[1] === '1';
+                        if (paneDead && panePid) {
+                            log(`${session.name} pane is dead after Ctrl+C, marking offline`);
+                            session.status = 'offline';
+                            session.currentTool = undefined;
+                            broadcastSessions();
+                            saveSessions();
+                        }
+                    });
+                }, 2000);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
             });
             return;
         }
@@ -5637,6 +5752,45 @@ async function handleHttpRequest(req, res) {
             });
             return;
         }
+        // GET /sessions/:id/output — Get recent agent output via REST (no WebSocket needed)
+        if (req.method === 'GET' && action === 'output') {
+            const session = getSession(sessionId);
+            if (!session) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Session not found' }));
+                return;
+            }
+            try {
+                validateTmuxSession(session.tmuxSession);
+            } catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Invalid tmux session' }));
+                return;
+            }
+            const urlObj = new URL(req.url, 'http://localhost');
+            const lines = Math.min(parseInt(urlObj.searchParams.get('lines') || '100', 10), 500);
+            execFile('tmux', ['capture-pane', '-t', session.tmuxSession, '-p', '-S', `-${lines}`],
+                { ...EXEC_OPTIONS, maxBuffer: 1024 * 1024 },
+                (error, stdout) => {
+                    if (error) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'Failed to capture output' }));
+                        return;
+                    }
+                    const tracker = sessionOutputs.get(session.id);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        ok: true,
+                        sessionId: session.id,
+                        name: session.name,
+                        status: session.status,
+                        raw: stdout,
+                        lastResponse: tracker?.lastResponse || null,
+                    }));
+                }
+            );
+            return;
+        }
     }
     // -------------------------------------------------------------------------
     // Text Tiles API
@@ -5734,6 +5888,114 @@ async function handleHttpRequest(req, res) {
             return;
         }
     }
+    // ============================================================================
+    // Remote Control API (convenience endpoints for external tools / MCP)
+    // ============================================================================
+
+    // GET /api/overview — Full system status in a single call
+    if (req.method === 'GET' && req.url === '/api/overview') {
+        const sessions = getSessions();
+        const projects = projectsManager.getProjects();
+        const pipelines = pipelineManager.getPipelines();
+        const allTasks = kanbanManager.getTasks();
+        const taskCounts = {};
+        for (const col of VALID_COLUMNS) { taskCounts[col] = 0; }
+        for (const t of allTasks) {
+            if (taskCounts[t.columnId] !== undefined) taskCounts[t.columnId]++;
+        }
+        const activePipelines = pipelines.filter(p => p.status === 'running' || p.status === 'pending');
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            ok: true,
+            agents: sessions.map(s => ({ id: s.id, name: s.name, status: s.status, currentTool: s.currentTool, projectId: s.projectId })),
+            projects: projects.map(p => ({ id: p.id, name: p.name, path: p.path })),
+            activePipelines: activePipelines.map(p => ({ id: p.id, taskId: p.taskId, status: p.status, phase: p.phase })),
+            taskCounts,
+            totalAgents: sessions.length,
+            totalProjects: projects.length,
+            totalTasks: allTasks.length,
+        }));
+        return;
+    }
+
+    // POST /api/restart — Gracefully restart the backend server
+    // Sessions, pipelines, and tasks persist to disk. tmux sessions keep running.
+    // WebSocket clients will auto-reconnect when the server comes back.
+    if (req.method === 'POST' && req.url === '/api/restart') {
+        log('Restart requested via API');
+        // Save all state before exiting
+        saveSessions();
+        saveTiles();
+        // Notify all WebSocket clients
+        broadcast({ type: 'server_restarting', payload: { message: 'Server is restarting...' } });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, message: 'Server restarting...' }));
+        // Give response time to flush, then self-restart
+        setTimeout(() => {
+            log('Restarting server...');
+            // Spawn a replacement server process, detached from this one.
+            // Uses spawn (not exec) with static args — no shell injection risk.
+            const serverPath = resolve(__dirname, 'index.js');
+            const child = spawn(process.execPath, [serverPath], {
+                env: process.env,
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            log('Spawned replacement server, exiting...');
+            process.exit(75);
+        }, 500);
+        return;
+    }
+
+    // POST /api/run-task — Create a kanban task and start a pipeline in one call
+    if (req.method === 'POST' && req.url === '/api/run-task') {
+        collectRequestBody(req).then(async (body) => {
+            try {
+                const { projectId, title, description, priority, tags } = JSON.parse(body);
+                if (!projectId || !title) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'projectId and title are required' }));
+                    return;
+                }
+                if (typeof title !== 'string' || title.length > 500) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Title must be a string under 500 characters' }));
+                    return;
+                }
+                const project = projectsManager.getProject(projectId);
+                if (!project) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'Project not found' }));
+                    return;
+                }
+                // Create task in "planning" column
+                const task = kanbanManager.createTask({
+                    title,
+                    description: description || '',
+                    projectId,
+                    columnId: 'planning',
+                    priority: priority || 'medium',
+                    tags: tags || [],
+                });
+                broadcast({ type: 'kanban_task_created', payload: { task } });
+                // Start pipeline
+                const pipeline = await pipelineManager.createPipeline(
+                    task.id, projectId, project.path, task.title, task.description || '', task.attachments || []
+                );
+                res.writeHead(201, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, task, pipeline }));
+            } 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;
+    }
+
     // Static file serving for frontend (production mode)
     serveStaticFile(req, res);
 }
@@ -5866,13 +6128,6 @@ function main() {
     gitStatusManager.start();
     log(`Git status polling started (adaptive: active=5s, idle=30s)`);
 
-    // Load lead agent state (after sessions are loaded)
-    loadLeadState();
-
-    // Set up commit watcher for lead agents
-    commitWatcher.setCommitHandler(handleNewCommit);
-    commitWatcher.start();
-    log(`Commit watcher started for ${projectLeads.size} projects`);
     // Watch for new events
     watchEventsFile();
     // Create HTTP server
@@ -5907,24 +6162,25 @@ function main() {
             payload: projectsManager.getProjects(),
         };
         ws.send(JSON.stringify(projectsMsg));
-        // Send pipelines
-        const pipelinesMsg = {
-            type: 'pipelines',
-            payload: Array.from(pipelineManager.pipelines.values()),
-        };
-        ws.send(JSON.stringify(pipelinesMsg));
-        // Send pipeline runs
-        const pipelineRunsMsg = {
-            type: 'pipeline_runs',
-            payload: Array.from(pipelineManager.runs.values()),
-        };
-        ws.send(JSON.stringify(pipelineRunsMsg));
         // Send text tiles
         const tilesMsg = {
             type: 'text_tiles',
             payload: getTiles(),
         };
         ws.send(JSON.stringify(tilesMsg));
+        // Send kanban tasks
+        const kanbanMsg = {
+            type: 'kanban_tasks',
+            payload: { tasks: kanbanManager.getTasks() },
+        };
+        ws.send(JSON.stringify(kanbanMsg));
+        // Send all pipelines (not just active) so frontend has worktree/branch info for completed tasks
+        const allPipelines = pipelineManager.getPipelines();
+        if (allPipelines.length > 0) {
+            for (const pipeline of allPipelines) {
+                ws.send(JSON.stringify({ type: 'pipeline_updated', payload: { pipeline } }));
+            }
+        }
         // Send recent history - filtered to only include events from current managed sessions
         const activeClaudeSessionIds = new Set(Array.from(managedSessions.values())
             .map(s => s.claudeSessionId)