grimoire-wizard 0.3.1 → 0.5.0

package/dist/index.js

@@ -1,283 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/schema.ts
 import { z } from "zod";
-var conditionSchema = z.lazy(() => {
-  const fieldEquals = z.object({ field: z.string(), equals: z.unknown() }).strict();
-  const fieldNotEquals = z.object({ field: z.string(), notEquals: z.unknown() }).strict();
-  const fieldIncludes = z.object({ field: z.string(), includes: z.unknown() }).strict();
-  const fieldNotIncludes = z.object({ field: z.string(), notIncludes: z.unknown() }).strict();
-  const fieldGreaterThan = z.object({ field: z.string(), greaterThan: z.number() }).strict();
-  const fieldLessThan = z.object({ field: z.string(), lessThan: z.number() }).strict();
-  const fieldIsEmpty = z.object({ field: z.string(), isEmpty: z.literal(true) }).strict();
-  const fieldIsNotEmpty = z.object({ field: z.string(), isNotEmpty: z.literal(true) }).strict();
-  const allCondition = z.object({ all: z.array(conditionSchema) }).strict();
-  const anyCondition = z.object({ any: z.array(conditionSchema) }).strict();
-  const notCondition = z.object({ not: conditionSchema }).strict();
-  return z.union([
-    fieldEquals,
-    fieldNotEquals,
-    fieldIncludes,
-    fieldNotIncludes,
-    fieldGreaterThan,
-    fieldLessThan,
-    fieldIsEmpty,
-    fieldIsNotEmpty,
-    allCondition,
-    anyCondition,
-    notCondition
-  ]);
-});
-var validationRuleSchema = z.discriminatedUnion("rule", [
-  z.object({ rule: z.literal("required"), message: z.string().optional() }),
-  z.object({ rule: z.literal("minLength"), value: z.number(), message: z.string().optional() }),
-  z.object({ rule: z.literal("maxLength"), value: z.number(), message: z.string().optional() }),
-  z.object({ rule: z.literal("pattern"), value: z.string(), message: z.string().optional() }),
-  z.object({ rule: z.literal("min"), value: z.number(), message: z.string().optional() }),
-  z.object({ rule: z.literal("max"), value: z.number(), message: z.string().optional() })
-]);
-var selectOptionSchema = z.object({
-  value: z.string(),
-  label: z.string(),
-  hint: z.string().optional(),
-  disabled: z.union([z.boolean(), z.string()]).optional()
-});
-var separatorOptionSchema = z.object({
-  separator: z.string()
-});
-var selectChoiceSchema = z.union([selectOptionSchema, separatorOptionSchema]);
-var baseStepFields = {
-  id: z.string(),
-  message: z.string(),
-  description: z.string().optional(),
-  next: z.string().optional(),
-  when: conditionSchema.optional(),
-  keepValuesOnPrevious: z.boolean().optional(),
-  required: z.boolean().optional(),
-  group: z.string().optional()
-};
-var textStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("text"),
-  placeholder: z.string().optional(),
-  default: z.string().optional(),
-  validate: z.array(validationRuleSchema).optional()
-});
-var selectStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("select"),
-  options: z.array(selectChoiceSchema).min(1).optional(),
-  optionsFrom: z.string().optional(),
-  default: z.string().optional(),
-  routes: z.record(z.string(), z.string()).optional(),
-  pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
-});
-var multiSelectStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("multiselect"),
-  options: z.array(selectChoiceSchema).min(1).optional(),
-  optionsFrom: z.string().optional(),
-  default: z.array(z.string()).optional(),
-  min: z.number().int().nonnegative().optional(),
-  max: z.number().int().positive().optional(),
-  pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
-});
-var confirmStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("confirm"),
-  default: z.boolean().optional()
-});
-var passwordStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("password"),
-  validate: z.array(validationRuleSchema).optional()
-});
-var numberStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("number"),
-  default: z.number().optional(),
-  min: z.number().optional(),
-  max: z.number().optional(),
-  step: z.number().positive().optional()
-});
-var searchStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("search"),
-  options: z.array(selectChoiceSchema).min(1).optional(),
-  optionsFrom: z.string().optional(),
-  default: z.string().optional(),
-  placeholder: z.string().optional(),
-  pageSize: z.number().int().positive().optional(),
-  loop: z.boolean().optional()
-});
-var editorStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("editor"),
-  default: z.string().optional(),
-  validate: z.array(validationRuleSchema).optional()
-});
-var pathStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("path"),
-  default: z.string().optional(),
-  placeholder: z.string().optional(),
-  validate: z.array(validationRuleSchema).optional()
-});
-var toggleStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("toggle"),
-  default: z.boolean().optional(),
-  active: z.string().optional(),
-  inactive: z.string().optional()
-});
-var messageStepSchema = z.object({
-  ...baseStepFields,
-  type: z.literal("message")
-});
-var stepConfigSchema = z.discriminatedUnion("type", [
-  textStepSchema,
-  selectStepSchema,
-  multiSelectStepSchema,
-  confirmStepSchema,
-  passwordStepSchema,
-  numberStepSchema,
-  searchStepSchema,
-  editorStepSchema,
-  pathStepSchema,
-  toggleStepSchema,
-  messageStepSchema
-]);
-var hexColorSchema = z.string().regex(
-  /^#[0-9a-fA-F]{6}$/,
-  "Must be a 6-digit hex color (e.g., #FF0000)"
-);
-var themeConfigSchema = z.object({
-  tokens: z.object({
-    primary: hexColorSchema.optional(),
-    success: hexColorSchema.optional(),
-    error: hexColorSchema.optional(),
-    warning: hexColorSchema.optional(),
-    info: hexColorSchema.optional(),
-    muted: hexColorSchema.optional(),
-    accent: hexColorSchema.optional()
-  }).optional(),
-  icons: z.object({
-    step: z.string().optional(),
-    stepDone: z.string().optional(),
-    stepPending: z.string().optional(),
-    pointer: z.string().optional()
-  }).optional()
-});
-var preFlightCheckSchema = z.object({
-  name: z.string(),
-  run: z.string(),
-  message: z.string()
-});
-var actionConfigSchema = z.object({
-  name: z.string().optional(),
-  run: z.string(),
-  when: conditionSchema.optional()
-});
-var wizardConfigSchema = z.object({
-  meta: z.object({
-    name: z.string(),
-    version: z.string().optional(),
-    description: z.string().optional()
-  }),
-  theme: themeConfigSchema.optional(),
-  steps: z.array(stepConfigSchema).min(1),
-  output: z.object({
-    format: z.enum(["json", "env", "yaml"]),
-    path: z.string().optional()
-  }).optional(),
-  extends: z.string().optional(),
-  checks: z.array(preFlightCheckSchema).optional(),
-  actions: z.array(actionConfigSchema).optional()
-}).superRefine((config, ctx) => {
-  const stepIds = /* @__PURE__ */ new Set();
-  for (const step of config.steps) {
-    if (stepIds.has(step.id)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Duplicate step ID: "${step.id}"`,
-        path: ["steps"]
-      });
-    }
-    stepIds.add(step.id);
-  }
-  config.steps.forEach((step, i) => {
-    if (step.next && step.next !== "__done__" && !stepIds.has(step.next)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Step "${step.id}" references unknown next step: "${step.next}"`,
-        path: ["steps", i, "next"]
-      });
-    }
-    if (step.type === "select" && step.routes) {
-      for (const [key, target] of Object.entries(step.routes)) {
-        if (target !== "__done__" && !stepIds.has(target)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Step "${step.id}" route "${key}" references unknown step: "${target}"`,
-            path: ["steps", i, "routes", key]
-          });
-        }
-      }
-    }
-    if (step.when) {
-      collectConditionFieldIssues(step.when, stepIds, ctx, ["steps", i, "when"]);
-    }
-    if (step.type === "select" && step.routes && step.options) {
-      const optionValues = /* @__PURE__ */ new Set();
-      for (const o of step.options) {
-        if ("value" in o) {
-          optionValues.add(o.value);
-        }
-      }
-      for (const routeKey of Object.keys(step.routes)) {
-        if (!optionValues.has(routeKey)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Step "${step.id}" route key "${routeKey}" does not match any option value`,
-            path: ["steps", i, "routes", routeKey]
-          });
-        }
-      }
-    }
-    if (step.type === "select" || step.type === "multiselect" || step.type === "search") {
-      const hasOptions = step.options !== void 0;
-      const hasOptionsFrom = step.optionsFrom !== void 0;
-      if (hasOptions && hasOptionsFrom) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Step "${step.id}" has both "options" and "optionsFrom" \u2014 only one is allowed`,
-          path: ["steps", i]
-        });
-      }
-      if (!hasOptions && !hasOptionsFrom) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Step "${step.id}" must have either "options" or "optionsFrom"`,
-          path: ["steps", i]
-        });
-      }
-    }
-    if ((step.type === "number" || step.type === "multiselect") && step.min !== void 0 && step.max !== void 0 && step.min > step.max) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Step "${step.id}" has min (${String(step.min)}) greater than max (${String(step.max)})`,
-        path: ["steps", i]
-      });
-    }
-  });
-  if (config.actions) {
-    config.actions.forEach((action, i) => {
-      if (action.when) {
-        collectConditionFieldIssues(action.when, stepIds, ctx, ["actions", i, "when"]);
-      }
-    });
-  }
-});
 function collectConditionFieldIssues(condition, validIds, ctx, path) {
   if ("field" in condition) {
     const fieldRoot = condition.field.split(".")[0];
@@ -310,13 +42,316 @@ function parseWizardConfig(raw) {
   const result = wizardConfigSchema.parse(raw);
   return result;
 }
+var conditionSchema, validationRuleSchema, selectOptionSchema, separatorOptionSchema, selectChoiceSchema, baseStepFields, textStepSchema, selectStepSchema, multiSelectStepSchema, confirmStepSchema, passwordStepSchema, numberStepSchema, searchStepSchema, editorStepSchema, pathStepSchema, toggleStepSchema, messageStepSchema, noteStepSchema, stepConfigSchema, hexColorSchema, themeConfigSchema, preFlightCheckSchema, actionConfigSchema, wizardConfigSchema;
+var init_schema = __esm({
+  "src/schema.ts"() {
+    "use strict";
+    conditionSchema = z.lazy(() => {
+      const fieldEquals = z.object({ field: z.string(), equals: z.unknown() }).strict();
+      const fieldNotEquals = z.object({ field: z.string(), notEquals: z.unknown() }).strict();
+      const fieldIncludes = z.object({ field: z.string(), includes: z.unknown() }).strict();
+      const fieldNotIncludes = z.object({ field: z.string(), notIncludes: z.unknown() }).strict();
+      const fieldGreaterThan = z.object({ field: z.string(), greaterThan: z.number() }).strict();
+      const fieldLessThan = z.object({ field: z.string(), lessThan: z.number() }).strict();
+      const fieldIsEmpty = z.object({ field: z.string(), isEmpty: z.literal(true) }).strict();
+      const fieldIsNotEmpty = z.object({ field: z.string(), isNotEmpty: z.literal(true) }).strict();
+      const allCondition = z.object({ all: z.array(conditionSchema) }).strict();
+      const anyCondition = z.object({ any: z.array(conditionSchema) }).strict();
+      const notCondition = z.object({ not: conditionSchema }).strict();
+      return z.union([
+        fieldEquals,
+        fieldNotEquals,
+        fieldIncludes,
+        fieldNotIncludes,
+        fieldGreaterThan,
+        fieldLessThan,
+        fieldIsEmpty,
+        fieldIsNotEmpty,
+        allCondition,
+        anyCondition,
+        notCondition
+      ]);
+    });
+    validationRuleSchema = z.discriminatedUnion("rule", [
+      z.object({ rule: z.literal("required"), message: z.string().optional() }),
+      z.object({ rule: z.literal("minLength"), value: z.number(), message: z.string().optional() }),
+      z.object({ rule: z.literal("maxLength"), value: z.number(), message: z.string().optional() }),
+      z.object({ rule: z.literal("pattern"), value: z.string(), message: z.string().optional() }),
+      z.object({ rule: z.literal("min"), value: z.number(), message: z.string().optional() }),
+      z.object({ rule: z.literal("max"), value: z.number(), message: z.string().optional() })
+    ]);
+    selectOptionSchema = z.object({
+      value: z.string(),
+      label: z.string(),
+      hint: z.string().optional(),
+      disabled: z.union([z.boolean(), z.string()]).optional()
+    });
+    separatorOptionSchema = z.object({
+      separator: z.string()
+    });
+    selectChoiceSchema = z.union([selectOptionSchema, separatorOptionSchema]);
+    baseStepFields = {
+      id: z.string(),
+      message: z.string(),
+      description: z.string().optional(),
+      next: z.string().optional(),
+      when: conditionSchema.optional(),
+      keepValuesOnPrevious: z.boolean().optional(),
+      required: z.boolean().optional(),
+      group: z.string().optional()
+    };
+    textStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("text"),
+      placeholder: z.string().optional(),
+      default: z.string().optional(),
+      validate: z.array(validationRuleSchema).optional()
+    });
+    selectStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("select"),
+      options: z.array(selectChoiceSchema).min(1).optional(),
+      optionsFrom: z.string().optional(),
+      default: z.string().optional(),
+      routes: z.record(z.string(), z.string()).optional(),
+      pageSize: z.number().int().positive().optional(),
+      loop: z.boolean().optional()
+    });
+    multiSelectStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("multiselect"),
+      options: z.array(selectChoiceSchema).min(1).optional(),
+      optionsFrom: z.string().optional(),
+      default: z.array(z.string()).optional(),
+      min: z.number().int().nonnegative().optional(),
+      max: z.number().int().positive().optional(),
+      pageSize: z.number().int().positive().optional(),
+      loop: z.boolean().optional()
+    });
+    confirmStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("confirm"),
+      default: z.boolean().optional()
+    });
+    passwordStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("password"),
+      validate: z.array(validationRuleSchema).optional()
+    });
+    numberStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("number"),
+      default: z.number().optional(),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      step: z.number().positive().optional()
+    });
+    searchStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("search"),
+      options: z.array(selectChoiceSchema).min(1).optional(),
+      optionsFrom: z.string().optional(),
+      default: z.string().optional(),
+      placeholder: z.string().optional(),
+      pageSize: z.number().int().positive().optional(),
+      loop: z.boolean().optional()
+    });
+    editorStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("editor"),
+      default: z.string().optional(),
+      validate: z.array(validationRuleSchema).optional()
+    });
+    pathStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("path"),
+      default: z.string().optional(),
+      placeholder: z.string().optional(),
+      validate: z.array(validationRuleSchema).optional()
+    });
+    toggleStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("toggle"),
+      default: z.boolean().optional(),
+      active: z.string().optional(),
+      inactive: z.string().optional()
+    });
+    messageStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("message")
+    });
+    noteStepSchema = z.object({
+      ...baseStepFields,
+      type: z.literal("note")
+    });
+    stepConfigSchema = z.discriminatedUnion("type", [
+      textStepSchema,
+      selectStepSchema,
+      multiSelectStepSchema,
+      confirmStepSchema,
+      passwordStepSchema,
+      numberStepSchema,
+      searchStepSchema,
+      editorStepSchema,
+      pathStepSchema,
+      toggleStepSchema,
+      messageStepSchema,
+      noteStepSchema
+    ]);
+    hexColorSchema = z.string().regex(
+      /^#[0-9a-fA-F]{6}$/,
+      "Must be a 6-digit hex color (e.g., #FF0000)"
+    );
+    themeConfigSchema = z.object({
+      preset: z.enum(["default", "catppuccin", "dracula", "nord", "tokyonight", "monokai"]).optional(),
+      tokens: z.object({
+        primary: hexColorSchema.optional(),
+        success: hexColorSchema.optional(),
+        error: hexColorSchema.optional(),
+        warning: hexColorSchema.optional(),
+        info: hexColorSchema.optional(),
+        muted: hexColorSchema.optional(),
+        accent: hexColorSchema.optional()
+      }).optional(),
+      icons: z.object({
+        step: z.string().optional(),
+        stepDone: z.string().optional(),
+        stepPending: z.string().optional(),
+        pointer: z.string().optional()
+      }).optional(),
+      spinner: z.union([
+        z.string(),
+        z.object({
+          frames: z.array(z.string()).min(1),
+          interval: z.number().positive().optional()
+        })
+      ]).optional()
+    });
+    preFlightCheckSchema = z.object({
+      name: z.string(),
+      run: z.string(),
+      message: z.string()
+    });
+    actionConfigSchema = z.object({
+      name: z.string().optional(),
+      run: z.string(),
+      when: conditionSchema.optional()
+    });
+    wizardConfigSchema = z.object({
+      meta: z.object({
+        name: z.string(),
+        version: z.string().optional(),
+        description: z.string().optional(),
+        review: z.boolean().optional()
+      }),
+      theme: themeConfigSchema.optional(),
+      steps: z.array(stepConfigSchema).min(1),
+      output: z.object({
+        format: z.enum(["json", "env", "yaml"]),
+        path: z.string().optional()
+      }).optional(),
+      extends: z.string().optional(),
+      checks: z.array(preFlightCheckSchema).optional(),
+      actions: z.array(actionConfigSchema).optional(),
+      onComplete: z.string().optional()
+    }).superRefine((config, ctx) => {
+      const stepIds = /* @__PURE__ */ new Set();
+      for (const step of config.steps) {
+        if (stepIds.has(step.id)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Duplicate step ID: "${step.id}"`,
+            path: ["steps"]
+          });
+        }
+        stepIds.add(step.id);
+      }
+      config.steps.forEach((step, i) => {
+        if (step.next && step.next !== "__done__" && !stepIds.has(step.next)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" references unknown next step: "${step.next}"`,
+            path: ["steps", i, "next"]
+          });
+        }
+        if (step.type === "select" && step.routes) {
+          for (const [key, target] of Object.entries(step.routes)) {
+            if (target !== "__done__" && !stepIds.has(target)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Step "${step.id}" route "${key}" references unknown step: "${target}"`,
+                path: ["steps", i, "routes", key]
+              });
+            }
+          }
+        }
+        if (step.when) {
+          collectConditionFieldIssues(step.when, stepIds, ctx, ["steps", i, "when"]);
+        }
+        if (step.type === "select" && step.routes && step.options) {
+          const optionValues = /* @__PURE__ */ new Set();
+          for (const o of step.options) {
+            if ("value" in o) {
+              optionValues.add(o.value);
+            }
+          }
+          for (const routeKey of Object.keys(step.routes)) {
+            if (!optionValues.has(routeKey)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Step "${step.id}" route key "${routeKey}" does not match any option value`,
+                path: ["steps", i, "routes", routeKey]
+              });
+            }
+          }
+        }
+        if (step.type === "select" || step.type === "multiselect" || step.type === "search") {
+          const hasOptions = step.options !== void 0;
+          const hasOptionsFrom = step.optionsFrom !== void 0;
+          if (hasOptions && hasOptionsFrom) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `Step "${step.id}" has both "options" and "optionsFrom" \u2014 only one is allowed`,
+              path: ["steps", i]
+            });
+          }
+          if (!hasOptions && !hasOptionsFrom) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `Step "${step.id}" must have either "options" or "optionsFrom"`,
+              path: ["steps", i]
+            });
+          }
+        }
+        if ((step.type === "number" || step.type === "multiselect") && step.min !== void 0 && step.max !== void 0 && step.min > step.max) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Step "${step.id}" has min (${String(step.min)}) greater than max (${String(step.max)})`,
+            path: ["steps", i]
+          });
+        }
+      });
+      if (config.actions) {
+        config.actions.forEach((action, i) => {
+          if (action.when) {
+            collectConditionFieldIssues(action.when, stepIds, ctx, ["actions", i, "when"]);
+          }
+        });
+      }
+    });
+  }
+});
 
 // src/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  loadWizardConfig: () => loadWizardConfig,
+  parseWizardYAML: () => parseWizardYAML
+});
 import { cosmiconfig } from "cosmiconfig";
 import { readFileSync } from "fs";
 import { dirname, resolve, isAbsolute } from "path";
 import { parse as parseYAML } from "yaml";
-var DONE_SENTINEL = "__done__";
 function buildStepGraph(steps) {
   const graph = /* @__PURE__ */ new Map();
   for (let i = 0; i < steps.length; i++) {
@@ -395,7 +430,6 @@ function mergeConfigs(parent, child) {
     actions: child.actions ?? parent.actions
   };
 }
-var OPTION_STEP_TYPES = /* @__PURE__ */ new Set(["select", "multiselect", "search"]);
 function resolveOptionsFromSteps(raw, configDir) {
   const steps = raw["steps"];
   if (!Array.isArray(steps)) return;
@@ -491,6 +525,19 @@ function parseWizardYAML(yamlString) {
   detectCycles(config);
   return config;
 }
+var DONE_SENTINEL, OPTION_STEP_TYPES;
+var init_parser = __esm({
+  "src/parser.ts"() {
+    "use strict";
+    init_schema();
+    DONE_SENTINEL = "__done__";
+    OPTION_STEP_TYPES = /* @__PURE__ */ new Set(["select", "multiselect", "search"]);
+  }
+});
+
+// src/index.ts
+init_schema();
+init_parser();
 
 // src/conditions.ts
 function isRecord(value) {
@@ -770,6 +817,102 @@ function applyValidationRule(rule, value) {
 
 // src/theme.ts
 import chalk from "chalk";
+
+// src/themes/presets.ts
+var THEME_PRESETS = {
+  default: {
+    primary: "#7C3AED",
+    success: "#10B981",
+    error: "#EF4444",
+    warning: "#F59E0B",
+    info: "#3B82F6",
+    muted: "#6B7280",
+    accent: "#8B5CF6"
+  },
+  catppuccin: {
+    primary: "#cba6f7",
+    success: "#a6e3a1",
+    error: "#f38ba8",
+    warning: "#fab387",
+    info: "#74c7ec",
+    muted: "#6c7086",
+    accent: "#f5c2e7"
+  },
+  dracula: {
+    primary: "#bd93f9",
+    success: "#50fa7b",
+    error: "#ff5555",
+    warning: "#ffb86c",
+    info: "#8be9fd",
+    muted: "#6272a4",
+    accent: "#ff79c6"
+  },
+  nord: {
+    primary: "#88c0d0",
+    success: "#a3be8c",
+    error: "#bf616a",
+    warning: "#ebcb8b",
+    info: "#81a1c1",
+    muted: "#4c566a",
+    accent: "#b48ead"
+  },
+  tokyonight: {
+    primary: "#7aa2f7",
+    success: "#9ece6a",
+    error: "#f7768e",
+    warning: "#e0af68",
+    info: "#7dcfff",
+    muted: "#565f89",
+    accent: "#bb9af7"
+  },
+  monokai: {
+    primary: "#ab9df2",
+    success: "#a9dc76",
+    error: "#ff6188",
+    warning: "#ffd866",
+    info: "#78dce8",
+    muted: "#727072",
+    accent: "#fc9867"
+  }
+};
+var PRESET_NAMES = Object.keys(THEME_PRESETS);
+
+// src/spinners.ts
+var spinners = {
+  dots: { interval: 80, frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] },
+  dots2: { interval: 80, frames: ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"] },
+  line: { interval: 130, frames: ["-", "\\", "|", "/"] },
+  arc: { interval: 100, frames: ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"] },
+  circle: { interval: 80, frames: ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] },
+  circleHalves: { interval: 50, frames: ["\u25D0", "\u25D3", "\u25D1", "\u25D2"] },
+  triangle: { interval: 50, frames: ["\u25E2", "\u25E3", "\u25E4", "\u25E5"] },
+  pipe: { interval: 100, frames: ["\u2524", "\u2518", "\u2534", "\u2514", "\u251C", "\u250C", "\u252C", "\u2510"] },
+  arrow: { interval: 100, frames: ["\u2190", "\u2196", "\u2191", "\u2197", "\u2192", "\u2198", "\u2193", "\u2199"] },
+  arrow3: { interval: 120, frames: ["\u25B9\u25B9\u25B9\u25B9\u25B9", "\u25B8\u25B9\u25B9\u25B9\u25B9", "\u25B9\u25B8\u25B9\u25B9\u25B9", "\u25B9\u25B9\u25B8\u25B9\u25B9", "\u25B9\u25B9\u25B9\u25B8\u25B9", "\u25B9\u25B9\u25B9\u25B9\u25B8"] },
+  bouncingBar: { interval: 80, frames: ["[    ]", "[=   ]", "[==  ]", "[=== ]", "[====]", "[ ===]", "[  ==]", "[   =]", "[    ]", "[   =]", "[  ==]", "[ ===]", "[====]", "[=== ]", "[==  ]", "[=   ]"] },
+  bouncingBall: { interval: 80, frames: ["( \u25CF    )", "(  \u25CF   )", "(   \u25CF  )", "(    \u25CF )", "(     \u25CF)", "(    \u25CF )", "(   \u25CF  )", "(  \u25CF   )", "( \u25CF    )", "(\u25CF     )"] },
+  simpleDots: { interval: 400, frames: [".  ", ".. ", "...", "   "] },
+  aesthetic: { interval: 80, frames: ["\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1", "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0", "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1"] },
+  star: { interval: 70, frames: ["\u2736", "\u2738", "\u2739", "\u273A", "\u2739", "\u2737"] }
+};
+var DEFAULT_SPINNER = "circle";
+function resolveSpinner(config) {
+  if (!config) {
+    return spinners[DEFAULT_SPINNER];
+  }
+  if (typeof config === "string") {
+    if (config in spinners) {
+      return spinners[config];
+    }
+    throw new Error(`Unknown spinner preset: "${config}". Available: ${Object.keys(spinners).join(", ")}`);
+  }
+  return {
+    frames: config.frames,
+    interval: config.interval ?? 80
+  };
+}
+
+// src/theme.ts
 var DEFAULT_TOKENS = {
   primary: "#5B9BD5",
   success: "#6BCB77",
@@ -786,7 +929,8 @@ var DEFAULT_ICONS = {
   pointer: "\u203A"
 };
 function resolveTheme(themeConfig) {
-  const tokens = { ...DEFAULT_TOKENS, ...themeConfig?.tokens };
+  const presetTokens = themeConfig?.preset ? THEME_PRESETS[themeConfig.preset] : void 0;
+  const tokens = { ...DEFAULT_TOKENS, ...presetTokens, ...themeConfig?.tokens };
   const icons = { ...DEFAULT_ICONS, ...themeConfig?.icons };
   return {
     primary: chalk.hex(tokens.primary),
@@ -797,7 +941,8 @@ function resolveTheme(themeConfig) {
     muted: chalk.hex(tokens.muted),
     accent: chalk.hex(tokens.accent),
     bold: chalk.bold,
-    icons
+    icons,
+    spinner: resolveSpinner(themeConfig?.spinner)
   };
 }
 
@@ -824,6 +969,8 @@ function resolveEnvDefaultBoolean(value) {
 
 // src/runner.ts
 import { execSync } from "child_process";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { pathToFileURL } from "url";
 
 // src/renderers/inquirer.ts
 import {
@@ -1024,6 +1171,17 @@ function resolveTemplate(template, answers) {
     return _match;
   });
 }
+function resolveTemplateStrict(template, answers) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_match, key) => {
+    const trimmedKey = key.trim();
+    if (!(trimmedKey in answers)) {
+      throw new Error(`Action references unknown step "${trimmedKey}"`);
+    }
+    const value = answers[trimmedKey];
+    if (Array.isArray(value)) return value.join(", ");
+    return String(value);
+  });
+}
 
 // src/banner.ts
 import figlet from "figlet";
@@ -1131,14 +1289,66 @@ function clearCache(wizardName, customDir) {
   }
 }
 
-// src/mru.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync } from "fs";
+// src/progress.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
-var MRU_DIR = join2(homedir2(), ".config", "grimoire", "mru");
+var DEFAULT_PROGRESS_DIR = join2(homedir2(), ".config", "grimoire", "progress");
+function getProgressFilePath(wizardName, customDir) {
+  const dir = customDir ?? DEFAULT_PROGRESS_DIR;
+  return join2(dir, `${slugify(wizardName)}.json`);
+}
+function saveProgress(wizardName, state, customDir, excludeStepIds) {
+  try {
+    const dir = customDir ?? DEFAULT_PROGRESS_DIR;
+    mkdirSync2(dir, { recursive: true });
+    const excludeSet = new Set(excludeStepIds ?? []);
+    const filteredAnswers = {};
+    for (const [key, value] of Object.entries(state.answers)) {
+      if (!excludeSet.has(key)) {
+        filteredAnswers[key] = value;
+      }
+    }
+    const progress = {
+      currentStepId: state.currentStepId,
+      answers: filteredAnswers,
+      history: state.history,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const filePath = getProgressFilePath(wizardName, customDir);
+    writeFileSync2(filePath, JSON.stringify(progress, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function loadProgress(wizardName, customDir) {
+  try {
+    const filePath = getProgressFilePath(wizardName, customDir);
+    const raw = readFileSync3(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "currentStepId" in parsed && "answers" in parsed && "history" in parsed && "savedAt" in parsed) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function clearProgress(wizardName, customDir) {
+  try {
+    const filePath = getProgressFilePath(wizardName, customDir);
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+
+// src/mru.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var MRU_DIR = join3(homedir3(), ".config", "grimoire", "mru");
 function getMruFilePath(wizardName) {
   const safeName = wizardName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join2(MRU_DIR, `${safeName}.json`);
+  return join3(MRU_DIR, `${safeName}.json`);
 }
 function loadMruData(wizardName) {
   const filePath = getMruFilePath(wizardName);
@@ -1146,7 +1356,7 @@ function loadMruData(wizardName) {
     if (!existsSync(filePath)) {
       return {};
     }
-    const raw = readFileSync3(filePath, "utf-8");
+    const raw = readFileSync4(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return {};
@@ -1159,8 +1369,8 @@ function loadMruData(wizardName) {
 function saveMruData(wizardName, data) {
   const filePath = getMruFilePath(wizardName);
   try {
-    mkdirSync2(MRU_DIR, { recursive: true });
-    writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    mkdirSync3(MRU_DIR, { recursive: true });
+    writeFileSync3(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
@@ -1216,20 +1426,28 @@ function clearMruData(wizardName) {
   const filePath = getMruFilePath(wizardName);
   try {
     if (existsSync(filePath)) {
-      writeFileSync2(filePath, "{}", "utf-8");
+      writeFileSync3(filePath, "{}", "utf-8");
     }
   } catch {
   }
 }
 
 // src/runner.ts
-function runPreFlightChecks(checks, theme) {
+function emitEvent(renderer, event, theme) {
+  if (renderer.onEvent) {
+    renderer.onEvent(event, theme);
+  }
+}
+function runPreFlightChecks(checks, theme, renderer) {
+  if (renderer) emitEvent(renderer, { type: "checks:start", checks }, theme);
   for (const check of checks) {
     try {
       execSync(check.run, { stdio: "pipe" });
       console.log(`  ${theme.success("\u2713")} ${check.name}`);
+      if (renderer) emitEvent(renderer, { type: "check:pass", name: check.name }, theme);
     } catch {
       console.log(`  ${theme.error("\u2717")} ${check.name}: ${check.message}`);
+      if (renderer) emitEvent(renderer, { type: "check:fail", name: check.name, message: check.message }, theme);
       throw new Error(`Pre-flight check failed: ${check.name} \u2014 ${check.message}`);
     }
   }
@@ -1239,7 +1457,7 @@ function getMockValue(step, mockAnswers) {
   if (step.id in mockAnswers) {
     return mockAnswers[step.id];
   }
-  if (step.type === "message") {
+  if (step.type === "message" || step.type === "note") {
     return true;
   }
   const defaultValue = getStepDefault(step);
@@ -1267,6 +1485,7 @@ function getStepDefault(step) {
       return step.default;
     case "password":
     case "message":
+    case "note":
       return void 0;
   }
 }
@@ -1280,6 +1499,21 @@ async function runWizard(config, options) {
   const cacheDir = typeof options?.cache === "object" ? options.cache.dir : void 0;
   const mruEnabled = !isMock && options?.mru !== false;
   let state = createWizardState(config);
+  const resumeEnabled = !isMock && options?.resume !== false;
+  if (resumeEnabled) {
+    const saved = loadProgress(config.meta.name);
+    if (saved) {
+      const stepExists = config.steps.some((s) => s.id === saved.currentStepId);
+      if (stepExists) {
+        state = {
+          ...state,
+          currentStepId: saved.currentStepId,
+          answers: { ...state.answers, ...saved.answers },
+          history: saved.history
+        };
+      }
+    }
+  }
   const cachedAnswers = cacheEnabled ? loadCachedAnswers(config.meta.name, cacheDir) : void 0;
   const userPlugins = options?.plugins;
   if (userPlugins) {
@@ -1289,103 +1523,174 @@ async function runWizard(config, options) {
   }
   try {
     if (!isMock && config.checks && config.checks.length > 0) {
-      runPreFlightChecks(config.checks, theme);
+      runPreFlightChecks(config.checks, theme, renderer);
     }
     if (!quiet) {
       printWizardHeader(config, theme, options?.plain);
     }
-    let previousGroup;
-    while (state.status === "running") {
-      const visibleSteps = getVisibleSteps(config, state.answers);
-      const currentStep = config.steps.find((s) => s.id === state.currentStepId);
-      if (!currentStep) {
-        throw new Error(`Current step not found: "${state.currentStepId}"`);
-      }
-      if (!isMock) {
+    const visibleStepsForCount = getVisibleSteps(config, state.answers);
+    emitEvent(renderer, { type: "session:start", wizard: config.meta.name, description: config.meta.description, totalSteps: visibleStepsForCount.length }, theme);
+    let needsReview = true;
+    while (needsReview) {
+      let previousGroup;
+      while (state.status === "running") {
+        const visibleSteps = getVisibleSteps(config, state.answers);
+        const currentStep = config.steps.find((s) => s.id === state.currentStepId);
+        if (!currentStep) {
+          throw new Error(`Current step not found: "${state.currentStepId}"`);
+        }
         if (currentStep.group !== void 0 && currentStep.group !== previousGroup) {
           const resolvedGroup = resolveTemplate(currentStep.group, state.answers);
-          renderer.renderGroupHeader(resolvedGroup, theme);
+          if (!isMock) {
+            renderer.renderGroupHeader(resolvedGroup, theme);
+          }
+          emitEvent(renderer, { type: "group:start", group: resolvedGroup }, theme);
         }
         previousGroup = currentStep.group;
         const stepIndex = visibleSteps.findIndex((s) => s.id === state.currentStepId);
         const resolvedMessage = resolveTemplate(currentStep.message, state.answers);
         const resolvedDescription = currentStep.description ? resolveTemplate(currentStep.description, state.answers) : void 0;
-        renderer.renderStepHeader(stepIndex, visibleSteps.length, resolvedMessage, theme, resolvedDescription);
-      }
-      if (options?.onBeforeStep) {
-        await options.onBeforeStep(currentStep.id, currentStep, state);
-      }
-      const pluginStep = getPluginStep(currentStep.type);
-      const resolvedStep = pluginStep ? currentStep : resolveStepDefaults(currentStep, cachedAnswers);
-      const withTemplate = options?.templateAnswers ? applyTemplateDefaults(resolvedStep, options.templateAnswers) : resolvedStep;
-      const templatedStep = resolveStepTemplates(withTemplate, state.answers);
-      const mruStep = mruEnabled ? applyMruOrdering(templatedStep, config.meta.name) : templatedStep;
-      try {
-        const value = isMock ? getMockValue(mruStep, mockAnswers) : pluginStep ? await pluginStep.render(toStepRecord(mruStep), state, theme) : await renderStep(renderer, mruStep, state, theme);
-        if (pluginStep?.validate) {
-          const pluginError = pluginStep.validate(value, toStepRecord(templatedStep));
-          if (pluginError) {
+        if (!isMock) {
+          renderer.renderStepHeader(stepIndex, visibleSteps.length, resolvedMessage, theme, resolvedDescription);
+        }
+        emitEvent(renderer, { type: "step:start", stepId: currentStep.id, stepIndex, totalVisible: visibleSteps.length, step: currentStep }, theme);
+        if (currentStep.type === "note") {
+          emitEvent(renderer, { type: "note", title: resolvedMessage, body: resolvedDescription ?? "" }, theme);
+        }
+        if (options?.onBeforeStep) {
+          await options.onBeforeStep(currentStep.id, currentStep, state);
+        }
+        const pluginStep = getPluginStep(currentStep.type);
+        const resolvedStep = pluginStep ? currentStep : resolveStepDefaults(currentStep, cachedAnswers);
+        const withTemplate = options?.templateAnswers ? applyTemplateDefaults(resolvedStep, options.templateAnswers) : resolvedStep;
+        const templatedStep = resolveStepTemplates(withTemplate, state.answers);
+        const mruStep = mruEnabled ? applyMruOrdering(templatedStep, config.meta.name) : templatedStep;
+        try {
+          const value = isMock ? getMockValue(mruStep, mockAnswers) : pluginStep ? await pluginStep.render(toStepRecord(mruStep), state, theme) : await renderStep(renderer, mruStep, state, theme);
+          if (pluginStep?.validate) {
+            const pluginError = pluginStep.validate(value, toStepRecord(templatedStep));
+            if (pluginError) {
+              if (isMock) {
+                throw new Error(
+                  `Mock mode: validation failed for step "${currentStep.id}": ${pluginError}`
+                );
+              }
+              console.log(theme.error(`
+  ${pluginError}
+`));
+              continue;
+            }
+          }
+          const nextState = wizardReducer(state, { type: "NEXT", value }, config);
+          if (nextState.errors[currentStep.id]) {
+            const errorMsg = resolveTemplate(nextState.errors[currentStep.id] ?? "", state.answers);
+            emitEvent(renderer, { type: "step:error", stepId: currentStep.id, error: errorMsg }, theme);
             if (isMock) {
               throw new Error(
-                `Mock mode: validation failed for step "${currentStep.id}": ${pluginError}`
+                `Mock mode: validation failed for step "${currentStep.id}": ${errorMsg}`
               );
             }
             console.log(theme.error(`
