create-merlin-brain 3.8.0-beta.1 → 3.8.0-beta.3

package/files/agents/merlin.md

@@ -305,6 +305,39 @@ Activated by: "get shit done", "Merlin mode", "move fast", "just build it", "shi
 
 ---
 
+## Proactive Workflow Suggestions
+
+When a user's task matches a workflow pattern, **suggest it as option [1]** before routing manually.
+Users don't need to know commands exist — Merlin surfaces them.
+
+| User intent | Suggest |
+|---|---|
+| "build [feature]", "add [feature]" | `/merlin:workflow run feature-dev "..."` |
+| "build the whole thing", "full product", "end to end" | `/merlin:workflow run product-dev "..."` |
+| "fix [bug]", "broken", "not working", "crash" | `/merlin:workflow run bug-fix "..."` |
+| "security", "audit", "vulnerabilities", "pen test" | `/merlin:workflow run security-audit` |
+| "refactor", "cleanup", "tech debt", "organize" | `/merlin:workflow run refactor "..."` |
+| "build UI", "frontend", "components", "design" | `/merlin:workflow run ui-build "..."` |
+| "build API", "endpoints", "REST", "backend" | `/merlin:workflow run api-build "..."` |
+| "idea", "from scratch", "spec first", "greenfield" | `/merlin:workflow run spec-to-code "..."` |
+| Complex multi-step, migration, unusual pipeline | `/merlin:workflow create "..."` |
+
+**Suggestion format:**
+```
+🔮 This looks like a great fit for an automated workflow:
+
+[1] Run **feature-dev** workflow (automated 7-step pipeline)
+[2] Route to specialist for quick manual work
+[3] Plan as a phase first
+```
+
+**When NOT to suggest workflows:**
+- Task is trivially small (one file, few lines)
+- User explicitly says "just do it" or "quick fix"
+- Already inside a workflow run
+
+---
+
 ## Anti-Patterns (NEVER Do These)
 
 - **Never** run `claude --agent` via Bash — it FAILS inside Claude Code sessions. Use `Skill("merlin:route")` instead

package/files/commands/merlin/help.md

@@ -306,6 +306,51 @@ See what's changed since your installed version.
 
 Usage: `/merlin:whats-new`
 
+## Automated Workflows
+
+Workflows are named pipelines that chain specialist agents through a fixed sequence.
+Each step spawns a fresh Claude process with 200K context.
+
+**`/merlin:workflow list`** — See all available workflows
+**`/merlin:workflow run <id> "<task>"`** — Execute a workflow
+**`/merlin:workflow create "<goal>"`** — Generate a custom workflow from a goal description
+**`/merlin:workflow status`** — Check current run progress
+**`/merlin:workflow resume`** — Resume an interrupted workflow
+**`/merlin:workflow skip`** — Skip current step and advance
+
+### Bundled Workflows
+
+| Workflow | Steps | Description |
+|----------|-------|-------------|
+| `feature-dev` | 7 | Drop in a feature request. Get back a tested PR. |
+| `bug-fix` | 6 | Report a bug. Get back a fix with regression test and PR. |
+| `security-audit` | 6 | Run a full security sweep. Get fixes and a clean report. |
+| `refactor` | 6 | Analyze, plan, refactor, verify, test, and PR. |
+| `product-dev` | 7 | Describe a product idea. Get back a fully built, tested feature. |
+| `ui-build` | 7 | Describe a UI. Get back designed, built, tested components. |
+| `api-build` | 7 | Describe an API. Get back designed, validated, tested endpoints. |
+| `spec-to-code` | 7 | Start from an idea. Get back specced, architected, tested code. |
+
+### Dynamic Workflow Creation
+
+Don't see a workflow that fits? Generate one:
+```
+/merlin:workflow create "Migrate from MongoDB to PostgreSQL with zero downtime"
+```
+
+Merlin uses Claude to design a custom pipeline with the right specialist agents.
+
+### Terminal Usage
+
+Workflows also run outside Claude Code via the loop:
+```bash
+merlin-loop workflow list
+merlin-loop workflow run feature-dev "Add OAuth login"
+merlin-loop workflow create "Set up CI/CD pipeline"
+merlin-loop workflow status
+merlin-loop workflow resume
+```
+
 ## Files & Structure
 
 ```

package/files/commands/merlin/update.md

@@ -1,23 +1,32 @@
 ---
 name: merlin:update
 description: Update Merlin to latest version with changelog display
+argument-hint: "[--beta | --stable]"
 ---
 
 <objective>
 Check for Merlin updates, install if available, and display what changed.
 
-Provides a better update experience than raw `npx create-merlin-brain` by showing version diff and changelog entries.
+Supports two channels:
+- **stable** (default) — production-ready releases via `npx create-merlin-brain@latest`
+- **beta** — cutting-edge features via `npx create-merlin-brain@beta`
+
+Provides a better update experience than raw `npx` by showing version diff, channel info, and changelog.
 </objective>
 
 <process>
 
 <step name="get_installed_version">
-Read installed version:
+Read installed version and detect current channel:
 
 ```bash
 cat ~/.claude/merlin/VERSION 2>/dev/null
 ```
 
+**Detect channel from version string:**
+- Contains `-beta` → user is on the **beta** channel
+- No prerelease suffix → user is on the **stable** channel
+
 **If VERSION file missing:**
 ```
 ## Merlin Update
@@ -32,56 +41,78 @@ Running fresh install...
 Proceed to install step (treat as version 0.0.0 for comparison).
 </step>
 
-<step name="check_latest_version">
-Check npm for latest version:
+<step name="check_available_versions">
+Check npm for both channels:
 
 ```bash
-npm view create-merlin-brain version 2>/dev/null
+npm view create-merlin-brain dist-tags --json 2>/dev/null
+```
+
+This returns something like:
+```json
+{"latest": "3.7.3", "beta": "3.8.0-beta.1"}
 ```
 
+If `--beta` flag in $ARGUMENTS: target the beta channel.
+If `--stable` flag in $ARGUMENTS: target the stable channel.
+If no flag: target whichever channel the user is currently on (detected from VERSION).
+
 **If npm check fails:**
 ```
 Couldn't check for updates (offline or npm unavailable).
 
-To update manually: `npx create-merlin-brain@latest`
+To update manually:
+  Stable: npx create-merlin-brain@latest
+  Beta:   npx create-merlin-brain@beta
 ```
 
 STOP here if npm unavailable.
 </step>
 
