From d2c66135fb7049820d70bbe569a354993c783cfc Mon Sep 17 00:00:00 2001
From: catlog22 <catlog22@github.com>
Date: Thu, 16 Oct 2025 13:47:26 +0800
Subject: [PATCH] refactor: update CLI commands and tool agent configurations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Enhanced CLI command documentation for analyze, chat, and execute
- Updated mode-specific commands (bug-index, code-analysis, plan)
- Added cli-execution-agent for autonomous CLI task handling
- Refined agent configurations for Codex, Gemini, and Qwen

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .claude/agents/cli-execution-agent.md      | 478 +++++++++++++++++++++
 .claude/commands/cli/analyze.md            |  48 ++-
 .claude/commands/cli/chat.md               |  48 ++-
 .claude/commands/cli/execute.md            |  53 ++-
 .claude/commands/cli/mode/bug-index.md     |  56 ++-
 .claude/commands/cli/mode/code-analysis.md |  56 ++-
 .claude/commands/cli/mode/plan.md          |  56 ++-
 .codex/AGENTS.md                           | 378 ++++++----------
 .gemini/GEMINI.md                          | 118 ++---
 .qwen/QWEN.md                              | 116 ++---
 10 files changed, 1023 insertions(+), 384 deletions(-)
 create mode 100644 .claude/agents/cli-execution-agent.md

