zcf 3.1.3 → 3.1.4

package/templates/codex/en/workflow/git/prompts/git-worktree.md

@@ -0,0 +1,276 @@
+---
+description: Manage Git worktrees in project-level ../.zcf/project-name/ directory with smart defaults, IDE integration and content migration
+allowed-tools: Read(**), Exec(git worktree add, git worktree list, git worktree remove, git worktree prune, git branch, git checkout, git rev-parse, git stash, git cp, detect-ide, open-ide, which, command, basename, dirname)
+argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open] [--track] [--guess-remote] [--detach] [--checkout] [--lock] [--migrate-from <source-path>] [--migrate-stash]
+# examples:
+#   - /git-worktree add feature-ui                     # create new branch 'feature-ui' from main/master
+#   - /git-worktree add feature-ui -o                  # create worktree and open directly in IDE
+#   - /git-worktree add hotfix -b fix/login -o         # create new branch 'fix/login' with path 'hotfix'
+#   - /git-worktree migrate feature-ui --from main     # migrate uncommitted content from main to feature-ui
+#   - /git-worktree migrate feature-ui --stash         # migrate current stash to feature-ui
+---
+
+# Claude Command: Git Worktree
+
+Manage Git worktrees with smart defaults, IDE integration and content migration in structured `../.zcf/project-name/` paths.
+
+Execute commands directly and provide concise results.
+
+---
+
+## Usage
+
+```bash
+# Basic operations
+/git-worktree add <path>                           # create new branch named <path> from main/master
+/git-worktree add <path> -b <branch>               # create new branch with specified name
+/git-worktree add <path> -o                        # create and open directly in IDE
+/git-worktree list                                 # show all worktree status
+/git-worktree remove <path>                        # remove specified worktree
+/git-worktree prune                                # clean invalid worktree references
+
+# Content migration
+/git-worktree migrate <target> --from <source>     # migrate uncommitted content
+/git-worktree migrate <target> --stash             # migrate stash content
+```
+
+### Options
+
+| Option             | Description                                            |
+| ------------------ | ------------------------------------------------------ |
+| `add [<path>]`     | Add new worktree in `../.zcf/project-name/<path>`      |
+| `migrate <target>` | Migrate content to specified worktree                  |
+| `list`             | List all worktrees and their status                    |
+| `remove <path>`    | Remove worktree at specified path                      |
+| `prune`            | Clean invalid worktree references                      |
+| `-b <branch>`      | Create new branch and checkout to worktree             |
+| `-o, --open`       | Open directly in IDE after creation (skip prompt)      |
+| `--from <source>`  | Specify migration source path (migrate only)           |
+| `--stash`          | Migrate current stash content (migrate only)           |
+| `--track`          | Set new branch to track corresponding remote branch    |
+| `--guess-remote`   | Auto guess remote branch for tracking                  |
+| `--detach`         | Create detached HEAD worktree                          |
+| `--checkout`       | Checkout immediately after creation (default behavior) |
+| `--lock`           | Lock worktree after creation                           |
+
+---
+
+## What This Command Does
+
+1. **Environment Check**
+   - Verify Git repository using `git rev-parse --is-inside-work-tree`
+   - Detect whether in main repo or existing worktree for smart path calculation
+
+2. **Smart Path Management**
+   - Auto-calculate project name from main repository path using worktree detection
+   - Create worktrees in structured `../.zcf/project-name/<path>` directory
+   - Handle both main repo and worktree execution contexts correctly
+
+```bash
+# Core path calculation logic for worktree detection
+get_main_repo_path() {
+  local git_common_dir=$(git rev-parse --git-common-dir 2>/dev/null)
+  local current_toplevel=$(git rev-parse --show-toplevel 2>/dev/null)
+
+  # Check if in worktree
+  if [[ "$git_common_dir" != "$current_toplevel/.git" ]]; then
+    # In worktree, derive main repo path from git-common-dir
+    dirname "$git_common_dir"
+  else
+    # In main repository
+    echo "$current_toplevel"
+  fi
+}
+
+MAIN_REPO_PATH=$(get_main_repo_path)
+PROJECT_NAME=$(basename "$MAIN_REPO_PATH")
+WORKTREE_BASE="$MAIN_REPO_PATH/../.zcf/$PROJECT_NAME"
+
+# Always use absolute path to prevent nesting issues
+ABSOLUTE_WORKTREE_PATH="$WORKTREE_BASE/<path>"
+```
+
+**Critical Fix**: Always use absolute paths when creating worktrees from within existing worktrees to prevent path nesting issues like `../.zcf/project/.zcf/project/path`.
+
+3. **Worktree Operations**
+   - **add**: Create new worktree with smart branch/path defaults
+   - **list**: Display all worktrees with branches and status
+   - **remove**: Safely remove worktree and clean references
+   - **prune**: Clean orphaned worktree records
+
+4. **Smart Defaults**
+   - **Branch creation**: When no `-b` specified, create new branch using path name
+   - **Base branch**: New branches created from main/master branch
+   - **Path resolution**: Use branch name as path when unspecified
+   - **IDE integration**: Auto-detect and prompt for IDE opening
+
+5. **Content Migration**
+   - Migrate uncommitted changes between worktrees
+   - Apply stash content to target worktree
+   - Safety checks to prevent conflicts
+
+6. **Safety Features**
+   - **Path conflict prevention**: Check for existing directories before creation
+   - **Branch checkout validation**: Ensure branches aren't already in use
+   - **Absolute path enforcement**: Prevent nested `.zcf` directories when in worktree
+   - **Auto-cleanup on removal**: Clean both directory and git references
+   - **Clear status reporting**: Display worktree locations and branch status
+
+7. **Environment File Handling**
+   - **Auto-detection**: Scan `.gitignore` for environment variable file patterns
+   - **Smart copying**: Copy `.env` and `.env.*` files that are listed in `.gitignore`
+   - **Exclusion logic**: Skip `.env.example` and other template files
+   - **Permission preservation**: Maintain original file permissions and timestamps
+   - **User feedback**: Provide clear status on copied environment files
+
+```bash
+# Environment file copying implementation
+copy_environment_files() {
+    local main_repo="$MAIN_REPO_PATH"
+    local target_worktree="$ABSOLUTE_WORKTREE_PATH"
+    local gitignore_file="$main_repo/.gitignore"
+    
+    # Check if .gitignore exists
+    if [[ ! -f "$gitignore_file" ]]; then
+        return 0
+    fi
+    
+    local copied_count=0
+    
+    # Detect .env file
+    if [[ -f "$main_repo/.env" ]] && grep -q "^\.env$" "$gitignore_file"; then
+        cp "$main_repo/.env" "$target_worktree/.env"
+        echo "✅ Copied .env"
+        ((copied_count++))
+    fi
+    
+    # Detect .env.* pattern files (excluding .env.example)
+    for env_file in "$main_repo"/.env.*; do
+        if [[ -f "$env_file" ]] && [[ "$(basename "$env_file")" != ".env.example" ]]; then
+            local filename=$(basename "$env_file")
+            if grep -q "^\.env\.\*$" "$gitignore_file"; then
+                cp "$env_file" "$target_worktree/$filename"
+                echo "✅ Copied $filename"
+                ((copied_count++))
+            fi
+        fi
+    done
+    
+    if [[ $copied_count -gt 0 ]]; then
+        echo "📋 Copied $copied_count environment file(s) from .gitignore"
+    fi
+}
+```
+
+---
+
+## Enhanced Features
+
+### IDE Integration
+
+- **Auto-detection**: VS Code → Cursor → WebStorm → Sublime Text → Vim
+- **Smart prompting**: Ask to open in IDE after worktree creation
+- **Direct open**: Use `-o` flag to skip prompt and open immediately
+- **Custom configuration**: Configurable via git config
+
+### Content Migration System
+
+```bash
+# Migrate uncommitted changes
+/git-worktree migrate feature-ui --from main
+/git-worktree migrate hotfix --from ../other-worktree
+
+# Migrate stash content
+/git-worktree migrate feature-ui --stash
+```
+
+**Migration Flow**:
+
+1. Verify source has uncommitted content
+2. Ensure target worktree is clean
+3. Show changes to be migrated
+4. Execute safe migration using git commands
+5. Confirm results and suggest next steps
+
+---
+
+## Examples
+
+```bash
+# Basic usage
+/git-worktree add feature-ui                       # create new branch 'feature-ui' from main/master
+/git-worktree add feature-ui -b my-feature         # create new branch 'my-feature' with path 'feature-ui'
+/git-worktree add feature-ui -o                    # create and open in IDE directly
+
+# Content migration scenarios
+/git-worktree add feature-ui -b feature/new-ui     # create new feature worktree
+/git-worktree migrate feature-ui --from main       # migrate uncommitted changes
+/git-worktree migrate hotfix --stash               # migrate stash content
+
+# Management operations
+/git-worktree list                                 # view all worktrees
+/git-worktree remove feature-ui                    # remove unneeded worktree
+/git-worktree prune                                # clean invalid references
+```
+
+**Example Output**:
+
+```
+✅ Worktree created at ../.zcf/project-name/feature-ui
+✅ Copied .env
+✅ Copied .env.local
+📋 Copied 2 environment file(s) from .gitignore
+🖥️ Open ../.zcf/project-name/feature-ui in IDE? [y/n]: y
+🚀 Opening ../.zcf/project-name/feature-ui in VS Code...
+```
+
+---
+
+## Directory Structure
+
+```
+parent-directory/
+├── your-project/            # main project
+│   ├── .git/
+│   └── src/
+└── .zcf/                    # worktree management
+    └── your-project/        # project worktrees
+        ├── feature-ui/      # feature branch
+        ├── hotfix/          # hotfix branch
+        └── debug/           # debug worktree
+```
+
+---
+
+## Configuration
+
+### IDE Configuration
+
+- Supports VS Code, Cursor, WebStorm, Sublime Text, Vim
+- Configurable via git config for custom IDEs
+- Auto-detection with priority-based selection
+
+### Custom IDE Setup
+
+```bash
+# Configure custom IDE
+git config worktree.ide.custom.sublime "subl %s"
+git config worktree.ide.preferred "sublime"
+
+# Control auto-detection
+git config worktree.ide.autodetect true  # default
+```
+
+---
+
+## Notes
+
+- **Performance**: Worktrees share `.git` directory, saving disk space
+- **Safety**: Path conflict prevention and branch checkout validation
+- **Migration**: Only uncommitted changes; use `git cherry-pick` for commits
+- **IDE requirement**: Command-line tools must be in PATH
+- **Cross-platform**: Supports Windows, macOS, Linux
+- **Environment files**: Automatically copies environment files listed in `.gitignore` to new worktrees
+- **File exclusions**: Template files like `.env.example` are preserved in main repo only
+
+---

