update dev workflow

feat: 支持通过环境变量配置 skills 模型

.claude-plugin/marketplace.json

@@ -226,6 +226,39 @@
       "skills": [
         "./SKILL.md"
       ]
+    },
+    {
+      "name": "dev-workflow",
+      "source": "./dev-workflow/",
+      "description": "Minimal lightweight development workflow with requirements clarification, parallel codex execution, and mandatory 90% test coverage",
+      "version": "1.0.0",
+      "author": {
+        "name": "Claude Code Dev Workflows",
+        "url": "https://github.com/cexll/myclaude"
+      },
+      "homepage": "https://github.com/cexll/myclaude",
+      "repository": "https://github.com/cexll/myclaude",
+      "license": "MIT",
+      "keywords": [
+        "dev",
+        "workflow",
+        "codex",
+        "testing",
+        "coverage",
+        "concurrent",
+        "lightweight"
+      ],
+      "category": "workflows",
+      "strict": false,
+      "commands": [
+        "./commands/dev.md"
+      ],
+      "agents": [
+        "./agents/dev-plan-generator.md"
+      ],
+      "skills": [
+        "../skills/codex/SKILL.md"
+      ]
     }
   ]
 }

README.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Claude Code](https://img.shields.io/badge/Claude-Code-blue)](https://claude.ai/code)
-[![Version](https://img.shields.io/badge/Version-3.2-green)](https://github.com/cexll/myclaude)
+[![Version](https://img.shields.io/badge/Version-4.4-green)](https://github.com/cexll/myclaude)
 [![Plugin Ready](https://img.shields.io/badge/Plugin-Ready-purple)](https://docs.claude.com/en/docs/claude-code/plugins)
 
 > Enterprise-grade agile development automation with AI-powered multi-agent orchestration
@@ -44,6 +44,7 @@ make install
 |--------|-------------|--------------|
 | **[bmad-agile-workflow](docs/BMAD-WORKFLOW.md)** | Complete BMAD methodology with 6 specialized agents | `/bmad-pilot` |
 | **[requirements-driven-workflow](docs/REQUIREMENTS-WORKFLOW.md)** | Streamlined requirements-to-code workflow | `/requirements-pilot` |
+| **[dev-workflow](dev-workflow/README.md)** | Extreme lightweight end-to-end development workflow | `/dev` |
 | **[development-essentials](docs/DEVELOPMENT-COMMANDS.md)** | Core development slash commands | `/code` `/debug` `/test` `/optimize` |
 | **[advanced-ai-agents](docs/ADVANCED-AGENTS.md)** | GPT-5 deep reasoning integration | Agent: `gpt5` |
 | **[requirements-clarity](docs/REQUIREMENTS-CLARITY.md)** | Automated requirements clarification with 100-point scoring | Auto-activated skill |

README_CN.md

@@ -2,7 +2,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Claude Code](https://img.shields.io/badge/Claude-Code-blue)](https://claude.ai/code)
-[![Version](https://img.shields.io/badge/Version-3.2-green)](https://github.com/cexll/myclaude)
+[![Version](https://img.shields.io/badge/Version-4.4-green)](https://github.com/cexll/myclaude)
 [![Plugin Ready](https://img.shields.io/badge/Plugin-Ready-purple)](https://docs.claude.com/en/docs/claude-code/plugins)
 
 > 企业级敏捷开发自动化与 AI 驱动的多智能体编排
@@ -44,6 +44,7 @@ make install
 |------|------|---------|
 | **[bmad-agile-workflow](docs/BMAD-WORKFLOW.md)** | 完整 BMAD 方法论，包含6个专业智能体 | `/bmad-pilot` |
 | **[requirements-driven-workflow](docs/REQUIREMENTS-WORKFLOW.md)** | 精简的需求到代码工作流 | `/requirements-pilot` |
+| **[dev-workflow](dev-workflow/README.md)** | 极简端到端开发工作流 | `/dev` |
 | **[development-essentials](docs/DEVELOPMENT-COMMANDS.md)** | 核心开发斜杠命令 | `/code` `/debug` `/test` `/optimize` |
 | **[advanced-ai-agents](docs/ADVANCED-AGENTS.md)** | GPT-5 深度推理集成 | 智能体: `gpt5` |
 | **[requirements-clarity](docs/REQUIREMENTS-CLARITY.md)** | 自动需求澄清，100分制质量评分 | 自动激活技能 |

dev-workflow/README.md

@@ -1,163 +1,163 @@
-# /dev - 极简开发工作流
+# /dev - Minimal Dev Workflow
 
-## 概述
+## Overview
 
-全新设计的轻量级开发工作流，无历史包袱，专注快速交付高质量代码。
+A freshly designed lightweight development workflow with no legacy baggage, focused on delivering high-quality code fast.
 
-## 工作流程
+## Flow
 
 ```
-/dev 触发
+/dev trigger
   ↓
-AskUserQuestion（需求澄清）
+AskUserQuestion (requirements clarification)
   ↓
-Codex 分析（提取要点和任务）
+Codex analysis (extract key points and tasks)
   ↓
-develop-doc-generator（生成开发文档）
+develop-doc-generator (create dev doc)
   ↓
-Codex 并发开发（2-5个任务）
+Codex concurrent development (2–5 tasks)
   ↓
-Codex 测试验证（≥90%覆盖率）
+Codex testing & verification (≥90% coverage)
   ↓
-完成（生成总结）
+Done (generate summary)
 ```
 
-## 6个步骤
+## The 6 Steps
 
-### 1. 需求澄清
+### 1. Clarify Requirements
-- 使用 **AskUserQuestion** 直接问用户
+- Use **AskUserQuestion** to ask the user directly
-- 无评分系统，无复杂逻辑
+- No scoring system, no complex logic
-- 2-3 轮问答直到需求明确
+- 2–3 rounds of Q&A until the requirement is clear
 
-### 2. Codex 分析
+### 2. Codex Analysis
-- 调用 codex 分析需求
+- Call codex to analyze the request
-- 提取：核心功能、技术要点、任务列表（2-5个）
+- Extract: core functions, technical points, task list (2–5 items)
-- 输出结构化分析结果
+- Output a structured analysis
 
-### 3. 生成开发文档
+### 3. Generate Dev Doc
-- 调用 **develop-doc-generator** agent
+- Call the **develop-doc-generator** agent
-- 生成 `dev-plan.md`（单一开发文档）
+- Produce a single `dev-plan.md`
-- 包含：任务分解、文件范围、依赖关系、测试命令
+- Include: task breakdown, file scope, dependencies, test commands
 
-### 4. 并发开发
+### 4. Concurrent Development
-- 基于 dev-plan.md 的任务列表
+- Work from the task list in dev-plan.md
-- 无依赖任务 → 并发执行
+- Independent tasks → run in parallel
-- 有冲突任务 → 串行执行
+- Conflicting tasks → run serially
 
-### 5. 测试验证
+### 5. Testing & Verification
-- 每个 codex 任务自己：
+- Each codex task:
-  - 实现功能
+  - Implements the feature
-  - 编写测试
+  - Writes tests
-  - 运行覆盖率
+  - Runs coverage
-  - 报告结果（≥90%）
+  - Reports results (≥90%)
 
-### 6. 完成
+### 6. Complete
-- 汇总任务状态
+- Summarize task status
-- 记录覆盖率
+- Record coverage
 
-## 使用方法
+## Usage
 
 ```bash
-/dev "实现用户登录功能，支持邮箱和密码验证"
+/dev "Implement user login with email + password"
 ```
 
-**无选项**，流程固定，开箱即用。
+**No options**, fixed workflow, works out of the box.
 
-## 输出结构
+## Output Structure
 
 ```
 .claude/specs/{feature_name}/
-├── dev-plan.md      # 开发文档（agent生成）
+└──  dev-plan.md      # Dev document generated by agent
 ```
 
-仅 2 个文件，极简清晰。
+Only one file—minimal and clear.
 
-## 核心组件
+## Core Components
 
-### 工具
+### Tools
-- **AskUserQuestion**：交互式需求澄清
+- **AskUserQuestion**: interactive requirement clarification
-- **codex**：分析、开发、测试
+- **codex**: analysis, development, testing
-- **develop-doc-generator**：生成开发文档（subagent，节省上下文）
+- **develop-doc-generator**: generate dev doc (subagent, saves context)
 
-## 核心特性
+## Key Features
 
-### ✅ 全新设计
+### ✅ Fresh Design
-- 无历史项目残留
+- No legacy project residue
-- 无复杂评分逻辑
+- No complex scoring logic
-- 无多余抽象层
+- No extra abstraction layers
 
-### ✅ 极简编排
+### ✅ Minimal Orchestration
-- orchestrator 直接控制流程
+- Orchestrator controls the flow directly
-- 只用 3 个工具/组件
+- Only three tools/components
-- 步骤清晰易懂
+- Steps are straightforward
 
-### ✅ 并发能力
+### ✅ Concurrency
-- 2-5 个任务并行
+- 2–5 tasks in parallel
-- 自动检测依赖和冲突
+- Auto-detect dependencies and conflicts
-- codex 独立执行
+- Codex executes independently
 
-### ✅ 质量保证
+### ✅ Quality Assurance
-- 强制 90% 覆盖率
+- Enforces 90% coverage
-- codex 自己测试和验证
+- Codex tests and verifies its own work
-- 失败自动重试
+- Automatic retry on failure
 
-## 示例
+## Example
 
 ```bash
-# 触发
+# Trigger
-/dev "添加用户登录功能"
+/dev "Add user login feature"
 
-# 步骤 1: 需求澄清
+# Step 1: Clarify requirements
-Q: 支持哪些登录方式？
+Q: What login methods are supported?
-A: 邮箱 + 密码
+A: Email + password
-Q: 需要记住登录状态吗？
+Q: Should login be remembered?
-A: 是，使用 JWT token
+A: Yes, use JWT token
 
-# 步骤 2: Codex 分析
+# Step 2: Codex analysis
-输出：
+Output:
-- 核心功能：邮箱密码登录 + JWT认证
+- Core: email/password login + JWT auth
-- 任务 1：后端 API
+- Task 1: Backend API
-- 任务 2：密码加密
+- Task 2: Password hashing
-- 任务 3：前端表单
+- Task 3: Frontend form
 
-# 步骤 3: 生成文档
+# Step 3: Generate doc
-dev-plan.md 已生成 ✓
+dev-plan.md generated ✓
 
-# 步骤 4-5: 并发开发
+# Step 4-5: Concurrent development
-[task-1] 后端API → 测试 → 92% ✓
+[task-1] Backend API → tests → 92% ✓
-[task-2] 密码加密 → 测试 → 95% ✓
+[task-2] Password hashing → tests → 95% ✓
-[task-3] 前端表单 → 测试 → 91% ✓
+[task-3] Frontend form → tests → 91% ✓
 ```
 
-## 目录结构
+## Directory Structure
 
 ```
 dev-workflow/
-├── README.md                          # 本文档
+├── README.md                          # This doc
 ├── commands/
-│   └── dev.md                         # 工作流定义
+│   └── dev.md                         # Workflow definition
 └── agents/
-    └── develop-doc-generator.md       # 文档生成器
+    └── develop-doc-generator.md       # Doc generator
 ```
 
-极简结构，只有 3 个文件。
+Minimal structure, only three files.
 
-## 适用场景
+## When to Use
 
-✅ **适合**：
+✅ **Good for**:
-- 任何规模的功能开发
+- Any feature size
-- 需要快速迭代
+- Fast iterations
-- 需要高测试覆盖率
+- High test coverage needs
-- 希望并发提速
+- Wanting concurrent speed-up
 
-## 设计原则
+## Design Principles
 
-1. **KISS**：保持简单愚蠢
+1. **KISS**: keep it simple
-2. **即用即抛**：无持久化配置
+2. **Disposable**: no persistent config
-3. **质量优先**：强制 90% 覆盖率
+3. **Quality first**: enforce 90% coverage
-4. **并发优先**：充分利用 codex 能力
+4. **Concurrency first**: leverage codex
-5. **无历史包袱**：全新设计，不受其他项目影响
+5. **No legacy baggage**: clean-slate design
 
 ---
 
-**哲学**：像 Linus 一样对复杂度零容忍，交付能立刻用的最小方案。
+**Philosophy**: zero tolerance for complexity—ship the smallest usable solution, like Linus would.

dev-workflow/agents/dev-plan-generator.md

@@ -20,35 +20,35 @@ Your output is a single file: `./.claude/specs/{feature_name}/dev-plan.md`
 ## Document Structure You Must Follow
 
 ```markdown
-# {Feature Name} - 开发计划
+# {Feature Name} - Development Plan
 
-## 功能概述
+## Overview
-[一句话描述核心功能]
+[One-sentence description of core functionality]
 
-## 任务分解
+## Task Breakdown
 
-### 任务 1: [任务名称]
+### Task 1: [Task Name]
 - **ID**: task-1
-- **描述**: [具体要做什么]
+- **Description**: [What needs to be done]
-- **文件范围**: [涉及的目录或文件，如 src/auth/**, tests/auth/]
+- **File Scope**: [Directories or files involved, e.g., src/auth/**, tests/auth/]
-- **依赖**: [无 或 依赖 task-x]
+- **Dependencies**: [None or depends on task-x]
-- **测试命令**: [如 pytest tests/auth --cov=src/auth --cov-report=term]
+- **Test Command**: [e.g., pytest tests/auth --cov=src/auth --cov-report=term]
-- **测试重点**: [需要覆盖的场景]
+- **Test Focus**: [Scenarios to cover]
 
-### 任务 2: [任务名称]
+### Task 2: [Task Name]
 ...
 
-（2-5个任务）
+(2-5 tasks)
 
-## 验收标准
+## Acceptance Criteria
-- [ ] 功能点 1
+- [ ] Feature point 1
-- [ ] 功能点 2
+- [ ] Feature point 2
-- [ ] 所有单元测试通过
+- [ ] All unit tests pass
-- [ ] 代码覆盖率 ≥90%
+- [ ] Code coverage ≥90%
 
-## 技术要点
+## Technical Notes
-- [关键技术决策]
+- [Key technical decisions]
-- [需要注意的约束]
+- [Constraints to be aware of]
 ```
 
 ## Generation Rules You Must Enforce
@@ -58,7 +58,7 @@ Your output is a single file: `./.claude/specs/{feature_name}/dev-plan.md`
    - Clear ID (task-1, task-2, etc.)
    - Specific description of what needs to be done
    - Explicit file scope (directories or files affected)
-   - Dependency declaration ("无" or "依赖 task-x")
+   - Dependency declaration ("None" or "depends on task-x")
    - Complete test command with coverage parameters
    - Testing focus points (scenarios to cover)
 3. **Task Independence**: Design tasks to be as independent as possible to enable parallel execution
@@ -78,7 +78,7 @@ Your output is a single file: `./.claude/specs/{feature_name}/dev-plan.md`
 ## Quality Checks Before Writing
 
 - [ ] Task count is between 2-5
-- [ ] Every task has all 6 required fields (ID, 描述, 文件范围, 依赖, 测试命令, 测试重点)
+- [ ] Every task has all 6 required fields (ID, Description, File Scope, Dependencies, Test Command, Test Focus)
 - [ ] Test commands include coverage parameters
 - [ ] Dependencies are explicitly stated
 - [ ] Acceptance criteria includes 90% coverage requirement
@@ -90,7 +90,7 @@ Your output is a single file: `./.claude/specs/{feature_name}/dev-plan.md`
 - **Document Only**: You generate documentation. You do NOT execute code, run tests, or modify source files.
 - **Single Output**: You produce exactly one file: `dev-plan.md` in the correct location
 - **Path Accuracy**: The path must be `./.claude/specs/{feature_name}/dev-plan.md` where {feature_name} matches the input
-- **Chinese Language**: The document must be in Chinese (as shown in the structure)
+- **Language Matching**: Output language matches user input (Chinese input → Chinese doc, English input → English doc)
 - **Structured Format**: Follow the exact markdown structure provided
 
 ## Example Output Quality

dev-workflow/commands/dev.md

@@ -20,61 +20,57 @@ You are the /dev Workflow Orchestrator, an expert development workflow manager s
   - Focus questions on functional boundaries, inputs/outputs, constraints, testing
   - Iterate 2-3 rounds until clear; rely on judgment; keep questions concise
 
-- **Step 2: Codex Analysis**
+- **Step 2: Codex Deep Analysis (Plan Mode Style)**
-  - Run:
-    ```bash
-    uv run ~/.claude/skills/codex/scripts/codex.py "分析以下需求并提取开发要点：
 
-    需求描述：
+  Use Codex Skill to perform deep analysis. Codex should operate in "plan mode" style:
-    [用户需求 + 澄清后的细节]
 
-    请输出：
+  **When Deep Analysis is Needed** (any condition triggers):
-    1. 核心功能（一句话）
+  - Multiple valid approaches exist (e.g., Redis vs in-memory vs file-based caching)
-    2. 关键技术点
+  - Significant architectural decisions required (e.g., WebSockets vs SSE vs polling)
-    3. 可并发的任务分解（2-5个）：
+  - Large-scale changes touching many files or systems
-       - 任务ID
+  - Unclear scope requiring exploration first
-       - 任务描述
+
-       - 涉及文件/目录
+  **What Codex Does in Analysis Mode**:
-       - 是否依赖其他任务
+  1. **Explore Codebase**: Use Glob, Grep, Read to understand structure, patterns, architecture
-       - 测试重点
+  2. **Identify Existing Patterns**: Find how similar features are implemented, reuse conventions
-    " "gpt-5.1-codex"
+  3. **Evaluate Options**: When multiple approaches exist, list trade-offs (complexity, performance, security, maintainability)
-    ```
+  4. **Make Architectural Decisions**: Choose patterns, APIs, data models with justification
-  - Extract core functionality, technical key points, and 2-5 parallelizable tasks with full metadata
+  5. **Design Task Breakdown**: Produce 2-5 parallelizable tasks with file scope and dependencies
+
+  **Analysis Output Structure**:
+  ```
+  ## Context & Constraints
+  [Tech stack, existing patterns, constraints discovered]
+
+  ## Codebase Exploration
+  [Key files, modules, patterns found via Glob/Grep/Read]
+
+  ## Implementation Options (if multiple approaches)
+  | Option | Pros | Cons | Recommendation |
+
+  ## Technical Decisions
+  [API design, data models, architecture choices made]
+
+  ## Task Breakdown
+  [2-5 tasks with: ID, description, file scope, dependencies, test command]
+  ```
+
+  **Skip Deep Analysis When**:
+  - Simple, straightforward implementation with obvious approach
+  - Small changes confined to 1-2 files
+  - Clear requirements with single implementation path
 
 - **Step 3: Generate Development Documentation**
-  - Use Task tool to invoke develop-doc-generator:
+  - invoke agent dev-plan-generator
-    ```
-    基于以下分析结果生成开发文档：
-
-    [Codex 分析输出]
-
-    输出文件：./.claude/specs/{feature_name}/dev-plan.md
-
-    包含：
-    1. 功能概述
-    2. 任务列表（2-5个并发任务）
-       - 每个任务：ID、描述、文件范围、依赖、测试命令
-    3. 验收标准
-    4. 覆盖率要求：≥90%
-    ```
 
 - **Step 4: Parallel Development Execution**
-  - For each task in `dev-plan.md` run:
+  - For each task in `dev-plan.md`, invoke Codex with this brief:
-    ```bash
+    ```
-    uv run ~/.claude/skills/codex/scripts/codex.py "实现任务：[任务ID]
+    Task: [task-id]
-
+    Reference: @.claude/specs/{feature_name}/dev-plan.md
-    参考文档：@.claude/specs/{feature_name}/dev-plan.md
+    Scope: [task file scope]
-
+    Test: [test command]
-    你的职责：
+    Deliverables: code + unit tests + coverage ≥90% + coverage summary
-    1. 实现功能代码
-    2. 编写单元测试
-    3. 运行测试 + 覆盖率
-    4. 报告覆盖率结果
-
-    文件范围：[任务的文件范围]
-    测试命令：[任务指定的测试命令]
-    覆盖率目标：≥90%
-    " "gpt-5.1-codex"
     ```
   - Execute independent tasks concurrently; serialize conflicting ones; track coverage reports
 

skills/codex/SKILL.md

@@ -14,31 +14,44 @@ Execute Codex CLI commands and parse structured JSON responses. Supports file re
 - Complex code analysis requiring deep understanding
 - Large-scale refactoring across multiple files
 - Automated code generation with safety controls
-- Tasks requiring specialized reasoning models (gpt-5.1, gpt-5.1-codex)
 
 ## Usage
 
-**Mandatory**: Run every automated invocation through the Bash tool in the foreground with the command below, keeping the `timeout` parameter fixed at `7200000` milliseconds (do not change it or use any other entry point).
+**Mandatory**: Run every automated invocation through the Bash tool in the foreground with **HEREDOC syntax** to avoid shell quoting issues, keeping the `timeout` parameter fixed at `7200000` milliseconds (do not change it or use any other entry point).
+
 ```bash
-uv run ~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
+uv run ~/.claude/skills/codex/scripts/codex.py - [working_dir] <<'EOF'
+<task content here>
+EOF
 ```
 
-**Optional methods** (direct execution or via Python):
+**Why HEREDOC?** Tasks often contain code blocks, nested quotes, shell metacharacters (`$`, `` ` ``, `\`), and multiline text. HEREDOC (Here Document) syntax passes these safely without shell interpretation, eliminating quote-escaping nightmares.
+
+**Foreground only (no background/BashOutput)**: Never set `background: true`, never accept Claude's "Running in the background" mode, and avoid `BashOutput` streaming loops. Keep a single foreground Bash call per Codex task; if work might be long, split it into smaller foreground runs instead of offloading to background execution.
+
+**Simple tasks** (backward compatibility):
+For simple single-line tasks without special characters, you can still use direct quoting:
 ```bash
-~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
+uv run ~/.claude/skills/codex/scripts/codex.py "simple task here" [working_dir]
-# or
-python3 ~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
 ```
 
-Resume a session:
+**Resume a session with HEREDOC:**
 ```bash
-uv run ~/.claude/skills/codex/scripts/codex.py resume <session_id> "<task>" [model] [working_dir]
+uv run ~/.claude/skills/codex/scripts/codex.py resume <session_id> - [working_dir] <<'EOF'
+<task content>
+EOF
 ```
 
+**Cross-platform notes:**
+- **Bash/Zsh**: Use `<<'EOF'` (single quotes prevent variable expansion)
+- **PowerShell 5.1+**: Use `@'` and `'@` (here-string syntax)
+  ```powershell
+  uv run ~/.claude/skills/codex/scripts/codex.py - @'
+  task content
+  '@
+  ```
+
 ## Environment Variables
-
-- **CODEX_MODEL**: Override default model (default: `gpt-5.1-codex`)
-  - Example: `export CODEX_MODEL=gpt-5-codex`
 - **CODEX_TIMEOUT**: Override timeout in milliseconds (default: 7200000 = 2 hours)
   - Example: `export CODEX_TIMEOUT=3600000` for 1 hour
 
@@ -53,9 +66,6 @@ uv run ~/.claude/skills/codex/scripts/codex.py resume <session_id> "<task>" [mod
 ### Parameters
 
 - `task` (required): Task description, supports `@file` references
-- `model` (optional): Model to use (default: gpt-5.1-codex)
-  - `gpt-5.1-codex`: Default, optimized for code
-  - `gpt-5.1`: Fast general purpose
 - `working_dir` (optional): Working directory (default: current)
 
 ### Return Format
@@ -73,64 +83,86 @@ Error format (stderr):
 ERROR: Error message
 ```
 
+Return only the final agent message and session ID—do not paste raw `BashOutput` logs or background-task chatter into the conversation.
+
 ### Invocation Pattern
 
-All automated executions may only invoke `uv run ~/.claude/skills/codex/scripts/codex.py "<task>" ...` through the Bash tool in the foreground, and the `timeout` must remain fixed at `7200000` (non-negotiable):
+All automated executions must use HEREDOC syntax through the Bash tool in the foreground, with `timeout` fixed at `7200000` (non-negotiable):
+
 ```
 Bash tool parameters:
-- command: uv run ~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
+- command: uv run ~/.claude/skills/codex/scripts/codex.py - [working_dir] <<'EOF'
+  <task content>
+  EOF
 - timeout: 7200000
 - description: <brief description of the task>
 ```
+
 Run every call in the foreground—never append `&` to background it—so logs and errors stay visible for timely interruption or diagnosis.
 
-Alternatives:
+**Important:** Use HEREDOC (`<<'EOF'`) for all but the simplest tasks. This prevents shell interpretation of quotes, variables, and special characters.
-```
-# Direct execution (simplest)
-- command: ~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
-
-# Using python3
-- command: python3 ~/.claude/skills/codex/scripts/codex.py "<task>" [model] [working_dir]
-```
 
 ### Examples
 
 **Basic code analysis:**
 ```bash
-# Recommended: via uv run (auto-manages Python environment)
+# Recommended: via uv run with HEREDOC (handles any special characters)
-uv run ~/.claude/skills/codex/scripts/codex.py "explain @src/main.ts"
+uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'
+explain @src/main.ts
+EOF
 # timeout: 7200000
 
-# Alternative: direct execution
+# Alternative: simple direct quoting (if task is simple)
-~/.claude/skills/codex/scripts/codex.py "explain @src/main.ts"
+uv run ~/.claude/skills/codex/scripts/codex.py "explain @src/main.ts"
 ```
 
-**Refactoring with specific model:**
+**Refactoring with multiline instructions:**
 ```bash
-uv run ~/.claude/skills/codex/scripts/codex.py "refactor @src/utils for performance" "gpt-5.1-codex"
+uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'
+refactor @src/utils for performance:
+- Extract duplicate code into helpers
+- Use memoization for expensive calculations
+- Add inline comments for non-obvious logic
+EOF
 # timeout: 7200000
 ```
 
 **Multi-file analysis:**
 ```bash
-uv run ~/.claude/skills/codex/scripts/codex.py "analyze @. and find security issues" "gpt-5.1-codex" "/path/to/project"
+uv run ~/.claude/skills/codex/scripts/codex.py - "/path/to/project" <<'EOF'
+analyze @. and find security issues:
+1. Check for SQL injection vulnerabilities
+2. Identify XSS risks in templates
+3. Review authentication/authorization logic
+4. Flag hardcoded credentials or secrets
+EOF
 # timeout: 7200000
 ```
 
 **Resume previous session:**
 ```bash
 # First session
-uv run ~/.claude/skills/codex/scripts/codex.py "add comments to @utils.js" "gpt-5.1-codex"
+uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'
+add comments to @utils.js explaining the caching logic
+EOF
 # Output includes: SESSION_ID: 019a7247-ac9d-71f3-89e2-a823dbd8fd14
 
-# Continue the conversation
+# Continue the conversation with more context
-uv run ~/.claude/skills/codex/scripts/codex.py resume 019a7247-ac9d-71f3-89e2-a823dbd8fd14 "now add type hints"
+uv run ~/.claude/skills/codex/scripts/codex.py resume 019a7247-ac9d-71f3-89e2-a823dbd8fd14 - <<'EOF'
+now add TypeScript type hints and handle edge cases where cache is null
+EOF
 # timeout: 7200000
 ```
 
-**Using python3 directly (alternative):**
+**Task with code snippets and special characters:**
 ```bash
-python3 ~/.claude/skills/codex/scripts/codex.py "your task here"
+uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'
+Fix the bug in @app.js where the regex /\d+/ doesn't match "123"
+The current code is:
+  const re = /\d+/;
+  if (re.test(input)) { ... }
+Add proper escaping and handle $variables correctly.
+EOF
 ```
 
 ### Large Task Protocol
@@ -141,8 +173,8 @@ python3 ~/.claude/skills/codex/scripts/codex.py "your task here"
 
 | ID | Description | Scope | Dependencies | Tests | Command |
 | --- | --- | --- | --- | --- | --- |
-| T1 | Review @spec.md to extract requirements | docs/, @spec.md | None | None | uv run ~/.claude/skills/codex/scripts/codex.py "analyze requirements @spec.md" |
+| T1 | Review @spec.md to extract requirements | docs/, @spec.md | None | None | `uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'`<br/>`analyze requirements @spec.md`<br/>`EOF` |
-| T2 | Implement the module and add test cases | src/module | T1 | npm test -- --runInBand | uv run ~/.claude/skills/codex/scripts/codex.py "implement and test @src/module" |
+| T2 | Implement the module and add test cases | src/module | T1 | npm test -- --runInBand | `uv run ~/.claude/skills/codex/scripts/codex.py - <<'EOF'`<br/>`implement and test @src/module`<br/>`EOF` |
 
 ## Notes
 

skills/codex/scripts/codex.py

@@ -8,10 +8,14 @@ Codex CLI wrapper with cross-platform support and session management.
 **FIXED**: Auto-detect long inputs and use stdin mode to avoid shell argument issues.
 
 Usage:
-    New session:  uv run codex.py "task" [model] [workdir]
+    New session:  uv run codex.py "task" [workdir]
-    Resume:       uv run codex.py resume <session_id> "task" [model] [workdir]
+    Stdin mode:   uv run codex.py - [workdir]
+    Resume:       uv run codex.py resume <session_id> "task" [workdir]
+    Resume stdin: uv run codex.py resume <session_id> - [workdir]
     Alternative:  python3 codex.py "task"
     Direct exec:  ./codex.py "task"
+
+    Model configuration: Set CODEX_MODEL environment variable (default: gpt-5.1-codex)
 """
 import subprocess
 import json
@@ -78,21 +82,23 @@ def parse_args():
         if len(sys.argv) < 4:
             log_error('Resume mode requires: resume <session_id> <task>')
             sys.exit(1)
+        task_arg = sys.argv[3]
         return {
             'mode': 'resume',
             'session_id': sys.argv[2],
-            'task': sys.argv[3],
+            'task': task_arg,
-            'model': sys.argv[4] if len(sys.argv) > 4 else DEFAULT_MODEL,
+            'explicit_stdin': task_arg == '-',
-            'workdir': sys.argv[5] if len(sys.argv) > 5 else DEFAULT_WORKDIR
+            'workdir': sys.argv[4] if len(sys.argv) > 4 else DEFAULT_WORKDIR,
-        }
-    else:
-        return {
-            'mode': 'new',
-            'task': sys.argv[1],
-            'model': sys.argv[2] if len(sys.argv) > 2 else DEFAULT_MODEL,
-            'workdir': sys.argv[3] if len(sys.argv) > 3 else DEFAULT_WORKDIR
         }
 
+    task_arg = sys.argv[1]
+    return {
+        'mode': 'new',
+        'task': task_arg,
+        'explicit_stdin': task_arg == '-',
+        'workdir': sys.argv[2] if len(sys.argv) > 2 else DEFAULT_WORKDIR,
+    }
+
 
 def read_piped_task() -> Optional[str]:
     """
@@ -102,9 +108,16 @@ def read_piped_task() -> Optional[str]:
     """
     stdin = sys.stdin
     if stdin is None or stdin.isatty():
+        log_info("Stdin is tty or None, skipping pipe read")
         return None
+    log_info("Reading from stdin pipe...")
     data = stdin.read()
-    return data if data else None
+    if not data:
+        log_info("Stdin pipe returned empty data")
+        return None
+
+    log_info(f"Read {len(data)} bytes from stdin pipe")
+    return data
 
 
 def should_stream_via_stdin(task_text: str, piped: bool) -> bool:
@@ -137,6 +150,7 @@ def build_codex_args(params: dict, target_arg: str) -> list:
     if params['mode'] == 'resume':
         return [
             'codex', 'e',
+            '-m', DEFAULT_MODEL,
             '--skip-git-repo-check',
             '--json',
             'resume',
@@ -146,7 +160,7 @@ def build_codex_args(params: dict, target_arg: str) -> list:
     else:
         base_args = [
             'codex', 'e',
-            '-m', params['model'],
+            '-m', DEFAULT_MODEL,
             '--dangerously-bypass-approvals-and-sandbox',
             '--skip-git-repo-check',
             '-C', params['workdir'],
@@ -168,6 +182,7 @@ def run_codex_process(codex_args, task_text: str, use_stdin: bool, timeout_sec:
 
     try:
         # 启动 codex 子进程（文本模式管道）
+        log_info(f"Starting codex with args: {' '.join(codex_args[:5])}...")
         process = subprocess.Popen(
             codex_args,
             stdin=subprocess.PIPE if use_stdin else None,
@@ -176,17 +191,23 @@ def run_codex_process(codex_args, task_text: str, use_stdin: bool, timeout_sec:
             text=True,
             bufsize=1,
         )
+        log_info(f"Process started with PID: {process.pid}")
 
         # 如果使用 stdin 模式，写入任务到 stdin 并关闭
         if use_stdin and process.stdin is not None:
+            log_info(f"Writing {len(task_text)} chars to stdin...")
             process.stdin.write(task_text)
+            process.stdin.flush()  # 强制刷新缓冲区，避免大任务死锁
             process.stdin.close()
+            log_info("Stdin closed")
 
         # 逐行解析 JSON 输出
         if process.stdout is None:
             log_error('Codex stdout pipe not available')
             sys.exit(1)
 
+        log_info("Reading stdout...")
+
         for line in process.stdout:
             line = line.strip()
             if not line:
@@ -247,19 +268,34 @@ def run_codex_process(codex_args, task_text: str, use_stdin: bool, timeout_sec:
 
 
 def main():
+    log_info("Script started")
     params = parse_args()
+    log_info(f"Parsed args: mode={params['mode']}, task_len={len(params['task'])}")
     timeout_sec = resolve_timeout()
+    log_info(f"Timeout: {timeout_sec}s")
 
-    piped_task = read_piped_task()
+    explicit_stdin = params.get('explicit_stdin', False)
-    piped = piped_task is not None
-    task_text = piped_task if piped else params['task']
 
-    use_stdin = should_stream_via_stdin(task_text, piped)
+    if explicit_stdin:
+        log_info("Explicit stdin mode: reading task from stdin")
+        task_text = sys.stdin.read()
+        if not task_text:
+            log_error("Explicit stdin mode requires task input from stdin")
+            sys.exit(1)
+        piped = not sys.stdin.isatty()
+    else:
+        piped_task = read_piped_task()
+        piped = piped_task is not None
+        task_text = piped_task if piped else params['task']
+
+    use_stdin = explicit_stdin or should_stream_via_stdin(task_text, piped)
 
     if use_stdin:
         reasons = []
         if piped:
             reasons.append('piped input')
+        if explicit_stdin:
+            reasons.append('explicit "-"')
         if '\n' in task_text:
             reasons.append('newline')
         if '\\' in task_text:

skills/gemini/SKILL.md

@@ -17,38 +17,32 @@ Execute Gemini CLI commands with support for multiple models and flexible prompt
 - Alternative perspective on code problems
 
 ## Usage
-
+**Mandatory**: Run via uv with fixed timeout 7200000ms (foreground):
-**推荐方式**（使用 uv run，自动管理 Python 环境）：
 ```bash
-uv run ~/.claude/skills/gemini/scripts/gemini.py -m <model> -p "<prompt>" [working_dir]
+uv run ~/.claude/skills/gemini/scripts/gemini.py "<prompt>" [working_dir]
 ```
 
-**备选方式**（直接执行或使用 Python）：
+**Optional** (direct execution or using Python):
 ```bash
-~/.claude/skills/gemini/scripts/gemini.py -m <model> -p "<prompt>" [working_dir]
+~/.claude/skills/gemini/scripts/gemini.py "<prompt>" [working_dir]
-# 或
+# or
-python3 ~/.claude/skills/gemini/scripts/gemini.py -m <model> -p "<prompt>" [working_dir]
+python3 ~/.claude/skills/gemini/scripts/gemini.py "<prompt>" [working_dir]
 ```
 
 ## Environment Variables
 
-- **GEMINI_MODEL**: Override default model (default: `gemini-3-pro-preview`)
+- **GEMINI_MODEL**: Configure model (default: `gemini-3-pro-preview`)
   - Example: `export GEMINI_MODEL=gemini-3`
-- **GEMINI_TIMEOUT**: Override timeout in milliseconds (default: 7200000 = 2 hours)
-  - Example: `export GEMINI_TIMEOUT=3600000` for 1 hour
 
 ## Timeout Control
 
-- **Built-in**: Script enforces 2-hour timeout by default
+- **Fixed**: 7200000 milliseconds (2 hours), immutable
-- **Override**: Set `GEMINI_TIMEOUT` environment variable (in milliseconds)
+- **Bash tool**: Always set `timeout: 7200000` for double protection
-- **Bash tool**: Always set `timeout: 7200000` parameter for double protection
 
 ### Parameters
 
-- `-m, --model` (optional): Model to use (default: gemini-3-pro-preview)
+- `prompt` (required): Task prompt or question
-  - `gemini-3-pro-preview`: Latest flagship model
+- `working_dir` (optional): Working directory (default: current directory)
-- `-p, --prompt` (required): Task prompt or question
-- `working_dir` (optional): Working directory (default: current)
 
 ### Return Format
 
@@ -70,7 +64,7 @@ When calling via Bash tool, always include the timeout parameter:
 
 ```yaml
 Bash tool parameters:
-- command: uv run ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "<prompt>"
+- command: uv run ~/.claude/skills/gemini/scripts/gemini.py "<prompt>"
 - timeout: 7200000
 - description: <brief description of the task>
 ```
@@ -79,10 +73,10 @@ Alternatives:
 
 ```yaml
 # Direct execution (simplest)
-- command: ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "<prompt>"
+- command: ~/.claude/skills/gemini/scripts/gemini.py "<prompt>"
 
 # Using python3
-- command: python3 ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "<prompt>"
+- command: python3 ~/.claude/skills/gemini/scripts/gemini.py "<prompt>"
 ```
 
 ### Examples
@@ -90,39 +84,28 @@ Alternatives:
 **Basic query:**
 
 ```bash
-# Recommended: via uv run
+uv run ~/.claude/skills/gemini/scripts/gemini.py "explain quantum computing"
-uv run ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "explain quantum computing"
 # timeout: 7200000
-
-# Alternative: direct execution
-~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "explain quantum computing"
 ```
 
 **Code analysis:**
 
 ```bash
-uv run ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "review this code for security issues: $(cat app.py)"
+uv run ~/.claude/skills/gemini/scripts/gemini.py "review this code for security issues: $(cat app.py)"
 # timeout: 7200000
 ```
 
 **With specific working directory:**
 
 ```bash
-uv run ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "analyze project structure" "/path/to/project"
+uv run ~/.claude/skills/gemini/scripts/gemini.py "analyze project structure" "/path/to/project"
-# timeout: 7200000
-```
-
-**Using fast model:**
-
-```bash
-uv run ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "quick code suggestion"
 # timeout: 7200000
 ```
 
 **Using python3 directly (alternative):**
 
 ```bash
-python3 ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "your prompt here"
+python3 ~/.claude/skills/gemini/scripts/gemini.py "your prompt here"
 ```
 
 ## Notes
@@ -133,5 +116,5 @@ python3 ~/.claude/skills/gemini/scripts/gemini.py -m gemini-3-pro-preview -p "yo
 - Cross-platform compatible (Windows/macOS/Linux)
 - PEP 723 compliant (inline script metadata)
 - Requires Gemini CLI installed and authenticated
-- Supports all Gemini model variants
+- Supports all Gemini model variants (configure via `GEMINI_MODEL` environment variable)
 - Output is streamed directly from Gemini CLI

skills/gemini/scripts/gemini.py

@@ -7,18 +7,18 @@
 Gemini CLI wrapper with cross-platform support.
 
 Usage:
-    uv run gemini.py -m <model> -p "<prompt>" [workdir]
+    uv run gemini.py "<prompt>" [workdir]
-    python3 gemini.py -m <model> -p "<prompt>"
+    python3 gemini.py "<prompt>"
-    ./gemini.py -m gemini-3-pro-preview -p "your prompt"
+    ./gemini.py "your prompt"
 """
 import subprocess
 import sys
 import os
-import argparse
 
 DEFAULT_MODEL = os.environ.get('GEMINI_MODEL', 'gemini-3-pro-preview')
 DEFAULT_WORKDIR = '.'
-DEFAULT_TIMEOUT = 7200  # 2 hours in seconds
+TIMEOUT_MS = 7_200_000  # 固定 2 小时，毫秒
+DEFAULT_TIMEOUT = TIMEOUT_MS // 1000
 FORCE_KILL_DELAY = 5
 
 
@@ -32,76 +32,56 @@ def log_warn(message: str):
     sys.stderr.write(f"WARN: {message}\n")
 
 
-def resolve_timeout() -> int:
+def log_info(message: str):
-    """解析超时配置（秒）"""
+    """输出信息到 stderr"""
-    raw = os.environ.get('GEMINI_TIMEOUT', '')
+    sys.stderr.write(f"INFO: {message}\n")
-    if not raw:
-        return DEFAULT_TIMEOUT
-
-    try:
-        parsed = int(raw)
-        if parsed <= 0:
-            log_warn(f"Invalid GEMINI_TIMEOUT '{raw}', falling back to {DEFAULT_TIMEOUT}s")
-            return DEFAULT_TIMEOUT
-        # 环境变量是毫秒，转换为秒
-        return parsed // 1000 if parsed > 10000 else parsed
-    except ValueError:
-        log_warn(f"Invalid GEMINI_TIMEOUT '{raw}', falling back to {DEFAULT_TIMEOUT}s")
-        return DEFAULT_TIMEOUT
 
 
 def parse_args():
-    """解析命令行参数"""
+    """解析位置参数"""
-    parser = argparse.ArgumentParser(
+    if len(sys.argv) < 2:
-        description='Gemini CLI wrapper for Claude Code integration',
+        log_error('Prompt required')
-        formatter_class=argparse.RawDescriptionHelpFormatter
+        sys.exit(1)
-    )
-    parser.add_argument(
-        '-m', '--model',
-        default=DEFAULT_MODEL,
-        help=f'Gemini model to use (default: {DEFAULT_MODEL})'
-    )
-    parser.add_argument(
-        '-p', '--prompt',
-        required=True,
-        help='Prompt to send to Gemini'
-    )
-    parser.add_argument(
-        'workdir',
-        nargs='?',
-        default=DEFAULT_WORKDIR,
-        help='Working directory (default: current directory)'
-    )
 
-    return parser.parse_args()
+    return {
+        'prompt': sys.argv[1],
+        'workdir': sys.argv[2] if len(sys.argv) > 2 else DEFAULT_WORKDIR
+    }
 
 
 def build_gemini_args(args) -> list:
     """构建 gemini CLI 参数"""
     return [
         'gemini',
-        '-m', args.model,
+        '-m', DEFAULT_MODEL,
-        '-p', args.prompt
+        '-p', args['prompt']
     ]
 
 
 def main():
+    log_info('Script started')
     args = parse_args()
+    log_info(f"Prompt length: {len(args['prompt'])}")
+    log_info(f"Working dir: {args['workdir']}")
     gemini_args = build_gemini_args(args)
-    timeout_sec = resolve_timeout()
+    timeout_sec = DEFAULT_TIMEOUT
+    log_info(f"Timeout: {timeout_sec}s")
 
     # 如果指定了工作目录，切换到该目录
-    if args.workdir != DEFAULT_WORKDIR:
+    if args['workdir'] != DEFAULT_WORKDIR:
         try:
-            os.chdir(args.workdir)
+            os.chdir(args['workdir'])
         except FileNotFoundError:
-            log_error(f"Working directory not found: {args.workdir}")
+            log_error(f"Working directory not found: {args['workdir']}")
             sys.exit(1)
         except PermissionError:
-            log_error(f"Permission denied: {args.workdir}")
+            log_error(f"Permission denied: {args['workdir']}")
             sys.exit(1)
+        log_info('Changed working directory')
 
     try:
+        log_info(f"Starting gemini with model {DEFAULT_MODEL}")
+        process = None
         # 启动 gemini 子进程，直接透传 stdout 和 stderr
         process = subprocess.Popen(
             gemini_args,
@@ -112,11 +92,9 @@ def main():
         )
 
         # 实时输出 stdout
-        stdout_lines = []
         for line in process.stdout:
             sys.stdout.write(line)
             sys.stdout.flush()
-            stdout_lines.append(line)
 
         # 等待进程结束
         returncode = process.wait(timeout=timeout_sec)
@@ -135,11 +113,12 @@ def main():
 
     except subprocess.TimeoutExpired:
         log_error(f'Gemini execution timeout ({timeout_sec}s)')
-        process.kill()
+        if process is not None:
-        try:
+            process.kill()
-            process.wait(timeout=FORCE_KILL_DELAY)
+            try:
-        except subprocess.TimeoutExpired:
+                process.wait(timeout=FORCE_KILL_DELAY)
-            pass
+            except subprocess.TimeoutExpired:
+                pass
         sys.exit(124)
 
     except FileNotFoundError:
@@ -148,11 +127,12 @@ def main():
         sys.exit(127)
 
     except KeyboardInterrupt:
-        process.terminate()
+        if process is not None:
-        try:
+            process.terminate()
-            process.wait(timeout=FORCE_KILL_DELAY)
+            try:
-        except subprocess.TimeoutExpired:
+                process.wait(timeout=FORCE_KILL_DELAY)
-            process.kill()
+            except subprocess.TimeoutExpired:
+                process.kill()
         sys.exit(130)