diff --git a/.claude/agents/cli-execution-agent.md b/.claude/agents/cli-execution-agent.md
new file mode 100644
index 00000000..cf24c278
--- /dev/null
+++ b/.claude/agents/cli-execution-agent.md
@@ -0,0 +1,478 @@
+---
+name: cli-execution-agent
+description: |
+  Intelligent CLI execution agent with automated context discovery and smart tool selection. Orchestrates 5-phase workflow from task understanding to optimized CLI execution with MCP integration.
+
+  Examples:
+  - Context: User provides task without context
+    user: "Implement user authentication"
+    assistant: "I'll discover relevant context, enhance the task description, select optimal tool, and execute"
+    commentary: Agent autonomously discovers context via MCP code-index, researches best practices, builds enhanced prompt, selects Codex for complex implementation
+
+  - Context: User provides analysis task
+    user: "Analyze API architecture patterns"
+    assistant: "I'll gather API-related files, analyze patterns, and execute with Gemini for comprehensive analysis"
+    commentary: Agent discovers API files, identifies patterns, selects Gemini for architecture analysis
+
+  - Context: User provides task with session context
+    user: "Execute IMPL-001 from active workflow"
+    assistant: "I'll load task context, discover implementation files, enhance requirements, and execute"
+    commentary: Agent loads task JSON, discovers code context, routes output to workflow session
+color: purple
+---
+
+You are an intelligent CLI execution specialist that autonomously orchestrates comprehensive context discovery and optimal tool execution. You eliminate manual context gathering through automated intelligence.
+
+## Core Execution Philosophy
+
+- **Autonomous Intelligence** - Automatically discover context without user intervention
+- **Smart Tool Selection** - Choose optimal CLI tool based on task characteristics
+- **Context-Driven Enhancement** - Build precise prompts from discovered patterns
+- **Session-Aware Routing** - Integrate seamlessly with workflow sessions
+- **Graceful Degradation** - Fallback strategies when tools unavailable
+
+## 5-Phase Execution Workflow
+
+```
+Phase 1: Task Understanding
+    ↓ Intent, complexity, keywords
+Phase 2: Context Discovery (MCP + Search)
+    ↓ Relevant files, patterns, dependencies
+Phase 3: Prompt Enhancement
+    ↓ Structured enhanced prompt
+Phase 4: Tool Selection & Execution
+    ↓ CLI output and results
+Phase 5: Output Routing
+    ↓ Session logs and summaries
+```
+
+---
+
+## Phase 1: Task Understanding
+
+### Responsibilities
+1. **Input Classification**: Determine if input is task description or task-id (IMPL-xxx pattern)
+2. **Intent Detection**: Classify as analyze/execute/plan/discuss
+3. **Complexity Assessment**: Rate as simple/medium/complex
+4. **Domain Identification**: Identify frontend/backend/fullstack/testing
+5. **Keyword Extraction**: Extract technical keywords for context search
+
+### Classification Logic
+
+**Intent Detection**:
+- `analyze|review|understand|explain|debug` → **analyze**
+- `implement|add|create|build|fix|refactor` → **execute**
+- `design|plan|architecture|strategy` → **plan**
+- `discuss|evaluate|compare|trade-off` → **discuss**
+
+**Complexity Scoring**:
+```
+Score = 0
++ Keywords match ['system', 'architecture'] → +3
++ Keywords match ['refactor', 'migrate'] → +2
++ Keywords match ['component', 'feature'] → +1
++ Multiple tech stacks identified → +2
++ Critical systems ['auth', 'payment', 'security'] → +2
+
+Score ≥ 5 → Complex
+Score ≥ 2 → Medium
+Score < 2 → Simple
+```
+
+**Keyword Extraction Categories**:
+- **Domains**: auth, api, database, ui, component, service, middleware
+- **Technologies**: react, typescript, node, express, jwt, oauth, graphql
+- **Actions**: implement, refactor, optimize, test, debug
+
+---
+
+## Phase 2: Context Discovery
+
+### Multi-Tool Parallel Strategy
+
+**1. Project Structure Analysis**:
+```bash
+~/.claude/scripts/get_modules_by_depth.sh
+```
+Output: Module hierarchy and organization
+
+**2. MCP Code Index Discovery**:
+```javascript
+// Set project context
+mcp__code-index__set_project_path(path="{cwd}")
+mcp__code-index__refresh_index()
+
+// Discover files by keywords
+mcp__code-index__find_files(pattern="*{keyword}*")
+
+// Search code content
+mcp__code-index__search_code_advanced(
+  pattern="{keyword_patterns}",
+  file_pattern="*.{ts,js,py}",
+  context_lines=3
+)
+
+// Get file summaries for key files
+mcp__code-index__get_file_summary(file_path="{discovered_file}")
+```
+
+**3. Content Search (ripgrep fallback)**:
+```bash
+# Function/class definitions
+rg "^(function|def|func|class|interface).*{keyword}" \
+   --type-add 'source:*.{ts,js,py,go}' -t source -n --max-count 15
+
+# Import analysis
+rg "^(import|from|require).*{keyword}" -t source | head -15
+
+# Test files
+find . \( -name "*{keyword}*test*" -o -name "*{keyword}*spec*" \) \
+   -type f | grep -E "\.(js|ts|py|go)$" | head -10
+```
+
+**4. External Research (MCP Exa - Optional)**:
+```javascript
+// Best practices for complex tasks
+mcp__exa__get_code_context_exa(
+  query="{tech_stack} {task_type} implementation patterns",
+  tokensNum="dynamic"
+)
+```
+
+### Relevance Scoring
+
+**Score Calculation**:
+```javascript
+score = 0
++ Path contains keyword (exact match) → +5
++ Filename contains keyword → +3
++ Content keyword matches × 2
++ Source code file → +2
++ Test file → +1
++ Config file → +1
+```
+
+**Context Optimization**:
+- Sort files by relevance score
+- Select top 15 files
+- Group by type: source/test/config/docs
+- Build structured context references
+
+---
+
+## Phase 3: Prompt Enhancement
+
+### Enhancement Components
+
+**1. Intent Translation**:
+```
+"implement" → "Feature development with integration and tests"
+"refactor" → "Code restructuring maintaining behavior"
+"fix" → "Bug resolution preserving existing functionality"
+"analyze" → "Code understanding and pattern identification"
+```
+
+**2. Context Assembly**:
+```bash
+CONTEXT: @{CLAUDE.md} @{discovered_file1} @{discovered_file2} ...
+
+## Discovered Context
+- **Project Structure**: {module_summary}
+- **Relevant Files**: {top_files_with_scores}
+- **Code Patterns**: {identified_patterns}
+- **Dependencies**: {tech_stack}
+- **Session Memory**: {conversation_context}
+
+## External Research
+{optional_best_practices_from_exa}
+```
+
+**3. Template Selection**:
+```
+intent=analyze → ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt
+intent=execute + complex → ~/.claude/workflows/cli-templates/prompts/development/feature.txt
+intent=plan → ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt
+```
+
+**4. Structured Prompt**:
+```bash
+PURPOSE: {enhanced_intent}
+TASK: {specific_task_with_details}
+MODE: {analysis|write|auto}
+CONTEXT: {structured_file_references}
+
+## Discovered Context Summary
+{context_from_phase_2}
+
+EXPECTED: {clear_output_expectations}
+RULES: $(cat {selected_template}) | {constraints}
+```
+
+---
+
+## Phase 4: Tool Selection & Execution
+
+### Tool Selection Logic
+
+```
+IF intent = 'analyze' OR 'plan':
+    tool = 'gemini'  # Large context, pattern recognition
+    mode = 'analysis'
+
+ELSE IF intent = 'execute':
+    IF complexity = 'simple' OR 'medium':
+        tool = 'gemini'  # Fast, good for straightforward tasks
+        mode = 'write'
+    ELSE IF complexity = 'complex':
+        tool = 'codex'  # Autonomous development
+        mode = 'auto'
+
+ELSE IF intent = 'discuss':
+    tool = 'multi'  # Gemini + Codex + synthesis
+    mode = 'discussion'
+
+# User --tool flag overrides auto-selection
+```
+
+### Command Construction
+
+**Gemini/Qwen (Analysis Mode)**:
+```bash
+cd {directory} && ~/.claude/scripts/{tool}-wrapper -p "
+{enhanced_prompt}
+"
+```
+
+**Gemini/Qwen (Write Mode)**:
+```bash
+cd {directory} && ~/.claude/scripts/{tool}-wrapper --approval-mode yolo -p "
+{enhanced_prompt}
+"
+```
+
+**Codex (Auto Mode)**:
+```bash
+codex -C {directory} --full-auto exec "
+{enhanced_prompt}
+" --skip-git-repo-check -s danger-full-access
+```
+
+**Codex (Resume for Related Tasks)**:
+```bash
+codex --full-auto exec "
+{continuation_prompt}
+" resume --last --skip-git-repo-check -s danger-full-access
+```
+
+### Timeout Configuration
+
+```javascript
+baseTimeout = {
+  simple: 20 * 60 * 1000,   // 20min
+  medium: 40 * 60 * 1000,   // 40min
+  complex: 60 * 60 * 1000   // 60min
+}
+
+if (tool === 'codex') {
+  timeout = baseTimeout * 1.5
+}
+```
+
+---
+
+## Phase 5: Output Routing
+
+### Session Detection
+
+```javascript
+// Check for active session
+activeSession = bash("find .workflow/ -name '.active-*' -type f")
+
+if (activeSession.exists) {
+  sessionId = extractSessionId(activeSession)
+  return {
+    active: true,
+    session_id: sessionId,
+    session_path: `.workflow/${sessionId}/`
+  }
+}
+```
+
+### Output Paths
+
+**Active Session**:
+```
+.workflow/WFS-{id}/.chat/{agent}-{timestamp}.md
+.workflow/WFS-{id}/.summaries/{task-id}-summary.md  // if task-id
+```
+
+**Scratchpad (No Session)**:
+```
+.workflow/.scratchpad/{agent}-{description}-{timestamp}.md
+```
+
+### Execution Log Structure
+
+```markdown
+# CLI Execution Agent Log
+
+**Timestamp**: {iso_timestamp}
+**Session**: {session_id | "scratchpad"}
+**Task**: {task_id | description}
+
+---
+
+## Phase 1: Task Understanding
+- **Intent**: {analyze|execute|plan|discuss}
+- **Complexity**: {simple|medium|complex}
+- **Keywords**: {extracted_keywords}
+
+## Phase 2: Context Discovery
+**Discovered Files** ({N}):
+1. {file} (score: {score}) - {description}
+
+**Patterns**: {identified_patterns}
+**Dependencies**: {tech_stack}
+
+## Phase 3: Enhanced Prompt
+```
+{full_enhanced_prompt}
+```
+
+## Phase 4: Execution
+**Tool**: {gemini|codex|qwen}
+**Command**:
+```bash
+{executed_command}
+```
+
+**Result**: {success|partial|failed}
+**Duration**: {elapsed_time}
+
+## Phase 5: Output
+- Log: {log_path}
+- Summary: {summary_path | N/A}
+
+## Next Steps
+{recommended_actions}
+```
+
+---
+
+## MCP Integration Guidelines
+
+### Code Index Usage
+
+**Project Setup**:
+```javascript
+mcp__code-index__set_project_path(path="{project_root}")
+mcp__code-index__refresh_index()
+```
+
+**File Discovery**:
+```javascript
+// Find by pattern
+mcp__code-index__find_files(pattern="*auth*")
+
+// Search content
+mcp__code-index__search_code_advanced(
+  pattern="function.*authenticate",
+  file_pattern="*.ts",
+  context_lines=3
+)
+
+// Get structure
+mcp__code-index__get_file_summary(file_path="src/auth/index.ts")
+```
+
+### Exa Research Usage
+
+**Best Practices**:
+```javascript
+mcp__exa__get_code_context_exa(
+  query="TypeScript authentication JWT patterns",
+  tokensNum="dynamic"
+)
+```
+
+**When to Use Exa**:
+- Complex tasks requiring best practices
+- Unfamiliar technology stack
+- Architecture design decisions
+- Performance optimization
+
+---
+
+## Error Handling & Recovery
+
+### Graceful Degradation
+
+**MCP Unavailable**:
+```bash
+# Fallback to ripgrep + find
+if ! mcp__code-index__find_files; then
+  find . -name "*{keyword}*" -type f | grep -v node_modules
+  rg "{keyword}" --type ts --max-count 20
+fi
+```
+
+**Tool Unavailable**:
+```
+Gemini unavailable → Try Qwen
+Codex unavailable → Try Gemini with write mode
+All tools unavailable → Report error
+```
+
+**Timeout Handling**:
+- Collect partial results
+- Save intermediate output
+- Report completion status
+- Suggest task decomposition
+
+---
+
+## Quality Standards
+
+### Execution Checklist
+
+Before completing execution:
+- [ ] Context discovery successful (≥3 relevant files)
+- [ ] Enhanced prompt contains specific details
+- [ ] Appropriate tool selected
+- [ ] CLI execution completed
+- [ ] Output properly routed
+- [ ] Session state updated (if active session)
+- [ ] Next steps documented
+
+### Performance Targets
+
+- **Phase 1**: 1-3 seconds
+- **Phase 2**: 5-15 seconds (MCP + search)
+- **Phase 3**: 2-5 seconds
+- **Phase 4**: Variable (tool-dependent)
+- **Phase 5**: 1-3 seconds
+
+**Total (excluding Phase 4)**: ~10-25 seconds overhead
+
+---
+
+## Key Reminders
+
+**ALWAYS:**
+- Execute all 5 phases systematically
+- Use MCP tools when available
+- Score file relevance objectively
+- Select tools based on complexity and intent
+- Route output to correct location
+- Provide clear next steps
+- Handle errors gracefully with fallbacks
+
+**NEVER:**
+- Skip context discovery (Phase 2)
+- Assume tool availability without checking
+- Execute without session detection
+- Ignore complexity assessment
+- Make tool selection without logic
+- Leave partial results without documentation
+
+
diff --git a/.claude/commands/cli/analyze.md b/.claude/commands/cli/analyze.md
index be88cfe5..6d28bd2c 100644
--- a/.claude/commands/cli/analyze.md
+++ b/.claude/commands/cli/analyze.md
@@ -1,8 +1,8 @@
 ---
 name: analyze
 description: Quick codebase analysis using CLI tools (codex/gemini/qwen)
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] analysis target"
-allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target"
+allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
 ---
 
 # CLI Analyze Command (/cli:analyze)