-<step name="compare_versions">
-Compare installed vs latest:
+<step name="display_status">
+Show a clear version dashboard:
 
-**If installed == latest:**
 ```
-## Merlin Update
+## Merlin Version Status
 
-**Installed:** X.Y.Z
-**Latest:** X.Y.Z
+**Installed:**  3.8.0-beta.1 (beta channel)
 
-You're already on the latest version.
-```
+**Available:**
+  stable  3.7.3          ← production-ready
+  beta    3.8.0-beta.1   ← cutting-edge (you are here)
 
-STOP here if already up to date.
+**Beta includes (not in stable):**
+  • Workflow Engine — predefined multi-agent pipelines
+    /merlin:workflow run feature-dev "Add OAuth login"
+  • 4 bundled workflows: feature-dev, bug-fix, security-audit, refactor
+  • CLI: merlin-loop workflow [list|run|status|resume|skip]
+```
 
-**If installed > latest:**
+**If installed matches target channel's latest:**
 ```
-## Merlin Update
+You're on the latest [channel] version.
+```
+STOP here if already up to date.
+</step>
 
-**Installed:** X.Y.Z
-**Latest:** A.B.C
+<step name="confirm_and_update">
+If update available, ask user to confirm:
 
-You're ahead of the latest release (development version?).
 ```
+Update available: X.Y.Z → A.B.C (channel)
 
-STOP here if ahead.
-</step>
-
-<step name="run_update">
-Run the update:
+[1] Update now
+[2] Switch to [other channel] instead
+[3] Skip
+```
 
+Run the update based on choice:
 ```bash
+# For stable:
 npx create-merlin-brain@latest
+
+# For beta:
+npx create-merlin-brain@beta
 ```
 
 Capture output. If install fails, show error and STOP.
@@ -101,59 +132,43 @@ cat ~/.claude/merlin/CHANGELOG.md 2>/dev/null
 ```
 </step>
 
-<step name="extract_changes">
-From the changelog, extract entries between:
-- **From:** installed version (exclusive)
-- **To:** latest version (inclusive)
-
-Parse each `## [X.Y.Z]` section and collect all versions in the range.
-</step>
-
 <step name="display_result">
-Format beautiful output:
+Format output:
 
 ```
-Merlin Updated: v1.5.10 -> v3.0.0
+Merlin Updated: v3.7.3 → v3.8.0-beta.1 (beta)
 
 What's New
 ------------------------------------------------------------
 
-## [3.0.0] - 2026-02-07
-
-### Changed
-- BREAKING: All agent routing now uses fresh process isolation
-- Every specialist gets fresh 200K context via `claude --agent -p`
-- Task() removed entirely — deterministic handoff protocol
-- Two modes: interactive (default) and automated
+## [3.8.0-beta.0] - 2026-02-21
 
-## [2.x.x] - ...
-
-### Fixed
-- ...
+### Added
+- Workflow Engine — predefined multi-agent pipelines
+- 4 bundled workflows: feature-dev, bug-fix, security-audit, refactor
+- /merlin:workflow skill command
+- merlin-loop workflow CLI integration
 
 ------------------------------------------------------------
 
 Restart Claude Code to pick up the new commands.
-
-[View full changelog](https://github.com/sandman66666/merlin/blob/main/CHANGELOG.md)
 ```
 
 **Key elements:**
-- Version transition header
+- Version transition header with channel
 - All changelog entries in the range
 - **BREAKING:** changes surfaced prominently
-- Restart reminder (critical for picking up new commands)
-- Link to full changelog
+- Restart reminder
 </step>
 
 </process>
 
 <success_criteria>
-- [ ] Installed version read correctly
-- [ ] Latest version checked via npm
-- [ ] Update skipped if already current
+- [ ] Installed version and channel detected correctly
+- [ ] Both stable and beta versions checked via npm
+- [ ] Channel-aware update (beta stays on beta, stable stays on stable)
+- [ ] User can switch channels with --beta / --stable flags
 - [ ] Update executed successfully
-- [ ] Changelog fetched (remote or local fallback)
-- [ ] Changes between versions displayed
+- [ ] Changelog displayed
 - [ ] Restart reminder shown
 </success_criteria>

package/files/commands/merlin/whats-new.md

@@ -4,9 +4,10 @@ description: See what's new in Merlin since your installed version
 ---
 
 <objective>
-Display changes between installed version and latest available version.
+Display your installed version, current channel (stable vs beta), what's available,
+and what the beta channel offers over stable.
 
-Shows version comparison, changelog entries for missed versions, and update instructions.
+Quick version check — no installs, just info.
 </objective>
 
 <process>
@@ -18,6 +19,10 @@ Read installed version from VERSION file:
 cat ~/.claude/merlin/VERSION 2>/dev/null
 ```
 
+**Detect channel from version string:**
+- Contains `-beta` → **beta** channel
+- No prerelease suffix → **stable** channel
+
 **If VERSION file missing:**
 ```
 ## Merlin What's New
@@ -27,98 +32,120 @@ cat ~/.claude/merlin/VERSION 2>/dev/null
 Your installation doesn't include version tracking.
 
 **To fix:** `npx create-merlin-brain@latest`
-
-This will reinstall with version tracking enabled.
 ```
 
 STOP here if no VERSION file.
 </step>
 
-<step name="fetch_remote_changelog">
-Fetch latest CHANGELOG.md from GitHub:
-
-Use WebFetch tool with:
-- URL: `https://raw.githubusercontent.com/sandman66666/merlin/main/CHANGELOG.md`
-- Prompt: "Extract all version entries with their dates and changes. Return in Keep-a-Changelog format."
+<step name="check_available_versions">
+Check npm for all dist-tags:
 
-**If fetch fails:**
-Fall back to local changelog:
 ```bash
-cat ~/.claude/merlin/CHANGELOG.md 2>/dev/null
+npm view create-merlin-brain dist-tags --json 2>/dev/null
 ```
 
-Note to user: "Couldn't check for updates (offline or GitHub unavailable). Showing local changelog."
+**If npm check fails:**
+Show installed version only with offline note.
 </step>
 
-<step name="parse_versions">
-From the remote (or local) changelog:
+<step name="display_dashboard">
+Show a clear version dashboard:
 
