claude-code-workflow 6.3.53 → 7.0.0

package/ccw/src/core/routes/issue-routes.ts

@@ -1,1547 +0,0 @@
-/**
- * Issue Routes Module (Optimized - Flat JSONL Storage)
- *
- * Storage Structure:
- * .workflow/issues/
- * ├── issues.jsonl              # All issues (one per line)
- * ├── queues/                   # Queue history directory
- * │   ├── index.json            # Queue index (active + history)
- * │   └── {queue-id}.json       # Individual queue files
- * └── solutions/
- *     ├── {issue-id}.jsonl      # Solutions for issue (one per line)
- *     └── ...
- *
- * API Endpoints (8 total):
- * - GET    /api/issues              - List all issues
- * - POST   /api/issues              - Create new issue
- * - GET    /api/issues/:id          - Get issue detail
- * - PATCH  /api/issues/:id          - Update issue (includes binding logic)
- * - DELETE /api/issues/:id          - Delete issue
- * - POST   /api/issues/:id/solutions - Add solution
- * - PATCH  /api/issues/:id/tasks/:taskId - Update task
- * - GET    /api/queue               - Get execution queue
- * - POST   /api/queue/reorder       - Reorder queue items
- */
-import { readFileSync, existsSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
-import { join, resolve, normalize } from 'path';
-import type { RouteContext } from './types.js';
-
-// ========== JSONL Helper Functions ==========
-
-function readIssuesJsonl(issuesDir: string): any[] {
-  const issuesPath = join(issuesDir, 'issues.jsonl');
-  if (!existsSync(issuesPath)) return [];
-  try {
-    const content = readFileSync(issuesPath, 'utf8');
-    return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
-  } catch {
-    return [];
-  }
-}
-
-function writeIssuesJsonl(issuesDir: string, issues: any[]) {
-  if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
-  const issuesPath = join(issuesDir, 'issues.jsonl');
-  writeFileSync(issuesPath, issues.map(i => JSON.stringify(i)).join('\n'));
-}
-
-function readSolutionsJsonl(issuesDir: string, issueId: string): any[] {
-  const solutionsPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
-  if (!existsSync(solutionsPath)) return [];
-  try {
-    const content = readFileSync(solutionsPath, 'utf8');
-    return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
-  } catch {
-    return [];
-  }
-}
-
-function readIssueHistoryJsonl(issuesDir: string): any[] {
-  const historyPath = join(issuesDir, 'issue-history.jsonl');
-  if (!existsSync(historyPath)) return [];
-  try {
-    const content = readFileSync(historyPath, 'utf8');
-    return content.split('\n').filter(line => line.trim()).map(line => JSON.parse(line));
-  } catch {
-    return [];
-  }
-}
-
-function writeIssueHistoryJsonl(issuesDir: string, issues: any[]) {
-  if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
-  const historyPath = join(issuesDir, 'issue-history.jsonl');
-  writeFileSync(historyPath, issues.map(i => JSON.stringify(i)).join('\n'));
-}
-
-function writeSolutionsJsonl(issuesDir: string, issueId: string, solutions: any[]) {
-  const solutionsDir = join(issuesDir, 'solutions');
-  if (!existsSync(solutionsDir)) mkdirSync(solutionsDir, { recursive: true });
-  writeFileSync(join(solutionsDir, `${issueId}.jsonl`), solutions.map(s => JSON.stringify(s)).join('\n'));
-}
-
-function generateQueueFileId(): string {
-  const now = new Date();
-  const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
-  return `QUE-${ts}`;
-}
-
-function readQueue(issuesDir: string) {
-  // Try new multi-queue structure first
-  const queuesDir = join(issuesDir, 'queues');
-  const indexPath = join(queuesDir, 'index.json');
-
-  if (existsSync(indexPath)) {
-    try {
-      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-      const activeQueueId = index.active_queue_id;
-
-      if (activeQueueId) {
-        const queueFilePath = join(queuesDir, `${activeQueueId}.json`);
-        if (existsSync(queueFilePath)) {
-          return JSON.parse(readFileSync(queueFilePath, 'utf8'));
-        }
-      }
-    } catch {
-      // Fall through to legacy check
-    }
-  }
-
-  // Fallback to legacy queue.json
-  const legacyQueuePath = join(issuesDir, 'queue.json');
-  if (existsSync(legacyQueuePath)) {
-    try {
-      return JSON.parse(readFileSync(legacyQueuePath, 'utf8'));
-    } catch {
-      // Return empty queue
-    }
-  }
-
-  return { tasks: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
-}
-
-function writeQueue(issuesDir: string, queue: any) {
-  if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
-
-  // Support both solution-based and task-based queues
-  const items = queue.solutions || queue.tasks || [];
-  const isSolutionBased = Array.isArray(queue.solutions) && queue.solutions.length > 0;
-
-  queue._metadata = {
-    ...queue._metadata,
-    updated_at: new Date().toISOString(),
-    ...(isSolutionBased
-      ? { total_solutions: items.length }
-      : { total_tasks: items.length })
-  };
-
-  // Check if using new multi-queue structure
-  const queuesDir = join(issuesDir, 'queues');
-  const indexPath = join(queuesDir, 'index.json');
-
-  if (existsSync(indexPath) && queue.id) {
-    // Write to new structure
-    const queueFilePath = join(queuesDir, `${queue.id}.json`);
-    writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
-
-    // Update index metadata
-    try {
-      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-      const queueEntry = index.queues?.find((q: any) => q.id === queue.id);
-      if (queueEntry) {
-        if (isSolutionBased) {
-          queueEntry.total_solutions = items.length;
-          queueEntry.completed_solutions = items.filter((i: any) => i.status === 'completed').length;
-        } else {
-          queueEntry.total_tasks = items.length;
-          queueEntry.completed_tasks = items.filter((i: any) => i.status === 'completed').length;
-        }
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-      }
-    } catch {
-      // Ignore index update errors
-    }
-  } else {
-    // Fallback to legacy queue.json
-    writeFileSync(join(issuesDir, 'queue.json'), JSON.stringify(queue, null, 2));
-  }
-}
-
-function getIssueDetail(issuesDir: string, issueId: string) {
-  const issues = readIssuesJsonl(issuesDir);
-  let issue = issues.find(i => i.id === issueId);
-
-  // Fix: Check history if not found in active issues
-  if (!issue) {
-    const historyIssues = readIssueHistoryJsonl(issuesDir);
-    issue = historyIssues.find(i => i.id === issueId);
-  }
-
-  // Fallback: Reconstruct issue from solution file if issue not in issues.jsonl or history
-  if (!issue) {
-    const solutionPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
-    if (existsSync(solutionPath)) {
-      const solutions = readSolutionsJsonl(issuesDir, issueId);
-      if (solutions.length > 0) {
-        const boundSolution = solutions.find(s => s.is_bound) || solutions[0];
-        issue = {
-          id: issueId,
-          title: boundSolution?.description || issueId,
-          status: 'completed',
-          priority: 3,
-          context: boundSolution?.approach || '',
-          bound_solution_id: boundSolution?.id || null,
-          created_at: boundSolution?.created_at || new Date().toISOString(),
-          updated_at: new Date().toISOString(),
-          _reconstructed: true
-        };
-      }
-    }
-  }
-
-  if (!issue) return null;
-
-  const solutions = readSolutionsJsonl(issuesDir, issueId);
-  let tasks: any[] = [];
-  if (issue.bound_solution_id) {
-    const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
-    if (boundSol?.tasks) tasks = boundSol.tasks;
-  }
-  return { ...issue, solutions, tasks };
-}
-
-function enrichIssues(issues: any[], issuesDir: string) {
-  return issues.map(issue => {
-    const solutions = readSolutionsJsonl(issuesDir, issue.id);
-    let tasks: any[] = [];
-
-    // Get tasks from bound solution
-    if (issue.bound_solution_id) {
-      const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
-      if (boundSol?.tasks) {
-        tasks = boundSol.tasks;
-      }
-    }
-
-    return {
-      ...issue,
-      solutions,                        // Add full solutions array
-      tasks,                            // Add full tasks array
-      solution_count: solutions.length,
-      task_count: tasks.length
-    };
-  });
-}
-
-/**
- * Get queue items (supports both solution-based and task-based queues)
- */
-function getQueueItems(queue: any): any[] {
-  return queue.solutions || queue.tasks || [];
-}
-
-/**
- * Check if queue is solution-based
- */
-function isSolutionBasedQueue(queue: any): boolean {
-  return Array.isArray(queue.solutions) && queue.solutions.length > 0;
-}
-
-function groupQueueByExecutionGroup(queue: any) {
-  const groups: { [key: string]: any[] } = {};
-  const items = getQueueItems(queue);
-  const isSolutionBased = isSolutionBasedQueue(queue);
-
-  for (const item of items) {
-    const groupId = item.execution_group || 'ungrouped';
-    if (!groups[groupId]) groups[groupId] = [];
-    groups[groupId].push(item);
-  }
-  for (const groupId of Object.keys(groups)) {
-    groups[groupId].sort((a, b) => (a.execution_order || 0) - (b.execution_order || 0));
-  }
-  const executionGroups = Object.entries(groups).map(([id, groupItems]) => ({
-    id,
-    type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
-    // Use appropriate count field based on queue type
-    ...(isSolutionBased
-      ? { solution_count: groupItems.length, solutions: groupItems.map(i => i.item_id) }
-      : { task_count: groupItems.length, tasks: groupItems.map(i => i.item_id) })
-  })).sort((a, b) => {
-    const aFirst = groups[a.id]?.[0]?.execution_order || 0;
-    const bFirst = groups[b.id]?.[0]?.execution_order || 0;
-    return aFirst - bFirst;
-  });
-  return { ...queue, execution_groups: executionGroups, grouped_items: groups };
-}
-
-/**
- * Bind solution to issue with proper side effects
- */
-function bindSolutionToIssue(issuesDir: string, issueId: string, solutionId: string, issues: any[], issueIndex: number) {
-  const solutions = readSolutionsJsonl(issuesDir, issueId);
-  const solIndex = solutions.findIndex(s => s.id === solutionId);
-
-  if (solIndex === -1) return { error: `Solution ${solutionId} not found` };
-
-  // Unbind all, bind new
-  solutions.forEach(s => { s.is_bound = false; });
-  solutions[solIndex].is_bound = true;
-  solutions[solIndex].bound_at = new Date().toISOString();
-  writeSolutionsJsonl(issuesDir, issueId, solutions);
-
-  // Update issue
-  issues[issueIndex].bound_solution_id = solutionId;
-  issues[issueIndex].status = 'planned';
-  issues[issueIndex].planned_at = new Date().toISOString();
-
-  return { success: true, bound: solutionId };
-}
-
-// ========== Path Validation ==========
-
-/**
- * Validate that the provided path is safe (no path traversal)
- * Returns the resolved, normalized path or null if invalid
- */
-function validateProjectPath(requestedPath: string, basePath: string): string | null {
-  if (!requestedPath) return basePath;
-
-  // Resolve to absolute path and normalize
-  const resolvedPath = resolve(normalize(requestedPath));
-  const resolvedBase = resolve(normalize(basePath));
-
-  // For local development tool, we allow any absolute path
-  // but prevent obvious traversal attempts
-  if (requestedPath.includes('..') && !resolvedPath.startsWith(resolvedBase)) {
-    // Check if it's trying to escape with ..
-    const normalizedRequested = normalize(requestedPath);
-    if (normalizedRequested.startsWith('..')) {
-      return null;
-    }
-  }
-
-  return resolvedPath;
-}
-
-// ========== Route Handler ==========
-
-export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
-  const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
-  const rawProjectPath = url.searchParams.get('path') || initialPath;
-
-  // Validate project path to prevent path traversal
-  const projectPath = validateProjectPath(rawProjectPath, initialPath);
-  if (!projectPath) {
-    res.writeHead(400, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'Invalid project path' }));
-    return true;
-  }
-
-  const issuesDir = join(projectPath, '.workflow', 'issues');
-
-  // ===== Helper: Normalize queue path (supports both /api/queue/* and /api/issues/queue/*) =====
-  const normalizeQueuePath = (path: string): string | null => {
-    if (path.startsWith('/api/issues/queue')) {
-      return path.replace('/api/issues/queue', '/api/queue');
-    }
-    if (path.startsWith('/api/queue')) {
-      return path;
-    }
-    return null;
-  };
-
-  const normalizedPath = normalizeQueuePath(pathname);
-
-  // ===== Queue Routes (supports both /api/queue/* and /api/issues/queue/*) =====
-
-  // GET /api/queue or /api/issues/queue - Get execution queue
-  if ((normalizedPath === '/api/queue') && req.method === 'GET') {
-    const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(queue));
-    return true;
-  }
-
-  // GET /api/queue/history or /api/issues/queue/history - Get queue history (all queues from index)
-  if (normalizedPath === '/api/queue/history' && req.method === 'GET') {
-    const queuesDir = join(issuesDir, 'queues');
-    const indexPath = join(queuesDir, 'index.json');
-
-    if (!existsSync(indexPath)) {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
-      return true;
-    }
-
-    try {
-      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-      // Ensure active_queue_ids is always returned for multi-queue support
-      if (!index.active_queue_ids) {
-        index.active_queue_ids = index.active_queue_id ? [index.active_queue_id] : [];
-      }
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(index));
-    } catch {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ queues: [], active_queue_id: null, active_queue_ids: [] }));
-    }
-    return true;
-  }
-
-  // GET /api/queue/:id or /api/issues/queue/:id - Get specific queue by ID
-  const queueDetailMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
-  const reservedQueuePaths = ['history', 'reorder', 'switch', 'deactivate', 'merge', 'activate'];
-  if (queueDetailMatch && req.method === 'GET' && !reservedQueuePaths.includes(queueDetailMatch[1])) {
-    const queueId = queueDetailMatch[1];
-    const queuesDir = join(issuesDir, 'queues');
-    const queueFilePath = join(queuesDir, `${queueId}.json`);
-
-    if (!existsSync(queueFilePath)) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
-      return true;
-    }
-
-    try {
-      const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(groupQueueByExecutionGroup(queue)));
-    } catch {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Failed to read queue' }));
-    }
-    return true;
-  }
-
-  // POST /api/queue/activate or /api/issues/queue/activate - Activate one or more queues (multi-queue support)
-  if (normalizedPath === '/api/queue/activate' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { queueId, queueIds } = body;
-
-      // Support both single queueId and array queueIds
-      const idsToActivate: string[] = queueIds
-        ? (Array.isArray(queueIds) ? queueIds : [queueIds])
-        : (queueId ? [queueId] : []);
-
-      if (idsToActivate.length === 0) {
-        return { error: 'queueId or queueIds required' };
-      }
-
-      const queuesDir = join(issuesDir, 'queues');
-      const indexPath = join(queuesDir, 'index.json');
-
-      // Validate all queue IDs exist
-      for (const id of idsToActivate) {
-        const queueFilePath = join(queuesDir, `${id}.json`);
-        if (!existsSync(queueFilePath)) {
-          return { error: `Queue ${id} not found` };
-        }
-      }
-
-      try {
-        const index = existsSync(indexPath)
-          ? JSON.parse(readFileSync(indexPath, 'utf8'))
-          : { active_queue_id: null, active_queue_ids: [], queues: [] };
-
-        index.active_queue_ids = idsToActivate;
-        index.active_queue_id = idsToActivate[0] || null; // Backward compat
-
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-
-        return {
-          success: true,
-          active_queue_ids: idsToActivate,
-          active_queue_id: idsToActivate[0] || null // Backward compat
-        };
-      } catch (err) {
-        return { error: 'Failed to activate queue(s)' };
-      }
-    });
-    return true;
-  }
-
-  // POST /api/queue/switch or /api/issues/queue/switch - Switch active queue (legacy, single queue)
-  if (normalizedPath === '/api/queue/switch' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { queueId } = body;
-      if (!queueId) return { error: 'queueId required' };
-
-      const queuesDir = join(issuesDir, 'queues');
-      const indexPath = join(queuesDir, 'index.json');
-      const queueFilePath = join(queuesDir, `${queueId}.json`);
-
-      if (!existsSync(queueFilePath)) {
-        return { error: `Queue ${queueId} not found` };
-      }
-
-      try {
-        const index = existsSync(indexPath)
-          ? JSON.parse(readFileSync(indexPath, 'utf8'))
-          : { active_queue_id: null, active_queue_ids: [], queues: [] };
-
-        index.active_queue_id = queueId;
-        index.active_queue_ids = [queueId]; // Also update multi-queue array
-
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-
-        return {
-          success: true,
-          active_queue_id: queueId,
-          active_queue_ids: [queueId]
-        };
-      } catch (err) {
-        return { error: 'Failed to switch queue' };
-      }
-    });
-    return true;
-  }
-
-  // POST /api/queue/deactivate or /api/issues/queue/deactivate - Deactivate queue(s)
-  if (normalizedPath === '/api/queue/deactivate' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { queueId } = body; // Optional: specific queue to deactivate
-      const queuesDir = join(issuesDir, 'queues');
-      const indexPath = join(queuesDir, 'index.json');
-
-      try {
-        const index = existsSync(indexPath)
-          ? JSON.parse(readFileSync(indexPath, 'utf8'))
-          : { active_queue_id: null, active_queue_ids: [], queues: [] };
-
-        const currentActiveIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
-        let deactivatedIds: string[] = [];
-        let remainingIds: string[] = [];
-
-        if (queueId) {
-          // Deactivate specific queue
-          deactivatedIds = currentActiveIds.includes(queueId) ? [queueId] : [];
-          remainingIds = currentActiveIds.filter((id: string) => id !== queueId);
-        } else {
-          // Deactivate all
-          deactivatedIds = [...currentActiveIds];
-          remainingIds = [];
-        }
-
-        index.active_queue_ids = remainingIds;
-        index.active_queue_id = remainingIds[0] || null; // Backward compat
-
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-
-        return {
-          success: true,
-          deactivated_queue_ids: deactivatedIds,
-          active_queue_ids: remainingIds,
-          active_queue_id: remainingIds[0] || null // Backward compat
-        };
-      } catch (err) {
-        return { error: 'Failed to deactivate queue' };
-      }
-    });
-    return true;
-  }
-
-  // POST /api/queue/reorder or /api/issues/queue/reorder - Reorder queue items (supports both solutions and tasks)
-  if (normalizedPath === '/api/queue/reorder' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { groupId, newOrder } = body;
-      if (!groupId || !Array.isArray(newOrder)) {
-        return { error: 'groupId and newOrder (array) required' };
-      }
-
-      const queue = readQueue(issuesDir);
-      const items = getQueueItems(queue);
-      const isSolutionBased = isSolutionBasedQueue(queue);
-
-      const groupItems = items.filter((item: any) => item.execution_group === groupId);
-      const otherItems = items.filter((item: any) => item.execution_group !== groupId);
-
-      if (groupItems.length === 0) return { error: `No items in group ${groupId}` };
-
-      const groupItemIds = new Set(groupItems.map((i: any) => i.item_id));
-      if (groupItemIds.size !== new Set(newOrder).size) {
-        return { error: 'newOrder must contain all group items' };
-      }
-      for (const id of newOrder) {
-        if (!groupItemIds.has(id)) return { error: `Invalid item_id: ${id}` };
-      }
-
-      const itemMap = new Map(groupItems.map((i: any) => [i.item_id, i]));
-      const reorderedItems = newOrder.map((qid: string, idx: number) => ({ ...itemMap.get(qid), _idx: idx }));
-      const newQueueItems = [...otherItems, ...reorderedItems].sort((a, b) => {
-        const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
-        const bGroup = parseInt(b.execution_group?.match(/\d+/)?.[0] || '999');
-        if (aGroup !== bGroup) return aGroup - bGroup;
-        if (a.execution_group === b.execution_group) {
-          return (a._idx ?? a.execution_order ?? 999) - (b._idx ?? b.execution_order ?? 999);
-        }
-        return (a.execution_order || 0) - (b.execution_order || 0);
-      });
-
-      newQueueItems.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
-
-      // Write back to appropriate array based on queue type
-      if (isSolutionBased) {
-        queue.solutions = newQueueItems;
-      } else {
-        queue.tasks = newQueueItems;
-      }
-      writeQueue(issuesDir, queue);
-
-      return { success: true, groupId, reordered: newOrder.length };
-    });
-    return true;
-  }
-
-  // DELETE /api/queue/:queueId/item/:itemId or /api/issues/queue/:queueId/item/:itemId
-  const queueItemDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)\/item\/([^/]+)$/);
-  if (queueItemDeleteMatch && req.method === 'DELETE') {
-    const queueId = queueItemDeleteMatch[1];
-    const itemId = decodeURIComponent(queueItemDeleteMatch[2]);
-
-    const queuesDir = join(issuesDir, 'queues');
-    const queueFilePath = join(queuesDir, `${queueId}.json`);
-
-    if (!existsSync(queueFilePath)) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
-      return true;
-    }
-
-    try {
-      const queue = JSON.parse(readFileSync(queueFilePath, 'utf8'));
-      const items = queue.solutions || queue.tasks || [];
-      const filteredItems = items.filter((item: any) => item.item_id !== itemId);
-
-      if (filteredItems.length === items.length) {
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: `Item ${itemId} not found in queue` }));
-        return true;
-      }
-
-      // Update queue items
-      if (queue.solutions) {
-        queue.solutions = filteredItems;
-      } else {
-        queue.tasks = filteredItems;
-      }
-
-      // Recalculate metadata
-      const completedCount = filteredItems.filter((i: any) => i.status === 'completed').length;
-      queue._metadata = {
-        ...queue._metadata,
-        updated_at: new Date().toISOString(),
-        ...(queue.solutions
-          ? { total_solutions: filteredItems.length, completed_solutions: completedCount }
-          : { total_tasks: filteredItems.length, completed_tasks: completedCount })
-      };
-
-      writeFileSync(queueFilePath, JSON.stringify(queue, null, 2));
-
-      // Update index counts
-      const indexPath = join(queuesDir, 'index.json');
-      if (existsSync(indexPath)) {
-        try {
-          const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-          const queueEntry = index.queues?.find((q: any) => q.id === queueId);
-          if (queueEntry) {
-            if (queue.solutions) {
-              queueEntry.total_solutions = filteredItems.length;
-              queueEntry.completed_solutions = completedCount;
-            } else {
-              queueEntry.total_tasks = filteredItems.length;
-              queueEntry.completed_tasks = completedCount;
-            }
-            writeFileSync(indexPath, JSON.stringify(index, null, 2));
-          }
-        } catch (err) {
-          console.error('Failed to update queue index:', err);
-        }
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, queueId, deletedItemId: itemId }));
-    } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Failed to delete item' }));
-    }
-    return true;
-  }
-
-  // DELETE /api/queue/:queueId or /api/issues/queue/:queueId - Delete entire queue
-  const queueDeleteMatch = normalizedPath?.match(/^\/api\/queue\/([^/]+)$/);
-  if (queueDeleteMatch && req.method === 'DELETE') {
-    const queueId = queueDeleteMatch[1];
-    const queuesDir = join(issuesDir, 'queues');
-    const queueFilePath = join(queuesDir, `${queueId}.json`);
-    const indexPath = join(queuesDir, 'index.json');
-
-    if (!existsSync(queueFilePath)) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: `Queue ${queueId} not found` }));
-      return true;
-    }
-
-    try {
-      // Delete queue file
-      unlinkSync(queueFilePath);
-
-      // Update index
-      if (existsSync(indexPath)) {
-        const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-
-        // Remove from queues array
-        index.queues = (index.queues || []).filter((q: any) => q.id !== queueId);
-
-        // Clear active if this was the active queue
-        if (index.active_queue_id === queueId) {
-          index.active_queue_id = null;
-        }
-
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-      }
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ success: true, deletedQueueId: queueId }));
-    } catch (err) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Failed to delete queue' }));
-    }
-    return true;
-  }
-
-  // POST /api/queue/merge or /api/issues/queue/merge - Merge source queue into target queue
-  if (normalizedPath === '/api/queue/merge' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { sourceQueueId, targetQueueId } = body;
-      if (!sourceQueueId || !targetQueueId) {
-        return { error: 'sourceQueueId and targetQueueId required' };
-      }
-
-      if (sourceQueueId === targetQueueId) {
-        return { error: 'Cannot merge queue into itself' };
-      }
-
-      const queuesDir = join(issuesDir, 'queues');
-      const sourcePath = join(queuesDir, `${sourceQueueId}.json`);
-      const targetPath = join(queuesDir, `${targetQueueId}.json`);
-
-      if (!existsSync(sourcePath)) return { error: `Source queue ${sourceQueueId} not found` };
-      if (!existsSync(targetPath)) return { error: `Target queue ${targetQueueId} not found` };
-
-      try {
-        const sourceQueue = JSON.parse(readFileSync(sourcePath, 'utf8'));
-        const targetQueue = JSON.parse(readFileSync(targetPath, 'utf8'));
-
-        const sourceItems = sourceQueue.solutions || sourceQueue.tasks || [];
-        const targetItems = targetQueue.solutions || targetQueue.tasks || [];
-        const isSolutionBased = !!targetQueue.solutions;
-
-        if (!isSolutionBased) {
-          targetQueue.solutions = [];
-        }
-
-        // Helper to generate next item ID (S-N format)
-        const getNextItemId = (): string => {
-          const items = targetQueue.solutions || [];
-          const maxNum = items.reduce((max: number, i: any) => {
-            const match = i.item_id?.match(/^S-(\d+)$/);
-            return match ? Math.max(max, parseInt(match[1])) : max;
-          }, 0);
-          return `S-${maxNum + 1}`;
-        };
-
-        let itemsMerged = 0;
-        let skippedDuplicates = 0;
-
-        for (const sourceItem of sourceItems) {
-          // Skip duplicates (same issue_id + solution_id)
-          const exists = (targetQueue.solutions || []).some(
-            (t: any) => t.issue_id === sourceItem.issue_id && t.solution_id === sourceItem.solution_id
-          );
-
-          if (exists) {
-            skippedDuplicates++;
-            continue;
-          }
-
-          // Add with new item_id (S-N format)
-          const newItem = {
-            ...sourceItem,
-            item_id: getNextItemId(),
-            execution_order: (targetQueue.solutions?.length || 0) + 1
-          };
-
-          if (!targetQueue.solutions) targetQueue.solutions = [];
-          targetQueue.solutions.push(newItem);
-          itemsMerged++;
-        }
-
-        // Merge issue_ids
-        const mergedIssueIds = [...new Set([
-          ...(targetQueue.issue_ids || []),
-          ...(sourceQueue.issue_ids || [])
-        ])];
-        targetQueue.issue_ids = mergedIssueIds;
-
-        // Merge conflicts
-        if (sourceQueue.conflicts && sourceQueue.conflicts.length > 0) {
-          if (!targetQueue.conflicts) targetQueue.conflicts = [];
-          targetQueue.conflicts.push(...sourceQueue.conflicts);
-        }
-
-        // Update metadata
-        const mergedItems = targetQueue.solutions || [];
-        const completedCount = mergedItems.filter((i: any) => i.status === 'completed').length;
-        targetQueue._metadata = {
-          ...targetQueue._metadata,
-          updated_at: new Date().toISOString(),
-          total_solutions: mergedItems.length,
-          completed_solutions: completedCount
-        };
-
-        // Write merged queue
-        writeFileSync(targetPath, JSON.stringify(targetQueue, null, 2));
-
-        // Update source queue status to 'merged'
-        sourceQueue.status = 'merged';
-        sourceQueue._metadata = {
-          ...sourceQueue._metadata,
-          merged_into: targetQueueId,
-          merged_at: new Date().toISOString()
-        };
-        writeFileSync(sourcePath, JSON.stringify(sourceQueue, null, 2));
-
-        // Update index
-        const indexPath = join(queuesDir, 'index.json');
-        if (existsSync(indexPath)) {
-          try {
-            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-            const sourceEntry = index.queues?.find((q: any) => q.id === sourceQueueId);
-            const targetEntry = index.queues?.find((q: any) => q.id === targetQueueId);
-            if (sourceEntry) {
-              sourceEntry.status = 'merged';
-            }
-            if (targetEntry) {
-              targetEntry.total_solutions = mergedItems.length;
-              targetEntry.completed_solutions = completedCount;
-              targetEntry.issue_ids = mergedIssueIds;
-            }
-            writeFileSync(indexPath, JSON.stringify(index, null, 2));
-          } catch {
-            // Ignore index update errors
-          }
-        }
-
-        return {
-          success: true,
-          sourceQueueId,
-          targetQueueId,
-          mergedItemCount: itemsMerged,
-          skippedDuplicates,
-          totalItems: mergedItems.length
-        };
-      } catch (err) {
-        return { error: 'Failed to merge queues' };
-      }
-    });
-    return true;
-  }
-
-  // POST /api/queue/split - Split items from source queue into a new queue
-  if (normalizedPath === '/api/queue/split' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      const { sourceQueueId, itemIds } = body;
-      if (!sourceQueueId || !itemIds || !Array.isArray(itemIds) || itemIds.length === 0) {
-        return { error: 'sourceQueueId and itemIds (non-empty array) required' };
-      }
-
-      const queuesDir = join(issuesDir, 'queues');
-      const sourcePath = join(queuesDir, `${sourceQueueId}.json`);
-
-      if (!existsSync(sourcePath)) {
-        return { error: `Source queue ${sourceQueueId} not found` };
-      }
-
-      try {
-        const sourceQueue = JSON.parse(readFileSync(sourcePath, 'utf8'));
-        const sourceItems = sourceQueue.solutions || sourceQueue.tasks || [];
-        const isSolutionBased = !!sourceQueue.solutions;
-
-        // Find items to split
-        const itemsToSplit = sourceItems.filter((item: any) =>
-          itemIds.includes(item.item_id) ||
-          itemIds.includes(item.solution_id) ||
-          itemIds.includes(item.task_id)
-        );
-
-        if (itemsToSplit.length === 0) {
-          return { error: 'No matching items found to split' };
-        }
-
-        if (itemsToSplit.length === sourceItems.length) {
-          return { error: 'Cannot split all items - at least one item must remain in source queue' };
-        }
-
-        // Find remaining items
-        const remainingItems = sourceItems.filter((item: any) =>
-          !itemIds.includes(item.item_id) &&
-          !itemIds.includes(item.solution_id) &&
-          !itemIds.includes(item.task_id)
-        );
-
-        // Create new queue with split items
-        const newQueueId = generateQueueFileId();
-        const newQueuePath = join(queuesDir, `${newQueueId}.json`);
-
-        // Re-index split items
-        const reindexedSplitItems = itemsToSplit.map((item: any, idx: number) => ({
-          ...item,
-          execution_order: idx + 1
-        }));
-
-        // Extract issue IDs from split items
-        const splitIssueIds = [...new Set(itemsToSplit.map((item: any) => item.issue_id).filter(Boolean))];
-
-        // Remaining issue IDs
-        const remainingIssueIds = [...new Set(remainingItems.map((item: any) => item.issue_id).filter(Boolean))];
-
-        // Create new queue
-        const newQueue: any = {
-          id: newQueueId,
-          status: 'active',
-          issue_ids: splitIssueIds,
-          conflicts: [],
-          _metadata: {
-            version: '2.1',
-            updated_at: new Date().toISOString(),
-            split_from: sourceQueueId,
-            split_at: new Date().toISOString(),
-            ...(isSolutionBased
-              ? {
-                  total_solutions: reindexedSplitItems.length,
-                  completed_solutions: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
-                }
-              : {
-                  total_tasks: reindexedSplitItems.length,
-                  completed_tasks: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
-                })
-          }
-        };
-
-        if (isSolutionBased) {
-          newQueue.solutions = reindexedSplitItems;
-        } else {
-          newQueue.tasks = reindexedSplitItems;
-        }
-
-        // Update source queue with remaining items
-        const reindexedRemainingItems = remainingItems.map((item: any, idx: number) => ({
-          ...item,
-          execution_order: idx + 1
-        }));
-
-        if (isSolutionBased) {
-          sourceQueue.solutions = reindexedRemainingItems;
-        } else {
-          sourceQueue.tasks = reindexedRemainingItems;
-        }
-
-        sourceQueue.issue_ids = remainingIssueIds;
-        sourceQueue._metadata = {
-          ...sourceQueue._metadata,
-          updated_at: new Date().toISOString(),
-          ...(isSolutionBased
-            ? {
-                total_solutions: reindexedRemainingItems.length,
-                completed_solutions: reindexedRemainingItems.filter((i: any) => i.status === 'completed').length
-              }
-            : {
-                total_tasks: reindexedRemainingItems.length,
-                completed_tasks: reindexedRemainingItems.filter((i: any) => i.status === 'completed').length
-              })
-        };
-
-        // Write both queues
-        writeFileSync(newQueuePath, JSON.stringify(newQueue, null, 2));
-        writeFileSync(sourcePath, JSON.stringify(sourceQueue, null, 2));
-
-        // Update index
-        const indexPath = join(queuesDir, 'index.json');
-        if (existsSync(indexPath)) {
-          try {
-            const index = JSON.parse(readFileSync(indexPath, 'utf8'));
-
-            // Add new queue to index
-            const newQueueEntry: any = {
-              id: newQueueId,
-              status: 'active',
-              issue_ids: splitIssueIds,
-              created_at: new Date().toISOString(),
-              ...(isSolutionBased
-                ? {
-                    total_solutions: reindexedSplitItems.length,
-                    completed_solutions: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
-                  }
-                : {
-                    total_tasks: reindexedSplitItems.length,
-                    completed_tasks: reindexedSplitItems.filter((i: any) => i.status === 'completed').length
-                  })
-            };
-
-            index.queues = index.queues || [];
-            index.queues.push(newQueueEntry);
-
-            // Update source queue in index
-            const sourceEntry = index.queues.find((q: any) => q.id === sourceQueueId);
-            if (sourceEntry) {
-              sourceEntry.issue_ids = remainingIssueIds;
-              if (isSolutionBased) {
-                sourceEntry.total_solutions = reindexedRemainingItems.length;
-                sourceEntry.completed_solutions = reindexedRemainingItems.filter((i: any) => i.status === 'completed').length;
-              } else {
-                sourceEntry.total_tasks = reindexedRemainingItems.length;
-                sourceEntry.completed_tasks = reindexedRemainingItems.filter((i: any) => i.status === 'completed').length;
-              }
-            }
-
-            writeFileSync(indexPath, JSON.stringify(index, null, 2));
-          } catch {
-            // Ignore index update errors
-          }
-        }
-
-        return {
-          success: true,
-          sourceQueueId,
-          newQueueId,
-          splitItemCount: itemsToSplit.length,
-          remainingItemCount: remainingItems.length
-        };
-      } catch (err) {
-        return { error: 'Failed to split queue' };
-      }
-    });
-    return true;
-  }
-
-  // Legacy: GET /api/issues/queue (backward compat)
-  if (pathname === '/api/issues/queue' && req.method === 'GET') {
-    const queue = groupQueueByExecutionGroup(readQueue(issuesDir));
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(queue));
-    return true;
-  }
-
-  // ===== Issue Routes =====
-
-  // GET /api/issues - List all issues
-  if (pathname === '/api/issues' && req.method === 'GET') {
-    const issues = enrichIssues(readIssuesJsonl(issuesDir), issuesDir);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-      issues,
-      _metadata: { version: '2.0', storage: 'jsonl', total_issues: issues.length, last_updated: new Date().toISOString() }
-    }));
-    return true;
-  }
-
-  // GET /api/issues/history - List completed issues from history
-  if (pathname === '/api/issues/history' && req.method === 'GET') {
-    // Fix: Use enrichIssues to add solution/task counts to historical issues
-    const history = enrichIssues(readIssueHistoryJsonl(issuesDir), issuesDir);
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({
-      issues: history,
-      _metadata: { version: '1.0', storage: 'jsonl', total_issues: history.length, last_updated: new Date().toISOString() }
-    }));
-    return true;
-  }
-
-  // POST /api/issues - Create issue
-  if (pathname === '/api/issues' && req.method === 'POST') {
-    handlePostRequest(req, res, async (body: any) => {
-      if (!body.id || !body.title) return { error: 'id and title required' };
-
-      const issues = readIssuesJsonl(issuesDir);
-      if (issues.find(i => i.id === body.id)) return { error: `Issue ${body.id} exists` };
-
-      const newIssue = {
-        id: body.id,
-        title: body.title,
-        status: body.status || 'registered',
-        priority: body.priority || 3,
-        context: body.context || '',
-        source: body.source || 'text',
-        source_url: body.source_url || null,
-        tags: body.tags || [],
-        created_at: new Date().toISOString(),
-        updated_at: new Date().toISOString()
-      };
-
-      issues.push(newIssue);
-      writeIssuesJsonl(issuesDir, issues);
-      return { success: true, issue: newIssue };
-    });
-    return true;
-  }
-
-  // POST /api/issues/pull - Pull issues from GitHub
-  if (pathname === '/api/issues/pull' && req.method === 'POST') {
-    const state = url.searchParams.get('state') || 'open';
-    const limit = parseInt(url.searchParams.get('limit') || '100');
-    const labels = url.searchParams.get('labels') || '';
-    const downloadImages = url.searchParams.get('downloadImages') === 'true';
-
-    try {
-      const { execSync } = await import('child_process');
-      const https = await import('https');
-      const http = await import('http');
-
-      // Check if gh CLI is available
-      try {
-        execSync('gh --version', { stdio: 'ignore', timeout: 5000 });
-      } catch {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'GitHub CLI (gh) is not installed or not in PATH' }));
-        return true;
-      }
-
-      // Build gh command
-      let ghCommand = `gh issue list --state ${state} --limit ${limit} --json number,title,body,labels,url,state`;
-      if (labels) ghCommand += ` --label "${labels}"`;
-
-      // Execute gh command from project root
-      const ghOutput = execSync(ghCommand, {
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 60000,
-        cwd: issuesDir.replace(/[\\/]\.workflow[\\/]issues$/, '')
-      }).trim();
-
-      if (!ghOutput) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ imported: 0, updated: 0, skipped: 0, images_downloaded: 0 }));
-        return true;
-      }
-
-      const ghIssues = JSON.parse(ghOutput);
-      const existingIssues = readIssuesJsonl(issuesDir);
-
-      let imported = 0;
-      let skipped = 0;
-      let updated = 0;
-      let imagesDownloaded = 0;
-
-      // Create images directory if needed
-      const imagesDir = join(issuesDir, 'images');
-      if (downloadImages && !existsSync(imagesDir)) {
-        mkdirSync(imagesDir, { recursive: true });
-      }
-
-      // Helper function to download image
-      const downloadImage = async (imageUrl: string, issueNumber: number, imageIndex: number): Promise<string | null> => {
-        return new Promise((resolveDownload) => {
-          try {
-            const ext = imageUrl.match(/\.(png|jpg|jpeg|gif|webp|svg)/i)?.[1] || 'png';
-            const filename = `GH-${issueNumber}-${imageIndex}.${ext}`;
-            const filePath = join(imagesDir, filename);
-
-            // Skip if already downloaded
-            if (existsSync(filePath)) {
-              resolveDownload(`.workflow/issues/images/${filename}`);
-              return;
-            }
-
-            const protocol = imageUrl.startsWith('https') ? https : http;
-            protocol.get(imageUrl, { timeout: 30000 }, (response: any) => {
-              // Handle redirect
-              if (response.statusCode === 301 || response.statusCode === 302) {
-                const redirectUrl = response.headers.location;
-                if (redirectUrl) {
-                  downloadImage(redirectUrl, issueNumber, imageIndex).then(resolveDownload);
-                  return;
-                }
-              }
-              if (response.statusCode !== 200) {
-                resolveDownload(null);
-                return;
-              }
-
-              const chunks: Buffer[] = [];
-              response.on('data', (chunk: Buffer) => chunks.push(chunk));
-              response.on('end', () => {
-                try {
-                  writeFileSync(filePath, Buffer.concat(chunks));
-                  resolveDownload(`.workflow/issues/images/${filename}`);
-                } catch {
-                  resolveDownload(null);
-                }
-              });
-              response.on('error', () => resolveDownload(null));
-            }).on('error', () => resolveDownload(null));
-          } catch {
-            resolveDownload(null);
-          }
-        });
-      };
-
-      // Process issues
-      for (const ghIssue of ghIssues) {
-        const issueId = `GH-${ghIssue.number}`;
-        const existingIssue = existingIssues.find((i: any) => i.id === issueId);
-
-        let context = ghIssue.body || ghIssue.title;
-
-        // Extract and download images if enabled
-        if (downloadImages && ghIssue.body) {
-          // Find all image URLs in the body
-          const imgPattern = /!\[[^\]]*\]\((https?:\/\/[^)]+)\)|<img[^>]+src=["'](https?:\/\/[^"']+)["']/gi;
-          const imageUrls: string[] = [];
-          let match;
-          while ((match = imgPattern.exec(ghIssue.body)) !== null) {
-            imageUrls.push(match[1] || match[2]);
-          }
-
-          // Download images and build reference list
-          if (imageUrls.length > 0) {
-            const downloadedImages: string[] = [];
-            for (let i = 0; i < imageUrls.length; i++) {
-              const localPath = await downloadImage(imageUrls[i], ghIssue.number, i + 1);
-              if (localPath) {
-                downloadedImages.push(localPath);
-                imagesDownloaded++;
-              }
-            }
-
-            // Append image references to context
-            if (downloadedImages.length > 0) {
-              context += '\n\n---\n**Downloaded Images:**\n';
-              downloadedImages.forEach((path, idx) => {
-                context += `- Image ${idx + 1}: \`${path}\`\n`;
-              });
-            }
-          }
-        }
-
-        // Prepare issue data (truncate context to 2000 chars max)
-        const issueData = {
-          id: issueId,
-          title: ghIssue.title,
-          status: ghIssue.state === 'OPEN' ? 'registered' : 'completed',
-          priority: 3,
-          context: context.substring(0, 2000),
-          source: 'github',
-          source_url: ghIssue.url,
-          tags: ghIssue.labels?.map((l: any) => l.name) || [],
-          created_at: new Date().toISOString(),
-          updated_at: new Date().toISOString()
-        };
-
-        if (existingIssue) {
-          // Update if changed
-          const newStatus = ghIssue.state === 'OPEN' ? 'registered' : 'completed';
-          if (existingIssue.status !== newStatus || existingIssue.title !== ghIssue.title) {
-            existingIssue.title = ghIssue.title;
-            existingIssue.status = newStatus;
-            existingIssue.context = issueData.context;
-            existingIssue.updated_at = new Date().toISOString();
-            updated++;
-          } else {
-            skipped++;
-          }
-        } else {
-          existingIssues.push(issueData);
-          imported++;
-        }
-      }
-
-      // Save all issues
-      writeIssuesJsonl(issuesDir, existingIssues);
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ imported, updated, skipped, images_downloaded: imagesDownloaded, total: ghIssues.length }));
-    } catch (err: any) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message || 'Failed to pull issues from GitHub' }));
-    }
-    return true;
-  }
-
-  // GET /api/issues/:id - Get issue detail
-  const detailMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
-  if (detailMatch && req.method === 'GET') {
-    const issueId = decodeURIComponent(detailMatch[1]);
-    if (issueId === 'queue') return false;
-
-    const detail = getIssueDetail(issuesDir, issueId);
-    if (!detail) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Issue not found' }));
-      return true;
-    }
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(detail));
-    return true;
-  }
-
-  // PATCH /api/issues/:id - Update issue (with binding support)
-  const updateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
-  if (updateMatch && req.method === 'PATCH') {
-    const issueId = decodeURIComponent(updateMatch[1]);
-    if (issueId === 'queue') return false;
-
-    handlePostRequest(req, res, async (body: any) => {
-      const issues = readIssuesJsonl(issuesDir);
-      const issueIndex = issues.findIndex(i => i.id === issueId);
-      if (issueIndex === -1) return { error: 'Issue not found' };
-
-      const updates: string[] = [];
-
-      // Handle binding if bound_solution_id provided
-      if (body.bound_solution_id !== undefined) {
-        if (body.bound_solution_id) {
-          const bindResult = bindSolutionToIssue(issuesDir, issueId, body.bound_solution_id, issues, issueIndex);
-          if (bindResult.error) return bindResult;
-          updates.push('bound_solution_id');
-        } else {
-          // Unbind
-          const solutions = readSolutionsJsonl(issuesDir, issueId);
-          solutions.forEach(s => { s.is_bound = false; });
-          writeSolutionsJsonl(issuesDir, issueId, solutions);
-          issues[issueIndex].bound_solution_id = null;
-          updates.push('bound_solution_id (unbound)');
-        }
-      }
-
-      // Update other fields
-      for (const field of ['title', 'context', 'status', 'priority', 'tags']) {
-        if (body[field] !== undefined) {
-          issues[issueIndex][field] = body[field];
-          updates.push(field);
-        }
-      }
-
-      issues[issueIndex].updated_at = new Date().toISOString();
-      writeIssuesJsonl(issuesDir, issues);
-      return { success: true, issueId, updated: updates };
-    });
-    return true;
-  }
-
-  // DELETE /api/issues/:id
-  const deleteMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
-  if (deleteMatch && req.method === 'DELETE') {
-    const issueId = decodeURIComponent(deleteMatch[1]);
-
-    const issues = readIssuesJsonl(issuesDir);
-    const filtered = issues.filter(i => i.id !== issueId);
-    if (filtered.length === issues.length) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Issue not found' }));
-      return true;
-    }
-
-    writeIssuesJsonl(issuesDir, filtered);
-
-    // Clean up solutions file
-    const solPath = join(issuesDir, 'solutions', `${issueId}.jsonl`);
-    if (existsSync(solPath)) {
-      try { unlinkSync(solPath); } catch {}
-    }
-
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true, issueId }));
-    return true;
-  }
-
-  // POST /api/issues/:id/archive - Archive issue (move to history)
-  const archiveMatch = pathname.match(/^\/api\/issues\/([^/]+)\/archive$/);
-  if (archiveMatch && req.method === 'POST') {
-    const issueId = decodeURIComponent(archiveMatch[1]);
-
-    const issues = readIssuesJsonl(issuesDir);
-    const issueIndex = issues.findIndex(i => i.id === issueId);
-
-    if (issueIndex === -1) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Issue not found' }));
-      return true;
-    }
-
-    // Get the issue and add archive metadata
-    const issue = issues[issueIndex];
-    issue.archived_at = new Date().toISOString();
-    issue.status = 'completed';
-
-    // Move to history
-    const history = readIssueHistoryJsonl(issuesDir);
-    history.push(issue);
-    writeIssueHistoryJsonl(issuesDir, history);
-
-    // Remove from active issues
-    issues.splice(issueIndex, 1);
-    writeIssuesJsonl(issuesDir, issues);
-
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true, issueId, archivedAt: issue.archived_at }));
-    return true;
-  }
-
-  // POST /api/issues/:id/solutions - Add solution
-  const addSolMatch = pathname.match(/^\/api\/issues\/([^/]+)\/solutions$/);
-  if (addSolMatch && req.method === 'POST') {
-    const issueId = decodeURIComponent(addSolMatch[1]);
-
-    handlePostRequest(req, res, async (body: any) => {
-      if (!body.id || !body.tasks) return { error: 'id and tasks required' };
-
-      const solutions = readSolutionsJsonl(issuesDir, issueId);
-      if (solutions.find(s => s.id === body.id)) return { error: `Solution ${body.id} exists` };
-
-      const newSolution = {
-        id: body.id,
-        description: body.description || '',
-        tasks: body.tasks,
-        exploration_context: body.exploration_context || {},
-        analysis: body.analysis || {},
-        score: body.score || 0,
-        is_bound: false,
-        created_at: new Date().toISOString()
-      };
-
-      solutions.push(newSolution);
-      writeSolutionsJsonl(issuesDir, issueId, solutions);
-
-      // Update issue solution_count
-      const issues = readIssuesJsonl(issuesDir);
-      const idx = issues.findIndex(i => i.id === issueId);
-      if (idx !== -1) {
-        issues[idx].solution_count = solutions.length;
-        issues[idx].updated_at = new Date().toISOString();
-        writeIssuesJsonl(issuesDir, issues);
-      }
-
-      return { success: true, solution: newSolution };
-    });
-    return true;
-  }
-
-  // PATCH /api/issues/:id/tasks/:taskId - Update task
-  const taskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/tasks\/([^/]+)$/);
-  if (taskMatch && req.method === 'PATCH') {
-    const issueId = decodeURIComponent(taskMatch[1]);
-    const taskId = decodeURIComponent(taskMatch[2]);
-
-    handlePostRequest(req, res, async (body: any) => {
-      const issues = readIssuesJsonl(issuesDir);
-      const issue = issues.find(i => i.id === issueId);
-      if (!issue?.bound_solution_id) return { error: 'Issue or bound solution not found' };
-
-      const solutions = readSolutionsJsonl(issuesDir, issueId);
-      const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
-      if (solIdx === -1) return { error: 'Bound solution not found' };
-
-      const taskIdx = solutions[solIdx].tasks?.findIndex((t: any) => t.id === taskId);
-      if (taskIdx === -1 || taskIdx === undefined) return { error: 'Task not found' };
-
-      const updates: string[] = [];
-      for (const field of ['status', 'priority', 'result', 'error']) {
-        if (body[field] !== undefined) {
-          solutions[solIdx].tasks[taskIdx][field] = body[field];
-          updates.push(field);
-        }
-      }
-      solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
-      writeSolutionsJsonl(issuesDir, issueId, solutions);
-
-      return { success: true, issueId, taskId, updated: updates };
-    });
-    return true;
-  }
-
-  // Legacy: PUT /api/issues/:id/task/:taskId (backward compat)
-  const legacyTaskMatch = pathname.match(/^\/api\/issues\/([^/]+)\/task\/([^/]+)$/);
-  if (legacyTaskMatch && req.method === 'PUT') {
-    const issueId = decodeURIComponent(legacyTaskMatch[1]);
-    const taskId = decodeURIComponent(legacyTaskMatch[2]);
-
-    handlePostRequest(req, res, async (body: any) => {
-      const issues = readIssuesJsonl(issuesDir);
-      const issue = issues.find(i => i.id === issueId);
-      if (!issue?.bound_solution_id) return { error: 'Issue or bound solution not found' };
-
-      const solutions = readSolutionsJsonl(issuesDir, issueId);
-      const solIdx = solutions.findIndex(s => s.id === issue.bound_solution_id);
-      if (solIdx === -1) return { error: 'Bound solution not found' };
-
-      const taskIdx = solutions[solIdx].tasks?.findIndex((t: any) => t.id === taskId);
-      if (taskIdx === -1 || taskIdx === undefined) return { error: 'Task not found' };
-
-      const updates: string[] = [];
-      if (body.status !== undefined) { solutions[solIdx].tasks[taskIdx].status = body.status; updates.push('status'); }
-      if (body.priority !== undefined) { solutions[solIdx].tasks[taskIdx].priority = body.priority; updates.push('priority'); }
-      solutions[solIdx].tasks[taskIdx].updated_at = new Date().toISOString();
-      writeSolutionsJsonl(issuesDir, issueId, solutions);
-
-      return { success: true, issueId, taskId, updated: updates };
-    });
-    return true;
-  }
-
-  // Legacy: PUT /api/issues/:id/bind/:solutionId (backward compat)
-  const legacyBindMatch = pathname.match(/^\/api\/issues\/([^/]+)\/bind\/([^/]+)$/);
-  if (legacyBindMatch && req.method === 'PUT') {
-    const issueId = decodeURIComponent(legacyBindMatch[1]);
-    const solutionId = decodeURIComponent(legacyBindMatch[2]);
-
-    const issues = readIssuesJsonl(issuesDir);
-    const issueIndex = issues.findIndex(i => i.id === issueId);
-    if (issueIndex === -1) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Issue not found' }));
-      return true;
-    }
-
-    const result = bindSolutionToIssue(issuesDir, issueId, solutionId, issues, issueIndex);
-    if (result.error) {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result));
-      return true;
-    }
-
-    issues[issueIndex].updated_at = new Date().toISOString();
-    writeIssuesJsonl(issuesDir, issues);
-
-    res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ success: true, issueId, solutionId }));
-    return true;
-  }
-
-  // Legacy: PUT /api/issues/:id (backward compat for PATCH)
-  const legacyUpdateMatch = pathname.match(/^\/api\/issues\/([^/]+)$/);
-  if (legacyUpdateMatch && req.method === 'PUT') {
-    const issueId = decodeURIComponent(legacyUpdateMatch[1]);
-    if (issueId === 'queue') return false;
-
-    handlePostRequest(req, res, async (body: any) => {
-      const issues = readIssuesJsonl(issuesDir);
-      const issueIndex = issues.findIndex(i => i.id === issueId);
-      if (issueIndex === -1) return { error: 'Issue not found' };
-
-      const updates: string[] = [];
-      for (const field of ['title', 'context', 'status', 'priority', 'bound_solution_id', 'tags']) {
-        if (body[field] !== undefined) {
-          issues[issueIndex][field] = body[field];
-          updates.push(field);
-        }
-      }
-
-      issues[issueIndex].updated_at = new Date().toISOString();
-      writeIssuesJsonl(issuesDir, issues);
-      return { success: true, issueId, updated: updates };
-    });
-    return true;
-  }
-
-  return false;
-}