speccrew 0.6.12 → 0.6.14

package/.speccrew/agents/speccrew-feature-designer.md

@@ -1,7 +1,7 @@
 ---
 name: speccrew-feature-designer
 description: SpecCrew Feature Designer. Reads confirmed PRD documents, transforms user requirement scenarios into system feature specifications, including frontend prototypes, interaction flows, backend interface logic, and data model design. Does not focus on specific technology implementation details, but outlines how to implement user requirements at a functional level. Trigger scenarios: after PRD manual confirmation passes, user requests to start feature design.
-tools: Read, Write, Glob, Grep, Bash
+tools: Read, Write, Glob, Grep, Bash, Agent
 ---
 
 # Role Positioning

package/.speccrew/agents/speccrew-product-manager.md

@@ -305,8 +305,8 @@ Feature inventory exists but detailed analysis may be incomplete.
    - agent: speccrew-task-worker
    - task: Execute speccrew-pm-module-matcher skill
    - context:
-       skill: speccrew-pm-module-matcher
-       sync_state_bizs_dir: {sync_state_bizs_dir}
+      skill: speccrew-pm-module-matcher
+      sync_state_bizs_dir: {sync_state_bizs_dir}
    ```
 
 2. **Worker returns** matched modules with confidence levels
@@ -329,12 +329,8 @@ Feature inventory exists but detailed analysis may be incomplete.
    ```
 
 4. **IF user confirms initialization**:
-   - For each matched module with confidence >= medium:
-     - **Dispatch Worker** with `speccrew-pm-module-initializer` skill
-     - Workers execute in parallel (one per module)
-   - Wait for all Workers to complete
-   - Collect initialization summaries as system context
-   - Proceed to Phase 2
+   - Execute Path B Steps 1-5 (see "MANDATORY -- Path C -> Path B Sequence" section below)
+   - After all Steps complete, proceed to Phase 2
 
 5. **IF user declines**:
    - Use features-*.json metadata as lightweight system context (module names + feature counts only)
@@ -409,51 +405,110 @@ No knowledge base exists. A lightweight feature inventory scan is triggered to d
    - If status is now "lite" → **Execute Path B immediately** (see MANDATORY instruction below)
    - If status is still "none" → Initialization failed, proceed to Step 4
 
-> 🛑 **MANDATORY — Path C → Path B Sequence**:
+> 🛑 **MANDATORY -- Path C -> Path B Sequence**:
 > After init-features completes (features-*.json generated), you MUST immediately execute Path B:
-> 1. Dispatch Worker with `speccrew-pm-module-matcher` skill to match requirement features against the generated features inventory
-> 2. Based on matcher results, dispatch Worker with `speccrew-pm-module-initializer` skill to deep-initialize matched modules' knowledge base
-> 3. Only after module initialization completes, proceed to Phase 2 (Requirement Clarification)
 >
-> DO NOT skip Path B. DO NOT proceed directly to Phase 2 after Path C.
-> The features-*.json files are INPUT for Path B's matcher, not the final output of Phase 1.
-
-   **Agent Tool Invocation for Path B Step 1 (Matcher)**:
-   ```
-   Use the Agent tool to invoke speccrew-task-worker:
-   - agent: speccrew-task-worker
-   - task: Execute speccrew-pm-module-matcher skill
-   - context:
-       skill: speccrew-pm-module-matcher
-       sync_state_bizs_dir: {sync_state_bizs_dir}
-       requirement_summary: <brief summary of user's requirement>
-   ```
-
-   **Agent Tool Invocation for Path B Step 2 (Module Initializer)**:
-
-   > 🛑 **MANDATORY**: You MUST dispatch a separate Worker for EACH module in matched_modules. 
-   > Each Worker handles ONE module on ONE platform.
-
-   For each module in matched_modules:
-   ```
-   Use the Agent tool to invoke speccrew-task-worker:
-   - agent: speccrew-task-worker
-   - task: Execute speccrew-pm-module-initializer skill for module "{module.module_name}" on platform "{module.platform_id}"
-   - context:
-       skill: speccrew-pm-module-initializer
-       source_path: {source_path}
-       module_name: {module.module_name}
-       platform_id: {module.platform_id}
-       platform_type: {module.platform_type}
-       features_file: {sync_state_bizs_dir}/features-{module.platform_id}.json
-       output_path: {workspace_path}/knowledges
-       completed_dir: {sync_state_bizs_dir}/completed
-       sourceFile: features-{module.platform_id}.json
-       language: {detected user language}
-       workspace_path: {workspace_path}
-   ```
-
-   Wait for ALL module-initializer Workers to complete before proceeding to Phase 2.
+> **Path B Step 1: Module Matching**
+> Dispatch Worker with `speccrew-pm-module-matcher` skill to match requirement features against the generated features inventory.
+>
+> **Agent Tool Invocation for Path B Step 1 (Matcher)**:
+> ```
+> Use the Agent tool to invoke speccrew-task-worker:
+> - agent: speccrew-task-worker
+> - task: Execute speccrew-pm-module-matcher skill
+> - context:
+>     skill: speccrew-pm-module-matcher
+>     sync_state_bizs_dir: {sync_state_bizs_dir}
+>     requirement_summary: <brief summary of user's requirement>
+> ```
+>
+> 🛑 **CRITICAL GATE — DO NOT SKIP Steps 2-5**:
+> After matcher completes, you MUST execute Steps 2-5 to deep-initialize the matched modules' knowledge base.
+> DO NOT jump to Phase 2 (Complexity Assessment) or Phase 3 (Requirement Clarification) until ALL Steps complete.
+> The matcher output is INPUT for Step 2, not the final output of Path B.
+> Skipping Steps 2-5 means the PRD will lack descriptions of existing system features.
+>
+> **Path B Step 2: Generate Analyze Task Plan**
+> For EACH matched module, dispatch Worker with `speccrew-pm-module-initializer` skill.
+> This Worker will output a task plan JSON (list of features to analyze + analyzer parameters).
+>
+> **Agent Tool Invocation for Path B Step 2 (Module Initializer)**:
+> ```
+> Use the Agent tool to invoke speccrew-task-worker:
+> - agent: speccrew-task-worker
+> - task: Execute speccrew-pm-module-initializer skill for module "{module.module_name}" on platform "{module.platform_id}"
+> - context:
+>     skill: speccrew-pm-module-initializer
+>     source_path: {source_path}
+>     module_name: {module.module_name}
+>     platform_id: {module.platform_id}
+>     platform_type: {module.platform_type}
+>     platform_subtype: {module.platform_subtype}
+>     tech_stack: {module.tech_stack}
+>     features_file: {sync_state_bizs_dir}/features-{module.platform_id}.json
+>     output_path: {workspace_path}/knowledges
+>     completed_dir: {sync_state_bizs_dir}/completed
+>     sourceFile: features-{module.platform_id}.json
+>     language: {detected user language}
+>     workspace_path: {workspace_path}
+> ```
+>
+> Wait for ALL module-initializer Workers to complete. Collect all task plan JSON outputs.
+>
+> **Path B Step 3: Execute Feature Analysis**
+> Based on the task plans from Step 2, dispatch Worker for EACH pending feature.
+>
+> For backend features: dispatch Worker with `speccrew-knowledge-bizs-api-analyze` skill
+> For web/mobile/desktop features: dispatch Worker with `speccrew-knowledge-bizs-ui-analyze` skill
+>
+> **Agent Tool Invocation for each feature**:
+> ```
+> Use the Agent tool to invoke speccrew-task-worker:
+> - agent: speccrew-task-worker
+> - task: Execute {analyzer_skill} for feature "{fileName}"
+> - context:
+>     skill: {analyzer_skill}
+>     fileName: {task.fileName}
+>     sourcePath: {source_path}/{task.sourcePath}
+>     documentPath: {workspace_path}/{task.documentPath}
+>     module: {task.module}
+>     analyzed: false
+>     platform_type: {task.platform_type}
+>     platform_subtype: {task.platform_subtype}
+>     tech_stack: {task.tech_stack}
+>     language: {language}
+>     completed_dir: {sync_state_bizs_dir}/completed
+>     sourceFile: features-{platform_id}.json
+> ```
+>
+> Wait for ALL analyze Workers to complete.
+>
+> **Path B Step 4: Generate Module Summaries**
+> For each matched module, dispatch Worker with `speccrew-knowledge-module-summarize` skill:
+> ```
+> Use the Agent tool to invoke speccrew-task-worker:
+> - agent: speccrew-task-worker
+> - task: Execute speccrew-knowledge-module-summarize for module "{module_name}"
+> - context:
+>     skill: speccrew-knowledge-module-summarize
+>     module_name: {module_name}
+>     module_path: {workspace_path}/knowledges/bizs/{platform_id}/{module_name}
+>     language: {language}
+> ```
+>
+> **Path B Step 5: Update Features Status**
+> After all analyze Workers complete, update each analyzed feature's `analyzed` field to `true` in the corresponding features-*.json file.
+>
+> Only after ALL Steps complete, proceed to Phase 2 (Requirement Clarification).
+>
+> 🛑 **Path B Completion Check**:
+> Before proceeding to Phase 2, verify:
+> - [ ] Step 2 completed: task plan JSON generated for each matched module
+> - [ ] Step 3 completed: analyze Workers dispatched and completed for ALL pending features
+> - [ ] Step 4 completed: module-summarize Workers completed for ALL matched modules
+> - [ ] Step 5 completed: features-*.json updated with analyzed=true
+> 
+> If ANY step is incomplete, DO NOT proceed. Execute the missing steps first.
 
 4. **IF feature inventory fails**:
    - Report to user: "Project structure scan encountered issues: [specific error]. Continuing without knowledge base context."
