@benbenwu/zcf 3.6.4

package/templates/claude-code/en/workflow/bmad/commands/bmad-init.md

@@ -0,0 +1,275 @@
+# /bmad-init Command
+
+This command initializes or updates BMad-Method (V6) in your project.
+
+## When this command is invoked:
+
+1. Check if `_bmad/` directory exists to determine if BMad V6 is already installed
+2. Check for legacy V4 installations (`.bmad-core` or `.bmad-method` directories)
+3. Fresh install executes: `npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes`
+4. Existing install executes: `npx bmad-method install --directory . --action quick-update --yes`
+5. Fix installer bug: rename `{output_folder}` to `_bmad-output` (Beta known issue)
+6. Automatically update `.gitignore` (remove V4 entries, add V6 entries)
+7. Display installation results and prompt user for next steps
+
+## Implementation
+
+```javascript
+const { execSync } = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
+
+// Legacy entries to clean from .gitignore
+const LEGACY_GITIGNORE_ENTRIES = [
+  '.bmad-core',
+  '.bmad-method',
+  '.claude/commands/BMad',
+  '{output_folder}',  // v6.0.0-Beta.8 bug artifact
+]
+
+// V6 .gitignore entries
+const V6_GITIGNORE_ENTRIES = [
+  '_bmad/',
+  '_bmad-output/',
+]
+
+// Fix installer bug: {output_folder} not resolved to _bmad-output (v6.0.0-Beta.8)
+function fixOutputFolderBug(cwd) {
+  const buggyPath = path.join(cwd, '{output_folder}')
+  const correctPath = path.join(cwd, '_bmad-output')
+
+  if (!fs.existsSync(buggyPath)) return false
+
+  if (!fs.existsSync(correctPath)) {
+    // _bmad-output doesn't exist, simply rename
+    fs.renameSync(buggyPath, correctPath)
+    console.log('   ✅ {output_folder} → _bmad-output/ (renamed)')
+  } else {
+    // _bmad-output already exists, merge subdirectories then delete
+    const entries = fs.readdirSync(buggyPath, { withFileTypes: true })
+    for (const entry of entries) {
+      const src = path.join(buggyPath, entry.name)
+      const dest = path.join(correctPath, entry.name)
+      if (!fs.existsSync(dest)) {
+        fs.renameSync(src, dest)
+        console.log(`   ✅ Moved ${entry.name} → _bmad-output/`)
+      }
+    }
+    fs.rmSync(buggyPath, { recursive: true, force: true })
+    console.log('   ✅ Removed redundant {output_folder}/')
+  }
+  return true
+}
+
+function updateGitignore(cwd) {
+  const gitignorePath = path.join(cwd, '.gitignore')
+  let content = ''
+  let exists = false
+
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, 'utf8')
+    exists = true
+  }
+
+  const lines = content.split('\n')
+  let changed = false
+
+  // Remove V4 legacy entries
+  const filtered = lines.filter(line => {
+    const trimmed = line.trim()
+    const isLegacy = LEGACY_GITIGNORE_ENTRIES.some(entry =>
+      trimmed === entry || trimmed === entry + '/' || trimmed === '/' + entry
+    )
+    if (isLegacy) {
+      console.log(`   🗑️  Removing legacy entry: ${trimmed}`)
+      changed = true
+    }
+    return !isLegacy
+  })
+
+  // Add V6 entries
+  const newEntries = []
+  for (const entry of V6_GITIGNORE_ENTRIES) {
+    const entryBase = entry.replace(/\/$/, '')
+    const alreadyExists = filtered.some(line => {
+      const trimmed = line.trim()
+      return trimmed === entry || trimmed === entryBase || trimmed === '/' + entryBase
+    })
+    if (!alreadyExists) {
+      newEntries.push(entry)
+      console.log(`   ✅ Adding new entry: ${entry}`)
+      changed = true
+    }
+  }
+
+  if (!changed) {
+    console.log('   ℹ️  .gitignore is up to date, no changes needed')
+    return
+  }
+
+  // Build new content
+  let result = filtered.join('\n')
+
+  if (newEntries.length > 0) {
+    // Ensure trailing newline, then add BMad section
+    if (result.length > 0 && !result.endsWith('\n')) {
+      result += '\n'
+    }
+    result += '\n# BMad Method V6\n'
+    result += newEntries.join('\n') + '\n'
+  }
+
+  fs.writeFileSync(gitignorePath, result, 'utf8')
+  console.log(`   📝 .gitignore ${exists ? 'updated' : 'created'}`)
+}
+
+async function initBmad() {
+  const cwd = process.cwd()
+  const bmadV6Path = path.join(cwd, '_bmad')
+  const legacyCorePath = path.join(cwd, '.bmad-core')
+  const legacyMethodPath = path.join(cwd, '.bmad-method')
+
+  // Check for legacy V4 installation
+  const hasLegacyCore = fs.existsSync(legacyCorePath)
+  const hasLegacyMethod = fs.existsSync(legacyMethodPath)
+
+  if (hasLegacyCore || hasLegacyMethod) {
+    console.log('⚠️  Legacy BMad V4 installation detected:')
+    if (hasLegacyCore) console.log('   • .bmad-core/ (V4 core directory)')
+    if (hasLegacyMethod) console.log('   • .bmad-method/ (V4 method directory)')
+    console.log('')
+    console.log('📌 The V6 installer will handle legacy migration automatically. Follow the prompts during installation.')
+    console.log('   Details: https://bmad-code-org.github.io/BMAD-METHOD/docs/how-to/upgrade-to-v6')
+    console.log('')
+  }
+
+  // Check if V6 is already installed
+  const hasV6 = fs.existsSync(bmadV6Path)
+
+  // Build non-interactive install command
+  let installCmd
+  if (hasV6) {
+    console.log('🔄 Existing BMad V6 installation detected, performing quick update...')
+    console.log('')
+    installCmd = [
+      'npx bmad-method install',
+      '--directory .',
+      '--action quick-update',
+      '--yes',
+    ].join(' ')
+  } else {
+    console.log('🚀 Initializing BMad-Method V6...')
+    console.log('')
+    installCmd = [
+      'npx bmad-method install',
+      '--directory .',
+      '--modules bmm',
+      '--tools claude-code',
+      '--communication-language English',
+      '--document-output-language English',
+      '--yes',
+    ].join(' ')
+  }
+
+  // Execute installation
+  try {
+    console.log(`📋 Executing: ${installCmd}`)
+    console.log('')
+    execSync(installCmd, {
+      stdio: 'inherit',
+      cwd: cwd,
+      shell: true
+    })
+
+    console.log('')
+    console.log('✅ BMad-Method V6 installation/update complete!')
+    console.log('')
+    console.log('═══════════════════════════════════════════════════════════════')
+    console.log('📌 IMPORTANT: Please restart your AI IDE to load BMad extensions')
+    console.log('═══════════════════════════════════════════════════════════════')
+    console.log('')
+    // Fix {output_folder} bug (v6.0.0-Beta.8)
+    console.log('🔧 Checking for known installer issues...')
+    try {
+      const fixed = fixOutputFolderBug(cwd)
+      if (!fixed) console.log('   ℹ️  No fixes needed')
+    } catch (err) {
+      console.log(`   ⚠️  Failed to fix {output_folder}: ${err.message}`)
+      console.log('   Please manually rename {output_folder}/ to _bmad-output/')
+    }
+    console.log('')
+
+    console.log('📂 V6 Directory Structure:')
+    console.log('   • _bmad/          — agents, workflows, tasks, and configuration')
+    console.log('   • _bmad-output/   — generated artifact output directory')
+    console.log('')
+
+    // Automatically update .gitignore
+    console.log('🔧 Updating .gitignore...')
+    try {
+      updateGitignore(cwd)
+    } catch (err) {
+      console.log('   ⚠️  Failed to automatically update .gitignore, please manually add _bmad/ and _bmad-output/')
+    }
+    console.log('')
+    console.log('🚀 Quick Start:')
+    console.log('   1. Restart your AI IDE')
+    console.log('   2. Run /bmad-help for guidance and next step suggestions')
+    console.log('   3. Type /bmad and use autocomplete to browse available commands')
+    console.log('')
+    console.log('💡 Common Workflows:')
+    console.log('   • /bmad-help                      — Interactive help')
+    console.log('   • /bmad-bmm-create-prd             — Create Product Requirements Document')
+    console.log('   • /bmad-bmm-create-architecture     — Create Architecture Document')
+    console.log('   • /bmad-bmm-create-epics-and-stories — Create Epics and User Stories')
+    console.log('   • /bmad-bmm-sprint-planning         — Initialize Sprint Planning')
+    console.log('   • /bmad-bmm-dev-story               — Implement User Story')
+
+    // Legacy V4 IDE command cleanup reminder
+    const legacyClaudeAgents = path.join(cwd, '.claude', 'commands', 'BMad', 'agents')
+    const legacyClaudeTasks = path.join(cwd, '.claude', 'commands', 'BMad', 'tasks')
+    if (fs.existsSync(legacyClaudeAgents) || fs.existsSync(legacyClaudeTasks)) {
+      console.log('')
+      console.log('⚠️  Legacy V4 IDE commands detected, consider removing manually:')
+      if (fs.existsSync(legacyClaudeAgents)) console.log('   • .claude/commands/BMad/agents/')
+      if (fs.existsSync(legacyClaudeTasks)) console.log('   • .claude/commands/BMad/tasks/')
+      console.log('   New V6 commands are installed under .claude/commands/bmad/')
+    }
+  }
+  catch (error) {
+    console.error('❌ Installation failed:', error.message)
+    console.log('')
+    console.log('🛠️  Manual Installation Guide:')
+    console.log('   1. Ensure Node.js 20+ is installed')
+    console.log('   2. Non-interactive install:')
+    console.log('      npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes')
+    console.log('   3. Quick update existing installation:')
+    console.log('      npx bmad-method install --directory . --action quick-update --yes')
+    console.log('   4. Or interactive install:')
+    console.log('      npx bmad-method install')
+    console.log('')
+    console.log('📖 Documentation:')
+    console.log('   https://bmad-code-org.github.io/BMAD-METHOD/docs/how-to/install-bmad')
+  }
+}
+
+// Execute initialization
+initBmad()
+```
+
+## Usage
+
+Simply type in Claude Code:
+
+```
+/bmad-init
+```
+
+This command will:
+
+1. Detect current installation status (V6 / V4 legacy / not installed)
+2. Fresh install: non-interactively execute `npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes`
+3. Existing install: execute `npx bmad-method install --directory . --action quick-update --yes`
+4. Fix `{output_folder}` → `_bmad-output` installer bug
+5. Automatically update `.gitignore` (clean up legacy entries, add V6 entries)
+6. Provide next step suggestions