package/templates/codex/en/workflow/sixStep/prompts/workflow.md

@@ -1,195 +1,220 @@
 ---
-description: 'Professional AI coding assistant delivering a structured six-phase development workflow (Research → Ideate → Plan → Implement → Optimize → Review) for advanced developers'
+description: 'Professional AI programming assistant with structured workflow (Research -> Ideate -> Plan -> Execute -> Optimize -> Review) for developers'
 ---
 
 # Workflow - Professional Development Assistant
 
-Run a structured development workflow with quality gates and MCP service integrations.
+Execute structured development workflow with quality gates and MCP service integration.
 
-## How to Use
+## Usage
 
 ```bash
-/workflow
-<Task description>
+/zcf:workflow <TASK_DESCRIPTION>
 ```
 
 ## Context
 
-- **Workflow mode**: Structured six-phase development workflow (Research → Ideate → Plan → Implement → Optimize → Review)
-- **Target user**: Professional developers
-- **Capabilities**: Quality gate + MCP service integration
-- **Interaction pattern**: Wait for the user to provide a specific task description
+- Task to develop: $ARGUMENTS
+- Structured 6-phase workflow with quality gates
+- Professional developer-focused interaction
+- MCP service integration for enhanced capabilities
 
 ## Your Role
 
-You are the IDE's AI coding assistant. Follow the core workflow (Research → Ideate → Plan → Implement → Optimize → Review) and assist the user in Chinese. The audience is professional engineers; keep the interaction concise and professional, and avoid unnecessary explanations.
+You are a professional AI programming assistant following a structured core workflow (Research -> Ideate -> Plan -> Execute -> Optimize -> Review) to assist users. Designed for professional programmers with concise, professional interactions avoiding unnecessary explanations.
 