-  ${pluginError}
+  ${errorMsg}
 `));
+            state = { ...nextState, errors: {} };
             continue;
           }
-        }
-        const nextState = wizardReducer(state, { type: "NEXT", value }, config);
-        if (nextState.errors[currentStep.id]) {
-          const errorMsg = resolveTemplate(nextState.errors[currentStep.id] ?? "", state.answers);
-          if (isMock) {
-            throw new Error(
-              `Mock mode: validation failed for step "${currentStep.id}": ${errorMsg}`
-            );
-          }
-          console.log(theme.error(`
-  ${errorMsg}
-`));
-          state = { ...nextState, errors: {} };
-          continue;
-        }
-        if (!isMock && options?.asyncValidate) {
-          const asyncError = await options.asyncValidate(currentStep.id, value, nextState.answers);
-          if (asyncError !== null) {
-            console.log(theme.error(`
+          if (!isMock && options?.asyncValidate) {
+            const asyncError = await options.asyncValidate(currentStep.id, value, nextState.answers);
+            if (asyncError !== null) {
+              console.log(theme.error(`
   ${asyncError}
 `));
-            state = { ...nextState, errors: {} };
-            continue;
+              state = { ...nextState, errors: {} };
+              continue;
+            }
           }
+          if (options?.onAfterStep) {
+            await options.onAfterStep(currentStep.id, value, nextState);
+          }
+          state = nextState;
+          emitEvent(renderer, { type: "step:complete", stepId: currentStep.id, value, step: currentStep }, theme);
+          if (mruEnabled && isSelectLikeStep(currentStep.type)) {
+            recordSelection(config.meta.name, currentStep.id, value);
+          }
+          options?.onStepComplete?.(currentStep.id, value, state);
+        } catch (error) {
+          if (!isMock && isUserCancel(error)) {
+            state = wizardReducer(state, { type: "CANCEL" }, config);
+            options?.onCancel?.(state);
+            const passwordStepIds = config.steps.filter((s) => s.type === "password").map((s) => s.id);
+            saveProgress(config.meta.name, {
+              currentStepId: state.currentStepId,
+              answers: state.answers,
+              history: state.history
+            }, void 0, passwordStepIds);
+            emitEvent(renderer, { type: "session:end", answers: state.answers, cancelled: true }, theme);
+            if (!quiet) {
+              console.log(theme.warning("\n  Wizard cancelled.\n"));
+            }
+            return state.answers;
+          }
+          throw error;
         }
