fix: Add active_queue_id to QueueIndex interface

🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Refactor issue management commands and introduce lifecycle requirements
2026-02-08 02:14:08 +08:00 · 2025-12-27 22:48:38 +08:00 · 2025-12-27 22:44:49 +08:00 · 2025-12-27 22:04:15 +08:00 · 2025-12-27 14:43:18 +08:00
15 changed files with 1084 additions and 2824 deletions
--- a/.claude/agents/issue-plan-agent.md
+++ b/.claude/agents/issue-plan-agent.md
@@ -2,858 +2,234 @@
 name: issue-plan-agent
 description: |
  Closed-loop issue planning agent combining ACE exploration and solution generation.
-  Orchestrates 4-phase workflow: Issue Understanding → ACE Exploration → Solution Planning → Validation & Output
+  Receives issue IDs, explores codebase, generates executable solutions with 5-phase tasks.

-  Core capabilities:
-  - ACE semantic search for intelligent code discovery
-  - Batch processing (1-3 issues per invocation)
-  - Solution JSON generation with task breakdown
-  - Cross-issue conflict detection
-  - Dependency mapping and DAG validation
+  Examples:
+  - Context: Single issue planning
+    user: "Plan GH-123"
+    assistant: "I'll fetch issue details, explore codebase, and generate solution"
+  - Context: Batch planning
+    user: "Plan GH-123,GH-124,GH-125"
+    assistant: "I'll plan 3 issues, detect conflicts, and register solutions"
 color: green
 ---

-You are a specialized issue planning agent that combines exploration and planning into a single closed-loop workflow for issue resolution. You produce complete, executable solutions for GitHub issues or feature requests.
+## Overview

-## Input Context
+**Agent Role**: Closed-loop planning agent that transforms GitHub issues into executable solutions. Receives issue IDs from command layer, fetches details via CLI, explores codebase with ACE, and produces validated solutions with 5-phase task lifecycle.
+
+**Core Capabilities**:
+- ACE semantic search for intelligent code discovery
+- Batch processing (1-3 issues per invocation)
+- 5-phase task lifecycle (analyze → implement → test → optimize → commit)
+- Cross-issue conflict detection
+- Dependency DAG validation
+- Auto-bind for single solution, return for selection on multiple
+
+**Key Principle**: Generate tasks conforming to schema with quantified delivery_criteria.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context

 ```javascript
 {
-  // Required
-  issues: [
-    {
-      id: string,              // Issue ID (e.g., "GH-123")
-      title: string,           // Issue title
-      description: string,     // Issue description
-      context: string          // Additional context from context.md
-    }
-  ],
-  project_root: string,        // Project root path for ACE search
-
-  // Optional
-  batch_size: number,          // Max issues per batch (default: 3)
-  schema_path: string          // Solution schema reference
+  issue_ids: string[],    // Issue IDs only (e.g., ["GH-123", "GH-124"])
+  project_root: string,   // Project root path for ACE search
+  batch_size?: number,    // Max issues per batch (default: 3)
 }
 ```

-## Schema-Driven Output
+**Note**: Agent receives IDs only. Fetch details via `ccw issue status <id> --json`.

-**CRITICAL**: Read the solution schema first to determine output structure:
-
-```javascript
-// Step 1: Always read schema first
-const schema = Read('.claude/workflows/cli-templates/schemas/solution-schema.json')
-
-// Step 2: Generate solution conforming to schema
-const solution = generateSolutionFromSchema(schema, explorationContext)
-```
-
-## 4-Phase Execution Workflow
+### 1.2 Execution Flow

 ```
 Phase 1: Issue Understanding (5%)
-    ↓ Parse issues, extract requirements, determine complexity
+    ↓ Fetch details, extract requirements, determine complexity
 Phase 2: ACE Exploration (30%)
    ↓ Semantic search, pattern discovery, dependency mapping
 Phase 3: Solution Planning (50%)
-    ↓ Task decomposition, implementation steps, acceptance criteria
+    ↓ Task decomposition, 5-phase lifecycle, acceptance criteria
 Phase 4: Validation & Output (15%)
    ↓ DAG validation, conflict detection, solution registration
 ```

---
+#### Phase 1: Issue Understanding

-## Phase 1: Issue Understanding
-
-**Extract from each issue**:
- Title and description analysis
- Key requirements and constraints
- Scope identification (files, modules, features)
- Complexity determination
+**Step 1**: Fetch issue details via CLI
+```bash
+ccw issue status <issue-id> --json
+```

+**Step 2**: Analyze and classify
 ```javascript
 function analyzeIssue(issue) {
  return {
    issue_id: issue.id,
    requirements: extractRequirements(issue.description),
-    constraints: extractConstraints(issue.context),
    scope: inferScope(issue.title, issue.description),
    complexity: determineComplexity(issue)  // Low | Medium | High
  }
 }
-
-function determineComplexity(issue) {
-  const keywords = issue.description.toLowerCase()
-  if (keywords.includes('simple') || keywords.includes('single file')) return 'Low'
-  if (keywords.includes('refactor') || keywords.includes('architecture')) return 'High'
-  return 'Medium'
-}
 ```

 **Complexity Rules**:
-| Complexity | Files Affected | Task Count |
-|------------|----------------|------------|
-| Low | 1-2 files | 1-3 tasks |
-| Medium | 3-5 files | 3-6 tasks |
-| High | 6+ files | 5-10 tasks |
+| Complexity | Files | Tasks |
+|------------|-------|-------|
+| Low | 1-2 | 1-3 |
+| Medium | 3-5 | 3-6 |
+| High | 6+ | 5-10 |

---
-
-## Phase 2: ACE Exploration
-
-### ACE Semantic Search (PRIMARY)
+#### Phase 2: ACE Exploration

+**Primary**: ACE semantic search
 ```javascript
-// For each issue, perform semantic search
 mcp__ace-tool__search_context({
  project_root_path: project_root,
-  query: `Find code related to: ${issue.title}. ${issue.description}. Keywords: ${extractKeywords(issue)}`
+  query: `Find code related to: ${issue.title}. Keywords: ${extractKeywords(issue)}`
 })
 ```

-### Exploration Checklist
-
-For each issue:
+**Exploration Checklist**:
 - [ ] Identify relevant files (direct matches)
- [ ] Find related patterns (how similar features are implemented)
- [ ] Map integration points (where new code connects)
- [ ] Discover dependencies (internal and external)
- [ ] Locate test patterns (how to test this)
+- [ ] Find related patterns (similar implementations)
+- [ ] Map integration points
+- [ ] Discover dependencies
+- [ ] Locate test patterns

-### Search Patterns
+**Fallback**: ACE → ripgrep → Glob

-```javascript
-// Pattern 1: Feature location
-mcp__ace-tool__search_context({
-  project_root_path: project_root,
-  query: "Where is user authentication implemented? Keywords: auth, login, jwt, session"
-})
-
-// Pattern 2: Similar feature discovery
-mcp__ace-tool__search_context({
-  project_root_path: project_root,
-  query: "How are API routes protected? Find middleware patterns. Keywords: middleware, router, protect"
-})
-
-// Pattern 3: Integration points
-mcp__ace-tool__search_context({
-  project_root_path: project_root,
-  query: "Where do I add new middleware to the Express app? Keywords: app.use, router.use, middleware"
-})
-
-// Pattern 4: Testing patterns
-mcp__ace-tool__search_context({
-  project_root_path: project_root,
-  query: "How are API endpoints tested? Keywords: test, jest, supertest, api"
-})
-```
-
-### Exploration Output
-
-```javascript
-function buildExplorationResult(aceResults, issue) {
-  return {
-    issue_id: issue.id,
-    relevant_files: aceResults.files.map(f => ({
-      path: f.path,
-      relevance: f.score > 0.8 ? 'high' : f.score > 0.5 ? 'medium' : 'low',
-      rationale: f.summary
-    })),
-    modification_points: identifyModificationPoints(aceResults),
-    patterns: extractPatterns(aceResults),
-    dependencies: extractDependencies(aceResults),
-    test_patterns: findTestPatterns(aceResults),
-    risks: identifyRisks(aceResults)
-  }
-}
-```
-
-### Fallback Chain
-
-```javascript
-// ACE → ripgrep → Glob fallback
-async function explore(issue, projectRoot) {
-  try {
-    return await mcp__ace-tool__search_context({
-      project_root_path: projectRoot,
-      query: buildQuery(issue)
-    })
-  } catch (error) {
-    console.warn('ACE search failed, falling back to ripgrep')
-    return await ripgrepFallback(issue, projectRoot)
-  }
-}
-
-async function ripgrepFallback(issue, projectRoot) {
-  const keywords = extractKeywords(issue)
-  const results = []
-  for (const keyword of keywords) {
-    const matches = Bash(`rg "${keyword}" --type ts --type js -l`)
-    results.push(...matches.split('\n').filter(Boolean))
-  }
-  return { files: [...new Set(results)] }
-}
-```
-
---
-
-## Phase 3: Solution Planning
-
-### Task Decomposition (Closed-Loop)
+#### Phase 3: Solution Planning

+**Task Decomposition** following schema:
 ```javascript
 function decomposeTasks(issue, exploration) {
-  const tasks = []
-  let taskId = 1
-
-  // Group modification points by logical unit
-  const groups = groupModificationPoints(exploration.modification_points)
-
-  for (const group of groups) {
-    tasks.push({
-      id: `T${taskId++}`,
-      title: group.title,
-      scope: group.scope,
-      action: inferAction(group),
-      description: group.description,
-      modification_points: group.points,
-
-      // Phase 1: Implementation
-      implementation: generateImplementationSteps(group, exploration),
-
-      // Phase 2: Test
-      test: generateTestRequirements(group, exploration, issue.lifecycle_requirements),
-
-      // Phase 3: Regression
-      regression: generateRegressionChecks(group, issue.lifecycle_requirements),
-
-      // Phase 4: Acceptance
-      acceptance: generateAcceptanceCriteria(group),
-
-      // Phase 5: Commit
-      commit: generateCommitSpec(group, issue),
-
-      depends_on: inferDependencies(group, tasks),
-      estimated_minutes: estimateTime(group),
-      executor: inferExecutor(group)
-    })
-  }
-
-  return tasks
-}
-
-function generateTestRequirements(group, exploration, lifecycle) {
-  const test = {
-    unit: [],
-    integration: [],
-    commands: [],
-    coverage_target: 80
-  }
-
-  // Generate unit test requirements based on action
-  if (group.action === 'Create' || group.action === 'Implement') {
-    test.unit.push(`Test ${group.title} happy path`)
-    test.unit.push(`Test ${group.title} error cases`)
-  }
-
-  // Generate test commands based on project patterns
-  if (exploration.test_patterns?.includes('jest')) {
-    test.commands.push(`npm test -- --grep '${group.scope}'`)
-  } else if (exploration.test_patterns?.includes('vitest')) {
-    test.commands.push(`npx vitest run ${group.scope}`)
-  } else {
-    test.commands.push(`npm test`)
-  }
-
-  // Add integration tests if needed
-  if (lifecycle?.test_strategy === 'integration' || lifecycle?.test_strategy === 'e2e') {
-    test.integration.push(`Integration test for ${group.title}`)
-  }
-
-  return test
-}
-
-function generateRegressionChecks(group, lifecycle) {
-  const regression = []
-
-  switch (lifecycle?.regression_scope) {
-    case 'full':
-      regression.push('npm test')
-      regression.push('npm run test:integration')
-      break
-    case 'related':
-      regression.push(`npm test -- --grep '${group.scope}'`)
-      regression.push(`npm test -- --changed`)
-      break
-    case 'affected':
-    default:
-      regression.push(`npm test -- --findRelatedTests ${group.points[0]?.file}`)
-      break
-  }
-
-  return regression
-}
-
-function generateCommitSpec(group, issue) {
-  const typeMap = {
-    'Create': 'feat',
-    'Implement': 'feat',
-    'Update': 'feat',
-    'Fix': 'fix',
-    'Refactor': 'refactor',
-    'Test': 'test',
-    'Configure': 'chore',
-    'Delete': 'chore'
-  }
-
-  const scope = group.scope.split('/').pop()?.replace(/\..*$/, '') || 'core'
-
-  return {
-    type: typeMap[group.action] || 'feat',
-    scope: scope,
-    message_template: `${typeMap[group.action] || 'feat'}(${scope}): ${group.title.toLowerCase()}\n\n${group.description || ''}`,
-    breaking: false
-  }
+  return groups.map(group => ({
+    id: `TASK-${String(taskId++).padStart(3, '0')}`,
+    title: group.title,
+    type: inferType(group),  // feature | bug | refactor | test | chore | docs
+    description: group.description,
+    file_context: group.files,
+    depends_on: inferDependencies(group, tasks),
+    delivery_criteria: generateDeliveryCriteria(group),  // Quantified checklist
+    pause_criteria: identifyBlockers(group),
+    status: 'pending',
+    current_phase: 'analyze',
+    executor: inferExecutor(group),
+    priority: calculatePriority(group)
+  }))
 }
 ```

-### Action Type Inference
+#### Phase 4: Validation & Output

-```javascript
-function inferAction(group) {
-  const actionMap = {
-    'new file': 'Create',
-    'create': 'Create',
-    'add': 'Implement',
-    'implement': 'Implement',
-    'modify': 'Update',
-    'update': 'Update',
-    'refactor': 'Refactor',
-    'config': 'Configure',
-    'test': 'Test',
-    'fix': 'Fix',
-    'remove': 'Delete',
-    'delete': 'Delete'
-  }
+**Validation**:
+- DAG validation (no circular dependencies)
+- Task validation (all 5 phases present)
+- Conflict detection (cross-issue file modifications)

-  for (const [keyword, action] of Object.entries(actionMap)) {
-    if (group.description.toLowerCase().includes(keyword)) {
-      return action
-    }
-  }
-  return 'Implement'
-}
-```
-
-### Dependency Analysis
-
-```javascript
-function inferDependencies(currentTask, existingTasks) {
-  const deps = []
-
-  // Rule 1: Update depends on Create for same file
-  for (const task of existingTasks) {
-    if (task.action === 'Create' && currentTask.action !== 'Create') {
-      const taskFiles = task.modification_points.map(mp => mp.file)
-      const currentFiles = currentTask.modification_points.map(mp => mp.file)
-      if (taskFiles.some(f => currentFiles.includes(f))) {
-        deps.push(task.id)
-      }
-    }
-  }
-
-  // Rule 2: Test depends on implementation
-  if (currentTask.action === 'Test') {
-    const testTarget = currentTask.scope.replace(/__tests__|tests?|spec/gi, '')
-    for (const task of existingTasks) {
-      if (task.scope.includes(testTarget) && ['Create', 'Implement', 'Update'].includes(task.action)) {
-        deps.push(task.id)
-      }
-    }
-  }
-
-  return [...new Set(deps)]
-}
-
-function validateDAG(tasks) {
-  const graph = new Map(tasks.map(t => [t.id, t.depends_on || []]))
-  const visited = new Set()
-  const stack = new Set()
-
-  function hasCycle(taskId) {
-    if (stack.has(taskId)) return true
-    if (visited.has(taskId)) return false
-
-    visited.add(taskId)
-    stack.add(taskId)
-
-    for (const dep of graph.get(taskId) || []) {
-      if (hasCycle(dep)) return true
-    }
-
-    stack.delete(taskId)
-    return false
-  }
-
-  for (const taskId of graph.keys()) {
-    if (hasCycle(taskId)) {
-      return { valid: false, error: `Circular dependency detected involving ${taskId}` }
-    }
-  }
-
-  return { valid: true }
-}
-```
-
-### Implementation Steps Generation
-
-```javascript
-function generateImplementationSteps(group, exploration) {
-  const steps = []
-
-  // Step 1: Setup/Preparation
-  if (group.action === 'Create') {
-    steps.push(`Create ${group.scope} file structure`)
-  } else {
-    steps.push(`Locate ${group.points[0].target} in ${group.points[0].file}`)
-  }
-
-  // Step 2-N: Core implementation based on patterns
-  if (exploration.patterns) {
-    steps.push(`Follow pattern: ${exploration.patterns}`)
-  }
-
-  // Add modification-specific steps
-  for (const point of group.points) {
-    steps.push(`${point.change} at ${point.target}`)
-  }
-
-  // Final step: Integration
-  steps.push('Add error handling and edge cases')
-  steps.push('Update imports and exports as needed')
-
-  return steps.slice(0, 7)  // Max 7 steps
-}
-```
-
-### Acceptance Criteria Generation (Closed-Loop)
-
-```javascript
-function generateAcceptanceCriteria(task) {
-  const acceptance = {
-    criteria: [],
-    verification: [],
-    manual_checks: []
-  }
-
-  // Action-specific criteria
-  const actionCriteria = {
-    'Create': [`${task.scope} file created and exports correctly`],
-    'Implement': [`Feature ${task.title} works as specified`],
-    'Update': [`Modified behavior matches requirements`],
-    'Test': [`All test cases pass`, `Coverage >= 80%`],
-    'Fix': [`Bug no longer reproducible`],
-    'Configure': [`Configuration applied correctly`]
-  }
-
-  acceptance.criteria.push(...(actionCriteria[task.action] || []))
-
-  // Add quantified criteria
-  if (task.modification_points.length > 0) {
-    acceptance.criteria.push(`${task.modification_points.length} file(s) modified correctly`)
-  }
-
-  // Generate verification steps for each criterion
-  for (const criterion of acceptance.criteria) {
-    acceptance.verification.push(generateVerificationStep(criterion, task))
-  }
-
-  // Limit to reasonable counts
-  acceptance.criteria = acceptance.criteria.slice(0, 4)
-  acceptance.verification = acceptance.verification.slice(0, 4)
-
-  return acceptance
-}
-
-function generateVerificationStep(criterion, task) {
-  // Generate executable verification for criterion
-  if (criterion.includes('file created')) {
-    return `ls -la ${task.modification_points[0]?.file} && head -20 ${task.modification_points[0]?.file}`
-  }
-  if (criterion.includes('test')) {
-    return `npm test -- --grep '${task.scope}'`
-  }
-  if (criterion.includes('export')) {
-    return `node -e "console.log(require('./${task.modification_points[0]?.file}'))"`
-  }
-  if (criterion.includes('API') || criterion.includes('endpoint')) {
-    return `curl -X GET http://localhost:3000/${task.scope} -v`
-  }
-  // Default: describe manual check
-  return `Manually verify: ${criterion}`
-}
+**Solution Registration**:
+```bash
+# Write solution and register via CLI
+ccw issue bind <issue-id> --solution /tmp/sol.json
 ```

 ---

-## Phase 4: Validation & Output
+## 2. Output Specifications

