@soleur/opencode 0.0.0-stage → 3.354.2

package/skills/frontend-anti-slop/scripts/tier1-scan.ts

@@ -0,0 +1,525 @@
+#!/usr/bin/env bun
+/**
+ * tier1-scan.ts — deterministic regex audit for React/Next.js anti-slop patterns.
+ *
+ * Adapted from Hallmark's `slop-test.md` Tier 1 gates (MIT, see /LICENSES/hallmark.MIT.txt).
+ * Rules live in `../references/slop-rules.md`; this script parses the Active-rules
+ * markdown table, filters `tier === 1`, and runs each rule's `pattern` regex over
+ * the target files.
+ *
+ * Usage:
+ *   bun plugins/soleur/skills/frontend-anti-slop/scripts/tier1-scan.ts \
+ *     [--paths <file-or-glob> ...] [--dry-run|--json] [--rule <id>]
+ *
+ * Default paths: `git diff --name-only --cached --diff-filter=AMR` filtered to
+ * `apps/web-platform/(app|components)/**\*.(tsx|jsx|css)` AND
+ * `apps/web-platform/server/**\*.(ts|tsx)` AND
+ * `plugins/soleur/docs/**\*.(njk|css)`.
+ *
+ * Output:
+ *   - `--dry-run` (default) — human-readable findings on stdout.
+ *   - `--json` — JSON array conforming to `finding.schema.json` with
+ *     `category: "anti-slop"`, `selector: "<file-path>#<rule-id>"`,
+ *     `route: ""`.
+ *
+ * Exit codes:
+ *   0 — scan completed with no blocking findings (anti-slop findings are advisory).
+ *   1 — bad CLI / parse error / IO error, OR ≥ 1 blocking finding (a finding whose
+ *       originating rule is `category === "brand" && severity === "high"`).
+ *   See `computeExitCode`. Non-brand and brand-below-high findings remain advisory.
+ *
+ * Per-file rule disable: `anti-slop:disable RULE_ID reason="..."` — matched as
+ * a literal substring, so any comment form works (JSX, HTML, CSS block, line).
+ */
+
+import {
+  readFileSync,
+  existsSync,
+  statSync,
+  lstatSync,
+  readdirSync,
+} from "node:fs";
+import { resolve, relative, join } from "node:path";
+
+const TC_VERSION = "1.0.0";
+
+function gitRepoRoot(): string {
+  // Use Bun.spawnSync (no shell expansion, argv-array form — no command-injection
+  // surface). Falls back to cwd if not in a git repo.
+  try {
+    const p = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    if (p.exitCode === 0) {
+      return new TextDecoder().decode(p.stdout).trim();
+    }
+  } catch {
+    /* fall through */
+  }
+  return process.cwd();
+}
+
+const REPO_ROOT = gitRepoRoot();
+
+const RULES_FILE = resolve(
+  import.meta.dir,
+  "..",
+  "references",
+  "slop-rules.md",
+);
+
+interface Rule {
+  id: string;
+  tier: 1 | 2;
+  category: string;
+  severity: "critical" | "high" | "medium" | "low";
+  pattern: RegExp;
+  message: string;
+  suggested_fix: string;
+  /** UNIFORM-HOVER-SCALE-style rules fire only at ≥ N occurrences in a single file. */
+  min_occurrences?: number;
+}
+
+interface Finding {
+  route: string;
+  selector: string;
+  category: "anti-slop";
+  severity: Rule["severity"];
+  title: string;
+  description: string;
+  fix_hint: string;
+  screenshot_ref: string;
+  line: number;
+}
+
+interface CliArgs {
+  paths: string[];
+  json: boolean;
+  ruleFilter?: string;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const out: CliArgs = { paths: [], json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--paths") {
+      while (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+        out.paths.push(argv[++i]);
+      }
+    } else if (a === "--json") {
+      out.json = true;
+    } else if (a === "--dry-run") {
+      out.json = false;
+    } else if (a === "--rule") {
+      out.ruleFilter = argv[++i];
+    } else if (a === "-h" || a === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (!a.startsWith("--")) {
+      out.paths.push(a);
+    } else {
+      console.error(`unknown arg: ${a}`);
+      process.exit(1);
+    }
+  }
+  return out;
+}
+
+function printHelp(): void {
+  console.log(
+    "tier1-scan.ts — React/Next.js anti-slop deterministic audit (v" +
+      TC_VERSION +
+      ")",
+  );
+  console.log(
+    "\nUsage: bun .../tier1-scan.ts [--paths <file>...] [--dry-run|--json] [--rule <id>]",
+  );
+}
+
+/**
+ * Parse the Active-rules table from references/slop-rules.md.
+ *
+ * Format: standard GitHub-flavoured Markdown pipe table. Header row is
+ * `| id | tier | category | hallmark_gate | severity | pattern | message | suggested_fix |`.
+ * Each data row contributes one Rule; `pattern` is unwrapped from backticks and
+ * compiled as a RegExp.
+ */
+function parseRules(content: string): Rule[] {
+  const lines = content.split("\n");
+  const rules: Rule[] = [];
+
+  let inActiveTable = false;
+  let headerSeen = false;
+
+  for (const line of lines) {
+    if (line.trim().startsWith("## Active rules")) {
+      inActiveTable = true;
+      continue;
+    }
+    if (inActiveTable && line.trim().startsWith("## ")) {
+      // hit the next section — stop
+      break;
+    }
+    if (!inActiveTable) continue;
+
+    if (line.startsWith("| id |")) {
+      headerSeen = true;
+      continue;
+    }
+    if (!headerSeen) continue;
+    if (line.startsWith("|---")) continue;
+    if (!line.startsWith("|")) continue;
+
+    // Split on unescaped `|` only — markdown table cells escape literal pipes
+    // (used inside regex alternations) as `\|`. After splitting, unescape.
+    const cells = line
+      .split(/(?<!\\)\|/)
+      .slice(1, -1)
+      .map((c) => c.trim().replace(/\\\|/g, "|"));
+    if (cells.length < 8) continue;
+
+    const [
+      id,
+      tierRaw,
+      category,
+      _hallmark,
+      severityRaw,
+      patternRaw,
+      message,
+      fix,
+    ] = cells;
+    const tier = Number(tierRaw) as 1 | 2;
+    if (tier !== 1) continue;
+
+    const patternBody = unwrapBackticks(patternRaw);
+    let regex: RegExp;
+    try {
+      regex = new RegExp(patternBody);
+    } catch (err) {
+      throw new Error(
+        `invalid regex for rule ${id}: ${patternBody} (${(err as Error).message})`,
+      );
+    }
+
+    const rule: Rule = {
+      id,
+      tier,
+      category,
+      severity: severityRaw as Rule["severity"],
+      pattern: regex,
+      message: unwrapBackticks(message),
+      suggested_fix: unwrapBackticks(fix),
+    };
+    if (id === "UNIFORM-HOVER-SCALE") rule.min_occurrences = 4;
+
+    rules.push(rule);
+  }
+
+  if (rules.length === 0) {
+    throw new Error(
+      `parseRules: no Tier-1 rules parsed from ${RULES_FILE} — table format drift`,
+    );
+  }
+  return rules;
+}
+
+function unwrapBackticks(s: string): string {
+  // Markdown table cells often have leading/trailing backticks (code spans).
+  // Strip a single pair if present.
+  if (s.startsWith("`") && s.endsWith("`") && s.length >= 2) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+/**
+ * Canonical scanner path regex SOURCE (single source of truth).
+ *
+ * Both `defaultPaths()` (JS RegExp) and the `review/SKILL.md` "Anti-slop Scanner
+ * Hook" collector (shell ERE) must contain the same alternation body (a parity
+ * test asserts it). The trailing `$` anchors the path end. Includes the
+ * `server/.*\.(ts|tsx)$` alternation so server-side email/HTML templates are in
+ * scope alongside the Next.js app/components and the Eleventy docs site.
+ */
+const DEFAULT_PATH_RE_SOURCE =
+  "^(apps/web-platform/(app|components)/.*\\.(tsx|jsx|css)|apps/web-platform/server/.*\\.(ts|tsx)|plugins/soleur/docs/.*\\.(njk|css))$";
+
+function defaultPaths(): string[] {
+  try {
+    const p = Bun.spawnSync(
+      ["git", "diff", "--name-only", "--cached", "--diff-filter=AMR"],
+      { cwd: REPO_ROOT, stdout: "pipe", stderr: "pipe" },
+    );
+    if (p.exitCode !== 0) return [];
+    const out = new TextDecoder().decode(p.stdout);
+    const all = out
+      .split("\n")
+      .map((p) => p.trim())
+      .filter(Boolean);
+    const re = new RegExp(DEFAULT_PATH_RE_SOURCE);
+    return all.filter((p) => re.test(p));
+  } catch {
+    return [];
+  }
+}
+
+function isContainedInRepo(abs: string): boolean {
+  // Containment check: the resolved path must live under REPO_ROOT.
+  // `relative` returns "" when abs === REPO_ROOT, an absolute path on
+  // Windows-different-drive (defensive — Linux-only here), or a path
+  // starting with ".." when abs is outside REPO_ROOT.
+  const rel = relative(REPO_ROOT, abs);
+  if (rel === "" || rel.startsWith("..") || rel.startsWith("/")) return false;
+  return true;
+}
+
+function expandPaths(inputs: string[]): string[] {
+  // Caller may pass repo-relative paths OR abs paths. Normalise to absolute,
+  // confine to REPO_ROOT, reject symlinks (no traversal via symlink chain),
+  // then keep only existing files matching the frontend glob. No glob
+  // expansion here — the shell already expanded any literal `*`; callers
+  // passing dir paths get all child .tsx/.jsx/.css.
+  const out: string[] = [];
+  for (const p of inputs) {
+    const abs = resolve(REPO_ROOT, p);
+    if (!isContainedInRepo(abs)) continue;
+    if (!existsSync(abs)) continue;
+    // `lstatSync` (not `statSync`) so we see the symlink itself, not its
+    // target. Symlinks under the repo pointing outside (or to sensitive
+    // files) are rejected here.
+    const ls = lstatSync(abs);
+    if (ls.isSymbolicLink()) continue;
+    const s = statSync(abs);
+    if (s.isFile()) {
+      // `.ts` included so server-side email/HTML templates
+      // (`apps/web-platform/server/*.ts`) are scannable when passed explicitly.
+      if (/\.(ts|tsx|jsx|css|njk)$/.test(abs)) out.push(abs);
+    } else if (s.isDirectory()) {
+      out.push(
+        ...listFilesRecursive(abs).filter((f) =>
+          /\.(ts|tsx|jsx|css|njk)$/.test(f),
+        ),
+      );
+    }
+  }
+  // Scope post-filter: the bare extension test above is BROADER than
+  // DEFAULT_PATH_RE_SOURCE (which scopes `.ts` to apps/web-platform/server/).
+  // Without this, `--paths apps/web-platform/app/api/x/route.ts` would be
+  // scanned and could block on raw hex outside the declared scope. Post-filter
+  // the repo-relative paths through the canonical regex so expandPaths and
+  // defaultPaths agree by construction.
+  const scopeRe = new RegExp(DEFAULT_PATH_RE_SOURCE);
+  return out.filter((abs) => scopeRe.test(relative(REPO_ROOT, abs)));
+}
+
+function listFilesRecursive(dir: string): string[] {
+  const acc: string[] = [];
+  const stack = [dir];
+  while (stack.length) {
+    const d = stack.pop()!;
+    let entries;
+    try {
+      entries = readdirSync(d, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = join(d, e.name);
+      // Symlinks rejected — same containment posture as `expandPaths`,
+      // so a recursive walk cannot escape the repo via a symlinked
+      // subdirectory or grab a sensitive file via a symlinked entry.
+      if (e.isSymbolicLink()) continue;
+      if (e.isDirectory()) {
+        if (e.name === "node_modules" || e.name === ".next") continue;
+        stack.push(full);
+      } else if (e.isFile()) {
+        acc.push(full);
+      }
+    }
+  }
+  return acc;
+}
+
+function disabledRulesInFile(content: string): Set<string> {
+  const out = new Set<string>();
+  const re = /anti-slop:disable\s+([A-Z][A-Z0-9-]*)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(content)) !== null) out.add(m[1]);
+  return out;
+}
+
+/**
+ * Per-line scan cap. Some rules (notably BRAND-WHITE-ON-GOLD, whose `[^"\n]*`
+ * spans can backtrack) are O(n²) on a single very long line, and minified
+ * `.css` (one line, hundreds of KB) is in scope. Testing against a bounded
+ * prefix bounds the worst-case work for ALL rules. A token that opens past
+ * 2000 chars on one physical line is not a realistic brand/slop signal we need
+ * to catch, so the truncation is safe.
+ */
+const MAX_SCAN_LINE = 2000;
+
+function scanFile(absPath: string, rules: Rule[]): Finding[] {
+  let content: string;
+  try {
+    content = readFileSync(absPath, "utf8");
+  } catch (err) {
+    console.error(
+      `[tier1-scan] read failed: ${absPath} (${(err as Error).message})`,
+    );
+    return [];
+  }
+
+  const relPath = relative(REPO_ROOT, absPath);
+  const lines = content.split("\n");
+  const disabled = disabledRulesInFile(content);
+  const findings: Finding[] = [];
+
+  for (const rule of rules) {
+    if (disabled.has(rule.id)) continue;
+
+    const hitLines: number[] = [];
+    for (let i = 0; i < lines.length; i++) {
+      // ReDoS guard: bound each line to MAX_SCAN_LINE before matching.
+      const lineToTest =
+        lines[i].length > MAX_SCAN_LINE
+          ? lines[i].slice(0, MAX_SCAN_LINE)
+          : lines[i];
+      if (rule.pattern.test(lineToTest)) hitLines.push(i + 1);
+    }
+    if (hitLines.length === 0) continue;
+    if (
+      rule.min_occurrences !== undefined &&
+      hitLines.length < rule.min_occurrences
+    ) {
+      continue;
+    }
+
+    findings.push({
+      route: "",
+      selector: `${relPath}#${rule.id}`,
+      category: "anti-slop",
+      severity: rule.severity,
+      title: `${rule.message} (rule ${rule.id})`,
+      description: `${rule.message} Detected at ${relPath}:${hitLines[0]}${
+        hitLines.length > 1 ? ` (and ${hitLines.length - 1} more)` : ""
+      }.`,
+      fix_hint: rule.suggested_fix,
+      screenshot_ref: "/tmp/anti-slop/no-screenshot.png",
+      line: hitLines[0],
+    });
+  }
+  return findings;
+}
+
+function formatHuman(findings: Finding[]): string {
+  if (findings.length === 0) return "anti-slop: no findings.\n";
+  const lines: string[] = [`anti-slop: ${findings.length} finding(s)\n`];
+  for (const f of findings) {
+    lines.push(
+      `  [${f.severity.padEnd(8)}] ${f.selector}:${f.line}\n    ${f.title}\n    fix: ${f.fix_hint}\n`,
+    );
+  }
+  return lines.join("");
+}
+
+/**
+ * Decide the process exit code from the findings and the rule set.
+ *
+ * Blocking is keyed on the originating **Rule**, not the emitted Finding (which
+ * always serializes `category: "anti-slop"` for `finding.schema.json`
+ * conformance). The rule id is recovered from the finding's `selector`
+ * (`"<file>#<RULE-ID>"`). Returns 1 iff any finding maps to a rule with
+ * `category === "brand" && severity === "high"`; else 0 (anti-slop and
+ * brand-below-high findings are advisory).
+ */
+function computeExitCode(findings: Finding[], rules: Rule[]): number {
+  const byId = new Map<string, Rule>();
+  for (const r of rules) byId.set(r.id, r);
+  for (const f of findings) {
+    // The selector is `${relPath}#${rule.id}`, so the rule id is the LAST
+    // `#`-segment. Splitting and taking `[1]` mis-captures a path fragment when
+    // a scanned file path itself contains `#`, the byId lookup misses, and the
+    // gate fails OPEN (returns 0) on a real brand/high finding. Parse from the
+    // last `#` so a `#`-bearing path can never defeat the blocking gate. If the
+    // selector has no `#`, lastIndexOf returns -1 → slice(0) yields the whole
+    // string → byId miss → non-blocking, which is acceptable for a malformed
+    // selector.
+    const ruleId = f.selector.slice(f.selector.lastIndexOf("#") + 1);
+    const rule = ruleId ? byId.get(ruleId) : undefined;
+    if (rule && rule.category === "brand" && rule.severity === "high") {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  let rules: Rule[];
+  try {
+    rules = parseRules(readFileSync(RULES_FILE, "utf8"));
+  } catch (err) {
+    console.error(`[tier1-scan] ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  if (args.ruleFilter) {
+    rules = rules.filter((r) => r.id === args.ruleFilter);
+    if (rules.length === 0) {
+      console.error(
+        `[tier1-scan] --rule ${args.ruleFilter} matched zero rules`,
+      );
+      process.exit(1);
+    }
+  }
+
+  const candidatePaths =
+    args.paths.length > 0
+      ? expandPaths(args.paths)
+      : expandPaths(defaultPaths());
+
+  if (candidatePaths.length === 0) {
+    if (args.json) {
+      process.stdout.write("[]\n");
+    } else {
+      process.stdout.write(
+        "anti-slop: no frontend files in scope; skipping scan.\n",
+      );
+    }
+    process.exit(0);
+  }
+
+  const findings: Finding[] = [];
+  for (const file of candidatePaths) {
+    findings.push(...scanFile(file, rules));
+  }
+
+  if (args.json) {
+    // Emit machine-readable shape (drop the `line` field — not in finding.schema.json).
+    const emit = findings.map(({ line: _line, ...rest }) => rest);
+    process.stdout.write(JSON.stringify(emit, null, 2) + "\n");
+  } else {
+    process.stdout.write(formatHuman(findings));
+  }
+  process.exit(computeExitCode(findings, rules));
+}
+
+if (import.meta.main) {
+  main();
+}
+
+export {
+  parseRules,
+  scanFile,
+  disabledRulesInFile,
+  expandPaths,
+  defaultPaths,
+  computeExitCode,
+  unwrapBackticks,
+  DEFAULT_PATH_RE_SOURCE,
+  REPO_ROOT,
+  RULES_FILE,
+};
+export type { Rule, Finding };

package/skills/frontend-design/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: frontend-design
+description: "This skill should be used when creating distinctive, production-grade frontend interfaces. It generates creative, polished web components, pages, or applications that avoid generic AI aesthetics with high design quality."
+context_queries:
+  - knowledge-base/marketing/brand-guide.md
+  - knowledge-base/product/design/taste-profile.md
+license: Complete terms in LICENSE.txt
+---
+
+<!-- soleur-cloud-mode:start -->
+**Cloud Mode (Devin):** before pipeline work run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/cloud-detect.sh"`. If `CLAUDE_PLUGIN_ROOT` is unset (cloud exec shells do not export it), resolve the root by IDENTITY, never by script basename: for `d` in `"$HOME/.local/share/devin/cli/plugins/cache"` and `/opt/.devin/plugins`, skip unless `[ -d "$d" ]`, then `MANIFEST="$(find "$d" -path '*/.claude-plugin/plugin.json' -exec grep -l '"name"[[:space:]]*:[[:space:]]*"soleur"' {} + 2>/dev/null | head -1)"`, `ROOT="${MANIFEST%/.claude-plugin/plugin.json}"` — one resolution, two consumers: `$ROOT/scripts/cloud-detect.sh` and `$ROOT/scripts/precommit-guard.sh`. (Shape check, not authentication: a planted `{"name":"soleur"}` dir passes — ADR-179 A11.) `local` or `not-local:no-devin-env` proceeds normally; any other `not-local:<reason>` applies `<plugin-root>/devin/INSTRUCTIONS.md` §Cloud Mode: emit the `--banner`, fan out sequentially with `Reviewed-Coverage: sequential-fallback` disclosure (never claim an independent review ran), `message_user` ack before any secrets read or production mutation, and run `precommit-guard.sh` before any `git commit` — hooks do not fire in cloud.
+<!-- soleur-cloud-mode:end -->
+
+<!-- grok-harness-invoke:start -->
+**Grok Build (`plugins/soleur/lib/harness.ts` `invokeSkill()`):** Read this SKILL.md in this process and run it to completion. A one-segment `soleur:<name>` in this document names a SKILL — on Grok Build, Read `plugins/soleur/skills/<name>/SKILL.md` in this process; it is not a nested tool_use. A multi-segment id such as `soleur:<domain>:<name>` names an AGENT: spawn it, never Read it, and on Grok Build spawn_subagent takes the id with its colons replaced by hyphens (`agentIdToGrokSubagentType`). **Claude Code:** Skill tool for a skill (`soleur:<name>`), Task tool with `subagent_type` for an agent. Forbidden is executing a subset, not the Read.
+<!-- grok-harness-invoke:end -->
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.
+
+### Multi-Variant Fan-Out
+
+When the design brief is a full surface (page, app, or non-trivial component), generate **3 variants in parallel** instead of a single take, then let the operator choose. This is Soleur's all-Claude adaptation of gstack `design-shotgun` (ADR-090).
+
+1. **Load learned taste (FR6 + validate).** The FR6 hook injects a read-directive for `knowledge-base/product/design/taste-profile.md`. Before trusting it, run `bash plugins/soleur/scripts/taste-profile-update.sh --validate knowledge-base/product/design/taste-profile.md`. On a **non-zero** exit, design with **no taste bias** (fail-open — never block on a corrupt profile). On success, read the profile's **fenced JSON machine block** (`entries[]` between the `taste-profile:data` markers — this is the region `--validate` certifies; do NOT bias from the human `## Reinforced Aesthetics` table, which `--validate` does not cover) and take the entries whose `context` matches the current design context (`landing-page | marketing-site | dashboard | app-ui | docs | email | component`); the most-recent value per axis is the operator's current lean.
+2. **Seed distinct directions.** Pick 3 distinct aesthetic directions from the Design Thinking tone list. Bias — do not restrict — the seeds toward the loaded taste: if the profile leans `minimalist@dashboard`, one seed should honor it and the others deliberately diverge so the operator still sees range. With an empty/invalid profile, pick 3 maximally-distinct seeds.
+3. **Fan out via the Agent tool.** Spawn 3 sub-agents (one per seed), each with the full brief + its assigned direction **in the prompt text** — sub-agents do NOT inherit the FR6 injection, so the taste bias must be passed explicitly. Each returns a self-contained variant.
+4. **Present the slate** for selection. Interactive: describe the 3 variants and let the operator choose by natural conversation — **never** `AskUserQuestion` (a nested Task subagent hangs on it). Headless / no operator turn: auto-select the variant matching the top-recency taste entry (or variant 1 if the profile is empty) and skip step 5 (no operator signal = no learning).
+
+### Recording Taste
+
+When the operator selects a variant **in an interactive session**, record the choice so future sessions are primed:
+
+```bash
+bash plugins/soleur/scripts/taste-profile-update.sh \
+  knowledge-base/product/design/taste-profile.md \
+  <context> aesthetic-direction <selected-direction> "$(date -u +%F)"
+```
+
+`<context>` is the current design context (the enum above); `<selected-direction>` is the chosen direction as a sanitized lowercase-hyphen token (e.g. `minimalist`, `editorial`). The helper ([`taste-profile-update.sh`](../../scripts/taste-profile-update.sh)) validates every token, recomputes the entry by recency, flags a same-context contradiction, and bumps `last_updated` only. Do **not** hand-edit `taste-profile.md`. Do **not** record in headless runs.