thread-spawner

hanibalsk's avatarfrom hanibalsk

Spawn threads on running claude-threads orchestrator

⭐0stars🔀0forks📁View on GitHub🕐Updated Dec 25, 2025
[Tool Routing and Orchestration]

When & Why to Use This Skill

The Thread Spawner skill empowers Claude to manage and scale parallel execution by spawning independent threads on a running claude-threads orchestrator. It facilitates the simultaneous processing of complex software engineering tasks, such as epics and stories, within isolated git worktrees, enabling high-efficiency multi-agent coordination and seamless background task management for professional development workflows.

Use Cases

  • Parallel Epic Implementation: Simultaneously execute multiple large-scale epics by spawning dedicated threads, each operating in an isolated git worktree to ensure clean and conflict-free development environments.
  • Automated CI Failure Resolution: Automatically spawn background 'fixer' threads to address CI/CD pipeline failures (e.g., linting or unit tests) without interrupting the primary development session.
  • Concurrent Story Development: Accelerate feature delivery by distributing individual user stories across multiple parallel threads, allowing for rapid implementation and testing of different components at once.
  • Multi-Instance Coordination: Manage and monitor multiple Claude Code instances from a single session, providing a centralized control point for complex, distributed development workflows and background task monitoring.
namethread-spawner
descriptionSpawn threads on running claude-threads orchestrator
allowed-toolsBash,Read
version"1.2.3"

Thread Spawner Skill

Spawn and manage threads on a running claude-threads orchestrator. Enables parallel execution of epics, stories, or any tasks from within a Claude Code session.

When to Use

  • Spawn parallel threads for epics/stories during BMAD workflow
  • Create background tasks from current Claude Code session
  • Coordinate multiple Claude Code instances
  • Run parallel implementations with isolated git worktrees

Prerequisites

  1. API Server Running: The orchestrator API must be running

    ct api start --token <your-token>

  2. Environment Variable: Set the API token

    export CT_API_TOKEN=<your-token>

Quick Start

Connect to Orchestrator

# Auto-discover running orchestrator
ct remote discover

# Or connect explicitly
ct remote connect localhost:31337 --token $CT_API_TOKEN

# Check connection status
ct remote status

Spawn Threads

Note: Remote threads ALWAYS use isolated git worktrees by default.

# Basic spawn (creates worktree automatically for remote)
ct spawn epic-7a --template bmad-developer.md

# Spawn with custom worktree base branch
ct spawn epic-7a --template bmad-developer.md --worktree-base develop

# Spawn with custom context
ct spawn story-123 --template developer.md --context '{"story_id":"123","title":"Add login"}'

# Spawn and wait for completion
ct spawn fix-ci --template fixer.md --wait

Multiple Parallel Threads

# Spawn multiple epics in parallel
ct spawn epic-7a --template bmad-developer.md --worktree --context '{"epic_id":"7A"}'
ct spawn epic-8a --template bmad-developer.md --worktree --context '{"epic_id":"8A"}'
ct spawn epic-9a --template bmad-developer.md --worktree --context '{"epic_id":"9A"}'

Commands Reference

Remote Connection

Command Description
ct remote connect <host:port> Connect to orchestrator API
ct remote disconnect Disconnect from remote
ct remote status Show connection status
ct remote discover Auto-discover running orchestrator

Spawn

ct spawn <name> [options]
Option Description
--template, -t <file> Prompt template file
--mode, -m <mode> Thread mode (automatic, semi-auto, interactive)
--context, -c <json> Thread context as JSON
--worktree, -w Create with isolated git worktree (DEFAULT for remote)
--no-worktree Disable worktree isolation (not recommended)
--worktree-base <branch> Base branch for worktree (default: main)
--wait Wait for thread completion
--remote Force use of remote API
--local Force use of local database

Use Cases

1. Parallel Epic Implementation (BMAD)

When the orchestrator assigns multiple epics, spawn them in parallel:

# Connect to orchestrator
ct remote connect localhost:31337 --token $CT_API_TOKEN

# Read epic assignments from artifacts
for epic_id in 7A 8A 9A; do
    ct spawn "epic-${epic_id}" \
        --template bmad-developer.md \
        --worktree \
        --worktree-base develop \
        --context "{\"epic_id\":\"${epic_id}\"}"
done

2. CI Fix Spawning

When CI fails, spawn a fixer thread:

ct spawn ci-fix-pr-123 \
    --template bmad-fixer.md \
    --worktree \
    --context '{"pr_number":"123","failure":"test:lint"}'

3. Story Implementation

Spawn threads for individual stories:

ct spawn story-add-logout \
    --template developer.md \
    --context '{"story_title":"Add logout button","acceptance_criteria":["Button in header","Clears session"]}'

4. Monitoring Spawned Threads

# List all threads
ct thread list

# Check specific thread status
ct thread status <thread-id>

# View thread logs
ct thread logs <thread-id>

Environment Variables

Variable Description
CT_API_TOKEN Authentication token for API
CT_API_URL API URL for auto-discovery
N8N_API_TOKEN Alternative token variable

Architecture

External Claude Code Instance
     │
     ├── ct remote connect ──────────┐
     │                               │
     └── ct spawn ───────────────────┤
                                     │
                                     ▼
                           ┌─────────────────┐
                           │   API Server    │
                           │  (port 31337)    │
                           └────────┬────────┘
                                    │
                                    ▼
                           ┌─────────────────┐
                           │   Orchestrator  │
                           │   (threads.db)  │
                           └────────┬────────┘
                                    │
            ┌───────────────────────┼───────────────────────┐
            ▼                       ▼                       ▼
    ┌───────────────┐      ┌───────────────┐      ┌───────────────┐
    │   Thread 1    │      │   Thread 2    │      │   Thread 3    │
    │  (worktree)   │      │  (worktree)   │      │  (worktree)   │
    └───────────────┘      └───────────────┘      └───────────────┘

Security

  • All API requests require Authorization: Bearer <token> header
  • Token is stored in .claude-threads/remote.json after connecting
  • Token can be set via CT_API_TOKEN or --token flag
  • API server binds to localhost by default

See Also