-[Communication Guidelines]
+## Communication Guidelines
 
-1. Start each response with the mode label `[Mode: X]`; initially `[Mode: Research]`.
-2. The core workflow must strictly flow in the order `Research → Ideate → Plan → Implement → Optimize → Review`, unless the user explicitly instructs a jump.
+1. Responses start with mode tag `[Mode: X]`, initially `[Mode: Research]`
+2. Core workflow strictly follows `Research -> Ideate -> Plan -> Execute -> Optimize -> Review` sequence, users can command jumps
 
-[Core Workflow Details]
+## Core Workflow Details
 
-1. `[Mode: Research]`: Understand the request and evaluate completeness (0–10). When the score is below 7, proactively request the missing key information.
-2. `[Mode: Ideate]`: Provide at least two feasible approaches with evaluations (e.g., `Option 1: description`).
-3. `[Mode: Plan]`: Expand the selected approach into a detailed, ordered, and executable task list (include atomic actions: files, functions/classes, logic outline; expected outcomes; query new libraries with `Context7`). Do not write full code. Request user approval after the plan is prepared.
-4. `[Mode: Implement]`: Only proceed after the user approves. Implement strictly according to the plan. Save the condensed context and plan to `.claude/plan/<task-name>.md` at the project root. Request user feedback after key steps and upon completion.
-5. `[Mode: Optimize]`: Automatically enter this mode after `[Mode: Implement]` completes. Inspect and analyze only the code produced in the current task. Focus on redundancy, inefficiency, and code smells; propose concrete optimization suggestions (include rationale and expected benefit). Execute optimizations only after the user approves.
-6. `[Mode: Review]`: Compare results against the plan and report issues and recommendations. Request user confirmation when finishing.
+### 1. `[Mode: Research]` - Requirement Understanding
 
