claude-code-workflow 6.3.13 → 6.3.15

package/ccw/src/commands/issue.ts

@@ -18,14 +18,34 @@ process.stdout.on('error', (err: NodeJS.ErrnoException) => {
 
 // ============ Interfaces ============
 
+interface IssueFeedback {
+  type: 'failure' | 'clarification' | 'rejection';
+  stage: string;               // new/plan/execute
+  content: string;
+  created_at: string;
+}
+
 interface Issue {
   id: string;
   title: string;
   status: 'registered' | 'planning' | 'planned' | 'queued' | 'executing' | 'completed' | 'failed' | 'paused';
   priority: number;
-  context: string;
+  context: string;             // Problem description (single source of truth)
+  source?: 'github' | 'text' | 'discovery';
+  source_url?: string;
+  tags?: string[];
+
+  // Optional structured fields
+  expected_behavior?: string;
+  actual_behavior?: string;
+  affected_components?: string[];
+
+  // Feedback history (failures + human clarifications)
+  feedback?: IssueFeedback[];
+
+  // Solution binding
   bound_solution_id: string | null;
-  solution_count: number;
+
   // Timestamps
   created_at: string;
   updated_at: string;
@@ -98,7 +118,6 @@ interface QueueItem {
   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;
@@ -175,7 +194,9 @@ interface IssueOptions {
   json?: boolean;
   force?: boolean;
   fail?: boolean;
-  ids?: boolean;        // List only IDs (one per line)
+  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)
 }
 
 const ISSUES_DIR = '.workflow/issues';
@@ -222,22 +243,132 @@ function readIssues(): Issue[] {
 function writeIssues(issues: Issue[]): void {
   ensureIssuesDir();
   const path = join(getIssuesDir(), 'issues.jsonl');
-  writeFileSync(path, issues.map(i => JSON.stringify(i)).join('\n'), 'utf-8');
+  // Always add trailing newline for proper JSONL format
+  const content = issues.map(i => JSON.stringify(i)).join('\n');
+  writeFileSync(path, content ? content + '\n' : '', 'utf-8');
 }
 
 function findIssue(issueId: string): Issue | undefined {
   return readIssues().find(i => i.id === issueId);
 }
 
+// ============ Issue History JSONL ============
+
+function readIssueHistory(): Issue[] {
+  const path = join(getIssuesDir(), 'issue-history.jsonl');
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, 'utf-8')
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+function appendIssueHistory(issue: Issue): void {
+  ensureIssuesDir();
+  const path = join(getIssuesDir(), 'issue-history.jsonl');
+  const line = JSON.stringify(issue) + '\n';
+  // Append to history file
+  if (existsSync(path)) {
+    const content = readFileSync(path, 'utf-8');
+    // Ensure proper newline before appending
+    const needsNewline = content.length > 0 && !content.endsWith('\n');
+    writeFileSync(path, (needsNewline ? '\n' : '') + line, { flag: 'a' });
+  } else {
+    writeFileSync(path, line, 'utf-8');
+  }
+}
+
+/**
+ * Move completed issue from issues.jsonl to issue-history.jsonl
+ */
+function moveIssueToHistory(issueId: string): boolean {
+  const issues = readIssues();
+  const idx = issues.findIndex(i => i.id === issueId);
+  if (idx === -1) return false;
+
+  const issue = issues[idx];
+  if (issue.status !== 'completed') return false;
+
+  // Append to history
+  appendIssueHistory(issue);
+
+  // Remove from active issues
+  issues.splice(idx, 1);
+  writeIssues(issues);
+
+  return true;
+}
+
 function updateIssue(issueId: string, updates: Partial<Issue>): boolean {
   const issues = readIssues();
   const idx = issues.findIndex(i => i.id === issueId);
   if (idx === -1) return false;
   issues[idx] = { ...issues[idx], ...updates, updated_at: new Date().toISOString() };
   writeIssues(issues);
+
+  // Auto-move to history when completed
+  if (updates.status === 'completed') {
+    moveIssueToHistory(issueId);
+  }
+
   return true;
 }
 
+/**
+ * Generate auto-increment issue ID: ISS-YYYYMMDD-NNN
+ */
+function generateIssueId(existingIssues: Issue[] = []): string {
+  const today = new Date();
+  const dateStr = today.toISOString().slice(0, 10).replace(/-/g, '');
+  const prefix = `ISS-${dateStr}-`;
+  const todayPattern = new RegExp(`^ISS-${dateStr}-(\\d{3})$`);
+  let maxSeq = 0;
+  for (const issue of existingIssues) {
+    const match = issue.id.match(todayPattern);
+    if (match) maxSeq = Math.max(maxSeq, parseInt(match[1], 10));
+  }
+  return `${prefix}${String(maxSeq + 1).padStart(3, '0')}`;
+}
+
+/**
+ * Create a new issue with proper JSONL handling
+ * Auto-generates ID if not provided
+ */
+function createIssue(data: Partial<Issue>): Issue {
+  const issues = readIssues();
+  const issueId = data.id || generateIssueId(issues);
+
+  if (issues.some(i => i.id === issueId)) {
+    throw new Error(`Issue "${issueId}" already exists`);
+  }
+
+  const newIssue: Issue = {
+    id: issueId,
+    title: data.title || issueId,
+    status: data.status || 'registered',
+    priority: data.priority || 3,
+    context: data.context || '',
+    source: data.source,
+    source_url: data.source_url,
+    tags: data.tags,
+    expected_behavior: data.expected_behavior,
+    actual_behavior: data.actual_behavior,
+    affected_components: data.affected_components,
+    feedback: data.feedback,
+    bound_solution_id: data.bound_solution_id || null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString()
+  };
+
+  issues.push(newIssue);
+  writeIssues(issues);
+  return newIssue;
+}
+
 // ============ Solutions JSONL ============
 
 function getSolutionsPath(issueId: string): string {
@@ -260,7 +391,9 @@ function readSolutions(issueId: string): Solution[] {
 function writeSolutions(issueId: string, solutions: Solution[]): void {
   const dir = join(getIssuesDir(), 'solutions');
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(getSolutionsPath(issueId), solutions.map(s => JSON.stringify(s)).join('\n'), 'utf-8');
+  // Always add trailing newline for proper JSONL format
+  const content = solutions.map(s => JSON.stringify(s)).join('\n');
+  writeFileSync(getSolutionsPath(issueId), content ? content + '\n' : '', 'utf-8');
 }
 
 function findSolution(issueId: string, solutionId: string): Solution | undefined {
@@ -271,9 +404,57 @@ function getBoundSolution(issueId: string): Solution | undefined {
   return readSolutions(issueId).find(s => s.is_bound);
 }
 
-function generateSolutionId(): string {
-  const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
-  return `SOL-${ts}`;
+/**
+ * Generate solution ID in format: SOL-{issue-id}-{seq}
+ * @param issueId - The issue ID to include in the solution ID
+ * @param existingSolutions - Existing solutions to calculate next sequence number
+ * @returns Solution ID like "SOL-GH-123-1" or "SOL-ISS-20251229-001-2"
+ */
+function generateSolutionId(issueId: string, existingSolutions: Solution[] = []): string {
+  // Find the highest existing sequence number for this issue
+  const pattern = new RegExp(`^SOL-${issueId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-(\\d+)$`);
+  let maxSeq = 0;
+  for (const sol of existingSolutions) {
+    const match = sol.id.match(pattern);
+    if (match) {
+      maxSeq = Math.max(maxSeq, parseInt(match[1], 10));
+    }
+  }
+  return `SOL-${issueId}-${maxSeq + 1}`;
+}
+
+/**
+ * Create a new solution with proper JSONL handling
+ * Auto-generates ID if not provided
+ */
+function createSolution(issueId: string, data: Partial<Solution>): Solution {
+  const issue = findIssue(issueId);
+  if (!issue) {
+    throw new Error(`Issue "${issueId}" not found`);
+  }
+
+  const solutions = readSolutions(issueId);
+  const solutionId = data.id || generateSolutionId(issueId, solutions);
+
+  if (solutions.some(s => s.id === solutionId)) {
+    throw new Error(`Solution "${solutionId}" already exists`);
+  }
+
+  const newSolution: Solution = {
+    id: solutionId,
+    description: data.description || '',
+    approach: data.approach || '',
+    tasks: data.tasks || [],
+    exploration_context: data.exploration_context,
+    analysis: data.analysis,
+    score: data.score,
+    is_bound: false,
+    created_at: new Date().toISOString()
+  };
+
+  solutions.push(newSolution);
+  writeSolutions(issueId, solutions);
+  return newSolution;
 }
 
 // ============ Queue Management (Multi-Queue) ============
@@ -434,7 +615,57 @@ function generateQueueItemId(queue: Queue, level: 'solution' | 'task' = 'solutio
 // ============ Commands ============
 
 /**
- * init - Initialize a new issue
+ * create - Create issue from JSON data
+ * Usage: ccw issue create --data '{"title":"...", "context":"..."}'
+ * Output: JSON with created issue (includes auto-generated ID)
+ */
+async function createAction(options: IssueOptions): Promise<void> {
+  if (!options.data) {
+    console.error(chalk.red('JSON data required'));
+    console.error(chalk.gray('Usage: ccw issue create --data \'{"title":"...", "context":"..."}\''));
+    process.exit(1);
+  }
+
+  try {
+    const data = JSON.parse(options.data);
+    const issue = createIssue(data);
+    console.log(JSON.stringify(issue, null, 2));
+  } catch (err) {
+    console.error(chalk.red((err as Error).message));
+    process.exit(1);
+  }
+}
+
+/**
+ * solution - Create solution from JSON data
+ * Usage: ccw issue solution <issue-id> --data '{"tasks":[...]}'
+ * Output: JSON with created solution (includes auto-generated ID)
+ */
+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":[...]}\''));
+    process.exit(1);
+  }
+
+  if (!options.data) {
+    console.error(chalk.red('JSON data required'));
+    console.error(chalk.gray('Usage: ccw issue solution <issue-id> --data \'{"tasks":[...]}\''));
+    process.exit(1);
+  }
+
+  try {
+    const data = JSON.parse(options.data);
+    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);
+  }
+}
+
+/**
+ * init - Initialize a new issue (manual ID)
  */
 async function initAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
   if (!issueId) {
@@ -458,7 +689,6 @@ async function initAction(issueId: string | undefined, options: IssueOptions): P
     priority: options.priority ? parseInt(options.priority) : 3,
     context: options.description || '',
     bound_solution_id: null,
-    solution_count: 0,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString()
   };
@@ -484,9 +714,17 @@ async function listAction(issueId: string | undefined, options: IssueOptions): P
       issues = issues.filter(i => statuses.includes(i.status));
     }
 
-    // IDs only mode (one per line, for scripting)
-    if (options.ids) {
-      issues.forEach(i => console.log(i.id));
+    // Brief mode: minimal fields only (id, title, status, priority, tags, bound_solution_id)
+    if (options.brief) {
+      const briefIssues = issues.map(i => ({
+        id: i.id,
+        title: i.title,
+        status: i.status,
+        priority: i.priority,
+        tags: i.tags || [],
+        bound_solution_id: i.bound_solution_id
+      }));
+      console.log(JSON.stringify(briefIssues, null, 2));
       return;
     }
 
@@ -517,7 +755,8 @@ async function listAction(issueId: string | undefined, options: IssueOptions): P
         'paused': chalk.magenta
       }[issue.status] || chalk.white;
 
-      const bound = issue.bound_solution_id ? `[${issue.bound_solution_id}]` : `${issue.solution_count}`;
+      const solutionCount = readSolutions(issue.id).length;
+      const bound = issue.bound_solution_id ? `[${issue.bound_solution_id}]` : `${solutionCount}`;
       console.log(
         issue.id.padEnd(20) +
         statusColor(issue.status.padEnd(15)) +
@@ -567,6 +806,52 @@ async function listAction(issueId: string | undefined, options: IssueOptions): P
   }
 }
 
+/**
+ * history - List completed issues from history
+ */
+async function historyAction(options: IssueOptions): Promise<void> {
+  const history = readIssueHistory();
+
+  // Brief mode: minimal fields only
+  if (options.brief) {
+    const briefHistory = history.map(i => ({
+      id: i.id,
+      title: i.title,
+      status: i.status,
+      completed_at: i.completed_at
+    }));
+    console.log(JSON.stringify(briefHistory, null, 2));
+    return;
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
+  }
+
+  if (history.length === 0) {
+    console.log(chalk.yellow('No completed issues in history'));
+    return;
+  }
+
+  console.log(chalk.bold.cyan('\nIssue History (Completed)\n'));
+  console.log(chalk.gray('ID'.padEnd(25) + 'Completed At'.padEnd(22) + 'Title'));
+  console.log(chalk.gray('-'.repeat(80)));
+
+  for (const issue of history) {
+    const completedAt = issue.completed_at
+      ? new Date(issue.completed_at).toLocaleString()
+      : 'N/A';
+    console.log(
+      chalk.green(issue.id.padEnd(25)) +
+      completedAt.padEnd(22) +
+      (issue.title || '').substring(0, 35)
+    );
+  }
+
+  console.log(chalk.gray(`\nTotal: ${history.length} completed issues`));
+}
+
 /**
  * status - Show detailed status
  */
@@ -651,7 +936,7 @@ async function taskAction(issueId: string | undefined, taskId: string | undefine
   // Create default solution if none bound
   if (boundIdx === -1) {
     const newSol: Solution = {
-      id: generateSolutionId(),
+      id: generateSolutionId(issueId, solutions),
       description: 'Manual tasks',
       tasks: [],
       is_bound: true,
@@ -718,11 +1003,88 @@ async function taskAction(issueId: string | undefined, taskId: string | undefine
 
 /**
  * update - Update issue fields (status, priority, title, etc.)
+ * --from-queue: Sync statuses from active queue (auto-update queued issues)
  */
 async function updateAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
+  // Handle --from-queue: Sync statuses from queue
+  if (options.fromQueue) {
+    // Determine queue ID: string value = specific queue, true = active queue
+    const queueId = typeof options.fromQueue === 'string' ? options.fromQueue : undefined;
+    const queue = queueId ? readQueue(queueId) : readActiveQueue();
+
+    if (!queue) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, message: `Queue not found: ${queueId}`, queued: [], unplanned: [] }));
+      } else {
+        console.log(chalk.red(`Queue not found: ${queueId}`));
+      }
+      return;
+    }
+
+    const items = queue.solutions || queue.tasks || [];
+    const allIssues = readIssues();
+
+    if (!queue.id || items.length === 0) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, message: 'No active queue', queued: [], unplanned: [] }));
+      } else {
+        console.log(chalk.yellow('No active queue to sync from'));
+      }
+      return;
+    }
+
+    // Get issue IDs from queue
+    const queuedIssueIds = new Set(items.map(item => item.issue_id));
+    const now = new Date().toISOString();
+
+    // Track updates
+    const updated: string[] = [];
+    const unplanned: string[] = [];
+
+    // Update queued issues
+    for (const issueId of queuedIssueIds) {
+      const issue = allIssues.find(i => i.id === issueId);
+      if (issue && issue.status !== 'queued' && issue.status !== 'executing' && issue.status !== 'completed') {
+        updateIssue(issueId, { status: 'queued', queued_at: now });
+        updated.push(issueId);
+      }
+    }
+
+    // Find planned issues NOT in queue
+    for (const issue of allIssues) {
+      if (issue.status === 'planned' && issue.bound_solution_id && !queuedIssueIds.has(issue.id)) {
+        unplanned.push(issue.id);
+      }
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        queue_id: queue.id,
+        queued: updated,
+        queued_count: updated.length,
+        unplanned: unplanned,
+        unplanned_count: unplanned.length
+      }, null, 2));
+    } else {
+      console.log(chalk.green(`✓ Synced from queue ${queue.id}`));
+      console.log(chalk.gray(`  Updated to 'queued': ${updated.length} issues`));
+      if (updated.length > 0) {
+        updated.forEach(id => console.log(chalk.gray(`    - ${id}`)));
+      }
+      if (unplanned.length > 0) {
+        console.log(chalk.yellow(`  Planned but NOT in queue: ${unplanned.length} issues`));
+        unplanned.forEach(id => console.log(chalk.yellow(`    - ${id}`)));
+      }
+    }
+    return;
+  }
+
+  // Standard single-issue update
   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 "..."]'));
