create-merlin-brain 3.7.3 → 3.8.0-beta.0

package/files/commands/merlin/workflow.md

@@ -0,0 +1,285 @@
+---
+name: merlin:workflow
+description: Run predefined multi-agent workflows (feature-dev, bug-fix, security-audit, refactor)
+argument-hint: "[list | run <id> \"<task>\" | status | resume | skip]"
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Write
+  - AskUserQuestion
+  - mcp__merlin__merlin_get_context
+  - mcp__merlin__merlin_search
+  - mcp__merlin__merlin_find_files
+  - mcp__merlin__merlin_sync_task
+  - mcp__merlin__merlin_save_checkpoint
+---
+
+<objective>
+Orchestrate predefined multi-agent workflows from within Claude Code sessions.
+
+Workflows are named pipelines (e.g., "feature-dev", "bug-fix") that chain specialist agents
+through a fixed sequence automatically. Each step spawns a FRESH Claude process with 200K context.
+
+This command wraps the Merlin Loop workflow engine for interactive use:
+- `list` — show available workflows
+- `run <id> "<task>"` — execute a workflow
+- `status` — check current run progress
+- `resume` — resume an interrupted workflow
+- `skip` — skip current step and advance
+
+Workflows use the Blend Engine for optimal agent selection per step, structured handoffs
+between steps, and independent verification for high-stakes steps.
+</objective>
+
+<process>
+
+## Step 1: Parse Arguments
+
+Extract from $ARGUMENTS:
+- **subcommand**: First word (list, run, status, resume, skip)
+- **workflow-id**: Second word (only for `run`)
+- **task**: Everything after workflow-id (only for `run`)
+
+If no arguments:
+```
+Available workflow commands:
+
+  /merlin:workflow list                      — See available workflows
+  /merlin:workflow run feature-dev "Add X"   — Run a workflow
+  /merlin:workflow status                    — Check progress
+  /merlin:workflow resume                    — Resume interrupted workflow
+  /merlin:workflow skip                      — Skip current step
+
+Bundled workflows: feature-dev, bug-fix, security-audit, refactor
+```
+
+## Step 2: Route by Subcommand
+
+### `list` — Show Available Workflows
+
+Read workflow JSON files from two locations:
+```bash
+# Bundled workflows (shipped with Merlin)
+ls ~/.claude/loop/workflows/*.json 2>/dev/null
+
+# User-installed workflows
+ls ~/.claude/loop/workflows/*.json 2>/dev/null
+```
+
+For each workflow file, extract and display:
+- id, name, description, step count
+- Step pipeline (e.g., "plan -> setup -> implement -> verify -> test -> pr -> review")
+
+Format:
+```
+Available Workflows
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+feature-dev  [7 steps]
+  Feature Development — Drop in a feature request. Get back a tested PR.
+  Pipeline: Planning -> Setup -> Implementation -> Verification -> Testing -> PR -> Review
+
+bug-fix  [6 steps]
+  Bug Fix — Report a bug. Get back a fix with regression test and PR.
+  Pipeline: Triage -> Investigation -> Fix -> Regression Test -> Verification -> PR
+
+security-audit  [6 steps]
+  Security Audit — Run a full security sweep. Get fixes and a clean report.
+  Pipeline: Scan -> Prioritize -> Fix -> Verification -> Tests -> PR
+
+refactor  [6 steps]
+  Code Refactor — Analyze, plan, refactor, verify, test, and PR.
+  Pipeline: Analysis -> Plan -> Refactor -> Verification -> Tests -> PR
+```
+
+### `run` — Execute a Workflow
+
+**Required args:** workflow-id and task description.
+
+If missing:
+```
+Usage: /merlin:workflow run <workflow-id> "<task description>"
+
+Example: /merlin:workflow run feature-dev "Add OAuth login with Google and GitHub providers"
+```
+
+#### Step 2a: Load Workflow
+
+```bash
+WORKFLOW_FILE=""
+for dir in ~/.claude/loop/workflows; do
+  if [ -f "$dir/${WORKFLOW_ID}.json" ]; then
+    WORKFLOW_FILE="$dir/${WORKFLOW_ID}.json"
+    break
+  fi
+done
+```
+
+If not found, list available workflows and error.
+
+#### Step 2b: Get Sights Context
+
+```
+Call: merlin_get_context
+Task: "{task description}"
+```
+
+#### Step 2c: Pre-Flight Summary
+
+Parse the workflow JSON and show:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WORKFLOW: Feature Development
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Task:     Add OAuth login with Google and GitHub providers
+Steps:    7
+Pipeline: Planning -> Setup -> Implementation -> Verification -> Testing -> PR -> Review
+
+Each step spawns a fresh Claude process with 200K context.
+Estimated time: 15-30 minutes depending on complexity.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Ask user to confirm or provide additional context:
+- "Any constraints or notes before we start?"
+- If none, proceed.
+
+#### Step 2d: Execute via merlin-loop
+
+Spawn the workflow engine as a shell process:
+
+```bash
+cd "$(pwd)" && merlin-loop workflow run "${WORKFLOW_ID}" "${TASK}" 2>&1
+```
+
+Use Bash tool with `timeout: 600000` (10 minutes per step, up to 60 minutes total).
+
+**IMPORTANT:** If `merlin-loop` is not in PATH, find it:
+```bash
+LOOP_SCRIPT="${HOME}/.claude/loop/merlin-loop.sh"
+bash "$LOOP_SCRIPT" workflow run "${WORKFLOW_ID}" "${TASK}" 2>&1
+```
+
+#### Step 2e: Monitor and Report
+
+After each step completes, the workflow engine outputs progress. Capture and relay to user:
+- Step name and status (done/failed/skipped)
+- Overall progress (e.g., "3/7 steps complete")
+
+If the workflow pauses on failure:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WORKFLOW PAUSED at step: implement
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Step "Implementation" failed after 3 attempts.
+
+[1] Resume workflow (/merlin:workflow resume)
+[2] Skip this step (/merlin:workflow skip)
+[3] Investigate the failure
+[4] Abort
+```
+
+#### Step 2f: Completion
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WORKFLOW COMPLETE: Feature Development
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Task:      Add OAuth login
+Steps:     7/7 complete
+Duration:  ~22 minutes
+
+Steps completed:
+  ✓ Planning
+  ✓ Environment Setup
+  ✓ Implementation
+  ✓ Independent Verification
+  ✓ Testing
+  ✓ Pull Request
+  ✓ Final Review
+
+Next steps:
+[1] Review the PR
+[2] Run another workflow
+[3] Continue in current context
+```
+
+### `status` — Show Current Run
+
+Read the workflow run state:
+```bash
+cat .merlin-loop/workflow-run.json 2>/dev/null
+```
+
+Parse and display:
+```
+Workflow: Feature Development
+Task:     Add OAuth login
+Status:   running
+Step:     implement (3/7)
+
+  ✓ plan (done)
+  ✓ setup (done)
+  ▶ implement (running, attempt 1)
+  · verify (pending)
+  · test (pending)
+  · pr (pending)
+  · review (pending)
+```
+
+If no active run: "No active workflow. Run one with: /merlin:workflow run <id> \"task\""
+
+### `resume` — Resume Interrupted Workflow
+
+```bash
+LOOP_SCRIPT="${HOME}/.claude/loop/merlin-loop.sh"
+bash "$LOOP_SCRIPT" workflow resume 2>&1
+```
+
+Show progress as steps complete.
+
+### `skip` — Skip Current Step
+
+```bash
+LOOP_SCRIPT="${HOME}/.claude/loop/merlin-loop.sh"
+bash "$LOOP_SCRIPT" workflow skip 2>&1
+```
+
+Confirm the skip and show updated status.
+
+</process>
+
+<critical_rules>
+
+**ALWAYS use merlin-loop workflow engine** — do NOT try to orchestrate steps manually.
+The workflow engine handles: blend selection, handoffs, retries, state tracking, resumability.
+
+**FRESH PROCESS PER STEP** — each workflow step spawns a new `claude --agent` process.
+This is handled by the workflow engine, not by this command.
+
+**NEVER run specialist work in this orchestrator context** — only manage the workflow lifecycle.
+
+**STATE IS PERSISTENT** — workflow-run.json survives crashes. Resume picks up exactly where it left off.
+
+**TIMEOUT** — use 600000ms (10 min) for status/resume/skip, up to 3600000ms (60 min) for full workflow runs.
+
+</critical_rules>
+
+<error_handling>
+
+| Condition | Action |
+|-----------|--------|
+| Workflow ID not found | List available workflows, suggest closest match |
+| merlin-loop not found | Check ~/.claude/loop/merlin-loop.sh, suggest reinstall |
+| Workflow step fails | Show failure, offer resume/skip/investigate/abort |
+| Timeout on full run | Suggest using `merlin-loop workflow run` directly in terminal |
+| No workflow-run.json | Report "no active run" for status/resume/skip |
+| Invalid JSON in workflow | Report parse error, suggest checking file |
+
+</error_handling>

