claude-code-workflow 6.3.48 → 6.3.49

package/.codex/prompts/brainstorm-to-cycle.md

@@ -0,0 +1,455 @@
+---
+description: Convert brainstorm session output to parallel-dev-cycle input with idea selection and context enrichment
+argument-hint: SESSION="<brainstorm-session-id>" [--idea=<index>] [--auto]
+---
+
+# Brainstorm to Cycle Adapter
+
+## Overview
+
+Bridge workflow that converts **brainstorm-with-file** output to **parallel-dev-cycle** input. Reads synthesis.json, allows user to select an idea, and formats it as an enriched TASK description.
+
+**Core workflow**: Load Session → Select Idea → Format Task → Launch Cycle
+
+## Inputs
+
+| Argument | Required | Description |
+|----------|----------|-------------|
+| SESSION | Yes | Brainstorm session ID (e.g., `BS-rate-limiting-2025-01-28`) |
+| --idea | No | Pre-select idea by index (0-based, from top_ideas) |
+| --auto | No | Auto-select top-scored idea without confirmation |
+
+## Output
+
+Launches `/parallel-dev-cycle` with enriched TASK containing:
+- Primary recommendation or selected idea
+- Key strengths and challenges
+- Suggested implementation steps
+- Alternative approaches for reference
+
+## Execution Process
+
+```
+Phase 1: Session Loading
+   ├─ Validate session folder exists
+   ├─ Read synthesis.json
+   ├─ Parse top_ideas and recommendations
+   └─ Validate data structure
+
+Phase 2: Idea Selection
+   ├─ --auto mode → Select highest scored idea
+   ├─ --idea=N → Select specified index
+   └─ Interactive → Present options, await selection
+
+Phase 3: Task Formatting
+   ├─ Build enriched task description
+   ├─ Include context from brainstorm
+   └─ Generate parallel-dev-cycle command
+
+Phase 4: Cycle Launch
+   ├─ Confirm with user (unless --auto)
+   └─ Execute parallel-dev-cycle
+```
+
+## Implementation
+
+### Phase 1: Session Loading
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// Parse arguments
+const args = "$ARGUMENTS"
+const sessionId = "$SESSION"
+const ideaIndexMatch = args.match(/--idea=(\d+)/)
+const preSelectedIdea = ideaIndexMatch ? parseInt(ideaIndexMatch[1]) : null
+const isAutoMode = args.includes('--auto')
+
+// Validate session
+const sessionFolder = `.workflow/.brainstorm/${sessionId}`
+const synthesisPath = `${sessionFolder}/synthesis.json`
+const brainstormPath = `${sessionFolder}/brainstorm.md`
+
+function fileExists(p) {
+  try { return bash(`test -f "${p}" && echo "yes"`).includes('yes') } catch { return false }
+}
+
+if (!fileExists(synthesisPath)) {
+  console.error(`
+## Error: Session Not Found
+
+Session ID: ${sessionId}
+Expected path: ${synthesisPath}
+
+**Available sessions**:
+`)
+  bash(`ls -1 .workflow/.brainstorm/ 2>/dev/null | head -10`)
+  return { status: 'error', message: 'Session not found' }
+}
+
+// Load synthesis
+const synthesis = JSON.parse(Read(synthesisPath))
+
+// Validate structure
+if (!synthesis.top_ideas || synthesis.top_ideas.length === 0) {
+  console.error(`
+## Error: No Ideas Found
+
+The brainstorm session has no top_ideas.
+Please complete the brainstorm workflow first.
+`)
+  return { status: 'error', message: 'No ideas in synthesis' }
+}
+
+console.log(`
+## Brainstorm Session Loaded
+
+**Session**: ${sessionId}
+**Topic**: ${synthesis.topic}
+**Completed**: ${synthesis.completed}
+**Ideas Found**: ${synthesis.top_ideas.length}
+`)
+```
+
+---
+
+### Phase 2: Idea Selection
+
+```javascript
+let selectedIdea = null
+let selectionSource = ''
+
+// Auto mode: select highest scored
+if (isAutoMode) {
+  selectedIdea = synthesis.top_ideas.reduce((best, idea) =>
+    idea.score > best.score ? idea : best
+  )
+  selectionSource = 'auto (highest score)'
+
+  console.log(`
+**Auto-selected**: ${selectedIdea.title} (Score: ${selectedIdea.score}/10)
+`)
+}
+
+// Pre-selected by index
+else if (preSelectedIdea !== null) {
+  if (preSelectedIdea >= synthesis.top_ideas.length) {
+    console.error(`
+## Error: Invalid Idea Index
+
+Requested: --idea=${preSelectedIdea}
+Available: 0 to ${synthesis.top_ideas.length - 1}
+`)
+    return { status: 'error', message: 'Invalid idea index' }
+  }
+
+  selectedIdea = synthesis.top_ideas[preSelectedIdea]
+  selectionSource = `index ${preSelectedIdea}`
+
+  console.log(`
+**Pre-selected**: ${selectedIdea.title} (Index: ${preSelectedIdea})
+`)
+}
+
+// Interactive selection
+else {
+  // Display options
+  console.log(`
+## Select Idea for Development
+
+| # | Title | Score | Feasibility |
+|---|-------|-------|-------------|
+${synthesis.top_ideas.map((idea, i) =>
+  `| ${i} | ${idea.title.substring(0, 40)} | ${idea.score}/10 | ${idea.feasibility || 'N/A'} |`
+).join('\n')}
+
+**Primary Recommendation**: ${synthesis.recommendations?.primary?.substring(0, 60) || 'N/A'}
+`)
+
+  // Build options for AskUser
+  const ideaOptions = synthesis.top_ideas.slice(0, 4).map((idea, i) => ({
+    label: `#${i}: ${idea.title.substring(0, 30)}`,
+    description: `Score: ${idea.score}/10 - ${idea.description?.substring(0, 50) || ''}`
+  }))
+
+  // Add primary recommendation option if different
+  if (synthesis.recommendations?.primary) {
+    ideaOptions.unshift({
+      label: "Primary Recommendation",
+      description: synthesis.recommendations.primary.substring(0, 60)
+    })
+  }
+
+  const selection = AskUser({
+    questions: [{
+      question: "Which idea should be developed?",
+      header: "Idea",
+      multiSelect: false,
+      options: ideaOptions
+    }]
+  })
+
+  // Parse selection
+  if (selection.idea === "Primary Recommendation") {
+    // Use primary recommendation as task
+    selectedIdea = {
+      title: "Primary Recommendation",
+      description: synthesis.recommendations.primary,
+      key_strengths: synthesis.key_insights || [],
+      main_challenges: [],
+      next_steps: synthesis.follow_up?.filter(f => f.type === 'implementation').map(f => f.summary) || []
+    }
+    selectionSource = 'primary recommendation'
+  } else {
+    const match = selection.idea.match(/^#(\d+):/)
+    const idx = match ? parseInt(match[1]) : 0
+    selectedIdea = synthesis.top_ideas[idx]
+    selectionSource = `user selected #${idx}`
+  }
+}
+
+console.log(`
+### Selected Idea
+
+**Title**: ${selectedIdea.title}
+**Source**: ${selectionSource}
+**Description**: ${selectedIdea.description?.substring(0, 200) || 'N/A'}
+`)
+```
+
+---
+
+### Phase 3: Task Formatting
+
+```javascript
+// Build enriched task description
+function formatTask(idea, synthesis) {
+  const sections = []
+
+  // Main objective
+  sections.push(`# Main Objective\n\n${idea.title}`)
+
+  // Description
+  if (idea.description) {
+    sections.push(`# Description\n\n${idea.description}`)
+  }
+
+  // Key strengths
+  if (idea.key_strengths?.length > 0) {
+    sections.push(`# Key Strengths\n\n${idea.key_strengths.map(s => `- ${s}`).join('\n')}`)
+  }
+
+  // Main challenges (important for RA agent)
+  if (idea.main_challenges?.length > 0) {
+    sections.push(`# Main Challenges to Address\n\n${idea.main_challenges.map(c => `- ${c}`).join('\n')}`)
+  }
+
+  // Recommended steps
+  if (idea.next_steps?.length > 0) {
+    sections.push(`# Recommended Implementation Steps\n\n${idea.next_steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`)
+  }
+
+  // Alternative approaches (for RA consideration)
+  if (synthesis.recommendations?.alternatives?.length > 0) {
+    sections.push(`# Alternative Approaches (for reference)\n\n${synthesis.recommendations.alternatives.map(a => `- ${a}`).join('\n')}`)
+  }
+
+  // Key insights from brainstorm
+  if (synthesis.key_insights?.length > 0) {
+    const relevantInsights = synthesis.key_insights.slice(0, 3)
+    sections.push(`# Key Insights from Brainstorm\n\n${relevantInsights.map(i => `- ${i}`).join('\n')}`)
+  }
+
+  // Source reference
+  sections.push(`# Source\n\nBrainstorm Session: ${synthesis.session_id}\nTopic: ${synthesis.topic}`)
+
+  return sections.join('\n\n')
+}
+
+const enrichedTask = formatTask(selectedIdea, synthesis)
+
+// Display formatted task
+console.log(`
+## Formatted Task for parallel-dev-cycle
+
+\`\`\`markdown
+${enrichedTask}
+\`\`\`
+`)
+
+// Save task to session folder for reference
+Write(`${sessionFolder}/cycle-task.md`, `# Generated Task\n\n**Generated**: ${getUtc8ISOString()}\n**Idea**: ${selectedIdea.title}\n**Selection**: ${selectionSource}\n\n---\n\n${enrichedTask}`)
+```
+
+---
+
+### Phase 4: Cycle Launch
+
+```javascript
+// Confirm launch (unless auto mode)
+let shouldLaunch = isAutoMode
+
+if (!isAutoMode) {
+  const confirmation = AskUser({
+    questions: [{
+      question: "Launch parallel-dev-cycle with this task?",
+      header: "Launch",
+      multiSelect: false,
+      options: [
+        { label: "Yes, launch cycle (Recommended)", description: "Start parallel-dev-cycle with enriched task" },
+        { label: "No, just save task", description: "Save formatted task for manual use" }
+      ]
+    }]
+  })
+
+  shouldLaunch = confirmation.launch.includes("Yes")
+}
+
+if (shouldLaunch) {
+  console.log(`
+## Launching parallel-dev-cycle
+
+**Task**: ${selectedIdea.title}
+**Source Session**: ${sessionId}
+`)
+
+  // Escape task for command line
+  const escapedTask = enrichedTask
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`')
+
+  // Launch parallel-dev-cycle
+  // Note: In actual execution, this would invoke the skill
+  console.log(`
+### Cycle Command
+
+\`\`\`bash
+/parallel-dev-cycle TASK="${escapedTask.substring(0, 100)}..."
+\`\`\`
+
+**Full task saved to**: ${sessionFolder}/cycle-task.md
+`)
+
+  // Return success with cycle trigger
+  return {
+    status: 'success',
+    action: 'launch_cycle',
+    session_id: sessionId,
+    idea: selectedIdea.title,
+    task_file: `${sessionFolder}/cycle-task.md`,
+    cycle_command: `/parallel-dev-cycle TASK="${enrichedTask}"`
+  }
+
+} else {
+  console.log(`
+## Task Saved (Not Launched)
+
+**Task file**: ${sessionFolder}/cycle-task.md
+
+To launch manually:
+\`\`\`bash
+/parallel-dev-cycle TASK="$(cat ${sessionFolder}/cycle-task.md)"
+\`\`\`
+`)
+
+  return {
+    status: 'success',
+    action: 'saved_only',
+    session_id: sessionId,
+    task_file: `${sessionFolder}/cycle-task.md`
+  }
+}
+```
+
+---
+
+## Session Files
+
+After execution:
+
+```
+.workflow/.brainstorm/{session-id}/
+├── brainstorm.md        # Original brainstorm
+├── synthesis.json       # Synthesis data (input)
+├── perspectives.json    # Perspectives data
+├── ideas/               # Idea deep-dives
+└── cycle-task.md        # ⭐ Generated task (output)
+```
+
+## Task Format
+
+The generated task includes:
+
+| Section | Purpose | Used By |
+|---------|---------|---------|
+| Main Objective | Clear goal statement | RA: Primary requirement |
+| Description | Detailed explanation | RA: Requirement context |
+| Key Strengths | Why this approach | RA: Design decisions |
+| Main Challenges | Known issues to address | RA: Edge cases, risks |
+| Implementation Steps | Suggested approach | EP: Planning guidance |
+| Alternatives | Other valid approaches | RA: Fallback options |
+| Key Insights | Learnings from brainstorm | RA: Domain context |
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Session not found | List available sessions, abort |
+| synthesis.json missing | Suggest completing brainstorm first |
+| No top_ideas | Report error, abort |
+| Invalid --idea index | Show valid range, abort |
+| Task too long | Truncate with reference to file |
+
+## Examples
+
+### Auto Mode (Quick Launch)
+
+```bash
+/brainstorm-to-cycle SESSION="BS-rate-limiting-2025-01-28" --auto
+# → Selects highest-scored idea
+# → Launches parallel-dev-cycle immediately
+```
+
+### Pre-Selected Idea
+
+```bash
+/brainstorm-to-cycle SESSION="BS-auth-system-2025-01-28" --idea=2
+# → Selects top_ideas[2]
+# → Confirms before launch
+```
+
+### Interactive Selection
+
+```bash
+/brainstorm-to-cycle SESSION="BS-caching-2025-01-28"
+# → Displays all ideas with scores
+# → User selects from options
+# → Confirms and launches
+```
+
+## Integration Flow
+
+```
+brainstorm-with-file
+        │
+        ▼
+   synthesis.json
+        │
+        ▼
+ brainstorm-to-cycle  ◄─── This command
+        │
+        ▼
+   enriched TASK
+        │
+        ▼
+ parallel-dev-cycle
+        │
+        ▼
+   RA → EP → CD → VAS
+```
+
+---
+
+**Now execute brainstorm-to-cycle** with session: $SESSION