claude-code-workflow 6.3.7 → 6.3.9

package/ccw/src/commands/issue.ts

@@ -5,7 +5,7 @@
  */
 
 import chalk from 'chalk';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { join, resolve } from 'path';
 
 // Handle EPIPE errors gracefully
@@ -29,6 +29,18 @@ interface Issue {
   source?: string;
   source_url?: string;
   labels?: string[];
+  // Agent workflow fields
+  affected_components?: string[];
+  lifecycle_requirements?: {
+    test_strategy?: 'unit' | 'integration' | 'e2e' | 'auto';
+    regression_scope?: 'full' | 'related' | 'affected';
+    commit_strategy?: 'per-task' | 'atomic' | 'squash';
+  };
+  problem_statement?: string;
+  expected_behavior?: string;
+  actual_behavior?: string;
+  reproduction_steps?: string[];
+  // Timestamps
   created_at: string;
   updated_at: string;
   planned_at?: string;
@@ -100,31 +112,48 @@ interface Solution {
 }
 
 interface QueueItem {
-  queue_id: string;
+  item_id: string;               // Task item ID in queue: T-1, T-2, ... (formerly queue_id)
   issue_id: string;
   solution_id: string;
   task_id: string;
+  title?: string;
   status: 'pending' | 'ready' | 'executing' | 'completed' | 'failed' | 'blocked';
   execution_order: number;
   execution_group: string;
   depends_on: string[];
   semantic_priority: number;
   assigned_executor: 'codex' | 'gemini' | 'agent';
-  queued_at: string;
   started_at?: string;
   completed_at?: string;
   result?: Record<string, any>;
   failure_reason?: string;
 }
 
+interface QueueConflict {
+  type: 'file_conflict' | 'dependency_conflict' | 'resource_conflict';
+  tasks: string[];               // Item IDs involved in conflict
+  file?: string;                 // Conflicting file path
+  resolution: 'sequential' | 'merge' | 'manual';
+  resolution_order?: string[];
+  rationale?: string;
+  resolved: boolean;
+}
+
+interface ExecutionGroup {
+  id: string;                    // Group ID: P1, S1, etc.
+  type: 'parallel' | 'sequential';
+  task_count: number;
+  tasks: string[];               // Item IDs in this group
+}
+
 interface Queue {
-  id: string;                    // Queue unique ID: QUE-YYYYMMDD-HHMMSS
+  id: string;                    // Queue unique ID: QUE-YYYYMMDD-HHMMSS (derived from filename)
   name?: string;                 // Optional queue name
   status: 'active' | 'completed' | 'archived' | 'failed';
   issue_ids: string[];           // Issues in this queue
-  queue: QueueItem[];
-  conflicts: any[];
-  execution_groups?: any[];
+  tasks: QueueItem[];            // Task items (formerly 'queue')
+  conflicts: QueueConflict[];
+  execution_groups?: ExecutionGroup[];
   _metadata: {
     version: string;
     total_tasks: number;
@@ -132,13 +161,13 @@ interface Queue {
     executing_count: number;
     completed_count: number;
     failed_count: number;
-    created_at: string;
     updated_at: string;
   };
 }
 
 interface QueueIndex {
   active_queue_id: string | null;
+  active_item_id: string | null;
   queues: {
     id: string;
     status: string;
@@ -162,6 +191,7 @@ interface IssueOptions {
   json?: boolean;
   force?: boolean;
   fail?: boolean;
+  ids?: boolean;        // List only IDs (one per line)
 }
 
 const ISSUES_DIR = '.workflow/issues';
@@ -278,7 +308,7 @@ function ensureQueuesDir(): void {
 function readQueueIndex(): QueueIndex {
   const path = join(getQueuesDir(), 'index.json');
   if (!existsSync(path)) {
-    return { active_queue_id: null, queues: [] };
+    return { active_queue_id: null, active_item_id: null, queues: [] };
   }
   return JSON.parse(readFileSync(path, 'utf-8'));
 }
@@ -319,16 +349,15 @@ function createEmptyQueue(): Queue {
     id: generateQueueFileId(),
     status: 'active',
     issue_ids: [],
-    queue: [],
+    tasks: [],
     conflicts: [],
     _metadata: {
-      version: '2.0',
+      version: '2.1',
       total_tasks: 0,
       pending_count: 0,
       executing_count: 0,
       completed_count: 0,
       failed_count: 0,
-      created_at: new Date().toISOString(),
       updated_at: new Date().toISOString()
     }
   };
@@ -338,11 +367,11 @@ function writeQueue(queue: Queue): void {
   ensureQueuesDir();
 
   // Update metadata counts
-  queue._metadata.total_tasks = queue.queue.length;
-  queue._metadata.pending_count = queue.queue.filter(q => q.status === 'pending').length;
-  queue._metadata.executing_count = queue.queue.filter(q => q.status === 'executing').length;
-  queue._metadata.completed_count = queue.queue.filter(q => q.status === 'completed').length;
-  queue._metadata.failed_count = queue.queue.filter(q => q.status === 'failed').length;
+  queue._metadata.total_tasks = queue.tasks.length;
+  queue._metadata.pending_count = queue.tasks.filter(q => q.status === 'pending').length;
+  queue._metadata.executing_count = queue.tasks.filter(q => q.status === 'executing').length;
+  queue._metadata.completed_count = queue.tasks.filter(q => q.status === 'completed').length;
+  queue._metadata.failed_count = queue.tasks.filter(q => q.status === 'failed').length;
   queue._metadata.updated_at = new Date().toISOString();
 
   // Write queue file
@@ -359,7 +388,7 @@ function writeQueue(queue: Queue): void {
     issue_ids: queue.issue_ids,
     total_tasks: queue._metadata.total_tasks,
     completed_tasks: queue._metadata.completed_count,
-    created_at: queue._metadata.created_at,
+    created_at: queue.id.replace('QUE-', '').replace(/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/, '$1-$2-$3T$4:$5:$6Z'), // Derive from ID
     completed_at: queue.status === 'completed' ? new Date().toISOString() : undefined
   };
 
@@ -377,11 +406,11 @@ function writeQueue(queue: Queue): void {
 }
 
 function generateQueueItemId(queue: Queue): string {
-  const maxNum = queue.queue.reduce((max, q) => {
-    const match = q.queue_id.match(/^Q-(\d+)$/);
+  const maxNum = queue.tasks.reduce((max, q) => {
+    const match = q.item_id.match(/^T-(\d+)$/);
     return match ? Math.max(max, parseInt(match[1])) : max;
   }, 0);
-  return `Q-${String(maxNum + 1).padStart(3, '0')}`;
+  return `T-${maxNum + 1}`;
 }
 
 // ============ Commands ============
@@ -429,7 +458,19 @@ async function initAction(issueId: string | undefined, options: IssueOptions): P
 async function listAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
   if (!issueId) {
     // List all issues
-    const issues = readIssues();
+    let issues = readIssues();
+
+    // Filter by status if specified
+    if (options.status) {
+      const statuses = options.status.split(',').map(s => s.trim());
+      issues = issues.filter(i => statuses.includes(i.status));
+    }
+
+    // IDs only mode (one per line, for scripting)
+    if (options.ids) {
+      issues.forEach(i => console.log(i.id));
+      return;
+    }
 
     if (options.json) {
       console.log(JSON.stringify(issues, null, 2));
@@ -807,7 +848,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
   // Archive current queue
   if (subAction === 'archive') {
     const queue = readActiveQueue();
-    if (!queue.id || queue.queue.length === 0) {
+    if (!queue.id || queue.tasks.length === 0) {
       console.log(chalk.yellow('No active queue to archive'));
       return;
     }
@@ -823,6 +864,31 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
     return;
   }
 
+  // Delete queue from history
+  if ((subAction === 'clear' || subAction === 'delete') && issueId) {
+    const queueId = issueId; // issueId is actually queue ID here
+    const queuePath = join(getQueuesDir(), `${queueId}.json`);
+
+    if (!existsSync(queuePath)) {
+      console.error(chalk.red(`Queue "${queueId}" not found`));
+      process.exit(1);
+    }
+
+    // Remove from index
+    const index = readQueueIndex();
+    index.queues = index.queues.filter(q => q.id !== queueId);
+    if (index.active_queue_id === queueId) {
+      index.active_queue_id = null;
+    }
+    writeQueueIndex(index);
+
+    // Delete queue file
+    unlinkSync(queuePath);
+
+    console.log(chalk.green(`✓ Deleted queue ${queueId}`));
+    return;
+  }
+
   // Add issue tasks to queue
   if (subAction === 'add' && issueId) {
     const issue = findIssue(issueId);
@@ -840,7 +906,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
     // Get or create active queue (create new if current is completed/archived)
     let queue = readActiveQueue();
-    const isNewQueue = queue.queue.length === 0 || queue.status !== 'active';
+    const isNewQueue = queue.tasks.length === 0 || queue.status !== 'active';
 
     if (queue.status !== 'active') {
       // Create new queue if current is not active
@@ -854,24 +920,23 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
     let added = 0;
     for (const task of solution.tasks) {
-      const exists = queue.queue.some(q => q.issue_id === issueId && q.task_id === task.id);
+      const exists = queue.tasks.some(q => q.issue_id === issueId && q.task_id === task.id);
       if (exists) continue;
 
-      queue.queue.push({
-        queue_id: generateQueueItemId(queue),
+      queue.tasks.push({
+        item_id: generateQueueItemId(queue),
         issue_id: issueId,
         solution_id: solution.id,
         task_id: task.id,
         status: 'pending',
-        execution_order: queue.queue.length + 1,
+        execution_order: queue.tasks.length + 1,
         execution_group: 'P1',
         depends_on: task.depends_on.map(dep => {
-          const depItem = queue.queue.find(q => q.task_id === dep && q.issue_id === issueId);
-          return depItem?.queue_id || dep;
+          const depItem = queue.tasks.find(q => q.task_id === dep && q.issue_id === issueId);
+          return depItem?.item_id || dep;
         }),
         semantic_priority: 0.5,
-        assigned_executor: task.executor === 'auto' ? 'codex' : task.executor as any,
-        queued_at: new Date().toISOString()
+        assigned_executor: task.executor === 'auto' ? 'codex' : task.executor as any
       });
       added++;
     }
@@ -896,7 +961,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
   console.log(chalk.bold.cyan('\nActive Queue\n'));
 
-  if (!queue.id || queue.queue.length === 0) {
+  if (!queue.id || queue.tasks.length === 0) {
     console.log(chalk.yellow('No active queue'));
     console.log(chalk.gray('Create one: ccw issue queue add <issue-id>'));
     console.log(chalk.gray('Or list history: ccw issue queue list'));
@@ -911,7 +976,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
   console.log(chalk.gray('QueueID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
   console.log(chalk.gray('-'.repeat(60)));
 
-  for (const item of queue.queue) {
+  for (const item of queue.tasks) {
     const statusColor = {
       'pending': chalk.gray,
       'ready': chalk.cyan,
@@ -922,7 +987,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
     }[item.status] || chalk.white;
 
     console.log(
-      item.queue_id.padEnd(10) +
+      item.item_id.padEnd(10) +
       item.issue_id.substring(0, 13).padEnd(15) +
       item.task_id.padEnd(8) +
       statusColor(item.status.padEnd(12)) +
@@ -938,13 +1003,13 @@ async function nextAction(options: IssueOptions): Promise<void> {
   const queue = readActiveQueue();
 
   // Priority 1: Resume executing tasks (interrupted/crashed)
-  const executingTasks = queue.queue.filter(item => item.status === 'executing');
+  const executingTasks = queue.tasks.filter(item => item.status === 'executing');
 
   // Priority 2: Find pending tasks with satisfied dependencies
-  const pendingTasks = queue.queue.filter(item => {
+  const pendingTasks = queue.tasks.filter(item => {
     if (item.status !== 'pending') return false;
     return item.depends_on.every(depId => {
-      const dep = queue.queue.find(q => q.queue_id === depId);
+      const dep = queue.tasks.find(q => q.item_id === depId);
       return !dep || dep.status === 'completed';
     });
   });
@@ -977,25 +1042,25 @@ async function nextAction(options: IssueOptions): Promise<void> {
 
   // Only update status if not already executing (new task)
   if (!isResume) {
-    const idx = queue.queue.findIndex(q => q.queue_id === nextItem.queue_id);
-    queue.queue[idx].status = 'executing';
-    queue.queue[idx].started_at = new Date().toISOString();
+    const idx = queue.tasks.findIndex(q => q.item_id === nextItem.item_id);
+    queue.tasks[idx].status = 'executing';
+    queue.tasks[idx].started_at = new Date().toISOString();
     writeQueue(queue);
     updateIssue(nextItem.issue_id, { status: 'executing' });
   }
 
   // Calculate queue stats for context
   const stats = {
-    total: queue.queue.length,
-    completed: queue.queue.filter(q => q.status === 'completed').length,
-    failed: queue.queue.filter(q => q.status === 'failed').length,
+    total: queue.tasks.length,
+    completed: queue.tasks.filter(q => q.status === 'completed').length,
+    failed: queue.tasks.filter(q => q.status === 'failed').length,
     executing: executingTasks.length,
     pending: pendingTasks.length
   };
   const remaining = stats.pending + stats.executing;
 
   console.log(JSON.stringify({
-    queue_id: nextItem.queue_id,
+    item_id: nextItem.item_id,
     issue_id: nextItem.issue_id,
     solution_id: nextItem.solution_id,
     task: taskDef,
@@ -1026,7 +1091,7 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
   }
 
   const queue = readActiveQueue();
-  const idx = queue.queue.findIndex(q => q.queue_id === queueId);
+  const idx = queue.tasks.findIndex(q => q.item_id === queueId);
 
   if (idx === -1) {
     console.error(chalk.red(`Queue item "${queueId}" not found`));
@@ -1034,22 +1099,22 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
   }
 
   const isFail = options.fail;
-  queue.queue[idx].status = isFail ? 'failed' : 'completed';
-  queue.queue[idx].completed_at = new Date().toISOString();
+  queue.tasks[idx].status = isFail ? 'failed' : 'completed';
+  queue.tasks[idx].completed_at = new Date().toISOString();
 
   if (isFail) {
-    queue.queue[idx].failure_reason = options.reason || 'Unknown failure';
+    queue.tasks[idx].failure_reason = options.reason || 'Unknown failure';
   } else if (options.result) {
     try {
-      queue.queue[idx].result = JSON.parse(options.result);
+      queue.tasks[idx].result = JSON.parse(options.result);
     } catch {
       console.warn(chalk.yellow('Warning: Could not parse result JSON'));
     }
   }
 
   // Check if all issue tasks are complete
-  const issueId = queue.queue[idx].issue_id;
-  const issueTasks = queue.queue.filter(q => q.issue_id === issueId);
+  const issueId = queue.tasks[idx].issue_id;
+  const issueTasks = queue.tasks.filter(q => q.issue_id === issueId);
   const allIssueComplete = issueTasks.every(q => q.status === 'completed');
   const anyIssueFailed = issueTasks.some(q => q.status === 'failed');
 
@@ -1065,13 +1130,13 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
   }
 
   // Check if entire queue is complete
-  const allQueueComplete = queue.queue.every(q => q.status === 'completed');
-  const anyQueueFailed = queue.queue.some(q => q.status === 'failed');
+  const allQueueComplete = queue.tasks.every(q => q.status === 'completed');
+  const anyQueueFailed = queue.tasks.some(q => q.status === 'failed');
 
   if (allQueueComplete) {
     queue.status = 'completed';
     console.log(chalk.green(`\n✓ Queue ${queue.id} completed (all tasks done)`));
-  } else if (anyQueueFailed && queue.queue.every(q => q.status === 'completed' || q.status === 'failed')) {
+  } else if (anyQueueFailed && queue.tasks.every(q => q.status === 'completed' || q.status === 'failed')) {
     queue.status = 'failed';
     console.log(chalk.yellow(`\n⚠ Queue ${queue.id} has failed tasks`));
   }
@@ -1080,24 +1145,20 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
 }
 
 /**
- * retry - Retry failed tasks, or reset stuck executing tasks (--force)
+ * retry - Reset failed tasks to pending for re-execution
  */
 async function retryAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
   const queue = readActiveQueue();
 
-  if (!queue.id || queue.queue.length === 0) {
+  if (!queue.id || queue.tasks.length === 0) {
     console.log(chalk.yellow('No active queue'));
     return;
   }
 
   let updated = 0;
 
-  // Check for stuck executing tasks (started > 30 min ago with no completion)
-  const stuckThreshold = 30 * 60 * 1000; // 30 minutes
-  const now = Date.now();
-
-  for (const item of queue.queue) {
-    // Retry failed tasks
+  for (const item of queue.tasks) {
+    // Retry failed tasks only
     if (item.status === 'failed') {
       if (!issueId || item.issue_id === issueId) {
         item.status = 'pending';
@@ -1107,23 +1168,11 @@ async function retryAction(issueId: string | undefined, options: IssueOptions):
         updated++;
       }
     }
-    // Reset stuck executing tasks (optional: use --force or --reset-stuck)
-    else if (item.status === 'executing' && options.force) {
-      const startedAt = item.started_at ? new Date(item.started_at).getTime() : 0;
-      if (now - startedAt > stuckThreshold) {
-        if (!issueId || item.issue_id === issueId) {
-          console.log(chalk.yellow(`Resetting stuck task: ${item.queue_id} (started ${Math.round((now - startedAt) / 60000)} min ago)`));
-          item.status = 'pending';
-          item.started_at = undefined;
-          updated++;
-        }
-      }
-    }
   }
 
   if (updated === 0) {
-    console.log(chalk.yellow('No failed/stuck tasks to retry'));
-    console.log(chalk.gray('Use --force to reset stuck executing tasks (>30 min)'));
+    console.log(chalk.yellow('No failed tasks to retry'));
+    console.log(chalk.gray('Note: Interrupted (executing) tasks are auto-resumed by "ccw issue next"'));
     return;
   }
 
@@ -1204,7 +1253,8 @@ export async function issueCommand(
       console.log(chalk.gray('  queue add <issue-id>               Add issue to active queue (or create new)'));
       console.log(chalk.gray('  queue switch <queue-id>            Switch active queue'));
       console.log(chalk.gray('  queue archive                      Archive current queue'));
-      console.log(chalk.gray('  retry [issue-id] [--force]         Retry failed/stuck tasks'));
+      console.log(chalk.gray('  queue delete <queue-id>            Delete queue from history'));
+      console.log(chalk.gray('  retry [issue-id]                   Retry failed tasks'));
       console.log();
       console.log(chalk.bold('Execution Endpoints:'));
       console.log(chalk.gray('  next                               Get next ready task (JSON)'));
@@ -1213,6 +1263,8 @@ export async function issueCommand(
       console.log();
       console.log(chalk.bold('Options:'));
       console.log(chalk.gray('  --title <title>                    Issue/task title'));
+      console.log(chalk.gray('  --status <status>                  Filter by status (comma-separated)'));
+      console.log(chalk.gray('  --ids                              List only IDs (one per line)'));
       console.log(chalk.gray('  --solution <path>                  Solution JSON file'));
       console.log(chalk.gray('  --result <json>                    Execution result'));
       console.log(chalk.gray('  --reason <text>                    Failure reason'));

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

@@ -5,7 +5,9 @@
  * Storage Structure:
  * .workflow/issues/
  * ├── issues.jsonl              # All issues (one per line)
- * ├── queue.json                # Execution queue
+ * ├── 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)
  *     └── ...
@@ -102,12 +104,12 @@ function readQueue(issuesDir: string) {
     }
   }
 
-  return { queue: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
+  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 });
-  queue._metadata = { ...queue._metadata, updated_at: new Date().toISOString(), total_tasks: queue.queue?.length || 0 };
+  queue._metadata = { ...queue._metadata, updated_at: new Date().toISOString(), total_tasks: queue.tasks?.length || 0 };
 
   // Check if using new multi-queue structure
   const queuesDir = join(issuesDir, 'queues');
@@ -123,8 +125,8 @@ function writeQueue(issuesDir: string, queue: any) {
       const index = JSON.parse(readFileSync(indexPath, 'utf8'));
       const queueEntry = index.queues?.find((q: any) => q.id === queue.id);
       if (queueEntry) {
-        queueEntry.total_tasks = queue.queue?.length || 0;
-        queueEntry.completed_tasks = queue.queue?.filter((i: any) => i.status === 'completed').length || 0;
+        queueEntry.total_tasks = queue.tasks?.length || 0;
+        queueEntry.completed_tasks = queue.tasks?.filter((i: any) => i.status === 'completed').length || 0;
         writeFileSync(indexPath, JSON.stringify(index, null, 2));
       }
     } catch {
@@ -151,15 +153,29 @@ function getIssueDetail(issuesDir: string, issueId: string) {
 }
 
 function enrichIssues(issues: any[], issuesDir: string) {
-  return issues.map(issue => ({
-    ...issue,
-    solution_count: readSolutionsJsonl(issuesDir, issue.id).length
-  }));
+  return issues.map(issue => {
+    const solutions = readSolutionsJsonl(issuesDir, issue.id);
+    let taskCount = 0;
+
+    // Get task count from bound solution
+    if (issue.bound_solution_id) {
+      const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
+      if (boundSol?.tasks) {
+        taskCount = boundSol.tasks.length;
+      }
+    }
+
+    return {
+      ...issue,
+      solution_count: solutions.length,
+      task_count: taskCount
+    };
+  });
 }
 
 function groupQueueByExecutionGroup(queue: any) {
   const groups: { [key: string]: any[] } = {};
-  for (const item of queue.queue || []) {
+  for (const item of queue.tasks || []) {
     const groupId = item.execution_group || 'ungrouped';
     if (!groups[groupId]) groups[groupId] = [];
     groups[groupId].push(item);
@@ -171,7 +187,7 @@ function groupQueueByExecutionGroup(queue: any) {
     id,
     type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
     task_count: items.length,
-    tasks: items.map(i => i.queue_id)
+    tasks: items.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;
@@ -220,6 +236,82 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
     return true;
   }
 
+  // GET /api/queue/history - Get queue history (all queues from index)
+  if (pathname === '/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 }));
+      return true;
+    }
+
+    try {
+      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
+      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 }));
+    }
+    return true;
+  }
+
+  // GET /api/queue/:id - Get specific queue by ID
+  const queueDetailMatch = pathname.match(/^\/api\/queue\/([^/]+)$/);
+  if (queueDetailMatch && req.method === 'GET' && queueDetailMatch[1] !== 'history' && queueDetailMatch[1] !== 'reorder') {
+    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/switch - Switch active queue
+  if (pathname === '/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, queues: [] };
+
+        index.active_queue_id = queueId;
+        writeFileSync(indexPath, JSON.stringify(index, null, 2));
+
+        return { success: true, active_queue_id: queueId };
+      } catch (err) {
+        return { error: 'Failed to switch queue' };
+      }
+    });
+    return true;
+  }
+
   // POST /api/queue/reorder - Reorder queue items
   if (pathname === '/api/queue/reorder' && req.method === 'POST') {
     handlePostRequest(req, res, async (body: any) => {
@@ -229,20 +321,20 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       }
 
       const queue = readQueue(issuesDir);
-      const groupItems = queue.queue.filter((item: any) => item.execution_group === groupId);
-      const otherItems = queue.queue.filter((item: any) => item.execution_group !== groupId);
+      const groupItems = queue.tasks.filter((item: any) => item.execution_group === groupId);
+      const otherItems = queue.tasks.filter((item: any) => item.execution_group !== groupId);
 
       if (groupItems.length === 0) return { error: `No items in group ${groupId}` };
 
-      const groupQueueIds = new Set(groupItems.map((i: any) => i.queue_id));
-      if (groupQueueIds.size !== new Set(newOrder).size) {
+      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 (!groupQueueIds.has(id)) return { error: `Invalid queue_id: ${id}` };
+        if (!groupItemIds.has(id)) return { error: `Invalid item_id: ${id}` };
       }
 
-      const itemMap = new Map(groupItems.map((i: any) => [i.queue_id, i]));
+      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 newQueue = [...otherItems, ...reorderedItems].sort((a, b) => {
         const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
@@ -255,7 +347,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
       });
 
       newQueue.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
-      queue.queue = newQueue;
+      queue.tasks = newQueue;
       writeQueue(issuesDir, queue);
 
       return { success: true, groupId, reordered: newOrder.length };