-1. **Extract latest version** - First `## [X.Y.Z]` line after `## [Unreleased]`
-2. **Compare with installed** - From VERSION file
-3. **Extract entries between** - All version sections from latest down to (but not including) installed
+```
+## Merlin Version Status
 
-**Version comparison:**
-- If installed == latest: "You're on the latest version"
-- If installed < latest: Show changes since installed version
-- If installed > latest: "You're ahead of latest release (development version?)"
-</step>
+**Installed:**  3.8.0-beta.1
+**Channel:**    beta
 
-<step name="display_output">
-Format output clearly:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-**If up to date:**
+**Available versions:**
+  stable   3.7.3            npx create-merlin-brain@latest
+  beta     3.8.0-beta.1  ←  npx create-merlin-brain@beta
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
-## Merlin What's New
 
-**Installed:** 1.4.26
-**Latest:** 1.4.26
+Then show what's different between channels.
+</step>
 
-You're on the latest version.
+<step name="show_beta_features">
+**Always show what beta has that stable doesn't:**
 
-[View full changelog](https://github.com/sandman66666/merlin/blob/main/CHANGELOG.md)
 ```
-
-**If updates available:**
+## What's in Beta (not in stable)
+
+### Workflow Engine (3.8.0-beta)
+Predefined multi-agent pipelines that chain specialist agents automatically.
+
+**4 bundled workflows:**
+- `feature-dev` — 7-step pipeline: plan → setup → implement → verify → test → PR → review
+- `bug-fix` — 6-step pipeline: triage → investigate → fix → regression-test → verify → PR
+- `security-audit` — 6-step pipeline: scan → prioritize → fix → verify → test → PR
+- `refactor` — 6-step pipeline: analyze → plan → refactor → verify → test → PR
+
+**How to use:**
+  /merlin:workflow list                         — see available workflows
+  /merlin:workflow run feature-dev "Add X"      — run a complete pipeline
+  /merlin:workflow status                       — check progress
+  /merlin:workflow resume                       — resume after interruption
+
+**CLI (outside Claude Code):**
+  merlin-loop workflow list
+  merlin-loop workflow run feature-dev "Add OAuth login"
+
+Each step spawns a fresh Claude process with 200K context.
+Uses blend engine for optimal agent selection per step.
+Structured handoffs pass context between steps automatically.
 ```
-## Merlin What's New
-
-**Installed:** 1.4.23
-**Latest:** 1.4.26
-
----
+</step>
 
-### Changes since your version:
+<step name="show_update_instructions">
+Based on current state:
 
-## [1.4.26] - 2026-01-20
+**If on stable, beta available:**
+```
+**Want to try beta?**
+  npx create-merlin-brain@beta
 
-### Added
-- Feature X
-- Feature Y
+**Stay on stable (just update):**
+  /merlin:update
+```
 
-### Changed
-- **BREAKING:** Changed Z behavior
+**If on beta, update available:**
+```
+**Update beta:**
+  npx create-merlin-brain@beta
 
-## [1.4.25] - 2026-01-18
+**Switch to stable:**
+  npx create-merlin-brain@latest
+```
 
-### Fixed
-- Bug in feature A
+**If on latest of current channel:**
+```
+You're on the latest [channel] version.
+```
+</step>
 
----
+<step name="fetch_changelog">
+Optionally fetch remote changelog for detailed version history:
 
-[View full changelog](https://github.com/sandman66666/merlin/blob/main/CHANGELOG.md)
+Use WebFetch tool with:
+- URL: `https://raw.githubusercontent.com/sandman66666/merlin/main/CHANGELOG.md`
+- Prompt: "Extract all version entries with their dates and changes. Return in Keep-a-Changelog format."
 
-**To update:** `npx create-merlin-brain@latest`
-```
+**If fetch fails:** Skip this step (dashboard is sufficient).
 
-**Breaking changes:** Surface prominently with **BREAKING:** prefix in the output.
+Show entries between installed version and latest only if there are missed versions.
 </step>
 
 </process>
 
 <success_criteria>
 - [ ] Installed version read from VERSION file
-- [ ] Remote changelog fetched (or graceful fallback to local)
-- [ ] Version comparison displayed clearly
-- [ ] Changes since installed version shown (if any)
-- [ ] Update instructions provided when behind
+- [ ] Channel correctly detected (stable vs beta)
+- [ ] Both available versions shown (stable + beta)
+- [ ] Beta features described clearly
+- [ ] Install/switch instructions provided
+- [ ] Works gracefully offline (shows installed info only)
 </success_criteria>

package/files/commands/merlin/workflow.md

@@ -1,7 +1,7 @@
 ---
 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]"
+argument-hint: "[list | run <id> \"<task>\" | create \"<goal>\" | status | resume | skip]"
 allowed-tools:
   - Read
   - Glob
@@ -38,7 +38,7 @@ between steps, and independent verification for high-stakes steps.
 ## Step 1: Parse Arguments
 
 Extract from $ARGUMENTS:
-- **subcommand**: First word (list, run, status, resume, skip)
+- **subcommand**: First word (list, run, create, status, resume, skip)
 - **workflow-id**: Second word (only for `run`)
 - **task**: Everything after workflow-id (only for `run`)
 
@@ -48,11 +48,12 @@ Available workflow commands:
 
   /merlin:workflow list                      — See available workflows
   /merlin:workflow run feature-dev "Add X"   — Run a workflow
+  /merlin:workflow create "Migrate to X"     — Generate custom workflow from goal
   /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
+Bundled workflows: feature-dev, bug-fix, security-audit, refactor, product-dev, ui-build, api-build, spec-to-code
 ```
 
 ## Step 2: Route by Subcommand
@@ -210,6 +211,59 @@ Next steps:
 [3] Continue in current context
 ```
 
+### `create` — Generate Custom Workflow
+
+**Required args:** goal description (what you want to achieve).
+
+If missing:
+```
+Usage: /merlin:workflow create "<goal description>"
+
+Example: /merlin:workflow create "Migrate from MongoDB to PostgreSQL with zero downtime"
+```
+
+#### Step 2a: Get Sights Context
+
+```
+Call: merlin_get_context
+Task: "{goal description}"
+```
+
+#### Step 2b: Generate via merlin-loop
+
+```bash
+LOOP_SCRIPT="${HOME}/.claude/loop/merlin-loop.sh"
+bash "$LOOP_SCRIPT" workflow create "${GOAL}" 2>&1
+```
+
+The workflow engine will:
+1. Use Claude to design a custom pipeline based on the goal
+2. Validate the generated JSON (correct schema, valid agent_hints)
+3. Save to `~/.claude/loop/workflows/<id>.json`
+4. Show a preview of the generated pipeline
+
+#### Step 2c: Confirm and Run
+
+Show the generated pipeline preview to the user:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+GENERATED WORKFLOW: [name]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Goal: [goal]
+Steps: [N]
+Pipeline: Step1 -> Step2 -> Step3 -> ...
+
+[1] Run this workflow now
+[2] Edit the workflow JSON first
+[3] Save for later
+```
+
+If user confirms, run it:
+```bash
+bash "$LOOP_SCRIPT" workflow run "${WORKFLOW_ID}" "${GOAL}" 2>&1
+```
+
 ### `status` — Show Current Run
 
 Read the workflow run state:

package/files/hooks/session-start-boot.md

@@ -35,6 +35,22 @@ You are not generic Claude. You are a **Merlin agent** — enhanced with codebas
 | plan, roadmap, phase, milestone | Use /merlin:plan-phase or /merlin:discuss-milestone |
 | map, analyze, understand codebase | Use /merlin:map-codebase |
 
+**You suggest workflows.** When a user's task matches a workflow pattern, suggest it proactively:
+
+| User says | Suggest workflow |
+|---|---|
+| "build [feature]", "add [feature]" | `feature-dev` |
+| "build the whole thing", "full product" | `product-dev` |
+| "fix [bug]", "broken", "not working" | `bug-fix` |
+| "security", "audit", "vulnerabilities" | `security-audit` |
+| "refactor", "cleanup", "tech debt" | `refactor` |
+| "build UI", "frontend", "components" | `ui-build` |
+| "build API", "endpoints", "REST" | `api-build` |
+| "idea", "from scratch", "spec first" | `spec-to-code` |
+| Complex multi-step or unusual task | `/merlin:workflow create "..."` |
+
+Show as: `[1] Run **workflow-name** workflow (automated N-step pipeline)` — users don't need to know commands.
+
 **You maintain continuity.** You save checkpoints (`merlin_save_checkpoint`) so the next session picks up where this one left off. You commit work incrementally. You never let work disappear.
 
 **You verify before committing.** Call `merlin_run_verification` before every git commit. Build, types, lint must pass.

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

