claude-code-workflow 6.3.50 → 6.3.51

package/.claude/skills/skill-generator/templates/autonomous-action.md

@@ -1,22 +1,22 @@
 # Autonomous Action Template
 
-自主模式动作文件的模板。
+Template for action files in Autonomous execution mode.
 
 ## Purpose
 
-生成 Autonomous 执行模式的 Action 文件，定义可独立执行的动作单元。
+Generate Action files for Autonomous execution mode, defining independent executable action units.
 
 ## Usage Context
 
 | Phase | Usage |
 |-------|-------|
-| Phase 3 (Phase Generation) | `config.execution_mode === 'autonomous'` 时生成 |
-| Generation Trigger | 为每个 `config.autonomous_config.actions` 生成一个 action 文件 |
+| Phase 3 (Phase Generation) | Generated when `config.execution_mode === 'autonomous'` |
+| Generation Trigger | Generate one action file for each `config.autonomous_config.actions` |
 | Output Location | `.claude/skills/{skill-name}/phases/actions/{action-id}.md` |
 
 ---
 
-## 模板结构
+## Template Structure
 
 ```markdown
 # Action: {{action_name}}
@@ -34,8 +34,8 @@
 ## Scripts
 
 \`\`\`yaml
-# 声明本动作使用的脚本（可选）
-# - script-id        # 对应 scripts/script-id.py 或 .sh
+# Declare scripts used in this action (optional)
+# - script-id        # Corresponds to scripts/script-id.py or .sh
 \`\`\`
 
 ## Execution
@@ -44,7 +44,7 @@
 async function execute(state) {
   {{execution_code}}
 
-  // 调用脚本示例
+  // Script execution example
   // const result = await ExecuteScript('script-id', { input: state.context.data });
   // if (!result.success) throw new Error(result.stderr);
 }
@@ -71,63 +71,66 @@ return {
 {{next_actions_hints}}
 ```
 
-## 变量说明
+## Variable Descriptions
 
-| 变量 | 说明 |
-|------|------|
-| `{{action_name}}` | 动作名称 |
-| `{{action_description}}` | 动作描述 |
-| `{{purpose}}` | 详细目的 |
-| `{{preconditions_list}}` | 前置条件列表 |
-| `{{execution_code}}` | 执行代码 |
-| `{{state_updates}}` | 状态更新 |
-| `{{error_handling_table}}` | 错误处理表格 |
-| `{{next_actions_hints}}` | 后续动作提示 |
+| Variable | Description |
+|----------|-------------|
+| `{{action_name}}` | Action name |
+| `{{action_description}}` | Action description |
+| `{{purpose}}` | Detailed purpose |
+| `{{preconditions_list}}` | List of preconditions |
+| `{{execution_code}}` | Execution code |
+| `{{state_updates}}` | State updates |
+| `{{error_handling_table}}` | Error handling table |
+| `{{next_actions_hints}}` | Next action hints |
 
-## 动作生命周期
+## Action Lifecycle
 
 ```
-状态驱动执行流:
+State-driven execution flow:
 
   state.status === 'pending'
-       ↓
-  ┌─ Init ─┐          ← 1次执行，环境准备
-  │ 创建工作目录        │
-  │ 初始化 context     │
-  │ status → running   │
-  └────┬────┘
-       ↓
-  ┌─ CRUD Loop ─┐     ← N次迭代，核心业务
-  │ 编排器选择动作  │    List / Create / Edit / Delete
-  │ execute(state)  │    共享模式: 收集输入 → 操作 context.items → 返回更新
-  │ 更新 state      │
-  └────┬────┘
-       ↓
-  ┌─ Complete ─┐      ← 1次执行，保存结果
-  │ 序列化输出    │
-  │ status → completed │
-  └──────────┘
-
-共享状态结构:
-  state.status          → 'pending' | 'running' | 'completed'
-  state.context.items   → 业务数据数组
-  state.completed_actions → 已执行动作 ID 列表
+       |
+       v
+  +-- Init --+          <- 1 execution, environment preparation
+  | Create working directory
+  | Initialize context
+  | status -> running
+  +----+----+
+       |
+       v
+  +-- CRUD Loop --+     <- N iterations, core business
+  | Orchestrator selects action  |    List / Create / Edit / Delete
+  | execute(state)  |    Shared pattern: collect input -> operate context.items -> return updates
+  | Update state
+  +----+----+
+       |
+       v
+  +-- Complete --+      <- 1 execution, save results
+  | Serialize output
+  | status -> completed
+  +----------+
+
+Shared state structure:
+  state.status          -> 'pending' | 'running' | 'completed'
+  state.context.items   -> Business data array
+  state.completed_actions -> List of executed action IDs
 ```
 