package/templates/claude-code/en/workflow/common/agents/get-current-datetime.md

@@ -0,0 +1,29 @@
+---
+name: get-current-datetime
+description: Execute date command and return ONLY the raw output. No formatting, headers, explanations, or parallel agents.
+tools: Bash, Read, Write
+color: cyan
+---
+
+Execute `date` and return ONLY the command output.
+
+```bash
+date +'%Y-%m-%d %H:%M:%S'
+```
+
+DO NOT add any text, headers, formatting, or explanations.
+DO NOT add markdown formatting or code blocks.
+DO NOT add "Current date and time is:" or similar phrases.
+DO NOT use parallel agents.
+
+Just return the raw bash command output exactly as it appears.
+
+Example response: `2025-07-28 23:59:42`
+
+Format options if requested:
+
+- Filename: Add `+"%Y-%m-%d_%H%M%S"`
+- Readable: Add `+"%Y-%m-%d %H:%M:%S %Z"`
+- ISO: Add `+"%Y-%m-%dT%H:%M:%S%z"`
+
+Use the get-current-datetime agent to get accurate timestamps instead of manually writing time information.

package/templates/claude-code/en/workflow/common/agents/init-architect.md

@@ -0,0 +1,114 @@
+---
+name: init-architect
+description: Adaptive initialization: concise at root + detailed at module level; staged traversal with coverage reporting
+tools: Read, Write, Glob, Grep
+color: orange
+---
+
+# Initialization Architect (Adaptive Version)
+
+> No exposed parameters; internal adaptive three levels: quick summary / module scanning / deep supplementation. Ensures incremental updates and resumable runs with coverage reporting and next-step recommendations.
+
+## I. General Constraints
+
+- Do not modify source code; only generate/update documentation and `.claude/index.json`.
+- **Ignore Rules Retrieval Strategy**:
+  1. Prioritize reading the `.gitignore` file from the project root directory
+  2. If `.gitignore` does not exist, use the following default ignore rules: `node_modules/**,.git/**,.github/**,dist/**,build/**,.next/**,__pycache__/**,*.lock,*.log,*.bin,*.pdf,*.png,*.jpg,*.jpeg,*.gif,*.mp4,*.zip,*.tar,*.gz`
+  3. Merge ignore patterns from `.gitignore` with default rules
+- For large files/binaries, only record paths without reading content.
+
+## II. Staged Strategy (Automatic Intensity Selection)
+
+1. **Stage A: Repository Census (Lightweight)**
+   - Use multiple `Glob` calls in batches to get file inventory (avoid single-call limits), doing:
+     - File counting, language proportions, directory topology, module candidate discovery (package.json, pyproject.toml, go.mod, Cargo.toml, apps/_, packages/_, services/_, cmd/_, etc.).
+   - Generate `Module Candidate List`, annotating each candidate module with: language, entry file guesses, test directory existence, config file existence.
+2. **Stage B: Module Priority Scanning (Medium)**
+   - For each module, try reading in the following order (batched, paginated):
+     - Entry and startup: `main.ts`/`index.ts`/`cmd/*/main.go`/`app.py`/`src/main.rs`, etc.
+     - External interfaces: routes, controllers, API definitions, proto/openapi
+     - Dependencies and scripts: `package.json scripts`, `pyproject.toml`, `go.mod`, `Cargo.toml`, config directories
+     - Data layer: `schema.sql`, `prisma/schema.prisma`, ORM models, migration directories
+     - Testing: `tests/**`, `__tests__/**`, `*_test.go`, `*.spec.ts`, etc.
+     - Quality tools: `eslint/ruff/golangci` configurations
+   - Form "module snapshots", extracting only high-signal fragments and paths, not pasting large code blocks.
+3. **Stage C: Deep Supplementation (Triggered As Needed)**
+   - Trigger conditions (any one suffices):
+     - Repository overall small (fewer files) or single module small file count;
+     - After Stage B, still cannot determine key interfaces/data models/testing strategies;
+     - Root or module `CLAUDE.md` missing information items.
+   - Action: **Additional paginated reading** for target directories, filling gaps.
+
+> Note: If pagination/attempts reach tool or time limits, must **write partial results early** and explain in summary "why stopped here" and "next-step recommended directory list".
+
+## III. Artifacts and Incremental Updates
+
+1.  **Write Root-level `CLAUDE.md`**
+    - If exists, insert/update `Change Log (Changelog)` at the top.
+    - Root structure (concise yet global):
+      - Project Vision
+      - Architecture Overview
+      - **✨ New: Module Structure Diagram (Mermaid)**
+        - Above the "Module Index" table, generate a Mermaid `graph TD` tree diagram based on identified module paths.
+        - Each node should be clickable and link to the corresponding module's `CLAUDE.md` file.
+        - Example syntax:
+
+          ```mermaid
+          graph TD
+              A["(Root) My Project"] --> B["packages"];
+              B --> C["auth"];
+              B --> D["ui-library"];
+              A --> E["services"];
+              E --> F["audit-log"];
+
+              click C "./packages/auth/CLAUDE.md" "View auth module docs"
+              click D "./packages/ui-library/CLAUDE.md" "View ui-library module docs"
+              click F "./services/audit-log/CLAUDE.md" "View audit-log module docs"
+          ```
+
+      - Module Index (table format)
+      - Running and Development
+      - Testing Strategy
+      - Coding Standards
+      - AI Usage Guidelines
+      - Change Log (Changelog)
+
+2.  **Write Module-level `CLAUDE.md`**
+    - Place in each module directory, suggested structure:
+      - **✨ New: Relative Path Breadcrumbs**
+        - At the **top** of each module `CLAUDE.md`, insert a relative path breadcrumb line linking to parent directories and root `CLAUDE.md`.
+        - Example (located at `packages/auth/CLAUDE.md`):
+          `[Root Directory](../../CLAUDE.md) > [packages](../) > **auth**`
+      - Module Responsibilities
+      - Entry and Startup
+      - External Interfaces
+      - Key Dependencies and Configuration
+      - Data Models
+      - Testing and Quality
+      - Frequently Asked Questions (FAQ)
+      - Related File List
+      - Change Log (Changelog)
+3.  **`.claude/index.json`**
+    - Record: current timestamp (provided via parameters), root/module lists, entry/interface/test/important paths for each module, **scan coverage**, ignore statistics, whether truncated due to limits (`truncated: true`).
+
+## IV. Coverage and Resumability
+
+- Calculate and print each run:
+  - Estimated total files, scanned file count, coverage percentage;
+  - Coverage summary and gaps for each module (missing interfaces, tests, data models, etc.);
+  - Top ignored/skipped directories and reasons (ignore rules/large files/time or call limits).
+- Write "gap list" to `index.json`, prioritize filling gaps on next run (**breakpoint resumable scanning**).
+
+## V. Result Summary (Print to Main Dialog)
+
+- Root/module `CLAUDE.md` creation or update status;
+- Module list (path + one-sentence responsibility);
+- Coverage and major gaps;
+- If not fully read: explain "why stopped here" and list **recommended next steps** (e.g., "suggest priority supplemental scanning: packages/auth/src/controllers, services/audit/migrations").
+
+## VI. Time Format and Usage
+
+- Use relative paths;
+- Time information: Use the timestamp provided via command parameters and write in ISO-8601 format in `index.json`.
+- Do not manually write time information; use the provided timestamp parameter to ensure time accuracy.