@@ -475,6 +530,10 @@ This context will be passed to Phase 3 (Requirement Clarification) and Phase 4 (
 
 ## Phase 2: Complexity Assessment & Skill Routing
 
+> **PRE-CONDITION**: Path B Steps 2-5 must be completed before entering Phase 2.
+> If matched_modules exist but knowledges/bizs/ directories are empty, Path B was not fully executed.
+> Go back and execute the remaining Path B steps.
+
 Before starting requirement analysis, assess the requirement complexity to determine the appropriate skill path.
 
 ### 2.1 Complexity Indicators

package/.speccrew/agents/speccrew-system-designer.md

@@ -1,7 +1,7 @@
 ---
 name: speccrew-system-designer
 description: SpecCrew System Designer. Reads confirmed Feature Spec and API Contract documents, loads technology knowledge base (techs), evaluates framework needs, and dispatches per-platform detailed design skills to generate system design documents that add technology-specific implementation details to the feature specification skeleton. Supports web, mobile, and desktop platforms. Trigger scenarios: after Feature Spec and API Contract are confirmed, user requests system design.
-tools: Read, Write, Glob, Grep, Bash
+tools: Read, Write, Glob, Grep, Bash, Agent
 ---
 
 # Role Positioning

package/.speccrew/agents/speccrew-system-developer.md

@@ -1,7 +1,7 @@
 ---
 name: speccrew-system-developer
 description: SpecCrew System Developer. Reads system design blueprints and coordinates cross-platform development task dispatch. Loads techs knowledge, verifies environment readiness, dispatches per-platform dev skills, performs integration checks, and delivers development completion reports. Supports web, mobile, desktop, and backend platforms.
-tools: Read, Write, Glob, Grep, Bash
+tools: Read, Write, Glob, Grep, Bash, Agent
 ---
 
 # Quick Reference — Execution Flow

package/.speccrew/agents/speccrew-team-leader.md

@@ -1,7 +1,7 @@
 ---
 name: speccrew-team-leader
 description: SpecCrew team leader, entry-point scheduling Agent for AI engineering implementation. Identifies user intent and invokes corresponding Skill to execute. Trigger scenarios: project initialization, Agent optimization, Skill development, workflow diagnosis, knowledge base sync, AI collaboration system consultation. Business development requests (feature requirements, code modifications, bug fixes) are NOT within this Agent's scope. Use proactively when users mention AI engineering workflows, agent configuration, or project infrastructure.
-tools: Read, Write, Glob, Grep, Bash
+tools: Read, Write, Glob, Grep, Bash, Agent
 ---
 
 # Quick Reference — Execution Flow

package/.speccrew/agents/speccrew-test-manager.md

@@ -1,7 +1,7 @@
 ---
 name: speccrew-test-manager
 description: SpecCrew Test Manager. Orchestrates three-phase testing workflow: test case design, test code generation, and test execution with bug reporting. Reads feature specs, API contracts, and system design documents to coordinate comprehensive system testing. Trigger scenarios: after development phase completes, user requests to start testing.
-tools: Read, Write, Glob, Grep, Bash
+tools: Read, Write, Glob, Grep, Bash, Agent
 ---
 
 # Role Positioning

package/.speccrew/skills/speccrew-knowledge-bizs-dispatch/SKILL.md

@@ -19,17 +19,17 @@ Stage 1: Feature Inventory Init
   └─ 1b: Merge features
   └─ 1c: Validate inventory
         ↓
-Stage 2: Feature Analysis (PARALLEL)
-  └─ Dispatch api-analyze + ui-analyze workers per platform
-  └─ After each analyze worker completes → dispatch corresponding graph worker
+Stage 2: Feature Analysis (Task Preparation)
+  └─ Prepare api-analyze + ui-analyze task specifications per platform
+  └─ After analyze completes → prepare corresponding graph worker task specification
   └─ Monitor completion markers
         ↓
-Stage 3: Module Summarize (PARALLEL)
-  └─ 3.0: module-summarize per module
-  └─ 3.5: UI style extraction
+Stage 3: Module Summarize (Task Preparation)
+  └─ 3.0: Prepare module-summarize task specifications per module
+  └─ 3.5: Prepare UI style extraction task specifications
         ↓
-Stage 4: System Summary
-  └─ system-summarize → system-overview.md
+Stage 4: System Summary (Task Preparation)
+  └─ Prepare system-summarize task specification
 ```
 
 ## Language Adaptation
@@ -102,19 +102,19 @@ STAGE 1: Feature Inventory
 STAGE 2: Feature Analysis (REPEAT until all features processed)
   Step 0: Ensure completed_dir exists
   Step 1: Get next batch of pending features
-  Step 2: Launch parallel Workers (API or UI analysis)
+  Step 2: Prepare analysis task specifications (API or UI analysis)
   Step 3: Process batch results, update features.json, write graph
 
-STAGE 3: Module Summarize (parallel per module)
+STAGE 3: Module Summarize (task preparation per module)
   FOR each module:
-    Launch Worker with module-summarize skill
+    Prepare module-summarize task specification
 
-STAGE 3.5: UI Style Pattern Extract (parallel per frontend platform)
+STAGE 3.5: UI Style Pattern Extract (task preparation per frontend platform)
   FOR each frontend platform:
-    Launch Worker with ui-style-extract skill
+    Prepare ui-style-extract task specification
 
-STAGE 4: System Summary
-  Launch Worker with system-summarize skill
+STAGE 4: System Summary (task preparation)
+  Prepare system-summarize task specification
 
 OUTPUT: system-overview.md, graph data, module overviews
 ```
@@ -343,9 +343,9 @@ flowchart TB
 
 ## Stage 2: Feature Analysis (Batch Processing)
 
-**Overview**: Process all pending features in batches. Each batch gets a set of features, launches Worker Agents to analyze them, then processes the results.
+**Overview**: Process all pending features in batches. Each batch gets a set of features, prepares task specifications for Worker Agents to analyze them, then processes the results.
 
-> **Script execution rule**: All script calls in Stage 2 are executed **directly by the dispatch agent** via `run_in_terminal`. Only the analysis tasks are delegated to Worker Agents.
+> **Script execution rule**: All script calls in Stage 2 are executed **directly by the dispatch agent** via `run_in_terminal`. Task specifications are prepared by this Skill; Worker dispatch is handled by the calling Agent (Team Leader).
 
 **Skill Routing Table (by platformType):**
 
@@ -364,7 +364,7 @@ Repeat the following 3 steps until all features are processed:
 
 **Step 0: Ensure completed directory exists (MANDATORY)**
 
-Before launching any Workers, you MUST create the `completed_dir` directory using Node.js (cross-platform compatible):
+Before any Workers are dispatched by the calling Agent, you MUST ensure the `completed_dir` directory exists using Node.js (cross-platform compatible):
 
 ```bash
 node -e "require('fs').mkdirSync('{completed_dir}', {recursive: true}); console.log('completed dir ready')"
@@ -386,31 +386,35 @@ node -e "require('fs').mkdirSync('{completed_dir}', {recursive: true}); console.
 - If output `action` is `"done"` → All features processed. Exit Stage 2, proceed to Stage 3.
 - If output `action` is `"process"` → The `batch` array contains features to analyze. Proceed to Step 2.
 
-**Step 2: Launch Workers — MUST BE PARALLEL**
+**Step 2: Prepare Analysis Task Specifications**
 
-⚠️ **CRITICAL**: You MUST launch ALL features in the current batch SIMULTANEOUSLY as parallel Worker Tasks. **FORBIDDEN**: sequential launch (start one Worker, wait, then start next).
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
-For each feature in the `batch` array, prepare a Worker Task:
+For each feature in the `batch` array, prepare a task specification:
 - **Select skill** using the routing table at Stage 2 start
-- **Worker parameters**: Pass all feature fields plus `language`, `completed_dir`, `sourceFile`, `skill_path`
-- **Behavior constraint**: Worker MUST NOT create any temporary scripts. If execution fails, STOP and report error.
+- **Task parameters**: Prepare all feature fields plus `language`, `completed_dir`, `sourceFile`, `skill_path`
+- **Behavior constraint**: Workers MUST NOT create any temporary scripts
 
-**Execution sequence**:
-1. Prepare ALL Worker Tasks first (do NOT launch yet)
-2. Launch ALL Workers at the SAME TIME in a single batch dispatch
-3. Wait for ALL Workers to complete before proceeding to Step 2.5
+**Task Preparation sequence**:
+1. Prepare ALL task specifications for the current batch
+2. Output the task specifications to the calling Agent
+3. The calling Agent will dispatch Workers based on these specifications
 4. Each Worker writes `.done` and `.graph.json` marker files to `completed_dir` upon completion
 
-**Step 2.5: Launch Graph Workers — PARALLEL per Completed Analyze Worker**
+> **NOTE**: This Skill does NOT dispatch analyze workers. The calling Agent (Team Leader) dispatches workers based on the prepared task specifications.
 
-After each analyze worker completes (writes `.done.json` marker), immediately dispatch the corresponding graph worker:
+**Step 2.5: Graph Worker Task Preparation**
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
+
+After each analyze worker completes (writes `.done.json` marker), the calling Agent will dispatch the corresponding graph worker. This Skill prepares the task specifications:
 
 | Analyze Worker | Graph Worker | Input |
 |----------------|--------------|-------|
 | `speccrew-knowledge-bizs-api-analyze` | `speccrew-knowledge-bizs-api-graph` | `documentPath` from analyze output |
 | `speccrew-knowledge-bizs-ui-analyze` | `speccrew-knowledge-bizs-ui-graph` | `documentPath` from analyze output |
 
-**Graph Worker Task Prompt Format**:
+**Graph Worker Task Specification Format**:
 
 **For API Graph Worker**:
 ```json
@@ -457,14 +461,14 @@ After each analyze worker completes (writes `.done.json` marker), immediately di
 }
 ```
 
-**Execution sequence**:
+**Task Preparation Sequence**:
 1. Scan `completed_dir` for new `.done.json` files from Step 2
-2. For each completed analyze worker, prepare corresponding graph worker task
-3. Launch ALL graph workers for the current batch in PARALLEL
-4. Wait for ALL graph workers to complete
-5. Each graph worker writes `.graph-done.json` marker to `completed_dir`
+2. For each completed analyze worker, prepare corresponding graph worker task specification
+3. Output the task specifications to the calling Agent
+4. The calling Agent will dispatch graph workers based on these specifications
+5. Each graph worker writes `.graph-done.json` marker to `completed_dir` upon completion
 
-Example: If batch has 5 features → create and launch 5 Worker Tasks simultaneously, NOT one by one.
+> **NOTE**: This Skill does NOT dispatch graph workers. The calling Agent (Team Leader) scans for `.done.json` markers and dispatches corresponding graph workers.
 
 **Worker Task Prompt Format**:
 
@@ -699,7 +703,7 @@ Dispatch 采用完全无状态的文件驱动设计。如果执行过程中发
 When dealing with modules containing more than **20 features**, consider the following:
 
 - **Single Agent Limit**: A single Worker Agent can reliably process ~20 features per session due to context window constraints. Beyond this, context degradation may cause incomplete document generation.
-- **Multi-Worker Strategy**: For modules with >20 features, dispatch multiple Worker Agents in parallel, each handling a non-overlapping subset of features (e.g., by batch index range).
+- **Multi-Worker Strategy**: For modules with >20 features, the calling Agent should dispatch multiple Worker Agents in parallel, each handling a non-overlapping subset of features (e.g., by batch index range).
 - **Resume Support**: The `get-next-batch` script naturally supports resume across sessions — it skips features that already have `.done` files. To resume after a session break, simply restart the Stage 2 loop.
 - **Validation After Completion**: After all features are marked `analyzed=true`, run `process-batch-results` with `--validateDocs --syncStatePath "{sync_state_path}"` to verify document completeness.
 
@@ -707,49 +711,53 @@ When dealing with modules containing more than **20 features**, consider the fol
 
 ---
 
-## Stage 3: Module Summarize (Parallel)
+## Stage 3: Module Summarize (Task Preparation)
 
-**Goal**: Complete each module overview based on feature details.
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
+
+**Goal**: Prepare task specifications for each module overview based on feature details.
 
 **Prerequisite**: Stage 2 completed for the module (in full or incremental mode).
 
 **Action (full mode)**:
 - Read all `features-{platform}.json` files from `{sync_state_bizs_dir}/`
 - For each platform, group features by `module` to identify unique modules
-- For each module, invoke 1 Worker Agent (`speccrew-task-worker.md`) with `skill_name: speccrew-knowledge-module-summarize`
-- Parameters to pass to skill:
+- For each module, prepare a task specification for `skill_name: speccrew-knowledge-module-summarize`
+- Parameters to include in task specification:
   - `module_name`: Module code_name
   - `module_path`: Path to module directory (e.g., `{workspace_path}/knowledges/bizs/{platform_id}/{module_name}/`)
   - `workspace_path`: Absolute path to speccrew-workspace directory — **REQUIRED**
   - `sync_state_bizs_dir`: Absolute path to sync-state/knowledge-bizs directory — **REQUIRED**
   - `language`: User's language — **REQUIRED**
-  - **Behavior constraint**: Worker MUST NOT create any temporary scripts or workaround files. If execution fails, STOP and report error immediately.
-
-Expected Worker Return: `{ "status": "success|failed", "module_name": "...", "output_file": "...-overview.md", "message": "..." }`
+  - **Behavior constraint**: Workers MUST NOT create any temporary scripts or workaround files
 
 **Action (incremental mode)**:
 - Reuse module status from Stage 2 (NEW / CHANGED / DELETED / UNMODIFIED).
-- Only dispatch Workers for modules with status **NEW** or **CHANGED**.
+- Only prepare task specifications for modules with status **NEW** or **CHANGED**.
 
-**Parallel Tasks** (grouped by platform):
+**Task Specifications** (grouped by platform):
 ```
 Platform: Web Frontend (web)
