claude-code-workflow 7.2.30 → 7.3.0

package/.claude/skills/ccw-chain/phases/brainstorm-with-file.md

@@ -1,482 +0,0 @@
----
-name: brainstorm-with-file
-description: Interactive brainstorming with multi-CLI collaboration, idea expansion, and documented thought evolution
-argument-hint: "[-y|--yes] [-c|--continue] [-m|--mode creative|structured] \"idea or topic\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-confirm decisions, use recommended roles, balanced exploration mode.
-
-# Workflow Brainstorm Command
-
-## Quick Start
-
-```bash
-# Basic usage
-/workflow:brainstorm-with-file "如何重新设计用户通知系统"
-
-# With options
-/workflow:brainstorm-with-file --continue "通知系统"              # Continue existing
-/workflow:brainstorm-with-file -y -m creative "创新的AI辅助功能"   # Creative auto mode
-/workflow:brainstorm-with-file -m structured "优化缓存策略"       # Goal-oriented mode
-```
-
-**Context Source**: cli-explore-agent + Multi-CLI perspectives (Gemini/Codex/Claude or Professional Roles)
-**Output Directory**: `.workflow/.brainstorm/{session-id}/`
-**Core Innovation**: Diverge-Converge cycles with documented thought evolution
-
-## Output Artifacts
-
-| Phase | Artifact | Description |
-|-------|----------|-------------|
-| 1 | `brainstorm.md` | Complete thought evolution timeline (initialized) |
-| 1 | Session variables | Dimensions, roles, exploration vectors |
-| 2 | `exploration-codebase.json` | Codebase context from cli-explore-agent |
-| 2 | `perspectives.json` | Multi-CLI perspective findings (creative/pragmatic/systematic) |
-| 2 | Updated `brainstorm.md` | Round 2 multi-perspective exploration |
-| 3 | `ideas/{idea-slug}.md` | Deep-dive analysis for selected ideas |
-| 3 | Updated `brainstorm.md` | Round 3-6 refinement cycles |
-| 4 | `synthesis.json` | Final synthesis with top ideas, recommendations |
-| 4 | Final `brainstorm.md` | Complete thought evolution with conclusions |
-
-## Output Structure
-
-```
-.workflow/.brainstorm/BS-{slug}-{date}/
-├── brainstorm.md                  # ⭐ Complete thought evolution timeline
-├── exploration-codebase.json      # Phase 2: Codebase context
-├── perspectives.json              # Phase 2: Multi-CLI findings
-├── synthesis.json                 # Phase 4: Final synthesis
-└── ideas/                         # Phase 3: Individual idea deep-dives
-    ├── idea-1.md
-    ├── idea-2.md
-    └── merged-idea-1.md
-```
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    INTERACTIVE BRAINSTORMING WORKFLOW                    │
-├─────────────────────────────────────────────────────────────────────────┤
-│                                                                          │
-│  Phase 1: Seed Understanding                                             │
-│     ├─ Parse initial idea/topic                                          │
-│     ├─ Identify dimensions (technical, UX, business, etc.)               │
-│     ├─ Select roles (professional or simple perspectives)                │
-│     ├─ Initial scoping questions                                         │
-│     ├─ Expand into exploration vectors                                   │
-│     └─ Initialize brainstorm.md                                          │
-│                                                                          │
-│  Phase 2: Divergent Exploration                                          │
-│     ├─ cli-explore-agent: Codebase context (FIRST)                       │
-│     ├─ Multi-CLI Perspectives (AFTER exploration)                        │
-│     │   ├─ Creative (Gemini): Innovation, cross-domain                   │
-│     │   ├─ Pragmatic (Codex): Implementation, feasibility                │
-│     │   └─ Systematic (Claude): Architecture, structure                  │
-│     └─ Aggregate diverse viewpoints                                      │
-│                                                                          │
-│  Phase 3: Interactive Refinement (Multi-Round)                           │
-│     ├─ Present multi-perspective findings                                │
-│     ├─ User selects promising directions                                 │
-│     ├─ Actions: Deep dive | Generate more | Challenge | Merge            │
-│     ├─ Update brainstorm.md with evolution                               │
-│     └─ Repeat diverge-converge cycles (max 6 rounds)                     │
-│                                                                          │
-│  Phase 4: Convergence & Crystallization                                  │
-│     ├─ Synthesize best ideas                                             │
-│     ├─ Resolve conflicts between perspectives                            │
-│     ├─ Generate actionable conclusions                                   │
-│     ├─ Offer next steps (plan/issue/analyze/export)                      │
-│     └─ Final brainstorm.md update                                        │
-│                                                                          │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-## Implementation
-
-### Session Initialization
-
-1. Extract idea/topic from `$ARGUMENTS`
-2. Generate session ID: `BS-{slug}-{date}` (slug: lowercase, alphanumeric + Chinese, max 40 chars; date: YYYY-MM-DD UTC+8)
-3. Define session folder: `.workflow/.brainstorm/{session-id}`
-4. Parse command options:
-   - `-c` or `--continue` for session continuation
-   - `-m` or `--mode` for brainstorm mode (creative/structured/balanced)
-   - `-y` or `--yes` for auto-approval mode
-5. Auto-detect mode: If session folder + brainstorm.md exist → continue mode
-6. Create directory structure: `{session-folder}/ideas/`
-
-7. **Create Progress Tracking** (TodoWrite — MANDATORY):
-   ```
-   TodoWrite([
-     { id: "phase-1", title: "Phase 1: Seed Understanding", status: "in_progress" },
-     { id: "phase-2", title: "Phase 2: Divergent Exploration", status: "pending" },
-     { id: "phase-3", title: "Phase 3: Interactive Refinement", status: "pending" },
-     { id: "phase-4", title: "Phase 4: Convergence & Crystallization", status: "pending" },
-     { id: "next-step", title: "GATE: Post-Completion Next Step", status: "pending" }
-   ])
-   ```
-   - Update status to `"in_progress"` when entering each phase, `"completed"` when done
-   - **`next-step` is a terminal gate** — workflow is NOT complete until this todo is `"completed"`
-
-**Session Variables**: `sessionId`, `sessionFolder`, `brainstormMode` (creative|structured|balanced), `autoMode` (boolean), `mode` (new|continue)
-
-### Phase 1: Seed Understanding
-
-1. **Parse Seed & Identify Dimensions**
-   - Match topic keywords against Brainstorm Dimensions table
-   - Default dimensions based on brainstormMode if no match
-
-2. **Role Selection**
-   - Recommend roles based on topic keywords (see Role Selection tables)
-   - **Professional roles**: system-architect, product-manager, ui-designer, ux-expert, data-architect, test-strategist, subject-matter-expert, product-owner, scrum-master
-   - **Simple perspectives** (fallback): creative/pragmatic/systematic
-   - **Auto mode**: Select top 3 recommended professional roles
-   - **Manual mode**: AskUserQuestion with recommended roles + "Use simple perspectives" option
-
-3. **Initial Scoping Questions** (if new session + not auto mode)
-   - **Direction**: Multi-select from directions generated by detected dimensions
-   - **Depth**: Single-select from quick/balanced/deep (15-20min / 30-60min / 1-2hr)
-   - **Constraints**: Multi-select from existing architecture, time, resources, or no constraints
-
-4. **Expand Seed into Exploration Vectors**
-
-```javascript
-Bash({
-  command: `ccw cli -p "
-Given the initial idea: '${idea_or_topic}'
-User focus areas: ${userFocusAreas.join(', ')}
-Constraints: ${constraints.join(', ')}
-
-Generate 5-7 exploration vectors (questions/directions) to expand this idea:
-1. Core question: What is the fundamental problem/opportunity?
-2. User perspective: Who benefits and how?
-3. Technical angle: What enables this technically?
-4. Alternative approaches: What other ways could this be solved?
-5. Challenges: What could go wrong or block success?
-6. Innovation angle: What would make this 10x better?
-7. Integration: How does this fit with existing systems/processes?
-
-Output as structured exploration vectors for multi-perspective analysis.
-" --tool gemini --mode analysis --model gemini-2.5-flash`,
-  run_in_background: false
-})
-```
-
-5. **Initialize brainstorm.md** with session metadata, initial context (user focus, depth, constraints), seed expansion (original idea + exploration vectors), empty thought evolution timeline sections
-
-**TodoWrite**: Update `phase-1` → `"completed"`, `phase-2` → `"in_progress"`
-
-### Phase 2: Divergent Exploration
-
-1. **Primary Codebase Exploration via cli-explore-agent** (⚠️ FIRST)
-
-```javascript
-Agent({
-  subagent_type: "cli-explore-agent",
-  run_in_background: false,
-  description: `Explore codebase for brainstorm: ${topicSlug}`,
-  prompt: `
-## Brainstorm Context
-Topic: ${idea_or_topic}
-Dimensions: ${dimensions.join(', ')}
-Mode: ${brainstormMode}
-Session: ${sessionFolder}
-
-## MANDATORY FIRST STEPS
-1. Run: ccw tool exec get_modules_by_depth '{}'
-2. Search for code related to topic keywords
-3. Read: .workflow/project-tech.json (if exists)
-
-## Exploration Focus
-- Identify existing implementations related to the topic
-- Find patterns that could inspire solutions
-- Map current architecture constraints
-- Locate integration points
-
-## Output
-Write findings to: ${sessionFolder}/exploration-codebase.json
-
-Schema:
-{
-  "relevant_files": [{"path": "...", "relevance": "high|medium|low", "rationale": "..."}],
-  "existing_patterns": [],
-  "architecture_constraints": [],
-  "integration_points": [],
-  "inspiration_sources": [],
-  "_metadata": { "exploration_type": "brainstorm-codebase", "timestamp": "..." }
-}
-`
-})
-```
-
-2. **Multi-CLI Perspective Analysis** (⚠️ AFTER exploration)
-
-Build shared context from exploration results:
-
-```javascript
-const explorationContext = `
-PRIOR EXPLORATION CONTEXT (from cli-explore-agent):
-- Key files: ${explorationResults.relevant_files.slice(0,5).map(f => f.path).join(', ')}
-- Existing patterns: ${explorationResults.existing_patterns.slice(0,3).join(', ')}
-- Architecture constraints: ${explorationResults.architecture_constraints.slice(0,3).join(', ')}
-- Integration points: ${explorationResults.integration_points.slice(0,3).join(', ')}`
-```
-
-Launch 3 parallel CLI calls (`run_in_background: true` each), one per perspective:
-
-| Perspective | Tool | PURPOSE | Key TASK bullets | EXPECTED | CONSTRAINTS |
-|-------------|------|---------|-----------------|----------|-------------|
-| Creative | gemini | Generate innovative ideas | Challenge assumptions, cross-domain inspiration, moonshot + practical ideas | 5+ creative ideas with novelty/impact ratings | structured mode: keep feasible |
-| Pragmatic | codex | Implementation reality | Evaluate feasibility, estimate complexity, identify blockers, incremental approach | 3-5 practical approaches with effort/risk ratings | Current tech stack |
-| Systematic | claude | Architectural thinking | Decompose problems, identify patterns, map dependencies, scalability | Problem decomposition, 2-3 approaches with tradeoffs | Existing architecture |
-
-```javascript
-// Each perspective uses this prompt structure (launch all 3 in parallel):
-Bash({
-  command: `ccw cli -p "
-PURPOSE: ${perspective} brainstorming for '${idea_or_topic}' - ${purposeFocus}
-Success: ${expected}
-
-${explorationContext}
-
-TASK:
-• Build on explored ${contextType} - how to ${actionVerb}?
-${perspectiveSpecificBullets}
-
-MODE: analysis
-CONTEXT: @**/* | Topic: ${idea_or_topic}
-EXPECTED: ${expected}
-CONSTRAINTS: ${constraints}
-" --tool ${tool} --mode analysis`,
-  run_in_background: true
-})
-// ⚠️ STOP POINT: Wait for hook callback to receive all results before continuing
-```
-
-3. **Aggregate Multi-Perspective Findings**
-   - Convergent themes (all agree), conflicting views (need resolution), unique contributions
-   - Write to perspectives.json
-
-4. **Update brainstorm.md** with Round 2 multi-perspective exploration and synthesis
-
-### Phase 3: Interactive Refinement
-
-**Guideline**: Delegate complex tasks to agents (cli-explore-agent, code-developer, universal-executor) or CLI calls. Avoid direct analysis/execution in main process.
-
-1. **Present Current State**: Extract top ideas from perspectives.json with title, source, description, novelty/feasibility ratings
-
-2. **Gather User Direction** (AskUserQuestion)
-   - **Q1**: Which ideas to explore (multi-select from top ideas)
-   - **Q2**: Next step (single-select):
-     - **深入探索**: Deep dive on selected ideas
-     - **继续发散**: Generate more ideas
-     - **挑战验证**: Devil's advocate challenge
-     - **合并综合**: Merge multiple ideas
-     - **准备收敛**: Begin convergence (exit loop)
-
-3. **Execute User-Selected Action**
-
-| Action | Tool | Output | Key Tasks |
-|--------|------|--------|-----------|
-| Deep Dive | Gemini CLI | ideas/{slug}.md | Elaborate concept, requirements, challenges, POC approach, metrics, dependencies |
-| Generate More | Selected CLI | Updated perspectives.json | New angles from unexplored vectors |
-| Challenge | Codex CLI | Challenge results | 3 objections per idea, challenge assumptions, failure scenarios, survivability (1-5) |
-| Merge | Gemini CLI | ideas/merged-{slug}.md | Complementary elements, resolve contradictions, unified concept |
-
-**Deep Dive CLI Call**:
-```javascript
-Bash({
-  command: `ccw cli -p "
-PURPOSE: Deep dive analysis on idea '${idea.title}'
-Success: Comprehensive understanding with actionable next steps
-
-TASK:
-• Elaborate the core concept in detail
-• Identify implementation requirements
-• List potential challenges and mitigations
-• Suggest proof-of-concept approach
-• Define success metrics
-• Map related/dependent features
-
-MODE: analysis
-CONTEXT: @**/*
-Original idea: ${idea.description}
-Source perspective: ${idea.source}
-
-EXPECTED: Detailed concept, technical requirements, risk matrix, MVP definition, success criteria, recommendation (pursue/pivot/park)
-CONSTRAINTS: Focus on actionability
-" --tool gemini --mode analysis`,
-  run_in_background: false
-})
-```
-
-**Devil's Advocate CLI Call**:
-```javascript
-Bash({
-  command: `ccw cli -p "
-PURPOSE: Devil's advocate - rigorously challenge these brainstorm ideas
-Success: Uncover hidden weaknesses and strengthen viable ideas
-
-IDEAS TO CHALLENGE:
-${ideas.map((idea, i) => `${i+1}. ${idea.title}: ${idea.brief}`).join('\n')}
-
-TASK:
-• For each idea, identify 3 strongest objections
-• Challenge core assumptions
-• Identify scenarios where this fails
-• Consider competitive/alternative solutions
-• Rate survivability after challenge (1-5)
-
-MODE: analysis
-EXPECTED: Per-idea challenge report, critical weaknesses, survivability ratings, modified/strengthened versions
-CONSTRAINTS: Be genuinely critical, not just contrarian
-" --tool codex --mode analysis`,
-  run_in_background: false
-})
-```
-
-**Merge Ideas CLI Call**:
-```javascript
-Bash({
-  command: `ccw cli -p "
-PURPOSE: Synthesize multiple ideas into unified concept
-Success: Coherent merged idea that captures best elements
-
-IDEAS TO MERGE:
-${selectedIdeas.map((idea, i) => `
-${i+1}. ${idea.title} (${idea.source})
-   ${idea.description}
-   Strengths: ${idea.strengths.join(', ')}
-`).join('\n')}
-
-TASK:
-• Identify complementary elements
-• Resolve contradictions
-• Create unified concept preserving key strengths
-• Assess viability of merged idea
-
-MODE: analysis
-EXPECTED: Merged concept, elements from each source, contradictions resolved, implementation considerations
-CONSTRAINTS: Don't force incompatible ideas together
-" --tool gemini --mode analysis`,
-  run_in_background: false
-})
-```
-
-4. **Update brainstorm.md** with Round N findings
-5. **Repeat or Converge**: Continue loop (max 6 rounds) or exit to Phase 4
-
-**TodoWrite**: Update `phase-2` → `"completed"` (after first round enters Phase 3), `phase-3` → `"in_progress"`
-**TodoWrite** (on exit loop): Update `phase-3` → `"completed"`, `phase-4` → `"in_progress"`
-
-### Phase 4: Convergence & Crystallization
-
-1. **Generate Final Synthesis** → Write to synthesis.json
-   - **Top ideas**: Filter active, sort by score, top 5 with title, description, source_perspective, score, novelty, feasibility, strengths, challenges, next_steps
-   - **Parked ideas**: With reason and future trigger
-   - **Key insights**: Process discoveries, challenged assumptions, unexpected connections
-   - **Recommendations**: Primary, alternatives, not recommended
-   - **Follow-up**: Implementation/research/validation summaries
-
-**synthesis.json Schema**: `session_id`, `topic`, `completed` (timestamp), `total_rounds`, `top_ideas[]`, `parked_ideas[]`, `key_insights[]`, `recommendations` (primary/alternatives/not_recommended), `follow_up[]`
-
-2. **Final brainstorm.md Update**: Executive summary, top ideas ranked, primary recommendation with rationale, alternative approaches, parked ideas, key insights, session statistics (rounds, ideas generated/survived, duration)
-
-3. **MANDATORY GATE: Next Step Selection** — workflow MUST NOT end without executing this step.
-
-   **TodoWrite**: Update `phase-4` → `"completed"`, `next-step` → `"in_progress"`
-
-   > **CRITICAL**: This AskUserQuestion is a **terminal gate**. The workflow is INCOMPLETE if this question is not asked. After displaying synthesis (step 2), you MUST immediately proceed here.
-
-   Call AskUserQuestion (single-select, header: "Next Step"):
-   - **创建实施计划** (Recommended if top idea has high feasibility): "基于最佳创意启动 workflow-plan 制定实施计划"
-   - **创建Issue**: "将 Top 3 创意转化为 issue 进行跟踪管理"
-   - **深入分析**: "对最佳创意启动 analyze-with-file 深入技术分析"
-   - **完成**: "头脑风暴已足够，无需进一步操作"
-
-   **Handle user selection**:
-
-   **"创建实施计划"** → MUST invoke Skill tool:
-   1. Build `taskDescription` from top idea in synthesis.json (title + description + next_steps)
-   2. Assemble context: `## Prior Brainstorm ({sessionId})` + summary + top idea details + key insights (up to 5)
-   3. **Invoke Skill tool immediately**:
-      ```javascript
-      Skill({ skill: "workflow-plan", args: `${taskDescription}\n\n${contextLines}` })
-      ```
-      If Skill invocation is omitted, the workflow is BROKEN.
-   4. After Skill invocation, brainstorm-with-file is complete
-
-   **"创建Issue"** → Convert top ideas to issues:
-   1. For each idea in synthesis.top_ideas (top 3):
-      - Build issue JSON: `{title: idea.title, context: idea.description + '\n' + idea.next_steps.join('\n'), priority: idea.score >= 8 ? 2 : 3, source: 'brainstorm', labels: dimensions}`
-      - Create via: `Skill({ skill: "issue:from-brainstorm", args: "${sessionFolder}/synthesis.json" })`
-   2. Display created issue IDs
-
-   **"深入分析"** → Launch analysis on top idea:
-   1. Build analysis topic from top idea title + description
-   2. **Invoke Skill tool immediately**:
-      ```javascript
-      Skill({ skill: "workflow:analyze-with-file", args: `${topIdea.title}: ${topIdea.description}` })
-      ```
-
-   **"完成"** → No further action needed.
-
-   **TodoWrite**: Update `next-step` → `"completed"` after user selection is handled
-
-## Configuration
-
-### Brainstorm Dimensions
-
-| Dimension | Keywords |
-|-----------|----------|
-| technical | 技术, technical, implementation, code, 实现, architecture |
-| ux | 用户, user, experience, UX, UI, 体验, interaction |
-| business | 业务, business, value, ROI, 价值, market |
-| innovation | 创新, innovation, novel, creative, 新颖 |
-| feasibility | 可行, feasible, practical, realistic, 实际 |
-| scalability | 扩展, scale, growth, performance, 性能 |
-| security | 安全, security, risk, protection, 风险 |
-
-### Role Selection
-
-**Professional Roles**:
-
-| Role | CLI Tool | Focus Area | Keywords |
-|------|----------|------------|----------|
-| system-architect | Claude | Architecture, patterns | 架构, architecture, system, 系统, design pattern |
-| product-manager | Gemini | Business value, roadmap | 产品, product, feature, 功能, roadmap |
-| ui-designer | Gemini | Visual design, interaction | UI, 界面, interface, visual, 视觉 |
-| ux-expert | Codex | User research, usability | UX, 体验, experience, user, 用户 |
-| data-architect | Claude | Data modeling, storage | 数据, data, database, 存储, storage |
-| test-strategist | Codex | Quality, testing | 测试, test, quality, 质量, QA |
-| subject-matter-expert | Gemini | Domain knowledge | 领域, domain, industry, 行业, expert |
-| product-owner | Codex | Priority, scope | 优先, priority, scope, 范围, backlog |
-| scrum-master | Gemini | Process, collaboration | 敏捷, agile, scrum, sprint, 迭代 |
-
-**Simple Perspectives** (fallback):
-
-| Perspective | CLI Tool | Focus |
-|-------------|----------|-------|
-| creative | Gemini | Innovation, cross-domain |
-| pragmatic | Codex | Implementation, feasibility |
-| systematic | Claude | Architecture, structure |
-
-**Selection Strategy**: Auto mode → top 3 professional roles | Manual mode → recommended roles + "Use simple perspectives" option | Continue mode → roles from previous session
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| cli-explore-agent fails | Continue with empty exploration context |
-| CLI timeout | Retry with shorter prompt, or skip perspective |
-| No good ideas | Reframe problem, adjust constraints, try new angles |
-| User disengaged | Summarize progress, offer break point with resume |
-| Perspectives conflict | Present as tradeoff, let user decide |
-| Max rounds reached | Force synthesis, highlight unresolved questions |
-| All ideas fail challenge | Return to divergent phase with new constraints |
-
----
-
-**Now execute brainstorm-with-file for**: $ARGUMENTS