claude-code-workflow 6.3.18 → 6.3.19

package/ccw/src/commands/issue.ts

@@ -5,8 +5,19 @@
  */
 
 import chalk from 'chalk';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { execSync } from 'child_process';
+import inquirer from 'inquirer';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
 import { join, resolve } from 'path';
+import { EXEC_TIMEOUTS } from '../utils/exec-constants.js';
+
+function isExecTimeoutError(error: unknown): boolean {
+  const err = error as { code?: unknown; errno?: unknown; message?: unknown } | null;
+  const code = err?.code ?? err?.errno;
+  if (code === 'ETIMEDOUT') return true;
+  const message = typeof err?.message === 'string' ? err.message : '';
+  return message.includes('ETIMEDOUT');
+}
 
 // Handle EPIPE errors gracefully
 process.stdout.on('error', (err: NodeJS.ErrnoException) => {
@@ -108,6 +119,15 @@ interface Solution {
   bound_at?: string;
 }
 
+// Structured failure detail for debugging
+interface FailureDetail {
+  task_id?: string;              // Which task failed within the solution
+  error_type: string;            // e.g., "compilation", "test_failure", "timeout"
+  message: string;               // Human-readable error message
+  stack_trace?: string;          // Optional stack trace
+  timestamp: string;             // ISO timestamp
+}
+
 interface QueueItem {
   item_id: string;               // Item ID in queue: T-1, T-2, ... (task-level) or S-1, S-2, ... (solution-level)
   issue_id: string;
@@ -124,7 +144,9 @@ interface QueueItem {
   started_at?: string;
   completed_at?: string;
   result?: Record<string, any>;
-  failure_reason?: string;
+  failure_reason?: string;       // Simple string (backward compat)
+  failure_details?: FailureDetail;   // Structured failure info
+  failure_history?: FailureDetail[]; // Preserved on retry for debugging
 }
 
 interface QueueConflict {
@@ -168,10 +190,12 @@ interface Queue {
 }
 
 interface QueueIndex {
-  active_queue_id: string | null;
+  active_queue_id: string | null;    // Single active queue (backward compat)
+  active_queue_ids?: string[];       // Multiple active queues, ordered by priority
   queues: {
     id: string;
     status: string;
+    priority?: number;               // Queue execution priority (lower = higher priority)
     issue_ids: string[];
     total_tasks?: number;          // For task-level queues
     total_solutions?: number;      // For solution-level queues
@@ -189,6 +213,7 @@ interface IssueOptions {
   executor?: string;
   priority?: string;
   solution?: string;
+  solutionId?: string;  // --solution-id <id> for filtering solutions
   result?: string;
   reason?: string;
   json?: boolean;
@@ -197,16 +222,113 @@ interface IssueOptions {
   brief?: boolean;      // List brief info only (id, title, status, priority, tags) - JSON format
   data?: string;        // JSON data for create
   fromQueue?: boolean | string;  // Sync statuses from queue (true=active, string=specific queue ID)
+  queue?: string;       // Target queue ID for multi-queue operations
 }
 
 const ISSUES_DIR = '.workflow/issues';
 
 // ============ Storage Layer (JSONL) ============
 
+/**
+ * Normalize path for comparison (handles Windows case sensitivity)
+ */
+function normalizePath(p: string): string {
+  const normalized = resolve(p);
+  // Windows: normalize to lowercase for comparison
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+/**
+ * Try to resolve main repo from .git file (worktree link file)
+ * .git file format: "gitdir: /path/to/main/.git/worktrees/name"
+ */
+function resolveMainRepoFromGitFile(gitFilePath: string): string | null {
+  try {
+    const content = readFileSync(gitFilePath, 'utf-8').trim();
+    // Parse "gitdir: /path/to/.git/worktrees/name"
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    if (match) {
+      const gitDir = match[1];
+      // Navigate from .git/worktrees/name to .git to repo root
+      // Pattern: /main/.git/worktrees/wt-name -> /main/.git -> /main
+      const worktreesMatch = gitDir.match(/^(.+)[/\\]\.git[/\\]worktrees[/\\]/);
+      if (worktreesMatch) {
+        return worktreesMatch[1];
+      }
+    }
+  } catch {
+    // Failed to read or parse .git file
+  }
+  return null;
+}
+
+/**
+ * Get the main repository root, even when running from a worktree.
+ * This ensures .workflow/issues/ is always accessed from the main repo.
+ */
 function getProjectRoot(): string {
+  // First, try to detect if we're in a git worktree using git commands
+  try {
+    // Get the common git directory (points to main repo's .git)
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: EXEC_TIMEOUTS.GIT_QUICK,
+    }).trim();
+
+    // Get the current git directory
+    const gitDir = execSync('git rev-parse --git-dir', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: EXEC_TIMEOUTS.GIT_QUICK,
+    }).trim();
+
+    // Normalize paths for comparison (Windows case insensitive)
+    const normalizedCommon = normalizePath(gitCommonDir);
+    const normalizedGit = normalizePath(gitDir);
+
+    // If gitDir != gitCommonDir, we're in a worktree
+    if (normalizedGit !== normalizedCommon && gitDir !== '.git') {
+      // We're in a worktree - resolve to main repo
+      const absoluteCommonDir = resolve(process.cwd(), gitCommonDir);
+      // .git directory's parent is the repo root
+      const mainRepoRoot = resolve(absoluteCommonDir, '..');
+
+      // Verify .workflow or .git exists in main repo
+      if (existsSync(join(mainRepoRoot, '.workflow')) || existsSync(join(mainRepoRoot, '.git'))) {
+        return mainRepoRoot;
+      }
+    }
+  } catch (err: unknown) {
+    if (isExecTimeoutError(err)) {
+      console.warn(`[issue] git rev-parse timed out after ${EXEC_TIMEOUTS.GIT_QUICK}ms; falling back to filesystem detection`);
+    }
+    // Git command failed - fall through to manual detection
+  }
+
+  // Standard detection with worktree file support: walk up to find .workflow or .git
   let dir = process.cwd();
   while (dir !== resolve(dir, '..')) {
-    if (existsSync(join(dir, '.workflow')) || existsSync(join(dir, '.git'))) {
+    const gitPath = join(dir, '.git');
+
+    // Check if .git is a file (worktree link) rather than directory
+    if (existsSync(gitPath)) {
+      try {
+        const gitStat = statSync(gitPath);
+        if (gitStat.isFile()) {
+          // .git is a file - this is a worktree, try to resolve main repo
+          const mainRepo = resolveMainRepoFromGitFile(gitPath);
+          if (mainRepo && existsSync(join(mainRepo, '.workflow'))) {
+            return mainRepo;
+          }
+          // If main repo doesn't have .workflow, fall back to current worktree
+        }
+      } catch {
+        // stat failed, continue with normal logic
+      }
+    }
+
+    if (existsSync(join(dir, '.workflow')) || existsSync(gitPath)) {
       return dir;
     }
     dir = resolve(dir, '..');
@@ -227,7 +349,7 @@ function ensureIssuesDir(): void {
 
 // ============ Issues JSONL ============
 
-function readIssues(): Issue[] {
+export function readIssues(): Issue[] {
   const path = join(getIssuesDir(), 'issues.jsonl');
   if (!existsSync(path)) return [];
   try {
@@ -240,7 +362,7 @@ function readIssues(): Issue[] {
   }
 }
 
-function writeIssues(issues: Issue[]): void {
+export function writeIssues(issues: Issue[]): void {
   ensureIssuesDir();
   const path = join(getIssuesDir(), 'issues.jsonl');
   // Always add trailing newline for proper JSONL format
@@ -375,7 +497,7 @@ function getSolutionsPath(issueId: string): string {
   return join(getIssuesDir(), 'solutions', `${issueId}.jsonl`);
 }
 
-function readSolutions(issueId: string): Solution[] {
+export function readSolutions(issueId: string): Solution[] {
   const path = getSolutionsPath(issueId);
   if (!existsSync(path)) return [];
   try {
@@ -388,7 +510,7 @@ function readSolutions(issueId: string): Solution[] {
   }
 }
 
-function writeSolutions(issueId: string, solutions: Solution[]): void {
+export function writeSolutions(issueId: string, solutions: Solution[]): void {
   const dir = join(getIssuesDir(), 'solutions');
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   // Always add trailing newline for proper JSONL format
@@ -489,7 +611,7 @@ function generateQueueFileId(): string {
   return `QUE-${ts}`;
 }
 
-function readQueue(queueId?: string): Queue | null {
+export function readQueue(queueId?: string): Queue | null {
   const index = readQueueIndex();
   const targetId = queueId || index.active_queue_id;
 
@@ -528,7 +650,120 @@ function createEmptyQueue(): Queue {
   };
 }
 
-function writeQueue(queue: Queue): void {
+// ============ Multi-Queue Helper Functions ============
+
+/**
+ * Find which queue contains a given item ID
+ * Supports both simple (S-1) and qualified (QUE-xxx:S-1) formats
+ */
+function findItemQueue(itemId: string): { queue: Queue; item: QueueItem; itemIndex: number } | null {
+  // Check if qualified format (QUE-xxx:S-1)
+  const qualifiedMatch = itemId.match(/^(QUE-[^:]+):(.+)$/);
+  if (qualifiedMatch) {
+    const [, queueId, actualItemId] = qualifiedMatch;
+    const queue = readQueue(queueId);
+    if (!queue) return null;
+    const items = queue.solutions || queue.tasks || [];
+    const itemIndex = items.findIndex(i => i.item_id === actualItemId);
+    if (itemIndex === -1) return null;
+    return { queue, item: items[itemIndex], itemIndex };
+  }
+
+  // Search all queues for unqualified item ID
+  const index = readQueueIndex();
+  const activeQueueIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
+
+  // Search active queues first
+  for (const queueId of activeQueueIds) {
+    const queue = readQueue(queueId);
+    if (!queue) continue;
+    const items = queue.solutions || queue.tasks || [];
+    const itemIndex = items.findIndex(i => i.item_id === itemId);
+    if (itemIndex >= 0) {
+      return { queue, item: items[itemIndex], itemIndex };
+    }
+  }
+
+  // Search all other queues
+  for (const queueEntry of index.queues) {
+    if (activeQueueIds.includes(queueEntry.id)) continue;
+    const queue = readQueue(queueEntry.id);
+    if (!queue) continue;
+    const items = queue.solutions || queue.tasks || [];
+    const itemIndex = items.findIndex(i => i.item_id === itemId);
+    if (itemIndex >= 0) {
+      return { queue, item: items[itemIndex], itemIndex };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get all active queues ordered by priority (lower = higher priority)
+ * Falls back to creation date order
+ */
+function getActiveQueues(): Queue[] {
+  const index = readQueueIndex();
+  const activeIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
+
+  const queues: Queue[] = [];
+  for (const queueId of activeIds) {
+    const queue = readQueue(queueId);
+    if (queue && queue.status === 'active') {
+      queues.push(queue);
+    }
+  }
+
+  // Sort by priority field in index (lower = higher priority)
+  const priorityMap = new Map<string, number>();
+  for (const entry of index.queues) {
+    priorityMap.set(entry.id, entry.priority ?? Number.MAX_SAFE_INTEGER);
+  }
+
+  queues.sort((a, b) => {
+    const pa = priorityMap.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+    const pb = priorityMap.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+    if (pa !== pb) return pa - pb;
+    // Fall back to creation date (from queue ID)
+    return a.id.localeCompare(b.id);
+  });
+
+  return queues;
+}
+
+/**
+ * Parse failure reason into structured FailureDetail
+ * Detects JSON format vs plain string
+ */
+function parseFailureReason(reason: string): FailureDetail {
+  const timestamp = new Date().toISOString();
+
+  // Try to parse as JSON first
+  if (reason.trim().startsWith('{')) {
+    try {
+      const parsed = JSON.parse(reason);
+      return {
+        task_id: parsed.task_id,
+        error_type: parsed.error_type || 'unknown',
+        message: parsed.message || reason,
+        stack_trace: parsed.stack_trace,
+        timestamp
+      };
+    } catch {
+      // Not valid JSON, treat as plain message
+    }
+  }
+
+  // Plain string message
+  return {
+    error_type: 'execution_error',
+    message: reason,
+    timestamp
+  };
+}
+
+export function writeQueue(queue: Queue): void {
   ensureQueuesDir();
 
   // Support both old (tasks) and new (solutions) queue format
@@ -650,16 +885,16 @@ async function createAction(options: IssueOptions): Promise<void> {
 }
 
 /**
- * solution - Create solution from JSON data
- * Usage: ccw issue solution <issue-id> --data '{"tasks":[...]}'
- *        echo '{"tasks":[...]}' | ccw issue solution <issue-id>
- * Output: JSON with created solution (includes auto-generated ID)
+ * solution - Create or read solutions
+ * Create: ccw issue solution <issue-id> --data '{"tasks":[...]}'
+ * Read:   ccw issue solution <issue-id> [--brief] [--solution-id <id>]
+ * Brief:  Returns { solution_id, files_touched[], task_count } for each solution
  */
 async function solutionAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
   if (!issueId) {
     console.error(chalk.red('Issue ID required'));
-    console.error(chalk.gray('Usage: ccw issue solution <issue-id> --data \'{"tasks":[...]}\''));
-    console.error(chalk.gray('       echo \'{"tasks":[...]}\' | ccw issue solution <issue-id>'));
+    console.error(chalk.gray('Usage: ccw issue solution <issue-id> [--brief] [--solution-id <id>]'));
+    console.error(chalk.gray('       ccw issue solution <issue-id> --data \'{"tasks":[...]}\''));
     process.exit(1);
   }
 
@@ -674,21 +909,85 @@ async function solutionAction(issueId: string | undefined, options: IssueOptions
     }
   }
 
-  if (!jsonData) {
-    console.error(chalk.red('JSON data required'));
-    console.error(chalk.gray('Usage: ccw issue solution <issue-id> --data \'{"tasks":[...]}\''));
-    console.error(chalk.gray('       echo \'{"tasks":[...]}\' | ccw issue solution <issue-id>'));
-    process.exit(1);
+  // CREATE mode: if --data provided
+  if (jsonData) {
+    try {
+      const data = JSON.parse(jsonData);
+      const solution = createSolution(issueId, data);
+      console.log(JSON.stringify(solution, null, 2));
+    } catch (err) {
+      console.error(chalk.red((err as Error).message));
+      process.exit(1);
+    }
+    return;
   }
 
-  try {
-    const data = JSON.parse(jsonData);
-    const solution = createSolution(issueId, data);
-    console.log(JSON.stringify(solution, null, 2));
-  } catch (err) {
-    console.error(chalk.red((err as Error).message));
+  // READ mode: list solutions for issue
+  const issue = findIssue(issueId);
+  if (!issue) {
+    console.error(chalk.red(`Issue "${issueId}" not found`));
     process.exit(1);
   }
+
+  const solutions = readSolutions(issueId);
+  if (solutions.length === 0) {
+    if (options.json || options.brief) {
+      console.log('[]');
+    } else {
+      console.log(chalk.yellow(`No solutions found for ${issueId}`));
+    }
+    return;
+  }
+
+  // Filter by solution-id if specified
+  let targetSolutions = solutions;
+  if (options.solutionId) {
+    targetSolutions = solutions.filter(s => s.id === options.solutionId);
+    if (targetSolutions.length === 0) {
+      console.error(chalk.red(`Solution "${options.solutionId}" not found`));
+      process.exit(1);
+    }
+  }
+
+  // Brief mode: extract files_touched from modification_points
+  if (options.brief) {
+    const briefSolutions = targetSolutions.map(sol => {
+      const filesTouched = new Set<string>();
+      for (const task of sol.tasks) {
+        if (task.modification_points) {
+          for (const mp of task.modification_points) {
+            if (mp.file) filesTouched.add(mp.file);
+          }
+        }
+      }
+      return {
+        solution_id: sol.id,
+        is_bound: sol.is_bound,
+        task_count: sol.tasks.length,
+        files_touched: Array.from(filesTouched)
+      };
+    });
+    console.log(JSON.stringify(briefSolutions, null, 2));
+    return;
+  }
+
+  // JSON mode: full solutions
+  if (options.json) {
+    console.log(JSON.stringify(targetSolutions, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  console.log(chalk.bold.cyan(`\nSolutions for ${issueId}:\n`));
+  for (const sol of targetSolutions) {
+    const marker = sol.is_bound ? chalk.green('◉ BOUND') : chalk.gray('○');
+    console.log(`${marker} ${sol.id}`);
+    console.log(chalk.gray(`  Tasks: ${sol.tasks.length}`));
+    if (sol.description) {
+      console.log(chalk.gray(`  ${sol.description.substring(0, 80)}...`));
+    }
+    console.log();
+  }
 }
 
 /**
@@ -1323,15 +1622,82 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 
     const index = readQueueIndex();
     index.active_queue_id = queueId;
+    // Also update active_queue_ids for multi-queue support
+    index.active_queue_ids = [queueId];
     writeQueueIndex(index);
 
     console.log(chalk.green(`✓ Switched to queue ${queueId}`));
     return;
   }
 
+  // Set queue priority (lower = higher priority)
+  if (subAction === 'priority' && issueId) {
+    const queueId = issueId;
+    const priority = parseInt(options.priority || '0');
+
+    if (isNaN(priority)) {
+      console.error(chalk.red('Invalid priority value (must be a number)'));
+      process.exit(1);
+    }
+
+    const index = readQueueIndex();
+    const queueEntry = index.queues.find(q => q.id === queueId);
+
+    if (!queueEntry) {
+      console.error(chalk.red(`Queue "${queueId}" not found`));
+      process.exit(1);
+    }
+
+    queueEntry.priority = priority;
+    writeQueueIndex(index);
+
+    console.log(chalk.green(`✓ Queue ${queueId} priority set to ${priority}`));
+    return;
+  }
+
+  // Activate multiple queues at once
+  if (subAction === 'activate' && issueId) {
+    const queueIds = issueId.split(',').map(id => id.trim());
+    const index = readQueueIndex();
+
+    // Validate all queue IDs
+    for (const queueId of queueIds) {
+      if (!index.queues.some(q => q.id === queueId)) {
+        console.error(chalk.red(`Queue "${queueId}" not found`));
+        process.exit(1);
+      }
+    }
+
+    index.active_queue_ids = queueIds;
+    index.active_queue_id = queueIds[0] || null; // Backward compat
+    writeQueueIndex(index);
+
+    console.log(chalk.green(`✓ Activated ${queueIds.length} queue(s): ${queueIds.join(', ')}`));
+    return;
+  }
+
   // DAG - Return dependency graph for parallel execution planning (solution-level)
   if (subAction === 'dag') {
-    const queue = readActiveQueue();
+    let queue: Queue;
+
+    // Use explicit queue if provided via --queue or issueId, otherwise use active queue
+    if (options.queue) {
+      const targetQueue = readQueue(options.queue);
+      if (!targetQueue) {
+        console.log(JSON.stringify({ error: `Queue ${options.queue} not found`, nodes: [], edges: [], groups: [] }));
+        return;
+      }
+      queue = targetQueue;
+    } else if (issueId && issueId.startsWith('QUE-')) {
+      const targetQueue = readQueue(issueId);
+      if (!targetQueue) {
+        console.log(JSON.stringify({ error: `Queue ${issueId} not found`, nodes: [], edges: [], groups: [] }));
+        return;
+      }
+      queue = targetQueue;
+    } else {
+      queue = readActiveQueue();
+    }
 
     // Support both old (tasks) and new (solutions) queue format
     const items = queue.solutions || queue.tasks || [];
@@ -1490,6 +1856,20 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       process.exit(1);
     }
 
+    if (!options.force) {
+      const { proceed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'proceed',
+        message: `Delete queue ${queueId}? This action cannot be undone.`,
+        default: false
+      }]);
+
+      if (!proceed) {
+        console.log(chalk.yellow('Queue deletion cancelled'));
+        return;
+      }
+    }
+
     // Remove from index
     const index = readQueueIndex();
     index.queues = index.queues.filter(q => q.id !== queueId);
@@ -1648,12 +2028,26 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       ? String(item.task_count || 0).padEnd(8)
       : (item.task_id || '-').padEnd(8);
 
-    console.log(
-      item.item_id.padEnd(10) +
+    let line = item.item_id.padEnd(10) +
       item.issue_id.substring(0, 13).padEnd(15) +
       thirdCol +
-      statusColor(item.status)
-    );
+      statusColor(item.status);
+
+    // Show failure reason for failed items
+    if (item.status === 'failed') {
+      const reason = item.failure_details?.message || item.failure_reason;
+      if (reason) {
+        // Truncate to 40 chars for display
+        const shortReason = reason.length > 40 ? reason.substring(0, 37) + '...' : reason;
+        line += chalk.gray(` [${shortReason}]`);
+      }
+      // Show retry count if there's failure history
+      if (item.failure_history && item.failure_history.length > 0) {
+        line += chalk.gray(` (${item.failure_history.length} retry)`);
+      }
+    }
+
+    console.log(line);
   }
 }
 
@@ -1662,17 +2056,58 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
  * Accepts optional item_id to fetch a specific task directly
  */
 async function nextAction(itemId: string | undefined, options: IssueOptions): Promise<void> {
-  const queue = readActiveQueue();
-  // Support both old (tasks) and new (solutions) queue format
-  const items = queue.solutions || queue.tasks || [];
-  let nextItem: typeof items[0] | undefined;
+  let queue: Queue;
+  let items: QueueItem[];
+
+  // Determine which queue(s) to use
+  if (options.queue) {
+    // Explicit queue specified
+    const targetQueue = readQueue(options.queue);
+    if (!targetQueue) {
+      console.log(JSON.stringify({ status: 'error', message: `Queue ${options.queue} not found` }));
+      return;
+    }
+    queue = targetQueue;
+    items = queue.solutions || queue.tasks || [];
+  } else {
+    // Multi-queue: iterate active queues in priority order (serialized execution)
+    const activeQueues = getActiveQueues();
+
+    if (activeQueues.length === 0) {
+      console.log(JSON.stringify({ status: 'empty', message: 'No active queues' }));
+      return;
+    }
+
+    // Find first queue with incomplete items (serialized: complete Q1 before Q2)
+    let foundQueue: Queue | null = null;
+    for (const q of activeQueues) {
+      const queueItems = q.solutions || q.tasks || [];
+      const hasIncomplete = queueItems.some(i =>
+        i.status === 'pending' || i.status === 'executing'
+      );
+      if (hasIncomplete) {
+        foundQueue = q;
+        break;
+      }
+    }
+
+    if (!foundQueue) {
+      console.log(JSON.stringify({ status: 'empty', message: 'All queues completed' }));
+      return;
+    }
+
+    queue = foundQueue;
+    items = queue.solutions || queue.tasks || [];
+  }
+
+  let nextItem: QueueItem | 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` }));
+      console.log(JSON.stringify({ status: 'error', message: `Item ${itemId} not found in queue ${queue.id}` }));
       return;
     }
     if (nextItem.status === 'completed') {
@@ -1701,6 +2136,7 @@ async function nextAction(itemId: string | undefined, options: IssueOptions): Pr
       console.log(JSON.stringify({
         status: 'empty',
         message: 'No ready items',
+        queue_id: queue.id,
         queue_status: queue._metadata
       }, null, 2));
       return;
@@ -1748,6 +2184,7 @@ async function nextAction(itemId: string | undefined, options: IssueOptions): Pr
   const totalMinutes = solution.tasks?.reduce((sum, t) => sum + (t.estimated_minutes || 30), 0) || 30;
 
   console.log(JSON.stringify({
+    queue_id: queue.id,
     item_id: nextItem.item_id,
     issue_id: nextItem.issue_id,
     solution_id: nextItem.solution_id,
@@ -1783,10 +2220,30 @@ async function detailAction(itemId: string | undefined, options: IssueOptions):
     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);
+  let queue: Queue;
+  let queueItem: QueueItem | undefined;
+
+  // Use explicit queue if provided, otherwise auto-detect
+  if (options.queue) {
+    const targetQueue = readQueue(options.queue);
+    if (!targetQueue) {
+      console.log(JSON.stringify({ status: 'error', message: `Queue ${options.queue} not found` }));
+      return;
+    }
+    queue = targetQueue;
+    const items = queue.solutions || queue.tasks || [];
+    queueItem = items.find(t => t.item_id === itemId);
+  } else {
+    // Auto-detect queue from item ID
+    const found = findItemQueue(itemId);
+    if (found) {
+      queue = found.queue;
+      queueItem = found.item;
+    } else {
+      console.log(JSON.stringify({ status: 'error', message: `Item ${itemId} not found in any queue` }));
+      return;
+    }
+  }
 
   if (!queueItem) {
     console.log(JSON.stringify({ status: 'error', message: `Item ${itemId} not found` }));
@@ -1806,6 +2263,7 @@ async function detailAction(itemId: string | undefined, options: IssueOptions):
 
   // Return FULL SOLUTION with all tasks (READ-ONLY - no status update)
   console.log(JSON.stringify({
+    queue_id: queue.id,
     item_id: queueItem.item_id,
     issue_id: queueItem.issue_id,
     solution_id: queueItem.solution_id,
@@ -1827,21 +2285,41 @@ async function detailAction(itemId: string | undefined, options: IssueOptions):
 /**
  * done - Mark task completed or failed
  */
-async function doneAction(queueId: string | undefined, options: IssueOptions): Promise<void> {
-  if (!queueId) {
+async function doneAction(queueItemId: string | undefined, options: IssueOptions): Promise<void> {
+  if (!queueItemId) {
     console.error(chalk.red('Item ID is required'));
-    console.error(chalk.gray('Usage: ccw issue done <item-id> [--fail] [--reason "..."]'));
+    console.error(chalk.gray('Usage: ccw issue done <item-id> [--fail] [--reason "..."] [--queue <queue-id>]'));
     process.exit(1);
   }
 
-  const queue = readActiveQueue();
-  // Support both old (tasks) and new (solutions) queue format
-  const items = queue.solutions || queue.tasks || [];
-  const idx = items.findIndex(q => q.item_id === queueId);
+  let queue: Queue;
+  let items: QueueItem[];
+  let idx: number;
 
-  if (idx === -1) {
-    console.error(chalk.red(`Queue item "${queueId}" not found`));
-    process.exit(1);
+  // Use explicit queue if provided, otherwise auto-detect
+  if (options.queue) {
+    const targetQueue = readQueue(options.queue);
+    if (!targetQueue) {
+      console.error(chalk.red(`Queue "${options.queue}" not found`));
+      process.exit(1);
+    }
+    queue = targetQueue;
+    items = queue.solutions || queue.tasks || [];
+    idx = items.findIndex(q => q.item_id === queueItemId);
+    if (idx === -1) {
+      console.error(chalk.red(`Queue item "${queueItemId}" not found in queue ${options.queue}`));
+      process.exit(1);
+    }
+  } else {
+    // Auto-detect queue from item ID
+    const found = findItemQueue(queueItemId);
+    if (!found) {
+      console.error(chalk.red(`Queue item "${queueItemId}" not found in any queue`));
+      process.exit(1);
+    }
+    queue = found.queue;
+    items = queue.solutions || queue.tasks || [];
+    idx = found.itemIndex;
   }
 
   const isFail = options.fail;
@@ -1849,7 +2327,9 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
   items[idx].completed_at = new Date().toISOString();
 
   if (isFail) {
-    items[idx].failure_reason = options.reason || 'Unknown failure';
+    const reason = options.reason || 'Unknown failure';
+    items[idx].failure_reason = reason;  // Backward compat
+    items[idx].failure_details = parseFailureReason(reason);  // Structured failure
   } else if (options.result) {
     try {
       items[idx].result = JSON.parse(options.result);
@@ -1863,10 +2343,10 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
 
   if (isFail) {
     updateIssue(issueId, { status: 'failed' });
-    console.log(chalk.red(`✗ ${queueId} failed`));
+    console.log(chalk.red(`✗ ${queueItemId} failed`));
   } else {
     updateIssue(issueId, { status: 'completed', completed_at: new Date().toISOString() });
-    console.log(chalk.green(`✓ ${queueId} completed`));
+    console.log(chalk.green(`✓ ${queueItemId} completed`));
     console.log(chalk.green(`✓ Issue ${issueId} completed`));
   }
 
@@ -1895,53 +2375,81 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
  * 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 || [];
+  let queues: Queue[];
 
-  if (!queue.id || items.length === 0) {
-    console.log(chalk.yellow('No active queue'));
+  // Use explicit queue if provided, otherwise use all active queues
+  if (options.queue) {
+    const targetQueue = readQueue(options.queue);
+    if (!targetQueue) {
+      console.log(chalk.red(`Queue "${options.queue}" not found`));
+      return;
+    }
+    queues = [targetQueue];
+  } else {
+    queues = getActiveQueues();
+  }
+
+  if (queues.length === 0) {
+    console.log(chalk.yellow('No active queues'));
     return;
   }
 
-  let updated = 0;
+  let totalUpdated = 0;
 
-  for (const item of items) {
-    // Retry failed items only
-    if (item.status === 'failed') {
-      if (!issueId || item.issue_id === issueId) {
-        item.status = 'pending';
-        item.failure_reason = undefined;
-        item.started_at = undefined;
-        item.completed_at = undefined;
-        updated++;
+  for (const queue of queues) {
+    const items = queue.solutions || queue.tasks || [];
+    let queueUpdated = 0;
+
+    for (const item of items) {
+      // Retry failed items only
+      if (item.status === 'failed') {
+        if (!issueId || item.issue_id === issueId) {
+          // Preserve failure history before resetting
+          if (item.failure_details) {
+            if (!item.failure_history) {
+              item.failure_history = [];
+            }
+            item.failure_history.push(item.failure_details);
+          }
+
+          // Reset for retry
+          item.status = 'pending';
+          item.failure_reason = undefined;
+          item.failure_details = undefined;
+          item.started_at = undefined;
+          item.completed_at = undefined;
+          queueUpdated++;
+        }
       }
     }
-  }
 
-  if (updated === 0) {
-    console.log(chalk.yellow('No failed items to retry'));
-    return;
-  }
+    if (queueUpdated > 0) {
+      // Reset queue status if it was failed
+      if (queue.status === 'failed') {
+        queue.status = 'active';
+      }
 
-  // Reset queue status if it was failed
-  if (queue.status === 'failed') {
-    queue.status = 'active';
+      // Write back to queue
+      if (queue.solutions) {
+        queue.solutions = items;
+      } else {
+        queue.tasks = items;
+      }
+      writeQueue(queue);
+      totalUpdated += queueUpdated;
+    }
   }
 
-  // Write back to queue
-  if (queue.solutions) {
-    queue.solutions = items;
-  } else {
-    queue.tasks = items;
+  if (totalUpdated === 0) {
+    console.log(chalk.yellow('No failed items to retry'));
+    return;
   }
-  writeQueue(queue);
 
   if (issueId) {
     updateIssue(issueId, { status: 'queued' });
   }
 
-  console.log(chalk.green(`✓ Reset ${updated} item(s) to pending`));
+  console.log(chalk.green(`✓ Reset ${totalUpdated} item(s) to pending (failure history preserved)`));
 }
 
 // ============ Main Entry ============
@@ -2015,6 +2523,8 @@ export async function issueCommand(
       console.log(chalk.gray('  list [issue-id]                    List issues or tasks'));
       console.log(chalk.gray('  history                            List completed issues (from history)'));
       console.log(chalk.gray('  status [issue-id]                  Show detailed status'));
+      console.log(chalk.gray('  solution <id>                      List solutions for issue'));
+      console.log(chalk.gray('  solution <id> --brief              Brief: solution_id, files_touched, task_count'));
       console.log(chalk.gray('  solution <id> --data \'{...}\'       Create solution (auto-generates ID)'));
       console.log(chalk.gray('  bind <issue-id> [sol-id]           Bind solution'));
       console.log(chalk.gray('  update <issue-id> --status <s>     Update issue status'));
@@ -2025,16 +2535,18 @@ export async function issueCommand(
       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 activate <q1,q2,...>         Activate multiple queues (comma-separated)'));
+      console.log(chalk.gray('  queue priority <queue-id>          Set queue priority (--priority N, lower=higher)'));
+      console.log(chalk.gray('  queue dag [--queue <id>]           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(chalk.gray('  retry [issue-id] [--queue <id>]    Retry failed tasks'));
       console.log();
       console.log(chalk.bold('Execution Endpoints:'));
-      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(chalk.gray('  next [item-id] [--queue <id>]      Get & mark task executing (JSON)'));
+      console.log(chalk.gray('  detail <item-id> [--queue <id>]    Get task details (READ-ONLY, for parallel)'));
+      console.log(chalk.gray('  done <item-id> [--queue <id>]      Mark task completed'));
+      console.log(chalk.gray('  done <item-id> --fail --reason "." Mark task failed with reason (supports JSON)'));
       console.log();
       console.log(chalk.bold('Options:'));
       console.log(chalk.gray('  --title <title>                    Issue/task title'));
@@ -2042,7 +2554,9 @@ export async function issueCommand(
       console.log(chalk.gray('  --brief                            Brief JSON output (minimal fields)'));
       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'));
+      console.log(chalk.gray('  --reason <text>                    Failure reason (string or JSON)'));
+      console.log(chalk.gray('  --queue <queue-id>                 Target queue for multi-queue operations'));
+      console.log(chalk.gray('  --priority <n>                     Queue priority (lower = higher)'));
       console.log(chalk.gray('  --json                             JSON output'));
       console.log(chalk.gray('  --force                            Force operation'));
       console.log();