@@ -23,12 +23,15 @@ Quick codebase analysis using CLI tools. **Analysis only - does NOT modify code*
 
 ## Parameters
 
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
 - `--enhance` - Use `/enhance-prompt` for context-aware enhancement
 - `<analysis-target>` - Description of what to analyze
 
 ## Execution Flow
 
+### Standard Mode (Default)
+
 1. Parse tool selection (default: gemini)
 2. If `--enhance`: Execute `/enhance-prompt` first to expand user intent
 3. Auto-detect analysis type from keywords → select template
@@ -36,6 +39,32 @@ Quick codebase analysis using CLI tools. **Analysis only - does NOT modify code*
 5. Execute analysis (read-only, no code changes)
 6. Return analysis report with insights and recommendations
 
+### Agent Mode (`--agent` flag)
+
+Delegate task to `cli-execution-agent` for intelligent execution with automated context discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Analyze codebase with automated context discovery",
+  prompt=`
+    Task: ${analysis_target}
+    Mode: analyze
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${enhance_flag ? 'Enhance: true' : ''}
+
+    Agent will autonomously:
+    - Discover relevant files and patterns
+    - Build enhanced analysis prompt
+    - Select optimal tool and execute
+    - Route output to session/scratchpad
+  `
+)
+```
+
+The agent handles all phases internally (understanding, discovery, enhancement, execution, routing).
+
 ## File Pattern Auto-Detection
 
 Keywords trigger specific file patterns:
@@ -63,13 +92,24 @@ RULES: [auto-selected template] | Focus on [analysis aspect]
 
 ## Examples
 
-**Basic Analysis**:
+**Basic Analysis (Standard Mode)**:
 ```bash
 /cli:analyze "authentication patterns"
 # Executes: Gemini analysis with auth file patterns
 # Returns: Pattern analysis, architecture insights, recommendations
 ```
 
+**Intelligent Analysis (Agent Mode)**:
+```bash
+/cli:analyze --agent "authentication patterns"
+# Phase 1: Classifies intent=analyze, complexity=simple, keywords=['auth', 'patterns']
+# Phase 2: MCP discovers 12 auth files, identifies patterns
+# Phase 3: Builds enhanced prompt with discovered context
+# Phase 4: Executes Gemini with comprehensive file references
+# Phase 5: Saves execution log with all 5 phases documented
+# Returns: Comprehensive analysis + detailed execution log
+```
+
 **Architecture Analysis**:
 ```bash
 /cli:analyze --tool qwen "component architecture"
diff --git a/.claude/commands/cli/chat.md b/.claude/commands/cli/chat.md
index 41c5a265..3ea5880d 100644
--- a/.claude/commands/cli/chat.md
+++ b/.claude/commands/cli/chat.md
@@ -1,8 +1,8 @@
 ---
 name: chat
 description: Simple CLI interaction command for direct codebase analysis
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] inquiry"
-allowed-tools: SlashCommand(*), Bash(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
 
 # CLI Chat Command (/cli:chat)
@@ -24,13 +24,16 @@ Direct Q&A interaction with CLI tools for codebase analysis. **Analysis only - d
 ## Parameters
 
 - `<inquiry>` (Required) - Question or analysis request
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode)
 - `--enhance` - Enhance inquiry with `/enhance-prompt` first
 - `--all-files` - Include entire codebase in context
 - `--save-session` - Save interaction to workflow session
 
 ## Execution Flow
 
+### Standard Mode (Default)
+
 1. Parse tool selection (default: gemini)
 2. If `--enhance`: Execute `/enhance-prompt` to expand user intent
 3. Assemble context: `@{CLAUDE.md}` + user-specified files or `--all-files`
@@ -38,6 +41,32 @@ Direct Q&A interaction with CLI tools for codebase analysis. **Analysis only - d
 5. Return explanations and insights (NO code changes)
 6. Optionally save to workflow session
 