-        if (options?.onAfterStep) {
-          await options.onAfterStep(currentStep.id, value, nextState);
+      }
+      if (config.meta.review && !isMock && state.status === "done") {
+        const reviewLines = [];
+        for (const step of config.steps) {
+          const answer = state.answers[step.id];
+          if (answer === void 0) continue;
+          const display = step.type === "password" ? "****" : Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+          reviewLines.push(`${step.id}: ${display}`);
         }
-        state = nextState;
-        if (mruEnabled && isSelectLikeStep(currentStep.type)) {
-          recordSelection(config.meta.name, currentStep.id, value);
+        emitEvent(renderer, { type: "note", title: "Review your answers", body: reviewLines.join("\n") }, theme);
+        console.log(`
+  ${theme.bold("Review your answers:")}
+`);
+        for (const line of reviewLines) {
+          console.log(`  ${line}`);
         }
-        options?.onStepComplete?.(currentStep.id, value, state);
-      } catch (error) {
-        if (!isMock && isUserCancel(error)) {
-          state = wizardReducer(state, { type: "CANCEL" }, config);
-          options?.onCancel?.(state);
-          if (!quiet) {
-            console.log(theme.warning("\n  Wizard cancelled.\n"));
-          }
-          return state.answers;
+        console.log();
+        const { confirm: confirmPrompt } = await import("@inquirer/prompts");
+        const ok = await confirmPrompt({
+          message: "Everything look right?",
+          default: true
+        });
+        if (ok) {
+          needsReview = false;
+        } else {
+          const { select: selectPrompt } = await import("@inquirer/prompts");
+          const stepsWithAnswers = config.steps.filter(
+            (s) => state.answers[s.id] !== void 0 && s.type !== "note" && s.type !== "message"
+          );
+          const stepToRevisit = await selectPrompt({
+            message: "Which step would you like to change?",
+            choices: stepsWithAnswers.map((s) => ({
+              name: `${s.id}: ${s.type === "password" ? "****" : String(state.answers[s.id] ?? "")}`,
+              value: s.id
+            }))
+          });
+          state = {
+            ...state,
+            currentStepId: stepToRevisit,
+            status: "running"
+          };
         }
-        throw error;
+      } else {
+        needsReview = false;
       }
     }
     if (state.status === "done" && !quiet) {
       renderer.renderSummary(state.answers, config.steps, theme);
     }
-    if (state.status === "done" && config.actions && config.actions.length > 0 && !isMock) {
-      await executeActions(config.actions, state.answers, theme);
+    if (state.status === "done" && !isMock) {
+      if (config.onComplete) {
+        await executeOnComplete(config.onComplete, options?.configFilePath, state.answers, config, theme, renderer);
+      }
+      if (config.actions && config.actions.length > 0) {
+        await executeActions(config.actions, state.answers, theme, renderer);
+      }
     }
+    emitEvent(renderer, { type: "session:end", answers: state.answers, cancelled: state.status === "cancelled" }, theme);
     if (state.status === "done" && cacheEnabled) {
       const passwordStepIds = new Set(
         config.steps.filter((s) => s.type === "password").map((s) => s.id)
@@ -1398,6 +1703,9 @@ async function runWizard(config, options) {
       }
       saveCachedAnswers(config.meta.name, answersToCache, cacheDir);
     }
+    if (state.status === "done") {
+      clearProgress(config.meta.name);
+    }
     return state.answers;
   } finally {
     if (userPlugins) {
@@ -1437,6 +1745,8 @@ function renderStep(renderer, step, state, theme) {
     case "message":
       renderer.renderMessage(step, state, theme);
       return Promise.resolve(true);
+    case "note":
+      return Promise.resolve(true);
   }
 }
 function resolveStepDefaults(step, cachedAnswers) {
@@ -1487,6 +1797,7 @@ function resolveStepDefaults(step, cachedAnswers) {
     }
     case "password":
     case "message":
+    case "note":
       return step;
   }
 }
@@ -1496,7 +1807,7 @@ function getCachedDefault(stepId, cachedAnswers) {
 }
 function applyTemplateDefaults(step, templateAnswers) {
   if (!(step.id in templateAnswers)) return step;
-  if (step.type === "password" || step.type === "message") return step;
+  if (step.type === "password" || step.type === "message" || step.type === "note") return step;
   const value = templateAnswers[step.id];
   switch (step.type) {
     case "text":
@@ -1585,13 +1896,34 @@ function resolveStepTemplates(step, answers) {
     case "confirm":
     case "toggle":
     case "message":
+    case "note":
       return {
         ...step,
         description: step.description ? resolveTemplate(step.description, answers) : void 0
       };
   }
 }
-async function executeActions(actions, answers, theme) {
+async function executeOnComplete(handlerPath, configFilePath, answers, config, theme, renderer) {
+  if (renderer) emitEvent(renderer, { type: "oncomplete:start" }, theme);
+  const resolvedPath = configFilePath ? resolve2(dirname2(configFilePath), handlerPath) : resolve2(handlerPath);
+  try {
+    const mod = await import(pathToFileURL(resolvedPath).href);
+    if (typeof mod.default !== "function") {
+      throw new Error(`onComplete handler "${handlerPath}" must export a default function`);
+    }
+    await mod.default({ answers, config });
+    if (renderer) emitEvent(renderer, { type: "oncomplete:pass" }, theme);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (renderer) emitEvent(renderer, { type: "oncomplete:fail", error: message }, theme);
+    console.log(`
+  ${theme.error("\u2717")} onComplete handler failed: ${message}
+`);
+    throw error;
+  }
+}
+async function executeActions(actions, answers, theme, renderer) {
+  if (renderer) emitEvent(renderer, { type: "actions:start" }, theme);
   console.log(`
   ${theme.bold("Running actions...")}
 `);
@@ -1599,14 +1931,16 @@ async function executeActions(actions, answers, theme) {
     if (action.when && !evaluateCondition(action.when, answers)) {
       continue;
     }
-    const resolvedCommand = resolveTemplate(action.run, answers);
-    const resolvedName = action.name ? resolveTemplate(action.name, answers) : void 0;
+    const resolvedCommand = resolveTemplateStrict(action.run, answers);
+    const resolvedName = action.name ? resolveTemplateStrict(action.name, answers) : void 0;
     const label = resolvedName ?? resolvedCommand;
     try {
       execSync(resolvedCommand, { stdio: "pipe" });
       console.log(`  ${theme.success("\u2713")} ${label}`);
+      if (renderer) emitEvent(renderer, { type: "action:pass", name: label }, theme);
     } catch {
       console.log(`  ${theme.error("\u2717")} ${label}`);
+      if (renderer) emitEvent(renderer, { type: "action:fail", name: label }, theme);
       throw new Error(`Action failed: ${label}`);
     }
   }
@@ -1827,21 +2161,201 @@ var InkRenderer = class {
   }
 };
 
+// src/renderers/clack.ts
+import chalk2 from "chalk";
+
+// src/renderers/symbols.ts
+function isUnicodeSupported() {
+  if (process.platform === "win32") {
+    return Boolean(process.env["WT_SESSION"]) || process.env["TERM_PROGRAM"] === "vscode";
+  }
+  return process.env["TERM"] !== "linux";
+}
+var unicode = isUnicodeSupported();
+var u = (unicodeChar, fallback) => unicode ? unicodeChar : fallback;
+var S_BAR_START = u("\u250C", "T");
+var S_BAR = u("\u2502", "|");
+var S_BAR_END = u("\u2514", "\u2014");
+var S_STEP_ACTIVE = u("\u25C6", "*");
+var S_STEP_SUBMIT = u("\u25C7", "o");
+var S_STEP_CANCEL = u("\u25A0", "x");
+var S_STEP_ERROR = u("\u25B2", "x");
+var S_CORNER_TR = u("\u256E", "+");
+var S_CORNER_BR = u("\u256F", "+");
+var S_BAR_H = u("\u2500", "-");
+
+// src/renderers/clack.ts
+var ClackRenderer = class extends InquirerRenderer {
+  spinnerInterval;
+  spinnerFrameIndex = 0;
+  renderStepHeader() {
+  }
+  renderGroupHeader() {
+  }
+  renderSummary(answers, steps, theme) {
+    const entries = [];
+    for (const step of steps) {
+      const answer = answers[step.id];
+      if (answer === void 0) continue;
+      const display = Array.isArray(answer) ? answer.map(String).join(", ") : String(answer);
+      entries.push({ id: step.id, display });
+    }
+    if (entries.length === 0) return;
+    const title = "Summary";
+    const lines = entries.map((e) => `${e.id}: ${e.display}`);
+    this.writeNoteBox(title, lines, theme);
+  }
+  onEvent(event, theme) {
+    switch (event.type) {
+      case "session:start":
+        this.handleSessionStart(event, theme);
+        break;
+      case "session:end":
+        this.handleSessionEnd(event, theme);
+        break;
+      case "step:start":
+        process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+        break;
+      case "step:complete":
+        this.handleStepComplete(event, theme);
+        break;
+      case "step:error":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.error(`${S_STEP_ERROR}  ${event.error}`)}
+`);
+        break;
+      case "step:back":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.muted("\u21A9 Back")}
+`);
+        break;
+      case "group:start":
+        process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.accent(event.group)}
+`);
+        break;
+      case "note":
+        this.writeNoteBox(event.title, event.body.split("\n"), theme);
+        break;
+      case "spinner:start":
+        this.startSpinner(event.message, theme);
+        break;
+      case "spinner:stop":
+        this.stopSpinner(event.message, theme);
+        break;
+      case "checks:start":
+        process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.bold("Running checks...")}
+`);
+        break;
+      case "check:pass":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${event.name}
+`);
+        break;
+      case "check:fail":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.error(S_STEP_ERROR)}  ${event.name}: ${event.message}
+`);
+        break;
+      case "actions:start":
+        process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.bold("Running actions...")}
+`);
+        break;
+      case "action:pass":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${event.name}
+`);
+        break;
+      case "action:fail":
+        process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.error(S_STEP_ERROR)}  ${event.name}
+`);
+        break;
+    }
+  }
+  handleSessionStart(event, theme) {
+    process.stdout.write(`${chalk2.gray(S_BAR_START)}  ${theme.bold(event.wizard)}
+`);
+    if (event.description) {
+      process.stdout.write(`${chalk2.gray(S_BAR)}  ${theme.muted(event.description)}
+`);
+    }
+    process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+  }
+  handleSessionEnd(event, theme) {
+    if (event.cancelled) {
+      process.stdout.write(`${theme.warning(S_STEP_CANCEL)}  Cancelled
+`);
+    } else {
+      process.stdout.write(`${chalk2.gray(S_BAR_END)}  ${theme.success("You're all set!")}
+`);
+    }
+  }
+  handleStepComplete(event, theme) {
+    const displayValue = event.step.type === "password" ? "****" : this.formatValue(event.value);
+    process.stdout.write(
+      `${chalk2.gray(S_STEP_SUBMIT)}  ${event.step.message} ${chalk2.gray("\xB7")} ${theme.muted(displayValue)}
+`
+    );
+  }
+  formatValue(value) {
+    if (Array.isArray(value)) return value.map(String).join(", ");
+    if (typeof value === "boolean") return value ? "Yes" : "No";
+    return String(value);
+  }
+  writeNoteBox(title, lines, _theme) {
+    const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
+    const padded = maxLen + 2;
+    const topLine = `${S_BAR_H.repeat(padded - title.length - 1)}${S_CORNER_TR}`;
+    const bottomLine = `${S_BAR_H.repeat(padded)}${S_CORNER_BR}`;
+    process.stdout.write(`${chalk2.gray(S_BAR)}
+`);
+    process.stdout.write(`${chalk2.gray(S_BAR)}  ${chalk2.gray(`\u256D${S_BAR_H} ${title} ${topLine}`)}
+`);
+    for (const line of lines) {
+      const pad = " ".repeat(maxLen - line.length);
+      process.stdout.write(`${chalk2.gray(S_BAR)}  ${chalk2.gray(S_BAR)} ${line}${pad} ${chalk2.gray(S_BAR)}
+`);
+    }
+    process.stdout.write(`${chalk2.gray(S_BAR)}  ${chalk2.gray(`\u256E${bottomLine}`)}
+`);
+  }
+  startSpinner(message, theme) {
+    this.spinnerFrameIndex = 0;
+    const { frames, interval } = theme.spinner;
+    this.spinnerInterval = setInterval(() => {
+      const frame = frames[this.spinnerFrameIndex % frames.length];
+      process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${chalk2.cyan(frame ?? "")}  ${message}`);
+      this.spinnerFrameIndex++;
+    }, interval);
+  }
+  stopSpinner(message, theme) {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = void 0;
+    }
+    const finalMessage = message ?? "Done";
+    process.stdout.write(`\r${chalk2.gray(S_BAR)}  ${theme.success(S_STEP_SUBMIT)}  ${finalMessage}
+`);
+  }
+};
+
 // src/templates.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-var TEMPLATES_DIR = join3(homedir3(), ".config", "grimoire", "templates");
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var TEMPLATES_DIR = join4(homedir4(), ".config", "grimoire", "templates");
 function getWizardTemplateDir(wizardName) {
-  return join3(TEMPLATES_DIR, slugify(wizardName));
+  return join4(TEMPLATES_DIR, slugify(wizardName));
 }
 function getTemplateFilePath(wizardName, templateName) {
-  return join3(getWizardTemplateDir(wizardName), `${slugify(templateName)}.json`);
+  return join4(getWizardTemplateDir(wizardName), `${slugify(templateName)}.json`);
 }
 function saveTemplate(wizardName, templateName, answers, excludeKeys) {
   try {
     const dir = getWizardTemplateDir(wizardName);
-    mkdirSync3(dir, { recursive: true });
+    mkdirSync4(dir, { recursive: true });
     const filePath = getTemplateFilePath(wizardName, templateName);
     let answersToSave = answers;
     if (excludeKeys && excludeKeys.length > 0) {
@@ -1850,14 +2364,14 @@ function saveTemplate(wizardName, templateName, answers, excludeKeys) {
         Object.entries(answers).filter(([k]) => !excluded.has(k))
       );
     }
-    writeFileSync3(filePath, JSON.stringify(answersToSave, null, 2) + "\n", "utf-8");
+    writeFileSync4(filePath, JSON.stringify(answersToSave, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 function loadTemplate(wizardName, templateName) {
   try {
     const filePath = getTemplateFilePath(wizardName, templateName);
-    const raw = readFileSync4(filePath, "utf-8");
+    const raw = readFileSync5(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
       return parsed;
@@ -1879,16 +2393,46 @@ function listTemplates(wizardName) {
 function deleteTemplate(wizardName, templateName) {
   try {
     const filePath = getTemplateFilePath(wizardName, templateName);
-    unlinkSync2(filePath);
+    unlinkSync3(filePath);
   } catch {
   }
 }
+
+// src/pipeline.ts
+async function runPipeline(steps, globalOptions) {
+  const results = {};
+  let accumulated = {};
+  for (const step of steps) {
+    let config;
+    if (typeof step.config === "string") {
+      const { loadWizardConfig: loadWizardConfig2 } = await Promise.resolve().then(() => (init_parser(), parser_exports));
+      config = await loadWizardConfig2(step.config);
+    } else {
+      config = step.config;
+    }
+    if (step.when && !evaluateCondition(step.when, accumulated)) {
+      continue;
+    }
+    const answers = await runWizard(config, {
+      ...globalOptions,
+      ...step.options,
+      mockAnswers: step.mockAnswers,
+      templateAnswers: accumulated
+    });
+    results[config.meta.name] = answers;
+    accumulated = { ...accumulated, ...answers };
+  }
+  return results;
+}
 export {
+  ClackRenderer,
+  DEFAULT_SPINNER,
   InkRenderer,
   InquirerRenderer,
   clearCache,
   clearMruData,
   clearPlugins,
+  clearProgress,
   createWizardState,
   defineWizard,
   deleteTemplate,
@@ -1900,6 +2444,7 @@ export {
   isStepVisible,
   listTemplates,
   loadCachedAnswers,
+  loadProgress,
   loadTemplate,
   loadWizardConfig,
   parseWizardConfig,
@@ -1909,13 +2454,18 @@ export {
   renderBanner,
   resolveEnvDefault,
   resolveNextStep,
+  resolveSpinner,
   resolveTemplate,
+  resolveTemplateStrict,
   resolveTheme,
+  runPipeline,
   runPreFlightChecks,
   runWizard,
   saveCachedAnswers,
+  saveProgress,
   saveTemplate,
   slugify,
+  spinners,
   validateStepAnswer,
   wizardReducer
 };