-  Worker 1: module="order",   module_path="speccrew-workspace/knowledges/bizs/web/order/"
-  Worker 2: module="payment", module_path="speccrew-workspace/knowledges/bizs/web/payment/"
+  Task 1: module="order",   module_path="speccrew-workspace/knowledges/bizs/web/order/"
+  Task 2: module="payment", module_path="speccrew-workspace/knowledges/bizs/web/payment/"
 
 Platform: Mobile App (mobile-flutter)
-  Worker 3: module="order",   module_path="speccrew-workspace/knowledges/bizs/mobile-flutter/order/"
-  Worker 4: module="payment", module_path="speccrew-workspace/knowledges/bizs/mobile-flutter/payment/"
+  Task 3: module="order",   module_path="speccrew-workspace/knowledges/bizs/mobile-flutter/order/"
+  Task 4: module="payment", module_path="speccrew-workspace/knowledges/bizs/mobile-flutter/payment/"
 ```
 
+> **NOTE**: This Skill does NOT dispatch module summarize workers. The calling Agent (Team Leader) dispatches workers based on the prepared task specifications.
+
 **Output per Module**:
 - `{{module_name}}-overview.md` (complete version)
 
 ---
 
-## Stage 3.5: UI Style Pattern Extract (Parallel by Platform)
+## Stage 3.5: UI Style Pattern Extract (Task Preparation)
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
-**Goal**: Extract UI design patterns (page types, component patterns, layout patterns) from analyzed feature documents, aggregating cross-module patterns and outputting to the techs knowledge base `ui-style-patterns/` directory.
+**Goal**: Prepare task specifications for extracting UI design patterns (page types, component patterns, layout patterns) from analyzed feature documents.
 
 **Prerequisite**: All Stage 3 tasks completed.
 
@@ -761,8 +769,8 @@ Platform: Mobile App (mobile-flutter)
 - Read all `features-{platform}.json` files from `{sync_state_bizs_dir}/`
 - Filter platforms where platformType is web/mobile/desktop
 - Determine platform_id (format: `{platformType}-{platformSubtype}`, e.g., `web-vue`, `mobile-uniapp`, `backend-system`)
-- For each qualifying platform, launch 1 Worker Agent (`speccrew-task-worker`) with `skill_name: speccrew-knowledge-bizs-ui-style-extract`
-- Parameters to pass:
+- For each qualifying platform, prepare a task specification for `skill_name: speccrew-knowledge-bizs-ui-style-extract`
+- Parameters to include in task specification:
   - `platform_id`: Platform identifier
   - `platform_type`: Platform type
   - `feature_docs_path`: Feature document base path for that platform (e.g., `{workspace_path}/knowledges/bizs/{platform_id}`)
@@ -772,7 +780,7 @@ Platform: Mobile App (mobile-flutter)
   - `workspace_path`: Absolute path to speccrew-workspace directory — **REQUIRED**
   - `sync_state_bizs_dir`: Absolute path to sync-state/knowledge-bizs directory — **REQUIRED**
   - `language`: User's language
-  - **Behavior constraint**: Worker MUST NOT create any temporary scripts or workaround files. If execution fails, STOP and report error immediately.
+  - **Behavior constraint**: Workers MUST NOT create any temporary scripts or workaround files
 
 **Cross-Pipeline Output**:
 - This stage writes to techs knowledge base, not bizs knowledge base
@@ -780,7 +788,9 @@ Platform: Mobile App (mobile-flutter)
 - Subdirectories: `page-types/`, `components/`, `layouts/`
 - `ui-style-guide.md` and `styles/` are managed by techs pipeline, this stage does not modify them
 
-**Parallel Tasks**: One Worker per frontend platform, can execute in parallel.
+**Task Specifications**: One task specification per frontend platform.
+
+> **NOTE**: This Skill does NOT dispatch UI style extract workers. The calling Agent (Team Leader) dispatches workers based on the prepared task specifications.
 
 **Output per Platform**:
 ```
