feat: Add unified-execute-parallel, unified-execute-with-file, and worktree-merge workflows

- Implemented unified-execute-parallel for executing tasks in isolated Git worktrees with parallel execution capabilities.
- Developed unified-execute-with-file for universal task execution from various planning outputs with progress tracking.
- Created worktree-merge to handle merging of completed worktrees back to the main branch, including dependency management and conflict detection.
- Enhanced documentation for each workflow, detailing core functionalities, implementation phases, and configuration options.

.codex/skills/issue-plan/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: issue-plan
+description: Plan issue(s) into bound solutions using subagent pattern (explore + plan closed-loop)
+argument-hint: "<issue-id>[,<issue-id>,...] [--all-pending] [--batch-size 4]"
+---
+
+# Issue Plan (Codex Version)
+
+## Goal
+
+Create executable solution(s) for issue(s) and bind the selected solution to each issue using `ccw issue bind`.
+
+This workflow uses **subagent pattern** for parallel batch processing: spawn planning agents per batch, wait for results, handle multi-solution selection.
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and solutions files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status pending --brief` | Read issues.jsonl |
+| Read issue details | `ccw issue status <id> --json` | Read issues.jsonl |
+| Update status | `ccw issue update <id> --status ...` | Direct file edit |
+| Bind solution | `ccw issue bind <id> <sol-id>` | Direct file edit |
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `solutions/*.jsonl` directly.
+
+## Inputs
+
+- **Explicit issues**: comma-separated IDs, e.g. `ISS-123,ISS-124`
+- **All pending**: `--all-pending` → plan all issues in `registered` status
+- **Batch size**: `--batch-size N` (default `4`) → max issues per subagent batch
+
+## Output Requirements
+
+For each issue:
+- Register at least one solution and bind one solution to the issue
+- Ensure tasks conform to `~/.claude/workflows/cli-templates/schemas/solution-schema.json`
+- Each task includes quantified `acceptance.criteria` and concrete `acceptance.verification`
+
+Return a final summary JSON:
+```json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": 0 }],
+  "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "...", "task_count": 0, "description": "..." }] }],
+  "conflicts": [{ "file": "...", "issues": ["..."] }]
+}
+```
+
+## Workflow
+
+### Step 1: Resolve Issue List
+
+**If `--all-pending`:**
+```bash
+ccw issue list --status registered --json
+```
+
+**Else (explicit IDs):**
+```bash
+# For each ID, ensure exists
+ccw issue init <issue-id> --title "Issue <issue-id>" 2>/dev/null || true
+ccw issue status <issue-id> --json
+```
+
+### Step 2: Group Issues by Similarity
+
+Group issues for batch processing (max 4 per batch):
+
+```bash
+# Extract issue metadata for grouping
+ccw issue list --status registered --brief --json
+```
+
+Group by:
+- Shared tags
+- Similar keywords in title
+- Related components
+
+### Step 3: Spawn Planning Subagents (Parallel)
+
+For each batch, spawn a planning subagent:
+
+```javascript
+// Subagent message structure
+spawn_agent({
+  message: `
+## TASK ASSIGNMENT
+
+### MANDATORY FIRST STEPS (Agent Execute)
+1. **Read role definition**: ~/.codex/agents/issue-plan-agent.md (MUST read first)
+2. Read: .workflow/project-tech.json
+3. Read: .workflow/project-guidelines.json
+4. Read schema: ~/.claude/workflows/cli-templates/schemas/solution-schema.json
+
+---
+
+Goal: Plan solutions for ${batch.length} issues with executable task breakdown
+
+Scope:
+- CAN DO: Explore codebase, design solutions, create tasks
+- CANNOT DO: Execute solutions, modify production code
+- Directory: ${process.cwd()}
+
+Context:
+- Issues: ${batch.map(i => `${i.id}: ${i.title}`).join('\n')}
+- Fetch full details: ccw issue status <id> --json
+
+Deliverables:
+- For each issue: Write solution to .workflow/issues/solutions/{issue-id}.jsonl
+- Single solution → auto-bind via ccw issue bind
+- Multiple solutions → return in pending_selection
+
+Quality bar:
+- Tasks have quantified acceptance.criteria
+- Each task includes test.commands
+- Solution follows schema exactly
+`
+})
+```
+
+**Batch execution (parallel):**
+```javascript
+// Launch all batches in parallel
+const agentIds = batches.map(batch => spawn_agent({ message: buildPrompt(batch) }))
+
+// Wait for all agents to complete
+const results = wait({ ids: agentIds, timeout_ms: 900000 })  // 15 min
+
+// Collect results
+const allBound = []
+const allPendingSelection = []
+const allConflicts = []
+
+for (const id of agentIds) {
+  if (results.status[id].completed) {
+    const result = JSON.parse(results.status[id].completed)
+    allBound.push(...(result.bound || []))
+    allPendingSelection.push(...(result.pending_selection || []))
+    allConflicts.push(...(result.conflicts || []))
+  }
+}
+
+// Close all agents
+agentIds.forEach(id => close_agent({ id }))
+```
+
+### Step 4: Handle Multi-Solution Selection
+
+If `pending_selection` is non-empty, present options:
+
+```
+Issue ISS-001 has multiple solutions:
+1. SOL-ISS-001-1: Refactor with adapter pattern (3 tasks)
+2. SOL-ISS-001-2: Direct implementation (2 tasks)
+
+Select solution (1-2):
+```
+
+Bind selected solution:
+```bash
+ccw issue bind ISS-001 SOL-ISS-001-1
+```
+
+### Step 5: Handle Conflicts
+
+If conflicts detected:
+- Low/Medium severity: Auto-resolve with recommended order
+- High severity: Present to user for decision
+
+### Step 6: Update Issue Status
+
+After binding, update status:
+```bash
+ccw issue update <issue-id> --status planned
+```
+
+### Step 7: Output Summary
+
+```markdown
+## Planning Complete
+
+**Planned**: 5 issues
+**Bound Solutions**: 4
+**Pending Selection**: 1
+
+### Bound Solutions
+| Issue | Solution | Tasks |
+|-------|----------|-------|
+| ISS-001 | SOL-ISS-001-1 | 3 |
+| ISS-002 | SOL-ISS-002-1 | 2 |
+
+### Pending Selection
+- ISS-003: 2 solutions available (user selection required)
+
+### Conflicts Detected
+- src/auth.ts touched by ISS-001, ISS-002 (resolved: sequential)
+
+**Next Step**: `/issue:queue`
+```
+
+## Subagent Role Reference
+
+Planning subagent uses role file at: `~/.codex/agents/issue-plan-agent.md`
+
+Role capabilities:
+- Codebase exploration (rg, file reading)
+- Solution design with task breakdown
+- Schema validation
+- Solution registration via CLI
+
+## Quality Checklist
+
+Before completing, verify:
+
+- [ ] All input issues have solutions in `solutions/{issue-id}.jsonl`
+- [ ] Single solution issues are auto-bound (`bound_solution_id` set)
+- [ ] Multi-solution issues returned in `pending_selection` for user choice
+- [ ] Each solution has executable tasks with `modification_points`
+- [ ] Task acceptance criteria are quantified (not vague)
+- [ ] Conflicts detected and reported (if multiple issues touch same files)
+- [ ] Issue status updated to `planned` after binding
+- [ ] All subagents closed after completion
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Issue not found | Auto-create via `ccw issue init` |
+| Subagent timeout | Retry with increased timeout or smaller batch |
+| No solutions generated | Display error, suggest manual planning |
+| User cancels selection | Skip issue, continue with others |
+| File conflicts | Detect and suggest resolution order |
+
+## Start Execution
+
+Begin by resolving issue list:
+
+```bash
+# Default to all pending
+ccw issue list --status registered --brief --json
+
+# Or with explicit IDs
+ccw issue status ISS-001 --json
+```
+
+Then group issues and spawn planning subagents.