@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.9

package/dist/builtin/workflows/builtin/chunk-nqr34qp3.js

@@ -0,0 +1,1061 @@
+import {
+  createChildProcessEnvironment
+} from "./chunk-x2ghn0je.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/open-claude-design.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/open-claude-design-utils.ts
+import { spawnSync } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { tmpdir, userInfo } from "node:os";
+import { join } from "node:path";
+import { Type } from "typebox";
+var OUTPUT_TYPES = [
+  "prototype",
+  "wireframe",
+  "page",
+  "component",
+  "theme",
+  "tokens"
+];
+var DEFAULT_OUTPUT_TYPE = "prototype";
+function taggedPrompt(sections) {
+  return sections.map(([tag, content]) => {
+    const trimmed = content.trim();
+    return `<${tag}>
+${trimmed}
+</${tag}>`;
+  }).join(`
+
+`);
+}
+function normalizeOutputType(value) {
+  return value !== undefined && OUTPUT_TYPES.includes(value) ? value : DEFAULT_OUTPUT_TYPE;
+}
+function shouldEarlyExitForBrowser(browserAvailable, nodeEnv) {
+  return !browserAvailable && nodeEnv !== "test";
+}
+var discoveryDecisionSchema = Type.Object({
+  brief: Type.String(),
+  output_type: Type.Union([...OUTPUT_TYPES].map((value) => Type.Literal(value))),
+  references: Type.Array(Type.String())
+}, { additionalProperties: false });
+function discoveryDecisionFromResult(result, fallbackBrief) {
+  const decision = result.structured;
+  const brief = typeof decision?.brief === "string" && decision.brief.trim().length > 0 ? decision.brief.trim() : fallbackBrief;
+  const references = Array.isArray(decision?.references) ? decision.references.filter((ref) => typeof ref === "string").map((ref) => ref.trim()).filter((ref) => ref.length > 0) : [];
+  return {
+    brief,
+    output_type: normalizeOutputType(decision?.output_type),
+    references
+  };
+}
+function joinResults(results) {
+  return results.map((result) => `### ${result.name}
+
+${result.text}`).join(`
+
+---
+
+`);
+}
+function tmpArtifactBase() {
+  let user = "default";
+  try {
+    user = userInfo().username.replace(/[^A-Za-z0-9._-]/g, "_") || "default";
+  } catch {}
+  return join(tmpdir(), `open-claude-design-${user}`);
+}
+function prepareArtifactDir(cwd = process.cwd()) {
+  const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpCandidates = [
+    join(tmpArtifactBase(), runId),
+    join(tmpdir(), "open-claude-design", runId)
+  ];
+  const candidates = [join(cwd, "specs", "design", runId), ...tmpCandidates];
+  for (const candidate of candidates) {
+    try {
+      mkdirSync(candidate, { recursive: true });
+      return {
+        runId,
+        artifactDir: candidate,
+        previewPath: join(candidate, "preview.html"),
+        specPath: join(candidate, "spec.html")
+      };
+    } catch {}
+  }
+  const fallback = join(tmpArtifactBase(), runId);
+  return {
+    runId,
+    artifactDir: fallback,
+    previewPath: join(fallback, "preview.html"),
+    specPath: join(fallback, "spec.html")
+  };
+}
+var HTML_PREVIEW_RULES = [
+  "Produce one self-contained HTML document: inline CSS in <style> and JS in <script>; make no external requests except explicitly required Google Fonts.",
+  "Use realistic brief-specific content, not Lorem ipsum or obvious placeholders.",
+  "Render well from 360px to 1440px with sensible container or media-query breakpoints.",
+  "Include default and hover/focus states for every interactive element, plus empty, loading, and error states where relevant.",
+  "Use semantic landmarks, labeled controls, WCAG AA contrast, visible focus, and prefers-reduced-motion.",
+  "Add HTML comments marking sections, states, and design-system token references for engineering handoff."
+].join(`
+`);
+var ANTI_SLOP_RULES = [
+  "Avoid generic AI palettes and structures: purple/indigo or blue-to-pink gradients, neon glassmorphism stacks, and nested card grids.",
+  "Avoid impeccable catalog clichés: gradient emphasis text, side-tab borders, three-font headers, and decorative shadows in flat-by-default systems.",
+  "Commit to a specific aesthetic rather than generic SaaS defaults."
+].join(`
+`);
+var REFERENCE_PRECEDENCE = "User references in <reference_context> are the PRIMARY visual authority and override conflicting DESIGN.md/PRODUCT.md guidance. DESIGN.md governs uncovered design decisions; PRODUCT.md still governs strategic register/voice.";
+function ensurePlaywrightCli() {
+  const isWindows = process.platform === "win32";
+  const onPath = () => {
+    try {
+      const probe = spawnSync(isWindows ? "where" : "which", ["playwright-cli"], {
+        stdio: "ignore",
+        timeout: 15000,
+        shell: isWindows,
+        env: createChildProcessEnvironment()
+      });
+      return probe.status === 0;
+    } catch {
+      return false;
+    }
+  };
+  if (onPath()) {
+    return {
+      available: true,
+      alreadyPresent: true,
+      installed: false,
+      summary: "playwright-cli already on PATH; skipped install."
+    };
+  }
+  if (false) {}
+  try {
+    const install = spawnSync("npm", ["install", "-g", "@playwright/cli@latest"], {
+      stdio: "ignore",
+      timeout: 180000,
+      shell: isWindows,
+      env: createChildProcessEnvironment()
+    });
+    if (install.status === 0) {
+      return {
+        available: true,
+        alreadyPresent: false,
+        installed: true,
+        summary: "Installed playwright-cli via `npm install -g @playwright/cli@latest`."
+      };
+    }
+    const reason = install.error?.message ?? (typeof install.status === "number" ? `npm install -g @playwright/cli@latest exited with code ${install.status}` : "npm install -g @playwright/cli@latest did not complete");
+    return {
+      available: false,
+      alreadyPresent: false,
+      installed: false,
+      summary: `Could not install playwright-cli (${reason}); stages will degrade gracefully.`,
+      error: reason
+    };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      available: false,
+      alreadyPresent: false,
+      installed: false,
+      summary: `Could not install playwright-cli (${reason}); stages will degrade gracefully.`,
+      error: reason
+    };
+  }
+}
+function buildPlaywrightCliBootstrapRules(status) {
+  const probeRule = status.available ? "The playwright-cli skill's `playwright-cli` command is on PATH. Do not reinstall it unless a command reports it missing; then probe with `which playwright-cli` (or `npx --no-install playwright-cli --version`), run `npm install -g @playwright/cli@latest` once, and retry. Do not add project dependencies." : `The playwright-cli skill's \`playwright-cli\` command failed setup: "${status.error ?? "unknown error"}". Probe with \`which playwright-cli\` (or \`npx --no-install playwright-cli --version\`) and retry once with \`npm install -g @playwright/cli@latest\`. For permission errors, use a user-writable global prefix; report missing npm/Node or network/registry errors plainly. If still unavailable, surface the manual file path / URL. Do not add project dependencies.`;
+  return [
+    probeRule,
+    "Use `playwright-cli open <url>` to show a local preview; use `playwright-cli snapshot` and `playwright-cli screenshot --filename=<file>` for review evidence.",
+    "If a `playwright-cli` command reports a missing browser executable, run `npx playwright install chromium` once and retry.",
+    "If `playwright-cli` is unavailable after three attempts or the browser runtime still fails, surface the manual file path / URL."
+  ].join(`
+`);
+}
+
+// dist/builtin/workflows/builtin/open-claude-design-live-protocol.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var MODEL_EVENTS = new Set(["generate", "steer", "manual_edit_apply", "variant_mount_failed"]);
+function needsModel(event) {
+  return MODEL_EVENTS.has(event.type);
+}
+function replyTokenFor(event) {
+  if (event.type === "steer")
+    return "steer_done";
+  return "done";
+}
+var LEGACY_REPLY_STATUSES = new Set(["done", "error", "complete", "discard", "discarded"]);
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLiveEvent(stdout) {
+  const lines = stdout.split(/\r?\n/).filter((line) => line.trim().startsWith("{"));
+  for (const line of [...lines].reverse()) {
+    try {
+      const parsed = JSON.parse(line);
+      if (!isJsonObject(parsed) || typeof parsed.type !== "string")
+        continue;
+      return { ...parsed, type: parsed.type, raw: line };
+    } catch {}
+  }
+  return { type: "timeout", raw: stdout };
+}
+function assertSuccessfulScript(result, operation) {
+  if (result.code !== 0) {
+    const details = result.stderr.length > 0 ? `: ${result.stderr}` : "";
+    throw new Error(`${operation} failed with exit code ${result.code}${details}`);
+  }
+  return result;
+}
+async function pollLiveEvent(input) {
+  const script = liveScriptPath("live-poll.mjs");
+  const run = input.deps?.run ?? runNodeScript;
+  for (;; ) {
+    if (input.signal?.aborted === true)
+      return { type: "exit", raw: "aborted" };
+    const result = assertSuccessfulScript(await run(script, [], input.workflowCwd, input.signal), "live poll");
+    const event = parseLiveEvent(result.stdout);
+    if (event.type !== "timeout")
+      return event;
+  }
+}
+async function replyLiveEvent(input) {
+  const id = input.event.id;
+  if (typeof id !== "string" || id.length === 0 || id.startsWith("--")) {
+    throw new Error(`Cannot reply to ${input.event.type}: live event id is missing`);
+  }
+  if (LEGACY_REPLY_STATUSES.has(id)) {
+    throw new Error(`Cannot reply to live event ${id}: expected an event id before the reply status`);
+  }
+  const status = input.status ?? replyTokenFor(input.event);
+  if (status.length === 0 || status.startsWith("--")) {
+    throw new Error(`Cannot reply to live event ${id}: reply status is missing`);
+  }
+  const args = ["--reply", id, status];
+  const file = input.file ?? input.event.file;
+  const message = input.message ?? input.event.message;
+  const data = input.data ?? input.event.data;
+  if (file !== undefined)
+    args.push("--file", file);
+  if (data !== undefined)
+    args.push("--data", JSON.stringify(data));
+  if (message !== undefined)
+    args.push(message);
+  const script = liveScriptPath("live-poll.mjs");
+  const run = input.deps?.run ?? runNodeScript;
+  return assertSuccessfulScript(await run(script, args, input.workflowCwd, input.signal), "live reply");
+}
+function liveScriptPath(script) {
+  return fileURLToPath(new URL(`../skills/impeccable/scripts/${script}`, import.meta.url));
+}
+function runNodeScript(scriptPath, args, cwd, signal) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath, ...args], {
+      cwd,
+      env: { ...process.env, GH_PAGER: "cat" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const onAbort = () => child.kill("SIGTERM");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ code: code ?? -1, stdout: stdout.trim(), stderr: stderr.trim() });
+    });
+  });
+}
+function buildLiveEventPrompt(input) {
+  const shared = [
+    `<live_event>
+${input.event.raw}
+</live_event>`,
+    `<preview_path>${input.previewPath}</preview_path>`,
+    "<role>You are an opinionated staff design engineer inside an impeccable `live` session. The workflow owns the poll loop; handle exactly this one event and stop.</role>"
+  ];
+  if (input.event.type === "generate") {
+    return [
+      ...shared,
+      [
+        "<instructions>",
+        "Follow the live contract for a `generate` event:",
+        "1. Reuse `event.scaffold` when present and read the annotation screenshot when one is attached.",
+        "2. Extract the page identity FIRST, then produce three DISTINCT on-brand variants and publish them for the user to preview.",
+        "3. Apply the craft floors by construction as you write. Do not screenshot, re-render, or QA between generate and accept; the overlay preview is the verification channel.",
+        "Do not poll, do not reply, and do not exit the session: the workflow does that. Stop as soon as the variants are published.",
+        "</instructions>"
+      ].join(`
+`)
+    ].join(`
+
+`);
+  }
+  if (input.event.type === "steer") {
+    return [
+      ...shared,
+      [
+        "<instructions>",
+        "Follow the live contract for a `steer` event: read the message and pageUrl, then do the work — page edits, navigation help, or a short answer.",
+        "Do not poll, do not reply, and do not exit the session: the workflow does that. Stop when the steer is handled.",
+        "</instructions>"
+      ].join(`
+`)
+    ].join(`
+
+`);
+  }
+  if (input.event.type === "variant_mount_failed") {
+    return [
+      ...shared,
+      [
+        "<instructions>",
+        "The browser could not mount the published variant. Inspect the reported variant source/module, fix the compile or runtime failure, and stop after the repair.",
+        "Do not poll, do not reply, and do not exit the session: the workflow does that."
+      ].join(`
+`)
+    ].join(`
+
+`);
+  }
+  return [
+    ...shared,
+    [
+      "<instructions>",
+      "Apply this manual edit event per the live contract, then stop. Do not poll, reply, or exit; the workflow does that.",
+      "</instructions>"
+    ].join(`
+`)
+  ].join(`
+
+`);
+}
+function buildLiveSessionStartPrompt(input) {
+  return [
+    `<preview_path>${input.previewPath}</preview_path>`,
+    `<preview_file_url>${input.previewFileUrl}</preview_file_url>`,
+    `<browser_use_guidelines>${input.browserBootstrapRules}</browser_use_guidelines>`,
+    "<role>You are an opinionated staff design engineer opening an impeccable `live` review session.</role>",
+    [
+      "<objective>",
+      `Start review session ${input.round}: boot live against the static preview and open it in the user's browser. Then STOP.`,
+      "</objective>"
+    ].join(`
+`),
+    [
+      "<instructions>",
+      "1. Drive `/skill:impeccable live` against the static preview: run `live.mjs` with `--target` pointed at the preview file, or the equivalent `.impeccable/live/config.json` entry, and open the URL that serves it.",
+      "2. Print the live `http://` review URL in plain text, plus the preview file URL as the manual fallback, so anyone attaching to this run can find the review.",
+      "3. Directly under the URL, print how the user ends the review, in plain text: click exit in the Impeccable overlay, close the browser tab, or say `exit live`. State that the review waits indefinitely until they do, and that ending it exports the design as it then stands, with no further round.",
+      "4. Do NOT start a poll loop. The workflow owns polling and will call you back for each event that needs you. Ending your turn does not end the review.",
+      "</instructions>"
+    ].join(`
+`),
+    "<output_format>Under 150 words: the live review URL, the manual fallback path, how to end the review, and whether the browser opened.</output_format>"
+  ].join(`
+
+`);
+}
+
+// dist/builtin/workflows/builtin/open-claude-design-setup.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+function renderDiscoveryContext(discovery) {
+  return [
+    `Confirmed design brief: ${discovery.brief}`,
+    `Output type: ${discovery.output_type}`,
+    discovery.references.length > 0 ? `References to emulate (take precedence over DESIGN.md/PRODUCT.md): ${discovery.references.join(", ")}` : "References to emulate: none provided."
+  ].join(`
+`);
+}
+function buildDiscoveryInitPrompt(prompt) {
+  const outputTypes = OUTPUT_TYPES.join(", ");
+  return `/skill:impeccable shape
+/skill:impeccable init
+
+${taggedPrompt([
+    ["role", "You are an opinionated staff designer running the open-claude-design front door."],
+    [
+      "objective",
+      `In one stage, confirm the design brief, output type, and references for: ${prompt}. Then run impeccable's \`init\` so PRODUCT.md and DESIGN.md are detected, created, or reconciled before design research; do not wait for another init stage.`
+    ],
+    [
+      "interview",
+      [
+        "Use `ask_user_question` for important gaps not inferable from the request or repository.",
+        `Cover the product and core jobs/screens, one output type (${outputTypes}), and references to emulate (URLs, local paths, screenshots, or design docs).`,
+        "Ask 2-3 questions per round and present inferred answers as options rather than facts.",
+        "User references are the PRIMARY visual authority and override conflicting DESIGN.md/PRODUCT.md guidance."
+      ].join(`
+`)
+    ],
+    [
+      "init_instructions",
+      [
+        "After confirmation, run `/skill:impeccable init` in this stage. Let impeccable init perform its own PRODUCT.md/DESIGN.md detection rather than relying on runner detection.",
+        "Create missing files when needed and reconcile existing ones without silently overwriting them; ask only about genuine gaps.",
+        "When headless, infer the most defensible brief/register from the prompt and repository, record explicit `## Gaps / Assumptions`, and do not block."
+      ].join(`
+`)
+    ],
+    [
+      "output_format",
+      `Return the structured fields \`brief\`, \`output_type\` (one of ${outputTypes}), and \`references\` (verbatim URL/path array, empty when none). In at most 250 words, summarize PRODUCT.md/DESIGN.md changes and assumptions. ${GROUNDED_REPORTING}`
+    ]
+  ])}`;
+}
+async function runDiscoveryAndInit(args) {
+  const result = await args.designContext.task("discovery", {
+    prompt: buildDiscoveryInitPrompt(args.prompt),
+    ...args.discoveryConfig
+  });
+  const discovery = discoveryDecisionFromResult(result, args.prompt);
+  return {
+    discovery,
+    discoveryContext: renderDiscoveryContext(discovery),
+    projectContext: {
+      summary: [
+        "Ran `/skill:impeccable shape` + `/skill:impeccable init` in the combined discovery stage.",
+        (result.text ?? "").trim()
+      ].filter((part) => part.length > 0).join(`
+
+`)
+    }
+  };
+}
+var REFERENCE_DESIGN_SITES = [
+  { name: "Awwwards", url: "https://www.awwwards.com/websites/" },
+  { name: "recent.design", url: "https://recent.design/" },
+  { name: "Dribbble (recent shots)", url: "https://dribbble.com/shots/recent" },
+  { name: "Monet", url: "https://www.monet.design/c" },
+  { name: "Motionsites", url: "https://motionsites.ai/" }
+];
+var NO_REFERENCES_BRIEF = "Reference discovery was skipped. Generate from the project design system and the prompt; do not fabricate external references.";
+var DESIGN_CONTEXT_FILENAME = "design-context.md";
+var REFERENCES_BRIEF_FILENAME = "references.md";
+function designContextPath(artifactDir) {
+  return join2(artifactDir, DESIGN_CONTEXT_FILENAME);
+}
+function referencesBriefPath(artifactDir) {
+  return join2(artifactDir, REFERENCES_BRIEF_FILENAME);
+}
+function buildReferenceDiscoveryPrompt(args) {
+  const siteList = REFERENCE_DESIGN_SITES.map((site, index) => `${index + 1}. ${site.name} — ${site.url}`).join(`
+`);
+  return taggedPrompt([
+    ["reference_galleries", siteList],
+    [
+      "design_context_file",
+      `Read the file at ${args.designContextFile} for the project design context (PRODUCT.md/DESIGN.md summary) and the ds-* discovery evidence before curating. Do not proceed from assumptions when the file is readable; if it is missing, say so and curate from the brief alone.`
+    ],
+    ["browser_use_guidelines", args.browserBootstrapRules],
+    ["screenshot_dir", args.artifactDir],
+    [
+      "role",
+      "You are an opinionated staff design engineer curating current, best-in-class visual references."
+    ],
+    [
+      "objective",
+      `Curate references for a ${args.outputType} serving: ${args.prompt}. Open actual design pages, capture motion with scroll-through video when possible and a full-page screenshot as fallback, record destination URLs, and apply impeccable \`extract\` to report concrete observed traits.`
+    ],
+    [
+      "instructions",
+      [
+        "Use the playwright-cli skill to open each gallery; if `playwright-cli` reports a missing browser executable, follow the bootstrap rules and retry once.",
+        "From each gallery, choose 1-3 fitting designs and CLICK INTO each actual live or project-detail page; do not capture only the grid or thumbnail.",
+        `Capture motion across the entire page: start \`playwright-cli video-start ${join2(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using \`playwright-cli run-code\` or repeated \`playwright-cli mousewheel 0 600\`) so animations fire and lazy content loads, then run \`playwright-cli video-stop\`.`,
+        `Also run \`playwright-cli screenshot --full-page --filename=${join2(args.artifactDir, "ref-<site>-<n>.png")}\`; this still is the minimum when video is unavailable.`,
+        "Record the actual destination URL, title, and author. For each reference, cite observed layout, typography, color, spacing, and motion traits rather than inferred traits.",
+        "Assess fit against DESIGN.md, PRODUCT.md, and the ds-* discovery evidence in the design-context file; prefer on-brand references and flag departures.",
+        "Use ask_user_question to ask which reference direction they prefer, offering 2-4 strongest options plus `None of these fit`. If none fit, ask them to provide a reference image, screenshot, URL, or local file path and record the answer.",
+        "If `playwright-cli` is unavailable or automation is blocked, use web search / page fetch to reach actual pages and mark missing recordings or screenshots. Never fabricate references or visual claims; report galleries with no usable result."
+      ].join(`
+`)
+    ],
+    [
+      "output_format",
+      [
+        "In at most 900 words, return these Markdown sections:",
+        "1. Curated references (table: Source gallery | Work (title/author) | Full page URL (destination) | Scroll-through video path | Full-page screenshot path | Transferable trait (incl. motion) | On-brand?)",
+        "2. User preference check (selected direction, or none plus the requested/provided reference)",
+        "3. Synthesis (3-5 strongest directions ranked by fit, including motion to reproduce)",
+        "4. What to avoid (observed anti-references)",
+        "5. Verification notes (actual-page video/screenshot versus search-only)",
+        GROUNDED_REPORTING
+      ].join(`
+`)
+    ]
+  ]);
+}
+function writeRequiredContextArtifact(artifactDir, filePath, content, label) {
+  try {
+    mkdirSync2(artifactDir, { recursive: true });
+    writeFileSync(filePath, `${content}
+`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`open-claude-design: failed to write the required ${label} artifact at ${filePath}. Downstream stages read this file via \`reads\` and must not run without it (${detail})`, { cause: error });
+  }
+}
+function persistReferencesBrief(artifactDir, brief) {
+  writeRequiredContextArtifact(artifactDir, referencesBriefPath(artifactDir), brief, "references-brief");
+}
+function persistDesignContext(artifactDir, content) {
+  writeRequiredContextArtifact(artifactDir, designContextPath(artifactDir), content, "design-context");
+}
+var LIVE_REVIEW_GATE_OPTIONS = [
+  "Start live review",
+  "Skip remaining review rounds and export as-is"
+];
+function buildLiveReviewGateMessage(args) {
+  return [
+    `Design review session ${args.round} is ready for your browser review.`,
+    "",
+    `Preview file: ${args.previewPath}`,
+    `Preview URL: ${args.previewFileUrl}`,
+    "",
+    `"${LIVE_REVIEW_GATE_OPTIONS[0]}" opens an interactive browser session; the session-start stage prints the live http:// review URL as soon as its server is up (attach with /workflow connect to see it, or open the preview URL above directly).`,
+    "The session is unbounded: pick elements, accept variants, and steer for as long as you like, and everything you accept lands in the preview as you go.",
+    "",
+    "YOU end the review, and nothing else does. It keeps waiting through any amount of silence.",
+    'End it by clicking exit in the Impeccable overlay, closing the browser tab, or saying "exit live".',
+    "The moment you do, the design you are looking at is exported. There is no further round and no confirmation, so end the session only when the preview is what you want handed off.",
+    `"${LIVE_REVIEW_GATE_OPTIONS[1]}" accepts the current design and proceeds to export without opening a session.`
+  ].join(`
+`);
+}
+function isUiUnavailableRejection(error) {
+  return error instanceof Error && /ctx\.ui\.\w+ (?:prompt node )?is unavailable/.test(error.message);
+}
+
+// dist/builtin/workflows/builtin/open-claude-design-phases.ts
+var GROUNDED_REPORTING2 = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+function forkContinuationOptions(sessionFile) {
+  return sessionFile === undefined || sessionFile.length === 0 ? {} : { context: "fork", forkFromSessionFile: sessionFile };
+}
+async function refineOpenClaudeDesign(options) {
+  const { designContext, prompt, outputType, previewPath, previewFileUrl, browserBootstrapRules, designContextFile, referencesFile, designModelConfig, workflowCwd } = options;
+  const importContext = options.importContext ?? "";
+  const generated = await designContext.task("generate-1", {
+    prompt: buildInitialGeneratePrompt({
+      prompt,
+      outputType,
+      previewPath,
+      designContextFile,
+      referencesFile,
+      importContext
+    }),
+    reads: [designContextFile, referencesFile],
+    ...designModelConfig
+  });
+  const gateChoice = await options.ui.select(buildLiveReviewGateMessage({ round: 1, previewPath, previewFileUrl }), LIVE_REVIEW_GATE_OPTIONS).catch((error) => {
+    if (isUiUnavailableRejection(error))
+      return LIVE_REVIEW_GATE_OPTIONS[0];
+    throw error;
+  });
+  if (gateChoice === LIVE_REVIEW_GATE_OPTIONS[0]) {
+    await runLiveReviewSession({
+      designContext,
+      round: 1,
+      reviewStageName: "user-feedback-1",
+      previewPath,
+      previewFileUrl,
+      browserBootstrapRules,
+      designModelConfig,
+      workflowCwd
+    });
+  }
+  return { latestDesign: generated.text };
+}
+async function runLiveReviewSession(options) {
+  const { designContext, round, reviewStageName, previewPath, previewFileUrl, browserBootstrapRules, designModelConfig, workflowCwd } = options;
+  let sessionFile;
+  const start = await designContext.task(`${reviewStageName}-start`, {
+    prompt: buildLiveSessionStartPrompt({ previewPath, previewFileUrl, browserBootstrapRules, round }),
+    ...designModelConfig
+  });
+  sessionFile = start.sessionFile;
+  for (let index = 1;; index += 1) {
+    const event = await designContext.tool(`live-poll-${round}-${index}`, { round, index }, async ({ signal }) => pollLiveEvent({ workflowCwd, signal }));
+    if (event.type === "exit")
+      break;
+    if (!needsModel(event))
+      continue;
+    if (event.id === undefined || event.id.length === 0) {
+      throw new Error(`Live ${event.type} event is missing its id`);
+    }
+    const response = await designContext.task(`live-${event.type}-${round}-${index}`, {
+      prompt: buildLiveEventPrompt({ event, previewPath }),
+      ...designModelConfig,
+      ...forkContinuationOptions(sessionFile)
+    });
+    sessionFile = response.sessionFile ?? sessionFile;
+    const status = replyTokenFor(event);
+    await designContext.tool(`live-reply-${round}-${index}`, { round, index, eventId: event.id, status }, async ({ signal }) => replyLiveEvent({ workflowCwd, event, status, signal }));
+  }
+}
+function buildInitialGeneratePrompt(args) {
+  return taggedPrompt([
+    ["design_brief", args.prompt],
+    [
+      "design_context_file",
+      `Read the file at ${args.designContextFile} for the project design context (PRODUCT.md/DESIGN.md summary) and the ds-* design-system evidence before designing.`
+    ],
+    ["reference_context", args.importContext],
+    [
+      "reference_inspiration_file",
+      `Read the file at ${args.referencesFile} for the curated reference inspiration to heavily emulate.`
+    ],
+    ["reference_precedence", REFERENCE_PRECEDENCE],
+    ["preview_artifact_path", args.previewPath],
+    ["html_rules", HTML_PREVIEW_RULES],
+    ["anti_design_slop_rules", ANTI_SLOP_RULES],
+    ["role", "You are an opinionated staff design engineer."],
+    [
+      "objective",
+      `Create the first production-ready ${args.outputType} for: ${args.prompt}. Write an interactive browser preview and apply impeccable \`craft\`; each decision must trace to the brief, references, design system, or reference context.`
+    ],
+    [
+      "instructions",
+      [
+        `First read the design-context and reference-inspiration files named above; they are the design system and reference authority for every decision. If a file is missing, say so and proceed from the brief.`,
+        `Create the HTML artifact exactly at ${args.previewPath}.`,
+        "Follow <reference_precedence>; heavily reference the reference-inspiration file without copying wholesale or inventing traits.",
+        `Build the requested output_type (${args.outputType}): render full realistic layouts for prototypes/pages, or the component in at least three representative contexts.`,
+        "Include structure, states, accessibility, responsive behavior, and integration notes as HTML comments so the preview stays clean.",
+        "Use project language rather than generic placeholders when conventions exist. Add no features or abstractions beyond this design brief."
+      ].join(`
+`)
+    ],
+    [
+      "output_format",
+      [
+        "In at most 500 words, return Markdown, not the HTML body:",
+        "1. Artifact overview",
+        "2. Files written (including the absolute preview.html path)",
+        "3. UI structure and states (by HTML section ID)",
+        "4. Accessibility and responsive behavior",
+        "5. Implementation notes",
+        "6. Assumptions / open questions",
+        GROUNDED_REPORTING2
+      ].join(`
+`)
+    ]
+  ]);
+}
+async function exportOpenClaudeDesign(options) {
+  const { designContext, prompt, outputType, previewPath, previewFileUrl, specPath, specFileUrl, browserBootstrapRules, designContextFile, referencesFile, designModelConfig } = options;
+  const latestDesign = options.latestDesign;
+  const handoff = await designContext.task("exporter", {
+    reads: [designContextFile, referencesFile],
+    prompt: taggedPrompt([
+      [
+        "design_context_file",
+        `Read the file at ${designContextFile} for the project design context (PRODUCT.md/DESIGN.md summary) and the ds-* design-system evidence to document.`
+      ],
+      [
+        "reference_inspiration_file",
+        `Read the file at ${referencesFile} for the curated reference research that informed the final design; use it wherever the spec cites visual direction or reference provenance.`
+      ],
+      ["preview_artifact_path", previewPath],
+      ["spec_artifact_path", specPath],
+      ["final_design_summary", "{previous}"],
+      ["html_rules", HTML_PREVIEW_RULES],
+      ["anti_design_slop_rules", ANTI_SLOP_RULES],
+      ["role", "You are an opinionated staff design engineer."],
+      [
+        "objective",
+        `Export the final ${outputType} for "${prompt}" as a rich browser-readable HTML spec. Apply impeccable \`document\` and embed or link the final preview so implementation reviewers see the design as exported.`
+      ],
+      [
+        "instructions",
+        [
+          "First read the design-context file named above, then read preview_artifact_path as the canonical final design, and use the Write tool to create one self-contained HTML5 file at spec_artifact_path.",
+          'In order, include: sticky header with title/status/run id; Executive Summary; Live Preview embedding the full preview via `<iframe srcdoc="...">` or a side-by-side rendered copy in `<article class="preview-frame">`; the six DESIGN.md sections (Overview, Colors, Typography, Elevation, Components, Do\'s and Don\'ts) rendered with swatches, tables, and code blocks; Implementation handoff (Recommended files + components, Implementation steps, Usage example, Accessibility & responsive checklist, Validation commands, Known limitations); and an appendix linking the raw preview path.',
+          "Use dense legible typography, generous whitespace, monospaced code, rendered hex/oklch swatches, and copy-to-clipboard hints in HTML comments.",
+          `Show the absolute preview path (${previewPath}) and file URL (${previewFileUrl}) prominently. Preserve assumptions and limitations; introduce no requirement absent from the final design or DESIGN.md.`
+        ].join(`
+`)
+      ],
+      [
+        "output_format",
+        [
+          "In at most 600 words, return Markdown, not the HTML:",
+          "1. Spec written to (absolute path)",
+          "2. Sections included",
+          "3. How to open the spec (playwright-cli command + manual fallback path)",
+          "4. Recommended files and components",
+          "5. Implementation steps",
+          "6. Usage example",
+          "7. Accessibility / responsive checklist",
+          "8. Validation commands",
+          "9. Known limitations",
+          GROUNDED_REPORTING2
+        ].join(`
+`)
+      ]
+    ]),
+    previous: { name: "final-design", text: latestDesign },
+    ...designModelConfig
+  });
+  await designContext.task("final-display", {
+    prompt: taggedPrompt([
+      ["spec_path", specPath],
+      ["spec_file_url", specFileUrl],
+      ["preview_path", previewPath],
+      ["preview_file_url", previewFileUrl],
+      ["browser_use_guidelines", browserBootstrapRules],
+      ["role", "You are an opinionated staff design engineer."],
+      [
+        "objective",
+        "Show the exported spec with the playwright-cli skill's `playwright-cli` command. Export is complete, so do not solicit changes; direct further changes to a new `/workflow open-claude-design` run and degrade gracefully when browser automation is unavailable."
+      ],
+      [
+        "instructions",
+        [
+          `Use the bootstrap rules, run \`playwright-cli open ${specFileUrl}\`, and if a browser executable is missing follow those rules and retry once before \`playwright-cli snapshot\`.`,
+          "Do not run `show --annotate` or invite changes because the review session has ended.",
+          `Prominently print the manual paths:
+- Final spec: ${specPath}
+- Preview: ${previewPath}`,
+          "Unavailable tooling must not block the workflow; return the structured summary."
+        ].join(`
+`)
+      ],
+      [
+        "output_format",
+        `Under 250 words, return Markdown with: \`display_method\` | \`spec_path\` | \`preview_path\` | \`manual_open_instructions\` | \`next_action_hint\` (how to re-run the workflow). ${GROUNDED_REPORTING2}`
+      ]
+    ]),
+    ...designModelConfig
+  }).catch(() => {
+    return;
+  });
+  return { latestDesign, handoff };
+}
+
+// dist/builtin/workflows/builtin/open-claude-design-runner.ts
+var GROUNDED_REPORTING3 = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+var DELEGATION_RULE = "Delegate further only work genuinely independent and too large for a handful of tool calls; do not delegate self-verification, and prefer one subagent over several.";
+async function runOpenClaudeDesignWorkflow(ctx) {
+  const designContext = ctx;
+  const playwrightCli = ensurePlaywrightCli();
+  const browserBootstrapRules = buildPlaywrightCliBootstrapRules(playwrightCli);
+  const inputs = designContext.inputs;
+  const prompt = inputs.prompt;
+  const discoverReferences = inputs.discover_references !== false;
+  const workflowCwd = designContext.cwd ?? process.cwd();
+  const { runId, artifactDir, previewPath, specPath } = prepareArtifactDir(workflowCwd);
+  const previewFileUrl = `file://${previewPath}`;
+  const specFileUrl = `file://${specPath}`;
+  const partialArtifactOutputs = {
+    playwright_cli_status: playwrightCli.summary,
+    run_id: runId,
+    artifact_dir: artifactDir,
+    preview_path: previewPath,
+    preview_file_url: previewFileUrl,
+    spec_path: specPath,
+    spec_file_url: specFileUrl
+  };
+  if (shouldEarlyExitForBrowser(playwrightCli.available, "development") && typeof designContext.exit === "function") {
+    designContext.exit({
+      reason: `open-claude-design needs the playwright-cli skill's browser for interactive design review, which is unavailable (${playwrightCli.error ?? playwrightCli.summary}). No design was generated. Install it (\`npm install -g @playwright/cli@latest\` + \`npx playwright install chromium\`) and re-run.`,
+      outputs: partialArtifactOutputs
+    });
+  }
+  const persistRequiredContextOrExit = (persist) => {
+    try {
+      persist();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      if (typeof designContext.exit === "function") {
+        designContext.exit({
+          status: "blocked",
+          reason: `${detail} No design was generated.`,
+          outputs: partialArtifactOutputs
+        });
+      }
+      throw error;
+    }
+  };
+  const designModelConfig = {
+    model: "anthropic/claude-opus-5:high",
+    fallbackModels: [
+      "github-copilot/claude-opus-5:high",
+      "anthropic/claude-fable-5:high",
+      "github-copilot/claude-fable-5:high",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
+      "anthropic/claude-opus-4-8:high",
+      "github-copilot/claude-opus-4.8:high",
+      "openai-codex/gpt-5.6-sol:xhigh",
+      "github-copilot/gpt-5.6-sol:xhigh",
+      "openai/gpt-5.6-sol:xhigh",
+      "xai/grok-4.6:xhigh",
+      "github-copilot/grok-4.6:xhigh",
+      "zai/glm-5.3:high",
+      "zai-coding-cn/glm-5.3:high",
+      "openrouter/anthropic/claude-opus-5:high",
+      "openrouter/anthropic/claude-fable-5:high",
+      "openrouter/anthropic/claude-opus-4-8:high",
+      "openrouter/moonshotai/kimi-k3:max",
+      "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/sakana/fugu-ultra:high",
+      "openrouter/x-ai/grok-4.6"
+    ]
+  };
+  const frontDoor = await runDiscoveryAndInit({
+    designContext,
+    prompt,
+    discoveryConfig: { ...designModelConfig, schema: discoveryDecisionSchema }
+  });
+  const discovery = frontDoor.discovery;
+  const designBrief = discovery.brief;
+  const outputType = discovery.output_type;
+  const references = discovery.references;
+  const projectContext = frontDoor.projectContext;
+  const userReferenceContext = references.length > 0 ? references.map((ref, index) => `${index + 1}. ${ref}`).join(`
+`) : "No user-provided references were collected during discovery.";
+  const referenceHandlingRules = references.length > 0 ? [
+    REFERENCE_PRECEDENCE,
+    "For URL references, use browser/screenshot tooling when available and cite only observable traits.",
+    "For files, screenshots, or design docs, read or parse the source directly and quote concrete evidence.",
+    "Include a `Reference requirements` section so the generator receives the imported constraints."
+  ].join(`
+`) : "No user references to import. Focus on project context and curated reference-discovery when present.";
+  const dsSteps = [
+    {
+      name: "ds-locator",
+      task: taggedPrompt([
+        ["user_references", userReferenceContext],
+        ["reference_handling", referenceHandlingRules],
+        ["browser_use_guidelines", browserBootstrapRules],
+        ["role", "You are an opinionated staff design engineer."],
+        [
+          "objective",
+          `Find UI/design-system sources for: ${designBrief}. Apply impeccable \`extract\` to codebase evidence and user reference URLs/files that should steer generation.`
+        ],
+        ["delegation_rule", DELEGATION_RULE],
+        [
+          "instructions",
+          [
+            "Locate UI components, stylesheets, tokens, Storybook/examples, screenshots, tests, design docs, and user references.",
+            "Report concrete file, URL, or artifact paths and why each informs generation; separate primary sources, supporting examples, and reference-only inspiration.",
+            "If no explicit system exists, report the strongest implicit evidence such as repeated literals and dominant component patterns."
+          ].join(`
+`)
+        ],
+        [
+          "output_format",
+          `In at most 500 words, return Markdown sections: Project sources table | User reference sources | Reference requirements | Confidence notes. ${GROUNDED_REPORTING3}`
+        ]
+      ]),
+      ...designModelConfig
+    },
+    {
+      name: "ds-analyzer",
+      task: taggedPrompt([
+        ["user_references", userReferenceContext],
+        ["reference_handling", referenceHandlingRules],
+        ["browser_use_guidelines", browserBootstrapRules],
+        [
+          "impeccable_skill",
+          "audit — score 0–4 across Accessibility, Performance, Theming, Responsive, Anti-patterns. Tag every finding P0 (blocks release) → P3 (polish). Document, do not fix."
+        ],
+        ["role", "You are an opinionated staff design engineer."],
+        [
+          "objective",
+          `Independently audit UI constraints for: ${designBrief}. Scan the repository, assess evidence across impeccable's six quality dimensions, and capture or parse user references without relying on another stage's output.`
+        ],
+        ["delegation_rule", DELEGATION_RULE],
+        [
+          "instructions",
+          [
+            "Inspect the UI stack, styling, tokens, responsive behavior, accessibility conventions, and component APIs.",
+            "Ground each claim in exact paths, symbols, code examples, screenshots, URLs, or quoted reference excerpts.",
+            "Identify integration constraints the generated design must follow, and state uncertainty when evidence is incomplete."
+          ].join(`
+`)
+        ],
+        [
+          "output_format",
+          `In at most 700 words, return Markdown sections in this order: Stack | Tokens | Components | Layout / responsiveness | Accessibility | Audit scores (per dimension, 0–4) | Reference requirements | Hard constraints for generation. ${GROUNDED_REPORTING3}`
+        ]
+      ]),
+      ...designModelConfig
+    },
+    {
+      name: "ds-patterns",
+      task: taggedPrompt([
+        ["user_references", userReferenceContext],
+        ["reference_handling", referenceHandlingRules],
+        ["browser_use_guidelines", browserBootstrapRules],
+        ["role", "You are an opinionated staff design engineer."],
+        [
+          "objective",
+          `Extract reusable patterns and anti-patterns for: ${designBrief}. Apply impeccable \`extract\` to repository evidence and user references, translating them into generation guidance without relying on another stage's output.`
+        ],
+        ["delegation_rule", DELEGATION_RULE],
+        [
+          "instructions",
+          [
+            "Find reusable naming, variant, composition, state, animation, and layout patterns.",
+            "Cite concrete paths, component/symbol names, reference URLs, or quoted file/screenshot evidence.",
+            "Identify generated-design anti-patterns using impeccable's 25 deterministic anti-patterns; do not generalize beyond repository or reference evidence."
+          ].join(`
+`)
+        ],
+        [
+          "output_format",
+          `In at most 600 words, return Markdown sections: Reusable patterns | Examples | Reference requirements | Anti-patterns | Generation implications. ${GROUNDED_REPORTING3}`
+        ]
+      ]),
+      ...designModelConfig
+    }
+  ];
+  const onboardingAnalysis = await designContext.parallel(dsSteps, {
+    task: designBrief
+  });
+  const onboardingSummary = joinResults(onboardingAnalysis);
+  const designSystem = [
+    "Project design context from `/skill:impeccable init` and PRODUCT.md/DESIGN.md:",
+    projectContext.summary,
+    "",
+    "Design-system and user-reference evidence:",
+    onboardingSummary
+  ].join(`
+
+`);
+  persistRequiredContextOrExit(() => persistDesignContext(artifactDir, designSystem));
+  const designContextFile = designContextPath(artifactDir);
+  const referenceResult = discoverReferences ? await designContext.task("reference-discovery", {
+    prompt: buildReferenceDiscoveryPrompt({
+      prompt: designBrief,
+      outputType,
+      designContextFile,
+      artifactDir,
+      browserBootstrapRules
+    }),
+    reads: [designContextFile],
+    ...designModelConfig
+  }) : undefined;
+  const referencesBriefRaw = (referenceResult?.text ?? "").trim();
+  const referencesBrief = referencesBriefRaw.length > 0 ? referencesBriefRaw : NO_REFERENCES_BRIEF;
+  persistRequiredContextOrExit(() => persistReferencesBrief(artifactDir, referencesBrief));
+  const referencesFile = referencesBriefPath(artifactDir);
+  const importContext = references.length > 0 ? [
+    REFERENCE_PRECEDENCE,
+    "Reference sources:",
+    userReferenceContext,
+    "",
+    "Full design-system and reference evidence: read the design-context file."
+  ].join(`
+`) : "No user reference was provided; infer the design direction from the brief, project design context, research, and curated reference inspiration.";
+  const refinement = await refineOpenClaudeDesign({
+    designContext,
+    prompt: designBrief,
+    outputType,
+    previewPath,
+    previewFileUrl,
+    browserBootstrapRules,
+    designContextFile,
+    referencesFile,
+    designModelConfig,
+    workflowCwd,
+    importContext,
+    ui: designContext.ui
+  });
+  const latestDesign = refinement.latestDesign;
+  const exportResult = await exportOpenClaudeDesign({
+    designContext,
+    prompt: designBrief,
+    outputType,
+    previewPath,
+    previewFileUrl,
+    specPath,
+    specFileUrl,
+    browserBootstrapRules,
+    designContextFile,
+    referencesFile,
+    latestDesign,
+    designModelConfig
+  });
+  const handoff = exportResult.handoff;
+  return {
+    output_type: outputType,
+    design_system: "project-derived design system",
+    artifact: latestDesign,
+    handoff: handoff.text,
+    import_context: importContext,
+    run_id: runId,
+    artifact_dir: artifactDir,
+    preview_path: previewPath,
+    preview_file_url: previewFileUrl,
+    spec_path: specPath,
+    spec_file_url: specFileUrl,
+    playwright_cli_status: playwrightCli.summary
+  };
+}
+
+// dist/builtin/workflows/builtin/open-claude-design.ts
+var open_claude_design_default = workflow({
+  name: "open-claude-design",
+  description: "AI-powered design workflow: combined discovery/init → design-system/reference research → curated reference discovery → HTML generation → one live review session → rich HTML handoff. The discovery stage asks what to build, the output type, and which references to emulate, then runs impeccable init for PRODUCT.md/DESIGN.md (references take precedence over project context). The user reviews the generated HTML in one live session.",
+  heartbeatIntervalMinutes: 0,
+  inputs: {
+    prompt: Type2.String({
+      description: "What to design (for example, a dashboard, page, component, or prototype). The discovery stage refines this into a confirmed brief and asks for the output type and references."
+    }),
+    discover_references: Type2.Boolean({
+      default: true,
+      description: "Discover beautiful, current reference designs from notable design websites (Awwwards, recent.design, Dribbble, Monet, Motionsites) and feed them to generation. Set false to skip the network/browser reference pass."
+    })
+  },
+  outputs: {
+    output_type: Type2.Optional(Type2.String({ description: "Kind of design artifact produced." })),
+    design_system: Type2.Optional(Type2.String({ description: "Design system source used for generation: the project-derived design system." })),
+    artifact: Type2.Optional(Type2.String({ description: "Latest final design summary from the final preview artifact." })),
+    handoff: Type2.Optional(Type2.String({ description: "Final rich HTML spec and implementation handoff summary." })),
+    import_context: Type2.Optional(Type2.String({ description: "Reference-import context used during generation." })),
+    run_id: Type2.Optional(Type2.String({ description: "Per-run design workflow artifact identifier." })),
+    artifact_dir: Type2.Optional(Type2.String({ description: "Directory containing preview and spec artifacts." })),
+    preview_path: Type2.Optional(Type2.String({ description: "Absolute path to the generated preview.html file." })),
+    preview_file_url: Type2.Optional(Type2.String({ description: "file:// URL for the generated preview.html file." })),
+    spec_path: Type2.Optional(Type2.String({ description: "Absolute path to the generated spec.html file." })),
+    spec_file_url: Type2.Optional(Type2.String({ description: "file:// URL for the generated spec.html file." })),
+    playwright_cli_status: Type2.Optional(Type2.String({ description: "Outcome of the initial deterministic step that ensures the playwright-cli skill's `playwright-cli` command is installed." }))
+  },
+  run: async (ctx) => await runOpenClaudeDesignWorkflow(withSteeringPropagationContext(ctx))
+});
+
+export { open_claude_design_default };