@@ -797,24 +807,26 @@ Platform: Mobile App (mobile-flutter)
 
 ---
 
-## Stage 4: System Summarize (Single Task)
+## Stage 4: System Summarize (Task Preparation)
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
-**Goal**: Generate complete system-overview.md aggregating all platforms and modules.
+**Goal**: Prepare task specification for generating complete system-overview.md aggregating all platforms and modules.
 
 **Prerequisite**: All Stage 3 tasks completed.
 
 **Action**:
 - Read all `features-{platform}.json` files from `{sync_state_bizs_dir}/` to get platform structure
-- Invoke 1 Worker Agent (`speccrew-task-worker.md`) with `skill_name: speccrew-knowledge-system-summarize`
-- Parameters to pass to skill:
+- Prepare a task specification for `skill_name: speccrew-knowledge-system-summarize`
+- Parameters to include in task specification:
   - `modules_path`: Path to knowledge base directory containing all platform modules (e.g., `{workspace_path}/knowledges/bizs/`)
   - `output_path`: Output path for system-overview.md (e.g., `{workspace_path}/knowledges/bizs/`)
   - `workspace_path`: Absolute path to speccrew-workspace directory — **REQUIRED**
   - `sync_state_bizs_dir`: Absolute path to sync-state/knowledge-bizs directory — **REQUIRED**
   - `language`: User's language — **REQUIRED**
-  - **Behavior constraint**: Worker MUST NOT create any temporary scripts or workaround files. If execution fails, STOP and report error immediately.
+  - **Behavior constraint**: Workers MUST NOT create any temporary scripts or workaround files
 
-Expected Worker Return: `{ "status": "success|failed", "output_file": "system-overview.md", "message": "..." }`
+> **NOTE**: This Skill does NOT dispatch system summarize workers. The calling Agent (Team Leader) dispatches workers based on the prepared task specification.
 
 **Output**:
 - `{workspace_path}/knowledges/bizs/system-overview.md` (complete with platform index and module hierarchy)

package/.speccrew/skills/speccrew-knowledge-bizs-init-features/SKILL.md