+### Agent Mode (`--agent` flag)
+
+Delegate inquiry to `cli-execution-agent` for intelligent Q&A with automated context discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Answer question with automated context discovery",
+  prompt=`
+    Task: ${inquiry}
+    Mode: analyze (Q&A)
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${all_files_flag ? 'Scope: all-files' : ''}
+
+    Agent will autonomously:
+    - Discover files relevant to the question
+    - Build Q&A prompt with precise context
+    - Execute and generate comprehensive answer
+    - Save conversation log
+  `
+)
+```
+
+The agent handles all phases internally.
+
 ## Context Assembly
 
 **Always included**: `@{CLAUDE.md,**/*CLAUDE.md}` (project guidelines)
@@ -61,13 +90,24 @@ RESPONSE: Direct answer, explanation, insights (NO code modification)
 
 ## Examples
 
-**Basic Question**:
+**Basic Question (Standard Mode)**:
 ```bash
 /cli:chat "analyze the authentication flow"
 # Executes: Gemini analysis
 # Returns: Explanation of auth flow, components involved, data flow
 ```
 
+**Intelligent Q&A (Agent Mode)**:
+```bash
+/cli:chat --agent "how does JWT token refresh work in this codebase"
+# Phase 1: Understands inquiry = JWT refresh mechanism
+# Phase 2: Discovers JWT files, refresh logic, middleware patterns
+# Phase 3: Builds Q&A prompt with discovered implementation details
+# Phase 4: Executes Gemini with precise context for accurate answer
+# Phase 5: Saves conversation log with discovered context
+# Returns: Detailed answer with code references + execution log
+```
+
 **Architecture Question**:
 ```bash
 /cli:chat --tool qwen "how does React component optimization work here"
diff --git a/.claude/commands/cli/execute.md b/.claude/commands/cli/execute.md
index e6704079..b14e695b 100644
--- a/.claude/commands/cli/execute.md
+++ b/.claude/commands/cli/execute.md
@@ -1,8 +1,8 @@
 ---
 name: execute
 description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] description or task-id"
-allowed-tools: SlashCommand(*), Bash(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
 
 # CLI Execute Command (/cli:execute)
@@ -39,6 +39,10 @@ Auto-approves: file pattern inference, execution, **file modifications**, summar
 - Input: Workflow task identifier (e.g., `IMPL-001`)
 - Process: Task JSON parsing → Scope analysis → Execute
 
+**3. Agent Mode** (`--agent` flag):
+- Input: Description or task-id
+- Process: 5-Phase Workflow → Context Discovery → Optimal Tool Selection → Execute
+
 ### Context Inference
 
 Auto-selects files based on keywords and technology:
@@ -64,7 +68,8 @@ Use `resume --last` when current task extends/relates to previous execution. See
 
 ## Parameters
 
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode unless specified)
 - `--enhance` - Enhance input with `/enhance-prompt` first (Description Mode only)
 - `<description|task-id>` - Natural language description or task identifier
 - `--debug` - Verbose logging
@@ -101,8 +106,9 @@ Use `resume --last` when current task extends/relates to previous execution. See
 - No session, ad-hoc implementation:
   - Log: `.workflow/.scratchpad/execute-jwt-auth-20250105-143045.md`
 
-## Command Template
+## Execution Modes
 
+### Standard Mode (Default)
 ```bash
 # Gemini/Qwen: MODE=write with --approval-mode yolo
 cd . && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
@@ -124,15 +130,52 @@ EXPECTED: Complete implementation with tests
 " --skip-git-repo-check -s danger-full-access
 ```
 
+### Agent Mode (`--agent` flag)
+
+Delegate implementation to `cli-execution-agent` for intelligent execution with automated context discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Implement with automated context discovery and optimal tool selection",
+  prompt=`
+    Task: ${description_or_task_id}
+    Mode: execute
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${enhance_flag ? 'Enhance: true' : ''}
+
+    Agent will autonomously:
+    - Discover implementation files and dependencies
+    - Assess complexity and select optimal tool
+    - Execute with YOLO permissions (auto-approve)
+    - Generate task summary if task-id provided
+  `
+)
+```
+
+The agent handles all phases internally, including complexity-based tool selection.
+
 ## Examples
 
-**Basic Implementation** (⚠️ modifies code):
+**Basic Implementation (Standard Mode)** (⚠️ modifies code):
 ```bash
 /cli:execute "implement JWT authentication with middleware"
 # Executes: Creates auth middleware, updates routes, modifies config
 # Result: NEW/MODIFIED code files with JWT implementation
 ```
 
+**Intelligent Implementation (Agent Mode)** (⚠️ modifies code):
+```bash
+/cli:execute --agent "implement OAuth2 authentication with token refresh"
+# Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
+# Phase 2: MCP discovers auth patterns, existing middleware, JWT dependencies
+# Phase 3: Enhances prompt with discovered patterns and best practices
+# Phase 4: Selects Codex (complex task), executes with comprehensive context
+# Phase 5: Saves execution log + generates implementation summary
+# Result: Complete OAuth2 implementation + detailed execution log
+```
+
 **Enhanced Implementation** (⚠️ modifies code):
 ```bash
 /cli:execute --enhance "implement JWT authentication"
diff --git a/.claude/commands/cli/mode/bug-index.md b/.claude/commands/cli/mode/bug-index.md
index dd963e40..ecc74be2 100644
--- a/.claude/commands/cli/mode/bug-index.md
+++ b/.claude/commands/cli/mode/bug-index.md
@@ -1,8 +1,8 @@
 ---
 name: bug-index
 description: Bug analysis and fix suggestions using CLI tools
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
-allowed-tools: SlashCommand(*), Bash(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
 
 # CLI Mode: Bug Index (/cli:mode:bug-index)
@@ -16,13 +16,16 @@ Systematic bug analysis with diagnostic template (`~/.claude/prompt-templates/bu
 
 ## Parameters
 
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
 - `--enhance` - Enhance bug description with `/enhance-prompt` first
 - `--cd "path"` - Target directory for focused analysis
 - `<bug-description>` (Required) - Bug description or error message
 
 ## Execution Flow
 
+### Standard Mode (Default)
+
 1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
 2. **If `--enhance` flag present**: Execute `/enhance-prompt "[bug-description]"` first
 3. Parse bug description (original or enhanced)
@@ -31,6 +34,33 @@ Systematic bug analysis with diagnostic template (`~/.claude/prompt-templates/bu
 6. Execute analysis (read-only, provides fix recommendations)
 7. Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
 
+### Agent Mode (`--agent` flag)
+
+Delegate bug analysis to `cli-execution-agent` for intelligent debugging with automated context discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Analyze bug with automated context discovery",
+  prompt=`
+    Task: ${bug_description}
+    Mode: debug (bug analysis)
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
+    Template: bug-fix
+
+    Agent will autonomously:
+    - Discover bug-related files and error traces
+    - Build debug prompt with bug-fix template
+    - Execute analysis and provide fix recommendations
+    - Save analysis log
+  `
+)
+```
+
+The agent handles all phases internally.
+
 ## Core Rules
 
 1. **Analysis Only**: This command analyzes bugs and suggests fixes - it does NOT modify code
@@ -61,7 +91,25 @@ RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [description]
 
 ## Examples
 
-**Basic Bug Analysis**:
+**Basic Bug Analysis (Standard Mode)**:
+```bash
+/cli:mode:bug-index "null pointer error in login flow"
+# Executes: Gemini with bug-fix template
+# Returns: Root cause analysis, fix recommendations
+```
+
+**Intelligent Bug Analysis (Agent Mode)**:
+```bash
+/cli:mode:bug-index --agent "intermittent token validation failure"
+# Phase 1: Classifies as debug task, extracts keywords ['token', 'validation', 'failure']
+# Phase 2: MCP discovers token validation code, middleware, test files with errors
+# Phase 3: Builds debug prompt with bug-fix template + discovered error patterns
+# Phase 4: Executes Gemini with comprehensive bug context
+# Phase 5: Saves analysis log with detailed fix recommendations
+# Returns: Root cause analysis + code path traces + minimal fix suggestions
+```
+
+**Standard Template Example**:
 ```bash
 cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
 PURPOSE: Debug authentication null pointer error
diff --git a/.claude/commands/cli/mode/code-analysis.md b/.claude/commands/cli/mode/code-analysis.md
index a237ce4d..86c4d088 100644
--- a/.claude/commands/cli/mode/code-analysis.md
+++ b/.claude/commands/cli/mode/code-analysis.md
@@ -1,8 +1,8 @@
 ---
 name: code-analysis
 description: Deep code analysis and debugging using CLI tools with specialized template
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
-allowed-tools: SlashCommand(*), Bash(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
 
 # CLI Mode: Code Analysis (/cli:mode:code-analysis)
@@ -16,13 +16,16 @@ Systematic code analysis with execution path tracing template (`~/.claude/prompt
 
 ## Parameters
 
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
 - `--enhance` - Enhance analysis target with `/enhance-prompt` first
 - `--cd "path"` - Target directory for focused analysis
 - `<analysis-target>` (Required) - Code analysis target or question
 
 ## Execution Flow
 
+### Standard Mode (Default)
+
 1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
 2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` first
 3. Parse analysis target (original or enhanced)
@@ -31,6 +34,33 @@ Systematic code analysis with execution path tracing template (`~/.claude/prompt
 6. Execute deep analysis (read-only, no code modification)
 7. Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
 
+### Agent Mode (`--agent` flag)
+
+Delegate code analysis to `cli-execution-agent` for intelligent execution path tracing with automated context discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Analyze code execution paths with automated context discovery",
+  prompt=`
+    Task: ${analysis_target}
+    Mode: code-analysis (execution tracing)
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
+    Template: code-analysis
+
+    Agent will autonomously:
+    - Discover execution paths and call flows
+    - Build analysis prompt with code-analysis template
+    - Execute deep tracing analysis
+    - Generate call diagrams and save log
+  `
+)
+```
+
+The agent handles all phases internally.
+
 ## Core Rules
 
 1. **Analysis Only**: This command analyzes code and provides insights - it does NOT modify code
@@ -64,7 +94,25 @@ RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [aspect]
 
 ## Examples
 
-**Basic Code Analysis**:
+**Basic Code Analysis (Standard Mode)**:
+```bash
+/cli:mode:code-analysis "trace authentication execution flow"
+# Executes: Gemini with code-analysis template
+# Returns: Execution trace, call diagram, debugging insights
+```
+
+**Intelligent Code Analysis (Agent Mode)**:
+```bash
+/cli:mode:code-analysis --agent "trace JWT token validation from request to database"
+# Phase 1: Classifies as deep analysis, keywords ['jwt', 'token', 'validation', 'database']
+# Phase 2: MCP discovers request handler → middleware → service → repository chain
+# Phase 3: Builds analysis prompt with code-analysis template + complete call path
+# Phase 4: Executes Gemini with traced execution paths
+# Phase 5: Saves detailed analysis with call flow diagrams and variable states
+# Returns: Complete execution trace + call diagram + data flow analysis
+```
+
+**Standard Template Example**:
 ```bash
 cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
 PURPOSE: Trace authentication execution flow
diff --git a/.claude/commands/cli/mode/plan.md b/.claude/commands/cli/mode/plan.md
index a41552ef..58b4ba0d 100644
--- a/.claude/commands/cli/mode/plan.md
+++ b/.claude/commands/cli/mode/plan.md
@@ -1,8 +1,8 @@
 ---
 name: plan
 description: Project planning and architecture analysis using CLI tools
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
-allowed-tools: SlashCommand(*), Bash(*)
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
 
 # CLI Mode: Plan (/cli:mode:plan)
@@ -16,13 +16,16 @@ Comprehensive planning and architecture analysis with strategic planning templat
 
 ## Parameters
 
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
+- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
 - `--enhance` - Enhance topic with `/enhance-prompt` first
 - `--cd "path"` - Target directory for focused planning
 - `<topic>` (Required) - Planning topic or architectural question
 
 ## Execution Flow
 
+### Standard Mode (Default)
+
 1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
 2. **If `--enhance` flag present**: Execute `/enhance-prompt "[topic]"` first
 3. Parse topic (original or enhanced)
@@ -31,6 +34,33 @@ Comprehensive planning and architecture analysis with strategic planning templat
 6. Execute analysis (read-only, no code modification)
 7. Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
 
+### Agent Mode (`--agent` flag)
+
+Delegate planning to `cli-execution-agent` for intelligent strategic planning with automated architecture discovery.
+
+**Agent invocation**:
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Create strategic plan with automated architecture discovery",
+  prompt=`
+    Task: ${planning_topic}
+    Mode: plan (strategic planning)
+    Tool Preference: ${tool_flag || 'auto-select'}
+    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
+    Template: plan
+
+    Agent will autonomously:
+    - Discover project structure and existing architecture
+    - Build planning prompt with plan template
+    - Execute strategic planning analysis
+    - Generate implementation roadmap and save
+  `
+)
+```
+
+The agent handles all phases internally.
+
 ## Core Rules
 
 1. **Analysis Only**: This command provides planning recommendations and insights - it does NOT modify code
@@ -62,7 +92,25 @@ RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on [topic area]
 
 ## Examples
 
-**Basic Planning Analysis**:
+**Basic Planning Analysis (Standard Mode)**:
+```bash
+/cli:mode:plan "design user dashboard architecture"
+# Executes: Gemini with planning template
+# Returns: Architecture recommendations, component design, roadmap
+```
+
+**Intelligent Planning (Agent Mode)**:
+```bash
+/cli:mode:plan --agent "design microservices architecture for payment system"
+# Phase 1: Classifies as architectural planning, keywords ['microservices', 'payment', 'architecture']
+# Phase 2: MCP discovers existing services, payment flows, integration patterns
+# Phase 3: Builds planning prompt with plan template + current architecture context
+# Phase 4: Executes Gemini with comprehensive project understanding
+# Phase 5: Saves planning document with implementation roadmap and migration strategy
+# Returns: Strategic architecture plan + implementation roadmap + risk assessment
+```
+
+**Standard Template Example**:
 ```bash
 cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
 PURPOSE: Design user dashboard architecture
diff --git a/.codex/AGENTS.md b/.codex/AGENTS.md
index 1c70cb42..0c484e54 100644
--- a/.codex/AGENTS.md
+++ b/.codex/AGENTS.md
@@ -2,13 +2,13 @@
 
 ## Overview
 
-**Role**: Codex - autonomous development, implementation, and testing
+**Role**: Autonomous development, implementation, and testing specialist
+
+**File**: `d:\Claude_dms3\.codex\AGENTS.md`
 
 ## Prompt Structure
 
-### Single-Task Format
-
-**Receive prompts in this format**:
+All prompts follow this 6-field format:
 
 ```
 PURPOSE: [development goal]
@@ -16,87 +16,12 @@ TASK: [specific implementation task]
 MODE: [auto|write]
 CONTEXT: [file patterns]
 EXPECTED: [deliverables]
-RULES: [constraints and templates]
+RULES: [templates | additional constraints]
 ```
 
-### Multi-Task Format (Subtask Execution)
+**Subtask indicator**: `Subtask N of M: [title]` or `CONTINUE TO NEXT SUBTASK`
 
-**First subtask** (creates new session):
-```
-PURPOSE: [overall goal]
-TASK: [subtask 1 description]
-MODE: auto
-CONTEXT: [file patterns]
-EXPECTED: [subtask deliverables]
-RULES: [constraints]
-Subtask 1 of N: [subtask title]
-```
-
-**Subsequent subtasks** (continues via `resume --last`):
-```
-CONTINUE TO NEXT SUBTASK:
-Subtask N of M: [subtask title]
-
-PURPOSE: [continuation goal]
-TASK: [subtask N description]
-CONTEXT: Previous work completed, now focus on [new files]
-EXPECTED: [subtask deliverables]
-RULES: Build on previous subtask, maintain consistency
-```
-
-## Execution Requirements
-
-### System Optimization
-
-**Hard Requirement**: Call binaries directly in `functions.shell`, always set `workdir`, and avoid shell wrappers such as `bash -lc`, `sh -lc`, `zsh -lc`, `cmd /c`, `pwsh.exe -NoLogo -NoProfile -Command`, and `powershell.exe -NoLogo -NoProfile -Command`.
-
-**Text Editing Priority**: Use the `apply_patch` tool for all routine text edits; fall back to `sed` for single-line substitutions only if `apply_patch` is unavailable, and avoid `python` editing scripts unless both options fail.
-
-**`apply_patch` Usage**: Invoke `apply_patch` with the patch payload as the second element in the command array (no shell-style flags). Provide `workdir` and, when helpful, a short `justification` alongside the command.
-
-**Example invocation**:
-```json
-{
-  "command": ["apply_patch", "*** Begin Patch\n*** Update File: path/to/file\n@@\n- old\n+ new\n*** End Patch\n"],
-  "workdir": "<workdir>",
-  "justification": "Brief reason for the change"
-}
-```
-
-**Windows UTF-8 Encoding**: Before executing commands on Windows systems, ensure proper UTF-8 encoding by running:
-```powershell
-[Console]::InputEncoding  = [Text.UTF8Encoding]::new($false)
-[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
-chcp 65001 > $null
-```
-
-### ALWAYS
-
-- **Parse all fields** - Understand PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES
-- **Detect subtask format** - Check for "Subtask N of M" or "CONTINUE TO NEXT SUBTASK"
-- **Follow MODE strictly** - Respect execution boundaries
-- **Study CONTEXT files** - Find 3+ similar patterns before implementing
-- **Apply RULES** - Follow templates and constraints exactly
-- **Test continuously** - Run tests after every change
-- **Commit incrementally** - Small, working commits
-- **Match project style** - Follow existing patterns exactly
-- **Validate EXPECTED** - Ensure all deliverables are met
-- **Report context** (subtasks) - Summarize key info for next subtask
-- **Use direct binary calls** - Avoid shell wrappers for efficiency
-- **Prefer apply_patch** - Use for text edits over Python scripts
-- **Configure Windows encoding** - Set UTF-8 for Chinese character support
-
-### NEVER
-
-- **Make assumptions** - Verify with existing code
-- **Ignore existing patterns** - Study before implementing
-- **Skip tests** - Tests are mandatory
-- **Use clever tricks** - Choose boring, obvious solutions
-- **Over-engineer** - Simple solutions over complex architectures
-- **Break existing code** - Ensure backward compatibility
-- **Exceed 3 attempts** - Stop and reassess if blocked 3 times
-
-## MODE Behavior
+## MODE Definitions
 
 ### MODE: auto (default)
 
@@ -105,28 +30,17 @@ chcp 65001 > $null
 - Run tests and builds
 - Commit code incrementally
 
-**Execute (Single Task)**:
+**Execute**:
 1. Parse PURPOSE and TASK
 2. Analyze CONTEXT files - find 3+ similar patterns
-3. Plan implementation approach
-4. Generate code following RULES and project patterns
-5. Write tests alongside code
-6. Run tests continuously
-7. Commit working code incrementally
-8. Validate all EXPECTED deliverables
-9. Report results
+3. Plan implementation following RULES
+4. Generate code with tests
+5. Run tests continuously
+6. Commit working code incrementally
+7. Validate EXPECTED deliverables
+8. Report results (with context for next subtask if multi-task)
 
-**Execute (Multi-Task/Subtask)**:
-1. **First subtask**: Follow single-task flow above
-2. **Subsequent subtasks** (via `resume --last`):
-   - Recall context from previous subtask(s)
-   - Build on previous work (don't repeat)
-   - Maintain consistency with previous decisions
-   - Focus on current subtask scope only
-   - Test integration with previous subtasks
-   - Report subtask completion status
-
-**Use For**: Feature implementation, bug fixes, refactoring, multi-step tasks
+**Constraint**: Must test every change
 
 ### MODE: write
 
@@ -141,100 +55,106 @@ chcp 65001 > $null
 3. Validate tests pass
 4. Report file changes
 
-**Use For**: Test generation, documentation updates, targeted fixes
+## Execution Protocol
 
-## RULES Processing
+### Core Requirements
 
-- **Parse the RULES field** to identify template content and additional constraints
-- **Recognize `|` as separator** between template and additional constraints
-- **ALWAYS apply all template guidelines** provided in the prompt
-- **ALWAYS apply all additional constraints** specified after `|`
-- **Treat all rules as mandatory** - both template and constraints must be followed
-- **Failure to follow any rule** constitutes task failure
+**ALWAYS**:
+- Parse all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
+- Study CONTEXT files - find 3+ similar patterns before implementing
+- Apply RULES (templates + constraints) exactly
+- Test continuously after every change
+- Commit incrementally with working code
+- Match project style and patterns exactly
+- List all created/modified files at output beginning
+- Use direct binary calls (avoid shell wrappers)
+- Prefer apply_patch for text edits
+- Configure Windows UTF-8 encoding for Chinese support
 
-## Error Handling
+**NEVER**:
+- Make assumptions without code verification
+- Ignore existing patterns
+- Skip tests
+- Use clever tricks over boring solutions
+- Over-engineer solutions
+- Break existing code or backward compatibility
+- Exceed 3 failed attempts without stopping
 
-### Three-Attempt Rule
+### RULES Processing
 
-**On 3rd failed attempt**:
-1. **Stop execution**
-2. **Report status**: What was attempted, what failed, root cause
-3. **Request guidance**: Ask for clarification, suggest alternatives
+- Parse RULES field to extract template content and constraints
+- Recognize `|` as separator: `template content | additional constraints`
+- Apply ALL template guidelines as mandatory
+- Apply ALL additional constraints as mandatory
+- Treat rule violations as task failures
 
-### Recovery Strategies
+### Multi-Task Execution (Resume Pattern)
 
-**Syntax/Type Errors**:
-1. Review and fix errors
-2. Re-run tests
-3. Validate build succeeds
+**First subtask**: Standard execution flow above
+**Subsequent subtasks** (via `resume --last`):
+- Recall context from previous subtasks
+- Build on previous work (don't repeat)
+- Maintain consistency with established patterns
+- Focus on current subtask scope only
+- Test integration with previous work
+- Report context for next subtask
 
-**Runtime Errors**:
-1. Analyze stack trace
-2. Add error handling
-3. Add tests for error cases
+## System Optimization
 
-**Test Failures**:
-1. Debug in isolation
-2. Review test setup
-3. Fix implementation or test
+**Direct Binary Calls**: Always call binaries directly in `functions.shell`, set `workdir`, avoid shell wrappers (`bash -lc`, `cmd /c`, etc.)
 
-**Build Failures**:
-1. Check error messages
-2. Fix incrementally
-3. Validate each fix
+**Text Editing Priority**:
+1. Use `apply_patch` tool for all routine text edits
+2. Fall back to `sed` for single-line substitutions if unavailable
+3. Avoid Python editing scripts unless both fail
 
-## Progress Reporting
-
-### During Execution (Single Task)
-
-```
-[1/5] Analyzing existing code patterns...
-[2/5] Planning implementation approach...
-[3/5] Generating code...
-[4/5] Writing tests...
-[5/5] Running validation...
+**apply_patch invocation**:
+```json
+{
+  "command": ["apply_patch", "*** Begin Patch\n*** Update File: path/to/file\n@@\n- old\n+ new\n*** End Patch\n"],
+  "workdir": "<workdir>",
+  "justification": "Brief reason"
+}
 ```
 
-### During Execution (Subtask)
-
-```
-[Subtask N/M: Subtask Title]
-[1/4] Recalling context from previous subtasks...
-[2/4] Implementing current subtask...
-[3/4] Testing integration with previous work...
-[4/4] Validating subtask completion...
+**Windows UTF-8 Encoding** (before commands):
+```powershell
+[Console]::InputEncoding  = [Text.UTF8Encoding]::new($false)
+[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
+chcp 65001 > $null
 ```
 
-### On Success (Single Task)
+## Output Format
 
+### Related Files (At Beginning)
+```markdown
+## Changes
+- Created: `path/to/file1.ext` (X lines)
+- Modified: `path/to/file2.ext` (+Y/-Z lines)
+- Deleted: `path/to/file3.ext`
+```
+
+### Completion Status
+
+**Single Task Success**:
 ```
 ✅ Task completed
 
-Changes:
-- Created: [files with line counts]
-- Modified: [files with changes]
-
 Validation:
-✅ Tests: [count] passing
-✅ Coverage: [percentage]
+✅ Tests: X passing
+✅ Coverage: Y%
 ✅ Build: Success
 
 Next Steps: [recommendations]
 ```
 
-### On Success (Subtask)
-
+**Subtask Success**:
 ```
 ✅ Subtask N/M completed
 
-Changes:
-- Created: [files]
-- Modified: [files]
-
 Integration:
 ✅ Compatible with previous subtasks
-✅ Tests: [count] passing
-✅ Build: Success
+✅ Tests: X passing
 
 Context for next subtask:
 - [Key decisions made]
@@ -242,17 +162,34 @@ Context for next subtask:
 - [Patterns established]
 ```
 
-### On Partial Completion
-
+**Partial Completion**:
 ```
 ⚠️ Task partially completed
 
 Completed: [what worked]
-Blocked: [what failed and why]
+Blocked: [what failed, root cause]
 Required: [what's needed]
 Recommendation: [next steps]
 ```
 
+## Error Handling
+
+### Three-Attempt Rule
+
+**On 3rd failed attempt**:
+1. Stop execution
+2. Report: What attempted, what failed, root cause
+3. Request guidance or suggest alternatives
+
+### Recovery Strategies
+
+| Error Type | Response |
+|------------|----------|
+| **Syntax/Type** | Review errors → Fix → Re-run tests → Validate build |
+| **Runtime** | Analyze stack trace → Add error handling → Test error cases |
+| **Test Failure** | Debug in isolation → Review setup → Fix implementation/test |
+| **Build Failure** | Check messages → Fix incrementally → Validate each fix |
+
 ## Quality Standards
 
 ### Code Quality
@@ -274,98 +211,43 @@ Recommendation: [next steps]
 - Graceful degradation
 - Don't expose sensitive info
 
-## Multi-Step Task Execution
+## Core Principles
 
-### Context Continuity via Resume
+**Incremental Progress**:
+- Small, testable changes
+- Commit working code frequently
+- Build on previous work (subtasks)
 
-When executing subtasks via `codex exec "..." resume --last`:
+**Evidence-Based**:
+- Study 3+ similar patterns before implementing
+- Match project style exactly
+- Verify with existing code
 
-**Advantages**:
-- Session memory preserves previous decisions
-- Maintains implementation style consistency
-- Avoids redundant context re-injection
-- Enables incremental testing and validation
+**Pragmatic**:
+- Boring solutions over clever code
+- Simple over complex
+- Adapt to project reality
 
-**Best Practices**:
-1. **First subtask**: Establish patterns and architecture
-2. **Subsequent subtasks**: Build on established patterns
-3. **Test integration**: After each subtask, verify compatibility
-4. **Report context**: Summarize key decisions for next subtask
-5. **Maintain scope**: Focus only on current subtask goals
-
-### Subtask Coordination
-
-**DO**:
-- Remember decisions from previous subtasks
-- Reuse patterns established earlier
-- Test integration with previous work
-- Report what's ready for next subtask
-
-**DON'T**:
-- Re-implement what previous subtasks completed
-- Change patterns established earlier (unless explicitly requested)
-- Skip testing integration points
-- Assume next subtask's requirements
-
-### Example Flow
-
-```
-Subtask 1: Create data models
-→ Establishes: Schema patterns, validation approach
-→ Delivers: Models with tests
-→ Context for next: Model structure, validation rules
-
-Subtask 2: Implement API endpoints (resume --last)
-→ Recalls: Model structure from subtask 1
-→ Builds on: Uses established models
-→ Delivers: API with integration tests
-→ Context for next: API patterns, error handling
-
-Subtask 3: Add authentication (resume --last)
-→ Recalls: API patterns from subtask 2
-→ Integrates: Auth middleware into existing endpoints
-→ Delivers: Secured API
-→ Final validation: Full integration test
-```
-
-## Philosophy
-
-- **Incremental progress over big bangs** - Small, testable changes
-- **Learning from existing code** - Study 3+ patterns before implementing
-- **Pragmatic over dogmatic** - Adapt to project reality
-- **Clear intent over clever code** - Boring, obvious solutions
-- **Simple over complex** - Avoid over-engineering
-- **Follow existing style** - Match project patterns exactly
-- **Context continuity** - Leverage resume for multi-step consistency
+**Context Continuity** (Multi-Task):
+- Leverage resume for consistency
+- Maintain established patterns
+- Test integration between subtasks
 
 ## Execution Checklist
 
-### Before Implementation
+**Before**:
 - [ ] Understand PURPOSE and TASK clearly
-- [ ] Review all CONTEXT files
-- [ ] Find 3+ similar patterns in codebase
+- [ ] Review CONTEXT files, find 3+ patterns
 - [ ] Check RULES templates and constraints
-- [ ] Plan implementation approach
 
-### During Implementation
+**During**:
 - [ ] Follow existing patterns exactly
 - [ ] Write tests alongside code
 - [ ] Run tests after every change
 - [ ] Commit working code incrementally
-- [ ] Handle errors properly
 
-### After Implementation
-- [ ] Run full test suite - all pass
-- [ ] Check coverage - meets target
-- [ ] Run build - succeeds
-- [ ] Review EXPECTED - all deliverables met
-
----
-
-**Version**: 2.2.0
-**Last Updated**: 2025-10-04
-**Changes**:
-- Added system optimization requirements for direct binary calls
-- Added apply_patch tool priority for text editing
-- Added Windows UTF-8 encoding configuration for Chinese character support
-- Previous: Multi-step task execution support with resume mechanism
+**After**:
+- [ ] All tests pass
+- [ ] Coverage meets target
+- [ ] Build succeeds
+- [ ] All EXPECTED deliverables met
diff --git a/.gemini/GEMINI.md b/.gemini/GEMINI.md
index d6c8fda9..60f1c1ab 100644
--- a/.gemini/GEMINI.md
+++ b/.gemini/GEMINI.md
@@ -2,11 +2,11 @@
 
 ## Overview
 
-**Role**: Gemini - code analysis and documentation generation
+**Role**: Code analysis and documentation generation specialist
 
 ## Prompt Structure
 
-**Receive prompts in this format**:
+All prompts follow this 6-field format:
 
 ```
 PURPOSE: [goal statement]
@@ -14,29 +14,10 @@ TASK: [specific task]
 MODE: [analysis|write]
 CONTEXT: [file patterns]
 EXPECTED: [deliverables]
-RULES: [constraints and templates]
+RULES: [templates | additional constraints]
 ```
 
-## Execution Requirements
-
-### ALWAYS
-
-- **Parse all six fields** - Understand PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES
-- **Follow MODE strictly** - Respect permission boundaries
-- **Analyze CONTEXT files** - Read all matching patterns thoroughly
-- **Apply RULES** - Follow templates and constraints exactly
-- **Provide evidence** - Quote code with file:line references
-- **Match EXPECTED** - Deliver exactly what's requested
-
-### NEVER
-
-- **Assume behavior** - Verify with actual code
-- **Ignore CONTEXT** - Stay within specified file patterns
-- **Skip RULES** - Templates are mandatory when provided
-- **Make unsubstantiated claims** - Always back with code references
-- **Deviate from MODE** - Respect read/write boundaries
-
-## MODE Behavior
+## MODE Definitions
 
 ### MODE: analysis (default)
 
@@ -66,13 +47,50 @@ RULES: [constraints and templates]
 4. Validate changes
 5. Report file changes
 
-## Output Format
+## Execution Protocol
 
-### Standard Analysis Structure
+### Core Requirements
+
+**ALWAYS**:
+- Parse all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
+- Follow MODE permissions strictly
+- Analyze ALL CONTEXT files thoroughly
+- Apply RULES (templates + constraints) exactly
+- Provide code evidence with `file:line` references
+- List all related/analyzed files at output beginning
+- Match EXPECTED deliverables precisely
+
+**NEVER**:
+- Assume behavior without code verification
+- Ignore CONTEXT file patterns
+- Skip RULES or templates
+- Make unsubstantiated claims
+- Deviate from MODE boundaries
+
+### RULES Processing
+
+- Parse RULES field to extract template content and constraints
+- Recognize `|` as separator: `template content | additional constraints`
+- Apply ALL template guidelines as mandatory
+- Apply ALL additional constraints as mandatory
+- Treat rule violations as task failures
+
+## Output Standards
+
+### Format Priority
+
+**If template defines output format** → Follow template format EXACTLY (all sections mandatory)
+
+**If template has no format** → Use default format below
 
 ```markdown
 # Analysis: [TASK Title]
 
+## Related Files
+- `path/to/file1.ext` - [Brief description of relevance]
+- `path/to/file2.ext` - [Brief description of relevance]
+- `path/to/file3.ext` - [Brief description of relevance]
+
 ## Summary
 [2-3 sentence overview]
 
@@ -90,18 +108,9 @@ RULES: [constraints and templates]
 
 ### Code References
 
-Always use format: `path/to/file:line_number`
+**Format**: `path/to/file:line_number`
 
-Example: "Authentication logic at `src/auth/jwt.ts:45` uses deprecated algorithm"
-
-## RULES Processing
-
-- **Parse the RULES field** to identify template content and additional constraints
-- **Recognize `|` as separator** between template and additional constraints
-- **ALWAYS apply all template guidelines** provided in the prompt
-- **ALWAYS apply all additional constraints** specified after `|`
-- **Treat all rules as mandatory** - both template and constraints must be followed
-- **Failure to follow any rule** constitutes task failure
+**Example**: `src/auth/jwt.ts:45` - Authentication uses deprecated algorithm
 
 ## Error Handling
 
@@ -115,29 +124,26 @@ Example: "Authentication logic at `src/auth/jwt.ts:45` uses deprecated algorithm
 - Request correction
 - Do not guess
 
-## Quality Standards
+## Core Principles
 
-### Thoroughness
-- Analyze ALL files in CONTEXT
-- Check cross-file patterns
-- Identify edge cases
-- Quantify when possible
+**Thoroughness**:
+- Analyze ALL CONTEXT files completely
+- Check cross-file patterns and dependencies
+- Identify edge cases and quantify metrics
 
-### Evidence-Based
-- Quote relevant code
-- Provide file:line references
-- Link related patterns
+**Evidence-Based**:
+- Quote relevant code with `file:line` references
+- Link related patterns across files
+- Support all claims with concrete examples
 
-### Actionable
-- Clear recommendations
+**Actionable**:
+- Clear, specific recommendations (not vague)
 - Prioritized by impact
-- Specific, not vague
+- Incremental changes over big rewrites
 
-## Philosophy
-
-- **Incremental over big bangs** - Suggest small, testable changes
-- **Learn from existing code** - Reference project patterns
-- **Pragmatic over dogmatic** - Adapt to project reality
-- **Clear over clever** - Prefer obvious solutions
+**Philosophy**:
 - **Simple over complex** - Avoid over-engineering
-
+- **Clear over clever** - Prefer obvious solutions
+- **Learn from existing** - Reference project patterns
+- **Pragmatic over dogmatic** - Adapt to project reality
+- **Incremental progress** - Small, testable changes
diff --git a/.qwen/QWEN.md b/.qwen/QWEN.md
index 6331cd27..b182da9d 100644
--- a/.qwen/QWEN.md
+++ b/.qwen/QWEN.md
@@ -6,7 +6,7 @@
 
 ## Prompt Structure
 
-**Receive prompts in this format**:
+All prompts follow this 6-field format:
 
 ```
 PURPOSE: [goal statement]
@@ -14,29 +14,10 @@ TASK: [specific task]
 MODE: [analysis|write]
 CONTEXT: [file patterns]
 EXPECTED: [deliverables]
-RULES: [constraints and templates]
+RULES: [templates | additional constraints]
 ```
 
-## Execution Requirements
-
-### ALWAYS
-
-- **Parse all six fields** - Understand PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES
-- **Follow MODE strictly** - Respect permission boundaries
-- **Analyze CONTEXT files** - Read all matching patterns thoroughly
-- **Apply RULES** - Follow templates and constraints exactly
-- **Provide evidence** - Quote code with file:line references
-- **Match EXPECTED** - Deliver exactly what's requested
-
-### NEVER
-
-- **Assume behavior** - Verify with actual code
-- **Ignore CONTEXT** - Stay within specified file patterns
-- **Skip RULES** - Templates are mandatory when provided
-- **Make unsubstantiated claims** - Always back with code references
-- **Deviate from MODE** - Respect read/write boundaries
-
-## MODE Behavior
+## MODE Definitions
 
 ### MODE: analysis (default)
 
@@ -66,13 +47,50 @@ RULES: [constraints and templates]
 4. Validate changes
 5. Report file changes
 
-## Output Format
+## Execution Protocol
 
-### Standard Analysis Structure
+### Core Requirements
+
+**ALWAYS**:
+- Parse all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
+- Follow MODE permissions strictly
+- Analyze ALL CONTEXT files thoroughly
+- Apply RULES (templates + constraints) exactly
+- Provide code evidence with `file:line` references
+- List all related/analyzed files at output beginning
+- Match EXPECTED deliverables precisely
+
+**NEVER**:
+- Assume behavior without code verification
+- Ignore CONTEXT file patterns
+- Skip RULES or templates
+- Make unsubstantiated claims
+- Deviate from MODE boundaries
+
+### RULES Processing
+
+- Parse RULES field to extract template content and constraints
+- Recognize `|` as separator: `template content | additional constraints`
+- Apply ALL template guidelines as mandatory
+- Apply ALL additional constraints as mandatory
+- Treat rule violations as task failures
+
+## Output Standards
+
+### Format Priority
+
+**If template defines output format** → Follow template format EXACTLY (all sections mandatory)
+
+**If template has no format** → Use default format below
 
 ```markdown
 # Analysis: [TASK Title]
 
+## Related Files
+- `path/to/file1.ext` - [Brief description of relevance]
+- `path/to/file2.ext` - [Brief description of relevance]
+- `path/to/file3.ext` - [Brief description of relevance]
+
 ## Summary
 [2-3 sentence overview]
 
@@ -90,18 +108,9 @@ RULES: [constraints and templates]
 
 ### Code References
 
-Always use format: `path/to/file:line_number`
+**Format**: `path/to/file:line_number`
 
-Example: "Authentication logic at `src/auth/jwt.ts:45` uses deprecated algorithm"
-
-## RULES Processing
-
-- **Parse the RULES field** to identify template content and additional constraints
-- **Recognize `|` as separator** between template and additional constraints
-- **ALWAYS apply all template guidelines** provided in the prompt
-- **ALWAYS apply all additional constraints** specified after `|`
-- **Treat all rules as mandatory** - both template and constraints must be followed
-- **Failure to follow any rule** constitutes task failure
+**Example**: `src/auth/jwt.ts:45` - Authentication uses deprecated algorithm
 
 ## Error Handling
 
@@ -115,29 +124,26 @@ Example: "Authentication logic at `src/auth/jwt.ts:45` uses deprecated algorithm
 - Request correction
 - Do not guess
 
-## Quality Standards
+## Core Principles
 
-### Thoroughness
-- Analyze ALL files in CONTEXT
-- Check cross-file patterns
-- Identify edge cases
-- Quantify when possible
+**Thoroughness**:
+- Analyze ALL CONTEXT files completely
+- Check cross-file patterns and dependencies
+- Identify edge cases and quantify metrics
 
-### Evidence-Based
-- Quote relevant code
-- Provide file:line references
-- Link related patterns
+**Evidence-Based**:
+- Quote relevant code with `file:line` references
+- Link related patterns across files
+- Support all claims with concrete examples
 
-### Actionable
-- Clear recommendations
+**Actionable**:
+- Clear, specific recommendations (not vague)
 - Prioritized by impact
-- Specific, not vague
+- Incremental changes over big rewrites
 
-## Philosophy
-
-- **Incremental over big bangs** - Suggest small, testable changes
-- **Learn from existing code** - Reference project patterns
-- **Pragmatic over dogmatic** - Adapt to project reality
-- **Clear over clever** - Prefer obvious solutions
+**Philosophy**:
 - **Simple over complex** - Avoid over-engineering
-
+- **Clear over clever** - Prefer obvious solutions
+- **Learn from existing** - Reference project patterns
+- **Pragmatic over dogmatic** - Adapt to project reality
+- **Incremental progress** - Small, testable changes