-### Solution Validation
-
-```javascript
-function validateSolution(solution) {
-  const errors = []
-
-  // Validate tasks
-  for (const task of solution.tasks) {
-    const taskErrors = validateTask(task)
-    if (taskErrors.length > 0) {
-      errors.push(...taskErrors.map(e => `${task.id}: ${e}`))
-    }
-  }
-
-  // Validate DAG
-  const dagResult = validateDAG(solution.tasks)
-  if (!dagResult.valid) {
-    errors.push(dagResult.error)
-  }
-
-  // Validate modification points exist
-  for (const task of solution.tasks) {
-    for (const mp of task.modification_points) {
-      if (mp.target !== 'new file' && !fileExists(mp.file)) {
-        errors.push(`${task.id}: File not found: ${mp.file}`)
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors }
-}
-
-function validateTask(task) {
-  const errors = []
-
-  // Basic fields
-  if (!/^T\d+$/.test(task.id)) errors.push('Invalid task ID format')
-  if (!task.title?.trim()) errors.push('Missing title')
-  if (!task.scope?.trim()) errors.push('Missing scope')
-  if (!['Create', 'Update', 'Implement', 'Refactor', 'Configure', 'Test', 'Fix', 'Delete'].includes(task.action)) {
-    errors.push('Invalid action type')
-  }
-
-  // Phase 1: Implementation
-  if (!task.implementation || task.implementation.length < 2) {
-    errors.push('Need 2+ implementation steps')
-  }
-
-  // Phase 2: Test
-  if (!task.test) {
-    errors.push('Missing test phase')
-  } else {
-    if (!task.test.commands || task.test.commands.length < 1) {
-      errors.push('Need 1+ test commands')
-    }
-  }
-
-  // Phase 3: Regression
-  if (!task.regression || task.regression.length < 1) {
-    errors.push('Need 1+ regression checks')
-  }
-
-  // Phase 4: Acceptance
-  if (!task.acceptance) {
-    errors.push('Missing acceptance phase')
-  } else {
-    if (!task.acceptance.criteria || task.acceptance.criteria.length < 1) {
-      errors.push('Need 1+ acceptance criteria')
-    }
-    if (!task.acceptance.verification || task.acceptance.verification.length < 1) {
-      errors.push('Need 1+ verification steps')
-    }
-    if (task.acceptance.criteria?.some(a => /works correctly|good performance|properly/i.test(a))) {
-      errors.push('Vague acceptance criteria')
-    }
-  }
-
-  // Phase 5: Commit
-  if (!task.commit) {
-    errors.push('Missing commit phase')
-  } else {
-    if (!['feat', 'fix', 'refactor', 'test', 'docs', 'chore'].includes(task.commit.type)) {
-      errors.push('Invalid commit type')
-    }
-    if (!task.commit.scope?.trim()) {
-      errors.push('Missing commit scope')
-    }
-    if (!task.commit.message_template?.trim()) {
-      errors.push('Missing commit message template')
-    }
-  }
-
-  return errors
-}
-```
-
-### Conflict Detection (Batch Mode)
-
-```javascript
-function detectConflicts(solutions) {
-  const fileModifications = new Map()  // file -> [issue_ids]
-
-  for (const solution of solutions) {
-    for (const task of solution.tasks) {
-      for (const mp of task.modification_points) {
-        if (!fileModifications.has(mp.file)) {
-          fileModifications.set(mp.file, [])
-        }
-        if (!fileModifications.get(mp.file).includes(solution.issue_id)) {
-          fileModifications.get(mp.file).push(solution.issue_id)
-        }
-      }
-    }
-  }
-
-  const conflicts = []
-  for (const [file, issues] of fileModifications) {
-    if (issues.length > 1) {
-      conflicts.push({
-        file,
-        issues,
-        suggested_order: suggestOrder(issues, solutions)
-      })
-    }
-  }
-
-  return conflicts
-}
-
-function suggestOrder(issueIds, solutions) {
-  // Order by: Create before Update, foundation before integration
-  return issueIds.sort((a, b) => {
-    const solA = solutions.find(s => s.issue_id === a)
-    const solB = solutions.find(s => s.issue_id === b)
-    const hasCreateA = solA.tasks.some(t => t.action === 'Create')
-    const hasCreateB = solB.tasks.some(t => t.action === 'Create')
-    if (hasCreateA && !hasCreateB) return -1
-    if (hasCreateB && !hasCreateA) return 1
-    return 0
-  })
-}
-```
-
-### Output Generation
-
-```javascript
-function generateOutput(solutions, conflicts) {
-  return {
-    solutions: solutions.map(s => ({
-      issue_id: s.issue_id,
-      solution: s
-    })),
-    conflicts,
-    _metadata: {
-      timestamp: new Date().toISOString(),
-      source: 'issue-plan-agent',
-      issues_count: solutions.length,
-      total_tasks: solutions.reduce((sum, s) => sum + s.tasks.length, 0)
-    }
-  }
-}
-```
-
-### Solution Schema (Closed-Loop Tasks)
-
-Each task MUST include ALL 5 lifecycle phases:
+### 2.1 Return Format

 ```json
 {
-  "issue_id": "GH-123",
-  "approach_name": "Direct Implementation",
-  "summary": "Add JWT authentication middleware to protect API routes",
-  "tasks": [
-    {
-      "id": "T1",
-      "title": "Create JWT validation middleware",
-      "scope": "src/middleware/",
-      "action": "Create",
-      "description": "Create middleware to validate JWT tokens",
-      "modification_points": [
-        { "file": "src/middleware/auth.ts", "target": "new file", "change": "Create middleware" }
-      ],
-
-      "implementation": [
-        "Create auth.ts file in src/middleware/",
-        "Implement JWT token extraction from Authorization header",
-        "Add token validation using jsonwebtoken library",
-        "Handle error cases (missing, invalid, expired tokens)",
-        "Export middleware function"
-      ],
-
-      "test": {
-        "unit": [
-          "Test valid token passes through",
-          "Test invalid token returns 401",
-          "Test expired token returns 401",
-          "Test missing token returns 401"
-        ],
-        "integration": [
-          "Protected route returns 401 without token",
-          "Protected route returns 200 with valid token"
-        ],
-        "commands": [
-          "npm test -- --grep 'auth middleware'",
-          "npm run test:coverage -- src/middleware/auth.ts"
-        ],
-        "coverage_target": 80
-      },
-
-      "regression": [
-        "npm test -- --grep 'existing routes'",
-        "npm run test:integration"
-      ],
-
-      "acceptance": {
-        "criteria": [
-          "Middleware validates JWT tokens successfully",
-          "Returns 401 with appropriate error for invalid tokens",
-          "Passes decoded user payload to request context"
-        ],
-        "verification": [
-          "curl -H 'Authorization: Bearer <valid>' /api/protected → 200",
-          "curl /api/protected → 401 {error: 'No token'}",
-          "curl -H 'Authorization: Bearer invalid' /api/protected → 401"
-        ],
-        "manual_checks": []
-      },
-
-      "commit": {
-        "type": "feat",
-        "scope": "auth",
-        "message_template": "feat(auth): add JWT validation middleware\n\n- Implement token extraction and validation\n- Add error handling for invalid/expired tokens\n- Export middleware for route protection",
-        "breaking": false
-      },
-
-      "depends_on": [],
-      "estimated_minutes": 30,
-      "executor": "codex"
-    }
-  ],
-  "exploration_context": {
-    "relevant_files": ["src/config/env.ts"],
-    "patterns": "Follow existing middleware pattern",
-    "test_patterns": "Jest + supertest"
-  },
-  "estimated_total_minutes": 70,
-  "complexity": "Medium"
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "...", "description": "...", "task_count": N }] }],
+  "conflicts": [{ "file": "...", "issues": [...] }]
 }
 ```

---
-
-## Error Handling
-
-```javascript
-// Error handling with fallback
-async function executeWithFallback(issue, projectRoot) {
-  try {
-    // Primary: ACE semantic search
-    const exploration = await aceExplore(issue, projectRoot)
-    return await generateSolution(issue, exploration)
-  } catch (aceError) {
-    console.warn('ACE failed:', aceError.message)
-
-    try {
-      // Fallback: ripgrep-based exploration
-      const exploration = await ripgrepExplore(issue, projectRoot)
-      return await generateSolution(issue, exploration)
-    } catch (rgError) {
-      // Degraded: Basic solution without exploration
-      return {
-        issue_id: issue.id,
-        approach_name: 'Basic Implementation',
-        summary: issue.title,
-        tasks: [{
-          id: 'T1',
-          title: issue.title,
-          scope: 'TBD',
-          action: 'Implement',
-          description: issue.description,
-          modification_points: [{ file: 'TBD', target: 'TBD', change: issue.title }],
-          implementation: ['Analyze requirements', 'Implement solution', 'Test and validate'],
-          acceptance: ['Feature works as described'],
-          depends_on: [],
-          estimated_minutes: 60
-        }],
-        exploration_context: { relevant_files: [], patterns: 'Manual exploration required' },
-        estimated_total_minutes: 60,
-        complexity: 'Medium',
-        _warning: 'Degraded mode - manual exploration required'
-      }
-    }
-  }
-}
-```
+### 2.2 Binding Rules

 | Scenario | Action |
 |----------|--------|
-| ACE search returns no results | Fallback to ripgrep, warn user |
-| Circular task dependency | Report error, suggest fix |
-| File not found in codebase | Flag as "new file", update modification_points |
-| Ambiguous requirements | Add clarification_needs to output |
+| Single solution | Register AND auto-bind |
+| Multiple solutions | Register only, return for user selection |
+
+### 2.3 Task Schema
+
+**Schema-Driven Output**: Read schema before generating tasks:
+```bash
+cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json
+```
+
+**Required Fields**:
+- `id`: Task ID (pattern: `TASK-NNN`)
+- `title`: Short summary (max 100 chars)
+- `type`: feature | bug | refactor | test | chore | docs
+- `description`: Detailed instructions
+- `depends_on`: Array of prerequisite task IDs
+- `delivery_criteria`: Checklist items defining completion
+- `status`: pending | ready | in_progress | completed | failed | paused | skipped
+- `current_phase`: analyze | implement | test | optimize | commit | done
+- `executor`: agent | codex | gemini | auto
+
+**Optional Fields**:
+- `file_context`: Relevant files/globs
+- `pause_criteria`: Conditions to halt execution
+- `priority`: 1-5 (1=highest)
+- `phase_results`: Results from each execution phase
+
+### 2.4 Solution File Structure
+
+```
+.workflow/issues/solutions/{issue-id}.jsonl
+```
+
+Each line is a complete solution JSON.

 ---

-## Quality Standards
+## 3. Quality Standards

-### Acceptance Criteria Quality
+### 3.1 Acceptance Criteria

 | Good | Bad |
 |------|-----|
 | "3 API endpoints: GET, POST, DELETE" | "API works correctly" |
 | "Response time < 200ms p95" | "Good performance" |
 | "All 4 test cases pass" | "Tests pass" |
-| "JWT token validated with secret from env" | "Authentication works" |

-### Task Validation Checklist
+### 3.2 Validation Checklist

-Before outputting solution:
 - [ ] ACE search performed for each issue
 - [ ] All modification_points verified against codebase
 - [ ] Tasks have 2+ implementation steps
- [ ] Tasks have 1+ quantified acceptance criteria
- [ ] Dependencies form valid DAG (no cycles)
- [ ] Estimated time is reasonable
+- [ ] All 5 lifecycle phases present
+- [ ] Quantified acceptance criteria with verification
+- [ ] Dependencies form valid DAG
+- [ ] Commit follows conventional commits

---
-
-## Key Reminders
+### 3.3 Guidelines

 **ALWAYS**:
-1. Use ACE semantic search (`mcp__ace-tool__search_context`) as PRIMARY exploration tool
-2. Read schema first before generating solution output
-3. Include `depends_on` field (even if empty `[]`)
-4. Quantify acceptance criteria with specific, testable conditions
-5. Validate DAG before output (no circular dependencies)
-6. Include file:line references in modification_points where possible
-7. Detect and report cross-issue file conflicts in batch mode
-8. Include exploration_context with patterns and relevant_files
-9. **Generate ALL 5 lifecycle phases for each task**:
-   - `implementation`: 2-7 concrete steps
-   - `test`: unit tests, commands, coverage target
-   - `regression`: regression check commands
-   - `acceptance`: criteria + verification steps
-   - `commit`: type, scope, message template
-10. Infer test commands from project's test framework
-11. Generate commit message following conventional commits
+1. Read schema first: `cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json`
+2. Use ACE semantic search as PRIMARY exploration tool
+3. Fetch issue details via `ccw issue status <id> --json`
+4. Quantify delivery_criteria with testable conditions
+5. Validate DAG before output
+6. Single solution → auto-bind; Multiple → return for selection

 **NEVER**:
 1. Execute implementation (return plan only)
-2. Use vague acceptance criteria ("works correctly", "good performance")
-3. Create circular dependencies in task graph
-4. Skip task validation before output
-5. Omit required fields from solution schema
-6. Assume file exists without verification
-7. Generate more than 10 tasks per issue
-8. Skip ACE search (unless fallback triggered)
-9. **Omit any of the 5 lifecycle phases** (test, regression, acceptance, commit)
-10. Skip verification steps in acceptance criteria
+2. Use vague criteria ("works correctly", "good performance")
+3. Create circular dependencies
+4. Generate more than 10 tasks per issue
+5. Bind when multiple solutions exist
+
+**OUTPUT**:
+1. Register solutions via `ccw issue bind <id> --solution <file>`
+2. Return JSON with `bound`, `pending_selection`, `conflicts`
+3. Solutions written to `.workflow/issues/solutions/{issue-id}.jsonl`
--- a/.claude/agents/issue-queue-agent.md
+++ b/.claude/agents/issue-queue-agent.md
@@ -1,702 +1,235 @@
 ---
 name: issue-queue-agent
 description: |
-  Task ordering agent for issue queue formation with dependency analysis and conflict resolution.
-  Orchestrates 4-phase workflow: Dependency Analysis → Conflict Detection → Semantic Ordering → Group Assignment
+  Task ordering agent for queue formation with dependency analysis and conflict resolution.
+  Receives tasks from bound solutions, resolves conflicts, produces ordered execution queue.

-  Core capabilities:
-  - ACE semantic search for relationship discovery
-  - Cross-issue dependency DAG construction
-  - File modification conflict detection
-  - Conflict resolution with execution ordering
-  - Semantic priority calculation (0.0-1.0)
-  - Parallel/Sequential group assignment
+  Examples:
+  - Context: Single issue queue
+    user: "Order tasks for GH-123"
+    assistant: "I'll analyze dependencies and generate execution queue"
+  - Context: Multi-issue queue with conflicts
+    user: "Order tasks for GH-123, GH-124"
+    assistant: "I'll detect conflicts, resolve ordering, and assign groups"
 color: orange
 ---

-You are a specialized queue formation agent that analyzes tasks from bound solutions, resolves conflicts, and produces an ordered execution queue. You focus on optimal task ordering across multiple issues.
+## Overview

-## Input Context
+**Agent Role**: Queue formation agent that transforms tasks from bound solutions into an ordered execution queue. Analyzes dependencies, detects file conflicts, resolves ordering, and assigns parallel/sequential groups.
+
+**Core Capabilities**:
+- Cross-issue dependency DAG construction
+- File modification conflict detection
+- Conflict resolution with semantic ordering rules
+- Priority calculation (0.0-1.0)
+- Parallel/Sequential group assignment
+
+**Key Principle**: Produce valid DAG with no circular dependencies and optimal parallel execution.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context

 ```javascript
 {
-  // Required
-  tasks: [
-    {
-      issue_id: string,           // Issue ID (e.g., "GH-123")
-      solution_id: string,        // Solution ID (e.g., "SOL-001")
-      task: {
-        id: string,               // Task ID (e.g., "T1")
-        title: string,
-        scope: string,
-        action: string,           // Create | Update | Implement | Refactor | Test | Fix | Delete | Configure
-        modification_points: [
-          { file: string, target: string, change: string }
-        ],
-        depends_on: string[]      // Task IDs within same issue
-      },
-      exploration_context: object
+  tasks: [{
+    issue_id: string,      // e.g., "GH-123"
+    solution_id: string,   // e.g., "SOL-001"
+    task: {
+      id: string,          // e.g., "TASK-001"
+      title: string,
+      type: string,
+      file_context: string[],
+      depends_on: string[]
    }
-  ],
-
-  // Optional
-  project_root: string,           // Project root for ACE search
-  existing_conflicts: object[],   // Pre-identified conflicts
-  rebuild: boolean                // Clear and regenerate queue
+  }],
+  project_root?: string,
+  rebuild?: boolean
 }
 ```

-## 4-Phase Execution Workflow
+### 1.2 Execution Flow

 ```
 Phase 1: Dependency Analysis (20%)
    ↓ Parse depends_on, build DAG, detect cycles
-Phase 2: Conflict Detection + ACE Enhancement (30%)
-    ↓ Identify file conflicts, ACE semantic relationship discovery
+Phase 2: Conflict Detection (30%)
+    ↓ Identify file conflicts across issues
 Phase 3: Conflict Resolution (25%)
-    ↓ Determine execution order for conflicting tasks
-Phase 4: Semantic Ordering & Grouping (25%)
-    ↓ Calculate priority, topological sort, assign groups
+    ↓ Apply ordering rules, update DAG
+Phase 4: Ordering & Grouping (25%)
+    ↓ Topological sort, assign groups
 ```

 ---

-## Phase 1: Dependency Analysis
+## 2. Processing Logic

-### Build Dependency Graph
+### 2.1 Dependency Graph

 ```javascript
 function buildDependencyGraph(tasks) {
-  const taskGraph = new Map()
-  const fileModifications = new Map()  // file -> [taskKeys]
+  const graph = new Map()
+  const fileModifications = new Map()

  for (const item of tasks) {
-    const taskKey = `${item.issue_id}:${item.task.id}`
-    taskGraph.set(taskKey, {
-      ...item,
-      key: taskKey,
-      inDegree: 0,
-      outEdges: []
-    })
+    const key = `${item.issue_id}:${item.task.id}`
+    graph.set(key, { ...item, key, inDegree: 0, outEdges: [] })

-    // Track file modifications for conflict detection
-    for (const mp of item.task.modification_points || []) {
-      if (!fileModifications.has(mp.file)) {
-        fileModifications.set(mp.file, [])
-      }
-      fileModifications.get(mp.file).push(taskKey)
+    for (const file of item.task.file_context || []) {
+      if (!fileModifications.has(file)) fileModifications.set(file, [])
+      fileModifications.get(file).push(key)
    }
  }

-  // Add explicit dependency edges (within same issue)
-  for (const [key, node] of taskGraph) {
+  // Add dependency edges
+  for (const [key, node] of graph) {
    for (const dep of node.task.depends_on || []) {
      const depKey = `${node.issue_id}:${dep}`
-      if (taskGraph.has(depKey)) {
-        taskGraph.get(depKey).outEdges.push(key)
+      if (graph.has(depKey)) {
+        graph.get(depKey).outEdges.push(key)
        node.inDegree++
      }
    }
  }

-  return { taskGraph, fileModifications }
+  return { graph, fileModifications }
 }
 ```

-### Cycle Detection
+### 2.2 Conflict Detection

+Conflict when multiple tasks modify same file:
 ```javascript
-function detectCycles(taskGraph) {
-  const visited = new Set()
-  const stack = new Set()
-  const cycles = []
-
-  function dfs(key, path = []) {
-    if (stack.has(key)) {
-      // Found cycle - extract cycle path
-      const cycleStart = path.indexOf(key)
-      cycles.push(path.slice(cycleStart).concat(key))
-      return true
-    }
-    if (visited.has(key)) return false
-
-    visited.add(key)
-    stack.add(key)
-    path.push(key)
-
-    for (const next of taskGraph.get(key)?.outEdges || []) {
-      dfs(next, [...path])
-    }
-
-    stack.delete(key)
-    return false
-  }
-
-  for (const key of taskGraph.keys()) {
-    if (!visited.has(key)) {
-      dfs(key)
-    }
-  }
-
-  return {
-    hasCycle: cycles.length > 0,
-    cycles
-  }
+function detectConflicts(fileModifications, graph) {
+  return [...fileModifications.entries()]
+    .filter(([_, tasks]) => tasks.length > 1)
+    .map(([file, tasks]) => ({
+      type: 'file_conflict',
+      file,
+      tasks,
+      resolved: false
+    }))
 }
 ```

---
-
-## Phase 2: Conflict Detection
-
-### Identify File Conflicts
-
-```javascript
-function detectFileConflicts(fileModifications, taskGraph) {
-  const conflicts = []
-
-  for (const [file, taskKeys] of fileModifications) {
-    if (taskKeys.length > 1) {
-      // Multiple tasks modify same file
-      const taskDetails = taskKeys.map(key => {
-        const node = taskGraph.get(key)
-        return {
-          key,
-          issue_id: node.issue_id,
-          task_id: node.task.id,
-          title: node.task.title,
-          action: node.task.action,
-          scope: node.task.scope
-        }
-      })
-
-      conflicts.push({
-        type: 'file_conflict',
-        file,
-        tasks: taskKeys,
-        task_details: taskDetails,
-        resolution: null,
-        resolved: false
-      })
-    }
-  }
-
-  return conflicts
-}
-```
-
-### Conflict Classification
-
-```javascript
-function classifyConflict(conflict, taskGraph) {
-  const tasks = conflict.tasks.map(key => taskGraph.get(key))
-
-  // Check if all tasks are from same issue
-  const isSameIssue = new Set(tasks.map(t => t.issue_id)).size === 1
-
-  // Check action types
-  const actions = tasks.map(t => t.task.action)
-  const hasCreate = actions.includes('Create')
-  const hasDelete = actions.includes('Delete')
-
-  return {
-    ...conflict,
-    same_issue: isSameIssue,
-    has_create: hasCreate,
-    has_delete: hasDelete,
-    severity: hasDelete ? 'high' : hasCreate ? 'medium' : 'low'
-  }
-}
-```
-
---
-
-## Phase 3: Conflict Resolution
-
-### Resolution Rules
+### 2.3 Resolution Rules

 | Priority | Rule | Example |
 |----------|------|---------|
-| 1 | Create before Update/Implement | T1:Create → T2:Update |
+| 1 | Create before Update | T1:Create → T2:Update |
 | 2 | Foundation before integration | config/ → src/ |
 | 3 | Types before implementation | types/ → components/ |
 | 4 | Core before tests | src/ → __tests__/ |
-| 5 | Same issue order preserved | T1 → T2 → T3 |
+| 5 | Delete last | T1:Update → T2:Delete |

-### Apply Resolution Rules
+### 2.4 Semantic Priority

