什么是 workflow-tools？

workflow-tools 技能是一个全面的扩展，旨在减少 Agent 工作流中的摩擦。通过整合四个专业工具，它使 AI 编程 Agent 能够处理复杂的任务编排，从识别未处理的 TODO 到确定项目阶段应并行还是串行执行。该工具集对于在现代开发环境中保持高质量输出和高效上下文管理至关重要。使用此类 Openclaw Skills 可确保 Agent 不会陷入递归循环，或因超大文件导致上下文窗口溢出。

下载入口:https://github.com/openclaw/skills/tree/main/skills/leegitw/workflow-tools

安装与下载

1. ClawHub CLI

从源直接安装技能的最快方式。

2. 手动安装

将技能文件夹复制到以下位置之一

优先级：工作区 > 本地 > 内置

3. 提示词安装

将此提示词复制到 OpenClaw 即可自动安装。

workflow-tools 应用场景

• 在完成任务前检测 DEFERRED 或 PLACEHOLDER 标记，以确保代码完整性。
• 根据五因子框架决定复杂的部署应并行化还是串行化。
• 识别超过 200 行 MCE 阈值的文件，以触发重构或拆分建议。
• 通过子工作流生成和后台监控，将特定的子任务委派给其他专业的 Openclaw Skills。

1. 用户或 Agent 显式调用子命令，如 /wt loops、/wt parallel 或 /wt mce。
2. 技能从 .openclaw/workflow-tools.yaml 读取本地配置，以确定模式和阈值。
3. 对于循环检测，它会递归扫描指定目录中的 FIXME、HACK 或 TODO 等标记，并按优先级分类。
4. 对于 MCE 分析，它根据行数阈值评估文件大小，并基于函数边界生成可操作的拆分建议。
5. 对于并行决策，它在五个维度（团队、耦合、接口、模式和集成）上应用逻辑矩阵并提供建议。
6. 所有结果、日志和子工作流数据都写入工作区输出目录中的结构化 Markdown 文件。

workflow-tools 配置指南

要开始使用 workflow-tools，请使用以下命令安装核心技能及其推荐的上下文依赖项：

openclaw install leegitw/failure-memory
openclaw install leegitw/constraint-engine
openclaw install leegitw/workflow-tools

可以通过工作区根目录中的 .openclaw/workflow-tools.yaml 文件管理配置，以定义自定义排除路径和行数阈值。

workflow-tools 数据架构与分类体系

该技能在工作区 output/ 文件夹内将输出组织成结构化的目录层级，以维护 Agent 决策的清晰记录：

name: workflow-tools
version: 1.4.0
description: Work smarter with loop detection, parallel decisions, and file size analysis
author: Live Neon 
homepage: https://github.com/live-neon/skills/tree/main/agentic/workflow-tools
repository: leegitw/workflow-tools
license: MIT
tags: [agentic, workflow, automation, orchestration, parallel, decision-making, loops, task-management]
layer: extensions
status: active
alias: wt
metadata:
  openclaw:
    requires:
      config:
        - .openclaw/workflow-tools.yaml
        - .claude/workflow-tools.yaml
      workspace:
        - output/loops/
        - output/parallel-decisions/
        - output/mce-analysis/
        - output/subworkflows/

workflow-tools (工具)

Unified skill for workflow utilities including open loop detection, parallel/serial decision framework, MCE file analysis, and subworkflow spawning. Consolidates 4 skills.

Trigger: 明示呼出 (explicit invocation)

Source skills: loop-closer, parallel-decision, MCE (minimal-context-engineering), subworkflow-spawner

Removed: pbd-strength-classifier (redundant with /fm classify)

Installation

openclaw install leegitw/workflow-tools

Dependencies:

• leegitw/failure-memory (for loop context)
• leegitw/constraint-engine (for enforcement context)

# Install with dependencies
openclaw install leegitw/context-verifier
openclaw install leegitw/failure-memory
openclaw install leegitw/constraint-engine
openclaw install leegitw/workflow-tools

Standalone usage: Loop detection, parallel decisions, and MCE analysis work independently. Full integration provides constraint-aware workflow recommendations.

Data handling: This skill operates within your agent's trust boundary. When triggered, it uses your agent's configured model for workflow analysis and decision support. No external APIs or third-party services are called. Results are written to output/ subdirectories in your workspace.

?? File access: This skill reads user-specified directories and files for analysis:

• /wt loops [path] scans the specified directory (default: current working directory)
• /wt mce reads the specified file for size analysis The metadata declares only config and output paths. See Security Considerations for details.

What This Solves

Workflows accumulate friction — loops that never close, decisions about parallel vs serial execution, files that grow too large. This skill provides utilities for common workflow problems:

1. Loop detection — find DEFERRED, PLACEHOLDER, and TODO markers before marking work complete
2. Parallel decisions — 5-factor framework for when to parallelize vs serialize
3. MCE analysis — identify files exceeding size thresholds, suggest splits

The insight: Small tools that do one thing well. Don't overthink the workflow — detect, decide, analyze, move on.

Usage

/wt  [arguments]

Sub-Commands

Arguments

/wt loops

/wt parallel

/wt mce

/wt subworkflow

Configuration

Configuration is loaded from (in order of precedence):

1. .openclaw/workflow-tools.yaml (OpenClaw standard)
2. .claude/workflow-tools.yaml (Claude Code compatibility)
3. Defaults (built-in)

# .openclaw/workflow-tools.yaml
loops:
  patterns:                  # Patterns to detect as open loops
    - "TODO:"
    - "FIXME:"
    - "HACK:"
    - "XXX:"
    - "DEFERRED:"
    - "PLACEHOLDER:"
  exclude:                   # Paths to exclude from scanning
    - "vendor/"
    - "node_modules/"
mce:
  threshold: 200             # Line threshold for MCE compliance
  warning_threshold: 300     # Line threshold for warning
parallel:
  default_factors: 5         # Number of factors to evaluate

Core Logic

Open Loop Detection

Scans for unclosed work items:

Parallel vs Serial Decision Framework

Five factors determine parallel suitability:

Decision matrix:

MCE (Minimal Context Engineering)

File size thresholds for context efficiency:

Split suggestions based on:

• Function/method boundaries
• Logical groupings
• Import dependencies
• Test coverage boundaries

Subworkflow Spawning

Delegate tasks to specialized ClawHub skills:

Task → Skill Selection → Spawn → Monitor → Collect Results

Available skill categories:

• research-*: Investigation and analysis
• generate-*: Content generation
• validate-*: Verification and testing
• transform-*: Data transformation

Example: Deployment Workflow Analysis

/wt parallel "Deploy new payment service to production"
[PARALLEL VS SERIAL ANALYSIS]
Task: "Deploy new payment service to production"

Factor Analysis:
1. Team: ? Serial - Single SRE team handles deploys
2. Coupling: ? Serial - Payment depends on auth service
3. Interface: ? Parallel - Clear API contracts defined
4. Pattern: ? Serial - Requires sequential rollout (canary → staging → prod)
5. Integration: ? Serial - Payment gateway integration must be verified

Score: 1/5 factors favor parallel
Recommendation: SERIAL deployment
Rationale: High-risk service requiring careful sequential verification.

Example: Infrastructure Loop Detection

/wt loops infra/ --pattern "MANUAL:,HARDCODED:"
[OPEN LOOPS DETECTED]
Scanned: ./infra
Files checked: 23

Infrastructure Issues (5):
  infra/terraform/main.tf:45  HARDCODED: AWS region
  infra/k8s/deployment.yaml:78  MANUAL: replica count
  infra/docker/Dockerfile:12  TODO: multi-stage build
  infra/scripts/deploy.sh:34  FIXME: rollback not implemented
  infra/helm/values.yaml:56  PLACEHOLDER: production secrets

Summary: 2 high, 2 medium, 1 low priority
Action: Address HARDCODED and FIXME before next release.

Output

/wt loops output

[OPEN LOOPS DETECTED]
Scanned: ./src
Files checked: 47

Open loops found (12):

High Priority (FIXME, XXX):
  src/auth/handler.go:45  FIXME: race condition in token refresh
  src/api/client.go:123   XXX: review error handling

Medium Priority (TODO):
  src/handlers/user.go:78  TODO: add input validation
  src/db/queries.go:234    TODO: optimize query
  src/utils/hash.go:12     TODO: add caching

Low Priority (DEFERRED, PLACEHOLDER):
  src/config/loader.go:89  DEFERRED: support YAML config
  src/templates/email.go:34 PLACEHOLDER: email templates
  ...

Summary: 2 high, 5 medium, 5 low priority loops
Action: Address high priority loops before release.

/wt parallel output

[PARALLEL VS SERIAL ANALYSIS]
Task: "Implement authentication and authorization"

Factor Analysis:

1. Team (独立性):
   ? Parallel - Auth and authz can be assigned separately

2. Coupling (結合度):
   ? Serial - Authz depends on auth tokens

3. Interface (境界):
   ? Parallel - Clear token interface between them

4. Pattern (手法):
   ? Parallel - Both follow established patterns

5. Integration (統合):
   ? Serial - Token format must match exactly

Score: 3/5 factors favor parallel