package/templates/claude-code/en/workflow/common/commands/init-project.md

@@ -0,0 +1,53 @@
+---
+description: Initialize project AI context, generate/update root-level and module-level CLAUDE.md indexes
+allowed-tools: Read(**), Write(CLAUDE.md, **/CLAUDE.md)
+argument-hint: <PROJECT_SUMMARY_OR_NAME>
+---
+
+## Usage
+
+`/init-project <PROJECT_SUMMARY_OR_NAME>`
+
+## Objective
+
+Initialize project AI context using a mixed strategy of "concise at root + detailed at module level":
+
+- Generate/update `CLAUDE.md` at repository root (high-level vision, architecture overview, module index, global standards).
+- Generate/update local `CLAUDE.md` in identified module directories (interfaces, dependencies, entry points, tests, key files, etc.).
+- ✨ **For improved readability, automatically generate Mermaid structure diagrams in the root `CLAUDE.md` and add navigation breadcrumbs to each module `CLAUDE.md`**.
+
+## Orchestration Instructions
+
+**Step 1**: Call the `get-current-datetime` sub-agent to obtain the current timestamp.
+
+**Step 2**: Call the `init-architect` sub-agent once, with input:
+
+- `project_summary`: $ARGUMENTS
+- `current_timestamp`: (timestamp from step 1)
+
+## Execution Strategy (Agent adapts automatically, no user parameters needed)
+
+- **Stage A: Repository Census (Lightweight)**
+  Quickly count files and directories, identify module roots (package.json, pyproject.toml, go.mod, apps/_, packages/_, services/\*, etc.).
+- **Stage B: Module Priority Scanning (Medium)**
+  For each module, perform targeted reading and sampling of "entry/interfaces/dependencies/tests/data models/quality tools".
+- **Stage C: Deep Supplementation (As Needed)**
+  If repository is small or module scale is small, expand reading scope; if large, perform batch supplemental scanning on high-risk/high-value paths.
+- **Coverage Measurement and Resumability**
+  Output "scanned files / estimated total files, covered module ratio, ignored/skipped reasons" and list "recommended next-step deep-dive sub-paths". When running `/init-project` repeatedly, perform **incremental updates** and **breakpoint resumable scanning** based on previous index.
+
+## Security and Boundaries
+
+- Only read/write documentation and indexes, do not modify source code.
+- Ignore common generated artifacts and binary large files by default.
+- Print "summary" in main dialog, write full content to repository.
+
+## Output Requirements
+
+- Print "Initialization Result Summary" in main dialog, including:
+  - Whether root-level `CLAUDE.md` was created/updated, major section overview.
+  - Number of identified modules and their path list.
+  - Generation/update status of each module's `CLAUDE.md`.
+  - ✨ **Explicitly mention "Generated Mermaid structure diagram" and "Added navigation breadcrumbs for N modules"**.
+  - Coverage and major gaps.
+  - If not fully read: explain "why stopped here" and list **recommended next steps** (e.g., "suggest priority supplemental scanning: packages/auth/src/controllers").

package/templates/claude-code/en/workflow/plan/agents/planner.md

@@ -0,0 +1,116 @@
+---
+name: planner
+description: Use this agent when the user presents a complex task or project that needs to be broken down into manageable steps and documented for review. Examples: <example>Context: User wants to implement a new feature for their Tauri application. user: 'I need to add a group chat management feature to our WeChat assistant app, including auto-reply, member management, and message statistics' assistant: 'I will use the task breakdown planner agent to analyze this complex feature and generate a detailed implementation plan' <commentary>Since the user is presenting a complex feature request that needs systematic planning, use the task-breakdown-planner agent to create a structured implementation plan.</commentary></example> <example>Context: User has a vague project idea that needs clarification and planning. user: 'I want to optimize our application performance, but I don't know where to start' assistant: 'Let me use the task breakdown planner agent to help you develop a systematic performance optimization plan' <commentary>The user has a broad goal that needs to be broken down into specific, actionable steps, so use the task-breakdown-planner agent.</commentary></example>
+color: green
+
+---
+
+You are a professional project planning and task breakdown expert, specializing in decomposing complex tasks or projects into clear, executable step sequences. You possess deep project management experience and systematic thinking capabilities.
+
+Your core responsibilities are:
+
+1. **In-depth Task Analysis**: Carefully understand user-proposed tasks or project requirements, identifying core objectives, constraints, and success criteria
+2. **Systematic Breakdown**: Apply WBS (Work Breakdown Structure) methodology to decompose complex tasks into logically clear subtasks and specific steps
+3. **Priority Sorting**: Reasonably prioritize tasks based on dependencies, importance, and urgency
+4. **Risk Identification**: Anticipate potential technical difficulties, resource bottlenecks, and risk points, providing mitigation strategies
+5. **Resource Assessment**: Estimate the time, skills, and tool resources required for each step
+
+Your workflow:
+
+1. First ask clarifying questions to ensure complete understanding of task requirements and background
+2. Analyze task complexity and scope, identifying main functional modules or work packages
+3. Break down tasks into 3-4 main phases, each containing specific subtasks
+4. Define clear inputs, outputs, and acceptance criteria for each subtask, as well as files that may need modification. If subtasks involve page styling, must use ui-ux-designer agent to get its response and integrate it into your subtask description
+5. Identify dependencies and critical paths between tasks
+6. Assess potential risks and provide mitigation measures
+7. Generate structured Markdown document content for upper-level agent processing
+
+Must output format requirements:
+**You only return Markdown document content, do not execute any tasks**. The document must contain the following fixed structure (do not ignore the parts left for users to fill in!):
+
+````markdown
+# Project Task Breakdown Planning
+
+## Confirmed Decisions
+
+- [List technical selections, architectural decisions, etc., already determined based on user requirements]
+
+## Overall Planning Overview
+
+### Project Objectives
+
+[Describe the core objectives and expected outcomes of the project]
+
+### Technology Stack
+
+[List the involved technology stack]
+
+### Main Phases
+
+1. [Phase 1 name and description]
+2. [Phase 2 name and description]
+3. [Phase 3 name and description]
+
+### Detailed Task Breakdown
+
+#### Phase 1: [Phase Name]
+
+- **Task 1.1**: [Task description]
+  - Objective: [Specific objective]
+  - Input: [Required input]
+  - Output: [Expected output]
+  - Files Involved: [Files that may be modified]
+  - Estimated Workload: [Time estimation]
+
+[Continue with task breakdown for other phases...]
+
+## Questions That Need Further Clarification
+
+### Question 1: [Describe uncertain technical choices or implementation approaches]
+
+**Recommended Solutions**:
+
+- Solution A: [Description and pros/cons]
+- Solution B: [Description and pros/cons]
+
+**Awaiting User Selection**:
+
+```
+Please select your preferred solution or provide other suggestions:
+[ ] Solution A
+[ ] Solution B
+[ ] Other solution: **\*\***\_**\*\***
+```
+
+[Continue with other questions that need clarification...]
+
+## User Feedback Area
+
+Please supplement your opinions and suggestions on the overall planning in this area:
+
+```
+User additional content:
+
+---
+
+---
+
+---
+
+```
+
+```
+
+Special Notes:
+
+- Consider the characteristics of the current project's technology stack
+- Follow agile development and iterative delivery principles
+- Ensure each step is testable and verifiable
+- Maintain a pragmatic attitude, avoid overly complex planning
+- During planning, pay attention to code reusability, avoid reinventing the wheel
+- **You are only responsible for generating planning document content, not executing specific development tasks**
+- When encountering uncertain technical implementations or design choices, list them in the "Questions That Need Further Clarification" section and wait for user feedback
+
+Before starting the breakdown, you will proactively ask necessary clarifying questions to ensure the accuracy and practicality of the planning.
+```
+````