mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-05 01:50:27 +08:00
feat(lite-execute): add new command for executing tasks with in-memory plans and flexible input modes
This commit is contained in:
catlog22
454
.claude/commands/workflow/lite-execute.md
Normal file
454
.claude/commands/workflow/lite-execute.md
Normal file
@@ -0,0 +1,454 @@
|
||||
---
|
||||
name: lite-execute
|
||||
description: Execute tasks based on in-memory plan, prompt description, or file content
|
||||
argument-hint: "[--in-memory] [\"task description\"|file-path]"
|
||||
allowed-tools: TodoWrite(*), Task(*), Bash(*)
|
||||
---
|
||||
|
||||
# Workflow Lite-Execute Command (/workflow:lite-execute)
|
||||
|
||||
## Overview
|
||||
|
||||
Flexible task execution command supporting three input modes: in-memory plan (from lite-plan), direct prompt description, or file content (file input is equivalent to prompt). Handles execution orchestration, progress tracking, and optional code review.
|
||||
|
||||
## Core Functionality
|
||||
|
||||
- **Multi-Mode Input**: Three ways to specify what to execute
|
||||
- `--in-memory`: Use plan from memory (called by lite-plan)
|
||||
- Prompt description: Direct task execution with simple planning
|
||||
- File path: Read file content as prompt (equivalent to Mode 2)
|
||||
- **Execution Orchestration**: Launch Agent or Codex with full context
|
||||
- **Live Progress Tracking**: Real-time TodoWrite updates at execution call level
|
||||
- **Optional Code Review**: Post-execution quality analysis with selected tool
|
||||
|
||||
## Usage
|
||||
|
||||
### Command Syntax
|
||||
```bash
|
||||
/workflow:lite-execute [FLAGS] <INPUT>
|
||||
|
||||
# Flags
|
||||
--in-memory Use plan from memory (called by lite-plan)
|
||||
|
||||
# Arguments
|
||||
<input> Task description string, or path to file containing task description (required)
|
||||
```
|
||||
|
||||
### Input Modes
|
||||
|
||||
#### Mode 1: In-Memory Plan
|
||||
|
||||
**Trigger**: Called by lite-plan after Phase 4 approval
|
||||
|
||||
**Input Source**: `executionContext` global variable set by lite-plan
|
||||
|
||||
**Expected Structure**:
|
||||
```javascript
|
||||
executionContext = {
|
||||
planObject: {
|
||||
summary: string,
|
||||
approach: string,
|
||||
tasks: string[],
|
||||
estimated_time: string,
|
||||
recommended_execution: string,
|
||||
complexity: string
|
||||
},
|
||||
explorationContext: {...} | null,
|
||||
clarificationContext: {...} | null,
|
||||
executionMethod: "Agent" | "Codex" | "Auto",
|
||||
codeReviewTool: "Skip" | "Gemini Review" | "Agent Review" | string
|
||||
}
|
||||
```
|
||||
|
||||
**Behavior**:
|
||||
- Skip execution method selection (already set)
|
||||
- Directly proceed to execution with full context
|
||||
|
||||
#### Mode 2: Prompt Description
|
||||
|
||||
**Trigger**: User calls with task description string
|
||||
|
||||
**Input**: Simple task description (e.g., "Add unit tests for auth module")
|
||||
|
||||
**Behavior**:
|
||||
- Create simple execution plan from prompt
|
||||
- Ask user to select execution method (Agent/Codex/Auto)
|
||||
- Ask user about code review preference
|
||||
- Proceed to execution
|
||||
|
||||
**AskUserQuestion Call**:
|
||||
```javascript
|
||||
AskUserQuestion({
|
||||
questions: [
|
||||
{
|
||||
question: "Select execution method for this task:",
|
||||
header: "Execution",
|
||||
multiSelect: false,
|
||||
options: [
|
||||
{ label: "Agent", description: "Execute with @code-developer agent" },
|
||||
{ label: "Codex", description: "Execute with codex CLI tool" },
|
||||
{ label: "Auto", description: "Auto-select based on task complexity" }
|
||||
]
|
||||
},
|
||||
{
|
||||
question: "Enable code review after execution?",
|
||||
header: "Code Review",
|
||||
multiSelect: false,
|
||||
options: [
|
||||
{ label: "Skip", description: "No review needed" },
|
||||
{ label: "Gemini Review", description: "Review with Gemini CLI tool" },
|
||||
{ label: "Agent Review", description: "Review with current agent" }
|
||||
]
|
||||
}
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
#### Mode 3: File Content
|
||||
|
||||
**Trigger**: User calls with file path
|
||||
|
||||
**Input**: Path to file containing task description or plan
|
||||
|
||||
**Behavior**:
|
||||
- Read file content
|
||||
- Use file content as task prompt (equivalent to Mode 2)
|
||||
- Ask user to select execution method (Agent/Codex/Auto)
|
||||
- Ask user about code review preference
|
||||
- Proceed to execution
|
||||
|
||||
**Note**: File content is treated as prompt text, no special format parsing required. Any file format can be used as long as it contains readable task description.
|
||||
|
||||
## Execution Process
|
||||
|
||||
### Workflow Overview
|
||||
|
||||
```
|
||||
Input Processing
|
||||
|
|
||||
v
|
||||
[Mode Detection]
|
||||
├─ --in-memory → Load from executionContext variable
|
||||
├─ File path → Read file content as prompt
|
||||
└─ String → Use as prompt directly
|
||||
|
|
||||
v
|
||||
[Execution Method Selection]
|
||||
├─ --in-memory: Already set (skip)
|
||||
└─ Others (file/prompt): AskUserQuestion for method + review
|
||||
|
|
||||
v
|
||||
[Execution & Progress Tracking]
|
||||
├─ Step 1: Initialize execution tracking
|
||||
├─ Step 2: Create TodoWrite execution list
|
||||
├─ Step 3: Launch execution (Agent or Codex)
|
||||
├─ Step 4: Track execution progress
|
||||
└─ Step 5: Code review (optional)
|
||||
|
|
||||
v
|
||||
Execution Complete
|
||||
```
|
||||
|
||||
## Detailed Execution Steps
|
||||
|
||||
### Step 1: Initialize Execution Tracking
|
||||
|
||||
**Operations**:
|
||||
- Initialize result tracking for multi-execution scenarios
|
||||
- Set up previousExecutionResults array
|
||||
|
||||
```javascript
|
||||
// Initialize result tracking
|
||||
previousExecutionResults = []
|
||||
```
|
||||
|
||||
### Step 2: Create TodoWrite Execution List
|
||||
|
||||
**Operations**:
|
||||
- Create execution tracking from task list
|
||||
- Typically single execution call for all tasks
|
||||
- May split into multiple calls if task list is very large (>10 tasks)
|
||||
|
||||
```javascript
|
||||
// Create execution calls (usually 1-2 calls total)
|
||||
executionCalls = createExecutionCalls(planObject.tasks).map((call, index) => ({
|
||||
...call,
|
||||
id: `[${call.method}-${index+1}]` // Store ID for result collection
|
||||
}))
|
||||
|
||||
// Create TodoWrite execution list
|
||||
TodoWrite({
|
||||
todos: executionCalls.map(call => ({
|
||||
content: `${call.id} (${call.taskSummary})`,
|
||||
status: "pending",
|
||||
activeForm: `Executing ${call.id} (${call.taskSummary})`
|
||||
}))
|
||||
})
|
||||
```
|
||||
|
||||
**Example Execution List**:
|
||||
```
|
||||
[ ] [Agent-1] (Implement all planned tasks)
|
||||
```
|
||||
|
||||
Or for large task sets:
|
||||
```
|
||||
[ ] [Agent-1] (Tasks 1-5: Core implementation)
|
||||
[ ] [Agent-2] (Tasks 6-10: Tests and documentation)
|
||||
```
|
||||
|
||||
### Step 3: Launch Execution
|
||||
|
||||
**IMPORTANT**: CLI execution MUST run in foreground (no background execution)
|
||||
|
||||
**Execution Loop**:
|
||||
```javascript
|
||||
// Execute each call in the execution list sequentially
|
||||
for (currentIndex = 0; currentIndex < executionCalls.length; currentIndex++) {
|
||||
const currentCall = executionCalls[currentIndex]
|
||||
|
||||
// Update TodoWrite: mark current call as in_progress
|
||||
// Launch execution with previousExecutionResults context
|
||||
// After completion, collect result and add to previousExecutionResults
|
||||
// Update TodoWrite: mark current call as completed
|
||||
}
|
||||
```
|
||||
|
||||
Based on execution method selection, launch appropriate execution:
|
||||
|
||||
#### Option A: Agent Execution
|
||||
|
||||
**When to use**:
|
||||
- executionMethod = "Agent"
|
||||
- executionMethod = "Auto" AND complexity = "Low"
|
||||
|
||||
**Agent Call**:
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="code-developer",
|
||||
description="Implement planned tasks with progress tracking",
|
||||
prompt=`
|
||||
Implement the following tasks:
|
||||
|
||||
Summary: ${planObject.summary}
|
||||
|
||||
Task Breakdown:
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
|
||||
${previousExecutionResults.length > 0 ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
Tasks handled: ${result.tasksSummary}
|
||||
Completion status: ${result.completionSummary}
|
||||
Key outputs: ${result.keyOutputs || 'See git diff for details'}
|
||||
${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
`).join('\n---\n')}` : ''}
|
||||
|
||||
Implementation Approach:
|
||||
${planObject.approach}
|
||||
|
||||
Code Context:
|
||||
${explorationContext || "No exploration performed"}
|
||||
|
||||
${clarificationContext ? `\nClarifications:\n${JSON.stringify(clarificationContext, null, 2)}` : ''}
|
||||
|
||||
IMPORTANT Instructions:
|
||||
- Review previous execution results to understand what's already completed
|
||||
- Build on previous work and avoid duplication
|
||||
- Test functionality as you go
|
||||
- Complete all tasks listed above
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Execution Result Collection**:
|
||||
After agent execution completes:
|
||||
```javascript
|
||||
executionResult = {
|
||||
executionId: executionCalls[currentIndex].id, // e.g., "[Agent-1]"
|
||||
status: "completed" | "partial" | "failed",
|
||||
tasksSummary: "Brief description of tasks handled",
|
||||
completionSummary: "What was completed",
|
||||
keyOutputs: "Files created/modified, key changes",
|
||||
notes: "Any important context for next execution"
|
||||
}
|
||||
previousExecutionResults.push(executionResult)
|
||||
```
|
||||
|
||||
#### Option B: CLI Execution (Codex)
|
||||
|
||||
**When to use**:
|
||||
- executionMethod = "Codex"
|
||||
- executionMethod = "Auto" AND complexity = "Medium" or "High"
|
||||
|
||||
**Command Format**:
|
||||
```bash
|
||||
codex --full-auto exec "
|
||||
TASK: ${planObject.summary}
|
||||
|
||||
## Task Breakdown
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
|
||||
${previousExecutionResults.length > 0 ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
Tasks: ${result.tasksSummary}
|
||||
Status: ${result.completionSummary}
|
||||
Outputs: ${result.keyOutputs || 'See git diff'}
|
||||
${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
`).join('\n---\n')}
|
||||
|
||||
IMPORTANT: Review previous results above. Build on completed work. Avoid duplication.
|
||||
` : ''}
|
||||
|
||||
## Implementation Approach
|
||||
${planObject.approach}
|
||||
|
||||
## Code Context from Exploration
|
||||
${explorationContext ? `
|
||||
Project Structure: ${explorationContext.project_structure || 'Standard structure'}
|
||||
Relevant Files: ${explorationContext.relevant_files?.join(', ') || 'TBD'}
|
||||
Current Patterns: ${explorationContext.patterns || 'Follow existing conventions'}
|
||||
Integration Points: ${explorationContext.dependencies || 'None specified'}
|
||||
Constraints: ${explorationContext.constraints || 'None'}
|
||||
` : 'No prior exploration - analyze codebase as needed'}
|
||||
|
||||
${clarificationContext ? `\n## User Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `${q}: ${a}`).join('\n')}` : ''}
|
||||
|
||||
## Execution Instructions
|
||||
- Review previous execution results for context continuity
|
||||
- Build on previous work, don't duplicate completed tasks
|
||||
- Complete all assigned tasks in single execution
|
||||
- Test functionality as you implement
|
||||
|
||||
Complexity: ${planObject.complexity}
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**Execution with Progress Tracking**:
|
||||
```javascript
|
||||
// Launch CLI in foreground (NOT background)
|
||||
bash_result = Bash(
|
||||
command=cli_command,
|
||||
timeout=600000 // 10 minutes
|
||||
)
|
||||
|
||||
// Update TodoWrite when CLI execution call completes
|
||||
```
|
||||
|
||||
**Execution Result Collection**:
|
||||
After CLI execution completes, analyze output and collect result summary with same structure as Agent execution.
|
||||
|
||||
### Step 4: Track Execution Progress
|
||||
|
||||
**Real-time TodoWrite Updates**:
|
||||
|
||||
Track at **execution call level** (not individual tasks):
|
||||
|
||||
```javascript
|
||||
// When execution call starts
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "[Agent-1] (Implement auth service + Create JWT utilities)", status: "in_progress", activeForm: "Executing [Agent-1] (Implement auth service + Create JWT utilities)" },
|
||||
{ content: "[Agent-2] (Add middleware + Update routes)", status: "pending", activeForm: "Executing [Agent-2] (Add middleware + Update routes)" },
|
||||
{ content: "[Codex-1] (Add integration tests)", status: "pending", activeForm: "Executing [Codex-1] (Add integration tests)" }
|
||||
]
|
||||
})
|
||||
|
||||
// When execution call completes
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "[Agent-1] (Implement auth service + Create JWT utilities)", status: "completed", activeForm: "Executing [Agent-1] (Implement auth service + Create JWT utilities)" },
|
||||
{ content: "[Agent-2] (Add middleware + Update routes)", status: "in_progress", activeForm: "Executing [Agent-2] (Add middleware + Update routes)" },
|
||||
{ content: "[Codex-1] (Add integration tests)", status: "pending", activeForm: "Executing [Codex-1] (Add integration tests)" }
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
**User Visibility**:
|
||||
- User sees **execution call progress** (not individual task progress)
|
||||
- Current execution highlighted as "in_progress"
|
||||
- Completed executions marked with checkmark
|
||||
- Pending executions remain unchecked
|
||||
- Each execution shows **task summary** for context
|
||||
|
||||
### Step 5: Code Review (Optional)
|
||||
|
||||
**Skip Condition**: Only run if codeReviewTool ≠ "Skip"
|
||||
|
||||
**Operations**:
|
||||
- If "Agent Review": Current agent performs direct code review analysis
|
||||
- If "Gemini Review": Execute gemini CLI with code review analysis prompt
|
||||
- If custom tool (via "Other"): Execute specified CLI tool (e.g., qwen, codex)
|
||||
- Review all modified files from execution
|
||||
- Generate quality assessment and improvement recommendations
|
||||
|
||||
**Command Format**:
|
||||
|
||||
```bash
|
||||
# Agent Review: Direct agent review (no CLI command needed)
|
||||
# Uses analysis prompt and TodoWrite tools directly
|
||||
|
||||
# Gemini Review:
|
||||
gemini -p "
|
||||
PURPOSE: Code review for implemented changes
|
||||
TASK: • Analyze code quality • Identify potential issues • Suggest improvements
|
||||
MODE: analysis
|
||||
CONTEXT: @**/* | Memory: Review changes from lite-execute execution
|
||||
EXPECTED: Quality assessment with actionable recommendations
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on recent changes | analysis=READ-ONLY
|
||||
"
|
||||
|
||||
# Qwen Review (custom tool via "Other"):
|
||||
qwen -p "
|
||||
PURPOSE: Code review for implemented changes
|
||||
TASK: • Analyze code quality • Identify potential issues • Suggest improvements
|
||||
MODE: analysis
|
||||
CONTEXT: @**/* | Memory: Review changes from lite-execute execution
|
||||
EXPECTED: Quality assessment with actionable recommendations
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on recent changes | analysis=READ-ONLY
|
||||
"
|
||||
|
||||
# Codex Review (custom tool via "Other"):
|
||||
codex --full-auto exec "Review the recent code changes for quality, potential issues, and improvements" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
### Execution Intelligence
|
||||
|
||||
1. **Context Continuity**: Each execution call receives previous results
|
||||
- Prevents duplication across multiple executions
|
||||
- Maintains coherent implementation flow
|
||||
- Builds on completed work
|
||||
|
||||
2. **Execution Call Tracking**: Progress at call level, not task level
|
||||
- Each call handles all or subset of tasks
|
||||
- Clear visibility of current execution
|
||||
- Simple progress updates
|
||||
|
||||
3. **Flexible Execution**: Supports multiple input modes
|
||||
- In-memory: Seamless integration with lite-plan
|
||||
- Prompt: Quick standalone execution
|
||||
- File: Read file content as prompt for execution
|
||||
|
||||
### Task Management
|
||||
|
||||
1. **Live Progress Updates**: Real-time TodoWrite tracking
|
||||
- Execution calls created before execution starts
|
||||
- Updated as executions progress
|
||||
- Clear completion status
|
||||
|
||||
2. **Simple Execution**: Straightforward task handling
|
||||
- All tasks in single execution call (typical)
|
||||
- Split only for very large task sets (>10 tasks)
|
||||
- Agent/Codex determines optimal execution order
|
||||
|
||||
## Error Handling
|
||||
|
||||
| Error | Cause | Resolution |
|
||||
|-------|-------|------------|
|
||||
| Missing executionContext | --in-memory called without context | Display error: "No execution context found. This mode is only available when called by lite-plan." |
|
||||
| File not found | File path doesn't exist | Display error: "File not found: {path}. Please check the file path." |
|
||||
| Empty file | File exists but has no content | Display error: "File is empty: {path}. Please provide task description." |
|
||||
| Execution failure | Agent/Codex crashes or errors | Display error details, save partial progress, suggest retry |
|
||||
| Codex unavailable | Codex tool not installed | Show installation instructions, offer Agent execution |
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
---
|
||||
name: lite-plan
|
||||
description: Lightweight interactive planning and execution workflow with in-memory planning, code exploration, and immediate execution after user confirmation
|
||||
argument-hint: "[--tool claude|gemini|qwen|codex] [-e|--explore] \"task description\"|file.md"
|
||||
allowed-tools: TodoWrite(*), Task(*), Bash(*), AskUserQuestion(*)
|
||||
description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
|
||||
argument-hint: "[-e|--explore] \"task description\"|file.md"
|
||||
allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
|
||||
timeout: 180000
|
||||
color: cyan
|
||||
---
|
||||
@@ -11,7 +11,7 @@ color: cyan
|
||||
|
||||
## Overview
|
||||
|
||||
Intelligent lightweight planning and execution command with dynamic workflow adaptation based on task complexity.
|
||||
Intelligent lightweight planning command with dynamic workflow adaptation based on task complexity. Focuses on planning phases (exploration, clarification, planning, confirmation) and delegates execution to `/workflow:lite-execute`.
|
||||
|
||||
## Core Functionality
|
||||
|
||||
@@ -22,9 +22,7 @@ Intelligent lightweight planning and execution command with dynamic workflow ada
|
||||
- Simple tasks: Direct planning by current Claude
|
||||
- Complex tasks: Delegates to cli-planning-agent for detailed breakdown
|
||||
- **Two-Step Confirmation**: First display complete plan as text, then collect three-dimensional input (task approval + execution method + code review tool)
|
||||
- **Direct Execution**: Immediate dispatch to selected execution method (agent/codex/auto)
|
||||
- **Live Progress Tracking**: Real-time TodoWrite updates at execution call level ([Agent-1], [Codex-1], etc.) during execution
|
||||
- **Optional Code Review**: Post-execution quality analysis with gemini/agent or custom tools via "Other" option (e.g., qwen, codex)
|
||||
- **Execution Dispatch**: Stores execution context in memory and calls `/workflow:lite-execute --in-memory` for actual implementation
|
||||
|
||||
|
||||
## Usage
|
||||
@@ -81,24 +79,22 @@ User Input ("/workflow:lite-plan \"task\"")
|
||||
-> If cancel: Exit
|
||||
|
|
||||
v
|
||||
[Phase 5] Execution & Progress Tracking
|
||||
-> Create TodoWrite execution call list (grouped tasks)
|
||||
-> Launch selected execution (agent or CLI)
|
||||
-> Track execution call progress with TodoWrite updates
|
||||
-> Real-time call status displayed to user (e.g., "[Agent-1] (Task A + Task B)")
|
||||
-> If code review enabled: Run selected CLI analysis
|
||||
[Phase 5] Dispatch to Execution
|
||||
-> Store execution context (plan, exploration, clarifications, selections)
|
||||
-> Call /workflow:lite-execute --in-memory
|
||||
-> Execution delegated to lite-execute command
|
||||
|
|
||||
v
|
||||
Execution Complete
|
||||
Planning Complete (Execution continues in lite-execute)
|
||||
```
|
||||
|
||||
### Task Management Pattern
|
||||
|
||||
- TodoWrite creates execution call list before execution starts (Phase 5)
|
||||
- Execution calls ([Agent-1], [Codex-1], etc.) marked as in_progress/completed during execution
|
||||
- Each execution call handles multiple related tasks
|
||||
- Real-time progress updates visible at call level (not individual task level)
|
||||
- No intermediate file artifacts generated
|
||||
- lite-plan focuses on planning phases (1-4) with TodoWrite tracking
|
||||
- Phase 5 stores execution context and dispatches to lite-execute
|
||||
- Execution tracking (TodoWrite updates, progress monitoring) handled by lite-execute
|
||||
- No intermediate file artifacts generated (all planning in-memory)
|
||||
- Execution artifacts (code changes, test results) managed by lite-execute
|
||||
|
||||
## Detailed Phase Execution
|
||||
|
||||
@@ -291,15 +287,10 @@ Task(
|
||||
|
||||
1. Summary: 2-3 sentence overview of the implementation
|
||||
2. Approach: High-level implementation strategy
|
||||
3. Task Breakdown: 5-10 specific, actionable tasks
|
||||
- Each task should specify: What to do, Which files to modify/create, Dependencies on other tasks (if any)
|
||||
4. Task Dependencies & Parallelization:
|
||||
- Identify independent tasks that can run in parallel (no shared file conflicts or logical dependencies)
|
||||
- Group tasks by execution order: parallel groups can execute simultaneously, sequential groups must wait for previous completion
|
||||
- Format: "Group 1 (parallel): Task 1, Task 2 | Group 2 (parallel): Task 3, Task 4 | Task 5 (depends on all)"
|
||||
5. Risks: Potential issues and mitigation strategies (for Medium/High complexity)
|
||||
6. Estimated Time: Total implementation time estimate
|
||||
7. Recommended Execution: "Agent" or "Codex" based on task complexity
|
||||
3. Task Breakdown: 3-10 specific, actionable tasks
|
||||
- Each task should specify: What to do, Which files to modify/create
|
||||
4. Estimated Time: Total implementation time estimate
|
||||
5. Recommended Execution: "Agent" or "Codex" based on task complexity
|
||||
|
||||
Ensure tasks are specific, with file paths and clear acceptance criteria.
|
||||
`
|
||||
@@ -311,9 +302,7 @@ Task(
|
||||
planObject = {
|
||||
summary: string, // 2-3 sentence overview
|
||||
approach: string, // High-level implementation strategy
|
||||
tasks: string[], // 3-5 tasks (Low) or 5-10 tasks (Medium/High) with file paths
|
||||
dependencies: string[], // Task execution order: parallel groups and sequential dependencies (Medium/High only)
|
||||
risks: string[], // Potential issues and mitigation strategies (Medium/High only)
|
||||
tasks: string[], // 3-10 tasks with file paths
|
||||
estimated_time: string, // Total implementation time estimate
|
||||
recommended_execution: string, // "Agent" (Low) or "Codex" (Medium/High)
|
||||
complexity: string // "Low" | "Medium" | "High"
|
||||
@@ -348,10 +337,6 @@ First, output the complete plan to the user as regular text:
|
||||
**Task Breakdown**:
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
|
||||
${planObject.dependencies ? `\n**Dependencies**:\n${planObject.dependencies.join('\n')}` : ''}
|
||||
|
||||
${planObject.risks ? `\n**Risks**:\n${planObject.risks.join('\n')}` : ''}
|
||||
|
||||
**Complexity**: ${planObject.complexity}
|
||||
**Estimated Time**: ${planObject.estimated_time}
|
||||
**Recommended Execution**: ${planObject.recommended_execution}
|
||||
@@ -362,7 +347,7 @@ ${planObject.risks ? `\n**Risks**:\n${planObject.risks.join('\n')}` : ''}
|
||||
After displaying the plan, collect three inputs via AskUserQuestion:
|
||||
|
||||
**Operations**:
|
||||
- Collect three inputs:
|
||||
- Collect four inputs:
|
||||
1. Task confirmation (multi-select: Allow/Modify/Cancel + optional supplements via "Other")
|
||||
2. Execution method (single-select: Agent/Codex/Auto)
|
||||
- Agent: Execute with @code-developer
|
||||
@@ -372,12 +357,16 @@ After displaying the plan, collect three inputs via AskUserQuestion:
|
||||
- Gemini Review: Use gemini CLI for code analysis
|
||||
- Agent Review: Use @code-reviewer agent
|
||||
- Other: Specify custom tool (e.g., "qwen", "codex") via text input
|
||||
4. Task JSON output (single-select: Yes/No)
|
||||
- Yes: Export plan to task JSON file for reuse or documentation
|
||||
- No: Keep plan in-memory only
|
||||
- Support plan supplements and custom tool specification via "Other" input
|
||||
|
||||
**Three Questions in Single AskUserQuestion Call**:
|
||||
**Four Questions in Single AskUserQuestion Call**:
|
||||
- Question 1: Task confirmation (multi-select: Allow/Modify/Cancel)
|
||||
- Question 2: Execution method selection (single-select: Agent/Codex/Auto)
|
||||
- Question 3: Code review tool selection (single-select: Skip/Gemini/Agent, custom via "Other")
|
||||
- Question 4: Task JSON output (single-select: Yes/No)
|
||||
|
||||
**AskUserQuestion Call**:
|
||||
```javascript
|
||||
@@ -418,6 +407,17 @@ Confirm this plan? (Multi-select enabled - you can select multiple options and a
|
||||
{ label: "Agent Review", description: "Review with @code-reviewer agent" },
|
||||
{ label: "Skip", description: "No review needed" }
|
||||
]
|
||||
},
|
||||
{
|
||||
question: `Export plan to task JSON file?
|
||||
|
||||
This allows you to reuse the plan or use it with lite-execute later.`,
|
||||
header: "Export JSON",
|
||||
multiSelect: false,
|
||||
options: [
|
||||
{ label: "Yes", description: "Export plan to JSON file (recommended for complex tasks)" },
|
||||
{ label: "No", description: "Keep plan in-memory only" }
|
||||
]
|
||||
}
|
||||
]
|
||||
})
|
||||
@@ -442,6 +442,12 @@ Code Review Selection (after execution):
|
||||
├─ Gemini Review → Run gemini code analysis (gemini-2.5-pro)
|
||||
├─ Agent Review → Current Claude agent review
|
||||
└─ Other → Specify custom tool (e.g., "qwen", "codex") via text input
|
||||
|
||||
Task JSON Export:
|
||||
├─ Yes → Export plan to JSON file before execution
|
||||
│ Format: .workflow/lite-plans/plan-{timestamp}.json
|
||||
│ Contains: planObject + explorationContext + clarificationContext
|
||||
└─ No → Keep plan in-memory only, no file export
|
||||
```
|
||||
|
||||
**Progress Tracking**:
|
||||
@@ -452,303 +458,120 @@ Code Review Selection (after execution):
|
||||
|
||||
---
|
||||
|
||||
### Phase 5: Execution & Progress Tracking
|
||||
### Phase 5: Dispatch to Execution
|
||||
|
||||
**Operations**:
|
||||
- Create TodoWrite execution call list (grouped tasks by dependencies)
|
||||
- Launch selected execution method (agent or CLI)
|
||||
- Track execution call progress with real-time TodoWrite updates (not individual tasks)
|
||||
- Display execution status to user
|
||||
- Export plan to task JSON file (if user selected "Yes")
|
||||
- Store execution context in memory variable
|
||||
- Call lite-execute command with --in-memory flag
|
||||
- Execution tracking delegated to lite-execute
|
||||
|
||||
**Step 5.1: Create TodoWrite Execution List**
|
||||
**Step 5.1: Export Task JSON (Optional)**
|
||||
|
||||
**Skip Condition**: Only run if user selected "Yes" for Task JSON Export in Phase 4
|
||||
|
||||
**Operations**:
|
||||
- Create `.workflow/lite-plans/` directory if not exists
|
||||
- Generate timestamp-based filename
|
||||
- Export complete plan context to JSON file
|
||||
|
||||
**Before execution starts**, initialize tracking variables and create execution call list:
|
||||
```javascript
|
||||
// Initialize result tracking for multi-execution scenarios
|
||||
previousExecutionResults = []
|
||||
```
|
||||
// Only execute if userSelection.export_task_json === "Yes"
|
||||
if (userSelection.export_task_json === "Yes") {
|
||||
const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
|
||||
const filename = `.workflow/lite-plans/plan-${timestamp}.json`
|
||||
|
||||
Create execution call list (not individual tasks):
|
||||
```javascript
|
||||
// Group tasks based on dependencies and execution strategy
|
||||
// Each execution call handles multiple related tasks
|
||||
executionCalls = groupTasksByExecution(planObject.tasks, planObject.dependencies).map((call, index) => ({
|
||||
...call,
|
||||
id: `[${call.method}-${index+1}]` // Store ID for result collection
|
||||
}))
|
||||
const planExport = {
|
||||
metadata: {
|
||||
created_at: new Date().toISOString(),
|
||||
task_description: original_task_description,
|
||||
complexity: planObject.complexity,
|
||||
estimated_time: planObject.estimated_time
|
||||
},
|
||||
plan: planObject,
|
||||
exploration: explorationContext || null,
|
||||
clarifications: clarificationContext || null
|
||||
}
|
||||
|
||||
TodoWrite({
|
||||
todos: executionCalls.map(call => ({
|
||||
content: `${call.id} (${call.taskSummary})`,
|
||||
status: "pending",
|
||||
activeForm: `Executing ${call.id} (${call.taskSummary})`
|
||||
}))
|
||||
})
|
||||
```
|
||||
Write(filename, JSON.stringify(planExport, null, 2))
|
||||
|
||||
**Example Execution List**:
|
||||
```
|
||||
[ ] [Agent-1] (Implement auth service + Create JWT utilities)
|
||||
[ ] [Agent-2] (Add middleware + Update routes)
|
||||
[ ] [Codex-1] (Add integration tests for auth flow)
|
||||
```
|
||||
|
||||
**Task Grouping Logic**:
|
||||
- Parallel tasks → Single execution call
|
||||
- Sequential tasks → Separate execution calls
|
||||
- Complex tasks → May split into multiple calls based on file scope
|
||||
|
||||
**Step 5.2: Launch Execution**
|
||||
|
||||
**IMPORTANT**: CLI execution MUST run in foreground (no background execution)
|
||||
|
||||
**Execution Loop**:
|
||||
```javascript
|
||||
// Execute each call in the execution list sequentially
|
||||
for (currentIndex = 0; currentIndex < executionCalls.length; currentIndex++) {
|
||||
const currentCall = executionCalls[currentIndex]
|
||||
|
||||
// Update TodoWrite: mark current call as in_progress
|
||||
// Launch execution with previousExecutionResults context
|
||||
// After completion, collect result and add to previousExecutionResults
|
||||
// Update TodoWrite: mark current call as completed
|
||||
// Display export confirmation to user
|
||||
console.log(`Plan exported to: ${filename}`)
|
||||
console.log(`You can reuse this plan with: /workflow:lite-execute ${filename}`)
|
||||
}
|
||||
```
|
||||
|
||||
Based on user selection in Phase 4, execute appropriate method:
|
||||
- **Agent**: Launch @code-developer agent
|
||||
- **Codex**: Execute with codex CLI tool
|
||||
- **Auto**: Automatic selection based on complexity
|
||||
- Low complexity → Agent execution
|
||||
- Medium/High complexity → Codex execution
|
||||
|
||||
#### Option A: Direct Execution with Agent
|
||||
|
||||
**Operations**:
|
||||
- Launch @code-developer agent with full plan context
|
||||
- Agent receives exploration findings, clarifications, and task breakdown
|
||||
- **For subsequent executions**: Include previous execution results to maintain context continuity
|
||||
- Agent call format:
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="code-developer",
|
||||
description="Implement planned tasks with progress tracking",
|
||||
prompt=`
|
||||
Implement the following tasks with TodoWrite progress updates:
|
||||
|
||||
Summary: ${planObject.summary}
|
||||
|
||||
Task Breakdown:
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
|
||||
${planObject.dependencies ? `\nTask Dependencies:\n${planObject.dependencies.join('\n')}` : ''}
|
||||
|
||||
${previousExecutionResults ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
Tasks handled: ${result.tasksSummary}
|
||||
Completion status: ${result.completionSummary}
|
||||
Key outputs: ${result.keyOutputs || 'See git diff for details'}
|
||||
${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
`).join('\n---\n')}` : ''}
|
||||
|
||||
Implementation Approach:
|
||||
${planObject.approach}
|
||||
|
||||
Code Context:
|
||||
${explorationContext || "No exploration performed"}
|
||||
|
||||
${clarificationContext ? `\nClarifications:\n${clarificationContext}` : ''}
|
||||
|
||||
${planObject.risks ? `\nRisks to Consider:\n${planObject.risks.join('\n')}` : ''}
|
||||
|
||||
IMPORTANT Instructions:
|
||||
- **Context Continuity**: Review previous execution results above to understand what's already completed
|
||||
- **Build on Previous Work**: Ensure your work integrates with previously completed tasks
|
||||
- **Avoid Duplication**: Don't redo tasks that are already completed in previous executions
|
||||
- **Parallel Execution**: Identify independent tasks from dependencies field and execute them in parallel using multiple tool calls in a single message
|
||||
- **Dependency Respect**: Sequential tasks must wait for dependent tasks to complete before starting
|
||||
- **Intelligent Grouping**: Analyze task dependencies to determine parallel groups - tasks with no file conflicts or logical dependencies can run simultaneously
|
||||
- Test functionality as you go
|
||||
- Handle risks proactively
|
||||
|
||||
Note: This agent call handles multiple tasks. TodoWrite tracking is managed at call level by orchestrator.
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Agent Responsibilities**:
|
||||
- Each agent call handles multiple tasks (grouped by dependencies)
|
||||
- Agent updates TodoWrite at **call level** (not individual task level)
|
||||
- Mark execution call as in_progress when starting, completed when all assigned tasks finished
|
||||
|
||||
**Execution Result Collection** (for multi-execution scenarios):
|
||||
- After each execution completes, collect result summary:
|
||||
```javascript
|
||||
executionResult = {
|
||||
executionId: executionCalls[currentIndex].id, // e.g., "[Agent-1]", "[Codex-1]" from Step 5.1 TodoWrite list
|
||||
status: "completed" or "partial" or "failed",
|
||||
tasksSummary: "Brief description of tasks handled",
|
||||
completionSummary: "What was completed",
|
||||
keyOutputs: "Files created/modified, key changes",
|
||||
notes: "Any important context for next execution"
|
||||
}
|
||||
previousExecutionResults.push(executionResult)
|
||||
```
|
||||
- The `executionId` comes from the execution call ID created in Step 5.1 (format: `[Method-Index]`)
|
||||
- Pass `previousExecutionResults` to subsequent executions for context continuity
|
||||
|
||||
#### Option B: CLI Execution (Codex)
|
||||
|
||||
**Operations**:
|
||||
- Build codex CLI command with comprehensive context
|
||||
- **For subsequent executions**: Include previous execution results summary
|
||||
- Execute codex tool with write permissions
|
||||
- Monitor CLI output and update TodoWrite based on progress indicators
|
||||
- Parse CLI completion signals to mark tasks as done
|
||||
|
||||
**Command Format (Codex)** - Single execution with full context:
|
||||
```bash
|
||||
codex --full-auto exec "
|
||||
TASK: ${planObject.summary}
|
||||
|
||||
## Task Breakdown
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
|
||||
${planObject.dependencies ? `\n## Task Dependencies\n${planObject.dependencies.join('\n')}` : ''}
|
||||
|
||||
${previousExecutionResults ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
Tasks: ${result.tasksSummary}
|
||||
Status: ${result.completionSummary}
|
||||
Outputs: ${result.keyOutputs || 'See git diff'}
|
||||
${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
`).join('\n---\n')}
|
||||
|
||||
IMPORTANT: Review previous results above. Build on completed work. Avoid duplication.
|
||||
` : ''}
|
||||
|
||||
## Implementation Approach
|
||||
${planObject.approach}
|
||||
|
||||
## Code Context from Exploration
|
||||
${explorationContext ? `
|
||||
Project Structure: ${explorationContext.project_structure || 'Standard structure'}
|
||||
Relevant Files: ${explorationContext.relevant_files?.join(', ') || 'TBD'}
|
||||
Current Patterns: ${explorationContext.patterns || 'Follow existing conventions'}
|
||||
Integration Points: ${explorationContext.dependencies || 'None specified'}
|
||||
Constraints: ${explorationContext.constraints || 'None'}
|
||||
` : 'No prior exploration - analyze codebase as needed'}
|
||||
|
||||
${clarificationContext ? `\n## User Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `${q}: ${a}`).join('\n')}` : ''}
|
||||
|
||||
${planObject.risks ? `\n## Risks to Handle\n${planObject.risks.join('\n')}` : ''}
|
||||
|
||||
## Execution Instructions
|
||||
- Review previous execution results for context continuity
|
||||
- Build on previous work, don't duplicate completed tasks
|
||||
- Complete all assigned tasks in single execution
|
||||
- Test functionality as you implement
|
||||
- Handle identified risks proactively
|
||||
|
||||
Complexity: ${planObject.complexity}
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
**Export File Format**:
|
||||
```json
|
||||
{
|
||||
"metadata": {
|
||||
"created_at": "2025-01-17T10:30:00.000Z",
|
||||
"task_description": "Original task description",
|
||||
"complexity": "Medium",
|
||||
"estimated_time": "30 minutes"
|
||||
},
|
||||
"plan": {
|
||||
"summary": "...",
|
||||
"approach": "...",
|
||||
"tasks": [...],
|
||||
"recommended_execution": "Agent|Codex",
|
||||
"complexity": "Low|Medium|High"
|
||||
},
|
||||
"exploration": {...} or null,
|
||||
"clarifications": {...} or null
|
||||
}
|
||||
```
|
||||
|
||||
**Note**: Avoid `resume --last` unless task is exceptionally complex or hits timeout. Optimize task breakdown for full completion in single execution.
|
||||
**Step 5.2: Store Execution Context**
|
||||
|
||||
**Execution Result Collection** (for multi-execution scenarios):
|
||||
- After CLI execution completes, analyze output and collect result summary
|
||||
- Extract key information: modified files, completion status, important notes
|
||||
- Store in `previousExecutionResults` array for subsequent executions
|
||||
- Result structure same as Agent execution (see Option A above)
|
||||
|
||||
**Execution with Progress Tracking**:
|
||||
Create execution context variable with all necessary information:
|
||||
```javascript
|
||||
// Launch CLI in foreground (NOT background)
|
||||
bash_result = Bash(
|
||||
command=cli_command,
|
||||
timeout=600000 // 10 minutes
|
||||
)
|
||||
|
||||
// Update TodoWrite when CLI execution call completes
|
||||
// Mark execution call (e.g., "[Codex-1]") as completed when CLI finishes
|
||||
// One CLI call may handle multiple tasks - track at call level, not task level
|
||||
// Create execution context for lite-execute
|
||||
executionContext = {
|
||||
planObject: planObject, // From Phase 3
|
||||
explorationContext: explorationContext || null, // From Phase 1
|
||||
clarificationContext: clarificationContext || null, // From Phase 2
|
||||
executionMethod: userSelection.execution_method, // From Phase 4
|
||||
codeReviewTool: userSelection.code_review_tool // From Phase 4
|
||||
}
|
||||
```
|
||||
|
||||
**CLI Progress Monitoring**:
|
||||
- Monitor CLI execution at **call level** (not individual task level)
|
||||
- Update TodoWrite when CLI execution call completes (all assigned tasks done)
|
||||
- Provide real-time visibility of execution call progress to user
|
||||
|
||||
**Step 5.3: Track Execution Progress**
|
||||
|
||||
Track **agent/CLI call level** (not individual tasks):
|
||||
|
||||
**Real-time TodoWrite Updates**:
|
||||
**Context Structure**:
|
||||
```javascript
|
||||
// When execution call starts
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "[Agent-1] (Implement auth service + Create JWT utilities)", status: "in_progress", activeForm: "Executing [Agent-1] (Implement auth service + Create JWT utilities)" },
|
||||
{ content: "[Agent-2] (Add middleware + Update routes)", status: "pending", activeForm: "Executing [Agent-2] (Add middleware + Update routes)" },
|
||||
{ content: "[Codex-1] (Add integration tests)", status: "pending", activeForm: "Executing [Codex-1] (Add integration tests)" }
|
||||
]
|
||||
})
|
||||
|
||||
// When execution call completes
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "[Agent-1] (Implement auth service + Create JWT utilities)", status: "completed", activeForm: "Executing [Agent-1] (Implement auth service + Create JWT utilities)" },
|
||||
{ content: "[Agent-2] (Add middleware + Update routes)", status: "in_progress", activeForm: "Executing [Agent-2] (Add middleware + Update routes)" },
|
||||
{ content: "[Codex-1] (Add integration tests)", status: "pending", activeForm: "Executing [Codex-1] (Add integration tests)" }
|
||||
]
|
||||
})
|
||||
{
|
||||
planObject: {
|
||||
summary: string,
|
||||
approach: string,
|
||||
tasks: string[],
|
||||
estimated_time: string,
|
||||
recommended_execution: string,
|
||||
complexity: string
|
||||
},
|
||||
explorationContext: {...} | null,
|
||||
clarificationContext: {...} | null,
|
||||
executionMethod: "Agent" | "Codex" | "Auto",
|
||||
codeReviewTool: "Skip" | "Gemini Review" | "Agent Review" | string
|
||||
}
|
||||
```
|
||||
|
||||
**User Visibility**:
|
||||
- User sees **execution call progress** (not individual task progress)
|
||||
- Current execution highlighted as "in_progress" (e.g., "[Agent-1] (Task A + Task B)")
|
||||
- Completed executions marked with checkmark
|
||||
- Pending executions remain unchecked
|
||||
- Each execution shows **task summary** for context
|
||||
**Step 5.3: Call lite-execute**
|
||||
|
||||
Dispatch execution to lite-execute command:
|
||||
```javascript
|
||||
SlashCommand(command="/workflow:lite-execute --in-memory")
|
||||
```
|
||||
|
||||
**Execution Handoff**:
|
||||
- lite-execute reads executionContext variable
|
||||
- All execution logic (TodoWrite tracking, Agent/Codex calls, code review) handled by lite-execute
|
||||
- lite-plan completes after successful handoff
|
||||
|
||||
**Progress Tracking**:
|
||||
- Track agent/CLI call completion (not task completion)
|
||||
- One execution call may handle multiple tasks simultaneously
|
||||
- Mark Phase 5 as completed when all execution calls done
|
||||
- Mark Phase 5 as completed
|
||||
- Execution tracking handed over to lite-execute
|
||||
- User sees execution progress from lite-execute TodoWrite updates
|
||||
|
||||
**Step 5.4: Code Review (Optional)**
|
||||
|
||||
**Skip Condition**: Only run if user selected review tool in Phase 4 (not "Skip")
|
||||
|
||||
**Operations**:
|
||||
- If "Agent Review": Current agent performs direct code review analysis
|
||||
- If "Gemini Review": Execute gemini CLI with code review analysis prompt
|
||||
- If "Other" (custom tool specified): Execute specified CLI tool (e.g., qwen, codex)
|
||||
- Review all modified files from execution
|
||||
- Generate quality assessment and improvement recommendations
|
||||
|
||||
**Command Format**:
|
||||
```bash
|
||||
# Agent Review: Direct agent review (no CLI command needed)
|
||||
# Uses analysis prompt and TodoWrite tools directly
|
||||
|
||||
# Gemini Review / Custom Tool (qwen, codex, etc.): Execute analysis command
|
||||
{selected_tool} -p "
|
||||
PURPOSE: Code review for implemented changes
|
||||
TASK: • Analyze code quality • Identify potential issues • Suggest improvements
|
||||
MODE: analysis
|
||||
CONTEXT: @**/* | Memory: Review changes from lite-plan execution
|
||||
EXPECTED: Quality assessment with actionable recommendations
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on recent changes | analysis=READ-ONLY
|
||||
"
|
||||
```
|
||||
|
||||
**Expected Duration**: Varies by task complexity and execution method
|
||||
- Low complexity: 5-15 minutes
|
||||
- Medium complexity: 15-45 minutes
|
||||
- High complexity: 45-120 minutes
|
||||
- Code review (if enabled): +2-5 minutes
|
||||
**Expected Duration**: < 1 second (dispatch only, actual execution in lite-execute)
|
||||
|
||||
---
|
||||
|
||||
@@ -852,8 +675,6 @@ RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-q
|
||||
| Phase 3 Planning Timeout | Planning takes > 90 seconds | Generate simplified direct plan, mark as "Quick Plan", continue to Phase 4 with reduced detail |
|
||||
| Phase 4 Confirmation Timeout | User no response > 5 minutes | Save plan context to temporary var, display resume instructions, exit gracefully |
|
||||
| Phase 4 Modification Loop | User requests modify > 3 times | Suggest breaking task into smaller pieces or using /workflow:plan for comprehensive planning |
|
||||
| Phase 5 Codex Unavailable | Codex tool not installed | Show installation instructions, offer to re-select (Agent execution or Auto mode) |
|
||||
| Phase 5 Execution Failure | Agent/Codex crashes or errors | Display error details, save partial progress from TodoWrite, suggest manual recovery or retry |
|
||||
|
||||
## Input/Output
|
||||
|
||||
|
||||
Reference in New Issue
Block a user