📦 Openclaw Skill Parallel Tasks — 技能工具

技能文档

Execute multiple tasks in parallel with enterprise-grade reliability: timeout protection, error isolation, and real-time progress feedback.

When to Use

Use this skill when:

• User says "run these in parallel" or "do these simultaneously"
• Multiple independent tasks need to be executed at once
• User wants faster results by running tasks concurrently
• Tasks are slow and user wants to avoid waiting sequentially

Core Concept

Serial vs Parallel:

SERIAL (slow):
Task 1 → Task 2 → Task 3  (5min + 5min + 5min = 15min)
PARALLEL (fast):
Task 1 ─┬─> (5min total, not 15min)
Task 2 ─┼─>
Task 3 ─┘

Usage

Basic Parallel Execution

/parallel
Task 1: Search for docs
Task 2: Search for code
Task 3: Search for examples

Named Tasks with Custom Timeout

/parallel timeout=300
[search-docs] Search for relevant documentation
[search-code] Find similar implementations
[analyze] Analyze the results

CLI Usage (scripts/executor.ts)

# Simple usage
node scripts/executor.ts "Research AI trends" "Research market analysis"
# Named tasks with custom timeout
node scripts/executor.ts --timeout 600 \
  --task "[research] Research AI trends" \
  --task "[implement] Build the feature"
# Read from file (one task per line)
node scripts/executor.ts --tasks-file my-tasks.txt --max-concurrent 3
# Named task formats (all equivalent):
# - [name] description
# - - description (auto-named as task-1, task-2, ...)
# - 1. description

Implementation

Core Execution Pattern

The executor uses a semaphore pattern with configurable concurrency:

// 1. Parse tasks from input
const tasks = parseTaskInput(input)
// 2. Execute tasks with concurrency control
const results: TaskResult[] = []
const executing: Promise[] = []
for (const task of tasks) {
  // Wait if at max concurrency
  if (executing.length >= maxConcurrent) {
    await Promise.race(executing)
  }
  const promise = runTask(task).then(result => {
    results.push(result)
    // Remove from executing list
    const idx = executing.indexOf(promise)
    if (idx > -1) executing.splice(idx, 1)
  })
  executing.push(promise)
}
await Promise.all(executing)

Task Execution via hermes cli

async function executeTaskViaSpawn(
  task: Task,
  timeoutSeconds: number
): Promise {
  const taskId = parallel-${Date.now()}-${randomId()}
  return new Promise((resolve) => {
    const proc = spawn('hermes', [
      'cli', '--',
      'sessions_spawn',
      '--task', "${task.description}",
      '--label', "${task.name}",
      '--timeout', String(timeoutSeconds),
      '--session-id', taskId
    ], { stdio: ['ignore', 'pipe', 'pipe'] })
    // Timeout handling
    const timeoutId = setTimeout(() => {
      proc.kill('SIGTERM')
      resolve({
        name: task.name,
        status: 'timeout',
        duration: Date.now() - startTime,
        error: Exceeded ${timeoutSeconds}s timeout
      })
    }, timeoutSeconds * 1000)
    proc.on('close', (code, signal) => {
      clearTimeout(timeoutId)
      if (signal === 'SIGTERM') {
        resolve({ name: task.name, status: 'timeout', ... })
      } else if (code === 0) {
        resolve({ name: task.name, status: 'fulfilled', ... })
      } else {
        resolve({ name: task.name, status: 'rejected', ... })
      }
    })
  })
}

Timeout Protection

Error Isolation

Each task runs in complete isolation:

Concurrency Control

Progress Feedback

Real-time terminal output with colored status:

🚀 Starting 3 tasks in parallel (max 5 concurrent)...
🔄 [task-1] Starting (timeout: 300s)...
🔄 [task-2] Starting (timeout: 300s)...
🔄 [task-3] Starting (timeout: 300s)...
✅ [1/3] [task-1] Complete (23.5s)
✅ [2/3] [task-2] Complete (45.2s)
⏱️  [3/3] [task-3] Timeout after 300s

Task Input Formats

1. Named Tasks (Recommended)

[research] Research AI trends and write report
[implement] Build the feature
[test] Write comprehensive tests

2. Bullet List

- Search for API documentation
Find relevant code examples
Check for existing implementations

3. Numbered List

1. Research authentication patterns
Design database schema
Implement API endpoints

4. Plain Text (auto-named)

Research AI trends
Build the feature
Write tests

Output Format

Success Case

✅ Parallel Execution Complete
   3 tasks: 2 succeeded, 1 failed (45.2s total)
┌─────────────────────┬────────────┬────────────┐
│ Task                │ Status     │ Duration   │
├─────────────────────┼────────────┼────────────┤
│ research            │ ✅ fulfilled│ 23.5s      │
│ implement           │ ✅ fulfilled│ 45.2s      │
│ test                │ ⏱️ timeout  │ 300.0s    │
└─────────────────────┴────────────┴────────────┘
❌ Failed Tasks:
   • test: Exceeded 300s timeout

Exit Codes

Options

CLI Options

Per-Task Options (in task description)

[name] description (timeout=600)

Error Handling

Error Types

Best Practices

• Independent tasks first: Tasks should not depend on each other
• Set reasonable timeouts: Don't set 5min if task should take 30s
• Use named tasks: Easier to debug when something fails
• Keep tasks focused: One clear goal per task
• Mind concurrency: Don't set maxConcurrent higher than system can handle

Examples

Example 1: Research Multiple Topics

node scripts/executor.ts \
  "Research Claude Code best practices" \
  "Find OpenClaw skill examples" \
  "Search for agent design patterns"

Example 2: Named Tasks from File

# tasks.txt:
# [research] Research AI trends
# [implement] Build the feature
# [test] Write tests
node scripts/executor.ts --tasks-file tasks.txt --timeout 600

Example 3: Parallel Implementation

node scripts/executor.ts --timeout 600 \
  --task "[backend] Implement user authentication API" \
  --task "[frontend] Build login form component" \
  --task "[database] Create users table migration"

Example 4: Web Scraping

node scripts/executor.ts \
  --task "[store1] Fetch product data from store1.com" \
  --task "[store2] Fetch product data from store2.com" \
  --task "[store3] Fetch product data from store3.com"

Anti-Patterns

❌ Don't use for dependent tasks:

# WRONG - second task depends on first!
node scripts/executor.ts \
  "Create user account" \
  "Send welcome email"

❌ Don't use for very fast tasks:

# WRONG - spawning overhead not worth it
node scripts/executor.ts "Read file A" "Read file B" "Read file C"

Related Skills

• subagents - Background agent spawning
• batch-operations - Bulk file operations
• workflow-orchestrator - Complex multi-step workflows