@@ -62,7 +62,9 @@ For each platform detected in Step 1, identify business module entry directories
 
 **Option A: Invoke Skill (Recommended)**
 
-Dispatch Worker with `speccrew-knowledge-bizs-identify-entries` skill:
+Execute `speccrew-knowledge-bizs-identify-entries` skill with the following parameters:
+
+> **NOTE**: Worker dispatch is handled by the calling Agent. This Skill only specifies the parameters needed.
 
 | Parameter | Value |
 |-----------|-------|
@@ -71,7 +73,7 @@ Dispatch Worker with `speccrew-knowledge-bizs-identify-entries` skill:
 | `sync_state_bizs_dir` | `{sync_state_bizs_dir}` |
 | `configs_dir` | `{configs_dir}` |
 
-Worker generates `entry-dirs-{platform_id}.json` files in `{sync_state_bizs_dir}/`.
+Expected output: `entry-dirs-{platform_id}.json` files in `{sync_state_bizs_dir}/`.
 
 **Option B: Direct Execution**
 

package/.speccrew/skills/speccrew-knowledge-techs-dispatch/SKILL.md

@@ -59,20 +59,22 @@ Stage 1: Platform Detection
   └─ Read techs-manifest.json → Identify platforms & tech stacks
         ↓
 Stage 2: Tech Doc Generation (PARALLEL)
-  └─ Dispatch techs-generate workers per platform
-  └─ After each generate worker completes → dispatch quality check worker
+  └─ Prepare task plans for techs-generate workers per platform
+  └─ After generate workers complete → prepare quality check worker task plans
   └─ Monitor completion markers
         ↓
 Stage 2.5: Completion Verification
   └─ Step A: Scan completion markers
   └─ Step B: Verify output integrity
-  └─ Step C: Update dispatch progress
+  └─ Step C: Update progress status
         ↓
 Stage 3: Root Index Generation
   └─ Generate techs/README.md root index
   └─ Cross-platform consistency check
 ```
 
+> **NOTE**: All worker dispatch operations are handled by the calling Agent (Team Leader). This Skill only prepares task plans and monitors completion markers.
+
 ## Workflow Overview
 
 ```mermaid
@@ -90,10 +92,14 @@ flowchart TB
 **Step 1a: Read Configuration**
 - Read `speccrew-workspace/docs/configs/platform-mapping.json` for standardized platform mapping rules
 
-**Step 1b: Invoke Worker**
-- Invoke 1 Worker Agent (`speccrew-task-worker.md`) with skill `speccrew-knowledge-techs-init/SKILL.md`
-- Task: Analyze project structure, detect technology platforms
-- Parameters to pass to skill:
+**Step 1b: Prepare Task Plan**
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
+
+Prepare the following task for the calling Agent to dispatch:
+- **Skill**: `speccrew-knowledge-techs-init/SKILL.md`
+- **Task**: Analyze project structure, detect technology platforms
+- **Parameters**:
   - `source_path`: Source code directory path
   - `output_path`: Output directory (default: `speccrew-workspace/knowledges/base/sync-state/knowledge-techs/`)
   - `language`: User's language — **REQUIRED**
