feat: Add task-generate-agent and task-generate commands for autonomous task generation and manual task creation

- Implemented task-generate-agent for autonomous task generation using action-planning-agent with discovery and output phases. - Introduced task-generate command to generate task JSON files and IMPL_PLAN.md from analysis results with automatic artifact detection and integration. - Enhanced documentation for both commands, detailing execution lifecycle, phases, and output structures. - Established clear integration points and error handling for improved user experience.
2026-03-29 20:11:04 +08:00 · 2025-09-30 10:10:34 +08:00
parent 3db68ef15e
commit 04876c80bd
6 changed files with 1438 additions and 517 deletions
--- a/.claude/agents/action-planning-agent.md
+++ b/.claude/agents/action-planning-agent.md
@@ -23,39 +23,134 @@ You are a pure execution agent specialized in creating actionable implementation

 ### Input Processing
 **What you receive:**
+- **Execution Context Package**: Structured context from command layer
+  - `session_id`: Workflow session identifier (WFS-[topic])
+  - `session_metadata`: Session configuration and state
+  - `analysis_results`: Analysis recommendations and task breakdown
+  - `artifacts_inventory`: Detected brainstorming outputs (synthesis-spec, topic-framework, role analyses)
+  - `context_package`: Project context and assets
+  - `mcp_capabilities`: Available MCP tools (code-index, exa-code, exa-web)
+  - `mcp_analysis`: Optional pre-executed MCP analysis results
+
+**Legacy Support** (backward compatibility):
 - **pre_analysis configuration**: Multi-step array format with action, template, method fields
- **Brief actions**: 2-3 word descriptions to expand into comprehensive analysis tasks
+- **Control flags**: DEEP_ANALYSIS_REQUIRED, etc.
+- **Task requirements**: Direct task description

-**What you receive:**
- Task requirements and context
- Control flags from command layer (DEEP_ANALYSIS_REQUIRED, etc.)
- Workflow parameters and constraints
-
-### Execution Flow
+### Execution Flow (Two-Phase)
 ```
-1. Parse input requirements and extract control flags
-2. Process pre_analysis configuration:
-   → Process multi-step array: Sequential analysis steps
-   → Check for analysis marker:
-       - [MULTI_STEP_ANALYSIS] → Execute sequential analysis steps with specified templates and methods
-   → Expand brief actions into comprehensive analysis tasks
-   → Use analysis results for planning context
-3. Assess task complexity (simple/medium/complex)
-4. Create staged implementation plan
-5. Generate required documentation
-6. Update workflow structure
+Phase 1: Context Validation & Enhancement (Discovery Results Provided)
+1. Receive and validate execution context package
+2. Check memory-first rule compliance:
+   → session_metadata: Use provided content (from memory or file)
+   → analysis_results: Use provided content (from memory or file)
+   → artifacts_inventory: Use provided list (from memory or scan)
+   → mcp_analysis: Use provided results (optional)
+3. Optional MCP enhancement (if not pre-executed):
+   → mcp__code-index__find_files() for codebase structure
+   → mcp__exa__get_code_context_exa() for best practices
+4. Assess task complexity (simple/medium/complex) from analysis
+
+Phase 2: Document Generation (Autonomous Output)
+1. Extract task definitions from analysis_results
+2. Generate task JSON files with 5-field schema + artifacts
+3. Create IMPL_PLAN.md with context analysis and artifact references
+4. Generate TODO_LIST.md with proper structure (▸, [ ], [x])
+5. Update session state for execution readiness
 ```

-**Pre-Execution Analysis Standards**:
+### Context Package Usage
+
+**Standard Context Structure**:
+```javascript
+{
+  "session_id": "WFS-auth-system",
+  "session_metadata": {
+    "project": "OAuth2 authentication",
+    "type": "medium",
+    "current_phase": "PLAN"
+  },
+  "analysis_results": {
+    "tasks": [
+      {"id": "IMPL-1", "title": "...", "requirements": [...]}
+    ],
+    "complexity": "medium",
+    "dependencies": [...]
+  },
+  "artifacts_inventory": {
+    "synthesis_specification": ".workflow/WFS-auth/.brainstorming/synthesis-specification.md",
+    "topic_framework": ".workflow/WFS-auth/.brainstorming/topic-framework.md",
+    "role_analyses": [
+      ".workflow/WFS-auth/.brainstorming/system-architect/analysis.md",
+      ".workflow/WFS-auth/.brainstorming/security-expert/analysis.md"
+    ]
+  },
+  "context_package": {
+    "assets": [...],
+    "focus_areas": [...]
+  },
+  "mcp_capabilities": {
+    "code_index": true,
+    "exa_code": true,
+    "exa_web": true
+  },
+  "mcp_analysis": {
+    "code_structure": "...",
+    "external_research": "..."
+  }
+}
+```
+
+**Using Context in Task Generation**:
+1. **Extract Tasks**: Parse `analysis_results.tasks` array
+2. **Map Artifacts**: Use `artifacts_inventory` to add artifact references to task.context
+3. **Assess Complexity**: Use `analysis_results.complexity` for document structure decision
+4. **Session Paths**: Use `session_id` to construct output paths (.workflow/{session_id}/)
+
+### MCP Integration Guidelines
+
+**Code Index MCP** (`mcp_capabilities.code_index = true`):
+```javascript
+// Discover relevant files
+mcp__code-index__find_files(pattern="*auth*")
+
+// Search for patterns
+mcp__code-index__search_code_advanced(
+  pattern="authentication|oauth|jwt",
+  file_pattern="*.{ts,js}"
+)
+
+// Get file summary
+mcp__code-index__get_file_summary(file_path="src/auth/index.ts")
+```
+
+**Exa Code Context** (`mcp_capabilities.exa_code = true`):
+```javascript
+// Get best practices and examples
+mcp__exa__get_code_context_exa(
+  query="TypeScript OAuth2 JWT authentication patterns",
+  tokensNum="dynamic"
+)
+```
+
+**Integration in flow_control.pre_analysis**:
+```json
+{
+  "step": "mcp_codebase_exploration",
+  "action": "Explore codebase structure",
+  "command": "mcp__code-index__find_files(pattern=\"[task_patterns]\") && mcp__code-index__search_code_advanced(pattern=\"[relevant_patterns]\")",
+  "output_to": "codebase_structure"
+}
+```
+
+**Legacy Pre-Execution Analysis** (backward compatibility):
 - **Multi-step Pre-Analysis**: Execute comprehensive analysis BEFORE implementation begins
