@wraps.dev/cli 2.14.3 → 2.14.4

package/dist/cli.js

@@ -1756,18 +1756,6 @@ You may need to merge your existing rules into the wraps rule set.`,
         "TEMPLATE_PUSH_FAILED",
         "Check your API key and network connection.",
         "https://wraps.dev/docs/templates-as-code"
-      ),
-      workflowGenerationFailed: (message) => new WrapsError(
-        `Workflow generation failed${message ? `: ${message}` : ""}`,
-        "WORKFLOW_GENERATION_FAILED",
-        "Try rephrasing your description, or use a built-in template:\n  wraps email workflows generate --template welcome\n  wraps email workflows generate --template cart-recovery",
-        "https://wraps.dev/docs/guides/orchestration"
-      ),
-      aiUsageLimitReached: () => new WrapsError(
-        "AI generation usage limit reached",
-        "AI_USAGE_LIMIT_REACHED",
-        "Upgrade your plan for more AI generations, or use built-in templates:\n  wraps email workflows generate --template welcome\n  wraps email workflows generate --template cart-recovery",
-        "https://wraps.dev/docs/pricing"
       )
     };
   }
@@ -24735,852 +24723,171 @@ ${pc30.green("\u2713")} ${pc30.bold("Upgrade complete!")}
 // src/commands/email/workflows/generate.ts
 init_esm_shims();
 init_events();
-import { existsSync as existsSync14, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join15 } from "path";
-import { cancel as cancel21, confirm as confirm14, intro as intro27, isCancel as isCancel20, log as log29 } from "@clack/prompts";
+init_json_output();
+import { existsSync as existsSync13, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join14 } from "path";
+import { intro as intro27, log as log29 } from "@clack/prompts";
 import pc31 from "picocolors";
+var TEMPLATES = {
+  welcome: `import {
+  defineWorkflow,
+  sendEmail,
+  delay,
+  condition,
+  exit,
+} from '@wraps.dev/client';
 