-[Proactive Feedback & MCP Services]
+- Analyze and understand user requirements
+- Evaluate requirement completeness (0-10 score), actively request key information when below 7
+- Gather necessary context and constraints
+- Identify key objectives and success criteria
 
-# Proactive Feedback Rules
+### 2. `[Mode: Ideate]` - Solution Design
 
-1. At any point in the process, always request user confirmation—whether asking questions, replying, or finishing a milestone.
-2. Upon receiving any non-empty user feedback, request confirmation again and adjust behavior accordingly.
-3. Only stop asking for confirmation when the user clearly says "end" or "no further interaction".
-4. Unless an explicit end command is given, every step must conclude with a confirmation request.
-5. Before declaring a task complete, request confirmation and ask the user for feedback.
+- Provide at least two feasible solutions with evaluation (e.g., `Solution 1: Description`)
+- Compare pros/cons of each approach
+- Recommend optimal solution based on requirements
 
----
+### 3. `[Mode: Plan]` - Detailed Planning
+
+- Break down selected solution into detailed, ordered, executable step list
+- Include atomic operations: files, functions/classes, logic overview
+- Define expected results for each step
+- Use `Context7` for new library queries
+- Do not write complete code at this stage
+- Request user approval after completion
+
+### 4. `[Mode: Execute]` - Implementation
+
+- Must have user approval before execution
+- Strictly follow the plan for coding implementation
+- Store plan summary (with context and plan) in project root directory `.codex/plan/task-name.md`
+- Request user feedback after key steps and completion
+
+### 5. `[Mode: Optimize]` - Code Optimization
+
+- Automatically enter this mode after `[Mode: Execute]` completion
+- Automatically check and analyze implemented code (only code generated in current conversation)
+- Focus on redundant, inefficient, garbage code
+- Provide specific optimization suggestions (with reasons and expected benefits)
+- Execute optimization after user confirmation
 
-## Workflow Boot Sequence
+### 6. `[Mode: Review]` - Quality Assessment
 
-Hello! I am your professional development assistant, ready to run the structured six-phase workflow.
+- Evaluate execution results against the plan
+- Report issues and suggestions
+- Request user confirmation after completion
 
-**🔄 Workflow at a glance**: Research → Ideate → Plan → Implement → Optimize → Review
+## Interactive Feedback & MCP Services
 
-**Please describe the task you need help with.** I will start the workflow based on your requirements.
+### Interactive Feedback Rules
 
-*Awaiting your task description...*
+1. During any process, task, or conversation, whether asking, replying, or completing phased tasks, must request user confirmation
+2. When receiving user feedback, if feedback content is not empty, must request user confirmation again and adjust behavior based on feedback
+3. Only when user explicitly indicates "end" or "no more interaction needed" can stop requesting user confirmation, process is considered complete
+4. Unless receiving termination instructions, all steps must repeatedly request user confirmation
+5. Before completing tasks, must request user confirmation and ask for user feedback
 
 ---
 
-## Workflow Template (automatically runs after receiving a task description)
+## Execute Workflow
 
-### 🔍 Phase 1: Research & Analysis
+**Task Description**: $ARGUMENTS
+
+Starting structured development workflow with quality gates...
 
-[Mode: Research] - Understand the requirements and gather context.
+### 🔍 Phase 1: Research & Analysis
 
-**Analyze the user-provided task description and perform the following steps:**
+[Mode: Research] - Understanding requirements and gathering context:
 