+    console.error(chalk.gray('Usage: ccw issue update <issue-id> --status <status>'));
+    console.error(chalk.gray('       ccw issue update --from-queue [queue-id]  (sync from queue)'));
     process.exit(1);
   }
 
@@ -802,8 +1164,9 @@ async function bindAction(issueId: string | undefined, solutionId: string | unde
     try {
       const content = readFileSync(options.solution, 'utf-8');
       const data = JSON.parse(content);
+      // Priority: CLI arg > file content ID > generate new (SOL-{issue-id}-{seq})
       const newSol: Solution = {
-        id: solutionId || generateSolutionId(),
+        id: solutionId || data.id || generateSolutionId(issueId, solutions),
         description: data.description || data.approach_name || 'Imported solution',
         tasks: data.tasks || [],
         exploration_context: data.exploration_context,
@@ -852,7 +1215,6 @@ async function bindAction(issueId: string | undefined, solutionId: string | unde
   writeSolutions(issueId, solutions);
   updateIssue(issueId, {
     bound_solution_id: solutionId,
-    solution_count: solutions.length,
     status: 'planned',
     planned_at: new Date().toISOString()
   });
@@ -868,6 +1230,22 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
   if (subAction === 'list' || subAction === 'history') {
     const index = readQueueIndex();
 
+    // Brief mode: minimal queue index info
+    if (options.brief) {
+      const briefIndex = {
+        active_queue_id: index.active_queue_id,
+        queues: index.queues.map(q => ({
+          id: q.id,
+          status: q.status,
+          issue_ids: q.issue_ids,
+          total_solutions: q.total_solutions,
+          completed_solutions: q.completed_solutions
+        }))
+      };
+      console.log(JSON.stringify(briefIndex, null, 2));
+      return;
+    }
+
     if (options.json) {
       console.log(JSON.stringify(index, null, 2));
       return;
@@ -944,7 +1322,6 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       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,
@@ -1161,7 +1538,6 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       execution_group: 'P1',
       depends_on: [],
       semantic_priority: 0.5,
-      assigned_executor: 'codex',
       task_count: solution.tasks?.length || 0,
       files_touched: Array.from(filesTouched)
     });
@@ -1179,6 +1555,28 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
   // Show current queue
   const queue = readActiveQueue();
 
+  // Brief mode: minimal queue info (id, issue_ids, item summaries)
+  if (options.brief) {
+    const items = queue.solutions || queue.tasks || [];
+    const briefQueue = {
+      id: queue.id,
+      issue_ids: queue.issue_ids || [],
+      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,
+      items: items.map(i => ({
+        item_id: i.item_id,
+        issue_id: i.issue_id,
+        solution_id: i.solution_id,
+        status: i.status,
+        task_count: i.task_count
+      }))
+    };
+    console.log(JSON.stringify(briefQueue, null, 2));
+    return;
+  }
+
   if (options.json) {
     console.log(JSON.stringify(queue, null, 2));
     return;
@@ -1203,11 +1601,11 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
   console.log();
 
   if (isSolutionLevel) {
-    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Tasks'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
+    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Tasks'.padEnd(8) + 'Status'));
   } else {
-    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
+    console.log(chalk.gray('ItemID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'));
   }
-  console.log(chalk.gray('-'.repeat(60)));
+  console.log(chalk.gray('-'.repeat(48)));
 
   for (const item of items) {
     const statusColor = {
@@ -1227,8 +1625,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
       item.item_id.padEnd(10) +
       item.issue_id.substring(0, 13).padEnd(15) +
       thirdCol +
-      statusColor(item.status.padEnd(12)) +
-      item.assigned_executor
+      statusColor(item.status)
     );
   }
 }
@@ -1337,7 +1734,6 @@ async function nextAction(itemId: string | undefined, options: IssueOptions): Pr
     resumed: isResume,
     resume_note: isResume ? `Resuming interrupted item (started: ${nextItem.started_at})` : undefined,
     execution_hints: {
-      executor: nextItem.assigned_executor,
       task_count: solution.tasks?.length || 0,
       estimated_minutes: totalMinutes
     },
@@ -1395,7 +1791,6 @@ async function detailAction(itemId: string | undefined, options: IssueOptions):
       exploration_context: solution.exploration_context || {}
     },
     execution_hints: {
-      executor: queueItem.assigned_executor,
       task_count: solution.tasks?.length || 0,
       estimated_minutes: totalMinutes
     }
@@ -1532,12 +1927,21 @@ export async function issueCommand(
   const argsArray = Array.isArray(args) ? args : (args ? [args] : []);
 
   switch (subcommand) {
+    case 'create':
+      await createAction(options);
+      break;
+    case 'solution':
+      await solutionAction(argsArray[0], options);
+      break;
     case 'init':
       await initAction(argsArray[0], options);
       break;
     case 'list':
       await listAction(argsArray[0], options);
       break;
+    case 'history':
+      await historyAction(options);
+      break;
     case 'status':
       await statusAction(argsArray[0], options);
       break;
@@ -1579,12 +1983,15 @@ export async function issueCommand(
     default:
       console.log(chalk.bold.cyan('\nCCW Issue Management (v3.0 - Multi-Queue + Lifecycle)\n'));
       console.log(chalk.bold('Core Commands:'));
-      console.log(chalk.gray('  init <issue-id>                    Initialize new issue'));
+      console.log(chalk.gray('  create --data \'{"title":"..."}\'    Create issue (auto-generates ID)'));
+      console.log(chalk.gray('  init <issue-id>                    Initialize new issue (manual ID)'));
       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('  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(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'));
+      console.log(chalk.gray('  update --from-queue [queue-id]     Sync statuses from queue (default: active)'));
       console.log();
       console.log(chalk.bold('Queue Commands:'));
       console.log(chalk.gray('  queue                              Show active queue'));
@@ -1605,7 +2012,7 @@ export async function issueCommand(
       console.log(chalk.bold('Options:'));
       console.log(chalk.gray('  --title <title>                    Issue/task title'));
       console.log(chalk.gray('  --status <status>                  Filter by status (comma-separated)'));
-      console.log(chalk.gray('  --ids                              List only IDs (one per line)'));
+      console.log(chalk.gray('  --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'));
@@ -1613,7 +2020,8 @@ export async function issueCommand(
       console.log(chalk.gray('  --force                            Force operation'));
       console.log();
       console.log(chalk.bold('Storage:'));
-      console.log(chalk.gray('  .workflow/issues/issues.jsonl      All issues'));
+      console.log(chalk.gray('  .workflow/issues/issues.jsonl         Active issues'));
+      console.log(chalk.gray('  .workflow/issues/issue-history.jsonl  Completed issues'));
       console.log(chalk.gray('  .workflow/issues/solutions/*.jsonl Solutions per issue'));
       console.log(chalk.gray('  .workflow/issues/queues/           Queue files (multi-queue)'));
       console.log(chalk.gray('  .workflow/issues/queues/index.json Queue index'));