@@ -108,11 +114,13 @@ See [Platform Status Tracking Fields](#platform-status-tracking-fields) for stat
 ---
 
 > **⚠️ MANDATORY RULES FOR PARALLEL EXECUTION (Stage 2)**:
-> 1. ALL platform workers MUST be dispatched in PARALLEL — sequential execution is FORBIDDEN
+> 1. ALL platform task plans should be prepared for parallel dispatch by the calling Agent — sequential execution is NOT recommended
 > 2. Each platform worker runs independently via techs-generate Skill
 > 3. Monitor completion via marker files in each platform directory
 > 4. Failed workers can be retried independently
 > 5. Do NOT proceed to Stage 2.5 until ALL workers have completed or failed
+>
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares task plans.
 
 ## Stage 2: Generate Platform Documents (Parallel)
 
@@ -120,21 +128,27 @@ See [Platform Status Tracking Fields](#platform-status-tracking-fields) for stat
 
 **Action**:
 - Read `speccrew-workspace/knowledges/base/sync-state/knowledge-techs/techs-manifest.json`
-- For each platform in `platforms` array, invoke 2 Worker Agents in PARALLEL:
-  - Worker 1: `speccrew-knowledge-techs-generate-conventions/SKILL.md` (ALL platforms)
-  - Worker 2: `speccrew-knowledge-techs-generate-ui-style/SKILL.md` (frontend platforms ONLY: web, mobile, desktop)
-- Parameters to pass to each skill:
-  - `platform_id`: Platform identifier from manifest
-  - `platform_type`: Platform type (web, mobile, backend, desktop)
-  - `framework`: Primary framework
-  - `source_path`: Platform source directory
-  - `config_files`: List of configuration file paths (conventions worker only)
-  - `convention_files`: List of convention file paths (conventions worker only)
-  - `output_path`: Output directory for platform docs (e.g., `speccrew-workspace/knowledges/techs/{platform_id}/`)
-  - `completed_dir`: Directory for Worker output markers (e.g., `speccrew-workspace/knowledges/techs/.sync-status/`)
-  - `language`: User's language — **REQUIRED**
 
-When launching each platform Worker, the Workers will output:
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
+
+**Prepare Task Plans for Each Platform**:
+
+For each platform in `platforms` array, prepare tasks for parallel execution:
+- **Task 1**: `speccrew-knowledge-techs-generate-conventions/SKILL.md` (ALL platforms)
+- **Task 2**: `speccrew-knowledge-techs-generate-ui-style/SKILL.md` (frontend platforms ONLY: web, mobile, desktop)
+
+**Parameters for each skill**:
+- `platform_id`: Platform identifier from manifest
+- `platform_type`: Platform type (web, mobile, backend, desktop)
+- `framework`: Primary framework
+- `source_path`: Platform source directory
+- `config_files`: List of configuration file paths (conventions worker only)
+- `convention_files`: List of convention file paths (conventions worker only)
+- `output_path`: Output directory for platform docs (e.g., `speccrew-workspace/knowledges/techs/{platform_id}/`)
+- `completed_dir`: Directory for Worker output markers (e.g., `speccrew-workspace/knowledges/techs/.sync-status/`)
+- `language`: User's language — **REQUIRED**
+
+**Expected Worker Output Markers**:
 - `{completed_dir}/{platform_id}.done-conventions.json` — conventions worker completion marker
 - `{completed_dir}/{platform_id}.done-ui-style.json` — ui-style worker completion marker (frontend only)
 - `{completed_dir}/{platform_id}.analysis-conventions.json` — conventions coverage report
@@ -150,9 +164,11 @@ When launching each platform Worker, the Workers will output:
    - IF platform.platform_type IN ["web", "mobile", "desktop"]: SET `platform.workers.ui_style.status = "processing"`
    - WRITE manifest to techs-manifest.json
 
-**Step 2b: Launch Conventions Worker (ALL Platforms)**
+**Step 2b: Prepare Conventions Worker Task Plans (ALL Platforms)**
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
-For each platform, invoke `speccrew-task-worker` with:
+For each platform, prepare a task with:
 - skill_path: `speccrew-knowledge-techs-generate-conventions/SKILL.md`
 - context:
   - platform_id: platform.platform_id
@@ -165,10 +181,12 @@ For each platform, invoke `speccrew-task-worker` with:
   - completed_dir: completed_dir
   - language: language
 
-**Step 2c: Launch UI-Style Worker (Frontend Platforms ONLY)**
+**Step 2c: Prepare UI-Style Worker Task Plans (Frontend Platforms ONLY)**
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
 IF platform.platform_type IN ["web", "mobile", "desktop"]:
-1. Invoke `speccrew-task-worker` with:
+1. Prepare a task with:
    - skill_path: `speccrew-knowledge-techs-generate-ui-style/SKILL.md`
    - context:
      - platform_id: platform.platform_id
@@ -179,13 +197,20 @@ IF platform.platform_type IN ["web", "mobile", "desktop"]:
      - completed_dir: completed_dir
      - language: language
 
-**Step 2d: Wait for All Workers**
-- WAIT_ALL workers complete
+**Step 2d: Completion Marker Monitoring**
+
+> **NOTE**: Worker dispatch and wait operations are handled by the calling Agent (Team Leader). This Skill only monitors completion markers.
+
+The calling Agent should:
+- Monitor for `{platform_id}.done-conventions.json` markers
+- Monitor for `{platform_id}.done-ui-style.json` markers (frontend platforms)
 - Both workers run in PARALLEL for the same platform
 
-**Step 2e: Launch Quality Check Workers — PARALLEL per Completed Generate Worker**
+**Step 2e: Prepare Quality Check Worker Task Plans**
+
+> **NOTE**: Quality worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
 
-After each `speccrew-knowledge-techs-generate` worker completes (writes `.done-conventions.json` marker), immediately dispatch the corresponding quality check worker:
+After each `speccrew-knowledge-techs-generate` worker completes (writes `.done-conventions.json` or `.done-ui-style.json` marker), the calling Agent should dispatch the corresponding quality check worker.
 
 | Generate Worker | Quality Worker | Input |
 |-----------------|----------------|-------|
@@ -206,12 +231,25 @@ After each `speccrew-knowledge-techs-generate` worker completes (writes `.done-c
 }
 ```
 
-**Execution sequence**:
-1. Scan `completed_dir` for new `.done-conventions.json` and `.done-ui-style.json` files
-2. For each completed generate worker, prepare corresponding quality worker task
-3. Launch ALL quality workers for the current batch in PARALLEL
-4. Wait for ALL quality workers to complete
-5. Each quality worker writes `.quality-done.json` marker to `completed_dir`
+**Quality Worker Completion Marker**:
+
+Each quality worker writes a `.quality-done.json` marker to `completed_dir` upon completion:
+
+```json
+{
+  "platform_id": "web-vue",
+  "worker_type": "quality",
+  "status": "completed",
+  "quality_score": 85,
+  "issues_found": 2,
+  "completed_at": "2024-01-15T11:00:00Z"
+}
+```
+
+**Expected Completion Markers after Stage 2**:
+1. `{platform_id}.done-conventions.json` — conventions worker marker
+2. `{platform_id}.done-ui-style.json` — ui-style worker marker (frontend only)
+3. `{platform_id}.quality-done.json` — quality worker marker
 
 > **Stage 2 Completion Condition**: ALL generate workers AND ALL quality check workers completed (`.done-*.json` and `.quality-done.json` markers present) before proceeding to Stage 2.5
 
@@ -585,8 +623,12 @@ Write to `speccrew-workspace/knowledges/base/sync-state/knowledge-techs/stage2-s
 
 **Action**:
 - Read `speccrew-workspace/knowledges/base/sync-state/knowledge-techs/techs-manifest.json`
-- Invoke 1 Worker Agent (`speccrew-task-worker.md`) with skill `speccrew-knowledge-techs-index/SKILL.md`
-- Parameters to pass to skill:
+
+> **NOTE**: Worker dispatch is handled by the calling Agent (Team Leader). This Skill only prepares the task plan and parameters.
+
+**Prepare Task Plan**:
+- **Skill**: `speccrew-knowledge-techs-index/SKILL.md`
+- **Parameters**:
   - `manifest_path`: Path to techs-manifest.json
   - `techs_base_path`: Base path for techs documentation (e.g., `speccrew-workspace/knowledges/techs/`)
   - `output_path`: Output path for root INDEX.md (e.g., `speccrew-workspace/knowledges/techs/`)
@@ -638,17 +680,19 @@ THRESHOLD: warnings > 5 → flag for manual review
 
 ## Execution Flow
 
+> **NOTE**: All worker dispatch and wait operations are handled by the calling Agent (Team Leader). This Skill only prepares task plans and monitors completion markers.
+
 ```
 1. Run Stage 1 (Platform Detection)
-   └─ Wait for completion
+   └─ Prepare task plan → Monitor completion
 
 2. Run Stage 2 (Tech Doc Generation)
    ├─ Read techs-manifest.json
-   ├─ Launch ALL platform Workers in parallel
-   └─ Wait for ALL Workers → generate stage2-status.json
+   ├─ Prepare ALL platform task plans for parallel dispatch
+   └─ Monitor completion markers → generate stage2-status.json
 
 3. Run Stage 3 (Root Index)
-   └─ Wait for completion → generate stage3-status.json
+   └─ Prepare task plan → Monitor completion → generate stage3-status.json
 ```
 
 ---

package/.speccrew/skills/speccrew-pm-module-initializer/SKILL.md

@@ -1,15 +1,14 @@
 ---
 name: speccrew-pm-module-initializer
-description: Initialize knowledge base for a single business module by analyzing its features. Dispatches api-analyze or ui-analyze based on platform type, then generates module summary. Used by Worker Agent, invoked by PM Agent for on-demand module initialization.
+description: Generate analyze task plan for a single business module. Reads features-*.json, filters matched module's pending features, and outputs a task plan JSON (list of features to analyze with analyzer parameters). Used by Worker Agent, invoked by PM Agent for on-demand module task planning.
 tools: Read, Write, Skill, Bash
 ---
 
-# Module Initializer
+# Module Initializer (Task Plan Generator)
 
-Initialize knowledge base for a single business module by analyzing its features. Dispatches api-analyze or ui-analyze based on platform type, then generates module summary. Used by Worker Agent, invoked by PM Agent for on-demand module initialization.
+Generate analyze task plan for a single business module. Reads features-*.json, filters matched module's pending features, and outputs a task plan JSON (list of features to analyze with analyzer parameters). Used by Worker Agent, invoked by PM Agent for on-demand module task planning.
 
-> **Positioning**: Lightweight knowledge base initializer for PM phase, processes only modules matched by PM matcher.
-> Difference from bizs-dispatch: module-initializer processes single modules on-demand, does not generate graph data, output is for PRD authoring reference only.
+> **Positioning**: Task plan generator for PM phase. Generates task list for PM Agent to orchestrate. Does NOT execute analyze or summarize directly — PM Agent handles Worker dispatch based on task plan output.
 
 ## Language Adaptation
 
@@ -23,10 +22,9 @@ Initialize knowledge base for a single business module by analyzing its features
 
 ## Trigger Scenarios
 
-- "Initialize module {name}"
-- "Deep analyze module {name}"
-- "Generate knowledge for module {name}"
-- "Start module analysis"
+- "Generate task plan for module {name}"
+- "Plan module {name} initialization"
+- "List pending features for module {name}"
 
 ## Input
 
@@ -34,7 +32,7 @@ Initialize knowledge base for a single business module by analyzing its features
 |-----------|------|----------|-------------|
 | `source_path` | string | Yes | Project source code root path |
 | `module_name` | string | Yes | Module name |
-| `platform_id` | string | Yes | Platform ID (e.g., "web-vue3", "admin-api") |
+| `platform_id` | string | Yes | Platform ID (e.g., "web-vue", "admin-api") |
 | `platform_type` | string | Yes | web / mobile / backend / desktop |
 | `platform_subtype` | string | No | Platform subtype (e.g., "vue", "spring-boot") |
 | `tech_stack` | array | No | Platform tech stack (e.g., ["java", "spring-boot"]) |
@@ -43,29 +41,47 @@ Initialize knowledge base for a single business module by analyzing its features
 | `completed_dir` | string | Yes | Marker file output directory for api-analyze .done.json markers. Value from PM Agent: `{sync_state_bizs_dir}/completed` |
 | `sourceFile` | string | Yes | Features JSON filename (e.g., "features-backend-system.json"), used for api-analyze marking |
 | `language` | string | Yes | Output language (zh / en) |
+| `workspace_path` | string | Yes | Workspace root path for constructing absolute paths |
 
 ## Output JSON
 
 ```json
 {
-  "status": "success | partial | failed",
   "module_name": "system",
-  "platform_id": "web-vue3",
-  "features_analyzed": 12,
-  "features_failed": 0,
-  "output_dir": "speccrew-workspace/knowledges/bizs/web-vue3/system/",
-  "overview_file": "system-overview.md",
-  "errors": []
+  "platform_id": "web-vue",
+  "analyzer_skill": "speccrew-knowledge-bizs-ui-analyze",
+  "tasks": [
+    {
+      "fileName": "index",
+      "sourcePath": "src/views/system/user/index.vue",
+      "documentPath": "knowledges/bizs/web-vue/system/features",
+      "module": "system",
+      "platform_type": "web",
+      "platform_subtype": "vue",
+      "tech_stack": ["vue", "typescript"],
+      "language": "zh"
+    }
+  ],
+  "total_pending": 90,
+  "summarize_params": {
+    "skill": "speccrew-knowledge-module-summarize",
+    "module_name": "system",
+    "module_path": "knowledges/bizs/web-vue/system",
+    "language": "zh"
+  }
 }
 ```
 
-**Status Definitions**:
+**Field Definitions**:
 
-| Status | Condition |
-|--------|-----------|
-| `success` | All features analyzed successfully, overview generated |
-| `partial` | Some features analyzed or overview generated with warnings |
-| `failed` | No features analyzed or critical error occurred |
+| Field | Description |
+|-------|-------------|
+| `module_name` | Module being processed |
+| `platform_id` | Platform identifier |
+| `analyzer_skill` | Selected analyzer skill name |
+| `tasks` | Array of pending features to analyze |
+| `total_pending` | Count of pending features |
+| `summarize_params` | Parameters for module-summarize skill (to be executed after all analyze tasks complete) |
 
 ## Workflow
 
@@ -73,9 +89,9 @@ Initialize knowledge base for a single business module by analyzing its features
 flowchart TD
     Start([Start]) --> Step1[Step 1: Read and filter features]
     Step1 --> Step2[Step 2: Select analyzer by platform_type]
-    Step2 --> Step3[Step 3: Analyze each pending feature]
-    Step3 --> Step4[Step 4: Generate module summary]
-    Step4 --> Step5[Step 5: Return result]
+    Step2 --> Step3[Step 3: Build task list]
+    Step3 --> Step4[Step 4: Build summarize params]
+    Step4 --> Step5[Step 5: Output task plan JSON]
     Step5 --> End([End])
 ```
 
@@ -88,7 +104,6 @@ flowchart TD
 3. **Record counts**:
    - Total features for this module
    - Pending features (analyzed = false)
-   - If no pending features found, skip to Step 4 (still generate/update module summary)
 
 **Output**: "Step 1 Status: ✅ COMPLETED - Found {total} total features, {pending} pending for analysis"
 
@@ -105,121 +120,74 @@ Based on `platform_type`, select the appropriate analyzer Skill:
 
 **Output**: "Step 2 Status: ✅ COMPLETED - Selected analyzer: {skill_name}"
 
-### Step 3: Analyze Each Pending Feature (Sequential)
+### Step 3: Build Task List
 
 **Step 3 Status: 🔄 IN PROGRESS**
 
-For each pending feature from Step 1, call the appropriate analyzer skill.
+For each pending feature from Step 1, build a task object with analyzer parameters.
 
-> 🛑 **FORBIDDEN**: DO NOT write custom scripts. You MUST call the analyzer skill directly using the Agent tool or execute it as defined in the skill's SKILL.md.
+> 🛑 **IMPORTANT**: This Skill does NOT execute analyze. It ONLY generates the task list. PM Agent will dispatch Workers based on this task plan.
 
-#### For backend modules (api-analyze):
+#### Task object structure for each pending feature:
 
-For each pending feature, invoke the `speccrew-knowledge-bizs-api-analyze` skill with these parameters:
-
-```
-Use Agent tool to invoke speccrew-task-worker:
-- agent: speccrew-task-worker  
-- task: Execute speccrew-knowledge-bizs-api-analyze skill
-- context:
-    skill: speccrew-knowledge-bizs-api-analyze
-    fileName: {feature.fileName}
-    sourcePath: {source_path}/{feature.sourcePath}
-    documentPath: {output_path}/bizs/{platform_id}/{feature.module}/features
-    module: {feature.module}
-    analyzed: false
-    platform_type: backend
-    platform_subtype: {platform_subtype}
-    tech_stack: {tech_stack}
-    language: {language}
-    completed_dir: {completed_dir}
-    sourceFile: {sourceFile}
+```json
+{
+  "fileName": "{feature.fileName}",
+  "sourcePath": "{feature.sourcePath}",
+  "documentPath": "{output_path}/bizs/{platform_id}/{feature.module}/features",
+  "module": "{feature.module}",
+  "platform_type": "{platform_type}",
+  "platform_subtype": "{platform_subtype}",
+  "tech_stack": "{tech_stack}",
+  "language": "{language}"
+}
 ```
 
-#### For web/mobile/desktop modules (ui-analyze):
-
-For each pending feature, invoke the `speccrew-knowledge-bizs-ui-analyze` skill with these parameters:
-
-```
-Use Agent tool to invoke speccrew-task-worker:
-- agent: speccrew-task-worker
-- task: Execute speccrew-knowledge-bizs-ui-analyze skill  
-- context:
-    skill: speccrew-knowledge-bizs-ui-analyze
-    fileName: {feature.fileName}
-    sourcePath: {source_path}/{feature.sourcePath}
-    documentPath: {output_path}/bizs/{platform_id}/{feature.module}/features
-    module: {feature.module}
-    analyzed: false
-    platform_type: {platform_type}
-    platform_subtype: {platform_subtype}
-    tech_stack: {tech_stack}
-    language: {language}
+For backend features (api-analyze), also include:
+```json
+{
+  "completed_dir": "{completed_dir}",
+  "sourceFile": "{sourceFile}"
+}
 ```
 
-> **NOTE**: UI Analyzer does NOT write .done.json marker files (handled by ui-graph skill in bizs-dispatch).
+**Output**: "Step 3 Status: ✅ COMPLETED - Built {count} task entries"
 
-#### After each successful analysis:
-Update the feature's `analyzed` field to `true` in the features JSON file.
-
-#### Error handling:
-- If an analyzer fails, log the error, increment `features_failed` counter
-- Continue with next feature (do NOT abort the entire module)
-- A module with partial analysis is better than no analysis
-
-**Output**: "Step 3 Status: ✅ COMPLETED - Analyzed {success} features, {failed} failed"
-
-### Step 4: Generate Module Summary
+### Step 4: Build Summarize Parameters
 
 **Step 4 Status: 🔄 IN PROGRESS**
 
-**Pre-check**: Verify that feature documents exist at `{output_path}/bizs/{platform_id}/{module_name}/features/`.
+Build the summarize_params object for module-summarize skill. This will be used by PM Agent after all analyze tasks complete.
 
-IF no feature documents exist AND features_analyzed == 0:
-  - Set status to "partial"
-  - Skip module-summarize
-  - Proceed to Step 5
-
-IF feature documents exist:
-  Invoke `speccrew-knowledge-module-summarize` skill:
-  ```
-  Use Agent tool to invoke speccrew-task-worker:
-  - agent: speccrew-task-worker
-  - task: Execute speccrew-knowledge-module-summarize skill
-  - context:
-      skill: speccrew-knowledge-module-summarize
-      module_name: {module_name}
-      module_path: {output_path}/bizs/{platform_id}/{module_name}
-      language: {language}
-  ```
+```json
+{
+  "skill": "speccrew-knowledge-module-summarize",
+  "module_name": "{module_name}",
+  "module_path": "{output_path}/bizs/{platform_id}/{module_name}",
+  "language": "{language}"
+}
+```
 
-**Output**: "Step 4 Status: ✅ COMPLETED - Module overview generated at {module_path}/{module_name}-overview.md"
+**Output**: "Step 4 Status: ✅ COMPLETED - Summarize params ready"
 
-### Step 5: Return Result
+### Step 5: Output Task Plan JSON
 
 **Step 5 Status: 🔄 IN PROGRESS**
 
-Compile and return the final result:
+Compile and output the final task plan:
 
 ```json
 {
-  "status": "success | partial | failed",
   "module_name": "...",
   "platform_id": "...",
-  "features_analyzed": <count>,
-  "features_failed": <count>,
-  "output_dir": "...",
-  "overview_file": "...",
-  "errors": [...]
+  "analyzer_skill": "...",
+  "tasks": [...],
+  "total_pending": <count>,
+  "summarize_params": {...}
 }
 ```
 
-**Status determination**:
-- `success`: All features analyzed successfully, overview generated
-- `partial`: Some features failed but overview generated, or no pending features but overview updated
-- `failed`: All features failed or critical error prevented overview generation
-
-**Output**: "Step 5 Status: ✅ COMPLETED - Module initialization {status}"
+**Output**: "Step 5 Status: ✅ COMPLETED - Task plan generated with {count} pending features"
 
 ## Constraints
 
@@ -231,21 +199,21 @@ Compile and return the final result:
 
 3. **Worker context**: This Skill runs in Worker Agent context, invoked by PM Agent
 
-4. **Sequential execution**: Process features sequentially within this Worker (PM Agent handles module-level parallelism)
+4. **NO execution**: This Skill generates task plan ONLY. It does NOT:
+   - Execute analyzer skills
+   - Execute summarize skills
+   - Update features.json analyzed field
+   - All execution is handled by PM Agent based on task plan output
 
-5. **No sync-state modification**: Do not directly create or modify sync-state directory files (that's dispatch's responsibility), but can update features.json analyzed markers
-
-6. **Mutual exclusion with full dispatch**: Do not run simultaneously with full dispatch process
+5. **Mutual exclusion with full dispatch**: Do not run simultaneously with full dispatch process
 
 ## Error Handling
 
 | Scenario | Action |
 |----------|--------|
-| Features file not found | Return `status: failed` with error message |
-| No features for module | Skip to Step 4, generate overview if possible |
-| No pending features | Skip to Step 4, update existing overview |
-| Analyzer fails for feature | Record in errors array, continue with next feature |
-| Module summarize fails | Return `status: partial` with error details |
+| Features file not found | Return error with message |
+| No features for module | Return empty tasks array with summarize_params |
+| No pending features | Return empty tasks array with summarize_params |
 
 ## Reference: Analyzer Input Parameters
 
@@ -253,10 +221,9 @@ Compile and return the final result:
 
 | Variable | Type | Description | Example |
 |----------|------|-------------|---------|
-| `feature` | object | Complete feature object from features.json | - |
 | `fileName` | string | Controller file name | `"UserController"` |
 | `sourcePath` | string | Relative path to source file | `"src/.../UserController.java"` |
-| `documentPath` | string | Target path for generated document | `"knowledges/bizs/.../UserController.md"` |
+| `documentPath` | string | Target path for generated document | `"knowledges/bizs/.../features"` |
 | `module` | string | Business module name | `"system"` |
 | `analyzed` | boolean | Analysis status flag | `false` |
 | `platform_type` | string | Platform type | `"backend"` |
@@ -270,18 +237,15 @@ Compile and return the final result:
 
 | Variable | Type | Description | Example |
 |----------|------|-------------|---------|
-| `feature` | object | Complete feature object from features.json | - |
 | `fileName` | string | Feature file name | `"index"` |
 | `sourcePath` | string | Relative path to source file | `"src/views/system/user/index.vue"` |
-| `documentPath` | string | Target path for generated document | `"knowledges/bizs/.../index.md"` |
+| `documentPath` | string | Target path for generated document | `"knowledges/bizs/.../features"` |
 | `module` | string | Business module name | `"system"` |
 | `analyzed` | boolean | Analysis status flag | `false` |
 | `platform_type` | string | Platform type | `"web"` |
 | `platform_subtype` | string | Platform subtype | `"vue"` |
 | `tech_stack` | array | Platform tech stack | `["vue", "typescript"]` |
 | `language` | string | Target language | `"zh"` |
-| `completed_dir` | string | Marker output directory (absolute path) | `".../knowledges/base/sync-state/completed"` |
-| `sourceFile` | string | Source features JSON filename | `"features-web-vue3.json"` |
 
 ## Task Completion Report
 
@@ -289,25 +253,16 @@ When the task is complete, report:
 
 ```json
 {
-  "status": "success | failed",
+  "status": "success",
   "skill": "speccrew-pm-module-initializer",
   "output": {
-    "status": "success | partial | failed",
     "module_name": "...",
     "platform_id": "...",
-    "features_analyzed": 12,
-    "features_failed": 0,
-    "output_dir": "...",
-    "overview_file": "...",
-    "errors": []
-  },
-  "metrics": {
-    "features_total": 15,
-    "features_analyzed": 12,
-    "features_skipped": 3,
-    "features_failed": 0
-  },
-  "errors": []
+    "analyzer_skill": "...",
+    "tasks": [...],
+    "total_pending": <count>,
+    "summarize_params": {...}
+  }
 }
 ```
 
@@ -315,6 +270,6 @@ When the task is complete, report:
 
 - [ ] Step 1: Read features file and filtered by module
 - [ ] Step 2: Selected analyzer type based on platform_type
-- [ ] Step 3: Analyzed each pending feature sequentially
-- [ ] Step 4: Generated module summary via module-summarize
-- [ ] Step 5: Returned aggregated result with correct status
+- [ ] Step 3: Built task list with analyzer parameters
+- [ ] Step 4: Built summarize parameters
+- [ ] Step 5: Output task plan JSON

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speccrew",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "description": "Spec-Driven Development toolkit for AI-powered IDEs",
   "author": "charlesmu99",
   "repository": {