Recommendation: SERIAL with parallel sub-tasks
Rationale: Core dependency between auth and authz, but sub-components
           within each can be developed in parallel.

Suggested approach:
1. Define token interface (serial, required first)
2. Implement auth + authz (parallel, once interface stable)
3. Integration testing (serial, final step)

/wt mce output

[MCE ANALYSIS]
File: src/handlers/user.go
Lines: 347

Status: ? EXCEEDS MCE THRESHOLD (200 lines)

Complexity Analysis:
  Functions: 12
  Avg function length: 29 lines
  Max function length: 67 lines (HandleUserUpdate)
  Import groups: 4

Split Suggestions:

1. Extract CRUD handlers (lines 45-180):
   → src/handlers/user_crud.go (~135 lines)
   - CreateUser, GetUser, UpdateUser, DeleteUser

2. Extract validation (lines 181-250):
   → src/handlers/user_validation.go (~70 lines)
   - ValidateUserInput, ValidateEmail, ValidatePassword

3. Keep orchestration (remaining):
   → src/handlers/user.go (~142 lines)
   - Handler setup, middleware, routing

After split: 3 files, all ≤200 lines ?

/wt subworkflow output

[SUBWORKFLOW SPAWNED]
Task: "Research competitor authentication implementations"
Skill: research-web-analysis
Status: Running in background

Job ID: SW-20260215-001
Monitor: /wt subworkflow --status SW-20260215-001

Expected completion: ~5 minutes
Results will be written to: output/subworkflows/SW-20260215-001/

Integration

• Layer: Extensions
• Depends on: failure-memory (for loop context), constraint-engine (for enforcement context)
• Used by: governance (for loop detection), review-orchestrator (for parallel decisions)

Failure Modes

Next Steps

After invoking this skill:

Workspace Files

This skill reads/writes:

output/
├── loops/
│   └── scan-YYYY-MM-DD.md    # Loop scan results
├── parallel-decisions/
│   └── task-YYYY-MM-DD.md    # Decision records
├── mce-analysis/
│   └── file-YYYY-MM-DD.md    # MCE analysis results
└── subworkflows/
    └── SW-YYYYMMDD-XXX/      # Subworkflow outputs
        ├── status.json
        └── results.md

Security Considerations

What this skill accesses:

• Configuration files in .openclaw/workflow-tools.yaml and .claude/workflow-tools.yaml
• User-specified directories via /wt loops [path] — scans for patterns (read-only)
• User-specified files via /wt mce — reads for size analysis (read-only)
• Its own output directories (write):
  • output/loops/ — loop scan results
  • output/parallel-decisions/ — decision records
  • output/mce-analysis/ — file analysis results
  • output/subworkflows/ — subworkflow outputs

?? IMPORTANT: The metadata declares only config and output paths. However, /wt loops and /wt mce read arbitrary user-specified paths beyond the declared metadata. This is by design — analysis requires reading the files/directories you want to analyze.

What this skill does NOT access:

• System environment variables
• Network resources or external APIs

What this skill does NOT do:

• Send data to external services
• Execute arbitrary code
• Modify source files (analysis is read-only)

?? Path scanning (/wt loops): The /wt loops command accepts an arbitrary directory path argument. It will recursively scan the specified directory for loop patterns (TODO, FIXME, etc.). This is a read-only operation but can scan any directory you have filesystem access to. The skill does NOT restrict which paths can be scanned — use caution with sensitive directories. Consider using --exclude to skip sensitive paths.

Subworkflow spawning (/wt subworkflow): The /wt subworkflow command spawns other ClawHub skills installed in your environment.

• Scope: Can invoke any skill installed via openclaw install
• Permissions: Spawned skills execute with their own declared permissions (not elevated)
• Categories: Typically research-*, generate-*, validate-*, transform-* skills
• Risk: The effective permission footprint is the union of this skill plus any spawned skills

Review your installed skills (openclaw list) to understand the combined permission scope when using subworkflow spawning.

Provenance note: This skill is developed by Live Neon (https://github.com/live-neon/skills) and published to ClawHub under the leegitw account. Both refer to the same maintainer.

Acceptance Criteria

• /wt loops detects all standard loop patterns
• /wt loops categorizes by priority (high/medium/low)
• /wt parallel evaluates all 5 factors
• /wt parallel provides clear recommendation with rationale
• /wt mce identifies files exceeding threshold
• /wt mce --suggest generates actionable split suggestions
• /wt subworkflow spawns ClawHub skills correctly
• /wt subworkflow supports background execution
• Results written to workspace files

Consolidated from 4 skills as part of agentic skills consolidation (2026-02-15).