@@ -0,0 +1,228 @@
+#!/usr/bin/env bash
+#
+# ╔═══════════════════════════════════════════════════════════════════════════╗
+# ║  MERLIN WORKFLOW ENGINE — Dynamic Workflow Generation                    ║
+# ║  Describe a goal, Merlin generates a custom pipeline                    ║
+# ╚═══════════════════════════════════════════════════════════════════════════╝
+#
+# Uses Claude to generate a workflow JSON from a natural language goal.
+# The generated workflow follows the same schema as bundled workflows
+# and can be run, resumed, and managed identically.
+
+# Colors (inherit from parent)
+: "${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}"
+
+# Valid agent_hint values from the blend engine registry
+VALID_AGENT_HINTS="impl security architect spec test debug refactor frontend api deploy docs perf migrate video secaudit codeorg review swift android uidesign uibuild anim"
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Generate a workflow from a goal description
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_generate() {
+  local goal="$1"
+
+  if [ -z "$goal" ]; then
+    echo -e "${RED}Usage: workflow create \"<goal description>\"${RESET}" >&2
+    echo -e "${DIM}Example: workflow create \"Migrate from MongoDB to PostgreSQL\"${RESET}" >&2
+    return 1
+  fi
+
+  echo -e "${MAGENTA}${BOLD}  Generating workflow for:${RESET} ${goal}" >&2
+  echo -e "${DIM}  Using Claude to design a custom pipeline...${RESET}" >&2
+  echo "" >&2
+
+  # Build the generation prompt
+  local prompt
+  prompt=$(cat <<'PROMPT_END'
+You are a workflow designer for the Merlin AI development system. Generate a JSON workflow definition.
+
+SCHEMA REQUIREMENTS:
+- "id": kebab-case identifier (e.g., "mongo-to-postgres")
+- "name": Human-readable name
+- "description": One-line description
+- "version": "1.0"
+- "steps": Array of 5-8 step objects
+- "on_failure": "pause"
+- "on_complete": "notify"
+
+STEP SCHEMA:
+- "id": short kebab-case (e.g., "analyze", "implement")
+- "label": Human-readable step name
+- "agent_hint": One of: impl, security, architect, spec, test, debug, refactor, frontend, api, deploy, docs, perf, migrate, secaudit, uidesign, uibuild, anim
+- "input_template": Detailed prompt with {{task}} and {{handoff}} placeholders. Use {{filename.md}} for output_file references.
+- "expects": UPPER_CASE signal (e.g., "ANALYSIS_COMPLETE")
+- "retry": 1-3 (more for complex steps)
+- Optional: "output_file": "filename.md", "blend": true (for implementation steps), "independent": true (for verification), "action": "gh_pr_create" (for PR steps)
+
+DESIGN PRINCIPLES:
+- Start with analysis/planning, end with testing/PR
+- Include an independent verification step
+- Implementation steps should have blend: true and retry: 3
+- Each step's input_template should be detailed enough for an AI agent to work autonomously
+- Reference previous step outputs via {{filename.md}} when available
+
+Output ONLY valid JSON. No markdown fences, no explanation.
+PROMPT_END
+)
+
+  prompt="${prompt}
+
+GOAL: ${goal}
+
+Generate the workflow JSON now:"
+
+  # Call Claude to generate
+  local raw_output
+  raw_output=$(echo "$prompt" | claude -p --output-format text 2>/dev/null)
+  local gen_exit=$?
+
+  if [ $gen_exit -ne 0 ] || [ -z "$raw_output" ]; then
+    echo -e "${RED}Failed to generate workflow. Claude returned an error.${RESET}" >&2
+    return 1
+  fi
+
+  # Extract JSON from output (handles possible markdown fences)
+  local json_output
+  json_output=$(echo "$raw_output" | python3 -c "
+import sys, json, re
+
+text = sys.stdin.read()
+
+# Try to extract JSON from markdown code fences
+match = re.search(r'\`\`\`(?:json)?\s*\n?(.*?)\n?\`\`\`', text, re.DOTALL)
+if match:
+    text = match.group(1).strip()
+
+# Try to find raw JSON object
+if not text.startswith('{'):
+    match = re.search(r'(\{.*\})', text, re.DOTALL)
+    if match:
+        text = match.group(1)
+
+# Validate it's valid JSON with required fields
+try:
+    wf = json.loads(text)
+    assert 'id' in wf, 'Missing id'
+    assert 'steps' in wf, 'Missing steps'
+    assert len(wf['steps']) > 0, 'No steps'
+    print(json.dumps(wf, indent=2))
+except Exception as e:
+    print(f'PARSE_ERROR: {e}', file=sys.stderr)
+    sys.exit(1)
+" 2>/dev/null)
+
+  if [ $? -ne 0 ] || [ -z "$json_output" ]; then
+    echo -e "${RED}Failed to parse generated workflow JSON.${RESET}" >&2
+    echo -e "${DIM}Raw output saved to /tmp/merlin-workflow-gen-debug.txt${RESET}" >&2
+    echo "$raw_output" > /tmp/merlin-workflow-gen-debug.txt
+    return 1
+  fi
+
+  # Validate agent_hints
+  local invalid_hints
+  invalid_hints=$(echo "$json_output" | python3 -c "
+import json, sys
+valid = set('${VALID_AGENT_HINTS}'.split())
+wf = json.load(sys.stdin)
+invalid = []
+for step in wf['steps']:
+    hint = step.get('agent_hint', '')
+    if hint and hint not in valid:
+        invalid.append(f\"{step['id']}: {hint}\")
+if invalid:
+    print('\n'.join(invalid))
+" 2>/dev/null)
+
+  if [ -n "$invalid_hints" ]; then
+    echo -e "${YELLOW}Warning: Some agent_hints are not in registry:${RESET}" >&2
+    echo -e "${DIM}${invalid_hints}${RESET}" >&2
+    echo -e "${YELLOW}Attempting to fix...${RESET}" >&2
+
+    # Auto-fix invalid hints to closest valid one (default: impl)
+    json_output=$(echo "$json_output" | python3 -c "
+import json, sys
+valid = set('${VALID_AGENT_HINTS}'.split())
+wf = json.load(sys.stdin)
+for step in wf['steps']:
+    if step.get('agent_hint', '') not in valid:
+        step['agent_hint'] = 'impl'
+print(json.dumps(wf, indent=2))
+" 2>/dev/null)
+  fi
+
+  # Ensure on_failure and on_complete exist
+  json_output=$(echo "$json_output" | python3 -c "
+import json, sys
+wf = json.load(sys.stdin)
+wf.setdefault('on_failure', 'pause')
+wf.setdefault('on_complete', 'notify')
+wf.setdefault('version', '1.0')
+print(json.dumps(wf, indent=2))
+" 2>/dev/null)
+
+  # Save to workflow directory
+  local wf_id
+  wf_id=$(echo "$json_output" | python3 -c "import json,sys; print(json.load(sys.stdin)['id'])")
+
+  local save_dir="${WORKFLOW_DIR}"
+  mkdir -p "$save_dir"
+  local save_path="${save_dir}/${wf_id}.json"
+
+  echo "$json_output" > "$save_path"
+  echo -e "${GREEN}${BOLD}  Workflow saved:${RESET} ${save_path}" >&2
+
+  # Show preview
+  workflow_show_preview "$json_output"
+
+  # Return the path for callers
+  echo "$save_path"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Pretty-print a workflow for user confirmation
+# ═══════════════════════════════════════════════════════════════════════════════
+
+workflow_show_preview() {
+  local json_input="$1"
+
+  python3 -c "
+import json, sys
+
+wf = json.loads('''${json_input//\'/\\\'}''')
+
+name = wf.get('name', wf['id'])
+desc = wf.get('description', '')
+steps = wf['steps']
+
+print()
+print(f'  \033[35m\033[1m{name}\033[0m')
+print(f'  \033[2m{desc}\033[0m')
+print(f'  \033[36mSteps:\033[0m {len(steps)}')
+print()
+
+# Pipeline visualization
+labels = [s.get('label', s['id']) for s in steps]
+pipeline = ' \033[2m->\033[0m '.join(f'\033[1m{l}\033[0m' for l in labels)
+print(f'  Pipeline: {pipeline}')
+print()
+
+# Step detail table
+print(f'  \033[2m{\"Step\":<4} {\"Label\":<25} {\"Agent\":<12} {\"Signal\":<25}\033[0m')
+print(f'  \033[2m{\"─\"*4} {\"─\"*25} {\"─\"*12} {\"─\"*25}\033[0m')
+for i, s in enumerate(steps, 1):
+    label = s.get('label', s['id'])[:25]
+    hint = s.get('agent_hint', '?')[:12]
+    expects = s.get('expects', '-')[:25]
+    print(f'  {i:<4} {label:<25} {hint:<12} {expects:<25}')
+print()
+" 2>/dev/null >&2
+}

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

@@ -342,6 +342,52 @@ workflow_dispatch() {
     status)  workflow_status ;;
     resume)  workflow_resume "$@" ;;
     skip)    workflow_skip ;;
+    create)
+      local goal="$*"
+      if [ -z "$goal" ]; then
+        echo -e "${RED}Usage: merlin-loop workflow create \"<goal description>\"${RESET}" >&2
+        echo -e "${DIM}Example: merlin-loop workflow create \"Migrate from MongoDB to PostgreSQL\"${RESET}" >&2
+        return 1
+      fi
+      if ! type workflow_generate &>/dev/null; then
+        echo -e "${RED}Workflow generation not available. Check lib/workflow-gen.sh${RESET}" >&2
+        return 1
+      fi
+      local wf_path
+      wf_path=$(workflow_generate "$goal")
+      local gen_exit=$?
+      if [ $gen_exit -ne 0 ]; then
+        return 1
+      fi
+      # Interactive mode: ask to run
+      if [ -t 0 ] && [ -t 1 ]; then
+        echo ""
+        echo -e "${BOLD}Run this workflow now?${RESET}"
+        echo -e "  [${BOLD}y${RESET}] Yes, run it"
+        echo -e "  [${BOLD}n${RESET}] No, just save it"
+        echo -e "  [${BOLD}e${RESET}] Edit the JSON first"
+        echo -ne "  Choice: "
+        read -r choice
+        case "$choice" in
+          y|Y)
+            local wf_id
+            wf_id=$(python3 -c "import json; print(json.load(open('$wf_path'))['id'])")
+            workflow_run "$wf_id" "$goal"
+            ;;
+          e|E)
+            echo -e "${CYAN}Edit the workflow at: ${BOLD}${wf_path}${RESET}"
+            echo -e "${DIM}Then run: merlin-loop workflow run <id> \"${goal}\"${RESET}"
+            ;;
+          *)
+            echo -e "${GREEN}Saved to: ${wf_path}${RESET}"
+            echo -e "${DIM}Run later: merlin-loop workflow run <id> \"${goal}\"${RESET}"
+            ;;
+        esac
+      else
+        # Non-interactive: just save and print path
+        echo -e "${GREEN}Workflow saved: ${wf_path}${RESET}"
+      fi
+      ;;
     install)
       local source="${1:-}"
       if [ -z "$source" ]; then