-## 动作类型模板
+## Action Type Templates
 
-### 1. 初始化动作 (Init)
+### 1. Initialize Action (Init)
 
-**触发条件**: `state.status === 'pending'`，仅执行一次
+**Trigger condition**: `state.status === 'pending'`, executes once
 
 ```markdown
 # Action: Initialize
 
-初始化 Skill 执行状态。
+Initialize Skill execution state.
 
 ## Purpose
 
-设置初始状态，准备执行环境。
+Set initial state, prepare execution environment.
 
 ## Preconditions
 
@@ -151,24 +154,24 @@ async function execute(state) {
 
 ## Next Actions
 
-- 成功: 进入主处理循环 (由编排器选择首个 CRUD 动作)
-- 失败: action-abort
+- Success: Enter main processing loop (Orchestrator selects first CRUD action)
+- Failure: action-abort
 ```
 
-### 2. CRUD 动作 (List / Create / Edit / Delete)
+### 2. CRUD Actions (List / Create / Edit / Delete)
 
-**触发条件**: `state.status === 'running'`，循环执行直至用户退出
+**Trigger condition**: `state.status === 'running'`, loop until user exits
 
-> 以 Create 为示例展示共享模式。List / Edit / Delete 遵循同一结构，仅 `执行逻辑` 和 `状态更新字段` 不同。
+> Example shows Create action demonstrating shared pattern. List / Edit / Delete follow same structure with different execution logic and state update fields.
 
 ```markdown
 # Action: Create Item
 
-创建新项目。
+Create new item.
 
 ## Purpose
 
-收集用户输入，向 context.items 追加新记录。
+Collect user input, append new record to context.items.
 
 ## Preconditions
 
@@ -178,25 +181,25 @@ async function execute(state) {
 
 \`\`\`javascript
 async function execute(state) {
-  // 1. 收集输入
+  // 1. Collect input
   const input = await AskUserQuestion({
     questions: [{
-      question: "请输入项目名称：",
-      header: "名称",
+      question: "Please enter item name:",
+      header: "Name",
       multiSelect: false,
-      options: [{ label: "手动输入", description: "输入自定义名称" }]
+      options: [{ label: "Manual input", description: "Enter custom name" }]
     }]
   });
 
-  // 2. 操作 context.items (核心逻辑因动作类型而异)
+  // 2. Operate context.items (core logic differs by action type)
   const newItem = {
     id: Date.now().toString(),
-    name: input["名称"],
+    name: input["Name"],
     status: 'pending',
     created_at: new Date().toISOString()
   };
 
-  // 3. 返回状态更新
+  // 3. Return state update
   return {
     stateUpdates: {
       context: {
@@ -211,31 +214,31 @@ async function execute(state) {
 
 ## Next Actions
 
-- 继续操作: 编排器根据 state 选择下一动作
-- 用户退出: action-complete
+- Continue operations: Orchestrator selects next action based on state
+- User exit: action-complete
 ```
 
-**其他 CRUD 动作差异对照:**
+**Other CRUD Actions Differences:**
 
-| 动作 | 核心逻辑 | 额外前置条件 | 关键状态字段 |
-|------|---------|------------|------------|
-| List | `items.forEach(→ console.log)` | 无 | `current_view: 'list'` |
-| Create | `items.push(newItem)` | 无 | `last_created_id` |
-| Edit | `items.map(→ 替换匹配项)` | `selected_item_id !== null` | `updated_at` |
-| Delete | `items.filter(→ 排除匹配项)` | `selected_item_id !== null` | 确认对话 → 执行 |
+| Action | Core Logic | Extra Preconditions | Key State Field |
+|--------|-----------|-------------------|-----------------|
+| List | `items.forEach(-> console.log)` | None | `current_view: 'list'` |
+| Create | `items.push(newItem)` | None | `last_created_id` |
+| Edit | `items.map(-> replace matching)` | `selected_item_id !== null` | `updated_at` |
+| Delete | `items.filter(-> exclude matching)` | `selected_item_id !== null` | Confirm dialog -> execute |
 
-### 3. 完成动作 (Complete)
+### 3. Complete Action
 
