claude-code-workflow 6.3.9 → 6.3.11

package/.codex/prompts/issue-execute.md

@@ -1,104 +1,163 @@
 ---
-description: Execute issue queue tasks sequentially with git commit after each task
-argument-hint: "[--dry-run]"
+description: Execute all solutions from issue queue with git commit after each task
+argument-hint: ""
 ---
 
 # Issue Execute (Codex Version)
 
 ## Core Principle
 
-**Serial Execution**: Execute tasks ONE BY ONE from the issue queue. Complete each task fully (implement → test → commit) before moving to next. Continue autonomously until ALL tasks complete or queue is empty.
+**Serial Execution**: Execute solutions ONE BY ONE from the issue queue via `ccw issue next`. For each solution, complete all tasks sequentially (implement → test → commit per task). Continue autonomously until queue is empty.
 
 ## Execution Flow
 
 ```
-INIT: Fetch first task via ccw issue next
-
-WHILE task exists:
-  1. Receive task JSON from ccw issue next
-  2. Execute full lifecycle:
-     - IMPLEMENT: Follow task.implementation steps
-     - 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 <item_id>
-  4. Fetch next task via ccw issue next
+INIT: Fetch first solution via ccw issue next
+
+WHILE solution exists:
+  1. Receive solution JSON from ccw issue next
+  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
+       - COMMIT: Stage files, commit with task.commit.message_template
+  3. Report completion via ccw issue done <item_id>
+  4. Fetch next solution via ccw issue next
 
 WHEN queue empty:
   Output final summary
 ```
 
-## Step 1: Fetch First Task
+## Step 1: Fetch First Solution
 
-Run this command to get your first task:
+Run this command to get your first solution:
 
 ```bash
 ccw issue next
 ```
 
