maestro-flow 0.3.47 → 0.3.49

package/workflows/impeccable/ui-search/render-prototype.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * render-prototype.js
+ *
+ * Reads one or more MASTER.md files and renders HTML prototypes by injecting
+ * extracted design tokens into prototype-template.html.
+ *
+ * Zero external dependencies — uses only Node.js built-ins.
+ *
+ * Usage:
+ *   node render-prototype.js <master1.md> [master2.md ...] --output <dir> [--project <name>]
+ *   node render-prototype.js --dir <folder-with-masters> --output <dir> [--project <name>]
+ *
+ * Output:
+ *   <dir>/prototype_1.html, prototype_2.html, ...
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+  const args = { files: [], output: "", project: "Project", dir: "" };
+  let i = 2; // skip node + script
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "--output" || a === "-o") { args.output = argv[++i]; }
+    else if (a === "--project" || a === "-p") { args.project = argv[++i]; }
+    else if (a === "--dir" || a === "-d") { args.dir = argv[++i]; }
+    else if (!a.startsWith("-")) { args.files.push(a); }
+    i++;
+  }
+  // Expand --dir to individual files
+  if (args.dir && fs.existsSync(args.dir)) {
+    const entries = fs.readdirSync(args.dir)
+      .filter(f => f.endsWith(".md") && f.toUpperCase().includes("MASTER"))
+      .map(f => path.join(args.dir, f));
+    args.files.push(...entries);
+  }
+  return args;
+}
+
+// ---------------------------------------------------------------------------
+// MASTER.md parser — extracts design tokens
+// ---------------------------------------------------------------------------
+function parseMaster(content) {
+  const tokens = {
+    projectName: "",
+    styleName: "",
+    colors: {},
+    fontHeading: "Inter",
+    fontBody: "Inter",
+    googleFontsUrl: "",
+    googleFontsLink: "",
+  };
+
+  // Project name
+  const projMatch = content.match(/\*\*Project:\*\*\s*(.+)/);
+  if (projMatch) tokens.projectName = projMatch[1].trim();
+
+  // Style name
+  const styleMatch = content.match(/\*\*Style:\*\*\s*(.+)/);
+  if (styleMatch) tokens.styleName = styleMatch[1].trim();
+
+  // Color palette table: | Role | `#hex` | `--css-var` |
+  const colorPattern = /\|\s*([^|]+?)\s*\|\s*`(#[0-9A-Fa-f]{3,8})`\s*\|\s*`(--[^`]+)`\s*\|/g;
+  let m;
+  while ((m = colorPattern.exec(content)) !== null) {
+    const cssVar = m[3].trim();
+    const hex = m[2].trim();
+    // Map --color-primary → primary
+    const key = cssVar.replace(/^--color-/, "");
+    tokens.colors[key] = hex;
+  }
+
+  // Typography
+  const headingMatch = content.match(/\*\*Heading Font:\*\*\s*(.+)/);
+  if (headingMatch) tokens.fontHeading = headingMatch[1].trim();
+
+  const bodyMatch = content.match(/\*\*Body Font:\*\*\s*(.+)/);
+  if (bodyMatch) tokens.fontBody = bodyMatch[1].trim();
+
+  // Google Fonts URL
+  const gfMatch = content.match(/\*\*Google Fonts:\*\*\s*\[.*?\]\((https:\/\/fonts\.googleapis\.com\/[^)]+)\)/);
+  if (gfMatch) {
+    tokens.googleFontsUrl = gfMatch[1];
+    tokens.googleFontsLink = `<link rel="preconnect" href="https://fonts.googleapis.com">\n  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>\n  <link href="${gfMatch[1]}" rel="stylesheet">`;
+  } else {
+    // Fallback: build Google Fonts link from font names
+    const families = [tokens.fontHeading, tokens.fontBody]
+      .filter((v, i, a) => a.indexOf(v) === i) // unique
+      .map(f => `family=${f.replace(/\s+/g, "+")}:wght@400;500;600;700`)
+      .join("&");
+    const url = `https://fonts.googleapis.com/css2?${families}&display=swap`;
+    tokens.googleFontsLink = `<link rel="preconnect" href="https://fonts.googleapis.com">\n  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>\n  <link href="${url}" rel="stylesheet">`;
+  }
+
+  // CSS import block (alternative font loading)
+  const cssImportMatch = content.match(/\*\*CSS Import:\*\*[\s\S]*?```css\n([\s\S]*?)```/);
+  if (cssImportMatch && !gfMatch) {
+    // Extract URL from @import
+    const importUrl = cssImportMatch[1].match(/url\(['"]?(https:\/\/[^'")\s]+)['"]?\)/);
+    if (importUrl) {
+      tokens.googleFontsLink = `<link rel="preconnect" href="https://fonts.googleapis.com">\n  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>\n  <link href="${importUrl[1]}" rel="stylesheet">`;
+    }
+  }
+
+  return tokens;
+}
+
+// ---------------------------------------------------------------------------
+// Template rendering
+// ---------------------------------------------------------------------------
+function render(template, tokens, projectOverride) {
+  const project = projectOverride || tokens.projectName || "Project";
+  const colors = tokens.colors;
+
+  let html = template
+    .replace(/\{\{PROJECT_NAME\}\}/g, project)
+    .replace(/\{\{STYLE_NAME\}\}/g, tokens.styleName || "Default")
+    .replace(/\{\{GOOGLE_FONTS_LINK\}\}/g, tokens.googleFontsLink || "")
+    .replace(/\{\{FONT_HEADING\}\}/g, tokens.fontHeading)
+    .replace(/\{\{FONT_BODY\}\}/g, tokens.fontBody)
+    .replace(/\{\{COLOR_PRIMARY\}\}/g, colors.primary || "#2563EB")
+    .replace(/\{\{COLOR_ON_PRIMARY\}\}/g, colors["on-primary"] || "#FFFFFF")
+    .replace(/\{\{COLOR_SECONDARY\}\}/g, colors.secondary || "#7C3AED")
+    .replace(/\{\{COLOR_ACCENT\}\}/g, colors["accent"] || colors["accent/cta"] || "#F97316")
+    .replace(/\{\{COLOR_BACKGROUND\}\}/g, colors.background || "#FFFFFF")
+    .replace(/\{\{COLOR_FOREGROUND\}\}/g, colors.foreground || "#1E293B")
+    .replace(/\{\{COLOR_MUTED\}\}/g, colors.muted || "#94A3B8")
+    .replace(/\{\{COLOR_BORDER\}\}/g, colors.border || "#E2E8F0")
+    .replace(/\{\{COLOR_DESTRUCTIVE\}\}/g, colors.destructive || "#EF4444")
+    .replace(/\{\{COLOR_RING\}\}/g, colors.ring || "#3B82F6");
+
+  return html;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.files.length === 0) {
+    console.error("Usage: node render-prototype.js <master1.md> [master2.md ...] --output <dir> [--project <name>]");
+    console.error("       node render-prototype.js --dir <folder> --output <dir> [--project <name>]");
+    process.exit(1);
+  }
+
+  if (!args.output) {
+    console.error("Error: --output <dir> is required");
+    process.exit(1);
+  }
+
+  // Load template
+  const templatePath = path.join(__dirname, "prototype-template.html");
+  if (!fs.existsSync(templatePath)) {
+    console.error(`Error: Template not found at ${templatePath}`);
+    process.exit(1);
+  }
+  const template = fs.readFileSync(templatePath, "utf-8");
+
+  // Ensure output directory
+  fs.mkdirSync(args.output, { recursive: true });
+
+  const results = [];
+
+  for (let i = 0; i < args.files.length; i++) {
+    const file = args.files[i];
+    if (!fs.existsSync(file)) {
+      console.error(`Warning: ${file} not found, skipping`);
+      continue;
+    }
+
+    const content = fs.readFileSync(file, "utf-8");
+    const tokens = parseMaster(content);
+    const html = render(template, tokens, args.project);
+
+    const label = String.fromCharCode(65 + i); // A, B, C, ...
+    const outName = `prototype_${label}.html`;
+    const outPath = path.join(args.output, outName);
+    fs.writeFileSync(outPath, html, "utf-8");
+
+    results.push({
+      file: outName,
+      style: tokens.styleName,
+      fonts: `${tokens.fontHeading} + ${tokens.fontBody}`,
+      colors: Object.keys(tokens.colors).length,
+    });
+
+    console.log(`  [${label}] ${outName} — ${tokens.styleName} (${tokens.fontHeading}/${tokens.fontBody}, ${Object.keys(tokens.colors).length} colors)`);
+  }
+
+  // Write manifest for downstream tools
+  const manifestPath = path.join(args.output, "manifest.json");
+  fs.writeFileSync(manifestPath, JSON.stringify({
+    generated: new Date().toISOString(),
+    project: args.project,
+    prototypes: results,
+  }, null, 2), "utf-8");
+
+  console.log(`\n  ${results.length} prototype(s) written to ${args.output}/`);
+  console.log(`  manifest: ${manifestPath}`);
+}
+
+main();