-**触发条件**: 用户明确退出或终止条件满足，仅执行一次
+**Trigger condition**: User explicitly exits or termination condition met, executes once
 
 ```markdown
 # Action: Complete
 
-完成任务并退出。
+Complete task and exit.
 
 ## Purpose
 
-序列化最终状态，结束 Skill 执行。
+Serialize final state, end Skill execution.
 
 ## Preconditions
 
@@ -253,7 +256,7 @@ async function execute(state) {
     actions_executed: state.completed_actions.length
   };
 
-  console.log(\`任务完成: \${summary.total_items} 项, \${summary.actions_executed} 次操作\`);
+  console.log(\`Task complete: \${summary.total_items} items, \${summary.actions_executed} operations\`);
 
   return {
     stateUpdates: {
@@ -267,31 +270,31 @@ async function execute(state) {
 
 ## Next Actions
 
-- 无（终止状态）
+- None (terminal state)
 ```
 
-## 生成函数
+## Generation Function
 
 ```javascript
 function generateAction(actionConfig, skillConfig) {
   return `# Action: ${actionConfig.name}
 
-${actionConfig.description || `执行 ${actionConfig.name} 操作`}
+${actionConfig.description || `Execute ${actionConfig.name} operation`}
 
 ## Purpose
 
-${actionConfig.purpose || 'TODO: 描述此动作的详细目的'}
+${actionConfig.purpose || 'TODO: Describe detailed purpose of this action'}
 
 ## Preconditions
 
-${actionConfig.preconditions?.map(p => `- [ ] ${p}`).join('\n') || '- [ ] 无特殊前置条件'}
+${actionConfig.preconditions?.map(p => `- [ ] ${p}`).join('\n') || '- [ ] No special preconditions'}
 
 ## Execution
 
 \`\`\`javascript
 async function execute(state) {
-  // TODO: 实现动作逻辑
-  
+  // TODO: Implement action logic
+
   return {
     stateUpdates: {
       completed_actions: [...state.completed_actions, '${actionConfig.id}']
@@ -305,7 +308,7 @@ async function execute(state) {
 \`\`\`javascript
 return {
   stateUpdates: {
-    // TODO: 定义状态更新
+    // TODO: Define state updates
 ${actionConfig.effects?.map(e => `    // Effect: ${e}`).join('\n') || ''}
   }
 };
@@ -315,13 +318,13 @@ ${actionConfig.effects?.map(e => `    // Effect: ${e}`).join('\n') || ''}
 
 | Error Type | Recovery |
 |------------|----------|
-| 数据验证失败 | 返回错误，不更新状态 |
-| 执行异常 | 记录错误，增加 error_count |
+| Data validation failed | Return error, no state update |
+| Execution exception | Log error, increment error_count |
 
 ## Next Actions (Hints)
 
-- 成功: 由编排器根据状态决定
-- 失败: 重试或 action-abort
+- Success: Orchestrator decides based on state
+- Failure: Retry or action-abort
 `;
 }
 ```

package/.claude/skills/skill-generator/templates/autonomous-orchestrator.md

@@ -1,59 +1,59 @@
 # Autonomous Orchestrator Template
 
-自主模式编排器的模板。
+Template for orchestrator file in Autonomous execution mode.
 
 ## Purpose
 
-生成 Autonomous 执行模式的 Orchestrator 文件，负责状态驱动的动作选择和执行循环。
+Generate Orchestrator file for Autonomous execution mode, responsible for state-driven action selection and execution loop.
 
 ## Usage Context
 
 | Phase | Usage |
 |-------|-------|
-| Phase 3 (Phase Generation) | `config.execution_mode === 'autonomous'` 时生成 |
-| Generation Trigger | 创建编排器逻辑，管理动作选择和状态更新 |
+| Phase 3 (Phase Generation) | Generated when `config.execution_mode === 'autonomous'` |
+| Generation Trigger | Create orchestrator logic to manage action selection and state updates |
 | Output Location | `.claude/skills/{skill-name}/phases/orchestrator.md` |
 
 ---
 
-## ⚠️ 重要提示
+## Important Notes
 
-> **Phase 0 是强制前置阶段**：在 Orchestrator 启动执行循环之前，必须先完成 Phase 0 的规范研读。
+> **Phase 0 is mandatory prerequisite**: Before Orchestrator starts execution loop, Phase 0 specification review must be completed first.
 >
-> 生成 Orchestrator 时，需要确保：
-> 1. SKILL.md 中已包含 Phase 0 规范研读步骤
-> 2. Orchestrator 启动前验证规范已阅读
-> 3. 所有 Action 文件都引用相关的规范文档
-> 4. Architecture Overview 中 Phase 0 位于 Orchestrator 之前
+> When generating Orchestrator, ensure:
+> 1. Phase 0 specification review step is included in SKILL.md
+> 2. Orchestrator validates specification has been reviewed before starting execution loop
+> 3. All Action files reference related specification documents
+> 4. Architecture Overview places Phase 0 before Orchestrator
 