@@ -352,7 +398,7 @@ workflow_dispatch() {
       ;;
     *)
       echo -e "${RED}Unknown workflow command: ${subcmd}${RESET}" >&2
-      echo -e "Commands: list, run, status, resume, skip, install" >&2
+      echo -e "Commands: list, run, create, status, resume, skip, install" >&2
       return 1
       ;;
   esac

package/files/loop/lib/workflow.sh

@@ -380,4 +380,5 @@ _workflow_run_action() {
 # ═══════════════════════════════════════════════════════════════════════════════
 
 _WORKFLOW_LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${_WORKFLOW_LIB_DIR}/workflow-gen.sh" 2>/dev/null || true
 source "${_WORKFLOW_LIB_DIR}/workflow-run.sh" 2>/dev/null || true

package/files/loop/merlin-loop.sh

@@ -772,6 +772,7 @@ usage() {
   echo ""
   echo "  workflow list                         List available workflows"
   echo "  workflow run <id> \"<task>\"             Run a named workflow"
+  echo "  workflow create \"<goal>\"               Generate custom workflow from goal"
   echo "  workflow status                       Show workflow run progress"
   echo "  workflow resume                       Resume interrupted workflow"
   echo "  workflow skip                         Skip current step and advance"
@@ -803,6 +804,7 @@ usage() {
   echo ""
   echo "  merlin-loop workflow list            # See available workflows"
   echo "  merlin-loop workflow run feature-dev \"Add OAuth\" # Run a workflow"
+  echo "  merlin-loop workflow create \"Migrate to Postgres\" # Generate custom workflow"
   echo "  merlin-loop workflow status          # Check progress"
   echo "  merlin-loop workflow resume          # Resume after failure"
 }

package/files/loop/workflows/api-build.json

@@ -0,0 +1,71 @@
+{
+  "id": "api-build",
+  "name": "API Build",
+  "description": "Describe an API. Get back designed, validated, authenticated, tested endpoints with PR.",
+  "version": "1.0",
+  "steps": [
+    {
+      "id": "design",
+      "label": "API Design",
+      "agent_hint": "api",
+      "input_template": "Design the API for:\n\n{{task}}\n\nDefine:\n- Resource naming and URL structure (RESTful)\n- HTTP methods and status codes per endpoint\n- Request/response schemas with examples\n- Pagination, filtering, sorting patterns\n- Error response format\n- Versioning strategy\n\nFollow existing API patterns in the codebase.\n\nOutput DESIGN_COMPLETE when done.",
+      "expects": "DESIGN_COMPLETE",
+      "output_file": "api-design.md",
+      "retry": 1
+    },
+    {
+      "id": "endpoints",
+      "label": "Endpoint Implementation",
+      "agent_hint": "impl",
+      "input_template": "Implement the API endpoints from this design:\n\n{{api-design.md}}\n\nPrevious context:\n{{handoff}}\n\nRules:\n- Follow existing route/controller/service patterns\n- Keep handlers thin — business logic in services\n- Include proper status codes and error responses\n- Add request logging\n- Keep files under 400 lines\n\nOutput ENDPOINTS_COMPLETE when done.",
+      "expects": "ENDPOINTS_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "validation",
+      "label": "Input Validation",
+      "agent_hint": "security",
+      "input_template": "Add comprehensive input validation to all endpoints:\n\nContext:\n{{handoff}}\n\nFor every endpoint:\n- Validate request body schema\n- Validate query parameters and path params\n- Sanitize string inputs\n- Enforce type constraints\n- Add meaningful validation error messages\n- Reject unexpected fields\n\nOutput VALIDATION_COMPLETE when done.",
+      "expects": "VALIDATION_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "auth",
+      "label": "Authentication & Authorization",
+      "agent_hint": "security",
+      "input_template": "Add authentication and authorization to the API:\n\nContext:\n{{handoff}}\n\nEnsure:\n- All endpoints require proper authentication\n- Role-based access control where applicable\n- Rate limiting on sensitive endpoints\n- CORS configuration\n- Token validation and refresh handling\n\nFollow existing auth patterns in the codebase.\n\nOutput AUTH_COMPLETE when done.",
+      "expects": "AUTH_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "test",
+      "label": "API Testing",
+      "agent_hint": "test",
+      "input_template": "Write comprehensive API tests:\n\nContext:\n{{handoff}}\n\nAPI Design:\n{{api-design.md}}\n\n1. Happy path tests for every endpoint\n2. Validation error tests (bad inputs)\n3. Authentication tests (unauthorized, forbidden)\n4. Edge cases (empty results, pagination bounds)\n5. All tests must pass\n\nOutput TESTS_PASS when complete.",
+      "expects": "TESTS_PASS",
+      "retry": 2
+    },
+    {
+      "id": "docs",
+      "label": "API Documentation",
+      "agent_hint": "docs",
+      "input_template": "Create API documentation:\n\nContext:\n{{handoff}}\n\nAPI Design:\n{{api-design.md}}\n\nGenerate:\n- OpenAPI/Swagger spec (if applicable)\n- Endpoint reference with examples\n- Authentication guide\n- Error code reference\n- Quick start for API consumers\n\nOutput DOCS_COMPLETE when done.",
+      "expects": "DOCS_COMPLETE",
+      "retry": 1
+    },
+    {
+      "id": "pr",
+      "label": "Pull Request",
+      "agent_hint": "impl",
+      "input_template": "Create a PR for the API build.\n\nContext:\n{{handoff}}\n\nOriginal task: {{task}}\n\nPR should include:\n- Endpoint summary table\n- Breaking changes (if any)\n- Auth requirements\n- How to test with curl/Postman examples\n\nOutput PR_CREATED when done.",
+      "expects": "PR_CREATED",
+      "action": "gh_pr_create",
+      "retry": 1
+    }
+  ],
+  "on_failure": "pause",
+  "on_complete": "notify"
+}

package/files/loop/workflows/product-dev.json

@@ -0,0 +1,71 @@
+{
+  "id": "product-dev",
+  "name": "Product Development",
+  "description": "Describe a product idea. Get back a fully built, tested, and documented feature.",
+  "version": "1.0",
+  "steps": [
+    {
+      "id": "spec",
+      "label": "Product Spec",
+      "agent_hint": "spec",
+      "input_template": "Create a lean product spec for:\n\n{{task}}\n\nInclude:\n- User stories with acceptance criteria\n- Core flows (happy path + error states)\n- Data model sketch\n- Out of scope (what NOT to build)\n- Success metrics\n\nKeep it lean — no fluff, just what an engineer needs to start building.\n\nOutput SPEC_COMPLETE when done.",
+      "expects": "SPEC_COMPLETE",
+      "output_file": "spec.md",
+      "retry": 2
+    },
+    {
+      "id": "architecture",
+      "label": "Architecture",
+      "agent_hint": "architect",
+      "input_template": "Design the architecture for this product spec:\n\n{{spec.md}}\n\nPrevious context:\n{{handoff}}\n\nDefine:\n- Service boundaries and data flow\n- Database schema / models\n- API endpoints\n- Key technical decisions with rationale\n- File structure plan\n\nKeep it simple. Prefer fewer services. No over-engineering.\n\nOutput ARCH_COMPLETE when done.",
+      "expects": "ARCH_COMPLETE",
+      "output_file": "architecture.md",
+      "retry": 1
+    },
+    {
+      "id": "implement",
+      "label": "Implementation",
+      "agent_hint": "impl",
+      "input_template": "Implement the product according to spec and architecture:\n\nSpec:\n{{spec.md}}\n\nArchitecture:\n{{architecture.md}}\n\nPrevious context:\n{{handoff}}\n\nRules:\n- Follow existing patterns in the codebase\n- Keep files under 400 lines\n- Commit after each logical change\n- Implement core flows first, then edge cases\n\nOutput IMPL_COMPLETE when done.",
+      "expects": "IMPL_COMPLETE",
+      "retry": 3,
+      "blend": true
+    },
+    {
+      "id": "harden",
+      "label": "Hardening",
+      "agent_hint": "security",
+      "input_template": "Harden the implementation for production:\n\nContext:\n{{handoff}}\n\nCheck and fix:\n- Input validation on all user inputs\n- Authentication and authorization checks\n- Error handling (no unhandled exceptions)\n- Rate limiting where appropriate\n- Secrets not hardcoded\n- SQL injection / XSS prevention\n\nOutput HARDENED when all critical paths are secured.",
+      "expects": "HARDENED",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "test",
+      "label": "Testing",
+      "agent_hint": "test",
+      "input_template": "Write comprehensive tests for the implementation:\n\nContext:\n{{handoff}}\n\n1. Unit tests for core business logic\n2. Integration tests for API endpoints\n3. Edge case tests from the spec\n4. Ensure all tests pass\n\nOutput TESTS_PASS when all tests pass.",
+      "expects": "TESTS_PASS",
+      "retry": 2
+    },
+    {
+      "id": "docs",
+      "label": "Documentation",
+      "agent_hint": "docs",
+      "input_template": "Write documentation for the new feature:\n\nContext:\n{{handoff}}\n\nCreate:\n- API documentation (if endpoints added)\n- User-facing docs (if UI added)\n- Developer notes (key decisions, gotchas)\n- Update existing docs if needed\n\nKeep it concise. Engineers read docs, not novels.\n\nOutput DOCS_COMPLETE when done.",
+      "expects": "DOCS_COMPLETE",
+      "retry": 1
+    },
+    {
+      "id": "pr",
+      "label": "Pull Request",
+      "agent_hint": "impl",
+      "input_template": "Create a PR for the completed product feature.\n\nContext:\n{{handoff}}\n\nOriginal task: {{task}}\n\nWrite a clear PR title and description covering:\n- What was built and why\n- Key technical decisions\n- How to test it\n- Screenshots if UI changes\n\nOutput PR_CREATED when done.",
+      "expects": "PR_CREATED",
+      "action": "gh_pr_create",
+      "retry": 1
+    }
+  ],
+  "on_failure": "pause",
+  "on_complete": "notify"
+}

package/files/loop/workflows/spec-to-code.json

@@ -0,0 +1,74 @@
+{
+  "id": "spec-to-code",
+  "name": "Spec to Code",
+  "description": "Start from an idea. Get back a specced, architected, planned, and tested implementation.",
+  "version": "1.0",
+  "steps": [
+    {
+      "id": "ideate",
+      "label": "Ideation",
+      "agent_hint": "spec",
+      "input_template": "Explore and expand this idea:\n\n{{task}}\n\nThink through:\n- What problem does this solve?\n- Who is the user?\n- What's the simplest version that delivers value?\n- What are the risks and unknowns?\n- What similar solutions exist?\n\nOutput a focused product brief.\n\nOutput IDEATION_COMPLETE when done.",
+      "expects": "IDEATION_COMPLETE",
+      "output_file": "brief.md",
+      "retry": 1
+    },
+    {
+      "id": "requirements",
+      "label": "Requirements",
+      "agent_hint": "spec",
+      "input_template": "Turn this product brief into concrete requirements:\n\n{{brief.md}}\n\nPrevious context:\n{{handoff}}\n\nCreate:\n- Functional requirements (what it MUST do)\n- Non-functional requirements (performance, security, scale)\n- Acceptance criteria for each requirement\n- Priority: P0 (must have) vs P1 (should have) vs P2 (nice to have)\n\nOutput REQUIREMENTS_COMPLETE when done.",
+      "expects": "REQUIREMENTS_COMPLETE",
+      "output_file": "requirements.md",
+      "retry": 1
+    },
+    {
+      "id": "architecture",
+      "label": "Architecture",
+      "agent_hint": "architect",
+      "input_template": "Design the technical architecture for these requirements:\n\n{{requirements.md}}\n\nPrevious context:\n{{handoff}}\n\nDefine:\n- System components and boundaries\n- Data models and relationships\n- API contracts\n- Infrastructure needs\n- Technical decisions with trade-off analysis\n\nOutput ARCH_COMPLETE when done.",
+      "expects": "ARCH_COMPLETE",
+      "output_file": "architecture.md",
+      "retry": 1
+    },
+    {
+      "id": "plan",
+      "label": "Implementation Plan",
+      "agent_hint": "spec",
+      "agent_override": "merlin-planner",
+      "input_template": "Create a detailed implementation plan:\n\nRequirements:\n{{requirements.md}}\n\nArchitecture:\n{{architecture.md}}\n\nPrevious context:\n{{handoff}}\n\nBreak into ordered tasks with:\n- File changes per task\n- Dependencies between tasks\n- Verification criteria\n- Estimated complexity\n\nOutput PLAN_COMPLETE when done.",
+      "expects": "PLAN_COMPLETE",
+      "output_file": "plan.md",
+      "retry": 1
+    },
+    {
+      "id": "implement",
+      "label": "Implementation",
+      "agent_hint": "impl",
+      "input_template": "Implement according to the plan:\n\n{{plan.md}}\n\nPrevious context:\n{{handoff}}\n\nFollow the task order. Commit after each logical unit.\nKeep files under 400 lines. Follow existing codebase patterns.\n\nOutput IMPL_COMPLETE when all plan tasks are done.",
+      "expects": "IMPL_COMPLETE",
+      "retry": 3,
+      "blend": true
+    },
+    {
+      "id": "verify",
+      "label": "Verification",
+      "agent_hint": "architect",
+      "agent_override": "merlin-verifier",
+      "input_template": "Verify the implementation against requirements.\n\nDo NOT read the original task. Evaluate cold:\n- Does the code match the requirements?\n- Are acceptance criteria met?\n- Any bugs, missing error handling, security issues?\n\nRequirements:\n{{requirements.md}}\n\nContext:\n{{handoff}}\n\nOutput VERIFIED when review passes.",
+      "expects": "VERIFIED",
+      "independent": true,
+      "retry": 1
+    },
+    {
+      "id": "test",
+      "label": "Testing",
+      "agent_hint": "test",
+      "input_template": "Write and run comprehensive tests:\n\nContext:\n{{handoff}}\n\nRequirements:\n{{requirements.md}}\n\n1. Unit tests for each P0 requirement\n2. Integration tests for core flows\n3. Edge case and error path tests\n4. All tests must pass\n\nOutput TESTS_PASS when complete.",
+      "expects": "TESTS_PASS",
+      "retry": 2
+    }
+  ],
+  "on_failure": "pause",
+  "on_complete": "notify"
+}

package/files/loop/workflows/ui-build.json

@@ -0,0 +1,72 @@
+{
+  "id": "ui-build",
+  "name": "UI Build",
+  "description": "Describe a UI. Get back designed, built, styled, tested components with PR.",
+  "version": "1.0",
+  "steps": [
+    {
+      "id": "design-spec",
+      "label": "Design Spec",
+      "agent_hint": "uidesign",
+      "input_template": "Create a UI design spec for:\n\n{{task}}\n\nInclude:\n- Component hierarchy and layout structure\n- User interaction flows (clicks, forms, navigation)\n- Responsive breakpoints and behavior\n- Accessibility requirements (ARIA, keyboard nav, contrast)\n- Design tokens to use (colors, spacing, typography)\n- States: loading, empty, error, success\n\nOutput DESIGN_COMPLETE when done.",
+      "expects": "DESIGN_COMPLETE",
+      "output_file": "design-spec.md",
+      "retry": 1
+    },
+    {
+      "id": "components",
+      "label": "Component Build",
+      "agent_hint": "uibuild",
+      "input_template": "Build the UI components from this design spec:\n\n{{design-spec.md}}\n\nPrevious context:\n{{handoff}}\n\nRules:\n- Use existing component library patterns in the codebase\n- Keep components small and focused (one responsibility)\n- Props interfaces first, then implementation\n- Keep files under 400 lines — split into subcomponents\n\nOutput COMPONENTS_COMPLETE when done.",
+      "expects": "COMPONENTS_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "layout",
+      "label": "Layout & Routing",
+      "agent_hint": "frontend",
+      "input_template": "Wire up layout, routing, and page structure:\n\nContext:\n{{handoff}}\n\nConnect components into pages. Set up routing if needed. Handle layout responsiveness.\nFollow existing routing patterns in the codebase.\n\nOutput LAYOUT_COMPLETE when done.",
+      "expects": "LAYOUT_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "state",
+      "label": "State & Data",
+      "agent_hint": "frontend",
+      "input_template": "Wire up state management and data fetching:\n\nContext:\n{{handoff}}\n\nConnect to APIs, set up state management, handle loading/error states.\nFollow existing data fetching patterns (hooks, queries, etc).\n\nOutput STATE_COMPLETE when done.",
+      "expects": "STATE_COMPLETE",
+      "retry": 2,
+      "blend": true
+    },
+    {
+      "id": "styling",
+      "label": "Styling & Polish",
+      "agent_hint": "frontend",
+      "input_template": "Polish the UI styling and interactions:\n\nContext:\n{{handoff}}\n\nRefine:\n- Spacing, alignment, typography consistency\n- Hover/focus/active states\n- Transitions and micro-animations\n- Dark mode support (if applicable)\n- Mobile responsive behavior\n\nOutput STYLING_COMPLETE when done.",
+      "expects": "STYLING_COMPLETE",
+      "retry": 1,
+      "blend": true
+    },
+    {
+      "id": "test",
+      "label": "UI Testing",
+      "agent_hint": "test",
+      "input_template": "Write tests for the UI components:\n\nContext:\n{{handoff}}\n\n1. Component render tests (all states)\n2. Interaction tests (clicks, form submissions)\n3. Accessibility tests (axe-core, keyboard navigation)\n4. Responsive layout tests if applicable\n\nOutput TESTS_PASS when all tests pass.",
+      "expects": "TESTS_PASS",
+      "retry": 2
+    },
+    {
+      "id": "pr",
+      "label": "Pull Request",
+      "agent_hint": "impl",
+      "input_template": "Create a PR for the UI build.\n\nContext:\n{{handoff}}\n\nOriginal task: {{task}}\n\nPR should include:\n- Screenshots or description of visual changes\n- Component breakdown\n- Accessibility notes\n- How to test manually\n\nOutput PR_CREATED when done.",
+      "expects": "PR_CREATED",
+      "action": "gh_pr_create",
+      "retry": 1
+    }
+  ],
+  "on_failure": "pause",
+  "on_complete": "notify"
+}

package/files/merlin/VERSION

@@ -1 +1 @@
-3.6.4
+3.8.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-merlin-brain",
-  "version": "3.8.0-beta.1",
+  "version": "3.8.0-beta.3",
   "description": "Merlin - The Ultimate AI Brain for Claude Code. One install: workflows, agents, loop, and Sights MCP server.",
   "type": "module",
   "main": "./dist/server/index.js",