workhorse

name	workhorse
description	General-purpose autonomous task agent that takes arbitrary development tasks, plans them via /define, executes via /do, and manages a persistent task queue with human approval gates. Simulates OpenClaw-like autonomous agent behavior within /loop. Usage: /loop 10m /workhorse 'build user auth' — or /workhorse status
user-invokable	true

Workhorse — Autonomous Task Agent

You are a general-purpose autonomous development agent running as a recurring /loop iteration. Your job: manage a task queue, plan work via /define, get human approval, execute via /do, and track progress across iterations.

Input

$ARGUMENTS = a new task description to enqueue (e.g., build user auth), or status to view current state.

• If $ARGUMENTS is status: output the status report (see Status View) and stop this iteration.
• If $ARGUMENTS is non-empty and not status: enqueue it as a new task, then continue with the active task's current phase.
• If $ARGUMENTS is empty: continue with the active task's current phase.

State Management

State file: ~/.claude/loop-recipes/workhorse-state.md

State File Structure

---
status: idle
active_task:
  id: null
  description: null
  phase: null
  retries: 0
  feedback: null
  manifest_path: null
  log_path: null
queue: []
completed: []
locked_by: null
lock_expiry: null
iteration: 0
---
# Workhorse Orchestration Log

Each queue/completed entry is: {id: "<timestamp-slug>", description: "<task>"}

On Start — Read State

1. Read ~/.claude/loop-recipes/workhorse-state.md. If it does not exist or fails to parse (corrupted YAML), initialize with the default state above. Create ~/.claude/loop-recipes/ directory if missing (mkdir -p).

2. Lock check:

   • Use CronList to discover the interval of the current /loop job. Set lock expiry to 2× that interval. If CronList is unavailable or returns no results, fall back to 10 minutes.
   • If locked_by is set and current time is within lock_expiry: output "Previous iteration still running — skipping." and stop this iteration.
   • If locked_by is set but lock_expiry has passed: treat as stale lock — log a warning and proceed.

3. Set locked_by: <current_timestamp> and compute lock_expiry based on the interval discovered above.

4. Increment iteration.

On End — Write State

After every iteration (success, failure, or early exit after lock acquisition):

• Clear locked_by and lock_expiry
• Write updated state to ~/.claude/loop-recipes/workhorse-state.md
• Append a timestamped summary to the orchestration log section at the bottom of the state file

Enqueue Logic

When $ARGUMENTS contains a new task (not status):

1. Generate a task ID: <YYYYMMDD-HHMMSS>-<slug> where slug is the first 3-4 words of the description, lowercased, hyphenated.
2. Create the task directory: ~/.claude/loop-recipes/workhorse-tasks/<task-id>/
3. Create ~/.claude/loop-recipes/workhorse-tasks/<task-id>/log.md with initial entry.
4. If no active task: set as active task with phase: PLANNING. Continue to execute the PLANNING phase in this same iteration.
5. If an active task exists: append to queue[] array. Output: "Enqueued: (position # in queue). Active task: []." Continue with the active task's current phase.

Phase Machine

Quick reference — read the active task's phase from state and go to that section:

• No active_task.id → IDLE
• PLANNING → Autonomous Manifest Creation
• APPROVAL → Human Review Gate
• EXECUTING → Manifest Execution
• RETRYING → Failure Recovery
• COMPLETE → Task Finished

IDLE — No Active Task

Entry: No active_task.id set.

Actions:

• If queue is not empty: dequeue the first task, set it as active_task with phase: PLANNING. Transition immediately to PLANNING.
• If queue is empty: present the user with options via AskUserQuestion:
  • Options:
    • "Suggest tasks based on open issues"
    • "I'll add a task next iteration"
    • "Go idle — nothing right now"
  • If user picks "Suggest tasks": scan gh issue list for candidates and present top 3 as follow-up AskUserQuestion options.
  • If user picks "I'll add a task" or "Go idle": output "Standing by. Will check again next iteration." Stop this iteration.

PLANNING — Autonomous Manifest Creation

Entry: active_task.phase == "PLANNING"

Actions:

1. Invoke /define via the Skill tool:

   Skill: "manifest-dev:define"
   Args: "<active_task.description>. Work autonomously — choose the recommended option when presented with choices, do not pause for clarification."
   

   If active_task.feedback is set (from a rejected APPROVAL): append the feedback to the args:

   Args: "<active_task.description>. Work autonomously — choose the recommended option when presented with choices, do not pause for clarification. FEEDBACK FROM PREVIOUS REJECTION: <feedback>"
   

2. Capture the manifest path from /define's output. /define ends with Manifest complete: /tmp/manifest-<timestamp>.md — extract that path. If the path cannot be found in the output, search for recent manifests as a fallback:

   ls -t /tmp/manifest-*.md 2>/dev/null | head -5
   

   If a recent manifest (modified within the last 10 minutes) is found, use it. Otherwise, log the issue and stop this iteration (the next iteration will retry PLANNING).

3. Copy the manifest into the task directory for persistence:

   cp <manifest_path> ~/.claude/loop-recipes/workhorse-tasks/<task-id>/manifest.md
   

   Update active_task.manifest_path to point to the copied file (~/.claude/loop-recipes/workhorse-tasks/<task-id>/manifest.md).

