claude-code-workflow 6.3.18 → 6.3.19

package/ccw/dist/commands/issue.js

@@ -4,8 +4,19 @@
  * Commands: init, list, status, task, bind, queue, next, done, retry
  */
 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) {
+    const err = error;
+    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) => {
     if (err.code === 'EPIPE') {
@@ -15,10 +26,100 @@ process.stdout.on('error', (err) => {
 });
 const ISSUES_DIR = '.workflow/issues';
 // ============ Storage Layer (JSONL) ============
+/**
+ * Normalize path for comparison (handles Windows case sensitivity)
+ */
+function normalizePath(p) {
+    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) {
+    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() {
+    // 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) {
+        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, '..');
@@ -35,7 +136,7 @@ function ensureIssuesDir() {
     }
 }
 // ============ Issues JSONL ============
-function readIssues() {
+export function readIssues() {
     const path = join(getIssuesDir(), 'issues.jsonl');
     if (!existsSync(path))
         return [];
@@ -49,7 +150,7 @@ function readIssues() {
         return [];
     }
 }
-function writeIssues(issues) {
+export function writeIssues(issues) {
     ensureIssuesDir();
     const path = join(getIssuesDir(), 'issues.jsonl');
     // Always add trailing newline for proper JSONL format
@@ -171,7 +272,7 @@ function createIssue(data) {
 function getSolutionsPath(issueId) {
     return join(getIssuesDir(), 'solutions', `${issueId}.jsonl`);
 }
-function readSolutions(issueId) {
+export function readSolutions(issueId) {
     const path = getSolutionsPath(issueId);
     if (!existsSync(path))
         return [];
@@ -185,7 +286,7 @@ function readSolutions(issueId) {
         return [];
     }
 }
-function writeSolutions(issueId, solutions) {
+export function writeSolutions(issueId, solutions) {
     const dir = join(getIssuesDir(), 'solutions');
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -272,7 +373,7 @@ function generateQueueFileId() {
     const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
     return `QUE-${ts}`;
 }
-function readQueue(queueId) {
+export function readQueue(queueId) {
     const index = readQueueIndex();
     const targetId = queueId || index.active_queue_id;
     if (!targetId)
@@ -307,7 +408,113 @@ function createEmptyQueue() {
         }
     };
 }
-function writeQueue(queue) {
+// ============ 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) {
+    // 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() {
+    const index = readQueueIndex();
+    const activeIds = index.active_queue_ids || (index.active_queue_id ? [index.active_queue_id] : []);
+    const queues = [];
+    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();
+    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) {
+    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) {
     ensureQueuesDir();
     // Support both old (tasks) and new (solutions) queue format
     const items = queue.solutions || queue.tasks || [];
@@ -414,16 +621,16 @@ async function createAction(options) {
     }
 }
 /**
- * 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, options) {
     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);
     }
     let jsonData = options.data;
@@ -436,20 +643,81 @@ async function solutionAction(issueId, options) {
             // stdin not available or empty
         }
     }
-    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>'));
+    // 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.message));
+            process.exit(1);
+        }
+        return;
+    }
+    // READ mode: list solutions for issue
+    const issue = findIssue(issueId);
+    if (!issue) {
+        console.error(chalk.red(`Issue "${issueId}" not found`));
         process.exit(1);
     }
-    try {
-        const data = JSON.parse(jsonData);
-        const solution = createSolution(issueId, data);
-        console.log(JSON.stringify(solution, null, 2));
+    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;
     }
-    catch (err) {
-        console.error(chalk.red(err.message));
-        process.exit(1);
+    // 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();
+            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();
     }
 }
 /**
@@ -1001,13 +1269,71 @@ async function queueAction(subAction, issueId, options) {
         }
         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;
+        // 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 || [];
         if (!queue.id || items.length === 0) {
@@ -1144,6 +1470,18 @@ async function queueAction(subAction, issueId, options) {
             console.error(chalk.red(`Queue "${queueId}" not found`));
             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);
@@ -1279,10 +1617,24 @@ async function queueAction(subAction, issueId, options) {
         const thirdCol = isSolutionLevel
             ? 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);
     }
 }
 /**
@@ -1290,16 +1642,50 @@ async function queueAction(subAction, issueId, options) {
  * Accepts optional item_id to fetch a specific task directly
  */
 async function nextAction(itemId, options) {
-    const queue = readActiveQueue();
-    // Support both old (tasks) and new (solutions) queue format
-    const items = queue.solutions || queue.tasks || [];
+    let queue;
+    let items;
+    // 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 = 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;
     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') {
@@ -1328,6 +1714,7 @@ async function nextAction(itemId, options) {
             console.log(JSON.stringify({
                 status: 'empty',
                 message: 'No ready items',
+                queue_id: queue.id,
                 queue_status: queue._metadata
             }, null, 2));
             return;
@@ -1369,6 +1756,7 @@ async function nextAction(itemId, options) {
     // 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({
+        queue_id: queue.id,
         item_id: nextItem.item_id,
         issue_id: nextItem.issue_id,
         solution_id: nextItem.solution_id,
@@ -1402,10 +1790,31 @@ async function detailAction(itemId, options) {
         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);
+    let queue;
+    let queueItem;
+    // 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` }));
         return;
@@ -1420,6 +1829,7 @@ async function detailAction(itemId, options) {
     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({
+        queue_id: queue.id,
         item_id: queueItem.item_id,
         issue_id: queueItem.issue_id,
         solution_id: queueItem.solution_id,
@@ -1440,25 +1850,48 @@ async function detailAction(itemId, options) {
 /**
  * done - Mark task completed or failed
  */
-async function doneAction(queueId, options) {
-    if (!queueId) {
+async function doneAction(queueItemId, options) {
+    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);
-    if (idx === -1) {
-        console.error(chalk.red(`Queue item "${queueId}" not found`));
-        process.exit(1);
+    let queue;
+    let items;
+    let idx;
+    // 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;
     items[idx].status = isFail ? 'failed' : 'completed';
     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 {
@@ -1472,11 +1905,11 @@ async function doneAction(queueId, options) {
     const issueId = items[idx].issue_id;
     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`));
     }
     // Check if entire queue is complete
@@ -1503,46 +1936,72 @@ async function doneAction(queueId, options) {
  * retry - Reset failed items to pending for re-execution
  */
 async function retryAction(issueId, options) {
-    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(chalk.yellow('No active queue'));
+    let queues;
+    // 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;
-    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++;
+    let totalUpdated = 0;
+    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 (queueUpdated > 0) {
+            // 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;
         }
     }
-    if (updated === 0) {
+    if (totalUpdated === 0) {
         console.log(chalk.yellow('No failed items to retry'));
         return;
     }
-    // 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);
     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 ============
 export async function issueCommand(subcommand, args, options) {
@@ -1609,6 +2068,8 @@ export async function issueCommand(subcommand, args, options) {
             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'));
@@ -1619,16 +2080,18 @@ export async function issueCommand(subcommand, args, options) {
             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'));
@@ -1636,7 +2099,9 @@ export async function issueCommand(subcommand, args, options) {
             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();