-This returns JSON with the full task definition:
-- `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
+This returns JSON with the full solution definition:
+- `item_id`: Solution identifier in queue (e.g., "S-1")
+- `issue_id`: Parent issue ID (e.g., "ISS-20251227-001")
+- `solution_id`: Solution ID (e.g., "SOL-20251227-001")
+- `solution`: Full solution with all tasks
 - `execution_hints`: Timing and executor hints
 
-If response contains `{ "status": "empty" }`, all tasks are complete - skip to final summary.
+If response contains `{ "status": "empty" }`, all solutions are complete - skip to final summary.
 
-## Step 2: Parse Task Response
+## Step 2: Parse Solution Response
 
-Expected task structure:
+Expected solution structure:
 
 ```json
 {
-  "item_id": "T-1",
-  "issue_id": "ISSUE-20251227-001",
-  "solution_id": "SOL-001",
-  "task": {
-    "id": "T1",
-    "title": "Task title",
-    "scope": "src/module/",
-    "action": "Create|Modify|Fix|Refactor",
-    "description": "What to do",
-    "modification_points": [
-      { "file": "path/to/file.ts", "target": "function name", "change": "description" }
+  "item_id": "S-1",
+  "issue_id": "ISS-20251227-001",
+  "solution_id": "SOL-20251227-001",
+  "status": "pending",
+  "solution": {
+    "id": "SOL-20251227-001",
+    "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
+      }
     ],
-    "implementation": [
-      "Step 1: Do this",
-      "Step 2: Do that"
-    ],
-    "test": {
-      "commands": ["npm test -- --filter=xxx"],
-      "unit": "Unit test requirements",
-      "integration": "Integration test requirements (optional)"
+    "exploration_context": {
+      "relevant_files": ["path/to/reference.ts"],
+      "patterns": "Follow existing pattern in xxx",
+      "integration_points": "Used by other modules"
     },
-    "acceptance": [
-      "Criterion 1: Must pass",
-      "Criterion 2: Must verify"
-    ],
-    "commit": {
-      "message_template": "feat(scope): description"
-    }
+    "analysis": {
+      "risk": "low|medium|high",
+      "impact": "low|medium|high",
+      "complexity": "low|medium|high"
+    },
+    "score": 0.95,
+    "is_bound": true
   },
-  "context": {
-    "relevant_files": ["path/to/reference.ts"],
-    "patterns": "Follow existing pattern in xxx"
+  "execution_hints": {
+    "executor": "codex",
+    "estimated_minutes": 180
   }
 }
 ```
 
-## Step 3: Execute Task Lifecycle
+## Step 2.5: Initialize Todo Tracking
+
+After parsing solution, create todo list to track each task:
+
+```javascript
+// Create todos for all tasks in current solution
+TodoWrite({
+  todos: solution.tasks.map(task => ({
+    content: `${task.id}: ${task.title}`,
+    activeForm: `Executing ${task.id}: ${task.title}`,
+    status: "pending"
+  }))
+})
+```
+
+## Step 3: Execute Tasks Sequentially
+
+Iterate through `solution.tasks` array and execute each task.
+
+**Before starting each task**, mark it as in_progress:
+```javascript
+// Update current task status to in_progress
+TodoWrite({ todos: [...existingTodos.map(t =>
+  t.content.startsWith(currentTask.id) ? {...t, status: "in_progress"} : t
+)] })
+```
+
+**After completing each task** (commit done), mark it as completed:
+```javascript
+// Update completed task status
+TodoWrite({ todos: [...existingTodos.map(t =>
+  t.content.startsWith(completedTask.id) ? {...t, status: "completed"} : t
+)] })
+```
 
 ### Phase A: IMPLEMENT
 
-1. Read all `context.relevant_files` to understand existing patterns
+1. Read all `solution.exploration_context.relevant_files` to understand existing patterns
 2. Follow `task.implementation` steps in order
 3. Apply changes to `task.modification_points` files
-4. Follow `context.patterns` for code style consistency
+4. Follow `solution.exploration_context.patterns` for code style consistency
+5. Run `task.regression` checks if specified to ensure no breakage
 
 **Output format:**
 ```
-## Implementing: [task.title]
+## Implementing: [task.title] (Task [N]/[Total])
 
 **Scope**: [task.scope]
 **Action**: [task.action]
@@ -132,7 +191,7 @@ Expected task structure:
 
 ### Phase C: VERIFY
 
-Check all `task.acceptance` criteria are met:
+Check all `task.acceptance.criteria` are met using `task.acceptance.verification` steps:
 
 ```
 ## Verifying: [task.title]
@@ -142,6 +201,10 @@ Check all `task.acceptance` criteria are met:
 - [x] Criterion 2: Verified
 ...
 
+**Verification Steps**:
+- [x] Run test command
+- [x] Manual verification step
+
 All criteria met: YES
 ```
 
@@ -149,7 +212,7 @@ All criteria met: YES
 
 ### Phase D: COMMIT
 
-After all phases pass, commit the changes:
+After all phases pass, commit the changes for this task:
 
 ```bash
 # Stage all modified files
@@ -159,7 +222,7 @@ git add path/to/file1.ts path/to/file2.ts ...
 git commit -m "$(cat <<'EOF'
 [task.commit.message_template]
 
-Item-ID: [item_id]
+Solution-ID: [solution_id]
 Issue-ID: [issue_id]
 Task-ID: [task.id]
 EOF
@@ -175,30 +238,44 @@ EOF
 **Files**: N files changed
 ```
 
+### Repeat for Next Task
+
+Continue to next task in `solution.tasks` array until all tasks are complete.
+
 ## Step 4: Report Completion
 
-After commit succeeds, report to queue system:
+After ALL tasks in the solution are complete, report to queue system:
 
 ```bash
-ccw issue complete [item_id] --result '{
+ccw issue done <item_id> --result '{
   "files_modified": ["path1", "path2"],
   "tests_passed": true,
   "acceptance_passed": true,
   "committed": true,
-  "commit_hash": "[actual hash]",
+  "commits": [
+    { "task_id": "T1", "hash": "abc123" },
+    { "task_id": "T2", "hash": "def456" }
+  ],
   "summary": "[What was accomplished]"
 }'
 ```
 
-**If task failed and cannot be fixed:**
+**If solution failed and cannot be fixed:**
 
 ```bash
-ccw issue fail [item_id] --reason "Phase [X] failed: [details]"
+ccw issue done <item_id> --fail --reason "Task [task.id] failed: [details]"
 ```
 
-## Step 5: Continue to Next Task
+## Step 5: Continue to Next Solution
+
+Clear current todo list and fetch next solution:
 
-Immediately fetch the next task:
+```javascript
+// Reset todos for next solution
+TodoWrite({ todos: [] })
+```
+
+Then fetch next solution:
 
 ```bash
 ccw issue next
@@ -206,8 +283,8 @@ ccw issue next
 
 **Output progress:**
 ```
-✓ [N/M] Completed: [item_id] - [task.title]
-→ Fetching next task...
+✓ [N/M] Completed: [item_id] - [solution.approach]
+→ Fetching next solution...
 ```
 
 **DO NOT STOP.** Return to Step 2 and continue until queue is empty.
@@ -219,12 +296,15 @@ When `ccw issue next` returns `{ "status": "empty" }`:
 ```markdown
 ## Issue Queue Execution Complete
 
-**Total Tasks Executed**: N
+**Total Solutions Executed**: N
+**Total Tasks Executed**: M
+
 **All Commits**:
-| # | Item ID | Task | Commit |
-|---|---------|------|--------|
-| 1 | T-1 | Task title | abc123 |
-| 2 | T-2 | Task title | def456 |
+| # | Solution | Task | Commit |
+|---|----------|------|--------|
+| 1 | S-1 | T1 | abc123 |
+| 2 | S-1 | T2 | def456 |
+| 3 | S-2 | T1 | ghi789 |
 
 **Files Modified**:
 - path/to/file1.ts
@@ -237,23 +317,33 @@ When `ccw issue next` returns `{ "status": "empty" }`:
 ## Execution Rules
 
 1. **Never stop mid-queue** - Continue until queue is empty
-2. **One task at a time** - Fully complete (including commit) before moving on
-3. **Tests MUST pass** - Do not proceed to commit if tests fail
-4. **Commit after each task** - Each task gets its own commit
-5. **Self-verify** - All acceptance criteria must pass before commit
-6. **Report accurately** - Use ccw issue complete/fail after each task
-7. **Handle failures gracefully** - If a task fails, report via ccw issue fail and continue to next
+2. **One solution at a time** - Fully complete (all tasks + report) before moving on
+3. **Sequential within solution** - Complete each task (including commit) before next
+4. **Tests MUST pass** - Do not proceed to commit if tests fail
+5. **Commit after each task** - Each task gets its own commit
+6. **Self-verify** - All acceptance criteria must pass before commit
+7. **Report accurately** - Use `ccw issue done` after each solution
+8. **Handle failures gracefully** - If a solution fails, report via `ccw issue done --fail` and continue to next
+9. **Track with todos** - Use TodoWrite to track task progress within each solution
 
 ## Error Handling
 
 | Situation | Action |
 |-----------|--------|
-| ccw issue next returns empty | All done - output final summary |
+| `ccw issue next` returns empty | All done - output final summary |
 | Tests fail | Fix code, re-run tests |
 | Verification fails | Go back to implement phase |
 | Git commit fails | Check staging, retry commit |
-| ccw issue complete fails | Log error, continue to next task |
-| Unrecoverable error | Call ccw issue fail, continue to next |
+| `ccw issue done` fails | Log error, continue to next solution |
+| Unrecoverable error | Call `ccw issue done --fail`, continue to next |
+
+## CLI Command Reference
+
+| Command | Purpose |
+|---------|---------|
+| `ccw issue next` | Fetch next solution from queue |
+| `ccw issue done <id>` | Mark solution complete with result |
+| `ccw issue done <id> --fail` | Mark solution failed with reason |
 
 ## Start Execution
 
@@ -263,4 +353,4 @@ Begin by running:
 ccw issue next
 ```
 
-Then follow the lifecycle for each task until queue is empty.
+Then follow the solution lifecycle for each solution until queue is empty.

package/.codex/prompts/issue-plan.md

@@ -0,0 +1,106 @@
+---
+description: Plan issue(s) into bound solutions (writes solutions JSONL via ccw issue bind)
+argument-hint: "<issue-id>[,<issue-id>,...] [--all-pending] [--batch-size 3]"
+---
+
+# 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 is **planning + registration** (no implementation): it explores the codebase just enough to produce a high-quality task breakdown that can be executed later (e.g., by `issue-execute.md`).
+
+## 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 `3`) → max issues per batch
+
+## Output Requirements
+
+For each issue:
+- Register at least one solution and bind one solution to the issue (updates `.workflow/issues/issues.jsonl` and appends to `.workflow/issues/solutions/{issue-id}.jsonl`).
+- 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`:
+  - Run `ccw issue list --status registered --json` and plan all returned issues.
+- Else:
+  - Parse IDs from user input (split by `,`), and ensure each issue exists:
+    - `ccw issue init <issue-id> --title "Issue <issue-id>"` (safe if already exists)
+
+### Step 2: Load issue details
+
+For each issue ID:
+- `ccw issue status <issue-id> --json`
+- Extract the issue title/context/labels and any discovery hints (affected files, snippets, etc. if present).
+
+### Step 3: Minimal exploration (evidence-based)
+
+- If issue context names specific files or symbols: open them first.
+- Otherwise:
+  - Use `rg` to locate relevant code paths by keywords from the title/context.
+  - Read 3+ similar patterns before proposing refactors or API changes.
+
+### Step 4: Draft solutions and tasks (schema-driven)
+
+Default to **one** solution per issue unless there are genuinely different approaches.
+
+Task rules (from schema):
+- `id`: `T1`, `T2`, ...
+- `action`: one of `Create|Update|Implement|Refactor|Add|Delete|Configure|Test|Fix`
+- `implementation`: step-by-step, executable instructions
+- `test.commands`: include at least one command per task when feasible
+- `acceptance.criteria`: testable statements
+- `acceptance.verification`: concrete steps/commands mapping to criteria
+- Prefer small, independently testable tasks; encode dependencies in `depends_on`.
+
+### Step 5: Register & bind solutions via CLI
+
+Create an import JSON file per solution (NOT JSONL), then bind it:
+
+1. Write a file (example path):
+   - `.workflow/issues/solutions/_imports/<issue-id>-<timestamp>.json`
+2. File contents shape (minimum):
+   ```json
+   {
+     "description": "High-level summary",
+     "approach": "Technical approach",
+     "tasks": []
+   }
+   ```
+3. Register+bind in one step:
+   - `ccw issue bind <issue-id> --solution <import-file>`
+
+If you intentionally generated multiple solutions for the same issue:
+- Register each via `ccw issue bind <issue-id> <solution-id> --solution <import-file>` (do NOT bind yet).
+- Present the alternatives in `pending_selection` and stop for user choice.
+- Bind chosen solution with: `ccw issue bind <issue-id> <solution-id>`.
+
+### Step 6: Detect cross-issue file conflicts (best-effort)
+
+Across the issues planned in this run:
+- Build a set of touched files from each solution’s `modification_points.file` (and/or task `scope` when explicit files are missing).
+- If the same file appears in multiple issues, add it to `conflicts` with all involved issue IDs.
+- Recommend a safe execution order (sequential) when conflicts exist.
+
+## Done Criteria
+
+- A bound solution exists for each issue unless explicitly deferred for user selection.
+- All tasks validate against the solution schema fields (especially acceptance criteria + verification).
+- The final summary JSON matches the required shape.
+