claude-code-workflow 6.3.9 → 6.3.11

package/ccw/src/commands/issue.ts

@@ -26,20 +26,6 @@ interface Issue {
   context: string;
   bound_solution_id: string | null;
   solution_count: number;
-  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;
@@ -85,16 +71,6 @@ interface SolutionTask {
 
   depends_on: string[];
   estimated_minutes?: number;
-  executor: 'codex' | 'gemini' | 'agent' | 'auto';
-
-  // Lifecycle status tracking
-  lifecycle_status?: {
-    implemented: boolean;
-    tested: boolean;
-    regression_passed: boolean;
-    accepted: boolean;
-    committed: boolean;
-  };
   status?: string;
   priority?: number;
 }
@@ -102,6 +78,7 @@ interface SolutionTask {
 interface Solution {
   id: string;
   description?: string;
+  approach?: string;             // Solution approach description
   tasks: SolutionTask[];
   exploration_context?: Record<string, any>;
   analysis?: { risk?: string; impact?: string; complexity?: string };
@@ -112,17 +89,19 @@ interface Solution {
 }
 
 interface QueueItem {
-  item_id: string;               // Task item ID in queue: T-1, T-2, ... (formerly queue_id)
+  item_id: string;               // Item ID in queue: T-1, T-2, ... (task-level) or S-1, S-2, ... (solution-level)
   issue_id: string;
   solution_id: string;
-  task_id: string;
-  title?: string;
+  task_id?: string;              // Only for task-level queues
   status: 'pending' | 'ready' | 'executing' | 'completed' | 'failed' | 'blocked';
   execution_order: number;
   execution_group: string;
   depends_on: string[];
   semantic_priority: number;
   assigned_executor: 'codex' | 'gemini' | 'agent';
+  task_count?: number;           // For solution-level queues
+  files_touched?: string[];      // For solution-level queues
+  queued_at?: string;
   started_at?: string;
   completed_at?: string;
   result?: Record<string, any>;
@@ -131,7 +110,8 @@ interface QueueItem {
 
 interface QueueConflict {
   type: 'file_conflict' | 'dependency_conflict' | 'resource_conflict';
-  tasks: string[];               // Item IDs involved in conflict
+  tasks?: string[];              // Task IDs involved (task-level queues)
+  solutions?: string[];          // Solution IDs involved (solution-level queues)
   file?: string;                 // Conflicting file path
   resolution: 'sequential' | 'merge' | 'manual';
   resolution_order?: string[];
@@ -142,8 +122,10 @@ interface QueueConflict {
 interface ExecutionGroup {
   id: string;                    // Group ID: P1, S1, etc.
   type: 'parallel' | 'sequential';
-  task_count: number;
-  tasks: string[];               // Item IDs in this group
+  task_count?: number;           // For task-level queues
+  solution_count?: number;       // For solution-level queues
+  tasks?: string[];              // Task IDs in this group (task-level)
+  solutions?: string[];          // Solution IDs in this group (solution-level)
 }
 
 interface Queue {
@@ -151,7 +133,8 @@ interface Queue {
   name?: string;                 // Optional queue name
   status: 'active' | 'completed' | 'archived' | 'failed';
   issue_ids: string[];           // Issues in this queue
-  tasks: QueueItem[];            // Task items (formerly 'queue')
+  tasks: QueueItem[];            // Task items (task-level queue)
+  solutions?: QueueItem[];       // Solution items (solution-level queue)
   conflicts: QueueConflict[];
   execution_groups?: ExecutionGroup[];
   _metadata: {
@@ -167,13 +150,14 @@ interface Queue {
 
 interface QueueIndex {
   active_queue_id: string | null;
-  active_item_id: string | null;
   queues: {
     id: string;
     status: string;
     issue_ids: string[];
-    total_tasks: number;
-    completed_tasks: number;
+    total_tasks?: number;          // For task-level queues
+    total_solutions?: number;      // For solution-level queues
+    completed_tasks?: number;      // For task-level queues
+    completed_solutions?: number;  // For solution-level queues
     created_at: string;
     completed_at?: string;
   }[];
@@ -308,7 +292,7 @@ function ensureQueuesDir(): void {
 function readQueueIndex(): QueueIndex {
   const path = join(getQueuesDir(), 'index.json');
   if (!existsSync(path)) {
-    return { active_queue_id: null, active_item_id: null, queues: [] };
+    return { active_queue_id: null, queues: [] };
   }
   return JSON.parse(readFileSync(path, 'utf-8'));
 }
@@ -366,12 +350,30 @@ function createEmptyQueue(): Queue {
 function writeQueue(queue: Queue): void {
   ensureQueuesDir();
 
+  // Support both old (tasks) and new (solutions) queue format
+  const items = queue.solutions || queue.tasks || [];
+  const isSolutionQueue = !!queue.solutions;
+
+  // Ensure _metadata exists (support queues with 'metadata' field from external sources)
+  if (!queue._metadata) {
+    const extMeta = (queue as any).metadata;
+    queue._metadata = {
+      version: '2.0',
+      total_tasks: extMeta?.total_tasks || items.length,
+      pending_count: items.filter(q => q.status === 'pending').length,
+      executing_count: items.filter(q => q.status === 'executing').length,
+      completed_count: items.filter(q => q.status === 'completed').length,
+      failed_count: items.filter(q => q.status === 'failed').length,
+      updated_at: new Date().toISOString()
+    };
+  }
+
   // Update metadata counts
-  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.total_tasks = items.length;
+  queue._metadata.pending_count = items.filter(q => q.status === 'pending').length;
+  queue._metadata.executing_count = items.filter(q => q.status === 'executing').length;
+  queue._metadata.completed_count = items.filter(q => q.status === 'completed').length;
+  queue._metadata.failed_count = items.filter(q => q.status === 'failed').length;
   queue._metadata.updated_at = new Date().toISOString();
 
   // Write queue file
@@ -382,16 +384,28 @@ function writeQueue(queue: Queue): void {
   const index = readQueueIndex();
   const existingIdx = index.queues.findIndex(q => q.id === queue.id);
 
-  const indexEntry = {
+  // Derive issue_ids from solutions if not present
+  const issueIds = queue.issue_ids || (isSolutionQueue
+    ? [...new Set(items.map(item => item.issue_id))]
+    : []);
+
+  const indexEntry: QueueIndex['queues'][0] = {
     id: queue.id,
     status: queue.status,
-    issue_ids: queue.issue_ids,
-    total_tasks: queue._metadata.total_tasks,
-    completed_tasks: queue._metadata.completed_count,
+    issue_ids: issueIds,
     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
   };
 
+  // Add format-specific counts
+  if (isSolutionQueue) {
+    indexEntry.total_solutions = items.length;
+    indexEntry.completed_solutions = queue._metadata.completed_count;
+  } else {
+    indexEntry.total_tasks = items.length;
+    indexEntry.completed_tasks = queue._metadata.completed_count;
+  }
+
   if (existingIdx >= 0) {
     index.queues[existingIdx] = indexEntry;
   } else {
@@ -405,12 +419,16 @@ function writeQueue(queue: Queue): void {
   writeQueueIndex(index);
 }
 
-function generateQueueItemId(queue: Queue): string {
-  const maxNum = queue.tasks.reduce((max, q) => {
-    const match = q.item_id.match(/^T-(\d+)$/);
+function generateQueueItemId(queue: Queue, level: 'solution' | 'task' = 'solution'): string {
+  const prefix = level === 'solution' ? 'S' : 'T';
+  const items = level === 'solution' ? (queue.solutions || []) : (queue.tasks || []);
+  const pattern = new RegExp(`^${prefix}-(\\d+)$`);
+
+  const maxNum = items.reduce((max, q) => {
+    const match = q.item_id.match(pattern);
     return match ? Math.max(max, parseInt(match[1])) : max;
   }, 0);
-  return `T-${maxNum + 1}`;
+  return `${prefix}-${maxNum + 1}`;
 }
 
 // ============ Commands ============
@@ -657,7 +675,6 @@ async function taskAction(issueId: string | undefined, taskId: string | undefine
 
     if (options.title) solution.tasks[taskIdx].title = options.title;
     if (options.status) solution.tasks[taskIdx].status = options.status;
-    if (options.executor) solution.tasks[taskIdx].executor = options.executor as any;
 
     writeSolutions(issueId, solutions);
     console.log(chalk.green(`✓ Task ${taskId} updated`));
@@ -690,8 +707,7 @@ async function taskAction(issueId: string | undefined, taskId: string | undefine
         scope: 'core',
         message_template: `feat(core): ${options.title}`
       },
-      depends_on: [],
-      executor: (options.executor as any) || 'auto'
+      depends_on: []
     };
 
     solution.tasks.push(newTask);
@@ -700,6 +716,69 @@ async function taskAction(issueId: string | undefined, taskId: string | undefine
   }
 }
 
+/**
+ * update - Update issue fields (status, priority, title, etc.)
+ */
+async function updateAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
+  if (!issueId) {
+    console.error(chalk.red('Issue ID is required'));
+    console.error(chalk.gray('Usage: ccw issue update <issue-id> --status <status> [--priority <n>] [--title "..."]'));
+    process.exit(1);
+  }
+
+  const issue = findIssue(issueId);
+  if (!issue) {
+    console.error(chalk.red(`Issue "${issueId}" not found`));
+    process.exit(1);
+  }
+
+  const updates: Partial<Issue> = {};
+
+  if (options.status) {
+    const validStatuses = ['registered', 'planning', 'planned', 'queued', 'executing', 'completed', 'failed', 'paused'];
+    if (!validStatuses.includes(options.status)) {
+      console.error(chalk.red(`Invalid status: ${options.status}`));
+      console.error(chalk.gray(`Valid: ${validStatuses.join(', ')}`));
+      process.exit(1);
+    }
+    updates.status = options.status as Issue['status'];
+
+    // Auto-set timestamps based on status
+    if (options.status === 'planned') updates.planned_at = new Date().toISOString();
+    if (options.status === 'queued') updates.queued_at = new Date().toISOString();
+    if (options.status === 'completed') updates.completed_at = new Date().toISOString();
+  }
+
+  if (options.priority) {
+    updates.priority = parseInt(options.priority);
+  }
+
+  if (options.title) {
+    updates.title = options.title;
+  }
+
+  if (options.description) {
+    updates.context = options.description;
+  }
+
+  if (Object.keys(updates).length === 0) {
+    console.error(chalk.yellow('No updates specified'));
+    console.error(chalk.gray('Use --status, --priority, --title, or --description'));
+    return;
+  }
+
+  updateIssue(issueId, updates);
+
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, issue_id: issueId, updates }));
+  } else {
+    console.log(chalk.green(`✓ Issue "${issueId}" updated`));
+    Object.entries(updates).forEach(([k, v]) => {
+      console.log(chalk.gray(`  ${k}: ${v}`));
+    });
+  }
+}
+
 /**
  * bind - Register and/or bind a solution
  */
@@ -845,6 +924,138 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
     return;
   }
 
+  // DAG - Return dependency graph for parallel execution planning (solution-level)
+  if (subAction === 'dag') {
+    const queue = readActiveQueue();
+
+    // Support both old (tasks) and new (solutions) queue format
+    const items = queue.solutions || queue.tasks || [];
+    if (!queue.id || items.length === 0) {
+      console.log(JSON.stringify({ error: 'No active queue', nodes: [], edges: [], groups: [] }));
+      return;
+    }
+
+    // Build DAG nodes (solution-level)
+    const completedIds = new Set(items.filter(t => t.status === 'completed').map(t => t.item_id));
+    const failedIds = new Set(items.filter(t => t.status === 'failed').map(t => t.item_id));
+
+    const nodes = items.map(item => ({
+      id: item.item_id,
+      issue_id: item.issue_id,
+      solution_id: item.solution_id,
+      status: item.status,
+      executor: item.assigned_executor,
+      priority: item.semantic_priority,
+      depends_on: item.depends_on || [],
+      task_count: item.task_count || 1,
+      files_touched: item.files_touched || [],
+      // Calculate if ready (dependencies satisfied)
+      ready: item.status === 'pending' && (item.depends_on || []).every(d => completedIds.has(d)),
+      blocked_by: (item.depends_on || []).filter(d => !completedIds.has(d) && !failedIds.has(d))
+    }));
+
+    // Build edges for visualization
+    const edges = items.flatMap(item =>
+      (item.depends_on || []).map(dep => ({ from: dep, to: item.item_id }))
+    );
+
+    // Group ready items by execution_group
+    const readyItems = nodes.filter(n => n.ready || n.status === 'executing');
+    const groups: Record<string, string[]> = {};
+
+    for (const item of items) {
+      if (readyItems.some(r => r.id === item.item_id)) {
+        const group = item.execution_group || 'P1';
+        if (!groups[group]) groups[group] = [];
+        groups[group].push(item.item_id);
+      }
+    }
+
+    // Calculate parallel batches - prefer execution_groups from queue if available
+    const parallelBatches: string[][] = [];
+    const readyItemIds = new Set(readyItems.map(t => t.id));
+
+    // Check if queue has pre-assigned execution_groups
+    if (queue.execution_groups && queue.execution_groups.length > 0) {
+      // Use agent-assigned execution groups
+      for (const group of queue.execution_groups) {
+        const groupItems = (group.solutions || group.tasks || [])
+          .filter((id: string) => readyItemIds.has(id));
+        if (groupItems.length > 0) {
+          if (group.type === 'parallel') {
+            // All items in parallel group can run together
+            parallelBatches.push(groupItems);
+          } else {
+            // Sequential group: each item is its own batch
+            for (const itemId of groupItems) {
+              parallelBatches.push([itemId]);
+            }
+          }
+        }
+      }
+    } else {
+      // Fallback: calculate parallel batches from file conflicts
+      const remainingReady = new Set(readyItemIds);
+
+      while (remainingReady.size > 0) {
+        const batch: string[] = [];
+        const batchFiles = new Set<string>();
+
+        for (const itemId of Array.from(remainingReady)) {
+          const item = items.find(t => t.item_id === itemId);
+          if (!item) continue;
+
+          // Get all files touched by this solution
+          let solutionFiles: string[] = item.files_touched || [];
+
+          // If not in queue item, fetch from solution definition
+          if (solutionFiles.length === 0) {
+            const solution = findSolution(item.issue_id, item.solution_id);
+            if (solution?.tasks) {
+              for (const task of solution.tasks) {
+                for (const mp of task.modification_points || []) {
+                  solutionFiles.push(mp.file);
+                }
+              }
+            }
+          }
+
+          const hasConflict = solutionFiles.some(f => batchFiles.has(f));
+
+          if (!hasConflict) {
+            batch.push(itemId);
+            solutionFiles.forEach(f => batchFiles.add(f));
+          }
+        }
+
+        if (batch.length === 0) {
+          // Fallback: take one at a time if all conflict
+          const first = Array.from(remainingReady)[0];
+          batch.push(first);
+        }
+
+        parallelBatches.push(batch);
+        batch.forEach(id => remainingReady.delete(id));
+      }
+    }
+
+    console.log(JSON.stringify({
+      queue_id: queue.id,
+      total: nodes.length,
+      ready_count: readyItems.length,
+      completed_count: completedIds.size,
+      nodes,
+      edges,
+      groups: Object.entries(groups).map(([id, solutions]) => ({ id, solutions })),
+      parallel_batches: parallelBatches,
+      _summary: {
+        can_parallel: parallelBatches[0]?.length || 0,
+        batches_needed: parallelBatches.length
+      }
+    }, null, 2));
+    return;
+  }
+
   // Archive current queue
   if (subAction === 'archive') {
     const queue = readActiveQueue();
@@ -889,7 +1100,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
     return;
   }
 
-  // Add issue tasks to queue
+  // Add issue solution to queue (solution-level granularity)
   if (subAction === 'add' && issueId) {
     const issue = findIssue(issueId);
     if (!issue) {
@@ -906,48 +1117,61 @@ 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.tasks.length === 0 || queue.status !== 'active';
+    const items = queue.solutions || [];
+    const isNewQueue = items.length === 0 || queue.status !== 'active';
 
     if (queue.status !== 'active') {
       // Create new queue if current is not active
       queue = createEmptyQueue();
     }
 
+    // Ensure solutions array exists
+    if (!queue.solutions) {
+      queue.solutions = [];
+    }
+
+    // Check if solution already in queue
+    const exists = queue.solutions.some(q => q.issue_id === issueId && q.solution_id === solution.id);
+    if (exists) {
+      console.log(chalk.yellow(`Solution ${solution.id} already in queue`));
+      return;
+    }
+
     // Add issue to queue's issue list
     if (!queue.issue_ids.includes(issueId)) {
       queue.issue_ids.push(issueId);
     }
 
-    let added = 0;
-    for (const task of solution.tasks) {
-      const exists = queue.tasks.some(q => q.issue_id === issueId && q.task_id === task.id);
-      if (exists) continue;
-
-      queue.tasks.push({
-        item_id: generateQueueItemId(queue),
-        issue_id: issueId,
-        solution_id: solution.id,
-        task_id: task.id,
-        status: 'pending',
-        execution_order: queue.tasks.length + 1,
-        execution_group: 'P1',
-        depends_on: task.depends_on.map(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
-      });
-      added++;
+    // Collect all files touched by this solution
+    const filesTouched = new Set<string>();
+    for (const task of solution.tasks || []) {
+      for (const mp of task.modification_points || []) {
+        filesTouched.add(mp.file);
+      }
     }
 
+    // Create solution-level queue item (S-N)
+    queue.solutions.push({
+      item_id: generateQueueItemId(queue, 'solution'),
+      issue_id: issueId,
+      solution_id: solution.id,
+      status: 'pending',
+      execution_order: queue.solutions.length + 1,
+      execution_group: 'P1',
+      depends_on: [],
+      semantic_priority: 0.5,
+      assigned_executor: 'codex',
+      task_count: solution.tasks?.length || 0,
+      files_touched: Array.from(filesTouched)
+    });
+
     writeQueue(queue);
     updateIssue(issueId, { status: 'queued', queued_at: new Date().toISOString() });
 
     if (isNewQueue) {
       console.log(chalk.green(`✓ Created queue ${queue.id}`));
     }
-    console.log(chalk.green(`✓ Added ${added} tasks from ${solution.id}`));
+    console.log(chalk.green(`✓ Added solution ${solution.id} (${solution.tasks?.length || 0} tasks) to queue`));
     return;
   }
 
@@ -961,7 +1185,11 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
   console.log(chalk.bold.cyan('\nActive Queue\n'));
 
-  if (!queue.id || queue.tasks.length === 0) {
+  // Support both solution-level and task-level queues
+  const items = queue.solutions || queue.tasks || [];
+  const isSolutionLevel = !!(queue.solutions && queue.solutions.length > 0);
+
+  if (!queue.id || items.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'));
@@ -970,13 +1198,17 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
   console.log(chalk.gray(`Queue: ${queue.id}`));
   console.log(chalk.gray(`Issues: ${queue.issue_ids.join(', ')}`));
-  console.log(chalk.gray(`Total: ${queue._metadata.total_tasks} | Pending: ${queue._metadata.pending_count} | Executing: ${queue._metadata.executing_count} | Completed: ${queue._metadata.completed_count}`));
+  console.log(chalk.gray(`Total: ${items.length} | Pending: ${items.filter(i => i.status === 'pending').length} | Executing: ${items.filter(i => i.status === 'executing').length} | Completed: ${items.filter(i => i.status === 'completed').length}`));
   console.log();
 
-  console.log(chalk.gray('QueueID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
+  if (isSolutionLevel) {
+    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Tasks'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
+  } else {
+    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
+  }
   console.log(chalk.gray('-'.repeat(60)));
 
-  for (const item of queue.tasks) {
+  for (const item of items) {
     const statusColor = {
       'pending': chalk.gray,
       'ready': chalk.cyan,
@@ -986,10 +1218,14 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       'blocked': chalk.magenta
     }[item.status] || chalk.white;
 
+    const thirdCol = isSolutionLevel
+      ? String(item.task_count || 0).padEnd(8)
+      : (item.task_id || '-').padEnd(8);
+
     console.log(
       item.item_id.padEnd(10) +
       item.issue_id.substring(0, 13).padEnd(15) +
-      item.task_id.padEnd(8) +
+      thirdCol +
       statusColor(item.status.padEnd(12)) +
       item.assigned_executor
     );
@@ -998,78 +1234,111 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
 /**
  * next - Get next ready task for execution (JSON output)
+ * Accepts optional item_id to fetch a specific task directly
  */
-async function nextAction(options: IssueOptions): Promise<void> {
+async function nextAction(itemId: string | undefined, options: IssueOptions): Promise<void> {
   const queue = readActiveQueue();
-
-  // Priority 1: Resume executing tasks (interrupted/crashed)
-  const executingTasks = queue.tasks.filter(item => item.status === 'executing');
-
-  // Priority 2: Find pending tasks with satisfied dependencies
-  const pendingTasks = queue.tasks.filter(item => {
-    if (item.status !== 'pending') return false;
-    return item.depends_on.every(depId => {
-      const dep = queue.tasks.find(q => q.item_id === depId);
-      return !dep || dep.status === 'completed';
+  // Support both old (tasks) and new (solutions) queue format
+  const items = queue.solutions || queue.tasks || [];
+  let nextItem: typeof items[0] | undefined;
+  let isResume = false;
+
+  // If specific item_id provided, fetch that item directly
+  if (itemId) {
+    nextItem = items.find(t => t.item_id === itemId);
+    if (!nextItem) {
+      console.log(JSON.stringify({ status: 'error', message: `Item ${itemId} not found` }));
+      return;
+    }
+    if (nextItem.status === 'completed') {
+      console.log(JSON.stringify({ status: 'completed', message: `Item ${itemId} already completed` }));
+      return;
+    }
+    if (nextItem.status === 'failed') {
+      console.log(JSON.stringify({ status: 'failed', message: `Item ${itemId} failed, use retry to reset` }));
+      return;
+    }
+    isResume = nextItem.status === 'executing';
+  } else {
+    // Auto-select: Priority 1 - executing, Priority 2 - ready pending
+    const executingItems = items.filter(item => item.status === 'executing');
+    const pendingItems = items.filter(item => {
+      if (item.status !== 'pending') return false;
+      return (item.depends_on || []).every(depId => {
+        const dep = items.find(q => q.item_id === depId);
+        return !dep || dep.status === 'completed';
+      });
     });
-  });
 
-  // Combine: executing first, then pending
-  const readyTasks = [...executingTasks, ...pendingTasks];
+    const readyItems = [...executingItems, ...pendingItems];
 
-  if (readyTasks.length === 0) {
-    console.log(JSON.stringify({
-      status: 'empty',
-      message: 'No ready tasks',
-      queue_status: queue._metadata
-    }, null, 2));
-    return;
-  }
+    if (readyItems.length === 0) {
+      console.log(JSON.stringify({
+        status: 'empty',
+        message: 'No ready items',
+        queue_status: queue._metadata
+      }, null, 2));
+      return;
+    }
 
-  // Sort by execution order
-  readyTasks.sort((a, b) => a.execution_order - b.execution_order);
-  const nextItem = readyTasks[0];
-  const isResume = nextItem.status === 'executing';
+    readyItems.sort((a, b) => a.execution_order - b.execution_order);
+    nextItem = readyItems[0];
+    isResume = nextItem.status === 'executing';
+  }
 
-  // Load task definition
+  // Load FULL solution with all tasks
   const solution = findSolution(nextItem.issue_id, nextItem.solution_id);
-  const taskDef = solution?.tasks.find(t => t.id === nextItem.task_id);
 
-  if (!taskDef) {
-    console.log(JSON.stringify({ status: 'error', message: 'Task definition not found' }));
+  if (!solution) {
+    console.log(JSON.stringify({ status: 'error', message: 'Solution not found' }));
     process.exit(1);
   }
 
-  // Only update status if not already executing (new task)
+  // Only update status if not already executing
   if (!isResume) {
-    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();
+    const idx = items.findIndex(q => q.item_id === nextItem.item_id);
+    items[idx].status = 'executing';
+    items[idx].started_at = new Date().toISOString();
+    // Write back to correct array
+    if (queue.solutions) {
+      queue.solutions = items;
+    } else {
+      queue.tasks = items;
+    }
     writeQueue(queue);
     updateIssue(nextItem.issue_id, { status: 'executing' });
   }
 
-  // Calculate queue stats for context
+  // Calculate queue stats
   const stats = {
-    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
+    total: items.length,
+    completed: items.filter(q => q.status === 'completed').length,
+    failed: items.filter(q => q.status === 'failed').length,
+    executing: items.filter(q => q.status === 'executing').length,
+    pending: items.filter(q => q.status === 'pending').length
   };
   const remaining = stats.pending + stats.executing;
 
+  // Calculate total estimated time for all tasks
+  const totalMinutes = solution.tasks?.reduce((sum, t) => sum + (t.estimated_minutes || 30), 0) || 30;
+
   console.log(JSON.stringify({
     item_id: nextItem.item_id,
     issue_id: nextItem.issue_id,
     solution_id: nextItem.solution_id,
-    task: taskDef,
-    context: solution?.exploration_context || {},
+    // Return full solution object with all tasks
+    solution: {
+      id: solution.id,
+      approach: solution.approach,
+      tasks: solution.tasks || [],
+      exploration_context: solution.exploration_context || {}
+    },
     resumed: isResume,
-    resume_note: isResume ? `Resuming interrupted task (started: ${nextItem.started_at})` : undefined,
+    resume_note: isResume ? `Resuming interrupted item (started: ${nextItem.started_at})` : undefined,
     execution_hints: {
       executor: nextItem.assigned_executor,
-      estimated_minutes: taskDef.estimated_minutes || 30
+      task_count: solution.tasks?.length || 0,
+      estimated_minutes: totalMinutes
     },
     queue_progress: {
       completed: stats.completed,
@@ -1080,18 +1349,72 @@ async function nextAction(options: IssueOptions): Promise<void> {
   }, null, 2));
 }
 
+/**
+ * detail - Get task details by item_id (READ-ONLY, does NOT change status)
+ * Used for parallel execution: orchestrator gets dag, then dispatches with detail <id>
+ */
+async function detailAction(itemId: string | undefined, options: IssueOptions): Promise<void> {
+  if (!itemId) {
+    console.log(JSON.stringify({ status: 'error', message: 'item_id is required' }));
+    return;
+  }
+
+  const queue = readActiveQueue();
+  // Support both old (tasks) and new (solutions) queue format
+  const items = queue.solutions || queue.tasks || [];
+  const queueItem = items.find(t => t.item_id === itemId);
+
+  if (!queueItem) {
+    console.log(JSON.stringify({ status: 'error', message: `Item ${itemId} not found` }));
+    return;
+  }
+
+  // Load FULL solution with all tasks
+  const solution = findSolution(queueItem.issue_id, queueItem.solution_id);
+
+  if (!solution) {
+    console.log(JSON.stringify({ status: 'error', message: 'Solution not found' }));
+    return;
+  }
+
+  // Calculate total estimated time for all tasks
+  const totalMinutes = solution.tasks?.reduce((sum, t) => sum + (t.estimated_minutes || 30), 0) || 30;
+
+  // Return FULL SOLUTION with all tasks (READ-ONLY - no status update)
+  console.log(JSON.stringify({
+    item_id: queueItem.item_id,
+    issue_id: queueItem.issue_id,
+    solution_id: queueItem.solution_id,
+    status: queueItem.status,
+    // Return full solution object with all tasks
+    solution: {
+      id: solution.id,
+      approach: solution.approach,
+      tasks: solution.tasks || [],
+      exploration_context: solution.exploration_context || {}
+    },
+    execution_hints: {
+      executor: queueItem.assigned_executor,
+      task_count: solution.tasks?.length || 0,
+      estimated_minutes: totalMinutes
+    }
+  }, null, 2));
+}
+
 /**
  * done - Mark task completed or failed
  */
 async function doneAction(queueId: string | undefined, options: IssueOptions): Promise<void> {
   if (!queueId) {
-    console.error(chalk.red('Queue ID is required'));
-    console.error(chalk.gray('Usage: ccw issue done <queue-id> [--fail] [--reason "..."]'));
+    console.error(chalk.red('Item ID is required'));
+    console.error(chalk.gray('Usage: ccw issue done <item-id> [--fail] [--reason "..."]'));
     process.exit(1);
   }
 
   const queue = readActiveQueue();
-  const idx = queue.tasks.findIndex(q => q.item_id === queueId);
+  // Support both old (tasks) and new (solutions) queue format
+  const items = queue.solutions || queue.tasks || [];
+  const idx = items.findIndex(q => q.item_id === queueId);
 
   if (idx === -1) {
     console.error(chalk.red(`Queue item "${queueId}" not found`));
@@ -1099,66 +1422,69 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
   }
 
   const isFail = options.fail;
-  queue.tasks[idx].status = isFail ? 'failed' : 'completed';
-  queue.tasks[idx].completed_at = new Date().toISOString();
+  items[idx].status = isFail ? 'failed' : 'completed';
+  items[idx].completed_at = new Date().toISOString();
 
   if (isFail) {
-    queue.tasks[idx].failure_reason = options.reason || 'Unknown failure';
+    items[idx].failure_reason = options.reason || 'Unknown failure';
   } else if (options.result) {
     try {
-      queue.tasks[idx].result = JSON.parse(options.result);
+      items[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.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');
+  // Update issue status (solution = issue in new model)
+  const issueId = items[idx].issue_id;
 
-  if (allIssueComplete) {
-    updateIssue(issueId, { status: 'completed', completed_at: new Date().toISOString() });
-    console.log(chalk.green(`✓ ${queueId} completed`));
-    console.log(chalk.green(`✓ Issue ${issueId} completed (all tasks done)`));
-  } else if (anyIssueFailed) {
+  if (isFail) {
     updateIssue(issueId, { status: 'failed' });
     console.log(chalk.red(`✗ ${queueId} failed`));
   } else {
-    console.log(isFail ? chalk.red(`✗ ${queueId} failed`) : chalk.green(`✓ ${queueId} completed`));
+    updateIssue(issueId, { status: 'completed', completed_at: new Date().toISOString() });
+    console.log(chalk.green(`✓ ${queueId} completed`));
+    console.log(chalk.green(`✓ Issue ${issueId} completed`));
   }
 
   // Check if entire queue is complete
-  const allQueueComplete = queue.tasks.every(q => q.status === 'completed');
-  const anyQueueFailed = queue.tasks.some(q => q.status === 'failed');
+  const allQueueComplete = items.every(q => q.status === 'completed');
+  const anyQueueFailed = items.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.tasks.every(q => q.status === 'completed' || q.status === 'failed')) {
+    console.log(chalk.green(`\n✓ Queue ${queue.id} completed (all solutions done)`));
+  } else if (anyQueueFailed && items.every(q => q.status === 'completed' || q.status === 'failed')) {
     queue.status = 'failed';
-    console.log(chalk.yellow(`\n⚠ Queue ${queue.id} has failed tasks`));
+    console.log(chalk.yellow(`\n⚠ Queue ${queue.id} has failed solutions`));
   }
 
+  // Write back to queue (update the correct array)
+  if (queue.solutions) {
+    queue.solutions = items;
+  } else {
+    queue.tasks = items;
+  }
   writeQueue(queue);
 }
 
 /**
- * retry - Reset failed tasks to pending for re-execution
+ * retry - Reset failed items to pending for re-execution
  */
 async function retryAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
   const queue = readActiveQueue();
+  // Support both old (tasks) and new (solutions) queue format
+  const items = queue.solutions || queue.tasks || [];
 
-  if (!queue.id || queue.tasks.length === 0) {
+  if (!queue.id || items.length === 0) {
     console.log(chalk.yellow('No active queue'));
     return;
   }
 
   let updated = 0;
 
-  for (const item of queue.tasks) {
-    // Retry failed tasks only
+  for (const item of items) {
+    // Retry failed items only
     if (item.status === 'failed') {
       if (!issueId || item.issue_id === issueId) {
         item.status = 'pending';
@@ -1171,8 +1497,7 @@ async function retryAction(issueId: string | undefined, options: IssueOptions):
   }
 
   if (updated === 0) {
-    console.log(chalk.yellow('No failed tasks to retry'));
-    console.log(chalk.gray('Note: Interrupted (executing) tasks are auto-resumed by "ccw issue next"'));
+    console.log(chalk.yellow('No failed items to retry'));
     return;
   }
 
@@ -1181,13 +1506,19 @@ async function retryAction(issueId: string | undefined, options: IssueOptions):
     queue.status = 'active';
   }
 
+  // Write back to queue
+  if (queue.solutions) {
+    queue.solutions = items;
+  } else {
+    queue.tasks = items;
+  }
   writeQueue(queue);
 
   if (issueId) {
     updateIssue(issueId, { status: 'queued' });
   }
 
-  console.log(chalk.green(`✓ Reset ${updated} task(s) to pending`));
+  console.log(chalk.green(`✓ Reset ${updated} item(s) to pending`));
 }
 
 // ============ Main Entry ============
@@ -1215,11 +1546,17 @@ export async function issueCommand(
     case 'bind':
       await bindAction(argsArray[0], argsArray[1], options);
       break;
+    case 'update':
+      await updateAction(argsArray[0], options);
+      break;
     case 'queue':
       await queueAction(argsArray[0], argsArray[1], options);
       break;
     case 'next':
-      await nextAction(options);
+      await nextAction(argsArray[0], options);
+      break;
+    case 'detail':
+      await detailAction(argsArray[0], options);
       break;
     case 'done':
       await doneAction(argsArray[0], options);
@@ -1246,20 +1583,23 @@ export async function issueCommand(
       console.log(chalk.gray('  status [issue-id]                  Show detailed status'));
       console.log(chalk.gray('  task <issue-id> [task-id]          Add or update task'));
       console.log(chalk.gray('  bind <issue-id> [sol-id]           Bind solution (--solution <path> to register)'));
+      console.log(chalk.gray('  update <issue-id>                  Update issue (--status, --priority, --title)'));
       console.log();
       console.log(chalk.bold('Queue Commands:'));
       console.log(chalk.gray('  queue                              Show active queue'));
       console.log(chalk.gray('  queue list                         List all queues (history)'));
       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 dag                          Get dependency graph (JSON) for parallel execution'));
       console.log(chalk.gray('  queue archive                      Archive current queue'));
       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)'));
-      console.log(chalk.gray('  done <queue-id>                    Mark task completed'));
-      console.log(chalk.gray('  done <queue-id> --fail             Mark task failed'));
+      console.log(chalk.gray('  next [item-id]                     Get & mark task executing (JSON)'));
+      console.log(chalk.gray('  detail <item-id>                   Get task details (READ-ONLY, for parallel)'));
+      console.log(chalk.gray('  done <item-id>                     Mark task completed'));
+      console.log(chalk.gray('  done <item-id> --fail              Mark task failed'));
       console.log();
       console.log(chalk.bold('Options:'));
       console.log(chalk.gray('  --title <title>                    Issue/task title'));