claude-code-workflow 6.3.12 → 6.3.13

package/.claude/commands/issue/plan.md

@@ -128,40 +128,46 @@ if (flags.allPending) {
   }
 }
 
-// Intelligent grouping by similarity (tags → title keywords)
-function groupBySimilarity(issues, maxSize) {
-  const batches = [];
-  const used = new Set();
-
-  for (const issue of issues) {
-    if (used.has(issue.id)) continue;
-
-    const batch = [issue];
-    used.add(issue.id);
-    const issueTags = new Set(issue.tags);
-    const issueWords = new Set(issue.title.toLowerCase().split(/\s+/));
-
-    // Find similar issues
-    for (const other of issues) {
-      if (used.has(other.id) || batch.length >= maxSize) continue;
-
-      // Similarity: shared tags or shared title keywords
-      const sharedTags = other.tags.filter(t => issueTags.has(t)).length;
-      const otherWords = other.title.toLowerCase().split(/\s+/);
-      const sharedWords = otherWords.filter(w => issueWords.has(w) && w.length > 3).length;
-
-      if (sharedTags > 0 || sharedWords >= 2) {
-        batch.push(other);
-        used.add(other.id);
-      }
-    }
-    batches.push(batch);
+// Semantic grouping via Gemini CLI (max 6 issues per group)
+async function groupBySimilarityGemini(issues) {
+  const issueSummaries = issues.map(i => ({
+    id: i.id, title: i.title, tags: i.tags
+  }));
+
+  const prompt = `
+PURPOSE: Group similar issues by semantic similarity for batch processing; maximize within-group coherence; max 6 issues per group
+TASK: • Analyze issue titles/tags semantically • Identify functional/architectural clusters • Assign each issue to one group
+MODE: analysis
+CONTEXT: Issue metadata only
+EXPECTED: JSON with groups array, each containing max 6 issue_ids, theme, rationale
+RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Each issue in exactly one group | Max 6 issues per group | Balance group sizes
+
+INPUT:
+${JSON.stringify(issueSummaries, null, 2)}
+
+OUTPUT FORMAT:
+{"groups":[{"group_id":1,"theme":"...","issue_ids":["..."],"rationale":"..."}],"ungrouped":[]}
+`;
+
+  const taskId = Bash({
+    command: `ccw cli -p "${prompt}" --tool gemini --mode analysis`,
+    run_in_background: true, timeout: 600000
+  });
+  const output = TaskOutput({ task_id: taskId, block: true });
+
+  // Extract JSON from potential markdown code blocks
+  function extractJsonFromMarkdown(text) {
+    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)\n```/) ||
+                      text.match(/```\s*\n([\s\S]*?)\n```/);
+    return jsonMatch ? jsonMatch[1] : text;
   }
-  return batches;
+
+  const result = JSON.parse(extractJsonFromMarkdown(output));
+  return result.groups.map(g => g.issue_ids.map(id => issues.find(i => i.id === id)));
 }
 
-const batches = groupBySimilarity(issues, batchSize);
-console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (grouped by similarity)`);
+const batches = await groupBySimilarityGemini(issues);
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (Gemini semantic grouping, max 6 issues/agent)`);
 
 TodoWrite({
   todos: batches.map((_, i) => ({
@@ -177,6 +183,7 @@ TodoWrite({
 ```javascript
 Bash(`mkdir -p .workflow/issues/solutions`);
 const pendingSelections = [];  // Collect multi-solution issues for user selection
+const agentResults = [];       // Collect all agent results for conflict aggregation
 
 // Build prompts for all batches
 const agentTasks = batches.map((batch, batchIndex) => {
@@ -200,13 +207,15 @@ ${issueList}
 ### Steps
 1. Fetch: \`ccw issue status <id> --json\`
 2. Load project context (project-tech.json + project-guidelines.json)
-3. **If source=discovery**: Use discovery_context (file, line, snippet, suggested_fix) as planning hints
+3. **If extended_context exists**: Use extended_context (location, suggested_fix, notes) as planning hints
 4. Explore (ACE) → Plan solution (respecting guidelines)
 5. Register & bind: \`ccw issue bind <id> --solution <file>\`
 
 ### Generate Files
 \`.workflow/issues/solutions/{issue-id}.jsonl\` - Solution with tasks (schema: cat .claude/workflows/cli-templates/schemas/solution-schema.json)
 
+**Solution ID Format**: \`SOL-{issue-id}-{seq}\` (e.g., \`SOL-GH-123-1\`, \`SOL-ISS-20251229-1\`)
+
 ### Binding Rules
 - **Single solution**: Auto-bind via \`ccw issue bind <id> --solution <file>\`
 - **Multiple solutions**: Register only, return for user selection
@@ -216,7 +225,13 @@ ${issueList}
 {
   "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
   "pending_selection": [{ "issue_id": "...", "solutions": [{ "id": "...", "description": "...", "task_count": N }] }],
-  "conflicts": [{ "file": "...", "issues": [...] }]
+  "conflicts": [{
+    "type": "file_conflict|api_conflict|data_conflict|dependency_conflict|architecture_conflict",
+    "severity": "high|medium|low",
+    "summary": "brief description",
+    "recommended_resolution": "auto-resolution for low/medium",
+    "resolution_options": [{ "strategy": "...", "rationale": "..." }]
+  }]
 }
 \`\`\`
 `;
@@ -247,7 +262,18 @@ for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
   // Collect results from this chunk
   for (const { taskId, batchIndex } of taskIds) {
     const result = TaskOutput(task_id=taskId, block=true);
-    const summary = JSON.parse(result);
+
+    // Extract JSON from potential markdown code blocks (agent may wrap in ```json...```)
+    const jsonText = extractJsonFromMarkdown(result);
+    let summary;
+    try {
+      summary = JSON.parse(jsonText);
+    } catch (e) {
+      console.log(`⚠ Batch ${batchIndex + 1}: Failed to parse agent result, skipping`);
+      updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+      continue;
+    }
+    agentResults.push(summary);  // Store for Phase 3 conflict aggregation
 
     for (const item of summary.bound || []) {
       console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
@@ -258,17 +284,66 @@ for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
       pendingSelections.push(pending);
     }
     if (summary.conflicts?.length > 0) {
-      console.log(`⚠ Conflicts: ${summary.conflicts.map(c => c.file).join(', ')}`);
+      console.log(`⚠ Conflicts: ${summary.conflicts.length} detected (will resolve in Phase 3)`);
     }
     updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
   }
 }
 ```
 
-### Phase 3: Multi-Solution Selection (MANDATORY when pendingSelections > 0)
+### Phase 3: Conflict Resolution & Solution Selection
 
 ```javascript
-// MUST trigger user selection when multiple solutions exist
+// Helper: Extract selected solution ID from AskUserQuestion answer
+function extractSelectedSolutionId(answer, issueId) {
+  // answer format: { [header]: selectedLabel } or { answers: { [question]: label } }
+  const key = Object.keys(answer).find(k => k.includes(issueId));
+  if (!key) return null;
+  const selected = answer[key];
+  // Label format: "SOL-xxx (N tasks)" - extract solution ID
+  const match = selected.match(/^(SOL-[^\s]+)/);
+  return match ? match[1] : null;
+}
+
+// Phase 3a: Aggregate and resolve conflicts from all agents
+const allConflicts = [];
+for (const result of agentResults) {
+  if (result.conflicts?.length > 0) {
+    allConflicts.push(...result.conflicts);
+  }
+}
+
+if (allConflicts.length > 0) {
+  console.log(`\n## Resolving ${allConflicts.length} conflict(s) detected by agents\n`);
+
+  // ALWAYS confirm high-severity conflicts (per user preference)
+  const highSeverity = allConflicts.filter(c => c.severity === 'high');
+  const lowMedium = allConflicts.filter(c => c.severity !== 'high');
+
+  // Auto-resolve low/medium severity
+  for (const conflict of lowMedium) {
+    console.log(`  Auto-resolved: ${conflict.summary} → ${conflict.recommended_resolution}`);
+  }
+
+  // ALWAYS require user confirmation for high severity
+  if (highSeverity.length > 0) {
+    const conflictAnswer = AskUserQuestion({
+      questions: highSeverity.slice(0, 4).map(conflict => ({
+        question: `${conflict.type}: ${conflict.summary}. How to resolve?`,
+        header: conflict.type.replace('_conflict', ''),
+        multiSelect: false,
+        options: conflict.resolution_options.map(opt => ({
+          label: opt.strategy,
+          description: opt.rationale
+        }))
+      }))
+    });
+    // Apply user-selected resolutions
+    console.log('Applied user-selected conflict resolutions');
+  }
+}
+
+// Phase 3b: Multi-Solution Selection (MANDATORY when pendingSelections > 0)
 if (pendingSelections.length > 0) {
   console.log(`\n## User Selection Required: ${pendingSelections.length} issue(s) have multiple solutions\n`);
 

package/.claude/commands/issue/queue.md

@@ -89,7 +89,7 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
     {
       "item_id": "S-1",
       "issue_id": "ISS-20251227-003",
-      "solution_id": "SOL-20251227-003",
+      "solution_id": "SOL-ISS-20251227-003-1",
       "status": "pending",
       "execution_order": 1,
       "execution_group": "P1",
@@ -102,7 +102,7 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
     {
       "item_id": "S-2",
       "issue_id": "ISS-20251227-001",
-      "solution_id": "SOL-20251227-001",
+      "solution_id": "SOL-ISS-20251227-001-1",
       "status": "pending",
       "execution_order": 2,
       "execution_group": "P1",
@@ -115,7 +115,7 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
     {
       "item_id": "S-3",
       "issue_id": "ISS-20251227-002",
-      "solution_id": "SOL-20251227-002",
+      "solution_id": "SOL-ISS-20251227-002-1",
       "status": "pending",
       "execution_order": 3,
       "execution_group": "S2",
@@ -332,102 +332,30 @@ const summary = JSON.parse(result);
 ### Phase 5: Validation & Status Update
 
 ```javascript
-// ============ VALIDATION: Prevent "next returns empty" issues ============
-
-const queuesDir = '.workflow/issues/queues';
-const indexPath = `${queuesDir}/index.json`;
-const queuePath = `${queuesDir}/${queueId}.json`;
-
-// 1. Validate index.json has active_queue_id
-const indexContent = Bash(`cat "${indexPath}" 2>/dev/null || echo '{}'`);
-const index = JSON.parse(indexContent);
-
-if (index.active_queue_id !== queueId) {
-  console.log(`⚠ Fixing: index.json active_queue_id not set to ${queueId}`);
-  index.active_queue_id = queueId;
-  // Ensure queue entry exists in index
-  if (!index.queues) index.queues = [];
-  const existing = index.queues.find(q => q.id === queueId);
-  if (!existing) {
-    index.queues.unshift({
-      id: queueId,
-      status: 'active',
-      issue_ids: summary.issues_queued,
-      total_solutions: summary.total_solutions,
-      completed_solutions: 0,
-      created_at: new Date().toISOString()
-    });
-  }
-  Bash(`echo '${JSON.stringify(index, null, 2)}' > "${indexPath}"`);
-  console.log(`✓ Fixed: index.json updated with active_queue_id: ${queueId}`);
-}
+const queuePath = `.workflow/issues/queues/${queueId}.json`;
 
-// 2. Validate queue file exists and has correct structure
-const queueContent = Bash(`cat "${queuePath}" 2>/dev/null || echo '{}'`);
-const queue = JSON.parse(queueContent);
-
-if (!queue.solutions || queue.solutions.length === 0) {
-  console.error(`✗ ERROR: Queue file ${queuePath} has no solutions array`);
-  console.error('  Agent did not generate queue correctly. Aborting.');
+// 1. Validate queue has solutions
+const solCount = Bash(`jq ".solutions | length" "${queuePath}"`).trim();
+if (!solCount || solCount === '0') {
+  console.error(`✗ Queue has no solutions. Aborting.`);
   return;
 }
 
-// 3. Validate all solutions have status: "pending" (not "queued" or other)
-let statusFixed = 0;
-for (const sol of queue.solutions) {
-  if (sol.status !== 'pending' && sol.status !== 'executing' && sol.status !== 'completed') {
-    console.log(`⚠ Fixing: ${sol.item_id} status "${sol.status}" → "pending"`);
-    sol.status = 'pending';
-    statusFixed++;
-  }
+// 2. Update issue statuses
+for (const id of summary.issues_queued) {
+  Bash(`ccw issue update ${id} --status queued`);
 }
 
-// 4. Validate at least one item has no dependencies (DAG entry point)
-const entryPoints = queue.solutions.filter(s =>
-  s.status === 'pending' && (!s.depends_on || s.depends_on.length === 0)
-);
-
-if (entryPoints.length === 0) {
-  console.error(`✗ ERROR: No entry points found (all items have dependencies)`);
-  console.error('  This will cause "ccw issue next" to return empty.');
-  console.error('  Check depends_on fields for circular dependencies.');
-  // Try to fix by clearing first item's dependencies
-  if (queue.solutions.length > 0) {
-    console.log(`⚠ Fixing: Clearing depends_on for first item ${queue.solutions[0].item_id}`);
-    queue.solutions[0].depends_on = [];
-  }
-}
-
-// Write back fixed queue if any changes made
-if (statusFixed > 0 || entryPoints.length === 0) {
-  Bash(`echo '${JSON.stringify(queue, null, 2)}' > "${queuePath}"`);
-  console.log(`✓ Queue file updated with ${statusFixed} status fixes`);
-}
-
-// ============ OUTPUT SUMMARY ============
-
+// 3. Summary
 console.log(`
-## Queue Formed: ${summary.queue_id}
+## Queue: ${summary.queue_id}
 
-**Solutions**: ${summary.total_solutions}
-**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}
-**Entry Points**: ${entryPoints.length} (items ready for immediate execution)
+- Solutions: ${summary.total_solutions}
+- Tasks: ${summary.total_tasks}
+- Issues: ${summary.issues_queued.join(', ')}
 
-Next: \`/issue:execute\` or \`ccw issue next\`
+Next: /issue:execute
 `);
-
-// Update issue statuses via CLI
-for (const issueId of summary.issues_queued) {
-  Bash(`ccw issue update ${issueId} --status queued`);
-}
-
-// Final verification
-const verifyResult = Bash(`ccw issue queue dag 2>/dev/null | head -20`);
-console.log('\n### Verification (DAG Preview):');
-console.log(verifyResult);
 ```
 
 ## Error Handling