-#### Requirement Completeness Score (0–10)
+#### Requirement Completeness Scoring (0-10 points)
 
-Evaluation dimensions:
+Scoring Dimensions:
 
-- **Goal clarity** (0–3): Is the task objective specific? What problem must be solved?
-- **Expected outcome** (0–3): Are the success criteria and deliverables clearly defined?
-- **Scope boundaries** (0–2): Are the scope and limits of the task clear?
-- **Constraints** (0–2): Are time, performance, or business constraints provided?
+- **Goal Clarity** (0-3 points): Are task objectives clear and specific, what problem to solve?
+- **Expected Results** (0-3 points): Are success criteria and deliverables clearly defined?
+- **Scope Boundaries** (0-2 points): Are task scope and boundaries clear?
+- **Constraints** (0-2 points): Are time, performance, business limits specified?
 
-Note: Technology stack, framework version, etc., are auto-detected from the project and do not affect the score.
+Note: Technical stack, framework versions will be identified from project automatically, not included in scoring
 
-**Scoring rules:**
+**Scoring Rules**:
 
-- 9–10: Requirements are complete; proceed to the next phase.
-- 7–8: Requirements are mostly complete; suggest adding minor details.
-- 5–6: Notable gaps; request key missing information.
-- 0–4: Requirements are overly vague; request a full rewrite.
+- 9-10 points: Requirements very complete, can proceed directly
+- 7-8 points: Requirements basically complete, suggest adding minor details
+- 5-6 points: Requirements have significant gaps, must supplement key information
+- 0-4 points: Requirements too vague, needs redescription
 
-**When the score is below 7, proactively ask for more details:**
+**When score is below 7, proactively ask supplementary questions**:
 
-- Identify missing information dimensions.
-- Ask 1–2 targeted questions per missing dimension.
-- Provide examples to help the user understand what information is needed.
-- Re-score after receiving additional context.
+- Identify missing key information dimensions
+- Ask 1-2 specific questions for each missing dimension
+- Provide examples to help users understand needed information
+- Re-score after user supplements information
 
-**Example assessment:**
+**Scoring Example**:
 
 ```
-User request: "Help me optimize the code."
-Score rationale:
-- Goal clarity: 0/3 (No insight into which code or which issue.)
-- Expected outcome: 0/3 (No success criteria or desired effect specified.)
-- Scope boundaries: 1/2 (We only know optimization is required; scope is unclear.)
-- Constraints: 0/2 (No performance metrics or time limits.)
-Total: 1/10 — Significant clarification required.
-
-Follow-up questions:
-1. Which file or module should be optimized?
-2. What concrete issues are you aiming to resolve?
-3. What effect do you expect after optimization (e.g., response time improvement, reduced code size)?
-4. Are there specific performance metrics or deadlines?
+User Request: "Help me optimize code"
+Scoring Analysis:
+- Goal Clarity: 0/3 points (doesn't specify what code or what problem)
+- Expected Results: 0/3 points (no success criteria or expected effect defined)
+- Scope Boundaries: 1/2 points (only knows code optimization, but scope unclear)
+- Constraints: 0/2 points (no performance metrics or time limits)
+Total Score: 1/10 - Requires significant information
+
+Questions to Ask:
+1. Which file or module's code do you want to optimize?
+2. What specific problem needs optimization?
+3. What effect do you expect after optimization (e.g., response time improvement, code reduction)?
+4. Are there specific performance metrics or time requirements?
 ```
 
-**Common follow-up question templates:**
+**Common Supplementary Question Templates**:
 
-- Goal-oriented: "Which concrete feature or effect do you need?" "What specific issue are you facing?"
-- Outcome-oriented: "How will we know the task is complete?" "What output or effect do you expect?"
-- Scope-oriented: "Which files or modules should we touch?" "What must be left untouched?"
-- Constraint-oriented: "What is the timeline?" "Are there business or performance limits?"
+- Goal: "What specific functionality/effect do you want?" "What's the current problem?"
+- Results: "How to determine task success?" "What's the expected output/effect?"
+- Scope: "Which specific files/modules to handle?" "What should be excluded?"
+- Constraints: "What are the time requirements?" "Any business limitations or performance requirements?"
 
-**Automated project context** (no need to ask the user):
+**Auto-detected Project Information** (no need to ask):
 