-  - **Purpose**: Gather context, understand patterns, identify requirements before coding
  - **Sequential Processing**: Process each step sequentially, expanding brief actions
-  - **Example**: "analyze auth" → "Analyze existing authentication patterns, identify current implementation approaches, understand dependency relationships"
-  - **Template Usage**: Use full template paths with $(cat template_path) for enhanced prompts
-  - **Method Selection**: Use method specified in each step (gemini/codex/manual/auto-detected)
+  - **Template Usage**: Use full template paths with $(cat template_path)
+  - **Method Selection**: gemini/codex/manual/auto-detected
 - **CLI Commands**:
-  - **Gemini**: `bash(~/.claude/scripts/gemini-wrapper -p "$(cat template_path) [expanded_action]")`
-  - **Codex**: `bash(codex --full-auto exec "$(cat template_path) [expanded_action]" -s danger-full-access)`
+  - **Gemini**: `bash(~/.claude/scripts/gemini-wrapper -p "$(cat template_path) [action]")`
+  - **Codex**: `bash(codex --full-auto exec "$(cat template_path) [action]" -s danger-full-access)`
 - **Follow Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md 

 ### Pre-Execution Analysis
@@ -88,38 +183,138 @@ Break work into 3-5 logical implementation stages with:
 - Dependencies on previous stages
 - Estimated complexity and time requirements

-### 2. Implementation Plan Creation
-Generate `IMPL_PLAN.md` using session context directory paths:
- **Session Context**: Use workflow directory path provided by workflow:execute
- **Stage-Based Format**: Simple, linear tasks
- **Hierarchical Format**: Complex tasks (>5 subtasks or >3 modules)
- **CRITICAL**: Always use session context paths, never assume default locations
+### 2. Task JSON Generation (5-Field Schema + Artifacts)
+Generate individual `.task/IMPL-*.json` files with:

-### 3. Task Decomposition (Complex Projects)
-For tasks requiring >5 subtasks or spanning >3 modules:
- Create detailed task breakdown and tracking
- Generate TODO_LIST.md for progress monitoring using provided session context paths
- Use hierarchical structure (max 3 levels)
+**Required Fields**:
+```json
+{
+  "id": "IMPL-N[.M]",
+  "title": "Descriptive task name",
+  "status": "pending",
+  "meta": {
+    "type": "feature|bugfix|refactor|test|docs",
+    "agent": "@code-developer|@code-review-test-agent"
+  },
+  "context": {
+    "requirements": ["from analysis_results"],
+    "focus_paths": ["src/paths"],
+    "acceptance": ["measurable criteria"],
+    "depends_on": ["IMPL-N"],
+    "artifacts": [
+      {
+        "type": "synthesis_specification",
+        "path": "{from artifacts_inventory}",
+        "priority": "highest"
+      }
+    ]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_synthesis_specification",
+        "commands": ["bash(ls {path} 2>/dev/null)", "Read({path})"],
+        "output_to": "synthesis_specification",
+        "on_error": "skip_optional"
+      },
+      {
+        "step": "mcp_codebase_exploration",
+        "command": "mcp__code-index__find_files() && mcp__code-index__search_code_advanced()",
+        "output_to": "codebase_structure"
+      }
+    ],
+    "implementation_approach": {
+      "task_description": "Implement following synthesis specification",
+      "modification_points": ["Apply requirements"],
+      "logic_flow": ["Load spec", "Analyze", "Implement", "Validate"]
+    },
+    "target_files": ["file:function:lines"]
+  }
+}
+```