package/files/loop/lib/workflow-run.sh

@@ -0,0 +1,359 @@
+#!/usr/bin/env bash
+#
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  MERLIN WORKFLOW ENGINE — Run, Resume, Status, CLI                       ║
+# ║  Orchestration layer on top of workflow.sh core engine                   ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+#
+# Requires: workflow.sh loaded first (provides core functions)
+
+# Colors (inherit or set defaults)
+: "${RESET:=\033[0m}"
+: "${BOLD:=\033[1m}"
+: "${DIM:=\033[2m}"
+: "${RED:=\033[31m}"
+: "${GREEN:=\033[32m}"
+: "${YELLOW:=\033[33m}"
+: "${BLUE:=\033[34m}"
+: "${MAGENTA:=\033[35m}"
+: "${CYAN:=\033[36m}"
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Main Run Orchestrator
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Run a complete workflow
+workflow_run() {
+  local wf_id="$1"
+  local task="$2"
+
+  # Load workflow
+  local wf_json
+  wf_json=$(workflow_load "$wf_id") || return 1
+
+  local wf_name step_count on_failure
+  wf_name=$(echo "$wf_json" | python3 -c "import json,sys; print(json.load(sys.stdin).get('name', '$wf_id'))")
+  step_count=$(echo "$wf_json" | python3 -c "import json,sys; print(len(json.load(sys.stdin)['steps']))")
+  on_failure=$(echo "$wf_json" | python3 -c "import json,sys; print(json.load(sys.stdin).get('on_failure','pause'))")
+
+  # Banner
+  echo -e "${MAGENTA}${BOLD}"
+  echo "  ╔═══════════════════════════════════════════════════════════╗"
+  echo "  ║  MERLIN WORKFLOW: ${wf_name}"
+  echo "  ╚═══════════════════════════════════════════════════════════╝"
+  echo -e "${RESET}"
+  echo -e "  ${CYAN}Task:${RESET}  $task"
+  echo -e "  ${CYAN}Steps:${RESET} $step_count"
+  echo ""
+
+  # Show step pipeline
+  local step_labels
+  step_labels=$(echo "$wf_json" | python3 -c "
+import json,sys
+wf = json.load(sys.stdin)
+labels = [s.get('label', s['id']) for s in wf['steps']]
+print(' -> '.join(labels))
+")
+  echo -e "  ${DIM}Pipeline: ${step_labels}${RESET}"
+  echo ""
+
+  # Initialize run
+  local session_dir="${MERLIN_LOOP_DIR:-.merlin-loop}/workflow-session"
+  mkdir -p "$session_dir"
+
+  local run_id
+  run_id=$(workflow_run_init "$wf_json" "$task")
+  echo -e "  ${BLUE}Run ID: ${BOLD}${run_id}${RESET}"
+  echo ""
+
+  # Create handoff chain
+  if type handoff_create &>/dev/null; then
+    handoff_create "$session_dir" >/dev/null
+  fi
+
+  # Execute steps sequentially
+  local step_num=0
+  local total_steps="$step_count"
+
+  echo "$wf_json" | python3 -c "
+import json,sys
+wf = json.load(sys.stdin)
+for s in wf['steps']:
+    print(json.dumps(s))
+" | while IFS= read -r step_json; do
+    step_num=$((step_num + 1))
+    local step_id step_label
+    step_id=$(echo "$step_json" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
+    step_label=$(echo "$step_json" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('label', d['id']))")
+
+    echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+    echo -e "${BOLD}  Step ${step_num}/${total_steps}: ${step_label}${RESET}"
+    echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+
+    # Get handoff context for this step
+    local handoff_context=""
+    if type handoff_format_for_agent &>/dev/null && [ -f "$session_dir/handoff.json" ]; then
+      handoff_context=$(handoff_format_for_agent "$session_dir/handoff.json")
+    fi
+
+    # Execute step
+    local step_output
+    step_output=$(workflow_step_run "$step_json" "$task" "$handoff_context" "$session_dir")
+    local step_exit=$?
+
+    if [ $step_exit -eq 0 ]; then
+      echo -e "  ${GREEN}${BOLD}✓ ${step_label} complete${RESET}"
+    else
+      echo -e "  ${RED}${BOLD}✗ ${step_label} failed${RESET}"
+      case "$on_failure" in
+        pause)
+          echo -e "  ${YELLOW}Workflow paused. Resume with: merlin-loop workflow resume${RESET}"
+          return 1 ;;
+        skip)
+          echo -e "  ${YELLOW}Skipping failed step and continuing...${RESET}"
+          _workflow_update_step "$step_id" "skipped" ;;
+        abort)
+          echo -e "  ${RED}Workflow aborted.${RESET}"
+          return 1 ;;
+      esac
+    fi
+    echo ""
+  done
+
+  # Completion banner
+  echo -e "${GREEN}${BOLD}"
+  echo "  ╔═══════════════════════════════════════════════════════════╗"
+  echo "  ║  WORKFLOW COMPLETE                                        ║"
+  echo "  ╚═══════════════════════════════════════════════════════════╝"
+  echo -e "${RESET}"
+
+  local on_complete
+  on_complete=$(echo "$wf_json" | python3 -c "import json,sys; print(json.load(sys.stdin).get('on_complete','notify'))")
+  if [ "$on_complete" = "notify" ] && type send_notification &>/dev/null; then
+    send_notification "Workflow Complete" "${wf_name}: ${task}"
+  fi
+  return 0
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Resume from interrupted run
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_resume() {
+  local run_id="${1:-}"
+
+  if [ ! -f "$WORKFLOW_RUN_FILE" ]; then
+    echo -e "${RED}No workflow run to resume.${RESET}" >&2
+    return 1
+  fi
+
+  local wf_id task current_step
+  wf_id=$(python3 -c "import json; r=json.load(open('$WORKFLOW_RUN_FILE')); print(r['workflow'])")
+  task=$(python3 -c "import json; r=json.load(open('$WORKFLOW_RUN_FILE')); print(r['task'])")
+  current_step=$(python3 -c "import json; r=json.load(open('$WORKFLOW_RUN_FILE')); print(r.get('current_step',''))")
+
+  if [ -z "$current_step" ] || [ "$current_step" = "None" ]; then
+    echo -e "${GREEN}Workflow already completed.${RESET}"
+    return 0
+  fi
+
+  echo -e "${BLUE}Resuming workflow '${wf_id}' from step '${current_step}'${RESET}"
+  echo -e "${BLUE}Task: ${task}${RESET}"
+  echo ""
+
+  local wf_json
+  wf_json=$(workflow_load "$wf_id") || return 1
+
+  local session_dir="${MERLIN_LOOP_DIR:-.merlin-loop}/workflow-session"
+  mkdir -p "$session_dir"
+
+  if [ ! -f "$session_dir/handoff.json" ] && type handoff_create &>/dev/null; then
+    handoff_create "$session_dir" >/dev/null
+  fi
+
+  local step_num=0
+  echo "$wf_json" | python3 -c "
+import json,sys
+wf = json.load(sys.stdin)
+for s in wf['steps']:
+    print(json.dumps(s))
+" | while IFS= read -r step_json; do
+    step_num=$((step_num + 1))
+    local step_id
+    step_id=$(echo "$step_json" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
+
+    local step_status
+    step_status=$(python3 -c "import json; r=json.load(open('$WORKFLOW_RUN_FILE')); print(r['steps'].get('$step_id',{}).get('status','pending'))")
+
+    if [ "$step_status" = "done" ] || [ "$step_status" = "skipped" ]; then
+      echo -e "  ${DIM}✓ ${step_id} (${step_status})${RESET}"
+      continue
+    fi
+
+    local step_label
+    step_label=$(echo "$step_json" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('label', d['id']))")
+
+    echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+    echo -e "${BOLD}  Resuming: ${step_label}${RESET}"
+    echo -e "${MAGENTA}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+
+    local handoff_context=""
+    if type handoff_format_for_agent &>/dev/null && [ -f "$session_dir/handoff.json" ]; then
+      handoff_context=$(handoff_format_for_agent "$session_dir/handoff.json")
+    fi
+
+    local step_output
+    step_output=$(workflow_step_run "$step_json" "$task" "$handoff_context" "$session_dir")
+    local step_exit=$?
+
+    if [ $step_exit -eq 0 ]; then
+      echo -e "  ${GREEN}${BOLD}✓ ${step_label} complete${RESET}"
+    else
+      echo -e "  ${RED}${BOLD}✗ ${step_label} failed${RESET}"
+      echo -e "  ${YELLOW}Paused. Resume with: merlin-loop workflow resume${RESET}"
+      return 1
+    fi
+  done
+
+  echo -e "${GREEN}${BOLD}  Workflow resumed and completed.${RESET}"
+  return 0
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Status Display
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_status() {
+  if [ ! -f "$WORKFLOW_RUN_FILE" ]; then
+    echo -e "${DIM}No active workflow run.${RESET}"
+    return 0
+  fi
+
+  python3 << PYEOF
+import json
+
+with open("$WORKFLOW_RUN_FILE", 'r') as f:
+    run = json.load(f)
+
+print(f"\n  \033[1mWorkflow:\033[0m {run.get('workflow_name', run['workflow'])}")
+print(f"  \033[1mTask:\033[0m     {run['task']}")
+print(f"  \033[1mStatus:\033[0m   {run['status']}")
+print(f"  \033[1mRun ID:\033[0m   {run['run_id']}")
+print(f"  \033[1mStarted:\033[0m  {run['started']}")
+print()
+
+for step_id, step in run['steps'].items():
+    status = step.get('status', 'pending')
+    icons = {'done': '\033[32m\u2713\033[0m', 'running': '\033[33m\u25b6\033[0m',
+             'failed': '\033[31m\u2717\033[0m', 'skipped': '\033[2m\u25cb\033[0m',
+             'pending': '\033[2m\u00b7\033[0m'}
+    icon = icons.get(status, '?')
+    current = " \u2190 current" if step_id == run.get('current_step') else ""
+    attempts = f" (attempts: {step.get('attempts', 0)})" if step.get('attempts', 0) > 1 else ""
+    print(f"  {icon} {step_id}{attempts}{current}")
+print()
+PYEOF
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Skip & Install
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_skip() {
+  if [ ! -f "$WORKFLOW_RUN_FILE" ]; then
+    echo -e "${RED}No active workflow run.${RESET}" >&2
+    return 1
+  fi
+
+  local current_step
+  current_step=$(python3 -c "import json; r=json.load(open('$WORKFLOW_RUN_FILE')); print(r.get('current_step',''))")
+
+  if [ -z "$current_step" ] || [ "$current_step" = "None" ]; then
+    echo -e "${GREEN}Workflow already completed.${RESET}"
+    return 0
+  fi
+
+  _workflow_update_step "$current_step" "skipped"
+  echo -e "${YELLOW}Skipped step: ${current_step}${RESET}"
+  workflow_status
+}
+
+workflow_install() {
+  local source="$1"
+  mkdir -p "$WORKFLOW_DIR"
+
+  if [[ "$source" == http* ]] || [[ "$source" == github.com/* ]]; then
+    local url="$source"
+    [[ "$url" != http* ]] && url="https://${url}"
+
+    if echo "$url" | grep -q "github.com"; then
+      url=$(echo "$url" | sed 's|github.com|raw.githubusercontent.com|' | sed 's|/blob/||')
+    fi
+
+    local filename
+    filename=$(basename "$url")
+    [[ "$filename" != *.json ]] && filename="${filename}.json"
+
+    echo -e "${BLUE}Downloading: ${url}${RESET}"
+    if curl -fsSL "$url" -o "$WORKFLOW_DIR/$filename" 2>/dev/null; then
+      if python3 -c "import json; json.load(open('$WORKFLOW_DIR/$filename'))" 2>/dev/null; then
+        echo -e "${GREEN}Installed: ${WORKFLOW_DIR}/${filename}${RESET}"
+      else
+        rm -f "$WORKFLOW_DIR/$filename"
+        echo -e "${RED}Invalid JSON. Installation failed.${RESET}" >&2
+        return 1
+      fi
+    else
+      echo -e "${RED}Download failed.${RESET}" >&2
+      return 1
+    fi
+  elif [ -f "$source" ]; then
+    local filename
+    filename=$(basename "$source")
+    cp "$source" "$WORKFLOW_DIR/$filename"
+    echo -e "${GREEN}Installed: ${WORKFLOW_DIR}/${filename}${RESET}"
+  else
+    echo -e "${RED}Source not found: ${source}${RESET}" >&2
+    return 1
+  fi
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CLI Dispatch
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_dispatch() {
+  local subcmd="${1:-list}"
+  shift 2>/dev/null || true
+
+  case "$subcmd" in
+    list)    workflow_list ;;
+    run)
+      local wf_id="${1:-}"
+      shift 2>/dev/null || true
+      local task="$*"
+      if [ -z "$wf_id" ] || [ -z "$task" ]; then
+        echo -e "${RED}Usage: merlin-loop workflow run <id> \"<task>\"${RESET}" >&2
+        echo -e "${DIM}Example: merlin-loop workflow run feature-dev \"Add OAuth login\"${RESET}" >&2
+        return 1
+      fi
+      workflow_run "$wf_id" "$task"
+      ;;
+    status)  workflow_status ;;
+    resume)  workflow_resume "$@" ;;
+    skip)    workflow_skip ;;
+    install)
+      local source="${1:-}"
+      if [ -z "$source" ]; then
+        echo -e "${RED}Usage: merlin-loop workflow install <url|file>${RESET}" >&2
+        return 1
+      fi
+      workflow_install "$source"
+      ;;
+    *)
+      echo -e "${RED}Unknown workflow command: ${subcmd}${RESET}" >&2
+      echo -e "Commands: list, run, status, resume, skip, install" >&2
+      return 1
+      ;;
+  esac
+}