-// src/utils/email/workflow-transform.ts
-init_esm_shims();
-function transformWorkflow(definition) {
-  const steps = [];
-  const transitions = [];
-  const triggerStep = createTriggerStep(definition.trigger);
-  steps.push(triggerStep);
-  if (definition.steps.length > 0) {
-    flattenSteps(definition.steps, steps, transitions, triggerStep.id, null);
-  }
-  assignPositions(steps, transitions);
-  return {
-    steps,
-    transitions,
-    triggerType: definition.trigger.type,
-    triggerConfig: extractTriggerConfig(definition.trigger),
-    settings: definition.settings,
-    defaults: definition.defaults
-  };
-}
-function createTriggerStep(trigger) {
-  const triggerConfig = {
-    type: "trigger",
-    triggerType: trigger.type,
-    ...extractTriggerConfig(trigger)
-  };
-  return {
-    id: "trigger",
-    type: "trigger",
-    name: getTriggerName(trigger.type),
-    position: { x: 0, y: 0 },
-    // Will be updated by assignPositions
-    config: triggerConfig
-  };
-}
-function extractTriggerConfig(trigger) {
-  const config2 = {};
-  if (trigger.eventName) {
-    config2.eventName = trigger.eventName;
-  }
-  if (trigger.segmentId) {
-    config2.segmentId = trigger.segmentId;
-  }
-  if (trigger.schedule) {
-    config2.schedule = trigger.schedule;
-  }
-  if (trigger.timezone) {
-    config2.timezone = trigger.timezone;
-  }
-  if (trigger.topicId) {
-    config2.topicId = trigger.topicId;
-  }
-  return config2;
-}
-function getTriggerName(type) {
-  const names = {
-    event: "When event occurs",
-    contact_created: "When contact is created",
-    contact_updated: "When contact is updated",
-    segment_entry: "When contact enters segment",
-    segment_exit: "When contact exits segment",
-    schedule: "On schedule",
-    api: "When triggered via API",
-    topic_subscribed: "When contact subscribes to topic",
-    topic_unsubscribed: "When contact unsubscribes from topic"
-  };
-  return names[type] || "Trigger";
-}
-function flattenSteps(stepDefs, steps, transitions, fromStepId, branch) {
-  let prevIds = [fromStepId];
-  let firstStepInBranch = true;
-  for (const def of stepDefs) {
-    const step = toWorkflowStep(def);
-    steps.push(step);
-    for (const prevId of prevIds) {
-      const transition = {
-        id: `t-${prevId}-${step.id}`,
-        fromStepId: prevId,
-        toStepId: step.id
-      };
-      if (firstStepInBranch && branch && prevId === fromStepId) {
-        transition.condition = { branch };
-      }
-      transitions.push(transition);
-    }
-    firstStepInBranch = false;
-    if (def.type === "condition" && def.branches) {
-      const leafIds = [];
-      if (def.branches.yes && def.branches.yes.length > 0) {
-        const yesLeaves = flattenSteps(
-          def.branches.yes,
-          steps,
-          transitions,
-          step.id,
-          "yes"
-        );
-        leafIds.push(...yesLeaves);
-      } else {
-        leafIds.push(step.id);
-      }
-      if (def.branches.no && def.branches.no.length > 0) {
-        const noLeaves = flattenSteps(
-          def.branches.no,
-          steps,
-          transitions,
-          step.id,
-          "no"
-        );
-        leafIds.push(...noLeaves);
-      } else if (!leafIds.includes(step.id)) {
-        leafIds.push(step.id);
-      }
-      prevIds = leafIds;
-      continue;
-    }
-    if (def.type === "exit") {
-      prevIds = [];
-      continue;
-    }
-    prevIds = [step.id];
-  }
-  return prevIds;
-}
-function toWorkflowStep(def) {
-  const step = {
-    id: def.id,
-    type: def.type,
-    name: def.name || getDefaultStepName(def.type),
-    position: { x: 0, y: 0 },
-    // Will be updated by assignPositions
-    config: def.config
-  };
-  if (def.cascadeGroupId) {
-    step.cascadeGroupId = def.cascadeGroupId;
-  }
-  return step;
-}
-function getDefaultStepName(type) {
-  const names = {
-    send_email: "Send Email",
-    send_sms: "Send SMS",
-    delay: "Wait",
-    exit: "Exit",
-    condition: "Condition",
-    webhook: "Webhook",
-    update_contact: "Update Contact",
-    wait_for_event: "Wait for Event",
-    wait_for_email_engagement: "Wait for Email Engagement",
-    subscribe_topic: "Subscribe to Topic",
-    unsubscribe_topic: "Unsubscribe from Topic"
-  };
-  return names[type] || type;
-}
-function assignPositions(steps, transitions) {
-  const LEVEL_HEIGHT = 200;
-  const BRANCH_OFFSET = 300;
-  const childrenMap = /* @__PURE__ */ new Map();
-  for (const t of transitions) {
-    if (!childrenMap.has(t.fromStepId)) {
-      childrenMap.set(t.fromStepId, []);
-    }
-    childrenMap.get(t.fromStepId)?.push({
-      id: t.toStepId,
-      branch: t.condition?.branch
-    });
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [];
-  const triggerStep = steps.find((s) => s.type === "trigger");
-  if (triggerStep) {
-    queue.push({ stepId: triggerStep.id, level: 0, xOffset: 0 });
-  }
-  while (queue.length > 0) {
-    const { stepId, level, xOffset } = queue.shift();
-    if (visited.has(stepId)) {
-      continue;
-    }
-    visited.add(stepId);
-    const step = steps.find((s) => s.id === stepId);
-    if (step) {
-      step.position = {
-        x: xOffset,
-        y: level * LEVEL_HEIGHT
-      };
-    }
-    const children = childrenMap.get(stepId) || [];
-    for (const child of children) {
-      if (!visited.has(child.id)) {
-        let childXOffset = xOffset;
-        if (child.branch === "yes") {
-          childXOffset = xOffset - BRANCH_OFFSET;
-        } else if (child.branch === "no") {
-          childXOffset = xOffset + BRANCH_OFFSET;
-        }
-        queue.push({
-          stepId: child.id,
-          level: level + 1,
-          xOffset: childXOffset
-        });
-      }
-    }
-  }
-  for (const step of steps) {
-    if (!visited.has(step.id)) {
-      step.position = {
-        x: 600,
-        y: steps.indexOf(step) * LEVEL_HEIGHT
-      };
-    }
-  }
-}
-
-// src/utils/email/workflow-ts.ts
-init_esm_shims();
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync13 } from "fs";
-import { mkdir as mkdir7, readdir as readdir3, readFile as readFile7, writeFile as writeFile9 } from "fs/promises";
-import { basename, join as join14 } from "path";
-async function discoverWorkflows(dir, filter) {
-  if (!existsSync13(dir)) {
-    return [];
-  }
-  const entries = await readdir3(dir);
-  const workflows = entries.filter(
-    (f) => (
-      // Include .ts files only (not .tsx for workflows)
-      f.endsWith(".ts") && // Exclude private/helper files starting with _
-      !f.startsWith("_") && // Exclude type definition files
-      !f.endsWith(".d.ts")
-    )
-  );
-  if (filter) {
-    const slug = filter.replace(/\.ts$/, "");
-    return workflows.filter((f) => f.replace(/\.ts$/, "") === slug);
-  }
-  return workflows;
-}
-async function parseWorkflowTs(filePath, wrapsDir) {
-  const { build: build2 } = await import("esbuild");
-  const source = await readFile7(filePath, "utf-8");
-  const sourceHash = createHash2("sha256").update(source).digest("hex");
-  const slug = basename(filePath, ".ts");
-  const shimDir = join14(wrapsDir, ".wraps", "_shims");
-  await mkdir7(shimDir, { recursive: true });
-  const clientShimContent = `
-// Identity functions for workflow definitions
-export const defineWorkflow = (def) => def;
-
-// Step helper functions - they just create step definition objects
-export const sendEmail = (id, config) => ({
-  id,
-  type: 'send_email',
-  name: config.name ?? \`Send email: \${config.template || 'custom'}\`,
-  config: { type: 'send_email', ...config },
-});
+/**
+ * Welcome Sequence
+ *
+ * Send a welcome email when a contact is created,
+ * wait 1 day, then check if they activated.
+ * If not, send a follow-up with tips.
+ */
+export default defineWorkflow({
+  name: 'Welcome Sequence',
+  trigger: {
+    type: 'contact_created',
+  },
 
-export const sendSms = (id, config) => ({
-  id,
-  type: 'send_sms',
-  name: config.name ?? \`Send SMS: \${config.template || 'custom'}\`,
-  config: { type: 'send_sms', ...config },
+  steps: [
+    sendEmail('send-welcome', { template: 'welcome-email' }),
+    delay('wait-1-day', { days: 1 }),
+    condition('check-activated', {
+      field: 'contact.hasActivated',
+      operator: 'equals',
+      value: true,
+      branches: {
+        yes: [exit('already-active')],
+        no: [
+          sendEmail('send-tips', { template: 'getting-started-tips' }),
+        ],
+      },
+    }),
+  ],
 });
+`,
+  "cart-recovery": `import {
+  defineWorkflow,
+  sendEmail,
+  sendSms,
+  delay,
+  cascade,
+  exit,
+} from '@wraps.dev/client';
 
-export const delay = (id, duration) => {
-  const { name, ...durationConfig } = duration;
-  const normalized = normalizeDuration(durationConfig);
-  return {
-    id,
-    type: 'delay',
-    name: name ?? \`Wait \${normalized.amount} \${normalized.unit}\`,
-    config: { type: 'delay', ...normalized },
-  };
-};
-
-export const condition = (id, config) => {
-  const { branches, name, ...conditionConfig } = config;
-  return {
-    id,
-    type: 'condition',
-    name: name ?? \`Check: \${config.field} \${config.operator}\`,
-    config: { type: 'condition', ...conditionConfig },
-    branches,
-  };
-};
-
-export const waitForEvent = (id, config) => {
-  const { name, timeout, ...eventConfig } = config;
-  return {
-    id,
-    type: 'wait_for_event',
-    name: name ?? \`Wait for: \${config.eventName}\`,
-    config: {
-      type: 'wait_for_event',
-      eventName: eventConfig.eventName,
-      timeoutSeconds: durationToSeconds(timeout),
-    },
-  };
-};
-
-export const waitForEmailEngagement = (id, config) => {
-  const { name, timeout, emailStepId, engagementType } = config;
-  return {
-    id,
-    type: 'wait_for_email_engagement',
-    name: name ?? \`Wait for email \${engagementType}: \${emailStepId}\`,
-    config: {
-      type: 'wait_for_email_engagement',
-      timeoutSeconds: durationToSeconds(timeout),
-    },
-  };
-};
-
-export const exit = (id, config) => {
-  const { name, ...exitConfig } = config ?? {};
-  return {
-    id,
-    type: 'exit',
-    name: name ?? 'Exit',
-    config: { type: 'exit', ...exitConfig },
-  };
-};
-
-export const updateContact = (id, config) => {
-  const { name, ...updateConfig } = config;
-  return {
-    id,
-    type: 'update_contact',
-    name: name ?? 'Update contact',
-    config: { type: 'update_contact', ...updateConfig },
-  };
-};
+/**
+ * Cart Recovery Cascade
+ *
+ * When a cart is abandoned, wait 30 minutes, then try
+ * email first. If not opened after 2 hours, fall back to SMS.
+ */
+export default defineWorkflow({
+  name: 'Cart Recovery Cascade',
+  trigger: {
+    type: 'event',
+    eventName: 'cart.abandoned',
+  },
 
-export const subscribeTopic = (id, config) => {
-  const { name, ...topicConfig } = config;
-  return {
-    id,
-    type: 'subscribe_topic',
-    name: name ?? \`Subscribe to topic: \${config.topicId}\`,
-    config: { type: 'subscribe_topic', ...topicConfig },
-  };
-};
+  steps: [
+    delay('initial-wait', { minutes: 30 }),
 
-export const unsubscribeTopic = (id, config) => {
-  const { name, ...topicConfig } = config;
-  return {
-    id,
-    type: 'unsubscribe_topic',
-    name: name ?? \`Unsubscribe from topic: \${config.topicId}\`,
-    config: { type: 'unsubscribe_topic', ...topicConfig },
-  };
-};
+    ...cascade('recover-cart', {
+      channels: [
+        {
+          type: 'email',
+          template: 'cart-recovery',
+          waitFor: { hours: 2 },
+          engagement: 'opened',
+        },
+        {
+          type: 'sms',
+          template: 'cart-sms-reminder',
+        },
+      ],
+    }),
 
-export const webhook = (id, config) => {
-  const { name, ...webhookConfig } = config;
-  return {
-    id,
-    type: 'webhook',
-    name: name ?? \`Webhook: \${config.url}\`,
-    config: { type: 'webhook', method: 'POST', ...webhookConfig },
-  };
-};
+    exit('cascade-complete'),
+  ],
+});
+`,
+  "trial-conversion": `import {
+  defineWorkflow,
+  sendEmail,
+  delay,
+  condition,
+  exit,
+} from '@wraps.dev/client';
 
 /**
- * cascade(id, config) \u2014 expand a cross-channel cascade into primitive steps.
- *
- * For each email channel (except the last), we emit:
- *   send_email \u2192 wait_for_email_engagement \u2192 condition (engaged?)
- * with the condition's "yes" branch containing an exit node and the "no"
- * branch falling through to the next channel.
- *
- * Non-email channels (SMS) emit only a send step.
+ * Trial Conversion
  *
- * Every generated step carries cascadeGroupId = id so the execution
- * engine can scope engagement queries to the correct group.
+ * Remind users 3 days before their trial ends.
+ * If they haven't upgraded after 1 day, send a final nudge.
  */
-export const cascade = (id, config) => {
-  const channels = config.channels || [];
-  const steps = [];
-
-  for (let i = 0; i < channels.length; i++) {
-    const channel = channels[i];
-    const isLast = i === channels.length - 1;
+export default defineWorkflow({
+  name: 'Trial Conversion',
+  trigger: {
+    type: 'event',
+    eventName: 'trial.ending',
+  },
 
-    if (channel.type === 'email') {
-      // Send email step
-      steps.push({
-        id: id + '-send-' + i,
-        type: 'send_email',
-        name: 'Cascade: send ' + (channel.template || 'email'),
-        config: { type: 'send_email', templateId: channel.template },
-        cascadeGroupId: id,
-      });
+  steps: [
+    sendEmail('send-reminder', { template: 'trial-ending-reminder' }),
+    delay('wait-1-day', { days: 1 }),
+    condition('check-upgraded', {
+      field: 'contact.plan',
+      operator: 'not_equals',
+      value: 'free',
+      branches: {
+        yes: [exit('already-upgraded')],
+        no: [
+          sendEmail('send-upgrade-nudge', { template: 'upgrade-offer' }),
+        ],
+      },
+    }),
+  ],
+});
+`,
+  "re-engagement": `import {
+  defineWorkflow,
+  sendEmail,
+  delay,
+  condition,
+  exit,
+} from '@wraps.dev/client';
 
-      // If not last channel, add wait + condition
-      if (!isLast && channel.waitFor) {
-        const waitSeconds = durationToSeconds(channel.waitFor) || 259200;
-        const waitId = id + '-wait-' + i;
-        const condId = id + '-cond-' + i;
-        const exitId = id + '-exit-' + i;
+/**
+ * Re-engagement Campaign
+ *
+ * Win back inactive users with a personalized email.
+ * Wait 3 days for engagement, then send a final offer.
+ */
+export default defineWorkflow({
+  name: 'Re-engagement Campaign',
+  trigger: {
+    type: 'event',
+    eventName: 'contact.inactive',
+  },
 
-        // Wait for engagement step
-        steps.push({
-          id: waitId,
-          type: 'wait_for_email_engagement',
-          name: 'Cascade: wait for ' + (channel.engagement || 'opened'),
-          config: { type: 'wait_for_email_engagement', timeoutSeconds: waitSeconds },
-          cascadeGroupId: id,
-        });
-
-        // Condition step: check engagement.status
-        steps.push({
-          id: condId,
-          type: 'condition',
-          name: 'Cascade: email engaged?',
-          config: {
-            type: 'condition',
-            field: 'engagement.status',
-            operator: 'equals',
-            value: 'true',
-          },
-          cascadeGroupId: id,
-          branches: {
-            yes: [{
-              id: exitId,
-              type: 'exit',
-              name: 'Exit',
-              config: { type: 'exit', reason: 'Engaged via email' },
-              cascadeGroupId: id,
-            }],
-          },
-        });
-      }
-    } else if (channel.type === 'sms') {
-      // Send SMS step
-      steps.push({
-        id: id + '-send-' + i,
-        type: 'send_sms',
-        name: 'Cascade: send ' + (channel.template || 'sms'),
-        config: { type: 'send_sms', template: channel.template, body: channel.body },
-        cascadeGroupId: id,
-      });
-    }
-  }
-
-  return steps;
-};
-
-// Internal helpers
-function normalizeDuration(duration) {
-  if (duration.days !== undefined) {
-    return { amount: duration.days, unit: 'days' };
-  }
-  if (duration.hours !== undefined) {
-    return { amount: duration.hours, unit: 'hours' };
-  }
-  if (duration.minutes !== undefined) {
-    return { amount: duration.minutes, unit: 'minutes' };
-  }
-  return { amount: 1, unit: 'hours' };
-}
-
-function durationToSeconds(duration) {
-  if (!duration) return undefined;
-  let seconds = 0;
-  if (duration.days) seconds += duration.days * 24 * 60 * 60;
-  if (duration.hours) seconds += duration.hours * 60 * 60;
-  if (duration.minutes) seconds += duration.minutes * 60;
-  return seconds > 0 ? seconds : undefined;
-}
-`;
-  await writeFile9(
-    join14(shimDir, "wraps-client-shim.mjs"),
-    clientShimContent,
-    "utf-8"
-  );
-  const result = await build2({
-    entryPoints: [filePath],
-    bundle: true,
-    write: false,
-    format: "esm",
-    platform: "node",
-    target: "node20",
-    alias: {
-      "@wraps.dev/client": join14(shimDir, "wraps-client-shim.mjs")
-    }
-  });
-  const bundledCode = result.outputFiles[0].text;
-  const tmpDir = join14(wrapsDir, ".wraps", "_workflows");
-  await mkdir7(tmpDir, { recursive: true });
-  const tmpPath = join14(tmpDir, `${slug}.mjs`);
-  await writeFile9(tmpPath, bundledCode, "utf-8");
-  const mod = await import(`${tmpPath}?t=${Date.now()}`);
-  const definition = mod.default;
-  if (!definition || typeof definition !== "object") {
-    throw new Error(
-      "Workflow must have a default export (workflow definition from defineWorkflow())"
-    );
-  }
-  if (!definition.name) {
-    throw new Error("Workflow definition must have a 'name' property");
-  }
-  if (!definition.trigger) {
-    throw new Error("Workflow definition must have a 'trigger' property");
-  }
-  if (!Array.isArray(definition.steps)) {
-    throw new Error("Workflow definition must have a 'steps' array");
-  }
-  return {
-    slug,
-    filePath,
-    source,
-    sourceHash,
-    definition,
-    cliProjectPath: `workflows/${slug}.ts`
-  };
-}
-
-// src/utils/email/workflow-validator.ts
-init_esm_shims();
-function validateTransformedWorkflow(transformed, localTemplateSlugs) {
-  const errors2 = [];
-  errors2.push(...validateStructure(transformed.steps, transformed.transitions));
-  for (const step of transformed.steps) {
-    errors2.push(...validateStep(step));
-  }
-  if (localTemplateSlugs) {
-    errors2.push(
-      ...validateTemplateReferences(transformed.steps, localTemplateSlugs)
-    );
-  }
-  const errorsByNodeId = /* @__PURE__ */ new Map();
-  for (const error of errors2) {
-    if (error.nodeId) {
-      const existing = errorsByNodeId.get(error.nodeId) || [];
-      existing.push(error);
-      errorsByNodeId.set(error.nodeId, existing);
-    }
-  }
-  return {
-    isValid: errors2.filter((e) => e.severity === "error").length === 0,
-    errors: errors2,
-    errorsByNodeId
-  };
-}
-function validateStructure(steps, transitions) {
-  const errors2 = [];
-  const triggerSteps = steps.filter((s) => s.type === "trigger");
-  if (triggerSteps.length === 0) {
-    errors2.push({
-      message: "Workflow must have a trigger node",
-      severity: "error"
-    });
-  } else if (triggerSteps.length > 1) {
-    errors2.push({
-      message: "Workflow can only have one trigger node",
-      severity: "error"
-    });
-  }
-  const actionSteps = steps.filter(
-    (s) => s.type !== "trigger" && s.type !== "exit"
-  );
-  if (actionSteps.length === 0 && steps.length > 1) {
-    errors2.push({
-      message: "Workflow must have at least one action step",
-      severity: "error"
-    });
-  }
-  if (triggerSteps.length === 1) {
-    const reachableIds = getReachableNodeIds(triggerSteps[0].id, transitions);
-    const orphanSteps = steps.filter(
-      (s) => s.type !== "trigger" && !reachableIds.has(s.id)
-    );
-    for (const orphan of orphanSteps) {
-      errors2.push({
-        nodeId: orphan.id,
-        message: `"${orphan.name}" is not connected to the workflow`,
-        severity: "warning"
-      });
-    }
-  }
-  const stepIds = new Set(steps.map((s) => s.id));
-  for (const transition of transitions) {
-    if (!stepIds.has(transition.fromStepId)) {
-      errors2.push({
-        message: `Transition references non-existent source step: ${transition.fromStepId}`,
-        severity: "error"
-      });
-    }
-    if (!stepIds.has(transition.toStepId)) {
-      errors2.push({
-        message: `Transition references non-existent target step: ${transition.toStepId}`,
-        severity: "error"
-      });
-    }
-  }
-  return errors2;
-}
-function getReachableNodeIds(startId, transitions) {
-  const reachable = /* @__PURE__ */ new Set();
-  const queue = [startId];
-  while (queue.length > 0) {
-    const currentId = queue.shift();
-    if (reachable.has(currentId)) {
-      continue;
-    }
-    reachable.add(currentId);
-    const outgoing = transitions.filter((t) => t.fromStepId === currentId);
-    for (const t of outgoing) {
-      if (!reachable.has(t.toStepId)) {
-        queue.push(t.toStepId);
-      }
-    }
-  }
-  return reachable;
-}
-function validateStep(step) {
-  const errors2 = [];
-  const config2 = step.config;
-  const configType = config2.type;
-  switch (configType) {
-    case "trigger":
-      errors2.push(...validateTrigger(step.id, config2));
-      break;
-    case "send_email":
-      errors2.push(...validateSendEmail(step.id, config2));
-      break;
-    case "condition":
-      errors2.push(...validateCondition(step.id, config2));
-      break;
-    case "webhook":
-      errors2.push(...validateWebhook(step.id, config2));
-      break;
-    case "subscribe_topic":
-    case "unsubscribe_topic":
-      errors2.push(...validateTopic(step.id, config2));
-      break;
-    case "wait_for_event":
-      errors2.push(...validateWaitForEvent(step.id, config2));
-      break;
-    case "delay":
-      errors2.push(...validateDelay(step.id, config2));
-      break;
-  }
-  return errors2;
-}
-function validateTrigger(nodeId, config2) {
-  const errors2 = [];
-  switch (config2.triggerType) {
-    case "event":
-      if (!config2.eventName) {
-        errors2.push({
-          nodeId,
-          field: "eventName",
-          message: "Event name is required",
-          severity: "error"
-        });
-      }
-      break;
-    case "segment_entry":
-    case "segment_exit":
-      if (!config2.segmentId) {
-        errors2.push({
-          nodeId,
-          field: "segmentId",
-          message: "Segment is required",
-          severity: "error"
-        });
-      }
-      break;
-    case "topic_subscribed":
-    case "topic_unsubscribed":
-      if (!config2.topicId) {
-        errors2.push({
-          nodeId,
-          field: "topicId",
-          message: "Topic is required",
-          severity: "error"
-        });
-      }
-      break;
-    case "schedule":
-      if (!config2.schedule) {
-        errors2.push({
-          nodeId,
-          field: "schedule",
-          message: "Schedule (cron expression) is required",
-          severity: "error"
-        });
-      }
-      if (!config2.timezone) {
-        errors2.push({
-          nodeId,
-          field: "timezone",
-          message: "Timezone is required",
-          severity: "error"
-        });
-      }
-      break;
-  }
-  return errors2;
-}
-function validateSendEmail(nodeId, config2) {
-  const errors2 = [];
-  const templateRef = config2.templateId || config2.template;
-  if (!templateRef) {
-    errors2.push({
-      nodeId,
-      field: "templateId",
-      message: "Email template is required",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateCondition(nodeId, config2) {
-  const errors2 = [];
-  if (!config2.field) {
-    errors2.push({
-      nodeId,
-      field: "field",
-      message: "Condition field is required",
-      severity: "error"
-    });
-  }
-  if (!config2.operator) {
-    errors2.push({
-      nodeId,
-      field: "operator",
-      message: "Condition operator is required",
-      severity: "error"
-    });
-  }
-  if (config2.operator !== "is_set" && config2.operator !== "is_not_set" && config2.operator !== "is_true" && config2.operator !== "is_false" && (config2.value === void 0 || config2.value === "")) {
-    errors2.push({
-      nodeId,
-      field: "value",
-      message: "Condition value is required",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateWebhook(nodeId, config2) {
-  const errors2 = [];
-  if (config2.url) {
-    try {
-      new URL(config2.url);
-    } catch {
-      errors2.push({
-        nodeId,
-        field: "url",
-        message: "Invalid URL format",
-        severity: "error"
-      });
-    }
-  } else {
-    errors2.push({
-      nodeId,
-      field: "url",
-      message: "Webhook URL is required",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateTopic(nodeId, config2) {
-  const errors2 = [];
-  if (!config2.topicId) {
-    errors2.push({
-      nodeId,
-      field: "topicId",
-      message: "Topic is required",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateWaitForEvent(nodeId, config2) {
-  const errors2 = [];
-  if (!config2.eventName) {
-    errors2.push({
-      nodeId,
-      field: "eventName",
-      message: "Event name is required",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateDelay(nodeId, config2) {
-  const errors2 = [];
-  const amount = config2.amount;
-  if (!amount || amount < 1) {
-    errors2.push({
-      nodeId,
-      field: "amount",
-      message: "Delay duration must be at least 1",
-      severity: "error"
-    });
-  }
-  return errors2;
-}
-function validateTemplateReferences(steps, localTemplateSlugs) {
-  const errors2 = [];
-  for (const step of steps) {
-    if (step.config.type === "send_email") {
-      const config2 = step.config;
-      const templateRef = config2.templateId || config2.template;
-      if (templateRef && !localTemplateSlugs.has(templateRef)) {
-        errors2.push({
-          nodeId: step.id,
-          field: "templateId",
-          message: `Template "${templateRef}" not found in templates/ directory`,
-          severity: "error"
-        });
-      }
-    }
-    if (step.config.type === "send_sms") {
-      const config2 = step.config;
-      const templateRef = config2.templateId || config2.template;
-      if (templateRef && !localTemplateSlugs.has(templateRef)) {
-        errors2.push({
-          nodeId: step.id,
-          field: "templateId",
-          message: `SMS template "${templateRef}" not found in templates/ directory`,
-          severity: "warning"
-          // Warning for SMS since we might not have SMS templates yet
-        });
-      }
-    }
-  }
-  return errors2;
-}
-
-// src/commands/email/workflows/generate.ts
-init_config();
-init_errors();
-init_json_output();
-init_output();
-var TEMPLATES = {
-  welcome: `import {
+  steps: [
+    sendEmail('send-win-back', { template: 'we-miss-you' }),
+    delay('wait-3-days', { days: 3 }),
+    condition('check-engaged', {
+      field: 'contact.lastActiveAt',
+      operator: 'is_set',
+      value: true,
+      branches: {
+        yes: [exit('re-engaged')],
+        no: [
+          sendEmail('send-final-offer', { template: 'final-offer' }),
+        ],
+      },
+    }),
+  ],
+});
+`,
+  onboarding: `import {
   defineWorkflow,
   sendEmail,
   delay,
@@ -25589,196 +24896,38 @@ var TEMPLATES = {
 } from '@wraps.dev/client';
 
 /**
- * Welcome Sequence
+ * Multi-step Onboarding
  *
- * Send a welcome email when a contact is created,
- * wait 1 day, then check if they activated.
- * If not, send a follow-up with tips.
+ * Guide new users through setup with a series of emails.
+ * Check progress at each step and skip ahead if they're done.
  */
 export default defineWorkflow({
-  name: 'Welcome Sequence',
+  name: 'Onboarding Sequence',
   trigger: {
     type: 'contact_created',
   },
 
   steps: [
-    sendEmail('send-welcome', { template: 'welcome-email' }),
+    sendEmail('send-welcome', { template: 'onboarding-welcome' }),
     delay('wait-1-day', { days: 1 }),
-    condition('check-activated', {
-      field: 'contact.hasActivated',
+
+    condition('check-profile-complete', {
+      field: 'contact.profileComplete',
       operator: 'equals',
       value: true,
       branches: {
-        yes: [exit('already-active')],
+        yes: [
+          sendEmail('send-next-steps', { template: 'onboarding-next-steps' }),
+        ],
         no: [
-          sendEmail('send-tips', { template: 'getting-started-tips' }),
+          sendEmail('send-profile-reminder', { template: 'complete-your-profile' }),
+          delay('wait-2-days', { days: 2 }),
+          sendEmail('send-next-steps-delayed', { template: 'onboarding-next-steps' }),
         ],
       },
     }),
-  ],
-});
-`,
-  "cart-recovery": `import {
-  defineWorkflow,
-  sendEmail,
-  sendSms,
-  delay,
-  cascade,
-  exit,
-} from '@wraps.dev/client';
-
-/**
- * Cart Recovery Cascade
- *
- * When a cart is abandoned, wait 30 minutes, then try
- * email first. If not opened after 2 hours, fall back to SMS.
- */
-export default defineWorkflow({
-  name: 'Cart Recovery Cascade',
-  trigger: {
-    type: 'event',
-    eventName: 'cart.abandoned',
-  },
 
-  steps: [
-    delay('initial-wait', { minutes: 30 }),
-
-    ...cascade('recover-cart', {
-      channels: [
-        {
-          type: 'email',
-          template: 'cart-recovery',
-          waitFor: { hours: 2 },
-          engagement: 'opened',
-        },
-        {
-          type: 'sms',
-          template: 'cart-sms-reminder',
-        },
-      ],
-    }),
-
-    exit('cascade-complete'),
-  ],
-});
-`,
-  "trial-conversion": `import {
-  defineWorkflow,
-  sendEmail,
-  delay,
-  condition,
-  exit,
-} from '@wraps.dev/client';
-
-/**
- * Trial Conversion
- *
- * Remind users 3 days before their trial ends.
- * If they haven't upgraded after 1 day, send a final nudge.
- */
-export default defineWorkflow({
-  name: 'Trial Conversion',
-  trigger: {
-    type: 'event',
-    eventName: 'trial.ending',
-  },
-
-  steps: [
-    sendEmail('send-reminder', { template: 'trial-ending-reminder' }),
-    delay('wait-1-day', { days: 1 }),
-    condition('check-upgraded', {
-      field: 'contact.plan',
-      operator: 'not_equals',
-      value: 'free',
-      branches: {
-        yes: [exit('already-upgraded')],
-        no: [
-          sendEmail('send-upgrade-nudge', { template: 'upgrade-offer' }),
-        ],
-      },
-    }),
-  ],
-});
-`,
-  "re-engagement": `import {
-  defineWorkflow,
-  sendEmail,
-  delay,
-  condition,
-  exit,
-} from '@wraps.dev/client';
-
-/**
- * Re-engagement Campaign
- *
- * Win back inactive users with a personalized email.
- * Wait 3 days for engagement, then send a final offer.
- */
-export default defineWorkflow({
-  name: 'Re-engagement Campaign',
-  trigger: {
-    type: 'event',
-    eventName: 'contact.inactive',
-  },
-
-  steps: [
-    sendEmail('send-win-back', { template: 'we-miss-you' }),
-    delay('wait-3-days', { days: 3 }),
-    condition('check-engaged', {
-      field: 'contact.lastActiveAt',
-      operator: 'is_set',
-      value: true,
-      branches: {
-        yes: [exit('re-engaged')],
-        no: [
-          sendEmail('send-final-offer', { template: 'final-offer' }),
-        ],
-      },
-    }),
-  ],
-});
-`,
-  onboarding: `import {
-  defineWorkflow,
-  sendEmail,
-  delay,
-  condition,
-  exit,
-} from '@wraps.dev/client';
-
-/**
- * Multi-step Onboarding
- *
- * Guide new users through setup with a series of emails.
- * Check progress at each step and skip ahead if they're done.
- */
-export default defineWorkflow({
-  name: 'Onboarding Sequence',
-  trigger: {
-    type: 'contact_created',
-  },
-
-  steps: [
-    sendEmail('send-welcome', { template: 'onboarding-welcome' }),
-    delay('wait-1-day', { days: 1 }),
-
-    condition('check-profile-complete', {
-      field: 'contact.profileComplete',
-      operator: 'equals',
-      value: true,
-      branches: {
-        yes: [
-          sendEmail('send-next-steps', { template: 'onboarding-next-steps' }),
-        ],
-        no: [
-          sendEmail('send-profile-reminder', { template: 'complete-your-profile' }),
-          delay('wait-2-days', { days: 2 }),
-          sendEmail('send-next-steps-delayed', { template: 'onboarding-next-steps' }),
-        ],
-      },
-    }),
-
-    delay('wait-3-days', { days: 3 }),
+    delay('wait-3-days', { days: 3 }),
 
     condition('check-first-action', {
       field: 'contact.hasCompletedFirstAction',
@@ -25800,8 +24949,6 @@ async function workflowsGenerate(options) {
   const startTime = Date.now();
   if (options.template) {
     generateFromTemplate(options);
-  } else if (options.description) {
-    await generateFromDescription(options);
   } else {
     showUsage();
     return;
@@ -25809,31 +24956,34 @@ async function workflowsGenerate(options) {
   trackCommand("email:workflows:generate", {
     success: true,
     duration_ms: Date.now() - startTime,
-    mode: options.template ? "template" : "llm"
+    mode: "template"
   });
 }
 function showUsage() {
   if (isJsonMode()) {
     jsonError("email.workflows.generate", {
       code: "MISSING_INPUT",
-      message: "Provide a --template name or a description as a positional argument"
+      message: "Provide a --template name to generate a workflow"
     });
     return;
   }
-  log29.error("Provide a description or use --template to generate a workflow.");
+  log29.error("Provide a --template to generate a workflow.");
   console.log();
-  console.log(`  ${pc31.bold("Template mode:")}`);
+  console.log(`  ${pc31.bold("Usage:")}`);
   console.log(
     `    ${pc31.cyan("wraps email workflows generate --template welcome")}`
   );
   console.log();
-  console.log(`  ${pc31.bold("AI mode:")}`);
   console.log(
-    `    ${pc31.cyan('wraps email workflows generate "Welcome series: send welcome on signup, wait 1 day, check activation"')}`
+    `  ${pc31.bold("Available templates:")} ${TEMPLATE_NAMES.join(", ")}`
   );
   console.log();
+  console.log(`  ${pc31.bold("Want a custom workflow?")}`);
   console.log(
-    `  ${pc31.bold("Available templates:")} ${TEMPLATE_NAMES.join(", ")}`
+    "    Describe what you need to your AI coding assistant (Claude Code, Cursor, etc.)"
+  );
+  console.log(
+    `    and it will generate a workflow file using the ${pc31.cyan("@wraps.dev/client")} DSL.`
   );
   console.log();
 }
@@ -25858,9 +25008,9 @@ function generateFromTemplate(options) {
   }
   const slug = options.name || templateName;
   const cwd = process.cwd();
-  const workflowsDir = join15(cwd, "wraps", "workflows");
-  const filePath = join15(workflowsDir, `${slug}.ts`);
-  if (existsSync14(filePath) && !options.force) {
+  const workflowsDir = join14(cwd, "wraps", "workflows");
+  const filePath = join14(workflowsDir, `${slug}.ts`);
+  if (existsSync13(filePath) && !options.force) {
     if (isJsonMode()) {
       jsonError("email.workflows.generate", {
         code: "FILE_EXISTS",
@@ -25890,195 +25040,27 @@ function generateFromTemplate(options) {
     showNextSteps2(slug);
   }
 }
-async function generateFromDescription(options) {
-  const description = options.description ?? "";
-  const slug = options.name || slugify(description);
-  if (!checkFileExists(slug, options.force)) {
-    return;
-  }
-  if (!isJsonMode()) {
-    intro27(pc31.bold("Generate Workflow"));
-  }
-  const progress = new DeploymentProgress();
-  const token = await resolveTokenAsync({ token: options.token });
-  if (!token) {
-    throw errors.notAuthenticated();
-  }
-  const code = await callGenerateApi(description, slug, token, progress);
-  if (!code) {
-    return;
-  }
-  if (options.dryRun) {
-    showDryRun(slug, code);
-    return;
-  }
-  if (!(options.yes || isJsonMode())) {
-    const shouldWrite = await showPreviewAndConfirm(slug, code);
-    if (!shouldWrite) {
-      return;
-    }
-  }
-  writeWorkflowFile(slug, code);
-  const workflowsDir = join15(process.cwd(), "wraps", "workflows");
-  const filePath = join15(workflowsDir, `${slug}.ts`);
-  await autoValidate(filePath, join15(process.cwd(), "wraps"), slug, progress);
-  if (isJsonMode()) {
-    jsonSuccess("email.workflows.generate", {
-      mode: "llm",
-      slug,
-      path: `wraps/workflows/${slug}.ts`
-    });
-  } else {
-    log29.success(`Created ${pc31.cyan(`wraps/workflows/${slug}.ts`)}`);
-    showNextSteps2(slug, true);
-  }
-}
-function slugify(text9) {
-  return text9.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function checkFileExists(slug, force) {
-  const filePath = join15(process.cwd(), "wraps", "workflows", `${slug}.ts`);
-  if (existsSync14(filePath) && !force) {
-    if (isJsonMode()) {
-      jsonError("email.workflows.generate", {
-        code: "FILE_EXISTS",
-        message: `wraps/workflows/${slug}.ts already exists. Use --force to overwrite.`
-      });
-    } else {
-      log29.error(
-        `${pc31.cyan(`wraps/workflows/${slug}.ts`)} already exists. Use ${pc31.bold("--force")} to overwrite.`
-      );
-    }
-    return false;
-  }
-  return true;
-}
-async function callGenerateApi(description, slug, token, progress) {
-  progress.start("Generating workflow from description");
-  const apiBase = getApiBaseUrl();
-  const resp = await fetch(`${apiBase}/v1/workflows/generate`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ description, slug })
-  });
-  if (!resp.ok) {
-    progress.fail("Generation failed");
-    if (resp.status === 429) {
-      throw errors.aiUsageLimitReached();
-    }
-    const body = await resp.text();
-    let message;
-    try {
-      const parsed = JSON.parse(body);
-      message = parsed.error || parsed.message || body;
-    } catch (e) {
-      if (e instanceof SyntaxError) {
-        message = body;
-      } else {
-        throw e;
-      }
-    }
-    throw errors.workflowGenerationFailed(message);
-  }
-  const data = await resp.json();
-  progress.succeed("Workflow generated");
-  return data.code;
-}
-function showDryRun(slug, code) {
-  if (isJsonMode()) {
-    jsonSuccess("email.workflows.generate", {
-      mode: "llm",
-      dryRun: true,
-      slug,
-      code
-    });
-  } else {
-    console.log();
-    log29.info(pc31.bold("Dry run \u2014 no file written"));
-    console.log();
-    console.log(pc31.dim("\u2500".repeat(60)));
-    console.log(code);
-    console.log(pc31.dim("\u2500".repeat(60)));
-    console.log();
-  }
-}
-async function showPreviewAndConfirm(slug, code) {
-  console.log();
-  console.log(pc31.dim("\u2500".repeat(60)));
-  console.log(code);
-  console.log(pc31.dim("\u2500".repeat(60)));
-  console.log();
-  const confirmed = await confirm14({
-    message: `Write to ${pc31.cyan(`wraps/workflows/${slug}.ts`)}?`,
-    initialValue: true
-  });
-  if (isCancel20(confirmed) || !confirmed) {
-    cancel21("Generation cancelled.");
-    return false;
-  }
-  return true;
-}
-function writeWorkflowFile(slug, code) {
-  const workflowsDir = join15(process.cwd(), "wraps", "workflows");
-  mkdirSync2(workflowsDir, { recursive: true });
-  writeFileSync(join15(workflowsDir, `${slug}.ts`), code, "utf-8");
-}
-function showNextSteps2(slug, isLlm = false) {
+function showNextSteps2(slug) {
   console.log();
   console.log(`  ${pc31.bold("Next steps:")}`);
-  if (isLlm) {
-    console.log(
-      `    1. Review the generated workflow in ${pc31.cyan(`wraps/workflows/${slug}.ts`)}`
-    );
-  } else {
-    console.log(
-      `    1. Edit template references in ${pc31.cyan(`wraps/workflows/${slug}.ts`)}`
-    );
-  }
+  console.log(
+    `    1. Edit template references in ${pc31.cyan(`wraps/workflows/${slug}.ts`)}`
+  );
   console.log(
     `    2. Validate: ${pc31.cyan(`wraps email workflows validate --workflow ${slug}`)}`
   );
   console.log(`    3. Push:     ${pc31.cyan("wraps email workflows push")}`);
   console.log();
 }
-async function autoValidate(filePath, wrapsDir, slug, progress) {
-  try {
-    progress.start(`Validating ${pc31.cyan(slug)}`);
-    const parsed = await parseWorkflowTs(filePath, wrapsDir);
-    const transformed = transformWorkflow(parsed.definition);
-    const result = validateTransformedWorkflow(transformed);
-    const errs = result.errors.filter((e) => e.severity === "error");
-    const warnings = result.errors.filter((e) => e.severity === "warning");
-    if (errs.length === 0 && warnings.length === 0) {
-      progress.succeed(`${pc31.cyan(slug)} is valid`);
-    } else if (errs.length === 0) {
-      progress.succeed(
-        `${pc31.cyan(slug)} is valid with ${warnings.length} warning(s)`
-      );
-    } else {
-      progress.fail(
-        `${pc31.cyan(slug)} has ${errs.length} validation error(s) \u2014 review and fix manually`
-      );
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    progress.info(
-      `Could not auto-validate ${pc31.cyan(slug)} \u2014 run ${pc31.cyan("wraps email workflows validate")} manually (${msg})`
-    );
-  }
-}
 
 // src/commands/email/workflows/init.ts
 init_esm_shims();
 init_events();
 init_json_output();
 init_output();
-import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile10 } from "fs/promises";
-import { join as join16 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile9 } from "fs/promises";
+import { join as join15 } from "path";
 import * as clack30 from "@clack/prompts";
 import pc32 from "picocolors";
 
@@ -26415,188 +25397,1024 @@ export default defineWorkflow({
       ],
     }),
 
-    exit('cascade-complete'),
-  ],
-});
-\`\`\`
+    exit('cascade-complete'),
+  ],
+});
+\`\`\`
+
+## Key Commands
+
+\`\`\`bash
+wraps email workflows validate                     # Validate all workflow files
+wraps email workflows validate --workflow welcome   # Validate a specific workflow
+wraps email workflows push                         # Push workflows to dashboard
+wraps email workflows generate --template welcome  # Generate from built-in template
+wraps email workflows generate "description..."    # Generate from AI description
+\`\`\`
+`;
+
+// src/commands/email/workflows/init.ts
+var EXAMPLE_WORKFLOW = `import {
+  defineWorkflow,
+  sendEmail,
+  delay,
+  condition,
+  exit,
+} from '@wraps.dev/client';
+
+/**
+ * Welcome Sequence
+ *
+ * Send a welcome email when a contact is created,
+ * wait 1 day, then check if they activated.
+ * If not, send a follow-up with tips.
+ */
+export default defineWorkflow({
+  name: 'Welcome Sequence',
+  trigger: {
+    type: 'contact_created',
+  },
+
+  steps: [
+    sendEmail('send-welcome', { template: 'welcome-email' }),
+    delay('wait-1-day', { days: 1 }),
+    condition('check-activated', {
+      field: 'contact.hasActivated',
+      operator: 'equals',
+      value: true,
+      branches: {
+        yes: [exit('already-active')],
+        no: [
+          sendEmail('send-tips', { template: 'getting-started-tips' }),
+        ],
+      },
+    }),
+  ],
+});
+`;
+async function workflowsInit(options) {
+  const startTime = Date.now();
+  const cwd = process.cwd();
+  const workflowsDir = join15(cwd, "wraps", "workflows");
+  if (!isJsonMode()) {
+    clack30.intro(pc32.bold("Workflows as Code"));
+  }
+  const progress = new DeploymentProgress();
+  if (existsSync14(workflowsDir) && !options.force) {
+    const { readdir: readdir4 } = await import("fs/promises");
+    const files = await readdir4(workflowsDir);
+    const tsFiles = files.filter(
+      (f) => f.endsWith(".ts") && !f.startsWith("_")
+    );
+    if (tsFiles.length > 0 && !options.force && !isJsonMode()) {
+      clack30.log.warn(
+        `${pc32.cyan("wraps/workflows/")} already contains ${tsFiles.length} workflow file(s). Use ${pc32.bold("--force")} to overwrite.`
+      );
+    }
+  }
+  progress.start("Creating wraps/workflows/ directory");
+  await mkdir7(workflowsDir, { recursive: true });
+  const configPath = join15(cwd, "wraps", "wraps.config.ts");
+  if (existsSync14(configPath)) {
+    const configContent = await readFile7(configPath, "utf-8");
+    if (!configContent.includes("workflowsDir")) {
+      const updated = configContent.replace(
+        /}\);(\s*)$/,
+        `  workflowsDir: './workflows',
+});$1`
+      );
+      if (updated !== configContent) {
+        await writeFile9(configPath, updated, "utf-8");
+      }
+    }
+  } else {
+    await writeFile9(configPath, generateMinimalConfig(), "utf-8");
+  }
+  const filesCreated = [];
+  if (!options.noExample) {
+    const examplePath = join15(workflowsDir, "welcome.ts");
+    if (!existsSync14(examplePath) || options.force) {
+      await writeFile9(examplePath, EXAMPLE_WORKFLOW, "utf-8");
+      filesCreated.push("wraps/workflows/welcome.ts");
+    }
+  }
+  progress.succeed("Workflows directory ready");
+  if (!options.noClaude) {
+    try {
+      progress.start("Scaffolding Claude Code context");
+      await scaffoldClaudeMdSection({
+        projectDir: cwd,
+        sectionId: "workflows",
+        sectionContent: WORKFLOWS_CLAUDE_MD_SECTION
+      });
+      filesCreated.push(".claude/CLAUDE.md");
+      await scaffoldClaudeSkill({
+        projectDir: cwd,
+        skillName: "wraps-workflows",
+        skillContent: WORKFLOWS_SKILL_CONTENT
+      });
+      filesCreated.push(".claude/skills/wraps-workflows/SKILL.md");
+      progress.succeed("Claude Code context scaffolded");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      progress.info(
+        `Could not scaffold .claude/ context \u2014 workflow files are still ready (${msg})`
+      );
+    }
+  }
+  trackCommand("email:workflows:init", {
+    success: true,
+    duration_ms: Date.now() - startTime
+  });
+  if (isJsonMode()) {
+    jsonSuccess("email.workflows.init", {
+      dir: "wraps/workflows",
+      files: filesCreated
+    });
+    return;
+  }
+  console.log();
+  clack30.log.success(pc32.green("Workflows as Code initialized!"));
+  console.log();
+  console.log(`  ${pc32.dim("Directory:")}  ${pc32.cyan("wraps/workflows/")}`);
+  if (!options.noExample) {
+    console.log(
+      `  ${pc32.dim("Example:")}    ${pc32.cyan("wraps/workflows/welcome.ts")}`
+    );
+  }
+  if (!options.noClaude) {
+    console.log(
+      `  ${pc32.dim("AI Context:")} ${pc32.cyan(".claude/skills/wraps-workflows/")}`
+    );
+  }
+  console.log();
+  console.log(`${pc32.bold("Next steps:")}`);
+  console.log(
+    `  1. Edit or create workflows in ${pc32.cyan("wraps/workflows/")}`
+  );
+  console.log(`  2. Validate: ${pc32.cyan("wraps email workflows validate")}`);
+  console.log(`  3. Push:     ${pc32.cyan("wraps email workflows push")}`);
+  if (!options.noClaude) {
+    console.log("  4. Use Claude Code to generate workflows from descriptions");
+  }
+  console.log();
+}
+function generateMinimalConfig() {
+  return `import { defineConfig } from '@wraps.dev/client';
+
+export default defineConfig({
+  org: 'my-org',
+  // from: { email: 'hello@yourapp.com', name: 'My App' },
+  // region: 'us-east-1',
+  templatesDir: './templates',
+  workflowsDir: './workflows',
+});
+`;
+}
+
+// src/commands/email/workflows/push.ts
+init_esm_shims();
+init_events();
+import { existsSync as existsSync16 } from "fs";
+import { join as join17 } from "path";
+import * as clack31 from "@clack/prompts";
+import pc33 from "picocolors";
+
+// src/utils/email/workflow-transform.ts
+init_esm_shims();
+function transformWorkflow(definition) {
+  const steps = [];
+  const transitions = [];
+  const triggerStep = createTriggerStep(definition.trigger);
+  steps.push(triggerStep);
+  if (definition.steps.length > 0) {
+    flattenSteps(definition.steps, steps, transitions, triggerStep.id, null);
+  }
+  assignPositions(steps, transitions);
+  return {
+    steps,
+    transitions,
+    triggerType: definition.trigger.type,
+    triggerConfig: extractTriggerConfig(definition.trigger),
+    settings: definition.settings,
+    defaults: definition.defaults
+  };
+}
+function createTriggerStep(trigger) {
+  const triggerConfig = {
+    type: "trigger",
+    triggerType: trigger.type,
+    ...extractTriggerConfig(trigger)
+  };
+  return {
+    id: "trigger",
+    type: "trigger",
+    name: getTriggerName(trigger.type),
+    position: { x: 0, y: 0 },
+    // Will be updated by assignPositions
+    config: triggerConfig
+  };
+}
+function extractTriggerConfig(trigger) {
+  const config2 = {};
+  if (trigger.eventName) {
+    config2.eventName = trigger.eventName;
+  }
+  if (trigger.segmentId) {
+    config2.segmentId = trigger.segmentId;
+  }
+  if (trigger.schedule) {
+    config2.schedule = trigger.schedule;
+  }
+  if (trigger.timezone) {
+    config2.timezone = trigger.timezone;
+  }
+  if (trigger.topicId) {
+    config2.topicId = trigger.topicId;
+  }
+  return config2;
+}
+function getTriggerName(type) {
+  const names = {
+    event: "When event occurs",
+    contact_created: "When contact is created",
+    contact_updated: "When contact is updated",
+    segment_entry: "When contact enters segment",
+    segment_exit: "When contact exits segment",
+    schedule: "On schedule",
+    api: "When triggered via API",
+    topic_subscribed: "When contact subscribes to topic",
+    topic_unsubscribed: "When contact unsubscribes from topic"
+  };
+  return names[type] || "Trigger";
+}
+function flattenSteps(stepDefs, steps, transitions, fromStepId, branch) {
+  let prevIds = [fromStepId];
+  let firstStepInBranch = true;
+  for (const def of stepDefs) {
+    const step = toWorkflowStep(def);
+    steps.push(step);
+    for (const prevId of prevIds) {
+      const transition = {
+        id: `t-${prevId}-${step.id}`,
+        fromStepId: prevId,
+        toStepId: step.id
+      };
+      if (firstStepInBranch && branch && prevId === fromStepId) {
+        transition.condition = { branch };
+      }
+      transitions.push(transition);
+    }
+    firstStepInBranch = false;
+    if (def.type === "condition" && def.branches) {
+      const leafIds = [];
+      if (def.branches.yes && def.branches.yes.length > 0) {
+        const yesLeaves = flattenSteps(
+          def.branches.yes,
+          steps,
+          transitions,
+          step.id,
+          "yes"
+        );
+        leafIds.push(...yesLeaves);
+      } else {
+        leafIds.push(step.id);
+      }
+      if (def.branches.no && def.branches.no.length > 0) {
+        const noLeaves = flattenSteps(
+          def.branches.no,
+          steps,
+          transitions,
+          step.id,
+          "no"
+        );
+        leafIds.push(...noLeaves);
+      } else if (!leafIds.includes(step.id)) {
+        leafIds.push(step.id);
+      }
+      prevIds = leafIds;
+      continue;
+    }
+    if (def.type === "exit") {
+      prevIds = [];
+      continue;
+    }
+    prevIds = [step.id];
+  }
+  return prevIds;
+}
+function toWorkflowStep(def) {
+  const step = {
+    id: def.id,
+    type: def.type,
+    name: def.name || getDefaultStepName(def.type),
+    position: { x: 0, y: 0 },
+    // Will be updated by assignPositions
+    config: def.config
+  };
+  if (def.cascadeGroupId) {
+    step.cascadeGroupId = def.cascadeGroupId;
+  }
+  return step;
+}
+function getDefaultStepName(type) {
+  const names = {
+    send_email: "Send Email",
+    send_sms: "Send SMS",
+    delay: "Wait",
+    exit: "Exit",
+    condition: "Condition",
+    webhook: "Webhook",
+    update_contact: "Update Contact",
+    wait_for_event: "Wait for Event",
+    wait_for_email_engagement: "Wait for Email Engagement",
+    subscribe_topic: "Subscribe to Topic",
+    unsubscribe_topic: "Unsubscribe from Topic"
+  };
+  return names[type] || type;
+}
+function assignPositions(steps, transitions) {
+  const LEVEL_HEIGHT = 200;
+  const BRANCH_OFFSET = 300;
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const t of transitions) {
+    if (!childrenMap.has(t.fromStepId)) {
+      childrenMap.set(t.fromStepId, []);
+    }
+    childrenMap.get(t.fromStepId)?.push({
+      id: t.toStepId,
+      branch: t.condition?.branch
+    });
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  const triggerStep = steps.find((s) => s.type === "trigger");
+  if (triggerStep) {
+    queue.push({ stepId: triggerStep.id, level: 0, xOffset: 0 });
+  }
+  while (queue.length > 0) {
+    const { stepId, level, xOffset } = queue.shift();
+    if (visited.has(stepId)) {
+      continue;
+    }
+    visited.add(stepId);
+    const step = steps.find((s) => s.id === stepId);
+    if (step) {
+      step.position = {
+        x: xOffset,
+        y: level * LEVEL_HEIGHT
+      };
+    }
+    const children = childrenMap.get(stepId) || [];
+    for (const child of children) {
+      if (!visited.has(child.id)) {
+        let childXOffset = xOffset;
+        if (child.branch === "yes") {
+          childXOffset = xOffset - BRANCH_OFFSET;
+        } else if (child.branch === "no") {
+          childXOffset = xOffset + BRANCH_OFFSET;
+        }
+        queue.push({
+          stepId: child.id,
+          level: level + 1,
+          xOffset: childXOffset
+        });
+      }
+    }
+  }
+  for (const step of steps) {
+    if (!visited.has(step.id)) {
+      step.position = {
+        x: 600,
+        y: steps.indexOf(step) * LEVEL_HEIGHT
+      };
+    }
+  }
+}
+
+// src/utils/email/workflow-ts.ts
+init_esm_shims();
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync15 } from "fs";
+import { mkdir as mkdir8, readdir as readdir3, readFile as readFile8, writeFile as writeFile10 } from "fs/promises";
+import { basename, join as join16 } from "path";
+async function discoverWorkflows(dir, filter) {
+  if (!existsSync15(dir)) {
+    return [];
+  }
+  const entries = await readdir3(dir);
+  const workflows = entries.filter(
+    (f) => (
+      // Include .ts files only (not .tsx for workflows)
+      f.endsWith(".ts") && // Exclude private/helper files starting with _
+      !f.startsWith("_") && // Exclude type definition files
+      !f.endsWith(".d.ts")
+    )
+  );
+  if (filter) {
+    const slug = filter.replace(/\.ts$/, "");
+    return workflows.filter((f) => f.replace(/\.ts$/, "") === slug);
+  }
+  return workflows;
+}
+async function parseWorkflowTs(filePath, wrapsDir) {
+  const { build: build2 } = await import("esbuild");
+  const source = await readFile8(filePath, "utf-8");
+  const sourceHash = createHash2("sha256").update(source).digest("hex");
+  const slug = basename(filePath, ".ts");
+  const shimDir = join16(wrapsDir, ".wraps", "_shims");
+  await mkdir8(shimDir, { recursive: true });
+  const clientShimContent = `
+// Identity functions for workflow definitions
+export const defineWorkflow = (def) => def;
+
+// Step helper functions - they just create step definition objects
+export const sendEmail = (id, config) => ({
+  id,
+  type: 'send_email',
+  name: config.name ?? \`Send email: \${config.template || 'custom'}\`,
+  config: { type: 'send_email', ...config },
+});
+
+export const sendSms = (id, config) => ({
+  id,
+  type: 'send_sms',
+  name: config.name ?? \`Send SMS: \${config.template || 'custom'}\`,
+  config: { type: 'send_sms', ...config },
+});
+
+export const delay = (id, duration) => {
+  const { name, ...durationConfig } = duration;
+  const normalized = normalizeDuration(durationConfig);
+  return {
+    id,
+    type: 'delay',
+    name: name ?? \`Wait \${normalized.amount} \${normalized.unit}\`,
+    config: { type: 'delay', ...normalized },
+  };
+};
+
+export const condition = (id, config) => {
+  const { branches, name, ...conditionConfig } = config;
+  return {
+    id,
+    type: 'condition',
+    name: name ?? \`Check: \${config.field} \${config.operator}\`,
+    config: { type: 'condition', ...conditionConfig },
+    branches,
+  };
+};
+
+export const waitForEvent = (id, config) => {
+  const { name, timeout, ...eventConfig } = config;
+  return {
+    id,
+    type: 'wait_for_event',
+    name: name ?? \`Wait for: \${config.eventName}\`,
+    config: {
+      type: 'wait_for_event',
+      eventName: eventConfig.eventName,
+      timeoutSeconds: durationToSeconds(timeout),
+    },
+  };
+};
+
+export const waitForEmailEngagement = (id, config) => {
+  const { name, timeout, emailStepId, engagementType } = config;
+  return {
+    id,
+    type: 'wait_for_email_engagement',
+    name: name ?? \`Wait for email \${engagementType}: \${emailStepId}\`,
+    config: {
+      type: 'wait_for_email_engagement',
+      timeoutSeconds: durationToSeconds(timeout),
+    },
+  };
+};
+
+export const exit = (id, config) => {
+  const { name, ...exitConfig } = config ?? {};
+  return {
+    id,
+    type: 'exit',
+    name: name ?? 'Exit',
+    config: { type: 'exit', ...exitConfig },
+  };
+};
+
+export const updateContact = (id, config) => {
+  const { name, ...updateConfig } = config;
+  return {
+    id,
+    type: 'update_contact',
+    name: name ?? 'Update contact',
+    config: { type: 'update_contact', ...updateConfig },
+  };
+};
+
+export const subscribeTopic = (id, config) => {
+  const { name, ...topicConfig } = config;
+  return {
+    id,
+    type: 'subscribe_topic',
+    name: name ?? \`Subscribe to topic: \${config.topicId}\`,
+    config: { type: 'subscribe_topic', ...topicConfig },
+  };
+};
+
+export const unsubscribeTopic = (id, config) => {
+  const { name, ...topicConfig } = config;
+  return {
+    id,
+    type: 'unsubscribe_topic',
+    name: name ?? \`Unsubscribe from topic: \${config.topicId}\`,
+    config: { type: 'unsubscribe_topic', ...topicConfig },
+  };
+};
+
+export const webhook = (id, config) => {
+  const { name, ...webhookConfig } = config;
+  return {
+    id,
+    type: 'webhook',
+    name: name ?? \`Webhook: \${config.url}\`,
+    config: { type: 'webhook', method: 'POST', ...webhookConfig },
+  };
+};
+
+/**
+ * cascade(id, config) \u2014 expand a cross-channel cascade into primitive steps.
+ *
+ * For each email channel (except the last), we emit:
+ *   send_email \u2192 wait_for_email_engagement \u2192 condition (engaged?)
+ * with the condition's "yes" branch containing an exit node and the "no"
+ * branch falling through to the next channel.
+ *
+ * Non-email channels (SMS) emit only a send step.
+ *
+ * Every generated step carries cascadeGroupId = id so the execution
+ * engine can scope engagement queries to the correct group.
+ */
+export const cascade = (id, config) => {
+  const channels = config.channels || [];
+  const steps = [];
+
+  for (let i = 0; i < channels.length; i++) {
+    const channel = channels[i];
+    const isLast = i === channels.length - 1;
+
+    if (channel.type === 'email') {
+      // Send email step
+      steps.push({
+        id: id + '-send-' + i,
+        type: 'send_email',
+        name: 'Cascade: send ' + (channel.template || 'email'),
+        config: { type: 'send_email', templateId: channel.template },
+        cascadeGroupId: id,
+      });
+
+      // If not last channel, add wait + condition
+      if (!isLast && channel.waitFor) {
+        const waitSeconds = durationToSeconds(channel.waitFor) || 259200;
+        const waitId = id + '-wait-' + i;
+        const condId = id + '-cond-' + i;
+        const exitId = id + '-exit-' + i;
+
+        // Wait for engagement step
+        steps.push({
+          id: waitId,
+          type: 'wait_for_email_engagement',
+          name: 'Cascade: wait for ' + (channel.engagement || 'opened'),
+          config: { type: 'wait_for_email_engagement', timeoutSeconds: waitSeconds },
+          cascadeGroupId: id,
+        });
+
+        // Condition step: check engagement.status
+        steps.push({
+          id: condId,
+          type: 'condition',
+          name: 'Cascade: email engaged?',
+          config: {
+            type: 'condition',
+            field: 'engagement.status',
+            operator: 'equals',
+            value: 'true',
+          },
+          cascadeGroupId: id,
+          branches: {
+            yes: [{
+              id: exitId,
+              type: 'exit',
+              name: 'Exit',
+              config: { type: 'exit', reason: 'Engaged via email' },
+              cascadeGroupId: id,
+            }],
+          },
+        });
+      }
+    } else if (channel.type === 'sms') {
+      // Send SMS step
+      steps.push({
+        id: id + '-send-' + i,
+        type: 'send_sms',
+        name: 'Cascade: send ' + (channel.template || 'sms'),
+        config: { type: 'send_sms', template: channel.template, body: channel.body },
+        cascadeGroupId: id,
+      });
+    }
+  }
+
+  return steps;
+};
 
-## Key Commands
+// Internal helpers
+function normalizeDuration(duration) {
+  if (duration.days !== undefined) {
+    return { amount: duration.days, unit: 'days' };
+  }
+  if (duration.hours !== undefined) {
+    return { amount: duration.hours, unit: 'hours' };
+  }
+  if (duration.minutes !== undefined) {
+    return { amount: duration.minutes, unit: 'minutes' };
+  }
+  return { amount: 1, unit: 'hours' };
+}
 
-\`\`\`bash
-wraps email workflows validate                     # Validate all workflow files
-wraps email workflows validate --workflow welcome   # Validate a specific workflow
-wraps email workflows push                         # Push workflows to dashboard
-wraps email workflows generate --template welcome  # Generate from built-in template
-wraps email workflows generate "description..."    # Generate from AI description
-\`\`\`
+function durationToSeconds(duration) {
+  if (!duration) return undefined;
+  let seconds = 0;
+  if (duration.days) seconds += duration.days * 24 * 60 * 60;
+  if (duration.hours) seconds += duration.hours * 60 * 60;
+  if (duration.minutes) seconds += duration.minutes * 60;
+  return seconds > 0 ? seconds : undefined;
+}
 `;
+  await writeFile10(
+    join16(shimDir, "wraps-client-shim.mjs"),
+    clientShimContent,
+    "utf-8"
+  );
+  const result = await build2({
+    entryPoints: [filePath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    alias: {
+      "@wraps.dev/client": join16(shimDir, "wraps-client-shim.mjs")
+    }
+  });
+  const bundledCode = result.outputFiles[0].text;
+  const tmpDir = join16(wrapsDir, ".wraps", "_workflows");
+  await mkdir8(tmpDir, { recursive: true });
+  const tmpPath = join16(tmpDir, `${slug}.mjs`);
+  await writeFile10(tmpPath, bundledCode, "utf-8");
+  const mod = await import(`${tmpPath}?t=${Date.now()}`);
+  const definition = mod.default;
+  if (!definition || typeof definition !== "object") {
+    throw new Error(
+      "Workflow must have a default export (workflow definition from defineWorkflow())"
+    );
+  }
+  if (!definition.name) {
+    throw new Error("Workflow definition must have a 'name' property");
+  }
+  if (!definition.trigger) {
+    throw new Error("Workflow definition must have a 'trigger' property");
+  }
+  if (!Array.isArray(definition.steps)) {
+    throw new Error("Workflow definition must have a 'steps' array");
+  }
+  return {
+    slug,
+    filePath,
+    source,
+    sourceHash,
+    definition,
+    cliProjectPath: `workflows/${slug}.ts`
+  };
+}
 
-// src/commands/email/workflows/init.ts
-var EXAMPLE_WORKFLOW = `import {
-  defineWorkflow,
-  sendEmail,
-  delay,
-  condition,
-  exit,
-} from '@wraps.dev/client';
-
-/**
- * Welcome Sequence
- *
- * Send a welcome email when a contact is created,
- * wait 1 day, then check if they activated.
- * If not, send a follow-up with tips.
- */
-export default defineWorkflow({
-  name: 'Welcome Sequence',
-  trigger: {
-    type: 'contact_created',
-  },
-
-  steps: [
-    sendEmail('send-welcome', { template: 'welcome-email' }),
-    delay('wait-1-day', { days: 1 }),
-    condition('check-activated', {
-      field: 'contact.hasActivated',
-      operator: 'equals',
-      value: true,
-      branches: {
-        yes: [exit('already-active')],
-        no: [
-          sendEmail('send-tips', { template: 'getting-started-tips' }),
-        ],
-      },
-    }),
-  ],
-});
-`;
-async function workflowsInit(options) {
-  const startTime = Date.now();
-  const cwd = process.cwd();
-  const workflowsDir = join16(cwd, "wraps", "workflows");
-  if (!isJsonMode()) {
-    clack30.intro(pc32.bold("Workflows as Code"));
+// src/utils/email/workflow-validator.ts
+init_esm_shims();
+function validateTransformedWorkflow(transformed, localTemplateSlugs) {
+  const errors2 = [];
+  errors2.push(...validateStructure(transformed.steps, transformed.transitions));
+  for (const step of transformed.steps) {
+    errors2.push(...validateStep(step));
   }
-  const progress = new DeploymentProgress();
-  if (existsSync15(workflowsDir) && !options.force) {
-    const { readdir: readdir4 } = await import("fs/promises");
-    const files = await readdir4(workflowsDir);
-    const tsFiles = files.filter(
-      (f) => f.endsWith(".ts") && !f.startsWith("_")
+  if (localTemplateSlugs) {
+    errors2.push(
+      ...validateTemplateReferences(transformed.steps, localTemplateSlugs)
     );
-    if (tsFiles.length > 0 && !options.force && !isJsonMode()) {
-      clack30.log.warn(
-        `${pc32.cyan("wraps/workflows/")} already contains ${tsFiles.length} workflow file(s). Use ${pc32.bold("--force")} to overwrite.`
-      );
-    }
   }
-  progress.start("Creating wraps/workflows/ directory");
-  await mkdir8(workflowsDir, { recursive: true });
-  const configPath = join16(cwd, "wraps", "wraps.config.ts");
-  if (existsSync15(configPath)) {
-    const configContent = await readFile8(configPath, "utf-8");
-    if (!configContent.includes("workflowsDir")) {
-      const updated = configContent.replace(
-        /}\);(\s*)$/,
-        `  workflowsDir: './workflows',
-});$1`
-      );
-      if (updated !== configContent) {
-        await writeFile10(configPath, updated, "utf-8");
-      }
+  const errorsByNodeId = /* @__PURE__ */ new Map();
+  for (const error of errors2) {
+    if (error.nodeId) {
+      const existing = errorsByNodeId.get(error.nodeId) || [];
+      existing.push(error);
+      errorsByNodeId.set(error.nodeId, existing);
     }
-  } else {
-    await writeFile10(configPath, generateMinimalConfig(), "utf-8");
   }
-  const filesCreated = [];
-  if (!options.noExample) {
-    const examplePath = join16(workflowsDir, "welcome.ts");
-    if (!existsSync15(examplePath) || options.force) {
-      await writeFile10(examplePath, EXAMPLE_WORKFLOW, "utf-8");
-      filesCreated.push("wraps/workflows/welcome.ts");
+  return {
+    isValid: errors2.filter((e) => e.severity === "error").length === 0,
+    errors: errors2,
+    errorsByNodeId
+  };
+}
+function validateStructure(steps, transitions) {
+  const errors2 = [];
+  const triggerSteps = steps.filter((s) => s.type === "trigger");
+  if (triggerSteps.length === 0) {
+    errors2.push({
+      message: "Workflow must have a trigger node",
+      severity: "error"
+    });
+  } else if (triggerSteps.length > 1) {
+    errors2.push({
+      message: "Workflow can only have one trigger node",
+      severity: "error"
+    });
+  }
+  const actionSteps = steps.filter(
+    (s) => s.type !== "trigger" && s.type !== "exit"
+  );
+  if (actionSteps.length === 0 && steps.length > 1) {
+    errors2.push({
+      message: "Workflow must have at least one action step",
+      severity: "error"
+    });
+  }
+  if (triggerSteps.length === 1) {
+    const reachableIds = getReachableNodeIds(triggerSteps[0].id, transitions);
+    const orphanSteps = steps.filter(
+      (s) => s.type !== "trigger" && !reachableIds.has(s.id)
+    );
+    for (const orphan of orphanSteps) {
+      errors2.push({
+        nodeId: orphan.id,
+        message: `"${orphan.name}" is not connected to the workflow`,
+        severity: "warning"
+      });
     }
   }
-  progress.succeed("Workflows directory ready");
-  if (!options.noClaude) {
-    try {
-      progress.start("Scaffolding Claude Code context");
-      await scaffoldClaudeMdSection({
-        projectDir: cwd,
-        sectionId: "workflows",
-        sectionContent: WORKFLOWS_CLAUDE_MD_SECTION
+  const stepIds = new Set(steps.map((s) => s.id));
+  for (const transition of transitions) {
+    if (!stepIds.has(transition.fromStepId)) {
+      errors2.push({
+        message: `Transition references non-existent source step: ${transition.fromStepId}`,
+        severity: "error"
       });
-      filesCreated.push(".claude/CLAUDE.md");
-      await scaffoldClaudeSkill({
-        projectDir: cwd,
-        skillName: "wraps-workflows",
-        skillContent: WORKFLOWS_SKILL_CONTENT
+    }
+    if (!stepIds.has(transition.toStepId)) {
+      errors2.push({
+        message: `Transition references non-existent target step: ${transition.toStepId}`,
+        severity: "error"
       });
-      filesCreated.push(".claude/skills/wraps-workflows/SKILL.md");
-      progress.succeed("Claude Code context scaffolded");
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      progress.info(
-        `Could not scaffold .claude/ context \u2014 workflow files are still ready (${msg})`
-      );
     }
   }
-  trackCommand("email:workflows:init", {
-    success: true,
-    duration_ms: Date.now() - startTime
-  });
-  if (isJsonMode()) {
-    jsonSuccess("email.workflows.init", {
-      dir: "wraps/workflows",
-      files: filesCreated
+  return errors2;
+}
+function getReachableNodeIds(startId, transitions) {
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [startId];
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    if (reachable.has(currentId)) {
+      continue;
+    }
+    reachable.add(currentId);
+    const outgoing = transitions.filter((t) => t.fromStepId === currentId);
+    for (const t of outgoing) {
+      if (!reachable.has(t.toStepId)) {
+        queue.push(t.toStepId);
+      }
+    }
+  }
+  return reachable;
+}
+function validateStep(step) {
+  const errors2 = [];
+  const config2 = step.config;
+  const configType = config2.type;
+  switch (configType) {
+    case "trigger":
+      errors2.push(...validateTrigger(step.id, config2));
+      break;
+    case "send_email":
+      errors2.push(...validateSendEmail(step.id, config2));
+      break;
+    case "condition":
+      errors2.push(...validateCondition(step.id, config2));
+      break;
+    case "webhook":
+      errors2.push(...validateWebhook(step.id, config2));
+      break;
+    case "subscribe_topic":
+    case "unsubscribe_topic":
+      errors2.push(...validateTopic(step.id, config2));
+      break;
+    case "wait_for_event":
+      errors2.push(...validateWaitForEvent(step.id, config2));
+      break;
+    case "delay":
+      errors2.push(...validateDelay(step.id, config2));
+      break;
+  }
+  return errors2;
+}
+function validateTrigger(nodeId, config2) {
+  const errors2 = [];
+  switch (config2.triggerType) {
+    case "event":
+      if (!config2.eventName) {
+        errors2.push({
+          nodeId,
+          field: "eventName",
+          message: "Event name is required",
+          severity: "error"
+        });
+      }
+      break;
+    case "segment_entry":
+    case "segment_exit":
+      if (!config2.segmentId) {
+        errors2.push({
+          nodeId,
+          field: "segmentId",
+          message: "Segment is required",
+          severity: "error"
+        });
+      }
+      break;
+    case "topic_subscribed":
+    case "topic_unsubscribed":
+      if (!config2.topicId) {
+        errors2.push({
+          nodeId,
+          field: "topicId",
+          message: "Topic is required",
+          severity: "error"
+        });
+      }
+      break;
+    case "schedule":
+      if (!config2.schedule) {
+        errors2.push({
+          nodeId,
+          field: "schedule",
+          message: "Schedule (cron expression) is required",
+          severity: "error"
+        });
+      }
+      if (!config2.timezone) {
+        errors2.push({
+          nodeId,
+          field: "timezone",
+          message: "Timezone is required",
+          severity: "error"
+        });
+      }
+      break;
+  }
+  return errors2;
+}
+function validateSendEmail(nodeId, config2) {
+  const errors2 = [];
+  const templateRef = config2.templateId || config2.template;
+  if (!templateRef) {
+    errors2.push({
+      nodeId,
+      field: "templateId",
+      message: "Email template is required",
+      severity: "error"
     });
-    return;
   }
-  console.log();
-  clack30.log.success(pc32.green("Workflows as Code initialized!"));
-  console.log();
-  console.log(`  ${pc32.dim("Directory:")}  ${pc32.cyan("wraps/workflows/")}`);
-  if (!options.noExample) {
-    console.log(
-      `  ${pc32.dim("Example:")}    ${pc32.cyan("wraps/workflows/welcome.ts")}`
-    );
+  return errors2;
+}
+function validateCondition(nodeId, config2) {
+  const errors2 = [];
+  if (!config2.field) {
+    errors2.push({
+      nodeId,
+      field: "field",
+      message: "Condition field is required",
+      severity: "error"
+    });
   }
-  if (!options.noClaude) {
-    console.log(
-      `  ${pc32.dim("AI Context:")} ${pc32.cyan(".claude/skills/wraps-workflows/")}`
-    );
+  if (!config2.operator) {
+    errors2.push({
+      nodeId,
+      field: "operator",
+      message: "Condition operator is required",
+      severity: "error"
+    });
   }
-  console.log();
-  console.log(`${pc32.bold("Next steps:")}`);
-  console.log(
-    `  1. Edit or create workflows in ${pc32.cyan("wraps/workflows/")}`
-  );
-  console.log(`  2. Validate: ${pc32.cyan("wraps email workflows validate")}`);
-  console.log(`  3. Push:     ${pc32.cyan("wraps email workflows push")}`);
-  if (!options.noClaude) {
-    console.log("  4. Use Claude Code to generate workflows from descriptions");
+  if (config2.operator !== "is_set" && config2.operator !== "is_not_set" && config2.operator !== "is_true" && config2.operator !== "is_false" && (config2.value === void 0 || config2.value === "")) {
+    errors2.push({
+      nodeId,
+      field: "value",
+      message: "Condition value is required",
+      severity: "error"
+    });
   }
-  console.log();
+  return errors2;
 }
-function generateMinimalConfig() {
-  return `import { defineConfig } from '@wraps.dev/client';
-
-export default defineConfig({
-  org: 'my-org',
-  // from: { email: 'hello@yourapp.com', name: 'My App' },
-  // region: 'us-east-1',
-  templatesDir: './templates',
-  workflowsDir: './workflows',
-});
-`;
+function validateWebhook(nodeId, config2) {
+  const errors2 = [];
+  if (config2.url) {
+    try {
+      new URL(config2.url);
+    } catch {
+      errors2.push({
+        nodeId,
+        field: "url",
+        message: "Invalid URL format",
+        severity: "error"
+      });
+    }
+  } else {
+    errors2.push({
+      nodeId,
+      field: "url",
+      message: "Webhook URL is required",
+      severity: "error"
+    });
+  }
+  return errors2;
+}
+function validateTopic(nodeId, config2) {
+  const errors2 = [];
+  if (!config2.topicId) {
+    errors2.push({
+      nodeId,
+      field: "topicId",
+      message: "Topic is required",
+      severity: "error"
+    });
+  }
+  return errors2;
+}
+function validateWaitForEvent(nodeId, config2) {
+  const errors2 = [];
+  if (!config2.eventName) {
+    errors2.push({
+      nodeId,
+      field: "eventName",
+      message: "Event name is required",
+      severity: "error"
+    });
+  }
+  return errors2;
+}
+function validateDelay(nodeId, config2) {
+  const errors2 = [];
+  const amount = config2.amount;
+  if (!amount || amount < 1) {
+    errors2.push({
+      nodeId,
+      field: "amount",
+      message: "Delay duration must be at least 1",
+      severity: "error"
+    });
+  }
+  return errors2;
+}
+function validateTemplateReferences(steps, localTemplateSlugs) {
+  const errors2 = [];
+  for (const step of steps) {
+    if (step.config.type === "send_email") {
+      const config2 = step.config;
+      const templateRef = config2.templateId || config2.template;
+      if (templateRef && !localTemplateSlugs.has(templateRef)) {
+        errors2.push({
+          nodeId: step.id,
+          field: "templateId",
+          message: `Template "${templateRef}" not found in templates/ directory`,
+          severity: "error"
+        });
+      }
+    }
+    if (step.config.type === "send_sms") {
+      const config2 = step.config;
+      const templateRef = config2.templateId || config2.template;
+      if (templateRef && !localTemplateSlugs.has(templateRef)) {
+        errors2.push({
+          nodeId: step.id,
+          field: "templateId",
+          message: `SMS template "${templateRef}" not found in templates/ directory`,
+          severity: "warning"
+          // Warning for SMS since we might not have SMS templates yet
+        });
+      }
+    }
+  }
+  return errors2;
 }
 
 // src/commands/email/workflows/push.ts
-init_esm_shims();
-init_events();
-import { existsSync as existsSync16 } from "fs";
-import { join as join17 } from "path";
-import * as clack31 from "@clack/prompts";
-import pc33 from "picocolors";
 init_config();
 init_errors();
 init_json_output();
@@ -27629,7 +27447,7 @@ import {
   IAMClient as IAMClient2,
   PutRolePolicyCommand
 } from "@aws-sdk/client-iam";
-import { confirm as confirm15, intro as intro33, isCancel as isCancel21, log as log33, outro as outro19, select as select14 } from "@clack/prompts";
+import { confirm as confirm14, intro as intro33, isCancel as isCancel20, log as log33, outro as outro19, select as select14 } from "@clack/prompts";
 import * as pulumi21 from "@pulumi/pulumi";
 import pc37 from "picocolors";
 init_events();
@@ -27980,7 +27798,7 @@ async function resolveOrganization() {
       hint: org.slug
     }))
   });
-  if (isCancel21(selected)) {
+  if (isCancel20(selected)) {
     outro19("Operation cancelled");
     process.exit(0);
   }
@@ -28042,11 +27860,11 @@ async function authenticatedConnect(token, options) {
             "Event tracking must be enabled to connect to the Wraps Platform."
           );
         }
-        const enableTracking = options.yes || await confirm15({
+        const enableTracking = options.yes || await confirm14({
           message: "Enable event tracking now?",
           initialValue: true
         });
-        if (isCancel21(enableTracking) || !enableTracking) {
+        if (isCancel20(enableTracking) || !enableTracking) {
           outro19("Platform connection cancelled.");
           process.exit(0);
         }
@@ -28236,11 +28054,11 @@ Run ${pc37.cyan("wraps email init")} or ${pc37.cyan("wraps sms init")} first.
         log33.info(
           "Enabling event tracking will allow SES events to be streamed to the dashboard."
         );
-        const enableEventTracking = await confirm15({
+        const enableEventTracking = await confirm14({
           message: "Enable event tracking now?",
           initialValue: true
         });
-        if (isCancel21(enableEventTracking) || !enableEventTracking) {
+        if (isCancel20(enableEventTracking) || !enableEventTracking) {
           outro19("Platform connection cancelled.");
           process.exit(0);
         }
@@ -28288,18 +28106,18 @@ Run ${pc37.cyan("wraps email init")} or ${pc37.cyan("wraps sms init")} first.
             }
           ]
         });
-        if (isCancel21(action)) {
+        if (isCancel20(action)) {
           outro19("Operation cancelled");
           process.exit(0);
         }
         if (action === "keep") {
           webhookSecret = existingSecret;
         } else if (action === "disconnect") {
-          const confirmDisconnect = await confirm15({
+          const confirmDisconnect = await confirm14({
             message: "Are you sure? Events will no longer be sent to the Wraps Platform.",
             initialValue: false
           });
-          if (isCancel21(confirmDisconnect) || !confirmDisconnect) {
+          if (isCancel20(confirmDisconnect) || !confirmDisconnect) {
             outro19("Disconnect cancelled");
             process.exit(0);
           }
@@ -28510,7 +28328,7 @@ import {
   GetRoleCommand as GetRoleCommand2,
   IAMClient as IAMClient3
 } from "@aws-sdk/client-iam";
-import { confirm as confirm16, intro as intro35, isCancel as isCancel22, log as log34, outro as outro20 } from "@clack/prompts";
+import { confirm as confirm15, intro as intro35, isCancel as isCancel21, log as log34, outro as outro20 } from "@clack/prompts";
 import pc39 from "picocolors";
 async function updateRole(options) {
   const startTime = Date.now();
@@ -28571,11 +28389,11 @@ Run ${pc39.cyan("wraps email init")} to deploy infrastructure first.
   if (!options.force) {
     progress.stop();
     const actionLabel = roleExists2 ? "Update" : "Create";
-    const shouldContinue = await confirm16({
+    const shouldContinue = await confirm15({
       message: `${actionLabel} IAM role ${pc39.cyan(roleName)} with latest permissions?`,
       initialValue: true
     });
-    if (isCancel22(shouldContinue) || !shouldContinue) {
+    if (isCancel21(shouldContinue) || !shouldContinue) {
       outro20(`${actionLabel} cancelled`);
       process.exit(0);
     }
@@ -36328,7 +36146,7 @@ function showHelp() {
     `  ${pc54.cyan("email workflows push")}      Push workflows to dashboard`
   );
   console.log(
-    `  ${pc54.cyan("email workflows generate")} Generate workflow from template or AI
+    `  ${pc54.cyan("email workflows generate")} Generate workflow from template
 `
   );
   console.log("SMS Commands:");
@@ -37106,14 +36924,10 @@ Available commands: ${pc54.cyan("init")}, ${pc54.cyan("push")}, ${pc54.cyan("pre
               break;
             case "generate":
               await workflowsGenerate({
-                description: args.sub[3],
                 template: flags.template,
                 name: flags.name,
-                dryRun: flags.dryRun,
-                yes: flags.yes,
                 force: flags.force,
-                json: flags.json,
-                token: flags.token
+                json: flags.json
               });
               break;
             default: