List queues → Output options → Stop and wait for user

undefined

**Worktree Execution Pattern**:

**Note**: Add `.ccw/worktrees/` to `.gitignore` to prevent tracking worktree contents.

**Benefits:**
- Parallel executors don't conflict with each other
- Main working directory stays clean
- Easy cleanup after execution
- **Resume support**: Pass existing worktree path to continue interrupted executions

**Resume Examples:**
```bash

**Completion - User Choice:**

When all solutions are complete, output options and wait for user to specify:

**Based on user response:**

```bash

**Parallel Execution Safety**: For parallel executors, "Create PR" is the safest option as it avoids race conditions during merge. Multiple PRs can be reviewed and merged sequentially.

STEP 0: Validate queue ID (--queue required, or prompt user to select)

INIT: Fetch first solution via ccw issue next --queue <queue-id>

WHILE solution exists:
  1. Receive solution JSON from ccw issue next --queue <queue-id>
  2. Execute all tasks in solution.tasks sequentially:
     FOR each task:
       - IMPLEMENT: Follow task.implementation steps
       - TEST: Run task.test commands
       - VERIFY: Check task.acceptance criteria
  3. COMMIT: Stage all files, commit once with formatted summary
  4. Report completion via ccw issue done <item_id>
  5. Fetch next solution via ccw issue next --queue <queue-id>

WHEN queue empty:
  Output final summary

// ccw auto-detects worktree and uses main repo's .workflow/
// QUEUE_ID is required - obtained from --queue argument or user selection
const result = shell_command({ command: `ccw issue next --queue ${QUEUE_ID}` })

{
  "item_id": "S-1",
  "issue_id": "ISS-20251227-001",
  "solution_id": "SOL-ISS-20251227-001-1",
  "status": "pending",
  "solution": {
    "id": "SOL-ISS-20251227-001-1",
    "description": "Description of solution approach",
    "tasks": [
      {
        "id": "T1",
        "title": "Task title",
        "scope": "src/module/",
        "action": "Create|Modify|Fix|Refactor|Add",
        "description": "What to do",
        "modification_points": [
          { "file": "path/to/file.ts", "target": "function name", "change": "description" }
        ],
        "implementation": [
          "Step 1: Do this",
          "Step 2: Do that"
        ],
        "test": {
          "commands": ["npm test -- --filter=xxx"],
          "unit": ["Unit test requirement 1", "Unit test requirement 2"]
        },
        "regression": ["Verify existing tests still pass"],
        "acceptance": {
          "criteria": ["Criterion 1: Must pass", "Criterion 2: Must verify"],
          "verification": ["Run test command", "Manual verification step"]
        },
        "commit": {
          "type": "feat|fix|test|refactor",
          "scope": "module",
          "message_template": "feat(scope): description"
        },
        "depends_on": [],
        "estimated_minutes": 30,
        "priority": 1
      }
    ],
    "exploration_context": {
      "relevant_files": ["path/to/reference.ts"],
      "patterns": "Follow existing pattern in xxx",
      "integration_points": "Used by other modules"
    },
    "analysis": {
      "risk": "low|medium|high",
      "impact": "low|medium|high",
      "complexity": "low|medium|high"
    },
    "score": 0.95,
    "is_bound": true
  },
  "execution_hints": {
    "executor": "codex",
    "estimated_minutes": 180
  }
}

REPRODUCE → INSTRUMENT → DIAGNOSE → IMPLEMENT → TEST → VERIFY → CLEANUP

ROOT_CAUSE → IMPLEMENT → TEST → EDGE_CASES → REGRESSION → VERIFY

DESIGN_REVIEW → UNIT_TESTS → IMPLEMENT → INTEGRATION_TESTS → TEST → CODE_REVIEW → DOCS → VERIFY

BASELINE_TESTS → IMPLEMENT → TEST → BEHAVIOR_PRESERVATION → PERFORMANCE_CMP → VERIFY

COVERAGE_BASELINE → TEST_DESIGN → IMPLEMENT → COVERAGE_CHECK → VERIFY

PROFILING → BOTTLENECK → IMPLEMENT → BENCHMARK → TEST → VERIFY

VULNERABILITY_SCAN → IMPLEMENT → SECURITY_TEST → PENETRATION_TEST → VERIFY

IMPACT_ASSESSMENT → IMPLEMENT → TEST → QUICK_VERIFY → VERIFY

IMPLEMENT → EXAMPLE_VALIDATION → FORMAT_CHECK → LINK_VALIDATION → VERIFY

IMPLEMENT → COMPATIBILITY_CHECK → TEST → CHANGELOG → VERIFY

IMPLEMENT → TEST → VERIFY

function determineStrategy(solution) {
  // Priority 1: Explicit strategy type
  if (solution.strategy_type) {
    return solution.strategy_type
  }

  // Priority 2: Infer from task actions
  const actions = solution.tasks.map(t => t.action.toLowerCase())
  const titles = solution.tasks.map(t => t.title.toLowerCase())
  const description = solution.description.toLowerCase()
  const allText = [...actions, ...titles, description].join(' ')

  // Match keywords (order matters - more specific first)
  if (/hotfix|urgent|critical|emergency/.test(allText)) return 'hotfix'
  if (/debug|diagnose|trace|investigate/.test(allText)) return 'debug'
  if (/security|vulnerability|cve|audit/.test(allText)) return 'security'
  if (/performance|optimize|speed|memory|benchmark/.test(allText)) return 'performance'
  if (/refactor|restructure|cleanup/.test(allText)) return 'refactor'
  if (/test|coverage|e2e|integration/.test(allText)) return 'test'
  if (/documentation|docs|comment|readme/.test(allText)) return 'documentation'
  if (/chore|dependency|config|maintenance/.test(allText)) return 'chore'
  if (/fix|patch|resolve|correct/.test(allText)) return 'bugfix'
  if (/feature|add|implement|create|build/.test(allText)) return 'feature'

  // Default
  return 'standard'
}

// After parsing solution (Step 2)
const strategy = determineStrategy(solution)
console.log(`Strategy selected: ${strategy}`)

// During task execution (Step 3), follow strategy-specific phases
for (const task of solution.tasks) {
  executeTaskWithStrategy(task, strategy)
}

// Initialize plan with all tasks from solution
update_plan({
  explanation: `Starting solution ${item_id}`,
  plan: solution.tasks.map(task => ({
    step: `${task.id}: ${task.title}`,
    status: "pending"
  }))
})

// Update current task status
update_plan({
  explanation: `Working on ${task.id}: ${task.title}`,
  plan: tasks.map(t => ({
    step: `${t.id}: ${t.title}`,
    status: t.id === task.id ? "in_progress" : (t.completed ? "completed" : "pending")
  }))
})

// Mark task as completed (commit happens at solution level)
update_plan({
  explanation: `Completed ${task.id}: ${task.title}`,
  plan: tasks.map(t => ({
    step: `${t.id}: ${t.title}`,
    status: t.id === task.id ? "completed" : t.status
  }))
})

// Read all relevant files in parallel for context
multi_tool_use.parallel({
  tool_uses: solution.exploration_context.relevant_files.map(file => ({
    recipient_name: "functions.read_file",
    parameters: { path: file }
  }))
})

undefined

undefined

undefined

undefined

undefined

**If any criterion fails**: Go back to IMPLEMENT phase and fix.

undefined

**Commit Type Selection**:
- `feat`: New feature or capability
- `fix`: Bug fix
- `refactor`: Code restructuring without behavior change
- `test`: Adding or updating tests
- `docs`: Documentation changes
- `chore`: Maintenance tasks

**Commit Language**:
- Use **Chinese** commit summary if project's `CLAUDE.md` specifies Chinese response guidelines or user explicitly requests Chinese
- Use **English** commit summary by default or when project targets international collaboration
- Check project's existing commit history for language convention consistency

**Output format:**

undefined

// ccw auto-detects worktree and uses main repo's .workflow/
// Record ALL solution context here (NOT in git commit)
shell_command({
  command: `ccw issue done ${item_id} --result '${JSON.stringify({
    solution_id: solution.id,
    issue_id: issue_id,
    commit: {
      hash: commit_hash,
      type: commit_type,
      scope: commit_scope,
      message: commit_message
    },
    analysis: {
      risk: solution.analysis.risk,
      impact: solution.analysis.impact,
      complexity: solution.analysis.complexity
    },
    tasks_completed: solution.tasks.map(t => ({
      id: t.id,
      title: t.title,
      action: t.action,
      scope: t.scope
    })),
    files_modified: ["path1", "path2", ...],
    tests_passed: true,
    verification: {
      all_tests_passed: true,
      acceptance_criteria_met: true,
      regression_checked: true
    },
    summary: "[What was accomplished - brief description]"
  })}'`
})

shell_command({
  command: `ccw issue done S-1 --result '${JSON.stringify({
    solution_id: "SOL-ISS-20251227-001-1",
    issue_id: "ISS-20251227-001",
    commit: {
      hash: "a1b2c3d4",
      type: "feat",
      scope: "auth",
      message: "feat(auth): add token refresh mechanism"
    },
    analysis: {
      risk: "low",
      impact: "medium",
      complexity: "medium"
    },
    tasks_completed: [
      { id: "T1", title: "Implement refresh token endpoint", action: "Add", scope: "src/auth/" },
      { id: "T2", title: "Add token rotation logic", action: "Create", scope: "src/auth/services/" }
    ],
    files_modified: [
      "src/auth/routes/token.ts",
      "src/auth/services/refresh.ts",
      "src/auth/middleware/validate.ts"
    ],
    tests_passed: true,
    verification: {
      all_tests_passed: true,
      acceptance_criteria_met: true,
      regression_checked: true
    },
    summary: "Implemented token refresh mechanism with automatic rotation"
  })}'`
})

shell_command({
  command: `ccw issue done ${item_id} --fail --reason '${JSON.stringify({
    task_id: "TX",
    error_type: "test_failure",
    message: "Integration tests failed: timeout in token validation",
    files_attempted: ["path1", "path2"],
    commit: null
  })}'`
})

// ccw auto-detects worktree
// Continue using the same QUEUE_ID throughout execution
const result = shell_command({ command: `ccw issue next --queue ${QUEUE_ID}` })

✓ [N/M] Completed: [item_id] - [solution.description]
  Commit: [commit_hash] ([commit_type])
  Tasks: [task_count] completed
→ Fetching next solution...

undefined

undefined

ccw issue next --queue <queue-id>