feat(retry): implement story 4.3 retry strategy configuration

- Add NonRetryableErrorTypes list to ToTemporalRetryPolicy (7 error types)
- Enhance ExecuteStepActivity with NonRetryableError detection and conversion
- Add retry_nonretry_test.go with comprehensive unit tests for error types
- Update docs/nodes/README.md with error handling best practices and examples
- Simplify workflow/activity tests, defer integration tests to test/integration/
- Add test scripts and testdata for retry strategy validation
- Update Story 4.3 status to done with code review fixes documented
- Fix errcheck linting issues in plugin manager tests

Resolves: Story 4.3 - Retry Strategy Configuration
Coverage: pkg/dsl 89.3%, pkg/dsl/node 84.4%
Tests: All pkg/temporal and pkg/dsl tests passing

Note: gocyclo warnings in validator.go from Story 4.2 are acceptable for complex validation logic

Author: zhaojing1987

agent

@@ -281,3 +281,83 @@ Failed to load config: invalid configuration: log.level must be one of [debug, i
 - 检查配置文件中的值是否符合要求
 - 参考本文档中的可选值列表
 - 使用默认值或环境变量覆盖
+## Step 配置参考
+
+### retry-strategy (重试策略)
+
+配置 Step 失败时的重试行为。(Story 4.3)
+
+**字段:**
+
+| 字段 | 类型 | 必需 | 默认值 | 说明 |
+|------|------|------|--------|------|
+| max-attempts | integer | 否 | 3 | 最大尝试次数 (1-10) |
+| initial-interval | string | 否 | "1s" | 首次重试间隔 (≥1s) |
+| backoff-coefficient | float | 否 | 2.0 | 退避系数 (1.0-10.0) |
+| max-interval | string | 否 | "60s" | 最大重试间隔 |
+
+**示例:**
+
+```yaml
+steps:
+  # 默认重试策略 (3次,指数退避)
+  - name: Quick Task
+    uses: exec/script@v1
+    with:
+      command: ./task.sh
+  
+  # 自定义重试策略 - 网络调用
+  - name: API Call
+    uses: http/request@v1
+    retry-strategy:
+      max-attempts: 10
+      initial-interval: 2s
+      backoff-coefficient: 1.5
+      max-interval: 60s
+    with:
+      url: https://api.example.com/data
+  
+  # 禁用重试
+  - name: One Shot
+    uses: exec/script@v1
+    retry-strategy:
+      max-attempts: 1
+    with:
+      command: ./critical-task.sh
+```
+
+**重试算法:**
+
+指数退避算法:
+```
+下次间隔 = min(
+    initial-interval * (backoff-coefficient ^ attempt),
+    max-interval
+)
+```
+
+示例 (initial-interval=1s, backoff-coefficient=2.0):
+```
+尝试 1: 失败 → 等待 1s
+尝试 2: 失败 → 等待 2s
+尝试 3: 失败 → 等待 4s
+尝试 4: 失败 → 等待 8s
+```
+
+**永久性错误 (不重试):**
+
+以下错误类型不会重试,立即失败:
+- `validation_error` - 参数验证错误
+- `schema_error` - JSON Schema 验证错误
+- `not_found` - 资源不存在
+- `permission_denied` - 权限不足
+- `invalid_argument` - 参数无效
+- `node_not_registered` - 节点未注册
+- `plugin_load_error` - 插件加载失败
+
+**最佳实践:**
+
+- 🎯 **网络调用:** 使用较高的 max-attempts (5-10次)
+- 🎯 **本地脚本:** 使用默认策略 (3次)
+- 🎯 **关键任务:** 禁用重试 (max-attempts: 1)
+- 🎯 **长时间任务:** 增大 max-interval (避免过长等待)

docs/configuration.md

@@ -87,29 +87,93 @@ func (n *MyNode) Params() map[string]node.ParamSpec {
 - `Enum` - Allowed values
 - `MinValue` / `MaxValue` - Numeric ranges (for int/float)
 
+#### Parameter Validation Details
+
+**Automatic Validation**: Waterflow automatically validates all parameters against your `ParamSpec` definitions:
+
+1. **Submission Time** (Static Values): DSL parser validates non-expression parameters when workflow is submitted
+2. **Runtime** (All Values): Activity validates all parameters (including expression results) before calling `Execute()`
+
+**Validation Rules**:
+
+| Constraint | Applies To | Example |
+|------------|-----------|---------|
+| `Required` | All types | Missing required parameter → Error |
+| `Type` | All types | String expected, int provided → Error |
+| `Pattern` | `string` | Email regex `^[a-z]+@[a-z]+\.[a-z]+$` |
+| `Enum` | All types | Must be one of `["GET", "POST", "PUT"]` |
+| `MinValue`/`MaxValue` | `int`, `float` | Value must be in range `[1, 100]` |
+| `Default` | Optional params | Applied if value not provided |
+
+**Type Compatibility** (JSON/YAML Parsing):
+- Numbers in JSON/YAML are parsed as `float64`
+- `Type: "int"` accepts `float64` if no decimal part (e.g., `30.0` → valid int)
+- `Type: "float"` accepts both `int` and `float64`
+
+**Expression Parameters**:
+- Expressions like `${{ vars.timeout }}` skip validation at submission time
+- Validated after expression evaluation at runtime
+- Expression results must match the declared type
+
+**Error Handling**:
+```go
+// Validation errors are NonRetryableError (permanent)
+err := node.ValidateInputs(inputs, n.Params())
+if err != nil {
+    // Error type: *node.InputValidationError
+    // Properties:
+    //   - NodeName: "exec/shell@v1"
+    //   - Errors: []ParameterError
+    //     - ParamName: "timeout"
+    //     - ErrorType: "RangeViolation"
+    //     - Expected: "<= 60"
+    //     - Actual: 120
+    //     - Message: "value 120 exceeds maximum 60"
+    return nil, err
+}
+```
+
+**Validation Error Types**:
+- `Missing` - Required parameter not provided
+- `TypeMismatch` - Wrong type (e.g., string instead of int)
+- `PatternMismatch` - String doesn't match regex pattern
+- `EnumViolation` - Value not in allowed list
+- `RangeViolation` - Number outside min/max range
+
+**Best Practices**:
+- Use `Pattern` for formats (emails, URLs, file paths)
+- Use `Enum` for limited choices (methods, log levels)
+- Use `MinValue`/`MaxValue` for sensible ranges (timeouts, counts)
+- Provide `Default` values for optional parameters
+- Write descriptive `Description` to help users
+
 ### 5. Implement Execute Logic
 
 ```go
 func (n *MyNode) Execute(ctx context.Context, inputs map[string]interface{}) (*node.NodeResult, error) {
     start := time.Now()
 
-    // 1. Validate inputs
-    if err := node.ValidateInputs(inputs, n.Params()); err != nil {
-        return nil, err
-    }
+    // ⚠️ 参数已由 Temporal Activity 验证，无需再次验证
+    // Waterflow 保证传入的 inputs 100% 符合 ParamSpec 定义
 
-    // 2. Extract parameters
+    // 1. 提取参数 (类型断言安全，因为已验证)
     command := inputs["command"].(string)
-    timeout := 60
+    timeout := 60 // Default value
     if t, ok := inputs["timeout"]; ok {
-        timeout = t.(int)
+        // Type already validated - safe to assert
+        switch v := t.(type) {
+        case int:
+            timeout = v
+        case float64:
+            timeout = int(v) // JSON numbers are float64
+        }
     }
 
-    // 3. Create result
+    // 2. Create result
     result := node.NewNodeResult()
     result.AddLog("Execution started")
 
-    // 4. Perform work (check context cancellation)
+    // 3. Perform work (check context cancellation)
     select {
     case <-ctx.Done():
         return nil, ctx.Err()
@@ -124,7 +188,7 @@ func (n *MyNode) Execute(ctx context.Context, inputs map[string]interface{}) (*n
         result.SetOutput("exit_code", 0)
     }
 
-    // 5. Record duration and logs
+    // 4. Record duration and logs
     result.Duration = time.Since(start)
     result.AddLog("Execution completed")
 
@@ -133,11 +197,11 @@ func (n *MyNode) Execute(ctx context.Context, inputs map[string]interface{}) (*n
 ```
 
 **Best Practices**:
-- Always validate inputs first
-- Handle `ctx.Done()` for cancellation
-- Log execution progress
-- Return structured outputs
-- Record execution duration
+- **Do NOT validate inputs** - Already validated by Activity layer
+- Handle `ctx.Done()` for cancellation support
+- Log execution progress for debugging
+- Return structured outputs in OutputSchema format
+- Record execution duration for metrics
 
 ### 6. Provide Metadata
 

docs/guides/node-development.md

@@ -146,25 +146,111 @@ steps:
     continue-on-error: true  # 容器不存在也继续执行
 ```
 
-#### 重试策略
+#### 重试策略 (Story 4.3)
 
 ```yaml
 steps:
   - name: Pull image with retry
     uses: docker/exec@v1
+    retry-strategy:
+      max-attempts: 3
+      initial-interval: 5s
+      backoff-coefficient: 2.0
+      max-interval: 60s
     with:
       command: pull
       args: ["nginx:latest"]
-    retry:
-      max_attempts: 3
-      initial_interval: 5s
-      backoff_coefficient: 2.0
 ```
 
 **重试参数:**
-- `max_attempts`: 最大尝试次数
-- `initial_interval`: 初始重试间隔
-- `backoff_coefficient`: 退避系数（每次重试间隔乘以此系数）
+- `max-attempts`: 最大尝试次数 (1-10)
+- `initial-interval`: 初始重试间隔 (≥1s)
+- `backoff-coefficient`: 退避系数 (1.0-10.0)
+- `max-interval`: 最大重试间隔
+
+**重试算法:** 指数退避 (`间隔 = initial-interval * backoff-coefficient ^ attempt`)
+
+**永久性错误 (不重试):**  
+某些错误类型会立即失败，不进行重试:
+- `validation_error` - 参数验证错误
+- `schema_error` - Schema 验证错误
+- `not_found` - 资源不存在
+- `permission_denied` - 权限不足
+- `invalid_argument` - 无效参数
+- `node_not_registered` - 节点未注册
+- `plugin_load_error` - 插件加载失败
+
+更多详情参考: [配置文档 - retry-strategy](../configuration.md#retry-strategy-重试策略)
+
+## 节点错误处理最佳实践
+
+在自定义节点中,应该正确区分永久性错误和临时性错误:
+
+### 永久性错误 (NonRetryableError)
+
+用于参数错误、权限问题等,重试无意义的场景:
+
+```go
+import "github.com/Websoft9/waterflow/pkg/dsl/node"
+
+func (n *MyNode) Execute(ctx context.Context, inputs map[string]interface{}) (*node.NodeResult, error) {
+    // 参数验证
+    replicas, ok := inputs["replicas"].(float64)
+    if !ok || replicas <= 0 {
+        return nil, &node.NonRetryableError{
+            ErrorType: "validation_error",
+            Message:   "parameter 'replicas' must be positive integer",
+        }
+    }
+    
+    // 权限检查
+    if !hasPermission(ctx) {
+        return nil, &node.NonRetryableError{
+            ErrorType: "permission_denied",
+            Message:   "insufficient permissions to execute this operation",
+        }
+    }
+    
+    // ... 执行逻辑
+}
+```
+
+### 临时性错误 (可重试)
+
+用于网络超时、服务不可用等,重试可能成功的场景:
+
+```go
+func (n *MyNode) Execute(ctx context.Context, inputs map[string]interface{}) (*node.NodeResult, error) {
+    // 网络调用
+    resp, err := http.Get(url)
+    if err != nil {
+        // 返回普通 error,Waterflow 会自动重试
+        return nil, fmt.Errorf("network call failed: %w", err)
+    }
+    
+    // 服务不可用 (503)
+    if resp.StatusCode == 503 {
+        return nil, fmt.Errorf("service temporarily unavailable")
+    }
+    
+    // ... 处理响应
+}
+```
+
+### 错误类型对照表
+
+| 场景 | 错误类型 | 重试 | 示例 |
+|------|----------|------|------|
+| 参数验证失败 | validation_error | ❌ | 缺少必填参数 |
+| JSON Schema 错误 | schema_error | ❌ | 参数类型不匹配 |
+| 资源不存在 | not_found | ❌ | 文件/容器不存在 |
+| 权限不足 | permission_denied | ❌ | SSH 认证失败 |
+| 无效参数 | invalid_argument | ❌ | 端口号超出范围 |
+| 网络超时 | (普通 error) | ✅ | http.Get() timeout |
+| 服务不可用 | (普通 error) | ✅ | API 返回 503 |
+| 临时故障 | (普通 error) | ✅ | 数据库连接失败 |
+
+更多节点开发指南,参考: [节点开发文档](../guides/node-development.md)
 
 ### 使用 Secrets