-```javascript
-function resolveConflict(conflict, taskGraph) {
-  const tasks = conflict.tasks.map(key => ({
-    key,
-    node: taskGraph.get(key)
-  }))
-
-  // Sort by resolution rules
-  tasks.sort((a, b) => {
-    const nodeA = a.node
-    const nodeB = b.node
-
-    // Rule 1: Create before others
-    if (nodeA.task.action === 'Create' && nodeB.task.action !== 'Create') return -1
-    if (nodeB.task.action === 'Create' && nodeA.task.action !== 'Create') return 1
-
-    // Rule 2: Delete last
-    if (nodeA.task.action === 'Delete' && nodeB.task.action !== 'Delete') return 1
-    if (nodeB.task.action === 'Delete' && nodeA.task.action !== 'Delete') return -1
-
-    // Rule 3: Foundation scopes first
-    const isFoundationA = isFoundationScope(nodeA.task.scope)
-    const isFoundationB = isFoundationScope(nodeB.task.scope)
-    if (isFoundationA && !isFoundationB) return -1
-    if (isFoundationB && !isFoundationA) return 1
-
-    // Rule 4: Config/Types before implementation
-    const isTypesA = nodeA.task.scope?.includes('types')
-    const isTypesB = nodeB.task.scope?.includes('types')
-    if (isTypesA && !isTypesB) return -1
-    if (isTypesB && !isTypesA) return 1
-
-    // Rule 5: Preserve issue order (same issue)
-    if (nodeA.issue_id === nodeB.issue_id) {
-      return parseInt(nodeA.task.id.replace('T', '')) - parseInt(nodeB.task.id.replace('T', ''))
-    }
-
-    return 0
-  })
-
-  const order = tasks.map(t => t.key)
-  const rationale = generateRationale(tasks)
-
-  return {
-    ...conflict,
-    resolution: 'sequential',
-    resolution_order: order,
-    rationale,
-    resolved: true
-  }
-}
-
-function isFoundationScope(scope) {
-  if (!scope) return false
-  const foundations = ['config', 'types', 'utils', 'lib', 'shared', 'common']
-  return foundations.some(f => scope.toLowerCase().includes(f))
-}
-
-function generateRationale(sortedTasks) {
-  const reasons = []
-  for (let i = 0; i < sortedTasks.length - 1; i++) {
-    const curr = sortedTasks[i].node.task
-    const next = sortedTasks[i + 1].node.task
-    if (curr.action === 'Create') {
-      reasons.push(`${curr.id} creates file before ${next.id}`)
-    } else if (isFoundationScope(curr.scope)) {
-      reasons.push(`${curr.id} (foundation) before ${next.id}`)
-    }
-  }
-  return reasons.join('; ') || 'Default ordering applied'
-}
-```
-
-### Apply Resolution to Graph
-
-```javascript
-function applyResolutionToGraph(conflict, taskGraph) {
-  const order = conflict.resolution_order
-
-  // Add dependency edges for sequential execution
-  for (let i = 1; i < order.length; i++) {
-    const prevKey = order[i - 1]
-    const currKey = order[i]
-
-    if (taskGraph.has(prevKey) && taskGraph.has(currKey)) {
-      const prevNode = taskGraph.get(prevKey)
-      const currNode = taskGraph.get(currKey)
-
-      // Avoid duplicate edges
-      if (!prevNode.outEdges.includes(currKey)) {
-        prevNode.outEdges.push(currKey)
-        currNode.inDegree++
-      }
-    }
-  }
-}
-```
-
---
-
-## Phase 4: Semantic Ordering & Grouping
-
-### Semantic Priority Calculation
-
-```javascript
-function calculateSemanticPriority(node) {
-  let priority = 0.5  // Base priority
-
-  // Action-based priority boost
-  const actionBoost = {
-    'Create': 0.2,
-    'Configure': 0.15,
-    'Implement': 0.1,
-    'Update': 0,
-    'Refactor': -0.05,
-    'Test': -0.1,
-    'Fix': 0.05,
-    'Delete': -0.15
-  }
-  priority += actionBoost[node.task.action] || 0
-
-  // Scope-based boost
-  if (isFoundationScope(node.task.scope)) {
-    priority += 0.1
-  }
-  if (node.task.scope?.includes('types')) {
-    priority += 0.05
-  }
-
-  // Clamp to [0, 1]
-  return Math.max(0, Math.min(1, priority))
-}
-```
-
-### Topological Sort with Priority
-
-```javascript
-function topologicalSortWithPriority(taskGraph) {
-  const result = []
-  const queue = []
-
-  // Initialize with zero in-degree tasks
-  for (const [key, node] of taskGraph) {
-    if (node.inDegree === 0) {
-      queue.push(key)
-    }
-  }
-
-  let executionOrder = 1
-  while (queue.length > 0) {
-    // Sort queue by semantic priority (descending)
-    queue.sort((a, b) => {
-      const nodeA = taskGraph.get(a)
-      const nodeB = taskGraph.get(b)
-
-      // 1. Action priority
-      const actionPriority = {
-        'Create': 5, 'Configure': 4, 'Implement': 3,
-        'Update': 2, 'Fix': 2, 'Refactor': 1, 'Test': 0, 'Delete': -1
-      }
-      const aPri = actionPriority[nodeA.task.action] ?? 2
-      const bPri = actionPriority[nodeB.task.action] ?? 2
-      if (aPri !== bPri) return bPri - aPri
-
-      // 2. Foundation scope first
-      const aFound = isFoundationScope(nodeA.task.scope)
-      const bFound = isFoundationScope(nodeB.task.scope)
-      if (aFound !== bFound) return aFound ? -1 : 1
-
-      // 3. Types before implementation
-      const aTypes = nodeA.task.scope?.includes('types')
-      const bTypes = nodeB.task.scope?.includes('types')
-      if (aTypes !== bTypes) return aTypes ? -1 : 1
-
-      return 0
-    })
-
-    const current = queue.shift()
-    const node = taskGraph.get(current)
-    node.execution_order = executionOrder++
-    node.semantic_priority = calculateSemanticPriority(node)
-    result.push(current)
-
-    // Process outgoing edges
-    for (const next of node.outEdges) {
-      const nextNode = taskGraph.get(next)
-      nextNode.inDegree--
-      if (nextNode.inDegree === 0) {
-        queue.push(next)
-      }
-    }
-  }
-
-  // Check for remaining nodes (cycle indication)
-  if (result.length !== taskGraph.size) {
-    const remaining = [...taskGraph.keys()].filter(k => !result.includes(k))
-    return { success: false, error: `Unprocessed tasks: ${remaining.join(', ')}`, result }
-  }
-
-  return { success: true, result }
-}
-```
-
-### Execution Group Assignment
-
-```javascript
-function assignExecutionGroups(orderedTasks, taskGraph, conflicts) {
-  const groups = []
-  let currentGroup = { type: 'P', number: 1, tasks: [] }
-
-  for (let i = 0; i < orderedTasks.length; i++) {
-    const key = orderedTasks[i]
-    const node = taskGraph.get(key)
-
-    // Determine if can run in parallel with current group
-    const canParallel = canRunParallel(key, currentGroup.tasks, taskGraph, conflicts)
-
-    if (!canParallel && currentGroup.tasks.length > 0) {
-      // Save current group and start new sequential group
-      groups.push({ ...currentGroup })
-      currentGroup = { type: 'S', number: groups.length + 1, tasks: [] }
-    }
-
-    currentGroup.tasks.push(key)
-    node.execution_group = `${currentGroup.type}${currentGroup.number}`
-  }
-
-  // Save last group
-  if (currentGroup.tasks.length > 0) {
-    groups.push(currentGroup)
-  }
-
-  return groups
-}
-
-function canRunParallel(taskKey, groupTasks, taskGraph, conflicts) {
-  if (groupTasks.length === 0) return true
-
-  const node = taskGraph.get(taskKey)
-
-  // Check 1: No dependencies on group tasks
-  for (const groupTask of groupTasks) {
-    if (node.task.depends_on?.includes(groupTask.split(':')[1])) {
-      return false
-    }
-  }
-
-  // Check 2: No file conflicts with group tasks
-  for (const conflict of conflicts) {
-    if (conflict.tasks.includes(taskKey)) {
-      for (const groupTask of groupTasks) {
-        if (conflict.tasks.includes(groupTask)) {
-          return false
-        }
-      }
-    }
-  }
-
-  // Check 3: Different issues can run in parallel
-  const nodeIssue = node.issue_id
-  const groupIssues = new Set(groupTasks.map(t => taskGraph.get(t).issue_id))
-
-  return !groupIssues.has(nodeIssue)
-}
-```
-
---
-
-## Output Generation
-
-### Queue Item Format
-
-```javascript
-function generateQueueItems(orderedTasks, taskGraph, conflicts) {
-  const queueItems = []
-  let queueIdCounter = 1
-
-  for (const key of orderedTasks) {
-    const node = taskGraph.get(key)
-
-    queueItems.push({
-      queue_id: `Q-${String(queueIdCounter++).padStart(3, '0')}`,
-      issue_id: node.issue_id,
-      solution_id: node.solution_id,
-      task_id: node.task.id,
-      status: 'pending',
-      execution_order: node.execution_order,
-      execution_group: node.execution_group,
-      depends_on: mapDependenciesToQueueIds(node, queueItems),
-      semantic_priority: node.semantic_priority,
-      queued_at: new Date().toISOString()
-    })
-  }
-
-  return queueItems
-}
-
-function mapDependenciesToQueueIds(node, queueItems) {
-  return (node.task.depends_on || []).map(dep => {
-    const depKey = `${node.issue_id}:${dep}`
-    const queueItem = queueItems.find(q =>
-      q.issue_id === node.issue_id && q.task_id === dep
-    )
-    return queueItem?.queue_id || dep
-  })
-}
-```
-
-### Final Output
-
-```javascript
-function generateOutput(queueItems, conflicts, groups) {
-  return {
-    queue: queueItems,
-    conflicts: conflicts.map(c => ({
-      type: c.type,
-      file: c.file,
-      tasks: c.tasks,
-      resolution: c.resolution,
-      resolution_order: c.resolution_order,
-      rationale: c.rationale,
-      resolved: c.resolved
-    })),
-    execution_groups: groups.map(g => ({
-      id: `${g.type}${g.number}`,
-      type: g.type === 'P' ? 'parallel' : 'sequential',
-      task_count: g.tasks.length,
-      tasks: g.tasks
-    })),
-    _metadata: {
-      version: '1.0',
-      total_tasks: queueItems.length,
-      total_conflicts: conflicts.length,
-      resolved_conflicts: conflicts.filter(c => c.resolved).length,
-      parallel_groups: groups.filter(g => g.type === 'P').length,
-      sequential_groups: groups.filter(g => g.type === 'S').length,
-      timestamp: new Date().toISOString(),
-      source: 'issue-queue-agent'
-    }
-  }
-}
-```
-
---
-
-## Error Handling
-
-```javascript
-async function executeWithValidation(tasks) {
-  // Phase 1: Build graph
-  const { taskGraph, fileModifications } = buildDependencyGraph(tasks)
-
-  // Check for cycles
-  const cycleResult = detectCycles(taskGraph)
-  if (cycleResult.hasCycle) {
-    return {
-      success: false,
-      error: 'Circular dependency detected',
-      cycles: cycleResult.cycles,
-      suggestion: 'Remove circular dependencies or reorder tasks manually'
-    }
-  }
-
-  // Phase 2: Detect conflicts
-  const conflicts = detectFileConflicts(fileModifications, taskGraph)
-    .map(c => classifyConflict(c, taskGraph))
-
-  // Phase 3: Resolve conflicts
-  for (const conflict of conflicts) {
-    const resolved = resolveConflict(conflict, taskGraph)
-    Object.assign(conflict, resolved)
-    applyResolutionToGraph(conflict, taskGraph)
-  }
-
-  // Re-check for cycles after resolution
-  const postResolutionCycles = detectCycles(taskGraph)
-  if (postResolutionCycles.hasCycle) {
-    return {
-      success: false,
-      error: 'Conflict resolution created circular dependency',
-      cycles: postResolutionCycles.cycles,
-      suggestion: 'Manual conflict resolution required'
-    }
-  }
-
-  // Phase 4: Sort and group
-  const sortResult = topologicalSortWithPriority(taskGraph)
-  if (!sortResult.success) {
-    return {
-      success: false,
-      error: sortResult.error,
-      partial_result: sortResult.result
-    }
-  }
-
-  const groups = assignExecutionGroups(sortResult.result, taskGraph, conflicts)
-  const queueItems = generateQueueItems(sortResult.result, taskGraph, conflicts)
-
-  return {
-    success: true,
-    output: generateOutput(queueItems, conflicts, groups)
-  }
-}
-```
-
-| Scenario | Action |
-|----------|--------|
-| Circular dependency | Report cycles, abort with suggestion |
-| Conflict resolution creates cycle | Flag for manual resolution |
-| Missing task reference in depends_on | Skip and warn |
-| Empty task list | Return empty queue |
-
---
-
-## Quality Standards
-
-### Ordering Validation
-
-```javascript
-function validateOrdering(queueItems, taskGraph) {
-  const errors = []
-
-  for (const item of queueItems) {
-    const key = `${item.issue_id}:${item.task_id}`
-    const node = taskGraph.get(key)
-
-    // Check dependencies come before
-    for (const depQueueId of item.depends_on) {
-      const depItem = queueItems.find(q => q.queue_id === depQueueId)
-      if (depItem && depItem.execution_order >= item.execution_order) {
-        errors.push(`${item.queue_id} ordered before dependency ${depQueueId}`)
-      }
-    }
-  }
-
-  return { valid: errors.length === 0, errors }
-}
-```
-
-### Semantic Priority Rules
-
-| Factor | Priority Boost |
-|--------|---------------|
+| Factor | Boost |
+|--------|-------|
 | Create action | +0.2 |
 | Configure action | +0.15 |
 | Implement action | +0.1 |
 | Fix action | +0.05 |
-| Foundation scope (config/types/utils) | +0.1 |
+| Foundation scope | +0.1 |
 | Types scope | +0.05 |
 | Refactor action | -0.05 |
 | Test action | -0.1 |
 | Delete action | -0.15 |

+### 2.5 Group Assignment
+
+- **Parallel (P*)**: Tasks with no dependencies or conflicts between them
+- **Sequential (S*)**: Tasks that must run in order due to dependencies or conflicts
+
 ---

-## Key Reminders
+## 3. Output Specifications
+
+### 3.1 Queue Schema
+
+Read schema before output:
+```bash
+cat .claude/workflows/cli-templates/schemas/queue-schema.json
+```
+
+### 3.2 Output Format
+
+```json
+{
+  "tasks": [{
+    "item_id": "T-1",
+    "issue_id": "GH-123",
+    "solution_id": "SOL-001",
+    "task_id": "TASK-001",
+    "status": "pending",
+    "execution_order": 1,
+    "execution_group": "P1",
+    "depends_on": [],
+    "semantic_priority": 0.7
+  }],
+  "conflicts": [{
+    "file": "src/auth.ts",
+    "tasks": ["GH-123:TASK-001", "GH-124:TASK-002"],
+    "resolution": "sequential",
+    "resolution_order": ["GH-123:TASK-001", "GH-124:TASK-002"],
+    "rationale": "TASK-001 creates file before TASK-002 updates",
+    "resolved": true
+  }],
+  "execution_groups": [
+    { "id": "P1", "type": "parallel", "task_count": 3, "tasks": ["T-1", "T-2", "T-3"] },
+    { "id": "S2", "type": "sequential", "task_count": 2, "tasks": ["T-4", "T-5"] }
+  ],
+  "_metadata": {
+    "total_tasks": 5,
+    "total_conflicts": 1,
+    "resolved_conflicts": 1,
+    "timestamp": "2025-12-27T10:00:00Z"
+  }
+}
+```
+
+---
+
+## 4. Quality Standards
+
+### 4.1 Validation Checklist
+
+- [ ] No circular dependencies
+- [ ] All conflicts resolved
+- [ ] Dependencies ordered correctly
+- [ ] Parallel groups have no conflicts
+- [ ] Semantic priority calculated
+
+### 4.2 Error Handling
+
+| Scenario | Action |
+|----------|--------|
+| Circular dependency | Abort, report cycles |
+| Resolution creates cycle | Flag for manual resolution |
+| Missing task reference | Skip and warn |
+| Empty task list | Return empty queue |
+
+### 4.3 Guidelines

 **ALWAYS**:
-1. Build dependency graph before any ordering
-2. Detect cycles before and after conflict resolution
-3. Apply resolution rules consistently (Create → Update → Delete)
-4. Preserve within-issue task order when no conflicts
-5. Calculate semantic priority for all tasks
+1. Build dependency graph before ordering
+2. Detect cycles before and after resolution
+3. Apply resolution rules consistently
+4. Calculate semantic priority for all tasks
+5. Include rationale for conflict resolutions
 6. Validate ordering before output
-7. Include rationale for conflict resolutions
-8. Map depends_on to queue_ids in output

 **NEVER**:
 1. Execute tasks (ordering only)
 2. Ignore circular dependencies
-3. Create arbitrary ordering without rules
-4. Skip conflict detection
-5. Output invalid DAG
-6. Merge tasks from different issues in same parallel group if conflicts exist
-7. Assume task order without checking depends_on
+3. Skip conflict detection
+4. Output invalid DAG
+5. Merge conflicting tasks in parallel group
+
+**OUTPUT**:
+1. Write queue via `ccw issue queue` CLI
+2. Return JSON with `tasks`, `conflicts`, `execution_groups`, `_metadata`
--- a/.claude/commands/issue/execute.md
+++ b/.claude/commands/issue/execute.md
@@ -17,12 +17,14 @@ Execution orchestrator that coordinates codex instances. Each task is executed b
 - No file reading in codex
 - Orchestrator manages parallelism

-## Storage Structure (Flat JSONL)
+## Storage Structure (Queue History)

 ```
 .workflow/issues/
 ├── issues.jsonl              # All issues (one per line)
-├── queue.json                # Execution queue
+├── queues/                   # Queue history directory
+│   ├── index.json            # Queue index (active + history)
+│   └── {queue-id}.json       # Individual queue files
 └── solutions/
    ├── {issue-id}.jsonl      # Solutions for issue
    └── ...
@@ -78,19 +80,19 @@ Phase 4: Completion
 ### Phase 1: Queue Loading

 ```javascript
