claude-code-workflow 6.3.7 → 6.3.8

package/.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
-
-${JSON.stringify(allTasks, null, 2)}
-
-## Project Root
-${process.cwd()}
-
-## 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
+## Order Tasks
+
+**Tasks**: ${allTasks.length} from ${plannedIssues.length} issues
+**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)}
+\`\`\`
+
+### 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

package/.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

package/.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

package/ccw/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAuEA,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAyNxC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAuEA,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CA0NxC"}

package/ccw/dist/cli.js

@@ -250,6 +250,7 @@ export function run(argv) {
         .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')