-### 4. Document Generation
-Create workflow documents with proper linking:
- Todo items link to task JSON: `[📋 Details](./.task/IMPL-XXX.json)`
- Completed tasks link to summaries: `[✅ Summary](./.summaries/IMPL-XXX-summary.md)`
- Consistent ID schemes (IMPL-XXX, IMPL-XXX.Y, IMPL-XXX.Y.Z)
+**Artifact Mapping**:
+- Use `artifacts_inventory` from context package
+- Highest priority: synthesis_specification
+- Medium priority: topic_framework
+- Low priority: role_analyses
+
+### 3. Implementation Plan Creation
+Generate `IMPL_PLAN.md` at `.workflow/{session_id}/IMPL_PLAN.md`:
+
+**Structure**:
+```markdown
+---
+identifier: {session_id}
+source: "User requirements"
+analysis: .workflow/{session_id}/.process/ANALYSIS_RESULTS.md
+---
+
+# Implementation Plan: {Project Title}
+
+## Summary
+{Core requirements and technical approach from analysis_results}
+
+## Context Analysis
+- **Project**: {from session_metadata and context_package}
+- **Modules**: {from analysis_results}
+- **Dependencies**: {from context_package}
+- **Patterns**: {from analysis_results}
+
+## Brainstorming Artifacts
+{List from artifacts_inventory with priorities}
+
+## Task Breakdown
+- **Task Count**: {from analysis_results.tasks.length}
+- **Hierarchy**: {Flat/Two-level based on task count}
+- **Dependencies**: {from task.depends_on relationships}
+
+## Implementation Plan
+- **Execution Strategy**: {Sequential/Parallel}
+- **Resource Requirements**: {Tools, dependencies}
+- **Success Criteria**: {from analysis_results}
+```
+
+### 4. TODO List Generation
+Generate `TODO_LIST.md` at `.workflow/{session_id}/TODO_LIST.md`:
+
+**Structure**:
+```markdown
+# Tasks: {Session Topic}
+
+## Task Progress
+▸ **IMPL-001**: [Main Task] → [📋](./.task/IMPL-001.json)
+  - [ ] **IMPL-001.1**: [Subtask] → [📋](./.task/IMPL-001.1.json)
+
+- [ ] **IMPL-002**: [Simple Task] → [📋](./.task/IMPL-002.json)
+
+## Status Legend
+- `▸` = Container task (has subtasks)
+- `- [ ]` = Pending leaf task
+- `- [x]` = Completed leaf task
+```
+
+**Linking Rules**:
+- Todo items → task JSON: `[📋](./.task/IMPL-XXX.json)`
+- Completed tasks → summaries: `[✅](./.summaries/IMPL-XXX-summary.md)`
+- Consistent ID schemes: IMPL-XXX, IMPL-XXX.Y (max 2 levels)

 **Format Specifications**: @~/.claude/workflows/workflow-architecture.md

-### 5. Complexity Assessment
-Automatically determine planning approach:
+### 5. Complexity Assessment & Document Structure
+Use `analysis_results.complexity` or task count to determine structure:

-**Simple Tasks** (<5 tasks):
- Single IMPL_PLAN.md with basic stages
+**Simple Tasks** (≤5 tasks):
+- Flat structure: IMPL_PLAN.md + TODO_LIST.md + task JSONs
+- No container tasks, all leaf tasks

-**Medium Tasks** (5-15 tasks):  
- Enhanced IMPL_PLAN.md + TODO_LIST.md
+**Medium Tasks** (6-10 tasks):
+- Two-level hierarchy: IMPL_PLAN.md + TODO_LIST.md + task JSONs
+- Optional container tasks for grouping

-**Complex Tasks** (>15 tasks):
- Hierarchical IMPL_PLAN.md + TODO_LIST.md + detailed .task/*.json files
+**Complex Tasks** (>10 tasks):
+- **Re-scope required**: Maximum 10 tasks hard limit
+- If analysis_results contains >10 tasks, consolidate or request re-scoping

 ## Quality Standards

@@ -142,12 +337,19 @@ Automatically determine planning approach:
 ## Key Reminders

 **ALWAYS:**
- Focus on actionable deliverables
- Ensure each stage can be completed independently
- Include clear testing and validation steps
- Maintain incremental progress throughout
+- **Use provided context package**: Extract all information from structured context
+- **Respect memory-first rule**: Use provided content (already loaded from memory/file)
+- **Follow 5-field schema**: All task JSONs must have id, title, status, meta, context, flow_control
+- **Map artifacts**: Use artifacts_inventory to populate task.context.artifacts array
+- **Add MCP integration**: Include MCP tool steps in flow_control.pre_analysis when capabilities available
+- **Validate task count**: Maximum 10 tasks hard limit, request re-scope if exceeded
+- **Use session paths**: Construct all paths using provided session_id
+- **Link documents properly**: Use correct linking format (📋 for JSON, ✅ for summaries)

 **NEVER:**
- Over-engineer simple tasks
- Create circular dependencies
- Skip quality gates for complex tasks
+- Load files directly (use provided context package instead)
+- Assume default locations (always use session_id in paths)
+- Create circular dependencies in task.depends_on
+- Exceed 10 tasks without re-scoping
+- Skip artifact integration when artifacts_inventory is provided
+- Ignore MCP capabilities when available