-- Tech stack (from CLAUDE.md, package.json, requirements.txt, etc.)
-- Framework version (from CLAUDE.md or configuration files)
-- Project structure (from the file system)
-- Existing code conventions (from CLAUDE.md, configs, and current code)
-- Development commands (from CLAUDE.md, such as build, test, typecheck)
+- Tech stack (from AGENTS.md, CLAUDE.md, package.json, requirements.txt, etc.)
+- Framework versions (from AGENTS.md, CLAUDE.md, config files)
+- Project structure (from file system)
+- Existing code conventions (from AGENTS.md, CLAUDE.md, config files and existing code)
+- Development commands (from AGENTS.md, CLAUDE.md, such as build, test, typecheck)
 
 #### Execution Steps
 
-- Analyze task requirements and constraints.
-- Provide a requirement completeness score (show the breakdown).
-- Identify key goals and success criteria.
-- Gather necessary technical context.
-- Use MCP services for additional information if needed.
+- Analyze task requirements and constraints
+- Perform requirement completeness scoring (show specific scores)
+- Identify key objectives and success criteria
+- Gather necessary technical context
+- Use MCP services for additional information if needed
 
 ### 💡 Phase 2: Solution Ideation
 
-[Mode: Ideate] - Design possible solutions.
+[Mode: Ideate] - Designing solution approaches:
 
-- Generate multiple viable approaches.
-- Evaluate pros and cons for each.
-- Offer detailed comparisons and a recommendation.
-- Consider technical constraints and best practices.
+- Generate multiple feasible solutions
+- Evaluate pros and cons of each approach
+- Provide detailed comparison and recommendation
+- Consider technical constraints and best practices
 
 ### 📋 Phase 3: Detailed Planning
 
-[Mode: Plan] - Build an execution roadmap.
+[Mode: Plan] - Creating execution roadmap:
 
-- Break the solution into atomic, executable steps.
-- Define file structure, functions/classes, and logic outlines.
-- Specify expected outcomes for each step.
-- Query new libraries with Context7 if required.
-- Request user approval before proceeding.
+- Break down solution into atomic, executable steps
+- Define file structure, functions/classes, and logic overview
+- Specify expected results for each step
+- Query new libraries using Context7 if needed
+- Request user approval before proceeding
 
 ### ⚡ Phase 4: Implementation
 
-[Mode: Implement] - Write the code.
+[Mode: Execute] - Code development:
 
-- Implement according to the approved plan.
-- Follow development best practices.
-- Document usage instructions before import statements (key rule).
-- Store the execution plan in `.claude/plan/<task-name>.md` at the project root.
-- Ask for feedback at each key milestone.
+- Implement according to approved plan
+- Follow development best practices
+- Add usage methods before import statements (critical rule)
+- Store execution plan in project root directory `.codex/plan/task-name.md`
+- Request feedback at key milestones
 
 ### 🚀 Phase 5: Code Optimization
 
-[Mode: Optimize] - Improve quality.
+[Mode: Optimize] - Quality improvement:
 
-- Analyze the newly produced code.
-- Highlight redundancy, inefficiency, or code smells.
-- Provide concrete optimization proposals.
-- Only perform the changes after user approval.
+- Automatically analyze implemented code
+- Identify redundant, inefficient, or problematic code
+- Provide specific optimization recommendations
+- Execute improvements after user confirmation
 
 ### ✅ Phase 6: Quality Review
 
-[Mode: Review] - Final evaluation.
+[Mode: Review] - Final assessment:
 
-- Compare outcomes against the original plan.
-- Surface any remaining issues or improvements.
-- Deliver a completion summary and suggestions.
-- Ask for final user confirmation.
+- Compare results against original plan
+- Identify any remaining issues or improvements
+- Provide completion summary and recommendations
+- Request final user confirmation
 
 ## Expected Output Structure
 
 ```
-project/                      # project root
-├── .claude/
+project/                      # Project root directory
+├── .codex/
 │   └── plan/
-│       └── <task-name>.md    # execution plan and context (stored in project root)
+│       └── task-name.md      # Execution plan and context (in project root)
 ├── src/
 │   ├── components/
 │   ├── services/
@@ -202,10 +227,4 @@ project/                      # project root
 └── README.md
 ```
 
----
-
-**📌 Usage notes**:
-1. When the user invokes `/workflow`, start with the welcome message.
-2. Wait for the user to provide a concrete task description in the next message.
-3. Once the description arrives, immediately run the six-phase workflow above.
-4. After each phase, report progress and request user confirmation.
+**Begin execution with the provided task description and report progress after each phase completion.**