-## 模板结构
+## Template Structure
 
 ```markdown
 # Orchestrator
 
 ## Role
 
-根据当前状态选择并执行下一个动作。
+Select and execute next action based on current state.
 
 ## State Management
 
-### 读取状态
+### Read State
 
 \`\`\`javascript
-const state = JSON.parse(Read(`${workDir}/state.json`));
+const state = JSON.parse(Read(\`${workDir}/state.json\`));
 \`\`\`
 
-### 更新状态
+### Update State
 
 \`\`\`javascript
 function updateState(updates) {
-  const state = JSON.parse(Read(`${workDir}/state.json`));
+  const state = JSON.parse(Read(\`${workDir}/state.json\`));
   const newState = {
     ...state,
     ...updates,
     updated_at: new Date().toISOString()
   };
-  Write(`${workDir}/state.json`, JSON.stringify(newState, null, 2));
+  Write(\`${workDir}/state.json\`, JSON.stringify(newState, null, 2));
   return newState;
 }
 \`\`\`
@@ -62,18 +62,18 @@ function updateState(updates) {
 
 \`\`\`javascript
 function selectNextAction(state) {
-  // 1. 终止条件检查
+  // 1. Check termination conditions
   {{termination_checks}}
-  
-  // 2. 错误限制检查
+
+  // 2. Check error limit
   if (state.error_count >= 3) {
     return 'action-abort';
   }
-  
-  // 3. 动作选择逻辑
+
+  // 3. Action selection logic
   {{action_selection_logic}}
-  
-  // 4. 默认完成
+
+  // 4. Default completion
   return 'action-complete';
 }
 \`\`\`
@@ -83,34 +83,34 @@ function selectNextAction(state) {
 \`\`\`javascript
 async function runOrchestrator() {
   console.log('=== Orchestrator Started ===');
-  
+
   let iteration = 0;
   const MAX_ITERATIONS = 100;
-  
+
   while (iteration < MAX_ITERATIONS) {
     iteration++;
-    
-    // 1. 读取当前状态
-    const state = JSON.parse(Read(`${workDir}/state.json`));
-    console.log(`[Iteration ${iteration}] Status: ${state.status}`);
-    
-    // 2. 选择下一个动作
+
+    // 1. Read current state
+    const state = JSON.parse(Read(\`${workDir}/state.json\`));
+    console.log(\`[Iteration ${iteration}] Status: ${state.status}\`);
+
+    // 2. Select next action
     const actionId = selectNextAction(state);
-    
+
     if (!actionId) {
       console.log('No action selected, terminating.');
       break;
     }
-    
-    console.log(`[Iteration ${iteration}] Executing: ${actionId}`);
-    
-    // 3. 更新状态：当前动作
+
+    console.log(\`[Iteration ${iteration}] Executing: ${actionId}\`);
+
+    // 3. Update state: current action
     updateState({ current_action: actionId });
-    
-    // 4. 执行动作
+
+    // 4. Execute action
     try {
-      const actionPrompt = Read(`phases/actions/${actionId}.md`);
-      
+      const actionPrompt = Read(\`phases/actions/${actionId}.md\`);
+
       const result = await Task({
         subagent_type: 'universal-executor',
         run_in_background: false,
@@ -125,18 +125,18 @@ async function runOrchestrator() {
 Return JSON with stateUpdates field.
 \`
       });
-      
+
       const actionResult = JSON.parse(result);
-      
-      // 5. 更新状态：动作完成
+
+      // 5. Update state: action completed
       updateState({
         current_action: null,
         completed_actions: [...state.completed_actions, actionId],
         ...actionResult.stateUpdates
       });
-      
+
     } catch (error) {
-      // 错误处理
+      // Error handling
       updateState({
         current_action: null,
         errors: [...state.errors, {
@@ -148,7 +148,7 @@ Return JSON with stateUpdates field.
       });
     }
   }
-  
+
   console.log('=== Orchestrator Finished ===');
 }
 \`\`\`
@@ -167,28 +167,28 @@ Return JSON with stateUpdates field.
 
 | Error Type | Recovery Strategy |
 |------------|-------------------|
-| 动作执行失败 | 重试最多 3 次 |
-| 状态不一致 | 回滚到上一个稳定状态 |
-| 用户中止 | 保存当前状态，允许恢复 |
+| Action execution failed | Retry up to 3 times |
+| State inconsistency | Rollback to last stable state |
+| User abort | Save current state, allow recovery |
 ```
 