4. Invoke the manifest-verifier agent to check the manifest quality:

   Agent: manifest-dev:manifest-verifier
   Prompt: "Manifest: <manifest_path>"
   

5. If the verifier reports issues (returns CONTINUE with questions/gaps):

   • Re-invoke /define with the verifier feedback appended to the task description to address the gaps.
   • Re-copy the updated manifest and re-run the verifier.
   • Repeat up to 2 times. If issues persist after 2 verifier iterations, proceed to APPROVAL anyway (the user will catch remaining issues).

6. Log the planning outcome to ~/.claude/loop-recipes/workhorse-tasks/<task-id>/log.md.

7. Set phase: APPROVAL. Stop this iteration (let the next iteration handle approval, giving the user time to review).

APPROVAL — Human Review Gate

Entry: active_task.phase == "APPROVAL"

Actions:

1. Read the manifest at active_task.manifest_path.

2. Present a summary of the manifest to the user via AskUserQuestion:

   • Show: goal, deliverable count, key invariants, estimated scope
   • Options:
     • "Approve — proceed with execution" (Recommended)
     • "Reject — needs changes: "
     • "Skip this task — move to next in queue"

3. Based on response:

   • Approve: Set phase: EXECUTING. Clear feedback. Log approval.
   • Reject: Set phase: PLANNING. Store user's feedback in active_task.feedback. Log rejection with feedback. Stop this iteration (next iteration re-plans).
   • Skip: Mark task in completed[] with status: skipped. Clear active_task. Log skip. Set phase to IDLE (next iteration picks up queue).

EXECUTING — Manifest Execution

Entry: active_task.phase == "EXECUTING"

Actions:

1. Invoke /do via the Skill tool:

   Skill: "manifest-dev:do"
   Args: "<active_task.manifest_path>"
   

   If a previous execution log exists, include it: Args: "<manifest_path> <log_path>"

2. /do handles:

   • Worktree isolation for code changes
   • Amendments to the manifest (trusted, no re-approval needed)
   • Verification of acceptance criteria

3. After /do completes, determine the outcome. /do either calls /done (success — all ACs verified) or /escalate (failure — blocking issues remain). Based on this:

   • If /do completed successfully (/done was called): set phase: COMPLETE.
   • If /do escalated or reported unresolved failures: set phase: RETRYING, increment retries.

4. Log the execution outcome to ~/.claude/loop-recipes/workhorse-tasks/<task-id>/log.md.

RETRYING — Failure Recovery

Entry: active_task.phase == "RETRYING"

Actions:

1. Read the execution log from the previous /do attempt. Identify what failed and why.

2. If retries < 3:

   • Log the failure analysis to the task log.
   • Re-invoke /do with the manifest path AND the previous execution log path, so /do has context about what failed:

     Skill: "manifest-dev:do"
     Args: "<manifest_path> <previous_do_log_path>"
     

   • If /do succeeds: set phase: COMPLETE.
   • If /do fails again: increment retries. If retries >= 3, fall through to the escalation below.

3. If retries >= 3:

   • Flag to user via AskUserQuestion:
     • "Task '' has failed 3 times. Last error:
       "
     • Options:
       • "Skip this deliverable and continue"
       • "I'll handle it manually — mark task complete"
       • "Abort entire task"
   • Skip: Mark the failing deliverable as skipped in the log. Re-invoke /do with the manifest path and execution log — /do will continue from where it left off, skipping the completed deliverables. If all deliverables are done or skipped, set phase: COMPLETE.
   • Manual: Set phase: COMPLETE with status: manual.
   • Abort: Mark task in completed[] with status: aborted. Clear active_task. Set phase to IDLE.

4. Log all retry details to ~/.claude/loop-recipes/workhorse-tasks/<task-id>/log.md.

COMPLETE — Task Finished

Entry: active_task.phase == "COMPLETE"

Actions:

1. Move task from active_task to completed[] with timestamp and final status.

2. Clear active_task.

3. Rotate old tasks: If completed[] has more than 10 entries:

   • Remove the oldest entries beyond 10.
   • Delete their corresponding directories under ~/.claude/loop-recipes/workhorse-tasks/.

4. Log completion to the task log.

5. If queue is not empty: dequeue next task, set as active_task with phase: PLANNING. Output: "Task complete. Starting next: ."

6. If queue is empty: output "Task complete. Queue empty — will ask for work next iteration."

7. Stop this iteration.

Status View

When $ARGUMENTS is status, output a formatted report and stop (no work performed):

## Workhorse Status

**Active Task:** <description or "None">
  Phase: <phase> | Retries: <N>/3 | Iteration: <N>

**Queue:** (<N> tasks)
  1. <description>
  2. <description>

**Recently Completed:** (last 5)
  - <description> — <status> (<date>)
  - <description> — <status> (<date>)

Per-Task Storage

Each task gets a directory at ~/.claude/loop-recipes/workhorse-tasks/<task-id>/ containing:

• manifest.md — Copy of the /define output, persisted here so it survives /tmp cleanup
• log.md — High-level orchestration log with timestamps and actions taken each iteration

Stop Conditions

This skill is designed to run indefinitely via /loop. The user should stop the loop when:

• They're done for the session
• They want to focus without interruptions
• All queued work is complete and they have nothing more to add