-// Load queue
-const queuePath = '.workflow/issues/queue.json';
-if (!Bash(`test -f "${queuePath}" && echo exists`).includes('exists')) {
-  console.log('No queue found. Run /issue:queue first.');
+// Load active queue via CLI endpoint
+const queueJson = Bash(`ccw issue status --json 2>/dev/null || echo '{}'`);
+const queue = JSON.parse(queueJson);
+
+if (!queue.id || queue.tasks?.length === 0) {
+  console.log('No active queue found. Run /issue:queue first.');
  return;
 }

-const queue = JSON.parse(Read(queuePath));
-
 // Count by status
-const pending = queue.queue.filter(q => q.status === 'pending');
-const executing = queue.queue.filter(q => q.status === 'executing');
-const completed = queue.queue.filter(q => q.status === 'completed');
+const pending = queue.tasks.filter(q => q.status === 'pending');
+const executing = queue.tasks.filter(q => q.status === 'executing');
+const completed = queue.tasks.filter(q => q.status === 'completed');

 console.log(`
 ## Execution Queue Status
@@ -98,7 +100,7 @@ console.log(`
 - Pending: ${pending.length}
 - Executing: ${executing.length}
 - Completed: ${completed.length}
- Total: ${queue.queue.length}
+- Total: ${queue.tasks.length}
 `);

 if (pending.length === 0 && executing.length === 0) {
@@ -113,10 +115,10 @@ if (pending.length === 0 && executing.length === 0) {
 // Find ready tasks (dependencies satisfied)
 function getReadyTasks() {
  const completedIds = new Set(
-    queue.queue.filter(q => q.status === 'completed').map(q => q.queue_id)
+    queue.tasks.filter(q => q.status === 'completed').map(q => q.item_id)
  );

-  return queue.queue.filter(item => {
+  return queue.tasks.filter(item => {
    if (item.status !== 'pending') return false;
    return item.depends_on.every(depId => completedIds.has(depId));
  });
@@ -141,9 +143,9 @@ readyTasks.sort((a, b) => a.execution_order - b.execution_order);
 // Initialize TodoWrite
 TodoWrite({
  todos: readyTasks.slice(0, parallelLimit).map(t => ({
-    content: `[${t.queue_id}] ${t.issue_id}:${t.task_id}`,
+    content: `[${t.item_id}] ${t.issue_id}:${t.task_id}`,
    status: 'pending',
-    activeForm: `Executing ${t.queue_id}`
+    activeForm: `Executing ${t.item_id}`
  }))
 });
 ```
@@ -207,7 +209,7 @@ This returns JSON with full lifecycle definition:
 ### Step 3: Report Completion
 When ALL phases complete successfully:
 \`\`\`bash
-ccw issue complete <queue_id> --result '{
+ccw issue complete <item_id> --result '{
  "files_modified": ["path1", "path2"],
  "tests_passed": true,
  "regression_passed": true,
@@ -220,7 +222,7 @@ ccw issue complete <queue_id> --result '{

 If any phase fails and cannot be fixed:
 \`\`\`bash
-ccw issue fail <queue_id> --reason "Phase X failed: <details>"
+ccw issue fail <item_id> --reason "Phase X failed: <details>"
 \`\`\`

 ### Rules
@@ -239,12 +241,12 @@ Begin by running: ccw issue next

  if (executor === 'codex') {
    Bash(
-      `ccw cli -p "${escapePrompt(codexPrompt)}" --tool codex --mode write --id exec-${queueItem.queue_id}`,
+      `ccw cli -p "${escapePrompt(codexPrompt)}" --tool codex --mode write --id exec-${queueItem.item_id}`,
      timeout=3600000  // 1 hour timeout
    );
  } else if (executor === 'gemini') {
    Bash(
-      `ccw cli -p "${escapePrompt(codexPrompt)}" --tool gemini --mode write --id exec-${queueItem.queue_id}`,
+      `ccw cli -p "${escapePrompt(codexPrompt)}" --tool gemini --mode write --id exec-${queueItem.item_id}`,
      timeout=1800000  // 30 min timeout
    );
  } else {
@@ -252,7 +254,7 @@ Begin by running: ccw issue next
    Task(
      subagent_type="code-developer",
      run_in_background=false,
-      description=`Execute ${queueItem.queue_id}`,
+      description=`Execute ${queueItem.item_id}`,
      prompt=codexPrompt
    );
  }
@@ -265,23 +267,23 @@ for (let i = 0; i < readyTasks.length; i += parallelLimit) {
  const batch = readyTasks.slice(i, i + parallelLimit);

  console.log(`\n### Executing Batch ${Math.floor(i / parallelLimit) + 1}`);
-  console.log(batch.map(t => `- ${t.queue_id}: ${t.issue_id}:${t.task_id}`).join('\n'));
+  console.log(batch.map(t => `- ${t.item_id}: ${t.issue_id}:${t.task_id}`).join('\n'));

  if (parallelLimit === 1) {
    // Sequential execution
    for (const task of batch) {
-      updateTodo(task.queue_id, 'in_progress');
+      updateTodo(task.item_id, 'in_progress');
      await executeTask(task);
-      updateTodo(task.queue_id, 'completed');
+      updateTodo(task.item_id, 'completed');
    }
  } else {
    // Parallel execution - launch all at once
    const executions = batch.map(task => {
-      updateTodo(task.queue_id, 'in_progress');
+      updateTodo(task.item_id, 'in_progress');
      return executeTask(task);
    });
    await Promise.all(executions);
-    batch.forEach(task => updateTodo(task.queue_id, 'completed'));
+    batch.forEach(task => updateTodo(task.item_id, 'completed'));
  }

  // Refresh ready tasks after batch
@@ -298,7 +300,7 @@ When codex calls `ccw issue next`, it receives:

 ```json
 {
-  "queue_id": "Q-001",
+  "item_id": "T-1",
  "issue_id": "GH-123",
  "solution_id": "SOL-001",
  "task": {
@@ -336,60 +338,38 @@ When codex calls `ccw issue next`, it receives:
 ### Phase 4: Completion Summary

 ```javascript
-// Reload queue for final status
-const finalQueue = JSON.parse(Read(queuePath));
+// Reload queue for final status via CLI
+const finalQueueJson = Bash(`ccw issue status --json 2>/dev/null || echo '{}'`);
+const finalQueue = JSON.parse(finalQueueJson);

-const summary = {
-  completed: finalQueue.queue.filter(q => q.status === 'completed').length,
-  failed: finalQueue.queue.filter(q => q.status === 'failed').length,
-  pending: finalQueue.queue.filter(q => q.status === 'pending').length,
-  total: finalQueue.queue.length
+// Use queue._metadata for summary (already calculated by CLI)
+const summary = finalQueue._metadata || {
+  completed_count: 0,
+  failed_count: 0,
+  pending_count: 0,
+  total_tasks: 0
 };

 console.log(`
 ## Execution Complete

-**Completed**: ${summary.completed}/${summary.total}
-**Failed**: ${summary.failed}
-**Pending**: ${summary.pending}
+**Completed**: ${summary.completed_count}/${summary.total_tasks}
+**Failed**: ${summary.failed_count}
+**Pending**: ${summary.pending_count}

 ### Task Results
-${finalQueue.queue.map(q => {
+${(finalQueue.tasks || []).map(q => {
  const icon = q.status === 'completed' ? '✓' :
               q.status === 'failed' ? '✗' :
               q.status === 'executing' ? '⟳' : '○';
-  return `${icon} ${q.queue_id} [${q.issue_id}:${q.task_id}] - ${q.status}`;
+  return `${icon} ${q.item_id} [${q.issue_id}:${q.task_id}] - ${q.status}`;
 }).join('\n')}
 `);

-// Update issue statuses in issues.jsonl
-const issuesPath = '.workflow/issues/issues.jsonl';
-const allIssues = Bash(`cat "${issuesPath}"`)
-  .split('\n')
-  .filter(line => line.trim())
-  .map(line => JSON.parse(line));
+// Issue status updates are handled by ccw issue complete/fail endpoints
+// No need to manually update issues.jsonl here

-const issueIds = [...new Set(finalQueue.queue.map(q => q.issue_id))];
-for (const issueId of issueIds) {
-  const issueTasks = finalQueue.queue.filter(q => q.issue_id === issueId);
-
-  if (issueTasks.every(q => q.status === 'completed')) {
-    console.log(`\n✓ Issue ${issueId} fully completed!`);
-
-    // Update issue status
-    const issueIndex = allIssues.findIndex(i => i.id === issueId);
-    if (issueIndex !== -1) {
-      allIssues[issueIndex].status = 'completed';
-      allIssues[issueIndex].completed_at = new Date().toISOString();
-      allIssues[issueIndex].updated_at = new Date().toISOString();
-    }
-  }
-}
-
-// Write updated issues.jsonl
-Write(issuesPath, allIssues.map(i => JSON.stringify(i)).join('\n'));
-
-if (summary.pending > 0) {
+if (summary.pending_count > 0) {
  console.log(`
 ### Continue Execution
 Run \`/issue:execute\` again to execute remaining tasks.
@@ -405,7 +385,7 @@ if (flags.dryRun) {
 ## Dry Run - Would Execute

 ${readyTasks.map((t, i) => `
-${i + 1}. ${t.queue_id}
+${i + 1}. ${t.item_id}
   Issue: ${t.issue_id}
   Task: ${t.task_id}
   Executor: ${t.assigned_executor}
@@ -426,7 +406,32 @@ No changes made. Remove --dry-run to execute.
 | No ready tasks | Check dependencies, show blocked tasks |
 | Codex timeout | Mark as failed, allow retry |
 | ccw issue next empty | All tasks done or blocked |
-| Task execution failure | Marked via ccw issue fail |
+| Task execution failure | Marked via ccw issue fail, use `ccw issue retry` to reset |
+
+## Troubleshooting
+
+### Interrupted Tasks
+
+If execution was interrupted (crashed/stopped), `ccw issue next` will automatically resume:
+
+```bash
+# Automatically returns the executing task for resumption
+ccw issue next
+```
+
+Tasks in `executing` status are prioritized and returned first, no manual reset needed.
+
+### Failed Tasks
+
+If a task failed and you want to retry:
+
+```bash
+# Reset all failed tasks to pending
+ccw issue retry
+
+# Reset failed tasks for specific issue
+ccw issue retry <issue-id>
+```

 ## Endpoint Contract

@@ -435,16 +440,20 @@ No changes made. Remove --dry-run to execute.
 - Marks task as 'executing'
 - Returns `{ status: 'empty' }` when no tasks

-### `ccw issue complete <queue-id>`
+### `ccw issue complete <item-id>`
 - Marks task as 'completed'
 - Updates queue.json
 - Checks if issue is fully complete

-### `ccw issue fail <queue-id>`
+### `ccw issue fail <item-id>`
 - Marks task as 'failed'
 - Records failure reason
 - Allows retry via /issue:execute

+### `ccw issue retry [issue-id]`
+- Resets failed tasks to 'pending'
+- Allows re-execution via `ccw issue next`
+
 ## Related Commands

 - `/issue:plan` - Plan issues with solutions
--- a/.claude/commands/issue/manage.md
+++ b/.claude/commands/issue/manage.md
@@ -20,17 +20,23 @@ Interactive menu-driven interface for issue management using `ccw issue` CLI end

 ```bash
 # Core endpoints (ccw issue)
-ccw issue list                    # List all issues
-ccw issue list <id> --json        # Get issue details
-ccw issue status <id>             # Detailed status
-ccw issue init <id> --title "..." # Create issue
-ccw issue task <id> --title "..." # Add task
+ccw issue list                      # List all issues
+ccw issue list <id> --json          # Get issue details
+ccw issue status <id>               # Detailed status
+ccw issue init <id> --title "..."   # Create issue
+ccw issue task <id> --title "..."   # Add task
+ccw issue bind <id> <solution-id>   # Bind solution

 # Queue management
-ccw issue queue                   # List queue
-ccw issue queue add <id>          # Add to queue
-ccw issue next                    # Get next task
-ccw issue done <queue-id>         # Complete task
+ccw issue queue                     # List current queue
+ccw issue queue add <id>            # Add to queue
+ccw issue queue list                # Queue history
+ccw issue queue switch <queue-id>   # Switch queue
+ccw issue queue archive             # Archive queue
+ccw issue queue delete <queue-id>   # Delete queue
+ccw issue next                      # Get next task
+ccw issue done <queue-id>           # Mark completed
+ccw issue complete <item-id>        # (legacy alias for done)
 ```

 ## Usage
@@ -49,7 +55,9 @@ ccw issue done <queue-id>         # Complete task

 ## Implementation

-### Phase 1: Entry Point
+This command delegates to the `issue-manage` skill for detailed implementation.
+
+### Entry Point

 ```javascript
 const issueId = parseIssueId(userInput);
@@ -63,787 +71,30 @@ if (!action) {
 }
 ```

-### Phase 2: Main Menu
+### Main Menu Flow

-```javascript
-async function showMainMenu(preselectedIssue = null) {
-  // Fetch current issues summary
-  const issuesResult = Bash('ccw issue list --json 2>/dev/null || echo "[]"');
-  const issues = JSON.parse(issuesResult) || [];
-  
-  const queueResult = Bash('ccw issue status --json 2>/dev/null');
-  const queueStatus = JSON.parse(queueResult || '{}');
-  
-  console.log(`
-## Issue Management Dashboard
+1. **Dashboard**: Fetch issues summary via `ccw issue list --json`
+2. **Menu**: Present action options via AskUserQuestion
+3. **Route**: Execute selected action (List/View/Edit/Delete/Bulk)
+4. **Loop**: Return to menu after each action

-**Total Issues**: ${issues.length}
-**Queue Status**: ${queueStatus.queue?.total_tasks || 0} tasks (${queueStatus.queue?.pending_count || 0} pending)
+### Available Actions

-### Quick Stats
- Registered: ${issues.filter(i => i.status === 'registered').length}
- Planned: ${issues.filter(i => i.status === 'planned').length}
- Executing: ${issues.filter(i => i.status === 'executing').length}
- Completed: ${issues.filter(i => i.status === 'completed').length}
-`);
+| Action | Description | CLI Command |
+|--------|-------------|-------------|
+| List | Browse with filters | `ccw issue list --json` |
+| View | Detail view | `ccw issue status <id> --json` |
+| Edit | Modify fields | Update `issues.jsonl` |
+| Delete | Remove issue | Clean up all related files |
+| Bulk | Batch operations | Multi-select + batch update |

-  const answer = AskUserQuestion({
-    questions: [{
-      question: 'What would you like to do?',
-      header: 'Action',
-      multiSelect: false,
-      options: [
-        { label: 'List Issues', description: 'Browse all issues with filters' },
-        { label: 'View Issue', description: 'Detailed view of specific issue' },
-        { label: 'Create Issue', description: 'Add new issue from text or GitHub' },
-        { label: 'Edit Issue', description: 'Modify issue fields' },
-        { label: 'Delete Issue', description: 'Remove issue(s)' },
-        { label: 'Bulk Operations', description: 'Batch actions on multiple issues' }
-      ]
-    }]
-  });
-  
-  const selected = parseAnswer(answer);
-  
-  switch (selected) {
-    case 'List Issues':
-      await listIssuesInteractive();
-      break;
-    case 'View Issue':
-      await viewIssueInteractive(preselectedIssue);
-      break;
-    case 'Create Issue':
-      await createIssueInteractive();
-      break;
-    case 'Edit Issue':
-      await editIssueInteractive(preselectedIssue);
-      break;
-    case 'Delete Issue':
-      await deleteIssueInteractive(preselectedIssue);
-      break;
-    case 'Bulk Operations':
-      await bulkOperationsInteractive();
-      break;
-  }
-}
-```
+## Data Files

-### Phase 3: List Issues
-
-```javascript
-async function listIssuesInteractive() {
-  // Ask for filter
-  const filterAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Filter issues by status?',
-      header: 'Filter',
-      multiSelect: true,
-      options: [
-        { label: 'All', description: 'Show all issues' },
-        { label: 'Registered', description: 'New, unplanned issues' },
-        { label: 'Planned', description: 'Issues with bound solutions' },
-        { label: 'Queued', description: 'In execution queue' },
-        { label: 'Executing', description: 'Currently being worked on' },
-        { label: 'Completed', description: 'Finished issues' },
-        { label: 'Failed', description: 'Failed issues' }
-      ]
-    }]
-  });
-  
-  const filters = parseMultiAnswer(filterAnswer);
-  
-  // Fetch and filter issues
-  const result = Bash('ccw issue list --json');
-  let issues = JSON.parse(result) || [];
-  
-  if (!filters.includes('All')) {
-    const statusMap = {
-      'Registered': 'registered',
-      'Planned': 'planned',
-      'Queued': 'queued',
-      'Executing': 'executing',
-      'Completed': 'completed',
-      'Failed': 'failed'
-    };
-    const allowedStatuses = filters.map(f => statusMap[f]).filter(Boolean);
-    issues = issues.filter(i => allowedStatuses.includes(i.status));
-  }
-  
-  if (issues.length === 0) {
-    console.log('No issues found matching filters.');
-    return showMainMenu();
-  }
-  
-  // Display issues table
-  console.log(`
-## Issues (${issues.length})
-
-| ID | Status | Priority | Title |
-|----|--------|----------|-------|
-${issues.map(i => `| ${i.id} | ${i.status} | P${i.priority} | ${i.title.substring(0, 40)} |`).join('\n')}
-`);
-
-  // Ask for action on issue
-  const actionAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Select an issue to view/edit, or return to menu:',
-      header: 'Select',
-      multiSelect: false,
-      options: [
-        ...issues.slice(0, 10).map(i => ({
-          label: i.id,
-          description: i.title.substring(0, 50)
-        })),
-        { label: 'Back to Menu', description: 'Return to main menu' }
-      ]
-    }]
-  });
-  
-  const selected = parseAnswer(actionAnswer);
-  
-  if (selected === 'Back to Menu') {
-    return showMainMenu();
-  }
-  
-  // View selected issue
-  await viewIssueInteractive(selected);
-}
-```
-
-### Phase 4: View Issue
-
-```javascript
-async function viewIssueInteractive(issueId) {
-  if (!issueId) {
-    // Ask for issue ID
-    const issues = JSON.parse(Bash('ccw issue list --json') || '[]');
-    
-    const idAnswer = AskUserQuestion({
-      questions: [{
-        question: 'Select issue to view:',
-        header: 'Issue',
-        multiSelect: false,
-        options: issues.slice(0, 10).map(i => ({
-          label: i.id,
-          description: `${i.status} - ${i.title.substring(0, 40)}`
-        }))
-      }]
-    });
-    
-    issueId = parseAnswer(idAnswer);
-  }
-  
-  // Fetch detailed status
-  const result = Bash(`ccw issue status ${issueId} --json`);
-  const data = JSON.parse(result);
-  
-  const issue = data.issue;
-  const solutions = data.solutions || [];
-  const bound = data.bound;
-  
-  console.log(`
-## Issue: ${issue.id}
-
-**Title**: ${issue.title}
-**Status**: ${issue.status}
-**Priority**: P${issue.priority}
-**Created**: ${issue.created_at}
-**Updated**: ${issue.updated_at}
-
-### Context
-${issue.context || 'No context provided'}
-
-### Solutions (${solutions.length})
-${solutions.length === 0 ? 'No solutions registered' :
-  solutions.map(s => `- ${s.is_bound ? '◉' : '○'} ${s.id}: ${s.tasks?.length || 0} tasks`).join('\n')}
-
-${bound ? `### Bound Solution: ${bound.id}\n**Tasks**: ${bound.tasks?.length || 0}` : ''}
-`);
-
-  // Show tasks if bound solution exists
-  if (bound?.tasks?.length > 0) {
-    console.log(`
-### Tasks
-| ID | Action | Scope | Title |
-|----|--------|-------|-------|
-${bound.tasks.map(t => `| ${t.id} | ${t.action} | ${t.scope?.substring(0, 20) || '-'} | ${t.title.substring(0, 30)} |`).join('\n')}
-`);
-  }
-  
-  // Action menu
-  const actionAnswer = AskUserQuestion({
-    questions: [{
-      question: 'What would you like to do?',
-      header: 'Action',
-      multiSelect: false,
-      options: [
-        { label: 'Edit Issue', description: 'Modify issue fields' },
-        { label: 'Plan Issue', description: 'Generate solution (/issue:plan)' },
-        { label: 'Add to Queue', description: 'Queue bound solution tasks' },
-        { label: 'View Queue', description: 'See queue status' },
-        { label: 'Delete Issue', description: 'Remove this issue' },
-        { label: 'Back to Menu', description: 'Return to main menu' }
-      ]
-    }]
-  });
-  
-  const action = parseAnswer(actionAnswer);
-  
-  switch (action) {
-    case 'Edit Issue':
-      await editIssueInteractive(issueId);
-      break;
-    case 'Plan Issue':
-      console.log(`Running: /issue:plan ${issueId}`);
-      // Invoke plan skill
-      break;
-    case 'Add to Queue':
-      Bash(`ccw issue queue add ${issueId}`);
-      console.log(`✓ Added ${issueId} tasks to queue`);
-      break;
-    case 'View Queue':
-      const queueOutput = Bash('ccw issue queue');
-      console.log(queueOutput);
-      break;
-    case 'Delete Issue':
-      await deleteIssueInteractive(issueId);
-      break;
-    default:
-      return showMainMenu();
-  }
-}
-```
-
-### Phase 5: Edit Issue
-
-```javascript
-async function editIssueInteractive(issueId) {
-  if (!issueId) {
-    const issues = JSON.parse(Bash('ccw issue list --json') || '[]');
-    const idAnswer = AskUserQuestion({
-      questions: [{
-        question: 'Select issue to edit:',
-        header: 'Issue',
-        multiSelect: false,
-        options: issues.slice(0, 10).map(i => ({
-          label: i.id,
-          description: `${i.status} - ${i.title.substring(0, 40)}`
-        }))
-      }]
-    });
-    issueId = parseAnswer(idAnswer);
-  }
-  
-  // Get current issue data
-  const result = Bash(`ccw issue list ${issueId} --json`);
-  const issueData = JSON.parse(result);
-  const issue = issueData.issue || issueData;
-  
-  // Ask which field to edit
-  const fieldAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Which field to edit?',
-      header: 'Field',
-      multiSelect: false,
-      options: [
-        { label: 'Title', description: `Current: ${issue.title?.substring(0, 40)}` },
-        { label: 'Priority', description: `Current: P${issue.priority}` },
-        { label: 'Status', description: `Current: ${issue.status}` },
-        { label: 'Context', description: 'Edit problem description' },
-        { label: 'Labels', description: `Current: ${issue.labels?.join(', ') || 'none'}` },
-        { label: 'Back', description: 'Return without changes' }
-      ]
-    }]
-  });
-  
-  const field = parseAnswer(fieldAnswer);
-  
-  if (field === 'Back') {
-    return viewIssueInteractive(issueId);
-  }
-  
-  let updatePayload = {};
-  
-  switch (field) {
-    case 'Title':
-      const titleAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Enter new title (or select current to keep):',
-          header: 'Title',
-          multiSelect: false,
-          options: [
-            { label: issue.title.substring(0, 50), description: 'Keep current title' }
-          ]
-        }]
-      });
-      const newTitle = parseAnswer(titleAnswer);
-      if (newTitle && newTitle !== issue.title.substring(0, 50)) {
-        updatePayload.title = newTitle;
-      }
-      break;
-      
-    case 'Priority':
-      const priorityAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Select priority:',
-          header: 'Priority',
-          multiSelect: false,
-          options: [
-            { label: 'P1 - Critical', description: 'Production blocking' },
-            { label: 'P2 - High', description: 'Major functionality' },
-            { label: 'P3 - Medium', description: 'Normal priority (default)' },
-            { label: 'P4 - Low', description: 'Minor issues' },
-            { label: 'P5 - Trivial', description: 'Nice to have' }
-          ]
-        }]
-      });
-      const priorityStr = parseAnswer(priorityAnswer);
-      updatePayload.priority = parseInt(priorityStr.charAt(1));
-      break;
-      
-    case 'Status':
-      const statusAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Select status:',
-          header: 'Status',
-          multiSelect: false,
-          options: [
-            { label: 'registered', description: 'New issue, not yet planned' },
-            { label: 'planning', description: 'Solution being generated' },
-            { label: 'planned', description: 'Solution bound, ready for queue' },
-            { label: 'queued', description: 'In execution queue' },
-            { label: 'executing', description: 'Currently being worked on' },
-            { label: 'completed', description: 'All tasks finished' },
-            { label: 'failed', description: 'Execution failed' },
-            { label: 'paused', description: 'Temporarily on hold' }
-          ]
-        }]
-      });
-      updatePayload.status = parseAnswer(statusAnswer);
-      break;
-      
-    case 'Context':
-      console.log(`Current context:\n${issue.context || '(empty)'}\n`);
-      const contextAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Enter new context (problem description):',
-          header: 'Context',
-          multiSelect: false,
-          options: [
-            { label: 'Keep current', description: 'No changes' }
-          ]
-        }]
-      });
-      const newContext = parseAnswer(contextAnswer);
-      if (newContext && newContext !== 'Keep current') {
-        updatePayload.context = newContext;
-      }
-      break;
-      
-    case 'Labels':
-      const labelsAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Enter labels (comma-separated):',
-          header: 'Labels',
-          multiSelect: false,
-          options: [
-            { label: issue.labels?.join(',') || '', description: 'Keep current labels' }
-          ]
-        }]
-      });
-      const labelsStr = parseAnswer(labelsAnswer);
-      if (labelsStr) {
-        updatePayload.labels = labelsStr.split(',').map(l => l.trim());
-      }
-      break;
-  }
-  
-  // Apply update if any
-  if (Object.keys(updatePayload).length > 0) {
-    // Read, update, write issues.jsonl
-    const issuesPath = '.workflow/issues/issues.jsonl';
-    const allIssues = Bash(`cat "${issuesPath}"`)
-      .split('\n')
-      .filter(line => line.trim())
-      .map(line => JSON.parse(line));
-    
-    const idx = allIssues.findIndex(i => i.id === issueId);
-    if (idx !== -1) {
-      allIssues[idx] = {
-        ...allIssues[idx],
-        ...updatePayload,
-        updated_at: new Date().toISOString()
-      };
-      
-      Write(issuesPath, allIssues.map(i => JSON.stringify(i)).join('\n'));
-      console.log(`✓ Updated ${issueId}: ${Object.keys(updatePayload).join(', ')}`);
-    }
-  }
-  
-  // Continue editing or return
-  const continueAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Continue editing?',
-      header: 'Continue',
-      multiSelect: false,
-      options: [
-        { label: 'Edit Another Field', description: 'Continue editing this issue' },
-        { label: 'View Issue', description: 'See updated issue' },
-        { label: 'Back to Menu', description: 'Return to main menu' }
-      ]
-    }]
-  });
-  
-  const cont = parseAnswer(continueAnswer);
-  if (cont === 'Edit Another Field') {
-    await editIssueInteractive(issueId);
-  } else if (cont === 'View Issue') {
-    await viewIssueInteractive(issueId);
-  } else {
-    return showMainMenu();
-  }
-}
-```
-
-### Phase 6: Delete Issue
-
-```javascript
-async function deleteIssueInteractive(issueId) {
-  if (!issueId) {
-    const issues = JSON.parse(Bash('ccw issue list --json') || '[]');
-    const idAnswer = AskUserQuestion({
-      questions: [{
-        question: 'Select issue to delete:',
-        header: 'Delete',
-        multiSelect: false,
-        options: issues.slice(0, 10).map(i => ({
-          label: i.id,
-          description: `${i.status} - ${i.title.substring(0, 40)}`
-        }))
-      }]
-    });
-    issueId = parseAnswer(idAnswer);
-  }
-  
-  // Confirm deletion
-  const confirmAnswer = AskUserQuestion({
-    questions: [{
-      question: `Delete issue ${issueId}? This will also remove associated solutions.`,
-      header: 'Confirm',
-      multiSelect: false,
-      options: [
-        { label: 'Delete', description: 'Permanently remove issue and solutions' },
-        { label: 'Cancel', description: 'Keep issue' }
-      ]
-    }]
-  });
-  
-  if (parseAnswer(confirmAnswer) !== 'Delete') {
-    console.log('Deletion cancelled.');
-    return showMainMenu();
-  }
-  
-  // Remove from issues.jsonl
-  const issuesPath = '.workflow/issues/issues.jsonl';
-  const allIssues = Bash(`cat "${issuesPath}"`)
-    .split('\n')
-    .filter(line => line.trim())
-    .map(line => JSON.parse(line));
-  
-  const filtered = allIssues.filter(i => i.id !== issueId);
-  Write(issuesPath, filtered.map(i => JSON.stringify(i)).join('\n'));
-  
-  // Remove solutions file if exists
-  const solPath = `.workflow/issues/solutions/${issueId}.jsonl`;
-  Bash(`rm -f "${solPath}" 2>/dev/null || true`);
-  
-  // Remove from queue if present
-  const queuePath = '.workflow/issues/queue.json';
-  if (Bash(`test -f "${queuePath}" && echo exists`) === 'exists') {
-    const queue = JSON.parse(Bash(`cat "${queuePath}"`));
-    queue.queue = queue.queue.filter(q => q.issue_id !== issueId);
-    Write(queuePath, JSON.stringify(queue, null, 2));
-  }
-  
-  console.log(`✓ Deleted issue ${issueId}`);
-  return showMainMenu();
-}
-```
-
-### Phase 7: Bulk Operations
-
-```javascript
-async function bulkOperationsInteractive() {
-  const bulkAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Select bulk operation:',
-      header: 'Bulk',
-      multiSelect: false,
-      options: [
-        { label: 'Update Status', description: 'Change status of multiple issues' },
-        { label: 'Update Priority', description: 'Change priority of multiple issues' },
-        { label: 'Add Labels', description: 'Add labels to multiple issues' },
-        { label: 'Delete Multiple', description: 'Remove multiple issues' },
-        { label: 'Queue All Planned', description: 'Add all planned issues to queue' },
-        { label: 'Retry All Failed', description: 'Reset all failed tasks to pending' },
-        { label: 'Back', description: 'Return to main menu' }
-      ]
-    }]
-  });
-  
-  const operation = parseAnswer(bulkAnswer);
-  
-  if (operation === 'Back') {
-    return showMainMenu();
-  }
-  
-  // Get issues for selection
-  const allIssues = JSON.parse(Bash('ccw issue list --json') || '[]');
-  
-  if (operation === 'Queue All Planned') {
-    const planned = allIssues.filter(i => i.status === 'planned' && i.bound_solution_id);
-    for (const issue of planned) {
-      Bash(`ccw issue queue add ${issue.id}`);
-      console.log(`✓ Queued ${issue.id}`);
-    }
-    console.log(`\n✓ Queued ${planned.length} issues`);
-    return showMainMenu();
-  }
-  
-  if (operation === 'Retry All Failed') {
-    Bash('ccw issue retry');
-    console.log('✓ Reset all failed tasks to pending');
-    return showMainMenu();
-  }
-  
-  // Multi-select issues
-  const selectAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Select issues (multi-select):',
-      header: 'Select',
-      multiSelect: true,
-      options: allIssues.slice(0, 15).map(i => ({
-        label: i.id,
-        description: `${i.status} - ${i.title.substring(0, 30)}`
-      }))
-    }]
-  });
-  
-  const selectedIds = parseMultiAnswer(selectAnswer);
-  
-  if (selectedIds.length === 0) {
-    console.log('No issues selected.');
-    return showMainMenu();
-  }
-  
-  // Execute bulk operation
-  const issuesPath = '.workflow/issues/issues.jsonl';
-  let issues = Bash(`cat "${issuesPath}"`)
-    .split('\n')
-    .filter(line => line.trim())
-    .map(line => JSON.parse(line));
-  
-  switch (operation) {
-    case 'Update Status':
-      const statusAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Select new status:',
-          header: 'Status',
-          multiSelect: false,
-          options: [
-            { label: 'registered', description: 'Reset to registered' },
-            { label: 'paused', description: 'Pause issues' },
-            { label: 'completed', description: 'Mark completed' }
-          ]
-        }]
-      });
-      const newStatus = parseAnswer(statusAnswer);
-      issues = issues.map(i => 
-        selectedIds.includes(i.id) 
-          ? { ...i, status: newStatus, updated_at: new Date().toISOString() }
-          : i
-      );
-      break;
-      
-    case 'Update Priority':
-      const prioAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Select new priority:',
-          header: 'Priority',
-          multiSelect: false,
-          options: [
-            { label: 'P1', description: 'Critical' },
-            { label: 'P2', description: 'High' },
-            { label: 'P3', description: 'Medium' },
-            { label: 'P4', description: 'Low' },
-            { label: 'P5', description: 'Trivial' }
-          ]
-        }]
-      });
-      const newPrio = parseInt(parseAnswer(prioAnswer).charAt(1));
-      issues = issues.map(i => 
-        selectedIds.includes(i.id) 
-          ? { ...i, priority: newPrio, updated_at: new Date().toISOString() }
-          : i
-      );
-      break;
-      
-    case 'Add Labels':
-      const labelAnswer = AskUserQuestion({
-        questions: [{
-          question: 'Enter labels to add (comma-separated):',
-          header: 'Labels',
-          multiSelect: false,
-          options: [
-            { label: 'bug', description: 'Bug fix' },
-            { label: 'feature', description: 'New feature' },
-            { label: 'urgent', description: 'Urgent priority' }
-          ]
-        }]
-      });
-      const newLabels = parseAnswer(labelAnswer).split(',').map(l => l.trim());
-      issues = issues.map(i => 
-        selectedIds.includes(i.id) 
-          ? { 
-              ...i, 
-              labels: [...new Set([...(i.labels || []), ...newLabels])],
-              updated_at: new Date().toISOString() 
-            }
-          : i
-      );
-      break;
-      
-    case 'Delete Multiple':
-      const confirmDelete = AskUserQuestion({
-        questions: [{
-          question: `Delete ${selectedIds.length} issues permanently?`,
-          header: 'Confirm',
-          multiSelect: false,
-          options: [
-            { label: 'Delete All', description: 'Remove selected issues' },
-            { label: 'Cancel', description: 'Keep issues' }
-          ]
-        }]
-      });
-      if (parseAnswer(confirmDelete) === 'Delete All') {
-        issues = issues.filter(i => !selectedIds.includes(i.id));
-        // Clean up solutions
-        for (const id of selectedIds) {
-          Bash(`rm -f ".workflow/issues/solutions/${id}.jsonl" 2>/dev/null || true`);
-        }
-      } else {
-        console.log('Deletion cancelled.');
-        return showMainMenu();
-      }
-      break;
-  }
-  
-  Write(issuesPath, issues.map(i => JSON.stringify(i)).join('\n'));
-  console.log(`✓ Updated ${selectedIds.length} issues`);
-  return showMainMenu();
-}
-```
-
-### Phase 8: Create Issue (Redirect)
-
-```javascript
-async function createIssueInteractive() {
-  const typeAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Create issue from:',
-      header: 'Source',
-      multiSelect: false,
-      options: [
-        { label: 'GitHub URL', description: 'Import from GitHub issue' },
-        { label: 'Text Description', description: 'Enter problem description' },
-        { label: 'Quick Create', description: 'Just title and priority' }
-      ]
-    }]
-  });
-  
-  const type = parseAnswer(typeAnswer);
-  
-  if (type === 'GitHub URL' || type === 'Text Description') {
-    console.log('Use /issue:new for structured issue creation');
-    console.log('Example: /issue:new https://github.com/org/repo/issues/123');
-    return showMainMenu();
-  }
-  
-  // Quick create
-  const titleAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Enter issue title:',
-      header: 'Title',
-      multiSelect: false,
-      options: [
-        { label: 'Authentication Bug', description: 'Example title' }
-      ]
-    }]
-  });
-  
-  const title = parseAnswer(titleAnswer);
-  
-  const prioAnswer = AskUserQuestion({
-    questions: [{
-      question: 'Select priority:',
-      header: 'Priority',
-      multiSelect: false,
-      options: [
-        { label: 'P3 - Medium (Recommended)', description: 'Normal priority' },
-        { label: 'P1 - Critical', description: 'Production blocking' },
-        { label: 'P2 - High', description: 'Major functionality' }
-      ]
-    }]
-  });
-  
-  const priority = parseInt(parseAnswer(prioAnswer).charAt(1));
-  
-  // Generate ID and create
-  const id = `ISS-${Date.now()}`;
-  Bash(`ccw issue init ${id} --title "${title}" --priority ${priority}`);
-  
-  console.log(`✓ Created issue ${id}`);
-  await viewIssueInteractive(id);
-}
-```
-
-## Helper Functions
-
-```javascript
-function parseAnswer(answer) {
-  // Extract selected option from AskUserQuestion response
-  if (typeof answer === 'string') return answer;
-  if (answer.answers) {
-    const values = Object.values(answer.answers);
-    return values[0] || '';
-  }
-  return '';
-}
-
-function parseMultiAnswer(answer) {
-  // Extract multiple selections
-  if (typeof answer === 'string') return answer.split(',').map(s => s.trim());
-  if (answer.answers) {
-    const values = Object.values(answer.answers);
-    return values.flatMap(v => v.split(',').map(s => s.trim()));
-  }
-  return [];
-}
-
-function parseFlags(input) {
-  const flags = {};
-  const matches = input.matchAll(/--(\w+)\s+([^\s-]+)/g);
-  for (const match of matches) {
-    flags[match[1]] = match[2];
-  }
-  return flags;
-}
-
-function parseIssueId(input) {
-  const match = input.match(/^([A-Z]+-\d+|ISS-\d+|GH-\d+)/i);
-  return match ? match[1] : null;
-}
-```
+| File | Purpose |
+|------|---------|
+| `.workflow/issues/issues.jsonl` | Issue records |
+| `.workflow/issues/solutions/<id>.jsonl` | Solutions per issue |
+| `.workflow/issues/queue.json` | Execution queue |

 ## Error Handling

@@ -853,7 +104,6 @@ function parseIssueId(input) {
 | Issue not found | Show available issues, ask for correction |
 | Invalid selection | Show error, re-prompt |
 | Write failure | Check permissions, show error |
-| Queue operation fails | Show ccw issue error, suggest fix |

 ## Related Commands

@@ -861,5 +111,3 @@ function parseIssueId(input) {
 - `/issue:plan` - Plan solution for issue
 - `/issue:queue` - Form execution queue
 - `/issue:execute` - Execute queued tasks
- `ccw issue list` - CLI list command
- `ccw issue status` - CLI status command
--- a/.claude/commands/issue/new.md
+++ b/.claude/commands/issue/new.md
@@ -51,51 +51,18 @@ interface Issue {
 }
 ```

-## Task Lifecycle (Each Task is Closed-Loop)
+## Lifecycle Requirements

-When `/issue:plan` generates tasks, each task MUST include:
+The `lifecycle_requirements` field guides downstream commands (`/issue:plan`, `/issue:execute`):

-```typescript
-interface SolutionTask {
-  id: string;
-  title: string;
-  scope: string;
-  action: string;
+| Field | Options | Purpose |
+|-------|---------|---------|
+| `test_strategy` | `unit`, `integration`, `e2e`, `manual`, `auto` | Which test types to generate |
+| `regression_scope` | `affected`, `related`, `full` | Which tests to run for regression |
+| `acceptance_type` | `automated`, `manual`, `both` | How to verify completion |
+| `commit_strategy` | `per-task`, `squash`, `atomic` | Commit granularity |

-  // Phase 1: Implementation
-  implementation: string[];     // Step-by-step implementation
-  modification_points: { file: string; target: string; change: string }[];
-
-  // Phase 2: Testing
-  test: {
-    unit?: string[];            // Unit test requirements
-    integration?: string[];     // Integration test requirements
-    commands?: string[];        // Test commands to run
-    coverage_target?: number;   // Minimum coverage %
-  };
-
-  // Phase 3: Regression
-  regression: string[];         // Regression check commands/points
-
-  // Phase 4: Acceptance
-  acceptance: {
-    criteria: string[];         // Testable acceptance criteria
-    verification: string[];     // How to verify each criterion
-    manual_checks?: string[];   // Manual verification if needed
-  };
-
-  // Phase 5: Commit
-  commit: {
-    type: 'feat' | 'fix' | 'refactor' | 'test' | 'docs' | 'chore';
-    scope: string;              // e.g., "auth", "api"
-    message_template: string;   // Commit message template
-    breaking?: boolean;
-  };
-
-  depends_on: string[];
-  executor: 'codex' | 'gemini' | 'agent' | 'auto';
-}
-```
+> **Note**: Task structure (SolutionTask) is defined in `/issue:plan` - see `.claude/commands/issue/plan.md`

 ## Usage

--- a/.claude/commands/issue/plan.md
+++ b/.claude/commands/issue/plan.md
@@ -1,7 +1,7 @@
 ---
 name: plan
 description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
-argument-hint: "<issue-id>[,<issue-id>,...] [--batch-size 3]"
+argument-hint: "<issue-id>[,<issue-id>,...] [--batch-size 3] --all-pending"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
 ---

@@ -9,13 +9,35 @@ allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(

 ## Overview

-Unified planning command using **issue-plan-agent** that combines exploration and planning into a single closed-loop workflow. The agent handles ACE semantic search, solution generation, and task breakdown.
+Unified planning command using **issue-plan-agent** that combines exploration and planning into a single closed-loop workflow.
+
+## Output Requirements
+
+**Generate Files:**
+1. `.workflow/issues/solutions/{issue-id}.jsonl` - Solution with tasks for each issue
+
+**Return Summary:**
+```json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "...", "solutions": [...] }],
+  "conflicts": [{ "file": "...", "issues": [...] }]
+}
+```
+
+**Completion Criteria:**
+- [ ] Solution file generated for each issue
+- [ ] Single solution → auto-bound via `ccw issue bind`
+- [ ] Multiple solutions → returned for user selection
+- [ ] Tasks conform to schema: `cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json`
+- [ ] Each task has quantified `delivery_criteria`
+
+## Core Capabilities

-**Core capabilities:**
 - **Closed-loop agent**: issue-plan-agent combines explore + plan
 - Batch processing: 1 agent processes 1-3 issues
 - ACE semantic search integrated into planning
- Solution with executable tasks and acceptance criteria
+- Solution with executable tasks and delivery criteria
 - Automatic solution registration and binding

 ## Storage Structure (Flat JSONL)
@@ -75,120 +97,90 @@ Phase 4: Summary

 ## Implementation

-### Phase 1: Issue Loading
+### Phase 1: Issue Loading (IDs Only)

 ```javascript
-// Parse input
-const issueIds = userInput.includes(',')
-  ? userInput.split(',').map(s => s.trim())
-  : [userInput.trim()];
+const batchSize = flags.batchSize || 3;
+let issueIds = [];

-// Read issues.jsonl
-const issuesPath = '.workflow/issues/issues.jsonl';
-const allIssues = Bash(`cat "${issuesPath}" 2>/dev/null || echo ''`)
-  .split('\n')
-  .filter(line => line.trim())
-  .map(line => JSON.parse(line));
+if (flags.allPending) {
+  // Get pending issue IDs directly via CLI
+  const ids = Bash(`ccw issue list --status pending,registered --ids`).trim();
+  issueIds = ids ? ids.split('\n').filter(Boolean) : [];

-// Load and validate issues
-const issues = [];
-for (const id of issueIds) {
-  let issue = allIssues.find(i => i.id === id);
-
-  if (!issue) {
-    console.log(`Issue ${id} not found. Creating...`);
-    issue = {
-      id,
-      title: `Issue ${id}`,
-      status: 'registered',
-      priority: 3,
-      context: '',
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString()
-    };
-    // Append to issues.jsonl
-    Bash(`echo '${JSON.stringify(issue)}' >> "${issuesPath}"`);
+  if (issueIds.length === 0) {
+    console.log('No pending issues found.');
+    return;
  }
+  console.log(`Found ${issueIds.length} pending issues`);
+} else {
+  // Parse comma-separated issue IDs
+  issueIds = userInput.includes(',')
+    ? userInput.split(',').map(s => s.trim())
+    : [userInput.trim()];

-  issues.push(issue);
+  // Create if not exists
+  for (const id of issueIds) {
+    Bash(`ccw issue init ${id} --title "Issue ${id}" 2>/dev/null || true`);
+  }
 }

 // Group into batches
-const batchSize = flags.batchSize || 3;
 const batches = [];
-for (let i = 0; i < issues.length; i += batchSize) {
-  batches.push(issues.slice(i, i + batchSize));
+for (let i = 0; i < issueIds.length; i += batchSize) {
+  batches.push(issueIds.slice(i, i + batchSize));
 }

+console.log(`Processing ${issueIds.length} issues in ${batches.length} batch(es)`);
+
 TodoWrite({
-  todos: batches.flatMap((batch, i) => [
-    { content: `Plan batch ${i+1}`, status: 'pending', activeForm: `Planning batch ${i+1}` }
-  ])
+  todos: batches.map((_, i) => ({
+    content: `Plan batch ${i+1}`,
+    status: 'pending',
+    activeForm: `Planning batch ${i+1}`
+  }))
 });
 ```

 ### Phase 2: Unified Explore + Plan (issue-plan-agent)

 ```javascript
+Bash(`mkdir -p .workflow/issues/solutions`);
+const pendingSelections = [];  // Collect multi-solution issues for user selection
+
 for (const [batchIndex, batch] of batches.entries()) {
  updateTodo(`Plan batch ${batchIndex + 1}`, 'in_progress');

-  // Build issue prompt for agent with lifecycle requirements
+  // Build minimal prompt - agent handles exploration, planning, and binding
  const issuePrompt = `
-## Issues to Plan (Closed-Loop Tasks Required)
+## Plan Issues

-${batch.map((issue, i) => `
-### Issue ${i + 1}: ${issue.id}
-**Title**: ${issue.title}
-**Context**: ${issue.context || 'No context provided'}
-**Affected Components**: ${issue.affected_components?.join(', ') || 'Not specified'}
+**Issue IDs**: ${batch.join(', ')}
+**Project Root**: ${process.cwd()}

-**Lifecycle Requirements**:
- Test Strategy: ${issue.lifecycle_requirements?.test_strategy || 'auto'}
- Regression Scope: ${issue.lifecycle_requirements?.regression_scope || 'affected'}
- Commit Strategy: ${issue.lifecycle_requirements?.commit_strategy || 'per-task'}
-`).join('\n')}
+### Steps
+1. Fetch: \`ccw issue status <id> --json\`
+2. Explore (ACE) → Plan solution
+3. Register & bind: \`ccw issue bind <id> --solution <file>\`

-## Project Root
-${process.cwd()}
+### Generate Files
+\`.workflow/issues/solutions/{issue-id}.jsonl\` - Solution with tasks (schema: cat .claude/workflows/cli-templates/schemas/issue-task-jsonl-schema.json)

-## Requirements - CLOSED-LOOP TASKS
+### Binding Rules
+- **Single solution**: Auto-bind via \`ccw issue bind <id> --solution <file>\`
+- **Multiple solutions**: Register only, return for user selection

-Each task MUST include ALL lifecycle phases:
-
-### 1. Implementation
- implementation: string[] (2-7 concrete steps)
- modification_points: { file, target, change }[]
-
-### 2. Test
- test.unit: string[] (unit test requirements)
- test.integration: string[] (integration test requirements if needed)
- test.commands: string[] (actual test commands to run)
- test.coverage_target: number (minimum coverage %)
-
-### 3. Regression
- regression: string[] (commands to run for regression check)
- Based on issue's regression_scope setting
-
-### 4. Acceptance
- acceptance.criteria: string[] (testable acceptance criteria)
- acceptance.verification: string[] (how to verify each criterion)
- acceptance.manual_checks: string[] (manual checks if needed)
-
-### 5. Commit
- commit.type: feat|fix|refactor|test|docs|chore
- commit.scope: string (module name)
- commit.message_template: string (full commit message)
- commit.breaking: boolean
-
-## Additional Requirements
-1. Use ACE semantic search (mcp__ace-tool__search_context) for exploration
-2. Detect file conflicts if multiple issues
-3. Generate executable test commands based on project's test framework
-4. Infer commit scope from affected files
+### Return Summary
+\`\`\`json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "...", "description": "...", "task_count": N }] }],
+  "conflicts": [{ "file": "...", "issues": [...] }]
+}
+\`\`\`
 `;

-  // Launch issue-plan-agent (combines explore + plan)
+  // Launch issue-plan-agent - agent writes solutions directly
  const result = Task(
    subagent_type="issue-plan-agent",
    run_in_background=false,
@@ -196,202 +188,68 @@ Each task MUST include ALL lifecycle phases:
    prompt=issuePrompt
  );

-  // Parse agent output
-  const agentOutput = JSON.parse(result);
+  // Parse summary from agent
+  const summary = JSON.parse(result);

-  // Register solutions for each issue (append to solutions/{issue-id}.jsonl)
-  for (const item of agentOutput.solutions) {
-    const solutionPath = `.workflow/issues/solutions/${item.issue_id}.jsonl`;
-
-    // Ensure solutions directory exists
-    Bash(`mkdir -p .workflow/issues/solutions`);
-
-    // Append solution as new line
-    Bash(`echo '${JSON.stringify(item.solution)}' >> "${solutionPath}"`);
+  // Display auto-bound solutions
+  for (const item of summary.bound || []) {
+    console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
  }

-  // Handle conflicts if any
-  if (agentOutput.conflicts?.length > 0) {
-    console.log(`\n⚠ File conflicts detected:`);
-    agentOutput.conflicts.forEach(c => {
-      console.log(`  ${c.file}: ${c.issues.join(', ')} → suggested: ${c.suggested_order.join(' → ')}`);
-    });
+  // Collect pending selections for Phase 3
+  pendingSelections.push(...(summary.pending_selection || []));
+
+  // Show conflicts
+  if (summary.conflicts?.length > 0) {
+    console.log(`⚠ Conflicts: ${summary.conflicts.map(c => c.file).join(', ')}`);
  }

  updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
 }
 ```

-### Phase 3: Solution Binding
+### Phase 3: Multi-Solution Selection

 ```javascript
-// Re-read issues.jsonl
-let allIssuesUpdated = Bash(`cat "${issuesPath}"`)
-  .split('\n')
-  .filter(line => line.trim())
-  .map(line => JSON.parse(line));
+// Only handle issues where agent generated multiple solutions
+if (pendingSelections.length > 0) {
+  const answer = AskUserQuestion({
+    questions: pendingSelections.map(({ issue_id, solutions }) => ({
+      question: `Select solution for ${issue_id}:`,
+      header: issue_id,
+      multiSelect: false,
+      options: solutions.map(s => ({
+        label: `${s.id} (${s.task_count} tasks)`,
+        description: s.description
+      }))
+    }))
+  });

-for (const issue of issues) {
-  const solPath = `.workflow/issues/solutions/${issue.id}.jsonl`;
-  const solutions = Bash(`cat "${solPath}" 2>/dev/null || echo ''`)
-    .split('\n')
-    .filter(line => line.trim())
-    .map(line => JSON.parse(line));
-
-  if (solutions.length === 0) {
-    console.log(`⚠ No solutions for ${issue.id}`);
-    continue;
+  // Bind user-selected solutions
+  for (const { issue_id } of pendingSelections) {
+    const selectedId = extractSelectedSolutionId(answer, issue_id);
+    if (selectedId) {
+      Bash(`ccw issue bind ${issue_id} ${selectedId}`);
+      console.log(`✓ ${issue_id}: ${selectedId} bound`);
+    }
  }
-
-  let selectedSolId;
-
-  if (solutions.length === 1) {
-    // Auto-bind single solution
-    selectedSolId = solutions[0].id;
-    console.log(`✓ Auto-bound ${selectedSolId} to ${issue.id} (${solutions[0].tasks?.length || 0} tasks)`);
-  } else {
-    // Multiple solutions - ask user
-    const answer = AskUserQuestion({
-      questions: [{
-        question: `Select solution for ${issue.id}:`,
-        header: issue.id,
-        multiSelect: false,
-        options: solutions.map(s => ({
-          label: `${s.id}: ${s.description || 'Solution'}`,
-          description: `${s.tasks?.length || 0} tasks`
-        }))
-      }]
-    });
-
-    selectedSolId = extractSelectedSolutionId(answer);
-    console.log(`✓ Bound ${selectedSolId} to ${issue.id}`);
-  }
-
-  // Update issue in allIssuesUpdated
-  const issueIndex = allIssuesUpdated.findIndex(i => i.id === issue.id);
-  if (issueIndex !== -1) {
-    allIssuesUpdated[issueIndex].bound_solution_id = selectedSolId;
-    allIssuesUpdated[issueIndex].status = 'planned';
-    allIssuesUpdated[issueIndex].planned_at = new Date().toISOString();
-    allIssuesUpdated[issueIndex].updated_at = new Date().toISOString();
-  }
-
-  // Mark solution as bound in solutions file
-  const updatedSolutions = solutions.map(s => ({
-    ...s,
-    is_bound: s.id === selectedSolId,
-    bound_at: s.id === selectedSolId ? new Date().toISOString() : s.bound_at
-  }));
-  Write(solPath, updatedSolutions.map(s => JSON.stringify(s)).join('\n'));
 }
-
-// Write updated issues.jsonl
-Write(issuesPath, allIssuesUpdated.map(i => JSON.stringify(i)).join('\n'));
 ```

 ### Phase 4: Summary

 ```javascript
+// Count planned issues via CLI
+const plannedIds = Bash(`ccw issue list --status planned --ids`).trim();
+const plannedCount = plannedIds ? plannedIds.split('\n').length : 0;
+
 console.log(`
-## Planning Complete
+## Done: ${issueIds.length} issues → ${plannedCount} planned

-**Issues Planned**: ${issues.length}
-
-### Bound Solutions
-${issues.map(i => {
-  const issue = allIssuesUpdated.find(a => a.id === i.id);
-  return issue?.bound_solution_id
-    ? `✓ ${i.id}: ${issue.bound_solution_id}`
-    : `○ ${i.id}: No solution bound`;
-}).join('\n')}
-
-### Next Steps
-1. Review: \`ccw issue status <issue-id>\`
-2. Form queue: \`/issue:queue\`
-3. Execute: \`/issue:execute\`
+Next: \`/issue:queue\` → \`/issue:execute\`
 `);
 ```

-## Solution Format (Closed-Loop Tasks)
-
-Each solution line in `solutions/{issue-id}.jsonl`:
-
-```json
-{
-  "id": "SOL-20251226-001",
-  "description": "Direct Implementation",
-  "tasks": [
-    {
-      "id": "T1",
-      "title": "Create auth middleware",
-      "scope": "src/middleware/",
-      "action": "Create",
-      "description": "Create JWT validation middleware",
-      "modification_points": [
-        { "file": "src/middleware/auth.ts", "target": "new file", "change": "Create middleware" }
-      ],
-
-      "implementation": [
-        "Create auth.ts file in src/middleware/",
-        "Implement JWT token validation using jsonwebtoken",
-        "Add error handling for invalid/expired tokens",
-        "Export middleware function"
-      ],
-
-      "test": {
-        "unit": [
-          "Test valid token passes through",
-          "Test invalid token returns 401",
-          "Test expired token returns 401",
-          "Test missing token returns 401"
-        ],
-        "commands": [
-          "npm test -- --grep 'auth middleware'",
-          "npm run test:coverage -- src/middleware/auth.ts"
-        ],
-        "coverage_target": 80
-      },
-
-      "regression": [
-        "npm test -- --grep 'protected routes'",
-        "npm run test:integration -- auth"
-      ],
-
-      "acceptance": {
-        "criteria": [
-          "Middleware validates JWT tokens successfully",
-          "Returns 401 for invalid or missing tokens",
-          "Passes decoded token to request context"
-        ],
-        "verification": [
-          "curl -H 'Authorization: Bearer valid_token' /api/protected → 200",
-          "curl /api/protected → 401",
-          "curl -H 'Authorization: Bearer invalid' /api/protected → 401"
-        ]
-      },
-
-      "commit": {
-        "type": "feat",
-        "scope": "auth",
-        "message_template": "feat(auth): add JWT validation middleware\n\n- Implement token validation\n- Add error handling for invalid tokens\n- Export for route protection",
-        "breaking": false
-      },
-
-      "depends_on": [],
-      "estimated_minutes": 30,
-      "executor": "codex"
-    }
-  ],
-  "exploration_context": {
-    "relevant_files": ["src/config/auth.ts"],
-    "patterns": "Follow existing middleware pattern"
-  },
-  "is_bound": true,
-  "created_at": "2025-12-26T10:00:00Z",
-  "bound_at": "2025-12-26T10:05:00Z"
-}
-```
-
 ## Error Handling

 | Error | Resolution |
@@ -402,17 +260,6 @@ Each solution line in `solutions/{issue-id}.jsonl`:
 | User cancels selection | Skip issue, continue with others |
 | File conflicts | Agent detects and suggests resolution order |

-## Agent Integration
-
-The command uses `issue-plan-agent` which:
-1. Performs ACE semantic search per issue
-2. Identifies modification points and patterns
-3. Generates task breakdown with dependencies
-4. Detects cross-issue file conflicts
-5. Outputs solution JSON for registration
-
-See `.claude/agents/issue-plan-agent.md` for agent specification.
-
 ## Related Commands

 - `/issue:queue` - Form execution queue from bound solutions
--- a/.claude/commands/issue/queue.md
+++ b/.claude/commands/issue/queue.md
@@ -9,16 +9,39 @@ allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)

 ## Overview

-Queue formation command using **issue-queue-agent** that analyzes all bound solutions, resolves conflicts, determines dependencies, and creates an ordered execution queue. The queue is global across all issues.
+Queue formation command using **issue-queue-agent** that analyzes all bound solutions, resolves conflicts, and creates an ordered execution queue.
+
+## Output Requirements
+
+**Generate Files:**
+1. `.workflow/issues/queues/{queue-id}.json` - Full queue with tasks, conflicts, groups
+2. `.workflow/issues/queues/index.json` - Update with new queue entry
+
+**Return Summary:**
+```json
+{
+  "queue_id": "QUE-20251227-143000",
+  "total_tasks": N,
+  "execution_groups": [{ "id": "P1", "type": "parallel", "count": N }],
+  "conflicts_resolved": N,
+  "issues_queued": ["GH-123", "GH-124"]
+}
+```
+
+**Completion Criteria:**
+- [ ] Queue JSON generated with valid DAG (no cycles)
+- [ ] All file conflicts resolved with rationale
+- [ ] Semantic priority calculated for all tasks
+- [ ] Execution groups assigned (parallel P* / sequential S*)
+- [ ] Issue statuses updated to `queued` via `ccw issue update`
+
+## Core Capabilities

-**Core capabilities:**
 - **Agent-driven**: issue-queue-agent handles all ordering logic
- ACE semantic search for relationship discovery
 - Dependency DAG construction and cycle detection
 - File conflict detection and resolution
 - Semantic priority calculation (0.0-1.0)
 - Parallel/Sequential group assignment
- Output global queue.json

 ## Storage Structure (Queue History)

@@ -77,10 +100,12 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
 # Flags
 --issue <id>          Form queue for specific issue only
 --append <id>         Append issue to active queue (don't create new)
--list                List all queues with status
--switch <queue-id>   Switch active queue
--archive             Archive current queue (mark completed)
--clear <queue-id>    Delete a queue from history
+
+# CLI subcommands (ccw issue queue ...)
+ccw issue queue list                  List all queues with status
+ccw issue queue switch <queue-id>     Switch active queue
+ccw issue queue archive               Archive current queue
+ccw issue queue delete <queue-id>     Delete queue from history
 ```

 ## Execution Process
@@ -166,165 +191,93 @@ console.log(`Loaded ${allTasks.length} tasks from ${plannedIssues.length} issues
 ### Phase 2-4: Agent-Driven Queue Formation

 ```javascript
-// Launch issue-queue-agent to handle all ordering logic
+// Build minimal prompt - agent reads schema and handles ordering
 const agentPrompt = `
-## Tasks to Order
+## Order Tasks

-${JSON.stringify(allTasks, null, 2)}
+**Tasks**: ${allTasks.length} from ${plannedIssues.length} issues
+**Project Root**: ${process.cwd()}

-## Project Root
-${process.cwd()}
+### Input
+\`\`\`json
+${JSON.stringify(allTasks.map(t => ({
+  key: \`\${t.issue_id}:\${t.task.id}\`,
+  type: t.task.type,
+  file_context: t.task.file_context,
+  depends_on: t.task.depends_on
+})), null, 2)}
+\`\`\`

-## Requirements
-1. Build dependency DAG from depends_on fields
-2. Detect circular dependencies (abort if found)
-3. Identify file modification conflicts
-4. Resolve conflicts using ordering rules:
-   - Create before Update/Implement
-   - Foundation scopes (config/types) before implementation
-   - Core logic before tests
-5. Calculate semantic priority (0.0-1.0) for each task
-6. Assign execution groups (parallel P* / sequential S*)
-7. Output queue JSON
+### Steps
+1. Parse tasks: Extract task keys, types, file contexts, dependencies
+2. Build DAG: Construct dependency graph from depends_on references
+3. Detect cycles: Verify no circular dependencies exist (abort if found)
+4. Detect conflicts: Identify file modification conflicts across issues
+5. Resolve conflicts: Apply ordering rules (Create→Update→Delete, config→src→tests)
+6. Calculate priority: Compute semantic priority (0.0-1.0) for each task
+7. Assign groups: Assign parallel (P*) or sequential (S*) execution groups
+8. Generate queue: Write queue JSON with ordered tasks
+9. Update index: Update queues/index.json with new queue entry
+
+### Rules
+- **DAG Validity**: Output must be valid DAG with no circular dependencies
+- **Conflict Resolution**: All file conflicts must be resolved with rationale
+- **Ordering Priority**:
+  1. Create before Update (files must exist before modification)
+  2. Foundation before integration (config/ → src/)
+  3. Types before implementation (types/ → components/)
+  4. Core before tests (src/ → __tests__/)
+  5. Delete last (preserve dependencies until no longer needed)
+- **Parallel Safety**: Tasks in same parallel group must have no file conflicts
+- **Queue ID Format**: \`QUE-YYYYMMDD-HHMMSS\` (UTC timestamp)
+
+### Generate Files
+1. \`.workflow/issues/queues/\${queueId}.json\` - Full queue (schema: cat .claude/workflows/cli-templates/schemas/queue-schema.json)
+2. \`.workflow/issues/queues/index.json\` - Update with new entry
+
+### Return Summary
+\`\`\`json
+{
+  "queue_id": "QUE-YYYYMMDD-HHMMSS",
+  "total_tasks": N,
+  "execution_groups": [{ "id": "P1", "type": "parallel", "count": N }],
+  "conflicts_resolved": N,
+  "issues_queued": ["GH-123"]
+}
+\`\`\`
 `;

 const result = Task(
  subagent_type="issue-queue-agent",
  run_in_background=false,
-  description=`Order ${allTasks.length} tasks from ${plannedIssues.length} issues`,
+  description=`Order ${allTasks.length} tasks`,
  prompt=agentPrompt
 );

-// Parse agent output
-const agentOutput = JSON.parse(result);
-
-if (!agentOutput.success) {
-  console.error(`Queue formation failed: ${agentOutput.error}`);
-  if (agentOutput.cycles) {
-    console.error('Circular dependencies:', agentOutput.cycles.join(', '));
-  }
-  return;
-}
+const summary = JSON.parse(result);
 ```

-### Phase 5: Queue Output & Summary
+### Phase 5: Summary & Status Update

 ```javascript
-const queueOutput = agentOutput.output;
-
-// Write queue.json
-Write('.workflow/issues/queue.json', JSON.stringify(queueOutput, null, 2));
-
-// Update issue statuses in issues.jsonl
-const updatedIssues = allIssues.map(issue => {
-  if (plannedIssues.find(p => p.id === issue.id)) {
-    return {
-      ...issue,
-      status: 'queued',
-      queued_at: new Date().toISOString(),
-      updated_at: new Date().toISOString()
-    };
-  }
-  return issue;
-});
-
-Write(issuesPath, updatedIssues.map(i => JSON.stringify(i)).join('\n'));
-
-// Display summary
+// Agent already generated queue files, use summary
 console.log(`
-## Queue Formed
+## Queue Formed: ${summary.queue_id}

-**Total Tasks**: ${queueOutput.queue.length}
-**Issues**: ${plannedIssues.length}
-**Conflicts**: ${queueOutput.conflicts?.length || 0} (${queueOutput._metadata?.resolved_conflicts || 0} resolved)
+**Tasks**: ${summary.total_tasks}
+**Issues**: ${summary.issues_queued.join(', ')}
+**Groups**: ${summary.execution_groups.map(g => `${g.id}(${g.count})`).join(', ')}
+**Conflicts Resolved**: ${summary.conflicts_resolved}

-### Execution Groups
-${(queueOutput.execution_groups || []).map(g => {
-  const type = g.type === 'parallel' ? 'Parallel' : 'Sequential';
-  return `- ${g.id} (${type}): ${g.task_count} tasks`;
-}).join('\n')}
-
-### Next Steps
-1. Review queue: \`ccw issue queue list\`
-2. Execute: \`/issue:execute\`
+Next: \`/issue:execute\`
 `);
-```

-## Queue Schema
-
-Output `queues/{queue-id}.json`:
-
-```json
-{
-  "id": "QUE-20251227-143000",
-  "name": "Auth Feature Queue",
-  "status": "active",
-  "issue_ids": ["GH-123", "GH-124"],
-
-  "queue": [
-    {
-      "queue_id": "Q-001",
-      "issue_id": "GH-123",
-      "solution_id": "SOL-001",
-      "task_id": "T1",
-      "status": "pending",
-      "execution_order": 1,
-      "execution_group": "P1",
-      "depends_on": [],
-      "semantic_priority": 0.7,
-      "queued_at": "2025-12-26T10:00:00Z"
-    }
-  ],
-
-  "conflicts": [
-    {
-      "type": "file_conflict",
-      "file": "src/auth.ts",
-      "tasks": ["GH-123:T1", "GH-124:T2"],
-      "resolution": "sequential",
-      "resolution_order": ["GH-123:T1", "GH-124:T2"],
-      "rationale": "T1 creates file before T2 updates",
-      "resolved": true
-    }
-  ],
-
-  "execution_groups": [
-    { "id": "P1", "type": "parallel", "task_count": 3, "tasks": ["GH-123:T1", "GH-124:T1", "GH-125:T1"] },
-    { "id": "S2", "type": "sequential", "task_count": 2, "tasks": ["GH-123:T2", "GH-124:T2"] }
-  ],
-
-  "_metadata": {
-    "version": "2.0",
-    "total_tasks": 5,
-    "pending_count": 3,
-    "completed_count": 2,
-    "failed_count": 0,
-    "created_at": "2025-12-26T10:00:00Z",
-    "updated_at": "2025-12-26T11:00:00Z",
-    "source": "issue-queue-agent"
-  }
+// Update issue statuses via CLI
+for (const issueId of summary.issues_queued) {
+  Bash(`ccw issue update ${issueId} --status queued`);
 }
 ```

-### Queue ID Format
-
-```
-QUE-YYYYMMDD-HHMMSS
-例如: QUE-20251227-143052
-```
-
-## Semantic Priority Rules
-
-| Factor | Priority Boost |
-|--------|---------------|
-| Create action | +0.2 |
-| Configure action | +0.15 |
-| Implement action | +0.1 |
-| Config/Types scope | +0.1 |
-| Refactor action | -0.05 |
-| Test action | -0.1 |
-| Delete action | -0.15 |
-
 ## Error Handling

 | Error | Resolution |
@@ -334,19 +287,6 @@ QUE-YYYYMMDD-HHMMSS
 | Unresolved conflicts | Agent resolves using ordering rules |
 | Invalid task reference | Skip and warn |

-## Agent Integration
-
-The command uses `issue-queue-agent` which:
-1. Builds dependency DAG from task depends_on fields
-2. Detects circular dependencies (aborts if found)
-3. Identifies file modification conflicts across issues
-4. Resolves conflicts using semantic ordering rules
-5. Calculates priority (0.0-1.0) for each task
-6. Assigns parallel/sequential execution groups
-7. Outputs structured queue JSON
-
-See `.claude/agents/issue-queue-agent.md` for agent specification.
-
 ## Related Commands

 - `/issue:plan` - Plan issues and bind solutions
--- a/.claude/skills/issue-manage/SKILL.md
+++ b/.claude/skills/issue-manage/SKILL.md
@@ -0,0 +1,244 @@
+---
+name: issue-manage
+description: Interactive issue management with menu-driven CRUD operations. Use when managing issues, viewing issue status, editing issue fields, or performing bulk operations on issues. Triggers on "manage issue", "list issues", "edit issue", "delete issue", "bulk update", "issue dashboard".
+allowed-tools: Bash, Read, Write, AskUserQuestion, Task, Glob
+---
+
+# Issue Management Skill
+
+Interactive menu-driven interface for issue CRUD operations via `ccw issue` CLI.
+
+## Quick Start
+
+Ask me:
+- "Show all issues" → List with filters
+- "View issue GH-123" → Detailed inspection
+- "Edit issue priority" → Modify fields
+- "Delete old issues" → Remove with confirmation
+- "Bulk update status" → Batch operations
+
+## CLI Endpoints
+
+```bash
+# Core operations
+ccw issue list                      # List all issues
+ccw issue list <id> --json          # Get issue details
+ccw issue status <id>               # Detailed status
+ccw issue init <id> --title "..."   # Create issue
+ccw issue task <id> --title "..."   # Add task
+ccw issue bind <id> <solution-id>   # Bind solution
+
+# Queue management
+ccw issue queue                     # List current queue
+ccw issue queue add <id>            # Add to queue
+ccw issue queue list                # Queue history
+ccw issue queue switch <queue-id>   # Switch queue
+ccw issue queue archive             # Archive queue
+ccw issue queue delete <queue-id>   # Delete queue
+ccw issue next                      # Get next task
+ccw issue done <queue-id>           # Mark completed
+```
+
+## Operations
+
+### 1. LIST 📋
+
+Filter and browse issues:
+
+```
+┌─ Filter by Status ─────────────────┐
+│ □ All        □ Registered          │
+│ □ Planned    □ Queued              │
+│ □ Executing  □ Completed           │
+└────────────────────────────────────┘
+```
+
+**Flow**:
+1. Ask filter preferences → `ccw issue list --json`
+2. Display table: ID | Status | Priority | Title
+3. Select issue for detail view
+
+### 2. VIEW 🔍
+
+Detailed issue inspection:
+
+```
+┌─ Issue: GH-123 ─────────────────────┐
+│ Title: Fix authentication bug       │
+│ Status: planned | Priority: P2      │
+│ Solutions: 2 (1 bound)              │
+│ Tasks: 5 pending                    │
+└─────────────────────────────────────┘
+```
+
+**Flow**:
+1. Fetch `ccw issue status <id> --json`
+2. Display issue + solutions + tasks
+3. Offer actions: Edit | Plan | Queue | Delete
+
+### 3. EDIT ✏️
+
+Modify issue fields:
+
+| Field | Options |
+|-------|---------|
+| Title | Free text |
+| Priority | P1-P5 |
+| Status | registered → completed |
+| Context | Problem description |
+| Labels | Comma-separated |
+
+**Flow**:
+1. Select field to edit
+2. Show current value
+3. Collect new value via AskUserQuestion
+4. Update `.workflow/issues/issues.jsonl`
+
+### 4. DELETE 🗑️
+
+Remove with confirmation:
+
+```
+⚠️ Delete issue GH-123?
+This will also remove:
+- Associated solutions
+- Queued tasks
+
+[Delete] [Cancel]
+```
+
+**Flow**:
+1. Confirm deletion via AskUserQuestion
+2. Remove from `issues.jsonl`
+3. Clean up `solutions/<id>.jsonl`
+4. Remove from `queue.json`
+
+### 5. BULK 📦
+
+Batch operations:
+
+| Operation | Description |
+|-----------|-------------|
+| Update Status | Change multiple issues |
+| Update Priority | Batch priority change |
+| Add Labels | Tag multiple issues |
+| Delete Multiple | Bulk removal |
+| Queue All Planned | Add all planned to queue |
+| Retry All Failed | Reset failed tasks |
+
+## Workflow
+
+```
+┌──────────────────────────────────────┐
+│         Main Menu                    │
+│  ┌────┐ ┌────┐ ┌────┐ ┌────┐        │
+│  │List│ │View│ │Edit│ │Bulk│        │
+│  └──┬─┘ └──┬─┘ └──┬─┘ └──┬─┘        │
+└─────┼──────┼──────┼──────┼──────────┘
+      │      │      │      │
+      ▼      ▼      ▼      ▼
+   Filter  Detail  Fields  Multi
+   Select  Actions Update  Select
+      │      │      │      │
+      └──────┴──────┴──────┘
+                │
+                ▼
+         Back to Menu
+```
+
+## Implementation Guide
+
+### Entry Point
+
+```javascript
+// Parse input for issue ID
+const issueId = input.match(/^([A-Z]+-\d+|ISS-\d+)/i)?.[1];
+
+// Show main menu
+await showMainMenu(issueId);
+```
+
+### Main Menu Pattern
+
+```javascript
+// 1. Fetch dashboard data
+const issues = JSON.parse(Bash('ccw issue list --json') || '[]');
+const queue = JSON.parse(Bash('ccw issue queue --json 2>/dev/null') || '{}');
+
+// 2. Display summary
+console.log(`Issues: ${issues.length} | Queue: ${queue.pending_count || 0} pending`);
+
+// 3. Ask action via AskUserQuestion
+const action = AskUserQuestion({
+  questions: [{
+    question: 'What would you like to do?',
+    header: 'Action',
+    options: [
+      { label: 'List Issues', description: 'Browse with filters' },
+      { label: 'View Issue', description: 'Detail view' },
+      { label: 'Edit Issue', description: 'Modify fields' },
+      { label: 'Bulk Operations', description: 'Batch actions' }
+    ]
+  }]
+});
+
+// 4. Route to handler
+```
+
+### Filter Pattern
+
+```javascript
+const filter = AskUserQuestion({
+  questions: [{
+    question: 'Filter by status?',
+    header: 'Filter',
+    multiSelect: true,
+    options: [
+      { label: 'All', description: 'Show all' },
+      { label: 'Registered', description: 'Unplanned' },
+      { label: 'Planned', description: 'Has solution' },
+      { label: 'Executing', description: 'In progress' }
+    ]
+  }]
+});
+```
+
+### Edit Pattern
+
+```javascript
+// Select field
+const field = AskUserQuestion({...});
+
+// Get new value based on field type
+// For Priority: show P1-P5 options
+// For Status: show status options
+// For Title: accept free text via "Other"
+
+// Update file
+const issuesPath = '.workflow/issues/issues.jsonl';
+// Read → Parse → Update → Write
+```
+
+## Data Files
+
+| File | Purpose |
+|------|---------|
+| `.workflow/issues/issues.jsonl` | Issue records |
+| `.workflow/issues/solutions/<id>.jsonl` | Solutions per issue |
+| `.workflow/issues/queue.json` | Execution queue |
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| No issues found | Suggest `/issue:new` to create |
+| Issue not found | Show available issues, re-prompt |
+| Write failure | Check file permissions |
+| Queue error | Display ccw error message |
+
+## Related Commands
+
+- `/issue:new` - Create structured issue
+- `/issue:plan` - Generate solution
+- `/issue:queue` - Form execution queue
+- `/issue:execute` - Execute tasks
--- a/.codex/prompts/issue-execute.md
+++ b/.codex/prompts/issue-execute.md
@@ -21,7 +21,7 @@ WHILE task exists:
     - TEST: Run task.test commands
     - VERIFY: Check task.acceptance criteria
     - COMMIT: Stage files, commit with task.commit.message_template
-  3. Report completion via ccw issue complete <queue_id>
+  3. Report completion via ccw issue complete <item_id>
  4. Fetch next task via ccw issue next

 WHEN queue empty:
@@ -37,7 +37,7 @@ ccw issue next
 ```

 This returns JSON with the full task definition:
- `queue_id`: Unique ID for queue tracking (e.g., "Q-001")
+- `item_id`: Unique task identifier in queue (e.g., "T-1")
 - `issue_id`: Parent issue ID (e.g., "ISSUE-20251227-001")
 - `task`: Full task definition with implementation steps
 - `context`: Relevant files and patterns
@@ -51,7 +51,7 @@ Expected task structure:

 ```json
 {
-  "queue_id": "Q-001",
+  "item_id": "T-1",
  "issue_id": "ISSUE-20251227-001",
  "solution_id": "SOL-001",
  "task": {
@@ -159,7 +159,7 @@ git add path/to/file1.ts path/to/file2.ts ...
 git commit -m "$(cat <<'EOF'
 [task.commit.message_template]

-Queue-ID: [queue_id]
+Item-ID: [item_id]
 Issue-ID: [issue_id]
 Task-ID: [task.id]
 EOF
@@ -180,7 +180,7 @@ EOF
 After commit succeeds, report to queue system:

 ```bash
-ccw issue complete [queue_id] --result '{
+ccw issue complete [item_id] --result '{
  "files_modified": ["path1", "path2"],
  "tests_passed": true,
  "acceptance_passed": true,
@@ -193,7 +193,7 @@ ccw issue complete [queue_id] --result '{
 **If task failed and cannot be fixed:**

 ```bash
-ccw issue fail [queue_id] --reason "Phase [X] failed: [details]"
+ccw issue fail [item_id] --reason "Phase [X] failed: [details]"
 ```

 ## Step 5: Continue to Next Task
@@ -206,7 +206,7 @@ ccw issue next

 **Output progress:**
 ```
-✓ [N/M] Completed: [queue_id] - [task.title]
+✓ [N/M] Completed: [item_id] - [task.title]
 → Fetching next task...
 ```

@@ -221,10 +221,10 @@ When `ccw issue next` returns `{ "status": "empty" }`:

 **Total Tasks Executed**: N
 **All Commits**:
-| # | Queue ID | Task | Commit |
-|---|----------|------|--------|
-| 1 | Q-001 | Task title | abc123 |
-| 2 | Q-002 | Task title | def456 |
+| # | Item ID | Task | Commit |
+|---|---------|------|--------|
+| 1 | T-1 | Task title | abc123 |
+| 2 | T-2 | Task title | def456 |

 **Files Modified**:
 - path/to/file1.ts
--- a/ccw/src/cli.ts
+++ b/ccw/src/cli.ts
@@ -277,6 +277,7 @@ export function run(argv: string[]): void {
    .option('--priority <n>', 'Task priority (1-5)')
    .option('--format <fmt>', 'Output format: json, markdown')
    .option('--json', 'Output as JSON')
+    .option('--ids', 'List only IDs (one per line, for scripting)')
    .option('--force', 'Force operation')
    // New options for solution/queue management
    .option('--solution <path>', 'Solution JSON file path')
--- a/ccw/src/commands/issue.ts
+++ b/ccw/src/commands/issue.ts
@@ -5,7 +5,7 @@
 */

 import chalk from 'chalk';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { join, resolve } from 'path';

 // Handle EPIPE errors gracefully
@@ -29,6 +29,18 @@ interface Issue {
  source?: string;
  source_url?: string;
  labels?: string[];
+  // Agent workflow fields
+  affected_components?: string[];
+  lifecycle_requirements?: {
+    test_strategy?: 'unit' | 'integration' | 'e2e' | 'auto';
+    regression_scope?: 'full' | 'related' | 'affected';
+    commit_strategy?: 'per-task' | 'atomic' | 'squash';
+  };
+  problem_statement?: string;
+  expected_behavior?: string;
+  actual_behavior?: string;
+  reproduction_steps?: string[];
+  // Timestamps
  created_at: string;
  updated_at: string;
  planned_at?: string;
@@ -100,17 +112,17 @@ interface Solution {
 }

 interface QueueItem {
-  queue_id: string;
+  item_id: string;               // Task item ID in queue: T-1, T-2, ... (formerly queue_id)
  issue_id: string;
  solution_id: string;
  task_id: string;
+  title?: string;
  status: 'pending' | 'ready' | 'executing' | 'completed' | 'failed' | 'blocked';
  execution_order: number;
  execution_group: string;
  depends_on: string[];
  semantic_priority: number;
  assigned_executor: 'codex' | 'gemini' | 'agent';
-  queued_at: string;
  started_at?: string;
  completed_at?: string;
  result?: Record<string, any>;
@@ -118,11 +130,11 @@ interface QueueItem {
 }

 interface Queue {
-  id: string;                    // Queue unique ID: QUE-YYYYMMDD-HHMMSS
+  id: string;                    // Queue unique ID: QUE-YYYYMMDD-HHMMSS (derived from filename)
  name?: string;                 // Optional queue name
  status: 'active' | 'completed' | 'archived' | 'failed';
  issue_ids: string[];           // Issues in this queue
-  queue: QueueItem[];
+  tasks: QueueItem[];            // Task items (formerly 'queue')
  conflicts: any[];
  execution_groups?: any[];
  _metadata: {
@@ -132,13 +144,13 @@ interface Queue {
    executing_count: number;
    completed_count: number;
    failed_count: number;
-    created_at: string;
    updated_at: string;
  };
 }

 interface QueueIndex {
  active_queue_id: string | null;
+  active_item_id: string | null;
  queues: {
    id: string;
    status: string;
@@ -162,6 +174,7 @@ interface IssueOptions {
  json?: boolean;
  force?: boolean;
  fail?: boolean;
+  ids?: boolean;        // List only IDs (one per line)
 }

 const ISSUES_DIR = '.workflow/issues';
@@ -278,7 +291,7 @@ function ensureQueuesDir(): void {
 function readQueueIndex(): QueueIndex {
  const path = join(getQueuesDir(), 'index.json');
  if (!existsSync(path)) {
-    return { active_queue_id: null, queues: [] };
+    return { active_queue_id: null, active_item_id: null, queues: [] };
  }
  return JSON.parse(readFileSync(path, 'utf-8'));
 }
@@ -319,16 +332,15 @@ function createEmptyQueue(): Queue {
    id: generateQueueFileId(),
    status: 'active',
    issue_ids: [],
-    queue: [],
+    tasks: [],
    conflicts: [],
    _metadata: {
-      version: '2.0',
+      version: '2.1',
      total_tasks: 0,
      pending_count: 0,
      executing_count: 0,
      completed_count: 0,
      failed_count: 0,
-      created_at: new Date().toISOString(),
      updated_at: new Date().toISOString()
    }
  };
@@ -338,11 +350,11 @@ function writeQueue(queue: Queue): void {
  ensureQueuesDir();

  // Update metadata counts
-  queue._metadata.total_tasks = queue.queue.length;
-  queue._metadata.pending_count = queue.queue.filter(q => q.status === 'pending').length;
-  queue._metadata.executing_count = queue.queue.filter(q => q.status === 'executing').length;
-  queue._metadata.completed_count = queue.queue.filter(q => q.status === 'completed').length;
-  queue._metadata.failed_count = queue.queue.filter(q => q.status === 'failed').length;
+  queue._metadata.total_tasks = queue.tasks.length;
+  queue._metadata.pending_count = queue.tasks.filter(q => q.status === 'pending').length;
+  queue._metadata.executing_count = queue.tasks.filter(q => q.status === 'executing').length;
+  queue._metadata.completed_count = queue.tasks.filter(q => q.status === 'completed').length;
+  queue._metadata.failed_count = queue.tasks.filter(q => q.status === 'failed').length;
  queue._metadata.updated_at = new Date().toISOString();

  // Write queue file
@@ -359,7 +371,7 @@ function writeQueue(queue: Queue): void {
    issue_ids: queue.issue_ids,
    total_tasks: queue._metadata.total_tasks,
    completed_tasks: queue._metadata.completed_count,
-    created_at: queue._metadata.created_at,
+    created_at: queue.id.replace('QUE-', '').replace(/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/, '$1-$2-$3T$4:$5:$6Z'), // Derive from ID
    completed_at: queue.status === 'completed' ? new Date().toISOString() : undefined
  };

@@ -377,11 +389,11 @@ function writeQueue(queue: Queue): void {
 }

 function generateQueueItemId(queue: Queue): string {
-  const maxNum = queue.queue.reduce((max, q) => {
-    const match = q.queue_id.match(/^Q-(\d+)$/);
+  const maxNum = queue.tasks.reduce((max, q) => {
+    const match = q.item_id.match(/^T-(\d+)$/);
    return match ? Math.max(max, parseInt(match[1])) : max;
  }, 0);
-  return `Q-${String(maxNum + 1).padStart(3, '0')}`;
+  return `T-${maxNum + 1}`;
 }

 // ============ Commands ============
@@ -429,7 +441,19 @@ async function initAction(issueId: string | undefined, options: IssueOptions): P
 async function listAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
  if (!issueId) {
    // List all issues
-    const issues = readIssues();
+    let issues = readIssues();
+
+    // Filter by status if specified
+    if (options.status) {
+      const statuses = options.status.split(',').map(s => s.trim());
+      issues = issues.filter(i => statuses.includes(i.status));
+    }
+
+    // IDs only mode (one per line, for scripting)
+    if (options.ids) {
+      issues.forEach(i => console.log(i.id));
+      return;
+    }

    if (options.json) {
      console.log(JSON.stringify(issues, null, 2));
@@ -519,7 +543,8 @@ async function statusAction(issueId: string | undefined, options: IssueOptions):
    const index = readQueueIndex();

    if (options.json) {
-      console.log(JSON.stringify({ queue: queue._metadata, issues: issues.length, queues: index.queues.length }, null, 2));
+      // Return full queue for programmatic access
+      console.log(JSON.stringify(queue, null, 2));
      return;
    }

@@ -806,7 +831,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
  // Archive current queue
  if (subAction === 'archive') {
    const queue = readActiveQueue();
-    if (!queue.id || queue.queue.length === 0) {
+    if (!queue.id || queue.tasks.length === 0) {
      console.log(chalk.yellow('No active queue to archive'));
      return;
    }
@@ -822,6 +847,31 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
    return;
  }

+  // Delete queue from history
+  if ((subAction === 'clear' || subAction === 'delete') && issueId) {
+    const queueId = issueId; // issueId is actually queue ID here
+    const queuePath = join(getQueuesDir(), `${queueId}.json`);
+
+    if (!existsSync(queuePath)) {
+      console.error(chalk.red(`Queue "${queueId}" not found`));
+      process.exit(1);
+    }
+
+    // Remove from index
+    const index = readQueueIndex();
+    index.queues = index.queues.filter(q => q.id !== queueId);
+    if (index.active_queue_id === queueId) {
+      index.active_queue_id = null;
+    }
+    writeQueueIndex(index);
+
+    // Delete queue file
+    unlinkSync(queuePath);
+
+    console.log(chalk.green(`✓ Deleted queue ${queueId}`));
+    return;
+  }
+
  // Add issue tasks to queue
  if (subAction === 'add' && issueId) {
    const issue = findIssue(issueId);
@@ -839,7 +889,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde

    // Get or create active queue (create new if current is completed/archived)
    let queue = readActiveQueue();
-    const isNewQueue = queue.queue.length === 0 || queue.status !== 'active';
+    const isNewQueue = queue.tasks.length === 0 || queue.status !== 'active';

    if (queue.status !== 'active') {
      // Create new queue if current is not active
@@ -853,24 +903,23 @@ async function queueAction(subAction: string | undefined, issueId: string | unde

    let added = 0;
    for (const task of solution.tasks) {
-      const exists = queue.queue.some(q => q.issue_id === issueId && q.task_id === task.id);
+      const exists = queue.tasks.some(q => q.issue_id === issueId && q.task_id === task.id);
      if (exists) continue;

-      queue.queue.push({
-        queue_id: generateQueueItemId(queue),
+      queue.tasks.push({
+        item_id: generateQueueItemId(queue),
        issue_id: issueId,
        solution_id: solution.id,
        task_id: task.id,
        status: 'pending',
-        execution_order: queue.queue.length + 1,
+        execution_order: queue.tasks.length + 1,
        execution_group: 'P1',
        depends_on: task.depends_on.map(dep => {
-          const depItem = queue.queue.find(q => q.task_id === dep && q.issue_id === issueId);
-          return depItem?.queue_id || dep;
+          const depItem = queue.tasks.find(q => q.task_id === dep && q.issue_id === issueId);
+          return depItem?.item_id || dep;
        }),
        semantic_priority: 0.5,
-        assigned_executor: task.executor === 'auto' ? 'codex' : task.executor as any,
-        queued_at: new Date().toISOString()
+        assigned_executor: task.executor === 'auto' ? 'codex' : task.executor as any
      });
      added++;
    }
@@ -895,7 +944,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde

  console.log(chalk.bold.cyan('\nActive Queue\n'));

-  if (!queue.id || queue.queue.length === 0) {
+  if (!queue.id || queue.tasks.length === 0) {
    console.log(chalk.yellow('No active queue'));
    console.log(chalk.gray('Create one: ccw issue queue add <issue-id>'));
    console.log(chalk.gray('Or list history: ccw issue queue list'));
@@ -910,7 +959,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
  console.log(chalk.gray('QueueID'.padEnd(10) + 'Issue'.padEnd(15) + 'Task'.padEnd(8) + 'Status'.padEnd(12) + 'Executor'));
  console.log(chalk.gray('-'.repeat(60)));

-  for (const item of queue.queue) {
+  for (const item of queue.tasks) {
    const statusColor = {
      'pending': chalk.gray,
      'ready': chalk.cyan,
@@ -921,7 +970,7 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
    }[item.status] || chalk.white;

    console.log(
-      item.queue_id.padEnd(10) +
+      item.item_id.padEnd(10) +
      item.issue_id.substring(0, 13).padEnd(15) +
      item.task_id.padEnd(8) +
      statusColor(item.status.padEnd(12)) +
@@ -936,15 +985,21 @@ async function queueAction(subAction: string | undefined, issueId: string | unde
 async function nextAction(options: IssueOptions): Promise<void> {
  const queue = readActiveQueue();

-  // Find ready tasks
-  const readyTasks = queue.queue.filter(item => {
+  // Priority 1: Resume executing tasks (interrupted/crashed)
+  const executingTasks = queue.tasks.filter(item => item.status === 'executing');
+
+  // Priority 2: Find pending tasks with satisfied dependencies
+  const pendingTasks = queue.tasks.filter(item => {
    if (item.status !== 'pending') return false;
    return item.depends_on.every(depId => {
-      const dep = queue.queue.find(q => q.queue_id === depId);
+      const dep = queue.tasks.find(q => q.item_id === depId);
      return !dep || dep.status === 'completed';
    });
  });

+  // Combine: executing first, then pending
+  const readyTasks = [...executingTasks, ...pendingTasks];
+
  if (readyTasks.length === 0) {
    console.log(JSON.stringify({
      status: 'empty',
@@ -957,6 +1012,7 @@ async function nextAction(options: IssueOptions): Promise<void> {
  // Sort by execution order
  readyTasks.sort((a, b) => a.execution_order - b.execution_order);
  const nextItem = readyTasks[0];
+  const isResume = nextItem.status === 'executing';

  // Load task definition
  const solution = findSolution(nextItem.issue_id, nextItem.solution_id);
@@ -967,24 +1023,42 @@ async function nextAction(options: IssueOptions): Promise<void> {
    process.exit(1);
  }

-  // Mark as executing
-  const idx = queue.queue.findIndex(q => q.queue_id === nextItem.queue_id);
-  queue.queue[idx].status = 'executing';
-  queue.queue[idx].started_at = new Date().toISOString();
-  writeQueue(queue);
+  // Only update status if not already executing (new task)
+  if (!isResume) {
+    const idx = queue.tasks.findIndex(q => q.item_id === nextItem.item_id);
+    queue.tasks[idx].status = 'executing';
+    queue.tasks[idx].started_at = new Date().toISOString();
+    writeQueue(queue);
+    updateIssue(nextItem.issue_id, { status: 'executing' });
+  }

-  // Update issue status
-  updateIssue(nextItem.issue_id, { status: 'executing' });
+  // Calculate queue stats for context
+  const stats = {
+    total: queue.tasks.length,
+    completed: queue.tasks.filter(q => q.status === 'completed').length,
+    failed: queue.tasks.filter(q => q.status === 'failed').length,
+    executing: executingTasks.length,
+    pending: pendingTasks.length
+  };
+  const remaining = stats.pending + stats.executing;

  console.log(JSON.stringify({
-    queue_id: nextItem.queue_id,
+    item_id: nextItem.item_id,
    issue_id: nextItem.issue_id,
    solution_id: nextItem.solution_id,
    task: taskDef,
    context: solution?.exploration_context || {},
+    resumed: isResume,
+    resume_note: isResume ? `Resuming interrupted task (started: ${nextItem.started_at})` : undefined,
    execution_hints: {
      executor: nextItem.assigned_executor,
      estimated_minutes: taskDef.estimated_minutes || 30
+    },
+    queue_progress: {
+      completed: stats.completed,
+      remaining: remaining,
+      total: stats.total,
+      progress: `${stats.completed}/${stats.total}`
    }
  }, null, 2));
 }
@@ -1000,7 +1074,7 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
  }

  const queue = readActiveQueue();
-  const idx = queue.queue.findIndex(q => q.queue_id === queueId);
+  const idx = queue.tasks.findIndex(q => q.item_id === queueId);

  if (idx === -1) {
    console.error(chalk.red(`Queue item "${queueId}" not found`));
@@ -1008,22 +1082,22 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
  }

  const isFail = options.fail;
-  queue.queue[idx].status = isFail ? 'failed' : 'completed';
-  queue.queue[idx].completed_at = new Date().toISOString();
+  queue.tasks[idx].status = isFail ? 'failed' : 'completed';
+  queue.tasks[idx].completed_at = new Date().toISOString();

  if (isFail) {
-    queue.queue[idx].failure_reason = options.reason || 'Unknown failure';
+    queue.tasks[idx].failure_reason = options.reason || 'Unknown failure';
  } else if (options.result) {
    try {
-      queue.queue[idx].result = JSON.parse(options.result);
+      queue.tasks[idx].result = JSON.parse(options.result);
    } catch {
      console.warn(chalk.yellow('Warning: Could not parse result JSON'));
    }
  }

  // Check if all issue tasks are complete
-  const issueId = queue.queue[idx].issue_id;
-  const issueTasks = queue.queue.filter(q => q.issue_id === issueId);
+  const issueId = queue.tasks[idx].issue_id;
+  const issueTasks = queue.tasks.filter(q => q.issue_id === issueId);
  const allIssueComplete = issueTasks.every(q => q.status === 'completed');
  const anyIssueFailed = issueTasks.some(q => q.status === 'failed');

@@ -1039,13 +1113,13 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
  }

  // Check if entire queue is complete
-  const allQueueComplete = queue.queue.every(q => q.status === 'completed');
-  const anyQueueFailed = queue.queue.some(q => q.status === 'failed');
+  const allQueueComplete = queue.tasks.every(q => q.status === 'completed');
+  const anyQueueFailed = queue.tasks.some(q => q.status === 'failed');

  if (allQueueComplete) {
    queue.status = 'completed';
    console.log(chalk.green(`\n✓ Queue ${queue.id} completed (all tasks done)`));
-  } else if (anyQueueFailed && queue.queue.every(q => q.status === 'completed' || q.status === 'failed')) {
+  } else if (anyQueueFailed && queue.tasks.every(q => q.status === 'completed' || q.status === 'failed')) {
    queue.status = 'failed';
    console.log(chalk.yellow(`\n⚠ Queue ${queue.id} has failed tasks`));
  }
@@ -1054,19 +1128,20 @@ async function doneAction(queueId: string | undefined, options: IssueOptions): P
 }

 /**
- * retry - Retry failed tasks
+ * retry - Reset failed tasks to pending for re-execution
 */
 async function retryAction(issueId: string | undefined, options: IssueOptions): Promise<void> {
  const queue = readActiveQueue();

-  if (!queue.id || queue.queue.length === 0) {
+  if (!queue.id || queue.tasks.length === 0) {
    console.log(chalk.yellow('No active queue'));
    return;
  }

  let updated = 0;

-  for (const item of queue.queue) {
+  for (const item of queue.tasks) {
+    // Retry failed tasks only
    if (item.status === 'failed') {
      if (!issueId || item.issue_id === issueId) {
        item.status = 'pending';
@@ -1080,6 +1155,7 @@ async function retryAction(issueId: string | undefined, options: IssueOptions):

  if (updated === 0) {
    console.log(chalk.yellow('No failed tasks to retry'));
+    console.log(chalk.gray('Note: Interrupted (executing) tasks are auto-resumed by "ccw issue next"'));
    return;
  }

@@ -1160,6 +1236,7 @@ export async function issueCommand(
      console.log(chalk.gray('  queue add <issue-id>               Add issue to active queue (or create new)'));
      console.log(chalk.gray('  queue switch <queue-id>            Switch active queue'));
      console.log(chalk.gray('  queue archive                      Archive current queue'));
+      console.log(chalk.gray('  queue delete <queue-id>            Delete queue from history'));
      console.log(chalk.gray('  retry [issue-id]                   Retry failed tasks'));
      console.log();
      console.log(chalk.bold('Execution Endpoints:'));
@@ -1169,6 +1246,8 @@ export async function issueCommand(
      console.log();
      console.log(chalk.bold('Options:'));
      console.log(chalk.gray('  --title <title>                    Issue/task title'));
+      console.log(chalk.gray('  --status <status>                  Filter by status (comma-separated)'));
+      console.log(chalk.gray('  --ids                              List only IDs (one per line)'));
      console.log(chalk.gray('  --solution <path>                  Solution JSON file'));
      console.log(chalk.gray('  --result <json>                    Execution result'));
      console.log(chalk.gray('  --reason <text>                    Failure reason'));
--- a/ccw/src/core/routes/issue-routes.ts
+++ b/ccw/src/core/routes/issue-routes.ts
@@ -5,7 +5,9 @@
 * Storage Structure:
 * .workflow/issues/
 * ├── issues.jsonl              # All issues (one per line)
- * ├── queue.json                # Execution queue
+ * ├── queues/                   # Queue history directory
+ * │   ├── index.json            # Queue index (active + history)
+ * │   └── {queue-id}.json       # Individual queue files
 * └── solutions/
 *     ├── {issue-id}.jsonl      # Solutions for issue (one per line)
 *     └── ...
@@ -102,12 +104,12 @@ function readQueue(issuesDir: string) {
    }
  }

-  return { queue: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
+  return { tasks: [], conflicts: [], execution_groups: [], _metadata: { version: '1.0', total_tasks: 0 } };
 }

 function writeQueue(issuesDir: string, queue: any) {
  if (!existsSync(issuesDir)) mkdirSync(issuesDir, { recursive: true });
-  queue._metadata = { ...queue._metadata, updated_at: new Date().toISOString(), total_tasks: queue.queue?.length || 0 };
+  queue._metadata = { ...queue._metadata, updated_at: new Date().toISOString(), total_tasks: queue.tasks?.length || 0 };

  // Check if using new multi-queue structure
  const queuesDir = join(issuesDir, 'queues');
@@ -123,8 +125,8 @@ function writeQueue(issuesDir: string, queue: any) {
      const index = JSON.parse(readFileSync(indexPath, 'utf8'));
      const queueEntry = index.queues?.find((q: any) => q.id === queue.id);
      if (queueEntry) {
-        queueEntry.total_tasks = queue.queue?.length || 0;
-        queueEntry.completed_tasks = queue.queue?.filter((i: any) => i.status === 'completed').length || 0;
+        queueEntry.total_tasks = queue.tasks?.length || 0;
+        queueEntry.completed_tasks = queue.tasks?.filter((i: any) => i.status === 'completed').length || 0;
        writeFileSync(indexPath, JSON.stringify(index, null, 2));
      }
    } catch {
@@ -151,15 +153,29 @@ function getIssueDetail(issuesDir: string, issueId: string) {
 }

 function enrichIssues(issues: any[], issuesDir: string) {
-  return issues.map(issue => ({
-    ...issue,
-    solution_count: readSolutionsJsonl(issuesDir, issue.id).length
-  }));
+  return issues.map(issue => {
+    const solutions = readSolutionsJsonl(issuesDir, issue.id);
+    let taskCount = 0;
+
+    // Get task count from bound solution
+    if (issue.bound_solution_id) {
+      const boundSol = solutions.find(s => s.id === issue.bound_solution_id);
+      if (boundSol?.tasks) {
+        taskCount = boundSol.tasks.length;
+      }
+    }
+
+    return {
+      ...issue,
+      solution_count: solutions.length,
+      task_count: taskCount
+    };
+  });
 }

 function groupQueueByExecutionGroup(queue: any) {
  const groups: { [key: string]: any[] } = {};
-  for (const item of queue.queue || []) {
+  for (const item of queue.tasks || []) {
    const groupId = item.execution_group || 'ungrouped';
    if (!groups[groupId]) groups[groupId] = [];
    groups[groupId].push(item);
@@ -171,7 +187,7 @@ function groupQueueByExecutionGroup(queue: any) {
    id,
    type: id.startsWith('P') ? 'parallel' : id.startsWith('S') ? 'sequential' : 'unknown',
    task_count: items.length,
-    tasks: items.map(i => i.queue_id)
+    tasks: items.map(i => i.item_id)
  })).sort((a, b) => {
    const aFirst = groups[a.id]?.[0]?.execution_order || 0;
    const bFirst = groups[b.id]?.[0]?.execution_order || 0;
@@ -229,20 +245,20 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
      }

      const queue = readQueue(issuesDir);
-      const groupItems = queue.queue.filter((item: any) => item.execution_group === groupId);
-      const otherItems = queue.queue.filter((item: any) => item.execution_group !== groupId);
+      const groupItems = queue.tasks.filter((item: any) => item.execution_group === groupId);
+      const otherItems = queue.tasks.filter((item: any) => item.execution_group !== groupId);

      if (groupItems.length === 0) return { error: `No items in group ${groupId}` };

-      const groupQueueIds = new Set(groupItems.map((i: any) => i.queue_id));
-      if (groupQueueIds.size !== new Set(newOrder).size) {
+      const groupItemIds = new Set(groupItems.map((i: any) => i.item_id));
+      if (groupItemIds.size !== new Set(newOrder).size) {
        return { error: 'newOrder must contain all group items' };
      }
      for (const id of newOrder) {
-        if (!groupQueueIds.has(id)) return { error: `Invalid queue_id: ${id}` };
+        if (!groupItemIds.has(id)) return { error: `Invalid item_id: ${id}` };
      }

-      const itemMap = new Map(groupItems.map((i: any) => [i.queue_id, i]));
+      const itemMap = new Map(groupItems.map((i: any) => [i.item_id, i]));
      const reorderedItems = newOrder.map((qid: string, idx: number) => ({ ...itemMap.get(qid), _idx: idx }));
      const newQueue = [...otherItems, ...reorderedItems].sort((a, b) => {
        const aGroup = parseInt(a.execution_group?.match(/\d+/)?.[0] || '999');
@@ -255,7 +271,7 @@ export async function handleIssueRoutes(ctx: RouteContext): Promise<boolean> {
      });

      newQueue.forEach((item, idx) => { item.execution_order = idx + 1; delete item._idx; });
-      queue.queue = newQueue;
+      queue.tasks = newQueue;
      writeQueue(issuesDir, queue);

      return { success: true, groupId, reordered: newOrder.length };
--- a/ccw/src/templates/dashboard-js/views/issue-manager.js
+++ b/ccw/src/templates/dashboard-js/views/issue-manager.js
@@ -6,7 +6,7 @@
 // ========== Issue State ==========
 var issueData = {
  issues: [],
-  queue: { queue: [], conflicts: [], execution_groups: [], grouped_items: {} },
+  queue: { tasks: [], conflicts: [], execution_groups: [], grouped_items: {} },
  selectedIssue: null,
  selectedSolution: null,
  selectedSolutionIssueId: null,
@@ -65,7 +65,7 @@ async function loadQueueData() {
    issueData.queue = await response.json();
  } catch (err) {
    console.error('Failed to load queue:', err);
-    issueData.queue = { queue: [], conflicts: [], execution_groups: [], grouped_items: {} };
+    issueData.queue = { tasks: [], conflicts: [], execution_groups: [], grouped_items: {} };
  }
 }

@@ -360,7 +360,7 @@ function filterIssuesByStatus(status) {
 // ========== Queue Section ==========
 function renderQueueSection() {
  const queue = issueData.queue;
-  const queueItems = queue.queue || [];
+  const queueItems = queue.tasks || [];
  const metadata = queue._metadata || {};

  // Check if queue is empty
@@ -530,10 +530,10 @@ function renderQueueItem(item, index, total) {
  return `
    <div class="queue-item ${statusColors[item.status] || ''}"
         draggable="true"
-         data-queue-id="${item.queue_id}"
+         data-item-id="${item.item_id}"
         data-group-id="${item.execution_group}"
-         onclick="openQueueItemDetail('${item.queue_id}')">
-      <span class="queue-item-id font-mono text-xs">${item.queue_id}</span>
+         onclick="openQueueItemDetail('${item.item_id}')">
+      <span class="queue-item-id font-mono text-xs">${item.item_id}</span>
      <span class="queue-item-issue text-xs text-muted-foreground">${item.issue_id}</span>
      <span class="queue-item-task text-sm">${item.task_id}</span>
      <span class="queue-item-priority" style="opacity: ${item.semantic_priority || 0.5}">
@@ -586,12 +586,12 @@ function handleIssueDragStart(e) {
  const item = e.target.closest('.queue-item');
  if (!item) return;

-  issueDragState.dragging = item.dataset.queueId;
+  issueDragState.dragging = item.dataset.itemId;
  issueDragState.groupId = item.dataset.groupId;

  item.classList.add('dragging');
  e.dataTransfer.effectAllowed = 'move';
-  e.dataTransfer.setData('text/plain', item.dataset.queueId);
+  e.dataTransfer.setData('text/plain', item.dataset.itemId);
 }

 function handleIssueDragEnd(e) {
@@ -610,7 +610,7 @@ function handleIssueDragOver(e) {
  e.preventDefault();

  const target = e.target.closest('.queue-item');
-  if (!target || target.dataset.queueId === issueDragState.dragging) return;
+  if (!target || target.dataset.itemId === issueDragState.dragging) return;

  // Only allow drag within same group
  if (target.dataset.groupId !== issueDragState.groupId) {
@@ -635,7 +635,7 @@ function handleIssueDrop(e) {

  // Get new order
  const items = Array.from(container.querySelectorAll('.queue-item'));
-  const draggedItem = items.find(i => i.dataset.queueId === issueDragState.dragging);
+  const draggedItem = items.find(i => i.dataset.itemId === issueDragState.dragging);
  const targetIndex = items.indexOf(target);
  const draggedIndex = items.indexOf(draggedItem);

@@ -649,7 +649,7 @@ function handleIssueDrop(e) {
  }

  // Get new order and save
-  const newOrder = Array.from(container.querySelectorAll('.queue-item')).map(i => i.dataset.queueId);
+  const newOrder = Array.from(container.querySelectorAll('.queue-item')).map(i => i.dataset.itemId);
  saveQueueOrder(issueDragState.groupId, newOrder);
 }

@@ -767,7 +767,7 @@ function renderIssueDetailPanel(issue) {
              <div class="flex items-center justify-between">
                <span class="font-mono text-sm">${task.id}</span>
                <select class="task-status-select" onchange="updateTaskStatus('${issue.id}', '${task.id}', this.value)">
-                  ${['pending', 'ready', 'in_progress', 'completed', 'failed', 'paused', 'skipped'].map(s =>
+                  ${['pending', 'ready', 'executing', 'completed', 'failed', 'blocked', 'paused', 'skipped'].map(s =>
                    `<option value="${s}" ${task.status === s ? 'selected' : ''}>${s}</option>`
                  ).join('')}
                </select>
@@ -1145,8 +1145,8 @@ function escapeHtml(text) {
  return div.innerHTML;
 }

-function openQueueItemDetail(queueId) {
-  const item = issueData.queue.queue?.find(q => q.queue_id === queueId);
+function openQueueItemDetail(itemId) {
+  const item = issueData.queue.tasks?.find(q => q.item_id === itemId);
  if (item) {
    openIssueDetail(item.issue_id);
  }
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
  "name": "claude-code-workflow",
-  "version": "6.2.9",
+  "version": "6.3.8",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "claude-code-workflow",
-      "version": "6.2.9",
+      "version": "6.3.8",
      "license": "MIT",
      "dependencies": {
        "@modelcontextprotocol/sdk": "^1.0.4",
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "claude-code-workflow",
-  "version": "6.3.6",
+  "version": "6.3.8",
  "description": "JSON-driven multi-agent development framework with intelligent CLI orchestration (Gemini/Qwen/Codex), context-first architecture, and automated workflow execution",
  "type": "module",
  "main": "ccw/src/index.js",
Author	SHA1	Message	Date
catlog22	d705a3e7d9	fix: Add active_queue_id to QueueIndex interface 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2025-12-27 22:48:38 +08:00
catlog22	726151bfea	Refactor issue management commands and introduce lifecycle requirements - Updated lifecycle requirements in issue creation to include new fields for testing, regression, acceptance, and commit strategies. - Enhanced the planning command to generate structured output and handle multi-solution scenarios. - Improved queue formation logic to ensure valid DAG and conflict resolution. - Introduced a new interactive issue management skill for CRUD operations, allowing users to manage issues through a menu-driven interface. - Updated documentation across commands to reflect changes in task structure and output requirements.	2025-12-27 22:44:49 +08:00
catlog22	b58589ddad	refactor: Update issue queue structure and commands - Changed queue structure from 'queue' to 'tasks' in various files for clarity. - Updated CLI commands to reflect new task ID usage instead of queue ID. - Enhanced queue management with new delete functionality for historical queues. - Improved metadata handling and task execution tracking. - Updated dashboard and issue manager views to accommodate new task structure. - Bumped version to 6.3.8 in package.json and package-lock.json.	2025-12-27 22:04:15 +08:00
catlog22	2e493277a1	feat(issue-queue): Enhance task execution flow with priority handling and stuck task reset option	2025-12-27 14:43:18 +08:00