-## 变量说明
+## Variable Descriptions
 
-| 变量 | 说明 |
-|------|------|
-| `{{termination_checks}}` | 终止条件检查代码 |
-| `{{action_selection_logic}}` | 动作选择逻辑代码 |
-| `{{action_catalog_table}}` | 动作目录表格 |
-| `{{termination_conditions_list}}` | 终止条件列表 |
+| Variable | Description |
+|----------|-------------|
+| `{{termination_checks}}` | Termination condition check code |
+| `{{action_selection_logic}}` | Action selection logic code |
+| `{{action_catalog_table}}` | Action directory table |
+| `{{termination_conditions_list}}` | List of termination conditions |
 
-## 生成函数
+## Generation Function
 
 ```javascript
 function generateOrchestrator(config) {
   const actions = config.autonomous_config.actions;
   const terminations = config.autonomous_config.termination_conditions || [];
-  
-  // 生成终止条件检查
+
+  // Generate termination checks
   const terminationChecks = terminations.map(t => {
     const checks = {
       'user_exit': 'if (state.status === "user_exit") return null;',
@@ -198,24 +198,24 @@ function generateOrchestrator(config) {
     };
     return checks[t] || `if (state.${t}) return null;`;
   }).join('\n  ');
-  
-  // 生成动作选择逻辑
+
+  // Generate action selection logic
   const actionSelectionLogic = actions.map(action => {
     if (!action.preconditions?.length) {
-      return `// ${action.name}: 无前置条件，需要手动添加选择逻辑`;
+      return `// ${action.name}: No preconditions, add selection logic manually`;
     }
     const conditions = action.preconditions.map(p => `state.${p}`).join(' && ');
     return `if (${conditions}) return '${action.id}';`;
   }).join('\n  ');
-  
-  // 生成动作目录表格
-  const actionCatalogTable = actions.map(a => 
+
+  // Generate action catalog table
+  const actionCatalogTable = actions.map(a =>
     `| [${a.id}](actions/${a.id}.md) | ${a.description || a.name} | ${a.preconditions?.join(', ') || '-'} |`
   ).join('\n');
-  
-  // 生成终止条件列表
+
+  // Generate termination conditions list
   const terminationConditionsList = terminations.map(t => `- ${t}`).join('\n');
-  
+
   return template
     .replace('{{termination_checks}}', terminationChecks)
     .replace('{{action_selection_logic}}', actionSelectionLogic)
@@ -224,11 +224,11 @@ function generateOrchestrator(config) {
 }
 ```
 
-## 编排策略
+## Orchestration Strategies
 
-### 1. 优先级策略
+### 1. Priority Strategy
 
-按预定义优先级选择动作：
+Select action by predefined priority:
 
 ```javascript
 const PRIORITY = ['action-init', 'action-process', 'action-review', 'action-complete'];
@@ -243,16 +243,16 @@ function selectByPriority(state, availableActions) {
 }
 ```
 
-### 2. 用户驱动策略
+### 2. User-Driven Strategy
 
-询问用户选择下一个动作：
+Ask user to select next action:
 
 ```javascript
 async function selectByUser(state, availableActions) {
   const response = await AskUserQuestion({
     questions: [{
-      question: "选择下一个操作：",
-      header: "操作",
+      question: "Select next operation:",
+      header: "Operations",
       multiSelect: false,
       options: availableActions.map(a => ({
         label: a.name,
@@ -260,32 +260,32 @@ async function selectByUser(state, availableActions) {
       }))
     }]
   });
-  
-  return availableActions.find(a => a.name === response["操作"])?.id;
+
+  return availableActions.find(a => a.name === response["Operations"])?.id;
 }
 ```
 
-### 3. 状态驱动策略
+### 3. State-Driven Strategy
 
-完全基于状态自动决策：
+Fully automatic decision based on state:
 
 ```javascript
 function selectByState(state) {
-  // 初始化
+  // Initialization
   if (state.status === 'pending') return 'action-init';
-  
-  // 有待处理项
+
+  // Has pending items
   if (state.pending_items?.length > 0) return 'action-process';
-  
-  // 需要审核
+
+  // Needs review
   if (state.needs_review) return 'action-review';
-  
-  // 完成
+
+  // Completed
   return 'action-complete';
 }
 ```
 
-## 状态机示例
+## State Machine Example
 
 ```mermaid
 stateDiagram-v2