package/workflows/impeccable/ui-search/search.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+UI/UX Pro Max Search - BM25 search engine for UI/UX style guides
+Usage: python search.py "<query>" [--domain <domain>] [--stack <stack>] [--max-results 3]
+       python search.py "<query>" --design-system [-p "Project Name"]
+       python search.py "<query>" --design-system --persist [-p "Project Name"] [--page "dashboard"]
+
+Domains: style, prompt, color, chart, landing, product, ux, typography, google-fonts
+Stacks: react, nextjs, vue, svelte, astro, swiftui, react-native, flutter, nuxtjs, nuxt-ui, html-tailwind, shadcn, jetpack-compose, threejs
+
+Persistence (Master + Overrides pattern):
+  --persist    Save design system to design-system/MASTER.md
+  --page       Also create a page-specific override file in design-system/pages/
+"""
+
+import argparse
+import sys
+import io
+from core import CSV_CONFIG, AVAILABLE_STACKS, MAX_RESULTS, search, search_stack
+from design_system import generate_design_system, persist_design_system
+
+# Force UTF-8 for stdout/stderr to handle emojis on Windows (cp1252 default)
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+if sys.stderr.encoding and sys.stderr.encoding.lower() != 'utf-8':
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    if result.get("stack"):
+        output.append(f"## UI Pro Max Stack Guidelines")
+        output.append(f"**Stack:** {result['stack']} | **Query:** {result['query']}")
+    else:
+        output.append(f"## UI Pro Max Search Results")
+        output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 300:
+                value_str = value_str[:300] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="UI Pro Max Search")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--stack", "-s", choices=AVAILABLE_STACKS, help=f"Stack-specific search. Available: {', '.join(AVAILABLE_STACKS)}")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results (default: 3)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    # Design system generation
+    parser.add_argument("--design-system", "-ds", action="store_true", help="Generate complete design system recommendation")
+    parser.add_argument("--project-name", "-p", type=str, default=None, help="Project name for design system output")
+    parser.add_argument("--format", "-f", choices=["ascii", "markdown"], default="ascii", help="Output format for design system")
+    # Persistence (Master + Overrides pattern)
+    parser.add_argument("--persist", action="store_true", help="Save design system to design-system/MASTER.md (creates hierarchical structure)")
+    parser.add_argument("--page", type=str, default=None, help="Create page-specific override file in design-system/pages/")
+    parser.add_argument("--output-dir", "-o", type=str, default=None, help="Output directory for persisted files (default: current directory)")
+
+    args = parser.parse_args()
+
+    # Design system takes priority
+    if args.design_system:
+        result = generate_design_system(
+            args.query, 
+            args.project_name, 
+            args.format,
+            persist=args.persist,
+            page=args.page,
+            output_dir=args.output_dir
+        )
+        print(result)
+        
+        # Print persistence confirmation
+        if args.persist:
+            project_slug = args.project_name.lower().replace(' ', '-') if args.project_name else "default"
+            print("\n" + "=" * 60)
+            print(f"✅ Design system persisted to design-system/{project_slug}/")
+            print(f"   📄 design-system/{project_slug}/MASTER.md (Global Source of Truth)")
+            if args.page:
+                page_filename = args.page.lower().replace(' ', '-')
+                print(f"   📄 design-system/{project_slug}/pages/{page_filename}.md (Page Overrides)")
+            print("")
+            print(f"📖 Usage: When building a page, check design-system/{project_slug}/pages/[page].md first.")
+            print(f"   If exists, its rules override MASTER.md. Otherwise, use MASTER.md.")
+            print("=" * 60)
+    # Stack search
+    elif args.stack:
+        result = search_stack(args.query, args.stack, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))
+    # Domain search
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))

package/workflows/maestro-chain-execute.md

@@ -76,7 +76,7 @@ context = {
    {milestone_num} → context.milestone_num
 
 2. In auto_mode, append per-command flag if not already present:
-   maestro-analyze / maestro-brainstorm / maestro-roadmap / maestro-ui-design → -y
+   maestro-analyze / maestro-brainstorm / maestro-roadmap / maestro-ui-craft → -y
    maestro-plan → --auto
    quality-test → --auto-fix
    quality-retrospective → --auto-yes
@@ -95,7 +95,7 @@ Read `step.engine` from status.json (pre-computed by selection workflow Step 3e)
 If `step.engine` is missing or null, fallback to auto selection:
 ```
   CLI: maestro-plan, maestro-execute, maestro-analyze, maestro-brainstorm,
-       maestro-roadmap, maestro-ui-design, quality-refactor
+       maestro-roadmap, maestro-ui-craft, quality-refactor
   Internal: everything else (current-session Skill() call)
 ```
 

package/workflows/maestro.codex.md

@@ -105,7 +105,7 @@ const chainMap = {
   'status':             [{ cmd: 'manage-status' }],
   'init':               [{ cmd: 'maestro-init' }],
   'analyze':            [{ cmd: 'maestro-analyze',        args: '{phase}' }],
-  'ui_design':          [{ cmd: 'maestro-ui-design',       args: '{phase}' }],
+  'ui_design':          [{ cmd: 'maestro-ui-craft',         args: '"{phase}" --chain build' }],
   'plan':               [{ cmd: 'maestro-plan',            args: '{phase}' }],
   'execute':            [{ cmd: 'maestro-execute',         args: '{phase}' }],
   'verify':             [{ cmd: 'maestro-verify',          args: '{phase}' }],
@@ -150,8 +150,8 @@ const chainMap = {
     { cmd: 'maestro-execute',    args: '{phase}' },
     { cmd: 'maestro-verify',     args: '{phase}' }
   ],
-  'ui-design-driven': [
-    { cmd: 'maestro-ui-design', args: '{phase}' },
+  'ui-craft-build': [
+    { cmd: 'maestro-ui-craft', args: '"{phase}" --chain build' },
     { cmd: 'maestro-plan',      args: '{phase}' },
     { cmd: 'maestro-execute',   args: '{phase}' },
     { cmd: 'maestro-verify',    args: '{phase}' }

package/workflows/maestro.md

@@ -233,7 +233,7 @@ Step type is selected **per step**, not per chain. Pre-compute and write to each
 ```
 If execMode is 'cli' or 'internal' → force that type for all steps ("cli" or "skill").
 In 'auto' mode, select per step:
-  CLI steps (heavy, context-isolated): maestro-plan, maestro-execute, maestro-analyze, maestro-brainstorm, maestro-roadmap, maestro-ui-design, quality-refactor → type: "cli"
+  CLI steps (heavy, context-isolated): maestro-plan, maestro-execute, maestro-analyze, maestro-brainstorm, maestro-roadmap, maestro-ui-craft, quality-refactor → type: "cli"
   Skill steps (everything else): current-session Skill() call — verify, review, test, debug, milestone-*, manage-*, spec-*, quick, etc. → type: "skill"
 ```
 
@@ -318,7 +318,7 @@ const chainMap = {
   'init':               [{ cmd: 'maestro-init' }],
   'analyze':            [{ cmd: 'maestro-analyze', args: '{phase}' }],
   'analyze-quick':      [{ cmd: 'maestro-analyze', args: '{phase} -q' }],
-  'ui_design':          [{ cmd: 'maestro-ui-design', args: '{phase}' }],
+  'ui_design':          [{ cmd: 'maestro-ui-craft', args: '"{description}" --chain build' }],
   'ui_craft':           [{ cmd: 'maestro-ui-craft', args: '"{description}"' }],
   'ui_craft_build':     [{ cmd: 'maestro-ui-craft', args: '"{description}" --chain build' }],
   'ui_craft_improve':   [{ cmd: 'maestro-ui-craft', args: '"{description}" --chain improve' }],
@@ -370,7 +370,7 @@ const chainMap = {
   'spec-driven':          [{ cmd: 'maestro-init' }, { cmd: 'maestro-roadmap', args: '--mode full "{description}"' }, { cmd: 'maestro-plan', args: '{phase}' }, { cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
   'roadmap-driven':       [{ cmd: 'maestro-init' }, { cmd: 'maestro-roadmap', args: '"{description}"' }, { cmd: 'maestro-plan', args: '{phase}' }, { cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
   'brainstorm-driven':    [{ cmd: 'maestro-brainstorm', args: '"{description}"' }, { cmd: 'maestro-plan', args: '{phase}' }, { cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
-  'ui-design-driven':     [{ cmd: 'maestro-ui-design', args: '{phase}' }, { cmd: 'maestro-plan', args: '{phase}' }, { cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
+  'ui-craft-build':       [{ cmd: 'maestro-ui-craft', args: '"{description}" --chain build' }, { cmd: 'maestro-plan', args: '{phase}' }, { cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
   'ui-craft-driven':      [{ cmd: 'maestro-ui-craft', args: '"{description}" --chain build' }, { cmd: 'maestro-verify', args: '{phase}' }],
   'analyze-plan-execute': [{ cmd: 'maestro-analyze', args: '"{description}" -q' }, { cmd: 'maestro-plan', args: '--dir {scratch_dir}' }, { cmd: 'maestro-execute', args: '--dir {scratch_dir}' }],
   'execute-verify':       [{ cmd: 'maestro-execute', args: '{phase}' }, { cmd: 'maestro-verify', args: '{phase}' }],
@@ -440,7 +440,7 @@ detectNextAction(state):
 | `spec-driven` | init → spec-generate → plan → execute → verify | From idea/requirements (heavy) |
 | `roadmap-driven` | init → roadmap → plan → execute → verify | From requirements (light) |
 | `brainstorm-driven` | brainstorm → plan → execute → verify | From exploration |
-| `ui-design-driven` | ui-design → plan → execute → verify | From UI prototypes |
+| `ui-craft-build` | ui-craft --chain build → plan → execute → verify | From design system generation |
 | `analyze-plan-execute` | analyze -q → plan --dir → execute --dir | Fast track (scratch mode) |
 | `execute-verify` | execute → verify | Resume after planning |
 | `review-fix` | plan --gaps → execute → review | Fix review-blocked issues |
@@ -470,7 +470,7 @@ detectNextAction(state):
 | `"discover issues"` | `{explore, issue}` | issue_discover | manage-issue-discover |
 | `"brainstorm notifications"` | `{explore, feature}` | brainstorm | brainstorm-driven |
 | `"spec generate auth"` | `{create, spec}` | spec_generate | spec-driven |
-| `"ui design landing"` | `{create, ui}` | ui_design | ui-design-driven |
+| `"ui design landing"` | `{create, ui}` | ui_design | ui-craft-build |
 | `"refactor auth module"` | `{refactor, code}` | refactor | quality-refactor |
 | `"复盘 phase 2"` | `{retrospect, phase}` | retrospective | quality-retrospective |
 | `"team review code"` | `{review, team}` | team_review | team-review |

package/workflows/plan.md

@@ -84,7 +84,7 @@ default             → Create Mode: P1 → P2 → P3 → P4 → P4.5 → P5
 4b. **Load design reference** (if available)
    - If `${PHASE_DIR}/design-ref/MASTER.md` exists: load MASTER.md, design-tokens.json, animation-tokens.json (optional), layout-templates/layout-*.json
      - Every UI task must include in `read_first[]`: design-tokens.json, animation-tokens.json, relevant layout-*.json, MASTER.md
-   - Else if phase goal matches UI keywords (`landing|page|dashboard|frontend|UI|component|界面`): suggest running `maestro-ui-design` (non-blocking)
+   - Else if phase goal matches UI keywords (`landing|page|dashboard|frontend|UI|component|界面`): suggest running `maestro-ui-craft --chain build` (non-blocking)
 
 5. **Load upstream analysis** (if available)
    - If `${PHASE_DIR}/conclusions.json` exists with non-empty status: load as explorationContext (conclusions + explorations.json + perspectives.json)

package/workflows/ui-design.md

@@ -364,7 +364,7 @@ Spacing & Layout, Effects & Interactions, Component Styles, Animation System, An
 
 `maestro-plan` P1 (Context Collection):
 - If `${PHASE_DIR}/design-ref/MASTER.md` exists: load as planner context, add `design-tokens.json`, `layout-templates/layout-*.json`, `animation-tokens.json` to UI task `read_first[]`
-- If missing + phase goal has UI keywords: suggest `maestro-ui-design` (non-blocking)
+- If missing + phase goal has UI keywords: suggest `maestro-ui-craft --chain build` (non-blocking)
 
 ---
 

package/workflows/ui-style.md

@@ -169,7 +169,7 @@ If the design needs exceed ui-ux-pro-max capabilities (e.g., multi-layout matrix
 
 ```
 For advanced multi-layer design exploration:
-  Skill({ skill: "maestro-ui-design", args: "{phase} --full" })
+  /maestro-ui-craft --chain build {target}
 ```
 
 ---

package/.claude/commands/maestro-ui-design.md

@@ -1,104 +0,0 @@
----
-name: maestro-ui-design
-description: Generate UI design prototypes, select and solidify as code
-argument-hint: "<phase|topic> [--styles N] [--stack <stack>] [--targets <pages>] [--layouts N] [--refine] [--persist] [--full] [-y]"
-allowed-tools:
-  - Read
-  - Write
-  - Edit
-  - Bash
-  - Glob
-  - Grep
-  - Agent
-  - AskUserQuestion
----
-<purpose>
-Generate UI design prototypes for a phase or topic. Two workflow paths, auto-selected by skill availability:
-
-1. **Primary (ui-style.md):** Delegates design to ui-ux-pro-max skill. Generates multiple style variants via `--design-system`, user selects, solidifies as code reference. Lightweight and fast.
-2. **Fallback (ui-design.md):** Self-contained 4-layer pipeline (style → animation → layout → assembly) with 6D attribute space, OKLCH tokens, layout templates, and full prototype matrix. Used when ui-ux-pro-max is unavailable or `--full` is requested.
-
-Both paths produce the same output contract: MASTER.md + design-tokens.json + animation-tokens.json + selection.json for downstream plan/execute consumption.
-
-Position in pipeline: analyze -> **ui-design** -> plan -> execute -> verify
-</purpose>
-
-<deferred_reading>
-- [ui-style.md](~/.maestro/workflows/ui-style.md) — read when SKILL_PATH found (primary path)
-- [ui-design.md](~/.maestro/workflows/ui-design.md) — read when SKILL_PATH empty or --full (fallback path)
-- [index.json](~/.maestro/templates/index.json) — read when updating phase metadata
-- [scratch-index.json](~/.maestro/templates/scratch-index.json) — read when operating in scratch mode
-</deferred_reading>
-
-<context>
-$ARGUMENTS — phase number for phase mode, topic text for scratch mode, with optional flags.
-
-Flags, workflow routing, scope modes, and output artifacts defined in the routed workflow (ui-style.md or ui-design.md).
-
-**Phase mode** (number): resolves phase directory, reads context.md/brainstorm for requirements.
-**Scratch mode** (text): creates `.workflow/scratch/{YYYYMMDD}-ui-design-{slug}/` for standalone exploration.
-</context>
-
-<execution>
-## 1. Load UI Specs
-
-Load project UI conventions before generating designs:
-
-```bash
-maestro spec load --category ui
-```
-
-If specs not initialized, continue without — the workflow still produces valid output.
-
-## 2. Workflow Routing
-
-Detect ui-ux-pro-max skill availability and route to the appropriate workflow:
-
-- **`--full` flag present** → Follow '~/.maestro/workflows/ui-design.md' completely (forced full pipeline)
-- **ui-ux-pro-max found** → Follow '~/.maestro/workflows/ui-style.md' completely (lightweight delegation)
-- **ui-ux-pro-max not found** → Follow '~/.maestro/workflows/ui-design.md' completely (self-contained fallback)
-
-Skill detection logic, report format, and complete pipeline steps defined in the routed workflow file.
-
-**Next-step routing on completion:**
-- Plan with design reference → /maestro-plan {phase}
-- Refine selected design → /maestro-ui-design {phase} --refine
-- Analyze before planning → /maestro-analyze {phase}
-</execution>
-
-<error_codes>
-| Code | Severity | Description | Stage |
-|------|----------|-------------|-------|
-| E001 | error | Phase or topic argument required | parse_input |
-| E002 | error | Phase directory not found | parse_input |
-| E003 | error | Python not available (both paths need Python for ui-ux-pro-max or agent fallback) | setup |
-| E004 | error | --refine requires existing design-ref/ | parse_input |
-| W001 | warning | Design system generation returned partial results | generate |
-| W002 | warning | Prototype rendering failed for one variant | render |
-| W003 | warning | No context.md found, using phase goal only | context |
-| W004 | warning | ui-ux-pro-max not found, falling back to full pipeline | routing |
-</error_codes>
-
-<success_criteria>
-**Both paths (common):**
-- [ ] UI specs loaded via `spec load --category ui` (if available)
-- [ ] Requirements extracted from phase context (context.md, brainstorm, spec, or user input)
-- [ ] N style variants generated with contrasting design directions
-- [ ] User selected preferred variant (or auto-selected in -y mode)
-- [ ] MASTER.md written with complete design system specification
-- [ ] design-tokens.json written with production-ready tokens (OKLCH colors, component_styles)
-- [ ] animation-tokens.json written (duration, easing, transitions, keyframes)
-- [ ] selection.json recorded with choice metadata
-- [ ] index.json updated with design_ref status
-
-**ui-style.md path (primary):**
-- [ ] ui-ux-pro-max --design-system called with product/industry/style keywords
-- [ ] Tokens extracted from ui-ux-pro-max output into structured JSON
-
-**ui-design.md path (--full or fallback):**
-- [ ] 6D attribute space used for maximum contrast between variants
-- [ ] Layout templates generated per target (dom_structure + css_layout_rules)
-- [ ] HTML prototypes assembled: styles x layouts x targets
-- [ ] compare.html generated as interactive matrix viewer
-</success_criteria>
-</output>