@decantr/cli 1.4.0 → 1.5.2

package/dist/{chunk-OTVIAUQG.js → chunk-66RIAQLH.js}

@@ -9,14 +9,14 @@ import {
   scaffoldMinimal,
   scaffoldProject,
   syncRegistry
-} from "./chunk-ZQ5FTYKG.js";
+} from "./chunk-6RJSFLT4.js";
 
 // src/index.ts
-import { readFileSync as readFileSync14, existsSync as existsSync19, readdirSync as readdirSync6 } from "fs";
-import { join as join19, dirname } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
+import { join as join23, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { validateEssence as validateEssence2, evaluateGuard, isV3 as isV36 } from "@decantr/essence-spec";
-import { RegistryAPIClient as RegistryAPIClient2 } from "@decantr/registry";
+import { RegistryAPIClient as RegistryAPIClient3 } from "@decantr/registry";
 
 // src/detect.ts
 import { existsSync, readFileSync } from "fs";
@@ -165,10 +165,10 @@ var CYAN = "\x1B[36m";
 function ask(question, defaultValue) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const prompt = defaultValue ? `${question} ${DIM}(${defaultValue})${RESET}: ` : `${question}: `;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(prompt, (answer) => {
       rl.close();
-      resolve(answer.trim() || defaultValue || "");
+      resolve2(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -361,7 +361,7 @@ function mergeWithDefaults(flags, detected) {
 }
 async function runSimplifiedInit(blueprints) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+  const question = (q) => new Promise((resolve2) => rl.question(q, resolve2));
   console.log("\n? What blueprint would you like to scaffold?\n");
   console.log("  1. Decantr default (recommended)");
   console.log("  2. Search registry...\n");
@@ -962,7 +962,7 @@ var GREEN4 = "\x1B[32m";
 var RED3 = "\x1B[31m";
 var DIM4 = "\x1B[2m";
 var RESET4 = "\x1B[0m";
-async function cmdRefresh(projectRoot = process.cwd()) {
+async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
   const essencePath = join8(projectRoot, "decantr.essence.json");
   if (!existsSync8(essencePath)) {
     console.error(`${RED3}No decantr.essence.json found. Run \`decantr init\` first.${RESET4}`);
@@ -985,7 +985,8 @@ async function cmdRefresh(projectRoot = process.cwd()) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join8(projectRoot, ".decantr", "cache")
+    cacheDir: join8(projectRoot, ".decantr", "cache"),
+    offline: options.offline
   });
   console.log("Regenerating derived files...\n");
   const result = await refreshDerivedFiles(projectRoot, essence, registryClient);
@@ -2200,7 +2201,9 @@ ${YELLOW5}Next step:${RESET8} Ask your AI assistant to read ${BOLD3}.decantr/ana
 `);
 }
 
-// src/index.ts
+// src/commands/magic.ts
+import { join as join19 } from "path";
+import { existsSync as existsSync19 } from "fs";
 var BOLD4 = "\x1B[1m";
 var DIM9 = "\x1B[2m";
 var RESET9 = "\x1B[0m";
@@ -2208,11 +2211,7 @@ var RED7 = "\x1B[31m";
 var GREEN9 = "\x1B[32m";
 var CYAN4 = "\x1B[36m";
 var YELLOW6 = "\x1B[33m";
-function heading(text) {
-  return `
-${BOLD4}${text}${RESET9}
-`;
-}
+var MAGENTA = "\x1B[35m";
 function success(text) {
   return `${GREEN9}${text}${RESET9}`;
 }
@@ -2225,6 +2224,1022 @@ function dim(text) {
 function cyan(text) {
   return `${CYAN4}${text}${RESET9}`;
 }
+var THEME_KEYWORDS = {
+  dark: ["dark", "noir", "midnight"],
+  light: ["light", "bright", "white"],
+  neon: ["neon", "cyber", "cyberpunk", "synthwave"],
+  glass: ["glass", "glassmorphic", "frosted", "translucent"],
+  minimal: ["minimal", "minimalist", "clean", "simple"],
+  warm: ["warm", "cozy", "earthy", "organic"],
+  cool: ["cool", "cold", "icy", "arctic"],
+  corporate: ["corporate", "enterprise", "business", "professional"],
+  playful: ["playful", "fun", "vibrant", "colorful"],
+  brutalist: ["brutalist", "brutal", "raw"],
+  elegant: ["elegant", "luxury", "premium", "refined"],
+  retro: ["retro", "vintage", "nostalgic"]
+};
+var ARCHETYPE_KEYWORDS = {
+  "ai-chatbot": ["chat", "chatbot", "conversational", "ai-chat", "messaging"],
+  "dashboard-analytics": ["dashboard", "analytics", "metrics", "monitoring", "overview"],
+  "marketplace-platform": ["marketplace", "store", "shop", "ecommerce", "e-commerce"],
+  "portfolio-creative": ["portfolio", "showcase", "gallery"],
+  "blog-editorial": ["blog", "editorial", "journal", "magazine", "news"],
+  "docs-knowledge": ["docs", "documentation", "knowledge", "wiki", "help-center"],
+  "admin-panel": ["admin", "panel", "backoffice", "back-office", "management"],
+  "saas-platform": ["saas", "platform", "subscription", "service"],
+  "marketing-saas": ["landing", "marketing", "homepage", "launch"],
+  "social-feed": ["social", "feed", "community", "forum"],
+  "agent-orchestrator": ["agent", "orchestrator", "workflow", "automation", "pipeline"]
+};
+var CONSTRAINT_KEYWORDS = [
+  "mobile-first",
+  "mobile first",
+  "accessible",
+  "accessibility",
+  "a11y",
+  "wcag",
+  "offline",
+  "offline-first",
+  "real-time",
+  "realtime",
+  "real time",
+  "responsive",
+  "high-contrast",
+  "performance",
+  "fast",
+  "seo"
+];
+function parseMagicPrompt(prompt) {
+  const lower = prompt.toLowerCase();
+  const tokens = lower.split(/[\s,;—–\-]+/).filter(Boolean);
+  const themeHints = [];
+  for (const [hint, keywords] of Object.entries(THEME_KEYWORDS)) {
+    if (keywords.some((kw) => tokens.includes(kw) || lower.includes(kw))) {
+      themeHints.push(hint);
+    }
+  }
+  let archetype;
+  let bestArchetypeScore = 0;
+  for (const [archetypeId, keywords] of Object.entries(ARCHETYPE_KEYWORDS)) {
+    const score = keywords.filter((kw) => tokens.includes(kw) || lower.includes(kw)).length;
+    if (score > bestArchetypeScore) {
+      bestArchetypeScore = score;
+      archetype = archetypeId;
+    }
+  }
+  const constraints = [];
+  for (const kw of CONSTRAINT_KEYWORDS) {
+    if (lower.includes(kw)) {
+      constraints.push(kw.replace(/\s+/g, "-"));
+    }
+  }
+  const personalityWords = [
+    "confident",
+    "bold",
+    "sleek",
+    "futuristic",
+    "modern",
+    "classic",
+    "edgy",
+    "sharp",
+    "soft",
+    "rounded",
+    "angular",
+    "geometric",
+    "organic",
+    "fluid",
+    "rigid",
+    "dense",
+    "airy",
+    "spacious",
+    "technical",
+    "creative",
+    "artistic",
+    "industrial",
+    "natural",
+    "techy",
+    "hacker",
+    "startup",
+    "enterprise",
+    "friendly",
+    "serious",
+    "formal",
+    "casual",
+    "approachable",
+    "luxurious",
+    "premium",
+    "polished",
+    "rough",
+    "gritty"
+  ];
+  const personalityHints = personalityWords.filter((w) => tokens.includes(w));
+  const allRecognized = /* @__PURE__ */ new Set([
+    ...Object.values(THEME_KEYWORDS).flat(),
+    ...Object.values(ARCHETYPE_KEYWORDS).flat(),
+    ...CONSTRAINT_KEYWORDS.flatMap((c) => c.split(/\s+/)),
+    ...personalityWords
+  ]);
+  const descTokens = tokens.filter(
+    (t) => !allRecognized.has(t) && t.length > 2
+  );
+  const description = descTokens.length > 0 ? descTokens.join(" ") : prompt.trim();
+  return {
+    description,
+    themeHints,
+    personalityHints,
+    constraints,
+    archetype
+  };
+}
+function resolveTheme(hints) {
+  let mode = "dark";
+  if (hints.includes("light")) mode = "light";
+  if (hints.includes("neon") || hints.includes("glass")) return { style: "obsidianite", mode };
+  if (hints.includes("warm") || hints.includes("elegant")) return { style: "aurealis", mode };
+  if (hints.includes("cool") || hints.includes("minimal")) return { style: "glacialis", mode };
+  if (hints.includes("brutalist")) return { style: "ferrocrete", mode };
+  if (hints.includes("corporate")) return { style: "luminarum", mode };
+  if (hints.includes("playful")) return { style: "solstice", mode };
+  if (hints.includes("retro")) return { style: "oxidian", mode };
+  return { style: "luminarum", mode };
+}
+function buildPersonality(intent) {
+  if (intent.personalityHints.length > 0) {
+    return intent.personalityHints;
+  }
+  if (intent.themeHints.includes("neon")) return ["bold", "futuristic"];
+  if (intent.themeHints.includes("minimal")) return ["clean", "focused"];
+  if (intent.themeHints.includes("corporate")) return ["professional", "reliable"];
+  if (intent.themeHints.includes("playful")) return ["friendly", "energetic"];
+  return ["professional"];
+}
+async function cmdMagic(prompt, projectRoot, options) {
+  console.log("");
+  console.log(`${MAGENTA}${BOLD4} Decantr Magic${RESET9}`);
+  console.log("");
+  const intent = parseMagicPrompt(prompt);
+  console.log(`${BOLD4} Parsed intent:${RESET9}`);
+  console.log(`   Description:  ${intent.description}`);
+  if (intent.themeHints.length > 0) {
+    console.log(`   Theme:        ${intent.themeHints.join(", ")}`);
+  }
+  if (intent.personalityHints.length > 0) {
+    console.log(`   Personality:  ${intent.personalityHints.join(", ")}`);
+  }
+  if (intent.constraints.length > 0) {
+    console.log(`   Constraints:  ${intent.constraints.join(", ")}`);
+  }
+  if (intent.archetype) {
+    console.log(`   Archetype:    ${intent.archetype}`);
+  }
+  console.log("");
+  const essencePath = join19(projectRoot, "decantr.essence.json");
+  if (existsSync19(essencePath)) {
+    console.log(error("  decantr.essence.json already exists in this directory."));
+    console.log(dim("  Remove it first or use a different directory."));
+    process.exitCode = 1;
+    return;
+  }
+  const registryClient = new RegistryClient({
+    cacheDir: join19(projectRoot, ".decantr", "cache"),
+    apiUrl: options.registry,
+    offline: options.offline
+  });
+  const apiAvailable = await registryClient.checkApiAvailability();
+  let matchedBlueprint;
+  let blueprintData;
+  if (apiAvailable) {
+    console.log(dim("  Searching registry for matching blueprints..."));
+    const blueprintsResult = await registryClient.fetchBlueprints();
+    const blueprints = blueprintsResult.data.items;
+    const scored = blueprints.map((bp) => {
+      const bpLower = `${bp.id} ${bp.name || ""} ${bp.description || ""}`.toLowerCase();
+      let score = 0;
+      if (intent.archetype) {
+        const archetypeTokens = intent.archetype.split("-");
+        for (const token of archetypeTokens) {
+          if (bpLower.includes(token)) score += 3;
+        }
+      }
+      const descTokens = intent.description.toLowerCase().split(/\s+/);
+      for (const token of descTokens) {
+        if (token.length > 2 && bpLower.includes(token)) score += 2;
+      }
+      for (const hint of intent.themeHints) {
+        if (bpLower.includes(hint)) score += 1;
+      }
+      return { id: bp.id, name: bp.name, description: bp.description, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    if (best && best.score >= 4) {
+      matchedBlueprint = best.id;
+      console.log("");
+      console.log(`${BOLD4} Matched blueprint:${RESET9} ${cyan(best.id)}`);
+      if (best.description) {
+        console.log(`   ${dim(best.description)}`);
+      }
+      const bpResult = await registryClient.fetchBlueprint(best.id);
+      if (bpResult) {
+        const rawBp = bpResult.data;
+        blueprintData = rawBp.data ?? rawBp;
+      }
+    } else {
+      console.log(dim("  No strong blueprint match found. Using archetype-based scaffold."));
+    }
+  } else {
+    console.log(dim("  Offline mode \u2014 using defaults."));
+  }
+  const themeResolved = resolveTheme(intent.themeHints);
+  const personality = buildPersonality(intent);
+  const initOptions = {
+    blueprint: matchedBlueprint,
+    archetype: intent.archetype || blueprintData?.compose?.[0]?.archetype || blueprintData?.compose?.[0] || "dashboard-analytics",
+    theme: themeResolved.style,
+    mode: themeResolved.mode,
+    shape: "rounded",
+    target: "react",
+    guard: "guided",
+    density: intent.constraints.includes("mobile-first") ? "compact" : "comfortable",
+    shell: "sidebar-main",
+    personality,
+    features: [],
+    existing: false
+  };
+  if (blueprintData) {
+    if (blueprintData.theme?.style) initOptions.theme = blueprintData.theme.style;
+    if (blueprintData.theme?.mode) initOptions.mode = blueprintData.theme.mode;
+    if (blueprintData.theme?.shape) initOptions.shape = blueprintData.theme.shape;
+    if (blueprintData.personality) {
+      initOptions.personality = typeof blueprintData.personality === "string" ? [blueprintData.personality] : blueprintData.personality;
+    }
+    if (intent.personalityHints.length > 0) {
+      const merged = /* @__PURE__ */ new Set([...initOptions.personality, ...intent.personalityHints]);
+      initOptions.personality = [...merged];
+    }
+  }
+  if (options.dryRun) {
+    console.log("");
+    console.log(`${YELLOW6}${BOLD4} Dry run \u2014 no files written${RESET9}`);
+    console.log("");
+    console.log(`   Blueprint:    ${matchedBlueprint || dim("(none \u2014 archetype-based)")}`);
+    console.log(`   Theme:        ${initOptions.theme} (${initOptions.mode})`);
+    console.log(`   Personality:  ${initOptions.personality.join(", ")}`);
+    console.log(`   Archetype:    ${initOptions.archetype}`);
+    console.log(`   Guard:        ${initOptions.guard}`);
+    console.log(`   Density:      ${initOptions.density}`);
+    console.log("");
+    return;
+  }
+  console.log("");
+  const detected = detectProject(projectRoot);
+  let archetypeData;
+  let composedSections;
+  let routeMap;
+  let patternSpecs;
+  let topologyMarkdown = "";
+  let themeData;
+  let recipeData;
+  let blueprintRecipeName;
+  let registrySource = apiAvailable ? "api" : "cache";
+  if (blueprintData?.compose && blueprintData.compose.length > 0) {
+    const entries = blueprintData.compose;
+    const archetypeMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const id = typeof entry === "string" ? entry : entry.archetype;
+      const result2 = await registryClient.fetchArchetype(id);
+      if (result2) {
+        const raw = result2.data;
+        archetypeMap.set(id, raw.data ?? raw);
+      } else {
+        archetypeMap.set(id, null);
+      }
+    }
+    composedSections = composeSections(entries, archetypeMap, blueprintData.overrides);
+    const primaryId = typeof entries[0] === "string" ? entries[0] : entries[0].archetype;
+    initOptions.archetype = primaryId;
+    if (composedSections.sections[0]?.shell) {
+      initOptions.shell = composedSections.sections[0].shell;
+    }
+    const allPages = composedSections.sections.flatMap(
+      (s) => s.pages.map((p) => ({
+        id: p.id,
+        shell: p.shell_override || s.shell,
+        default_layout: p.layout
+      }))
+    );
+    archetypeData = {
+      id: primaryId,
+      pages: allPages,
+      features: composedSections.features
+    };
+    routeMap = {};
+    if (blueprintData.routes) {
+      for (const [path, entry] of Object.entries(blueprintData.routes)) {
+        if (entry.archetype && entry.page) {
+          routeMap[path] = { section: entry.archetype, page: entry.page };
+          const section = composedSections.sections.find((s) => s.id === entry.archetype);
+          const page = section?.pages.find((p) => p.id === entry.page);
+          if (page) page.route = path;
+        }
+      }
+    }
+    const allPatternIds = /* @__PURE__ */ new Set();
+    for (const section of composedSections.sections) {
+      for (const page of section.pages) {
+        if (page.patterns) {
+          for (const ref of page.patterns) allPatternIds.add(ref.pattern);
+        }
+        for (const item of page.layout) {
+          if (typeof item === "string") allPatternIds.add(item);
+        }
+      }
+    }
+    patternSpecs = {};
+    for (const pid of allPatternIds) {
+      try {
+        const result2 = await registryClient.fetchPattern(pid);
+        if (result2) {
+          const raw = result2.data;
+          const inner = raw.data ?? raw;
+          const defaultPreset = inner.default_preset || "standard";
+          const preset = inner.presets?.[defaultPreset];
+          patternSpecs[pid] = {
+            description: inner.description || "",
+            components: inner.components || [],
+            slots: preset?.layout?.slots || {}
+          };
+        }
+      } catch {
+      }
+    }
+    const zoneInputs = [];
+    for (const entry of entries) {
+      const arcId = typeof entry === "string" ? entry : entry.archetype;
+      const archData = archetypeMap.get(arcId);
+      if (archData) {
+        const explicitRole = typeof entry === "object" && "role" in entry ? entry.role : void 0;
+        zoneInputs.push({
+          archetypeId: arcId,
+          role: explicitRole || archData.role || "auxiliary",
+          shell: archData.pages?.[0]?.shell || initOptions.shell,
+          features: archData.features || [],
+          description: archData.description || ""
+        });
+      }
+    }
+    const zones = deriveZones(zoneInputs);
+    const transitions = deriveTransitions(zones);
+    if (zones.length > 0) {
+      topologyMarkdown = generateTopologySection(
+        {
+          intent: blueprintData.description || initOptions.archetype || "Application",
+          zones,
+          transitions,
+          entryPoints: {
+            anonymous: "/",
+            authenticated: `/${archetypeData.pages?.[0]?.id || "home"}`
+          }
+        },
+        initOptions.personality
+      );
+    }
+    blueprintRecipeName = blueprintData.theme?.recipe;
+    console.log(`${BOLD4} Composition:${RESET9}`);
+    console.log(`   Sections:  ${composedSections.sections.length} (${composedSections.sections.map((s) => s.id).join(", ")})`);
+    const totalRoutes = Object.keys(routeMap).length;
+    if (totalRoutes > 0) console.log(`   Routes:    ${totalRoutes}`);
+    if (composedSections.features.length > 0) {
+      console.log(`   Features:  ${composedSections.features.join(", ")}`);
+    }
+    console.log("");
+  } else if (intent.archetype && apiAvailable) {
+    const archResult = await registryClient.fetchArchetype(initOptions.archetype);
+    if (archResult) {
+      const raw = archResult.data;
+      archetypeData = raw.data ?? raw;
+    }
+  }
+  if (apiAvailable && initOptions.theme) {
+    const themeResult = await registryClient.fetchTheme(initOptions.theme);
+    if (themeResult) {
+      const rawTheme = themeResult.data;
+      const theme = rawTheme.data ?? rawTheme;
+      themeData = {
+        seed: theme.seed,
+        palette: theme.palette,
+        tokens: theme.tokens,
+        cvd_support: theme.cvd_support,
+        typography_hints: theme.typography_hints,
+        motion_hints: theme.motion_hints
+      };
+      if (theme.decorators) {
+        recipeData = { decorators: theme.decorators };
+      }
+    }
+    const recipeName = blueprintRecipeName || initOptions.theme;
+    const recipeResult = await registryClient.fetchRecipe(recipeName);
+    if (recipeResult) {
+      const rawRecipe = recipeResult.data;
+      const recipe = rawRecipe.data ?? rawRecipe;
+      recipeData = {
+        decorators: recipe.decorators || recipeData?.decorators,
+        spatial_hints: recipe.spatial_hints,
+        radius_hints: recipe.radius_hints
+      };
+    }
+  }
+  console.log(`${BOLD4} Scaffolding...${RESET9}`);
+  const result = await scaffoldProject(
+    projectRoot,
+    initOptions,
+    detected,
+    registryClient,
+    archetypeData,
+    registrySource,
+    themeData,
+    recipeData,
+    topologyMarkdown,
+    composedSections,
+    routeMap,
+    patternSpecs,
+    blueprintData
+  );
+  console.log(`   ${success("Created")} decantr.essence.json (V3.1)`);
+  console.log(`   ${success("Created")} DECANTR.md`);
+  if (result.cssFiles && result.cssFiles.length > 0) {
+    for (const cssFile of result.cssFiles) {
+      const name = cssFile.split("/").pop();
+      console.log(`   ${success("Created")} src/styles/${name}`);
+    }
+  }
+  if (result.contextFiles && result.contextFiles.length > 0) {
+    const sectionContexts = result.contextFiles.filter((f) => f.includes("section-"));
+    const otherContexts = result.contextFiles.filter((f) => !f.includes("section-"));
+    if (sectionContexts.length > 0) {
+      console.log(`   ${success("Created")} ${sectionContexts.length} section context(s)`);
+    }
+    for (const f of otherContexts) {
+      const name = f.split("/").pop();
+      if (name && !name.startsWith("task-") && !name.startsWith("essence-summary")) {
+        console.log(`   ${success("Created")} ${name}`);
+      }
+    }
+  }
+  if (result.gitignoreUpdated) {
+    console.log(`   ${dim(".gitignore updated")}`);
+  }
+  console.log("");
+  console.log(`${BOLD4} Ready!${RESET9} Next steps:`);
+  console.log(`   1. Read ${cyan("DECANTR.md")} to understand the design system`);
+  console.log(`   2. Read ${cyan(".decantr/context/scaffold.md")} for the full app overview`);
+  console.log(`   3. Start building pages from the route map`);
+  console.log("");
+}
+
+// src/commands/export.ts
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync20, mkdirSync as mkdirSync5 } from "fs";
+import { join as join20, dirname } from "path";
+var GREEN10 = "\x1B[32m";
+var RED8 = "\x1B[31m";
+var DIM10 = "\x1B[2m";
+var RESET10 = "\x1B[0m";
+var SHADCN_MAP = {
+  "--d-bg": "--background",
+  "--d-text": "--foreground",
+  "--d-surface": "--card",
+  "--d-surface-raised": "--popover",
+  "--d-primary": "--primary",
+  "--d-secondary": "--secondary",
+  "--d-accent": "--accent",
+  "--d-border": "--border",
+  "--d-text-muted": "--muted-foreground",
+  "--d-error": "--destructive",
+  "--d-radius": "--radius"
+};
+var TAILWIND_COLOR_MAP = {
+  "--d-primary": "primary",
+  "--d-secondary": "secondary",
+  "--d-accent": "accent",
+  "--d-bg": "background",
+  "--d-surface": "surface",
+  "--d-surface-raised": "surface-raised",
+  "--d-border": "border",
+  "--d-text": "foreground",
+  "--d-text-muted": "muted",
+  "--d-success": "success",
+  "--d-error": "error",
+  "--d-warning": "warning",
+  "--d-info": "info"
+};
+function parseTokensCSS(css) {
+  const tokens = /* @__PURE__ */ new Map();
+  const re = /(--d-[\w-]+)\s*:\s*([^;]+);/g;
+  let match;
+  while ((match = re.exec(css)) !== null) {
+    tokens.set(match[1], match[2].trim());
+  }
+  return tokens;
+}
+function generateShadcnCSS(tokens) {
+  const lines = ["/* Exported by decantr export --to shadcn */", "@layer base {", "  :root {"];
+  for (const [decantrVar, shadcnVar] of Object.entries(SHADCN_MAP)) {
+    const value = tokens.get(decantrVar);
+    if (value) {
+      lines.push(`    ${shadcnVar}: ${value};`);
+    }
+  }
+  const textValue = tokens.get("--d-text");
+  if (textValue) {
+    lines.push(`    --card-foreground: ${textValue};`);
+    lines.push(`    --popover-foreground: ${textValue};`);
+  }
+  const surfaceValue = tokens.get("--d-surface");
+  if (surfaceValue) {
+    lines.push(`    --muted: ${surfaceValue};`);
+  }
+  const accentFg = tokens.get("--d-text");
+  if (accentFg) {
+    lines.push(`    --accent-foreground: ${accentFg};`);
+  }
+  lines.push(`    --destructive-foreground: #FAFAFA;`);
+  lines.push("  }", "}", "");
+  return lines.join("\n");
+}
+function generateShadcnComponentsJSON() {
+  const config = {
+    $schema: "https://ui.shadcn.com/schema.json",
+    style: "default",
+    rsc: false,
+    tsx: true,
+    tailwind: {
+      config: "tailwind.config.ts",
+      css: "src/styles/shadcn-theme.css",
+      baseColor: "zinc"
+    },
+    aliases: {
+      components: "@/components",
+      utils: "@/lib/utils"
+    }
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+function generateTailwindConfig(tokens) {
+  const colors = {};
+  for (const [decantrVar, twName] of Object.entries(TAILWIND_COLOR_MAP)) {
+    const value = tokens.get(decantrVar);
+    if (value) {
+      colors[twName] = value;
+    }
+  }
+  const borderRadius = {};
+  for (const suffix of ["", "-sm", "-lg", "-xl", "-full"]) {
+    const key = `--d-radius${suffix}`;
+    const value = tokens.get(key);
+    if (value) {
+      const name = suffix ? suffix.slice(1) : "DEFAULT";
+      borderRadius[name] = value;
+    }
+  }
+  const boxShadow = {};
+  for (const suffix of ["-sm", "", "-md", "-lg"]) {
+    const key = `--d-shadow${suffix}`;
+    const value = tokens.get(key);
+    if (value) {
+      const name = suffix ? suffix.slice(1) : "DEFAULT";
+      boxShadow[name] = value;
+    }
+  }
+  const lines = [
+    "// Generated by decantr export --to tailwind",
+    "import type { Config } from 'tailwindcss';",
+    "",
+    "export default {",
+    "  theme: {",
+    "    extend: {"
+  ];
+  lines.push("      colors: {");
+  for (const [name, value] of Object.entries(colors)) {
+    lines.push(`        '${name}': '${value}',`);
+  }
+  lines.push("      },");
+  lines.push("      borderRadius: {");
+  for (const [name, value] of Object.entries(borderRadius)) {
+    lines.push(`        '${name}': '${value}',`);
+  }
+  lines.push("      },");
+  lines.push("      boxShadow: {");
+  for (const [name, value] of Object.entries(boxShadow)) {
+    lines.push(`        '${name}': '${value}',`);
+  }
+  lines.push("      },");
+  lines.push("    },", "  },", "} satisfies Partial<Config>;", "");
+  return lines.join("\n");
+}
+function generateCSSVars(tokens) {
+  const lines = ["/* Exported by decantr export --to css-vars */", ":root {"];
+  for (const [key, value] of tokens) {
+    lines.push(`  ${key}: ${value};`);
+  }
+  lines.push("}", "");
+  return lines.join("\n");
+}
+async function cmdExport(target, projectRoot, options = {}) {
+  const essencePath = join20(projectRoot, "decantr.essence.json");
+  const tokensPath = join20(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync20(essencePath)) {
+    console.error(`${RED8}No decantr.essence.json found. Run \`decantr init\` first.${RESET10}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!existsSync20(tokensPath)) {
+    console.error(`${RED8}No src/styles/tokens.css found. Run \`decantr refresh\` to generate tokens.${RESET10}`);
+    process.exitCode = 1;
+    return;
+  }
+  const tokensCSS = readFileSync14(tokensPath, "utf-8");
+  const tokens = parseTokensCSS(tokensCSS);
+  if (tokens.size === 0) {
+    console.error(`${RED8}No --d-* tokens found in tokens.css.${RESET10}`);
+    process.exitCode = 1;
+    return;
+  }
+  switch (target) {
+    case "shadcn": {
+      const cssOut = options.output ?? join20(projectRoot, "src", "styles", "shadcn-theme.css");
+      const jsonOut = join20(projectRoot, "components.json");
+      ensureDir(cssOut);
+      writeFileSync10(cssOut, generateShadcnCSS(tokens), "utf-8");
+      writeFileSync10(jsonOut, generateShadcnComponentsJSON(), "utf-8");
+      console.log(`${GREEN10}Exported shadcn theme:${RESET10}`);
+      console.log(`  ${DIM10}CSS:${RESET10}  ${cssOut}`);
+      console.log(`  ${DIM10}JSON:${RESET10} ${jsonOut}`);
+      break;
+    }
+    case "tailwind": {
+      const out = options.output ?? join20(projectRoot, "tailwind.decantr.config.ts");
+      ensureDir(out);
+      writeFileSync10(out, generateTailwindConfig(tokens), "utf-8");
+      console.log(`${GREEN10}Exported Tailwind config:${RESET10}`);
+      console.log(`  ${DIM10}File:${RESET10} ${out}`);
+      break;
+    }
+    case "css-vars": {
+      const out = options.output ?? join20(projectRoot, "decantr-tokens.css");
+      ensureDir(out);
+      writeFileSync10(out, generateCSSVars(tokens), "utf-8");
+      console.log(`${GREEN10}Exported CSS variables:${RESET10}`);
+      console.log(`  ${DIM10}File:${RESET10} ${out}`);
+      break;
+    }
+  }
+}
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync20(dir)) {
+    mkdirSync5(dir, { recursive: true });
+  }
+}
+
+// src/commands/registry-mirror.ts
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync11 } from "fs";
+import { join as join21 } from "path";
+import { RegistryAPIClient as RegistryAPIClient2 } from "@decantr/registry";
+var GREEN11 = "\x1B[32m";
+var RED9 = "\x1B[31m";
+var DIM11 = "\x1B[2m";
+var CYAN5 = "\x1B[36m";
+var YELLOW7 = "\x1B[33m";
+var RESET11 = "\x1B[0m";
+var ALL_CONTENT_TYPES = [
+  "patterns",
+  "archetypes",
+  "themes",
+  "recipes",
+  "blueprints",
+  "shells"
+];
+async function cmdRegistryMirror(projectRoot, options = {}) {
+  const apiUrl = process.env.DECANTR_API_URL || "https://api.decantr.ai/v1";
+  const apiClient = new RegistryAPIClient2({
+    baseUrl: apiUrl,
+    apiKey: process.env.DECANTR_API_KEY || void 0
+  });
+  const healthy = await apiClient.checkHealth();
+  if (!healthy) {
+    console.error(`${RED9}Registry API is unavailable. Check your connection.${RESET11}`);
+    process.exitCode = 1;
+    return;
+  }
+  const types = options.type ? [options.type] : ALL_CONTENT_TYPES;
+  if (options.type && !ALL_CONTENT_TYPES.includes(options.type)) {
+    console.error(`${RED9}Unknown content type: ${options.type}${RESET11}`);
+    console.error(`${DIM11}Valid types: ${ALL_CONTENT_TYPES.join(", ")}${RESET11}`);
+    process.exitCode = 1;
+    return;
+  }
+  const cacheDir = join21(projectRoot, ".decantr", "cache");
+  const counts = {};
+  const failed = [];
+  console.log(`
+Mirroring registry content to ${DIM11}.decantr/cache/${RESET11}
+`);
+  for (const type of types) {
+    try {
+      const result = await apiClient.listContent(type, { namespace: "@official" });
+      const items = result.items;
+      const typeDir = join21(cacheDir, "@official", type);
+      mkdirSync6(typeDir, { recursive: true });
+      writeFileSync11(join21(typeDir, "index.json"), JSON.stringify(result, null, 2));
+      let itemCount = 0;
+      for (const item of items) {
+        const slug = item.slug || item.id;
+        if (!slug) continue;
+        try {
+          const fullItem = await apiClient.getContent(type, "@official", slug);
+          writeFileSync11(join21(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
+          itemCount++;
+        } catch {
+          writeFileSync11(join21(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
+          itemCount++;
+        }
+      }
+      counts[type] = itemCount;
+      console.log(`  ${GREEN11}\u2713${RESET11} ${type}: ${CYAN5}${itemCount}${RESET11} items`);
+    } catch (e) {
+      failed.push(type);
+      console.log(`  ${RED9}\u2717${RESET11} ${type}: ${e.message}`);
+    }
+  }
+  const manifest = {
+    mirrored_at: (/* @__PURE__ */ new Date()).toISOString(),
+    counts
+  };
+  mkdirSync6(join21(cacheDir), { recursive: true });
+  writeFileSync11(join21(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
+  const totalItems = Object.values(counts).reduce((a, b) => a + b, 0);
+  console.log("");
+  if (failed.length > 0) {
+    console.log(`${YELLOW7}Mirrored ${totalItems} items (${failed.length} type(s) failed)${RESET11}`);
+  } else {
+    console.log(`${GREEN11}Mirrored ${totalItems} items across ${Object.keys(counts).length} types${RESET11}`);
+  }
+  console.log(`${DIM11}Use \`decantr init --offline\` or \`decantr refresh --offline\` to work without API.${RESET11}
+`);
+}
+
+// src/commands/new-project.ts
+import { existsSync as existsSync22, mkdirSync as mkdirSync7, writeFileSync as writeFileSync12 } from "fs";
+import { join as join22, resolve } from "path";
+import { execSync } from "child_process";
+var BOLD5 = "\x1B[1m";
+var DIM12 = "\x1B[2m";
+var RESET12 = "\x1B[0m";
+var RED10 = "\x1B[31m";
+var GREEN12 = "\x1B[32m";
+var CYAN6 = "\x1B[36m";
+var YELLOW8 = "\x1B[33m";
+function heading(text) {
+  return `
+${BOLD5}${text}${RESET12}
+`;
+}
+function success2(text) {
+  return `${GREEN12}${text}${RESET12}`;
+}
+function error2(text) {
+  return `${RED10}${text}${RESET12}`;
+}
+function dim2(text) {
+  return `${DIM12}${text}${RESET12}`;
+}
+function cyan2(text) {
+  return `${CYAN6}${text}${RESET12}`;
+}
+async function cmdNewProject(projectName, options) {
+  const projectDir = resolve(process.cwd(), projectName);
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(projectName)) {
+    console.error(error2("Invalid project name. Use alphanumeric characters, hyphens, dots, or underscores."));
+    process.exitCode = 1;
+    return;
+  }
+  if (existsSync22(projectDir)) {
+    console.error(error2(`Directory "${projectName}" already exists.`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(heading(`Creating ${projectName}...`));
+  mkdirSync7(projectDir, { recursive: true });
+  console.log(dim2(`  Created ${projectName}/`));
+  const packageJson = {
+    name: projectName,
+    private: true,
+    version: "0.0.0",
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "tsc -b && vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      "react": "^19.0.0",
+      "react-dom": "^19.0.0",
+      "react-router-dom": "^7.0.0",
+      "@decantr/css": "^1.0.0"
+    },
+    devDependencies: {
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0",
+      "@vitejs/plugin-react": "^4.0.0",
+      "typescript": "^5.7.0",
+      "vite": "^6.0.0"
+    }
+  };
+  writeFileSync12(join22(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+  console.log(dim2("  Created package.json"));
+  const viteConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});
+`;
+  writeFileSync12(join22(projectDir, "vite.config.ts"), viteConfig);
+  console.log(dim2("  Created vite.config.ts"));
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      isolatedModules: true,
+      moduleDetection: "force",
+      noEmit: true,
+      jsx: "react-jsx",
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      noUncheckedSideEffectImports: true
+    },
+    include: ["src"]
+  };
+  writeFileSync12(join22(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+  const tsconfigApp = {
+    compilerOptions: {
+      tsBuildInfoFile: "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+      target: "ES2020",
+      useDefineForClassFields: true,
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      module: "ESNext",
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      isolatedModules: true,
+      moduleDetection: "force",
+      noEmit: true,
+      jsx: "react-jsx",
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      noUncheckedSideEffectImports: true
+    },
+    include: ["src"]
+  };
+  writeFileSync12(join22(projectDir, "tsconfig.app.json"), JSON.stringify(tsconfigApp, null, 2) + "\n");
+  console.log(dim2("  Created tsconfig.json"));
+  const title = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const indexHtml = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+  writeFileSync12(join22(projectDir, "index.html"), indexHtml);
+  console.log(dim2("  Created index.html"));
+  const srcDir = join22(projectDir, "src");
+  mkdirSync7(srcDir, { recursive: true });
+  const mainTsx = `import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+import { App } from './App';
+import './styles/tokens.css';
+import './styles/decorators.css';
+import './styles/global.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </StrictMode>,
+);
+`;
+  writeFileSync12(join22(srcDir, "main.tsx"), mainTsx);
+  const appTsx = `import { Routes, Route } from 'react-router-dom';
+
+function WelcomePage() {
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', minHeight: '100vh', gap: '1rem' }}>
+      <h1>${title}</h1>
+      <p style={{ opacity: 0.6 }}>Scaffolded with Decantr. Run <code>decantr status</code> to check project health.</p>
+    </div>
+  );
+}
+
+export function App() {
+  return (
+    <Routes>
+      <Route path="/" element={<WelcomePage />} />
+    </Routes>
+  );
+}
+`;
+  writeFileSync12(join22(srcDir, "App.tsx"), appTsx);
+  writeFileSync12(join22(srcDir, "vite-env.d.ts"), '/// <reference types="vite/client" />\n');
+  mkdirSync7(join22(srcDir, "styles"), { recursive: true });
+  console.log(dim2("  Created src/"));
+  console.log(heading("Installing dependencies..."));
+  const packageManager = detectPackageManager();
+  try {
+    execSync(`${packageManager} install`, { cwd: projectDir, stdio: "inherit" });
+  } catch {
+    console.log(`
+${YELLOW8}Dependency install failed. Run \`${packageManager} install\` manually.${RESET12}`);
+  }
+  console.log(heading("Initializing Decantr..."));
+  const initFlags = ["--yes", "--existing"];
+  if (options.blueprint) initFlags.push(`--blueprint=${options.blueprint}`);
+  if (options.archetype) initFlags.push(`--archetype=${options.archetype}`);
+  if (options.theme) initFlags.push(`--theme=${options.theme}`);
+  if (options.mode) initFlags.push(`--mode=${options.mode}`);
+  if (options.shape) initFlags.push(`--shape=${options.shape}`);
+  if (options.offline) initFlags.push("--offline");
+  if (options.registry) initFlags.push(`--registry=${options.registry}`);
+  try {
+    const cliBin = join22(__dirname, "..", "bin", "decantr.js");
+    const cliPath = existsSync22(cliBin) ? `node ${cliBin}` : "npx decantr";
+    execSync(`${cliPath} init ${initFlags.join(" ")}`, { cwd: projectDir, stdio: "inherit" });
+  } catch {
+    console.log(`
+${YELLOW8}Decantr init encountered issues. Run \`decantr init\` manually inside ${projectName}/.${RESET12}`);
+  }
+  console.log(success2(`
+\u2713 Project "${projectName}" created!
+`));
+  console.log(`  ${cyan2("cd " + projectName)}`);
+  console.log(`  ${cyan2(packageManager + " run dev")}`);
+  console.log("");
+}
+function detectPackageManager() {
+  if (existsSync22(join22(process.cwd(), "pnpm-lock.yaml")) || existsSync22(join22(process.cwd(), "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync22(join22(process.cwd(), "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync22(join22(process.cwd(), "bun.lockb")) || existsSync22(join22(process.cwd(), "bun.lock"))) {
+    return "bun";
+  }
+  return "npm";
+}
+
+// src/index.ts
+var BOLD6 = "\x1B[1m";
+var DIM13 = "\x1B[2m";
+var RESET13 = "\x1B[0m";
+var RED11 = "\x1B[31m";
+var GREEN13 = "\x1B[32m";
+var CYAN7 = "\x1B[36m";
+var YELLOW9 = "\x1B[33m";
+function heading2(text) {
+  return `
+${BOLD6}${text}${RESET13}
+`;
+}
+function success3(text) {
+  return `${GREEN13}${text}${RESET13}`;
+}
+function error3(text) {
+  return `${RED11}${text}${RESET13}`;
+}
+function dim3(text) {
+  return `${DIM13}${text}${RESET13}`;
+}
+function cyan3(text) {
+  return `${CYAN7}${text}${RESET13}`;
+}
 function extractPatternName(item) {
   if (typeof item === "string") return item;
   if (typeof item === "object" && item !== null) {
@@ -2267,7 +3282,7 @@ function boxedPrompt(content, title) {
   const maxLen = Math.max(...lines.map((l) => l.length), title.length + 4);
   const width = maxLen + 4;
   const top = `\u250C${"\u2500".repeat(width - 2)}\u2510`;
-  const titleLine = `\u2502 ${BOLD4}${title}${RESET9}${" ".repeat(width - title.length - 4)} \u2502`;
+  const titleLine = `\u2502 ${BOLD6}${title}${RESET13}${" ".repeat(width - title.length - 4)} \u2502`;
   const sep2 = `\u251C${"\u2500".repeat(width - 2)}\u2524`;
   const bottom = `\u2514${"\u2500".repeat(width - 2)}\u2518`;
   const body = lines.map((line) => {
@@ -2281,7 +3296,7 @@ ${body}
 ${bottom}`;
 }
 function getAPIClient() {
-  return new RegistryAPIClient2({
+  return new RegistryAPIClient3({
     baseUrl: process.env.DECANTR_API_URL || void 0,
     apiKey: process.env.DECANTR_API_KEY || void 0
   });
@@ -2292,17 +3307,17 @@ async function cmdSearch(query, type) {
     const response = await apiClient.search({ q: query, type });
     const results = response.results;
     if (results.length === 0) {
-      console.log(dim(`No results for "${query}"`));
+      console.log(dim3(`No results for "${query}"`));
       return;
     }
-    console.log(heading(`${results.length} result(s) for "${query}"`));
+    console.log(heading2(`${results.length} result(s) for "${query}"`));
     for (const r of results) {
-      console.log(`  ${cyan(r.type.padEnd(12))} ${BOLD4}${r.slug}${RESET9}`);
-      console.log(`  ${dim(r.description || "")}`);
+      console.log(`  ${cyan3(r.type.padEnd(12))} ${BOLD6}${r.slug}${RESET13}`);
+      console.log(`  ${dim3(r.description || "")}`);
       console.log("");
     }
   } catch {
-    console.log(dim(`Search failed. API may be unavailable.`));
+    console.log(dim3(`Search failed. API may be unavailable.`));
   }
 }
 async function cmdSuggest(query, type) {
@@ -2312,40 +3327,40 @@ async function cmdSuggest(query, type) {
     const response = await apiClient.search({ q: query, type: searchType });
     const results = response.results;
     if (results.length === 0) {
-      console.log(dim(`No suggestions for "${query}"`));
+      console.log(dim3(`No suggestions for "${query}"`));
       console.log("");
       console.log("Try:");
-      console.log(`  ${cyan("decantr list patterns")} - see all patterns`);
-      console.log(`  ${cyan("decantr search <broader-term>")} - broaden your search`);
+      console.log(`  ${cyan3("decantr list patterns")} - see all patterns`);
+      console.log(`  ${cyan3("decantr search <broader-term>")} - broaden your search`);
       return;
     }
-    console.log(heading(`Suggestions for "${query}"`));
+    console.log(heading2(`Suggestions for "${query}"`));
     const queryLower = query.toLowerCase();
     const exact = results.filter((r) => r.slug.toLowerCase().includes(queryLower));
     const related = results.filter((r) => !r.slug.toLowerCase().includes(queryLower));
     if (exact.length > 0) {
-      console.log(`${BOLD4}Direct matches:${RESET9}`);
+      console.log(`${BOLD6}Direct matches:${RESET13}`);
       for (const r of exact.slice(0, 3)) {
-        console.log(`  ${cyan(r.slug)} - ${r.description || ""}`);
+        console.log(`  ${cyan3(r.slug)} - ${r.description || ""}`);
       }
       console.log("");
     }
     if (related.length > 0) {
-      console.log(`${BOLD4}Related:${RESET9}`);
+      console.log(`${BOLD6}Related:${RESET13}`);
       for (const r of related.slice(0, 5)) {
-        console.log(`  ${cyan(r.slug)} - ${r.description || ""}`);
+        console.log(`  ${cyan3(r.slug)} - ${r.description || ""}`);
       }
       console.log("");
     }
-    console.log(dim(`Use "decantr get pattern <id>" for full details`));
+    console.log(dim3(`Use "decantr get pattern <id>" for full details`));
   } catch {
-    console.log(dim(`Suggestion search failed. API may be unavailable.`));
+    console.log(dim3(`Suggestion search failed. API may be unavailable.`));
   }
 }
 async function cmdGet(type, id) {
   const validTypes = ["pattern", "archetype", "recipe", "theme", "blueprint", "shell"];
   if (!validTypes.includes(type)) {
-    console.error(error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
+    console.error(error3(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
     process.exitCode = 1;
     return;
   }
@@ -2359,29 +3374,29 @@ async function cmdGet(type, id) {
   };
   const apiType = typeMap[type];
   const registryClient = new RegistryClient({
-    cacheDir: join19(process.cwd(), ".decantr", "cache")
+    cacheDir: join23(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
     console.log(JSON.stringify(result.data, null, 2));
     return;
   }
-  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const currentDir = dirname2(fileURLToPath(import.meta.url));
   const bundledCandidates = [
-    join19(currentDir, "bundled", apiType, `${id}.json`),
+    join23(currentDir, "bundled", apiType, `${id}.json`),
     // Running from src/
-    join19(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
+    join23(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
     // Running from dist/
-    join19(currentDir, "..", "bundled", apiType, `${id}.json`)
+    join23(currentDir, "..", "bundled", apiType, `${id}.json`)
     // Alternative dist layout
   ];
-  const bundledPath = bundledCandidates.find((p) => existsSync19(p)) || null;
+  const bundledPath = bundledCandidates.find((p) => existsSync23(p)) || null;
   if (bundledPath) {
-    const data = JSON.parse(readFileSync14(bundledPath, "utf-8"));
+    const data = JSON.parse(readFileSync15(bundledPath, "utf-8"));
     console.log(JSON.stringify(data, null, 2));
     return;
   }
-  console.error(error(`${type} "${id}" not found.`));
+  console.error(error3(`${type} "${id}" not found.`));
   process.exitCode = 1;
   return;
 }
@@ -2389,13 +3404,13 @@ function buildRegistryContext() {
   const themeRegistry = /* @__PURE__ */ new Map();
   const patternRegistry = /* @__PURE__ */ new Map();
   const projectRoot = process.cwd();
-  const cacheDir = join19(projectRoot, ".decantr", "cache");
-  const customDir = join19(projectRoot, ".decantr", "custom");
-  const cachedThemesDir = join19(cacheDir, "@official", "themes");
+  const cacheDir = join23(projectRoot, ".decantr", "cache");
+  const customDir = join23(projectRoot, ".decantr", "custom");
+  const cachedThemesDir = join23(cacheDir, "@official", "themes");
   try {
-    if (existsSync19(cachedThemesDir)) {
+    if (existsSync23(cachedThemesDir)) {
       for (const f of readdirSync6(cachedThemesDir).filter((f2) => f2.endsWith(".json") && f2 !== "index.json")) {
-        const data = JSON.parse(readFileSync14(join19(cachedThemesDir, f), "utf-8"));
+        const data = JSON.parse(readFileSync15(join23(cachedThemesDir, f), "utf-8"));
         if (data.id && !themeRegistry.has(data.id)) {
           themeRegistry.set(data.id, { modes: data.modes || ["light", "dark"] });
         }
@@ -2403,11 +3418,11 @@ function buildRegistryContext() {
     }
   } catch {
   }
-  const customThemesDir = join19(customDir, "themes");
+  const customThemesDir = join23(customDir, "themes");
   try {
-    if (existsSync19(customThemesDir)) {
+    if (existsSync23(customThemesDir)) {
       for (const f of readdirSync6(customThemesDir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync14(join19(customThemesDir, f), "utf-8"));
+        const data = JSON.parse(readFileSync15(join23(customThemesDir, f), "utf-8"));
         if (data.id) {
           themeRegistry.set(`custom:${data.id}`, { modes: data.modes || ["light", "dark"] });
         }
@@ -2415,11 +3430,11 @@ function buildRegistryContext() {
     }
   } catch {
   }
-  const cachedPatternsDir = join19(cacheDir, "@official", "patterns");
+  const cachedPatternsDir = join23(cacheDir, "@official", "patterns");
   try {
-    if (existsSync19(cachedPatternsDir)) {
+    if (existsSync23(cachedPatternsDir)) {
       for (const f of readdirSync6(cachedPatternsDir).filter((f2) => f2.endsWith(".json") && f2 !== "index.json")) {
-        const data = JSON.parse(readFileSync14(join19(cachedPatternsDir, f), "utf-8"));
+        const data = JSON.parse(readFileSync15(join23(cachedPatternsDir, f), "utf-8"));
         if (data.id && !patternRegistry.has(data.id)) {
           patternRegistry.set(data.id, data);
         }
@@ -2430,12 +3445,12 @@ function buildRegistryContext() {
   return { themeRegistry, patternRegistry };
 }
 async function cmdValidate(path) {
-  const essencePath = path || join19(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join23(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync14(essencePath, "utf-8");
+    raw = readFileSync15(essencePath, "utf-8");
   } catch {
-    console.error(error(`Could not read ${essencePath}`));
+    console.error(error3(`Could not read ${essencePath}`));
     process.exitCode = 1;
     return;
   }
@@ -2443,39 +3458,39 @@ async function cmdValidate(path) {
   try {
     essence = JSON.parse(raw);
   } catch (e) {
-    console.error(error(`Invalid JSON: ${e.message}`));
+    console.error(error3(`Invalid JSON: ${e.message}`));
     process.exitCode = 1;
     return;
   }
   const detectedVersion = isV36(essence) ? "v3" : "v2";
-  console.log(`${DIM9}Detected essence version: ${detectedVersion}${RESET9}`);
+  console.log(`${DIM13}Detected essence version: ${detectedVersion}${RESET13}`);
   const result = validateEssence2(essence);
   if (result.valid) {
-    console.log(success(`Essence is valid (${detectedVersion}).`));
+    console.log(success3(`Essence is valid (${detectedVersion}).`));
   } else {
-    console.error(error("Validation failed:"));
+    console.error(error3("Validation failed:"));
     for (const err of result.errors) {
-      console.error(`  ${RED7}${err}${RESET9}`);
+      console.error(`  ${RED11}${err}${RESET13}`);
     }
     process.exitCode = 1;
   }
   if (detectedVersion === "v2" && result.valid) {
-    console.log(`${YELLOW6}Tip: Run \`decantr migrate\` to upgrade to v3 format.${RESET9}`);
+    console.log(`${YELLOW9}Tip: Run \`decantr migrate\` to upgrade to v3 format.${RESET13}`);
   }
   try {
     const { themeRegistry, patternRegistry } = buildRegistryContext();
     const violations = evaluateGuard(essence, { themeRegistry, patternRegistry });
     if (violations.length > 0) {
-      console.log(heading("Guard violations:"));
+      console.log(heading2("Guard violations:"));
       for (const v of violations) {
         const vr = v;
-        console.log(`  ${YELLOW6}[${vr.rule}]${RESET9} ${vr.message}`);
+        console.log(`  ${YELLOW9}[${vr.rule}]${RESET13} ${vr.message}`);
         if (vr.suggestion) {
-          console.log(`    ${DIM9}Suggestion: ${vr.suggestion}${RESET9}`);
+          console.log(`    ${DIM13}Suggestion: ${vr.suggestion}${RESET13}`);
         }
       }
     } else if (result.valid) {
-      console.log(success("No guard violations."));
+      console.log(success3("No guard violations."));
     }
   } catch {
   }
@@ -2483,59 +3498,59 @@ async function cmdValidate(path) {
 async function cmdList(type) {
   const validTypes = ["patterns", "archetypes", "recipes", "themes", "blueprints", "shells"];
   if (!validTypes.includes(type)) {
-    console.error(error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
+    console.error(error3(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
     process.exitCode = 1;
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join19(process.cwd(), ".decantr", "cache")
+    cacheDir: join23(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(type);
   const items = result.data.items;
   if (items.length === 0) {
-    console.log(dim(`No ${type} found.`));
+    console.log(dim3(`No ${type} found.`));
     return;
   }
   if (type === "themes") {
     const customItems = registryClient.listCustomContent("themes");
     const customIds = new Set(customItems.map((c) => c.id));
     const registryItems = items.filter((i) => !customIds.has(i.id));
-    console.log(heading(`Registry themes (${registryItems.length}):`));
+    console.log(heading2(`Registry themes (${registryItems.length}):`));
     for (const item of registryItems) {
-      console.log(`  ${cyan(item.id)}  ${dim(item.description || item.name || "")}`);
+      console.log(`  ${cyan3(item.id)}  ${dim3(item.description || item.name || "")}`);
     }
     if (customItems.length > 0) {
       console.log("");
-      console.log(heading(`Custom themes (${customItems.length}):`));
+      console.log(heading2(`Custom themes (${customItems.length}):`));
       for (const item of customItems) {
-        console.log(`  ${cyan(`custom:${item.id}`)}  ${dim(item.description || item.name || "")}`);
+        console.log(`  ${cyan3(`custom:${item.id}`)}  ${dim3(item.description || item.name || "")}`);
       }
     } else {
       console.log("");
-      console.log(dim("Custom themes (0):"));
-      console.log(dim('  Run "decantr theme create <name>" to create a custom theme.'));
+      console.log(dim3("Custom themes (0):"));
+      console.log(dim3('  Run "decantr theme create <name>" to create a custom theme.'));
     }
   } else {
-    console.log(heading(`${items.length} ${type} found`));
+    console.log(heading2(`${items.length} ${type} found`));
     for (const item of items) {
-      console.log(`  ${cyan(item.id)}  ${dim(item.description || item.name || "")}`);
+      console.log(`  ${cyan3(item.id)}  ${dim3(item.description || item.name || "")}`);
     }
   }
 }
 async function cmdInit(args) {
   const projectRoot = process.cwd();
-  console.log(heading("Decantr Project Setup"));
+  console.log(heading2("Decantr Project Setup"));
   const detected = detectProject(projectRoot);
   if (detected.existingEssence && !args.existing) {
-    console.log(`${YELLOW6}Warning: decantr.essence.json already exists.${RESET9}`);
+    console.log(`${YELLOW9}Warning: decantr.essence.json already exists.${RESET13}`);
     const overwrite = await confirm("Overwrite existing configuration?", false);
     if (!overwrite) {
-      console.log(dim("Cancelled."));
+      console.log(dim3("Cancelled."));
       return;
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join19(projectRoot, ".decantr", "cache"),
+    cacheDir: join23(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline
   });
@@ -2547,30 +3562,30 @@ async function cmdInit(args) {
   } else if (!apiAvailable) {
     if (!args.blueprint) {
       console.log(`
-${YELLOW6}You're offline. Scaffolding minimal Decantr project.${RESET9}`);
-      console.log(dim("Run `decantr sync` or `decantr upgrade` when online to pull full registry content.\n"));
+${YELLOW9}You're offline. Scaffolding minimal Decantr project.${RESET13}`);
+      console.log(dim3("Run `decantr sync` or `decantr upgrade` when online to pull full registry content.\n"));
       const result2 = scaffoldMinimal(projectRoot);
-      console.log(success("\nProject scaffolded (minimal/offline)!\n"));
+      console.log(success3("\nProject scaffolded (minimal/offline)!\n"));
       console.log("  Files created:");
-      console.log(`    ${cyan("decantr.essence.json")}    Design specification`);
-      console.log(`    ${cyan("DECANTR.md")}              LLM instructions`);
-      console.log(`    ${cyan(".decantr/")}               Project state & custom content dirs`);
+      console.log(`    ${cyan3("decantr.essence.json")}    Design specification`);
+      console.log(`    ${cyan3("DECANTR.md")}              LLM instructions`);
+      console.log(`    ${cyan3(".decantr/")}               Project state & custom content dirs`);
       if (result2.gitignoreUpdated) {
-        console.log(`    ${dim(".gitignore updated")}`);
+        console.log(`    ${dim3(".gitignore updated")}`);
       }
       console.log("");
       console.log("  Next steps:");
-      console.log(`    1. Run ${cyan("decantr sync")} when online`);
-      console.log(`    2. Use ${cyan("decantr create <type> <name>")} to create custom content`);
+      console.log(`    1. Run ${cyan3("decantr sync")} when online`);
+      console.log(`    2. Use ${cyan3("decantr create <type> <name>")} to create custom content`);
       console.log(`    3. Review DECANTR.md for methodology`);
       return;
     }
     console.log(`
-${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
-    console.log(dim("Run `decantr upgrade` when online, or visit decantr.ai/registry\n"));
+${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
+    console.log(dim3("Run `decantr upgrade` when online, or visit decantr.ai/registry\n"));
     selectedBlueprint = "default";
   } else {
-    console.log(dim("Fetching registry content..."));
+    console.log(dim3("Fetching registry content..."));
     const blueprintsResult2 = await registryClient.fetchBlueprints();
     registrySource = blueprintsResult2.source.type === "api" ? "api" : "cache";
     const { selectedBlueprint: selected } = await runSimplifiedInit(
@@ -2578,11 +3593,9 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
     );
     selectedBlueprint = selected || "default";
   }
-  const [archetypesResult, blueprintsResult, themesResult] = await Promise.all([
-    registryClient.fetchArchetypes(),
-    registryClient.fetchBlueprints(),
-    registryClient.fetchThemes()
-  ]);
+  const archetypesResult = await registryClient.fetchArchetypes();
+  const blueprintsResult = await registryClient.fetchBlueprints();
+  const themesResult = await registryClient.fetchThemes();
   if (archetypesResult.source.type === "api") {
     registrySource = "api";
   }
@@ -2620,21 +3633,20 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
           options.shape = blueprint.theme.shape;
         }
       }
-      if (blueprint.personality?.length && (!options.personality || options.personality.length === 0 || options.personality.length === 1 && options.personality[0] === "professional")) {
-        options.personality = blueprint.personality;
+      if (blueprint.personality && (!options.personality || options.personality.length === 0 || options.personality.length === 1 && options.personality[0] === "professional")) {
+        options.personality = typeof blueprint.personality === "string" ? [blueprint.personality] : blueprint.personality;
       }
       blueprintRecipeName = blueprint.theme?.recipe;
       if (blueprint.compose && blueprint.compose.length > 0) {
         const entries = blueprint.compose;
-        const fetchPromises = entries.map((entry) => {
+        const results = [];
+        for (const entry of entries) {
           const id = typeof entry === "string" ? entry : entry.archetype;
-          return registryClient.fetchArchetype(id).then((r) => {
-            const raw = r?.data;
-            const inner = raw?.data ?? raw;
-            return [id, inner];
-          });
-        });
-        const results = await Promise.all(fetchPromises);
+          const r = await registryClient.fetchArchetype(id);
+          const raw = r?.data;
+          const inner = raw?.data ?? raw;
+          results.push([id, inner]);
+        }
         const archetypeMap = new Map(results.map(([id, data]) => [id, data || null]));
         const composed = composeArchetypes(entries, archetypeMap);
         const primaryId = typeof entries[0] === "string" ? entries[0] : entries[0].archetype;
@@ -2677,8 +3689,7 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
         }
         patternSpecs = {};
         if (allPatternIds.size > 0) {
-          const pSpecs = patternSpecs;
-          const fetches = [...allPatternIds].map(async (pid) => {
+          for (const pid of allPatternIds) {
             try {
               const result2 = await registryClient.fetchPattern(pid);
               if (result2) {
@@ -2686,17 +3697,15 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
                 const inner = raw.data ?? raw;
                 const defaultPreset = inner.default_preset || "standard";
                 const preset = inner.presets?.[defaultPreset];
-                pSpecs[pid] = {
+                patternSpecs[pid] = {
                   description: inner.description || "",
                   components: inner.components || [],
-                  slots: preset?.layout?.slots || {},
-                  code: preset?.code?.example || inner.code?.example || ""
+                  slots: preset?.layout?.slots || {}
                 };
               }
             } catch {
             }
-          });
-          await Promise.all(fetches);
+          }
         }
         const zoneInputs = [];
         for (const entry of entries) {
@@ -2732,7 +3741,7 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
         ) : "";
       }
     } else {
-      console.log(`${YELLOW6}  Warning: Could not fetch blueprint "${options.blueprint}". Using defaults.${RESET9}`);
+      console.log(`${YELLOW9}  Warning: Could not fetch blueprint "${options.blueprint}". Using defaults.${RESET13}`);
     }
   } else if (options.archetype) {
     const archetypeResult = await registryClient.fetchArchetype(options.archetype);
@@ -2740,7 +3749,7 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
       const rawArch = archetypeResult.data;
       archetypeData = rawArch.data ?? rawArch;
     } else {
-      console.log(`${YELLOW6}  Warning: Could not fetch archetype "${options.archetype}". Using defaults.${RESET9}`);
+      console.log(`${YELLOW9}  Warning: Could not fetch archetype "${options.archetype}". Using defaults.${RESET13}`);
     }
   }
   let themeData;
@@ -2762,10 +3771,14 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
         recipeData = { decorators: theme.decorators };
       }
     } else {
-      console.log(`${YELLOW6}  Warning: Could not fetch theme "${options.theme}". Using defaults.${RESET9}`);
+      console.log(`${YELLOW9}  Warning: Could not fetch theme "${options.theme}". Using defaults.${RESET13}`);
     }
     const recipeName = blueprintRecipeName || options.theme;
     const recipeResult = await registryClient.fetchRecipe(recipeName);
+    if (process.env.DECANTR_DEBUG && recipeResult) {
+      const dbg = recipeResult.data;
+      console.error(`  [debug] recipe source: ${recipeResult.source.type}, keys: ${Object.keys(dbg).join(",")}, has .data: ${"data" in dbg}, has .decorators: ${"decorators" in dbg}, inner.decorators: ${!!dbg.data?.decorators}`);
+    }
     if (recipeResult) {
       const rawRecipe = recipeResult.data;
       const recipe = rawRecipe.data ?? rawRecipe;
@@ -2776,7 +3789,7 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
       };
     }
   }
-  console.log(heading("Scaffolding project..."));
+  console.log(heading2("Scaffolding project..."));
   const result = await scaffoldProject(
     projectRoot,
     options,
@@ -2793,13 +3806,13 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
     patternSpecs,
     blueprintData
   );
-  console.log(success("\nProject scaffolded!\n"));
+  console.log(success3("\nProject scaffolded!\n"));
   console.log("  Files created:");
-  console.log(`    ${cyan("decantr.essence.json")}    Design specification`);
-  console.log(`    ${cyan("DECANTR.md")}              LLM instructions`);
-  console.log(`    ${cyan(".decantr/")}               Project state & cache`);
+  console.log(`    ${cyan3("decantr.essence.json")}    Design specification`);
+  console.log(`    ${cyan3("DECANTR.md")}              LLM instructions`);
+  console.log(`    ${cyan3(".decantr/")}               Project state & cache`);
   if (result.gitignoreUpdated) {
-    console.log(`    ${dim(".gitignore updated")}`);
+    console.log(`    ${dim3(".gitignore updated")}`);
   }
   console.log("");
   console.log("  Next steps:");
@@ -2807,27 +3820,30 @@ ${YELLOW6}You're offline. Scaffolding Decantr default.${RESET9}`);
   console.log("    2. Explore more at decantr.ai/registry");
   console.log("");
   console.log("  Commands:");
-  console.log(`    ${cyan("decantr status")}     Project health`);
-  console.log(`    ${cyan("decantr search")}     Search registry`);
-  console.log(`    ${cyan("decantr get")}        Fetch content details`);
-  console.log(`    ${cyan("decantr validate")}   Check essence file`);
-  console.log(`    ${cyan("decantr upgrade")}    Update to latest patterns`);
-  console.log(`    ${cyan("decantr check")}      Detect drift issues`);
-  console.log(`    ${cyan("decantr migrate")}    Migrate v2 essence to v3`);
-  const essenceContent = readFileSync14(result.essencePath, "utf-8");
+  console.log(`    ${cyan3("decantr status")}     Project health`);
+  console.log(`    ${cyan3("decantr search")}     Search registry`);
+  console.log(`    ${cyan3("decantr get")}        Fetch content details`);
+  console.log(`    ${cyan3("decantr validate")}   Check essence file`);
+  console.log(`    ${cyan3("decantr upgrade")}    Update to latest patterns`);
+  console.log(`    ${cyan3("decantr check")}      Detect drift issues`);
+  console.log(`    ${cyan3("decantr migrate")}    Migrate v2 essence to v3`);
+  const essenceContent = readFileSync15(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
-  const validation = validateEssence2(essence);
-  if (!validation.valid) {
-    console.log(error(`
+  if (essence.version !== "3.1.0") {
+    const validation = validateEssence2(essence);
+    if (!validation.valid) {
+      console.log(error3(`
 Validation warnings: ${validation.errors.join(", ")}`));
+    }
   }
   console.log("");
   let promptPages;
   if (isV36(essence)) {
-    promptPages = essence.blueprint.pages.map((p) => ({
+    const allPages = essence.blueprint.sections ? essence.blueprint.sections.flatMap((s) => s.pages.map((p) => ({ ...p, _shell: s.shell }))) : essence.blueprint.pages || [];
+    promptPages = allPages.map((p) => ({
       id: p.id,
-      shell: p.shell_override ?? essence.blueprint.shell,
-      layout: p.layout.map((item) => typeof item === "string" ? item : extractPatternName(item))
+      shell: p.shell_override ?? p._shell ?? essence.blueprint.shell,
+      layout: (p.layout || []).map((item) => typeof item === "string" ? item : extractPatternName(item))
     }));
   } else {
     promptPages = essence.structure || [{ id: "home", shell: options.shell, layout: ["hero"] }];
@@ -2847,32 +3863,32 @@ Validation warnings: ${validation.errors.join(", ")}`));
   console.log(boxedPrompt(curatedPrompt, "Copy this prompt for your AI assistant"));
   console.log("");
   if (registrySource === "cache") {
-    console.log(dim('Run "decantr sync" when online to get the latest registry content.'));
+    console.log(dim3('Run "decantr sync" when online to get the latest registry content.'));
   }
 }
 async function cmdStatus() {
   const projectRoot = process.cwd();
-  const essencePath = join19(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join19(projectRoot, ".decantr", "project.json");
-  console.log(heading("Decantr Project Status"));
-  if (!existsSync19(essencePath)) {
-    console.log(`${RED7}No decantr.essence.json found.${RESET9}`);
-    console.log(dim('Run "decantr init" to create one.'));
+  const essencePath = join23(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join23(projectRoot, ".decantr", "project.json");
+  console.log(heading2("Decantr Project Status"));
+  if (!existsSync23(essencePath)) {
+    console.log(`${RED11}No decantr.essence.json found.${RESET13}`);
+    console.log(dim3('Run "decantr init" to create one.'));
     return;
   }
   try {
-    const essence = JSON.parse(readFileSync14(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync15(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
     const essenceVersion = isV36(essence) ? "v3" : "v2";
-    console.log(`${BOLD4}Essence:${RESET9}`);
+    console.log(`${BOLD6}Essence:${RESET13}`);
     if (validation.valid) {
-      console.log(`  ${GREEN9}Valid${RESET9} (${essenceVersion})`);
+      console.log(`  ${GREEN13}Valid${RESET13} (${essenceVersion})`);
     } else {
-      console.log(`  ${RED7}Invalid: ${validation.errors.join(", ")}${RESET9}`);
+      console.log(`  ${RED11}Invalid: ${validation.errors.join(", ")}${RESET13}`);
     }
     if (isV36(essence)) {
       const v3 = essence;
-      console.log(`  ${BOLD4}DNA:${RESET9}`);
+      console.log(`  ${BOLD6}DNA:${RESET13}`);
       console.log(`    Theme: ${v3.dna.theme.style} (${v3.dna.theme.mode})`);
       console.log(`    Spacing: ${v3.dna.spacing.density} density, ${v3.dna.spacing.content_gap} gap`);
       console.log(`    Typography: ${v3.dna.typography.scale} scale`);
@@ -2880,11 +3896,11 @@ async function cmdStatus() {
       console.log(`    Motion: ${v3.dna.motion.preference} (reduce: ${v3.dna.motion.reduce_motion})`);
       console.log(`    Accessibility: WCAG ${v3.dna.accessibility.wcag_level}`);
       console.log(`    Personality: ${v3.dna.personality.join(", ")}`);
-      console.log(`  ${BOLD4}Blueprint:${RESET9}`);
+      console.log(`  ${BOLD6}Blueprint:${RESET13}`);
       console.log(`    Shell: ${v3.blueprint.shell}`);
       console.log(`    Pages: ${v3.blueprint.pages.length}`);
       console.log(`    Features: ${v3.blueprint.features.length > 0 ? v3.blueprint.features.join(", ") : "none"}`);
-      console.log(`  ${BOLD4}Meta:${RESET9}`);
+      console.log(`  ${BOLD6}Meta:${RESET13}`);
       console.log(`    Archetype: ${v3.meta.archetype}`);
       console.log(`    Target: ${v3.meta.target}`);
       console.log(`    Guard: ${v3.meta.guard.mode} (DNA: ${v3.meta.guard.dna_enforcement}, Blueprint: ${v3.meta.guard.blueprint_enforcement})`);
@@ -2896,92 +3912,92 @@ async function cmdStatus() {
       console.log(`  Theme: ${theme?.style || "unknown"} (${theme?.mode || "unknown"})`);
       console.log(`  Guard: ${guard?.mode || "unknown"}`);
       console.log(`  Pages: ${(structure || []).length}`);
-      console.log(`  ${YELLOW6}Tip: Run \`decantr migrate\` to upgrade to v3.${RESET9}`);
+      console.log(`  ${YELLOW9}Tip: Run \`decantr migrate\` to upgrade to v3.${RESET13}`);
     }
   } catch (e) {
-    console.log(`  ${RED7}Error reading essence: ${e.message}${RESET9}`);
+    console.log(`  ${RED11}Error reading essence: ${e.message}${RESET13}`);
   }
   console.log("");
-  console.log(`${BOLD4}Sync Status:${RESET9}`);
-  if (existsSync19(projectJsonPath)) {
+  console.log(`${BOLD6}Sync Status:${RESET13}`);
+  if (existsSync23(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync14(projectJsonPath, "utf-8"));
+      const projectJson = JSON.parse(readFileSync15(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
-      const statusColor = syncStatus === "synced" ? GREEN9 : YELLOW6;
-      console.log(`  Status: ${statusColor}${syncStatus}${RESET9}`);
-      console.log(`  Last sync: ${dim(lastSync)}`);
-      console.log(`  Source: ${dim(source)}`);
+      const statusColor = syncStatus === "synced" ? GREEN13 : YELLOW9;
+      console.log(`  Status: ${statusColor}${syncStatus}${RESET13}`);
+      console.log(`  Last sync: ${dim3(lastSync)}`);
+      console.log(`  Source: ${dim3(source)}`);
     } catch {
-      console.log(`  ${YELLOW6}Could not read project.json${RESET9}`);
+      console.log(`  ${YELLOW9}Could not read project.json${RESET13}`);
     }
   } else {
-    console.log(`  ${YELLOW6}No .decantr/project.json found${RESET9}`);
-    console.log(dim('  Run "decantr init" to create project files.'));
+    console.log(`  ${YELLOW9}No .decantr/project.json found${RESET13}`);
+    console.log(dim3('  Run "decantr init" to create project files.'));
   }
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join19(projectRoot, ".decantr", "cache");
-  console.log(heading("Syncing registry content..."));
+  const cacheDir = join23(projectRoot, ".decantr", "cache");
+  console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
-    console.log(success("Sync completed successfully."));
+    console.log(success3("Sync completed successfully."));
     console.log(`  Synced: ${result.synced.join(", ")}`);
     if (result.failed.length > 0) {
-      console.log(`  ${YELLOW6}Failed: ${result.failed.join(", ")}${RESET9}`);
+      console.log(`  ${YELLOW9}Failed: ${result.failed.join(", ")}${RESET13}`);
     }
   } else {
-    console.log(`${YELLOW6}Could not sync: API unavailable${RESET9}`);
+    console.log(`${YELLOW9}Could not sync: API unavailable${RESET13}`);
     if (result.failed.length > 0) {
-      console.log(`  ${YELLOW6}Failed: ${result.failed.join(", ")}${RESET9}`);
+      console.log(`  ${YELLOW9}Failed: ${result.failed.join(", ")}${RESET13}`);
     }
   }
 }
 async function cmdAudit() {
   const projectRoot = process.cwd();
-  const essencePath = join19(projectRoot, "decantr.essence.json");
-  console.log(heading("Auditing project..."));
-  if (!existsSync19(essencePath)) {
-    console.log(`${RED7}No decantr.essence.json found.${RESET9}`);
+  const essencePath = join23(projectRoot, "decantr.essence.json");
+  console.log(heading2("Auditing project..."));
+  if (!existsSync23(essencePath)) {
+    console.log(`${RED11}No decantr.essence.json found.${RESET13}`);
     process.exitCode = 1;
     return;
   }
   try {
-    const essence = JSON.parse(readFileSync14(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync15(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
     if (!validation.valid) {
-      console.log(`${RED7}Essence validation failed:${RESET9}`);
+      console.log(`${RED11}Essence validation failed:${RESET13}`);
       for (const err of validation.errors) {
-        console.log(`  ${RED7}${err}${RESET9}`);
+        console.log(`  ${RED11}${err}${RESET13}`);
       }
       process.exitCode = 1;
       return;
     }
-    console.log(success("Essence is valid."));
+    console.log(success3("Essence is valid."));
     const { themeRegistry, patternRegistry } = buildRegistryContext();
     const violations = evaluateGuard(essence, { themeRegistry, patternRegistry });
     if (violations.length > 0) {
       console.log("");
-      console.log(`${YELLOW6}Guard violations:${RESET9}`);
+      console.log(`${YELLOW9}Guard violations:${RESET13}`);
       for (const v of violations) {
         const vr = v;
-        console.log(`  ${YELLOW6}[${vr.rule}]${RESET9} ${vr.message}`);
+        console.log(`  ${YELLOW9}[${vr.rule}]${RESET13} ${vr.message}`);
         if (vr.suggestion) {
-          console.log(`    ${DIM9}Suggestion: ${vr.suggestion}${RESET9}`);
+          console.log(`    ${DIM13}Suggestion: ${vr.suggestion}${RESET13}`);
         }
       }
     } else {
-      console.log(success("No guard violations."));
+      console.log(success3("No guard violations."));
     }
     console.log("");
-    console.log(`${BOLD4}Summary:${RESET9}`);
+    console.log(`${BOLD6}Summary:${RESET13}`);
     console.log(`  Pages defined: ${essence.structure.length}`);
     console.log(`  Guard mode: ${essence.guard.mode}`);
     console.log(`  Theme: ${essence.theme.style}`);
   } catch (e) {
-    console.log(`${RED7}Error: ${e.message}${RESET9}`);
+    console.log(`${RED11}Error: ${e.message}${RESET13}`);
     process.exitCode = 1;
   }
 }
@@ -2990,17 +4006,17 @@ async function cmdTheme(args) {
   const projectRoot = process.cwd();
   if (!subcommand || subcommand === "help") {
     console.log(`
-${BOLD4}decantr theme${RESET9} \u2014 Manage custom themes
+${BOLD6}decantr theme${RESET13} \u2014 Manage custom themes
 
-${BOLD4}Commands:${RESET9}
-  ${cyan("create")} <name>        Create a new custom theme
-  ${cyan("create")} <name> --guided   Interactive theme creation
-  ${cyan("list")}                 List custom themes
-  ${cyan("validate")} <name>      Validate a custom theme
-  ${cyan("delete")} <name>        Delete a custom theme
-  ${cyan("import")} <path>        Import theme from JSON file
+${BOLD6}Commands:${RESET13}
+  ${cyan3("create")} <name>        Create a new custom theme
+  ${cyan3("create")} <name> --guided   Interactive theme creation
+  ${cyan3("list")}                 List custom themes
+  ${cyan3("validate")} <name>      Validate a custom theme
+  ${cyan3("delete")} <name>        Delete a custom theme
+  ${cyan3("import")} <path>        Import theme from JSON file
 
-${BOLD4}Examples:${RESET9}
+${BOLD6}Examples:${RESET13}
   decantr theme create mytheme
   decantr theme list
   decantr theme validate mytheme
@@ -3012,19 +4028,19 @@ ${BOLD4}Examples:${RESET9}
     case "create": {
       const name = args[1];
       if (!name) {
-        console.error(error("Usage: decantr theme create <name>"));
+        console.error(error3("Usage: decantr theme create <name>"));
         process.exitCode = 1;
         return;
       }
       const displayName = name.charAt(0).toUpperCase() + name.slice(1).replace(/-/g, " ");
       const result = createTheme(projectRoot, name, displayName);
       if (result.success) {
-        console.log(success(`Created custom theme "${name}"`));
-        console.log(dim(`  Path: ${result.path}`));
+        console.log(success3(`Created custom theme "${name}"`));
+        console.log(dim3(`  Path: ${result.path}`));
         console.log("");
-        console.log(`Use in essence: ${cyan(`"style": "custom:${name}"`)}`);
+        console.log(`Use in essence: ${cyan3(`"style": "custom:${name}"`)}`);
       } else {
-        console.error(error(result.error || "Failed to create theme"));
+        console.error(error3(result.error || "Failed to create theme"));
         process.exitCode = 1;
       }
       break;
@@ -3032,12 +4048,12 @@ ${BOLD4}Examples:${RESET9}
     case "list": {
       const themes = listCustomThemes(projectRoot);
       if (themes.length === 0) {
-        console.log(dim("No custom themes found."));
-        console.log(dim('Run "decantr theme create <name>" to create one.'));
+        console.log(dim3("No custom themes found."));
+        console.log(dim3('Run "decantr theme create <name>" to create one.'));
       } else {
-        console.log(heading(`${themes.length} custom theme(s)`));
+        console.log(heading2(`${themes.length} custom theme(s)`));
         for (const theme of themes) {
-          console.log(`  ${cyan(`custom:${theme.id}`)}  ${dim(theme.description || theme.name)}`);
+          console.log(`  ${cyan3(`custom:${theme.id}`)}  ${dim3(theme.description || theme.name)}`);
         }
       }
       break;
@@ -3045,30 +4061,30 @@ ${BOLD4}Examples:${RESET9}
     case "validate": {
       const name = args[1];
       if (!name) {
-        console.error(error("Usage: decantr theme validate <name>"));
+        console.error(error3("Usage: decantr theme validate <name>"));
         process.exitCode = 1;
         return;
       }
-      const themePath = join19(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync19(themePath)) {
-        console.error(error(`Theme "${name}" not found at ${themePath}`));
+      const themePath = join23(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync23(themePath)) {
+        console.error(error3(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync14(themePath, "utf-8"));
+        const theme = JSON.parse(readFileSync15(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
-          console.log(success(`Custom theme "${name}" is valid`));
+          console.log(success3(`Custom theme "${name}" is valid`));
         } else {
-          console.error(error("Validation failed:"));
+          console.error(error3("Validation failed:"));
           for (const err of result.errors) {
-            console.error(`  ${RED7}${err}${RESET9}`);
+            console.error(`  ${RED11}${err}${RESET13}`);
           }
           process.exitCode = 1;
         }
       } catch (e) {
-        console.error(error(`Invalid JSON: ${e.message}`));
+        console.error(error3(`Invalid JSON: ${e.message}`));
         process.exitCode = 1;
       }
       break;
@@ -3076,15 +4092,15 @@ ${BOLD4}Examples:${RESET9}
     case "delete": {
       const name = args[1];
       if (!name) {
-        console.error(error("Usage: decantr theme delete <name>"));
+        console.error(error3("Usage: decantr theme delete <name>"));
         process.exitCode = 1;
         return;
       }
       const result = deleteTheme(projectRoot, name);
       if (result.success) {
-        console.log(success(`Deleted custom theme "${name}"`));
+        console.log(success3(`Deleted custom theme "${name}"`));
       } else {
-        console.error(error(result.error || "Failed to delete theme"));
+        console.error(error3(result.error || "Failed to delete theme"));
         process.exitCode = 1;
       }
       break;
@@ -3092,18 +4108,18 @@ ${BOLD4}Examples:${RESET9}
     case "import": {
       const sourcePath = args[1];
       if (!sourcePath) {
-        console.error(error("Usage: decantr theme import <path>"));
+        console.error(error3("Usage: decantr theme import <path>"));
         process.exitCode = 1;
         return;
       }
       const result = importTheme(projectRoot, sourcePath);
       if (result.success) {
-        console.log(success("Theme imported successfully"));
-        console.log(dim(`  Path: ${result.path}`));
+        console.log(success3("Theme imported successfully"));
+        console.log(dim3(`  Path: ${result.path}`));
       } else {
-        console.error(error("Import failed:"));
+        console.error(error3("Import failed:"));
         for (const err of result.errors || []) {
-          console.error(`  ${RED7}${err}${RESET9}`);
+          console.error(`  ${RED11}${err}${RESET13}`);
         }
         process.exitCode = 1;
       }
@@ -3112,7 +4128,7 @@ ${BOLD4}Examples:${RESET9}
     case "switch": {
       const name = args[1];
       if (!name) {
-        console.error(error("Usage: decantr theme switch <themeName> [--recipe <r>] [--shape <s>] [--mode <m>]"));
+        console.error(error3("Usage: decantr theme switch <themeName> [--recipe <r>] [--shape <s>] [--mode <m>]"));
         process.exitCode = 1;
         return;
       }
@@ -3120,15 +4136,17 @@ ${BOLD4}Examples:${RESET9}
       break;
     }
     default:
-      console.error(error(`Unknown theme command: ${subcommand}`));
+      console.error(error3(`Unknown theme command: ${subcommand}`));
       process.exitCode = 1;
   }
 }
 function cmdHelp() {
   console.log(`
-${BOLD4}decantr${RESET9} \u2014 Design intelligence for AI-generated UI
+${BOLD6}decantr${RESET13} \u2014 Design intelligence for AI-generated UI
 
-${BOLD4}Usage:${RESET9}
+${BOLD6}Usage:${RESET13}
+  decantr new <name> [--blueprint=X] [--archetype=X] [--theme=X]
+  decantr magic <prompt> [--dry-run]
   decantr init [options]
   decantr status
   decantr sync
@@ -3149,7 +4167,7 @@ ${BOLD4}Usage:${RESET9}
   decantr logout
   decantr help
 
-${BOLD4}Init Options:${RESET9}
+${BOLD6}Init Options:${RESET13}
   --blueprint, -b    Blueprint ID
   --theme            Theme ID
   --mode             Color mode: dark | light | auto
@@ -3163,29 +4181,35 @@ ${BOLD4}Init Options:${RESET9}
   --yes, -y          Accept defaults, skip confirmations
   --registry         Custom registry URL
 
-${BOLD4}Commands:${RESET9}
-  ${cyan("init")}        Initialize a new Decantr project (v3 essence by default)
-  ${cyan("status")}      Show project status, DNA axioms, and blueprint info
-  ${cyan("sync")}        Sync registry content from API
-  ${cyan("audit")}       Validate essence and check for drift
-  ${cyan("migrate")}     Migrate v2 essence to v3 format (with .v2.backup.json backup)
-  ${cyan("check")}       Detect drift issues (validate + guard rules)
-  ${cyan("sync-drift")}  Review and resolve drift log entries
-  ${cyan("search")}      Search the registry
-  ${cyan("suggest")}     Suggest patterns or alternatives for a query
-  ${cyan("get")}         Get full details of a registry item
-  ${cyan("list")}        List items by type
-  ${cyan("validate")}    Validate essence file (v2 and v3)
-  ${cyan("theme")}       Manage custom themes (create, list, validate, delete, import)
-  ${cyan("create")}      Create a custom content item (pattern, recipe, theme, etc.)
-  ${cyan("publish")}     Publish a custom content item to the community registry
-  ${cyan("login")}       Authenticate with the Decantr registry
-  ${cyan("logout")}      Remove stored credentials
-  ${cyan("analyze")}     Scan existing project and produce analysis report
-  ${cyan("upgrade")}     Check for content updates from registry
-  ${cyan("help")}        Show this help
+${BOLD6}Commands:${RESET13}
+  ${cyan3("new")}         Create a new project with Vite + React + Decantr
+  ${cyan3("magic")}       One-liner scaffold from a natural language prompt
+  ${cyan3("init")}        Initialize Decantr in an existing project (v3 essence by default)
+  ${cyan3("status")}      Show project status, DNA axioms, and blueprint info
+  ${cyan3("sync")}        Sync registry content from API
+  ${cyan3("audit")}       Validate essence and check for drift
+  ${cyan3("migrate")}     Migrate v2 essence to v3 format (with .v2.backup.json backup)
+  ${cyan3("check")}       Detect drift issues (validate + guard rules) [--telemetry]
+  ${cyan3("sync-drift")}  Review and resolve drift log entries
+  ${cyan3("search")}      Search the registry
+  ${cyan3("suggest")}     Suggest patterns or alternatives for a query
+  ${cyan3("get")}         Get full details of a registry item
+  ${cyan3("list")}        List items by type
+  ${cyan3("validate")}    Validate essence file (v2 and v3)
+  ${cyan3("theme")}       Manage custom themes (create, list, validate, delete, import)
+  ${cyan3("create")}      Create a custom content item (pattern, recipe, theme, etc.)
+  ${cyan3("publish")}     Publish a custom content item to the community registry
+  ${cyan3("login")}       Authenticate with the Decantr registry
+  ${cyan3("logout")}      Remove stored credentials
+  ${cyan3("analyze")}     Scan existing project and produce analysis report
+  ${cyan3("export")}      Export design tokens to framework format (shadcn, tailwind, css-vars)
+  ${cyan3("registry")}    Registry management (mirror)
+  ${cyan3("upgrade")}     Check for content updates from registry
+  ${cyan3("help")}        Show this help
 
-${BOLD4}Examples:${RESET9}
+${BOLD6}Examples:${RESET13}
+  decantr new my-app --blueprint=carbon-ai-portal
+  decantr magic "AI chatbot with dark cyber theme \u2014 bold and futuristic"
   decantr init
   decantr init --blueprint=saas-dashboard --theme=luminarum --yes
   decantr status
@@ -3206,6 +4230,38 @@ async function main() {
     return;
   }
   switch (command) {
+    case "new": {
+      const newName = args[1];
+      if (!newName) {
+        console.error(error3("Usage: decantr new <project-name> [--blueprint=X] [--archetype=X] [--theme=X]"));
+        process.exitCode = 1;
+        break;
+      }
+      const newOpts = {};
+      for (let i = 2; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--offline") {
+          newOpts.offline = true;
+        } else if (arg.startsWith("--")) {
+          const [key, value] = arg.slice(2).split("=");
+          if (value) {
+            newOpts[key] = value;
+          } else if (args[i + 1] && !args[i + 1].startsWith("-")) {
+            newOpts[key] = args[++i];
+          }
+        }
+      }
+      await cmdNewProject(newName, {
+        blueprint: newOpts.blueprint,
+        archetype: newOpts.archetype,
+        theme: newOpts.theme,
+        mode: newOpts.mode,
+        shape: newOpts.shape,
+        offline: newOpts.offline === true,
+        registry: newOpts.registry
+      });
+      break;
+    }
     case "init": {
       const initArgs = {};
       for (let i = 1; i < args.length; i++) {
@@ -3241,7 +4297,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-EHMDEZGC.js");
+      const { cmdUpgrade } = await import("./upgrade-25IURU4X.js");
       const applyFlag = args.includes("--apply");
       await cmdUpgrade(process.cwd(), { apply: applyFlag });
       break;
@@ -3249,10 +4305,11 @@ async function main() {
     case "check":
     case "heal": {
       if (command === "heal") {
-        console.log(`${YELLOW6}Note: \`decantr heal\` is deprecated. Use \`decantr check\` instead.${RESET9}`);
+        console.log(`${YELLOW9}Note: \`decantr heal\` is deprecated. Use \`decantr check\` instead.${RESET13}`);
       }
-      const { cmdHeal } = await import("./heal-ZG5VJZ5J.js");
-      await cmdHeal(process.cwd());
+      const { cmdHeal } = await import("./heal-54MKDDSQ.js");
+      const telemetryFlag = args.includes("--telemetry");
+      await cmdHeal(process.cwd(), { telemetry: telemetryFlag });
       break;
     }
     case "migrate": {
@@ -3271,9 +4328,9 @@ async function main() {
           resolveIndex: resolveNum
         });
         if (result.success) {
-          console.log(success(clearFlag ? "Drift log cleared." : "Entries resolved."));
+          console.log(success3(clearFlag ? "Drift log cleared." : "Entries resolved."));
         } else {
-          console.error(error(result.error || "Failed"));
+          console.error(error3(result.error || "Failed"));
           process.exitCode = 1;
         }
       } else {
@@ -3288,7 +4345,7 @@ async function main() {
     case "search": {
       const query = args[1];
       if (!query) {
-        console.error(error("Usage: decantr search <query> [--type <type>]"));
+        console.error(error3("Usage: decantr search <query> [--type <type>]"));
         process.exitCode = 1;
         return;
       }
@@ -3300,7 +4357,7 @@ async function main() {
     case "suggest": {
       const query = args[1];
       if (!query) {
-        console.error(error("Usage: decantr suggest <query> [--type <type>]"));
+        console.error(error3("Usage: decantr suggest <query> [--type <type>]"));
         process.exitCode = 1;
         return;
       }
@@ -3313,7 +4370,7 @@ async function main() {
       const type = args[1];
       const id = args[2];
       if (!type || !id) {
-        console.error(error("Usage: decantr get <type> <id>"));
+        console.error(error3("Usage: decantr get <type> <id>"));
         process.exitCode = 1;
         return;
       }
@@ -3323,7 +4380,7 @@ async function main() {
     case "list": {
       const type = args[1];
       if (!type) {
-        console.error(error("Usage: decantr list <type>"));
+        console.error(error3("Usage: decantr list <type>"));
         process.exitCode = 1;
         return;
       }
@@ -3343,37 +4400,37 @@ async function main() {
       if (apiKeyArg && apiKeyArg.startsWith("--api-key=")) {
         const key = apiKeyArg.split("=")[1];
         saveCredentials({ access_token: key, api_key: key });
-        console.log(success("API key saved."));
+        console.log(success3("API key saved."));
       } else {
-        console.log(heading("Decantr Login"));
+        console.log(heading2("Decantr Login"));
         console.log("  To authenticate, get your API key from the Decantr dashboard:");
         console.log("");
-        console.log(`    ${cyan("https://decantr.ai/dashboard/api-keys")}`);
+        console.log(`    ${cyan3("https://decantr.ai/dashboard/api-keys")}`);
         console.log("");
         console.log("  Then run:");
-        console.log(`    ${cyan("decantr login --api-key=<your-key>")}`);
+        console.log(`    ${cyan3("decantr login --api-key=<your-key>")}`);
         console.log("");
         console.log("  Or set the environment variable:");
-        console.log(`    ${cyan("export DECANTR_API_KEY=<your-key>")}`);
+        console.log(`    ${cyan3("export DECANTR_API_KEY=<your-key>")}`);
         const existingCreds = getCredentials();
         if (existingCreds) {
           console.log("");
-          console.log(dim("You are currently authenticated."));
+          console.log(dim3("You are currently authenticated."));
         }
       }
       break;
     }
     case "logout": {
       clearCredentials();
-      console.log(success("Logged out. Credentials removed."));
+      console.log(success3("Logged out. Credentials removed."));
       break;
     }
     case "create": {
       const type = args[1];
       const name = args[2];
       if (!type || !name) {
-        console.error(error("Usage: decantr create <type> <name>"));
-        console.error(dim("Types: pattern, recipe, theme, blueprint, archetype, shell"));
+        console.error(error3("Usage: decantr create <type> <name>"));
+        console.error(dim3("Types: pattern, recipe, theme, blueprint, archetype, shell"));
         process.exitCode = 1;
         break;
       }
@@ -3384,8 +4441,8 @@ async function main() {
       const type = args[1];
       const name = args[2];
       if (!type || !name) {
-        console.error(error("Usage: decantr publish <type> <name>"));
-        console.error(dim("Types: pattern, recipe, theme, blueprint, archetype, shell"));
+        console.error(error3("Usage: decantr publish <type> <name>"));
+        console.error(dim3("Types: pattern, recipe, theme, blueprint, archetype, shell"));
         process.exitCode = 1;
         break;
       }
@@ -3393,13 +4450,26 @@ async function main() {
       break;
     }
     case "refresh": {
-      await cmdRefresh(process.cwd());
+      const refreshOffline = args.includes("--offline");
+      await cmdRefresh(process.cwd(), { offline: refreshOffline });
+      break;
+    }
+    case "registry": {
+      const subcommand = args[1];
+      if (subcommand === "mirror") {
+        const typeIdx = args.indexOf("--type");
+        const mirrorType = typeIdx !== -1 ? args[typeIdx + 1] : void 0;
+        await cmdRegistryMirror(process.cwd(), { type: mirrorType });
+      } else {
+        console.error(`${RED11}Usage: decantr registry mirror [--type <type>]${RESET13}`);
+        process.exitCode = 1;
+      }
       break;
     }
     case "add": {
       const subcommand = args[1];
       if (!subcommand) {
-        console.error(error("Usage: decantr add <section|page|feature> <target>"));
+        console.error(error3("Usage: decantr add <section|page|feature> <target>"));
         process.exitCode = 1;
         break;
       }
@@ -3407,7 +4477,7 @@ async function main() {
         case "section": {
           const id = args[2];
           if (!id) {
-            console.error(error("Usage: decantr add section <archetypeId>"));
+            console.error(error3("Usage: decantr add section <archetypeId>"));
             process.exitCode = 1;
             break;
           }
@@ -3417,7 +4487,7 @@ async function main() {
         case "page": {
           const pagePath = args[2];
           if (!pagePath) {
-            console.error(error("Usage: decantr add page <section>/<page>"));
+            console.error(error3("Usage: decantr add page <section>/<page>"));
             process.exitCode = 1;
             break;
           }
@@ -3427,7 +4497,7 @@ async function main() {
         case "feature": {
           const feature = args[2];
           if (!feature) {
-            console.error(error("Usage: decantr add feature <feature> [--section <id>]"));
+            console.error(error3("Usage: decantr add feature <feature> [--section <id>]"));
             process.exitCode = 1;
             break;
           }
@@ -3435,7 +4505,7 @@ async function main() {
           break;
         }
         default:
-          console.error(error(`Unknown add subcommand: ${subcommand}. Use section, page, or feature.`));
+          console.error(error3(`Unknown add subcommand: ${subcommand}. Use section, page, or feature.`));
           process.exitCode = 1;
       }
       break;
@@ -3443,7 +4513,7 @@ async function main() {
     case "remove": {
       const subcommand = args[1];
       if (!subcommand) {
-        console.error(error("Usage: decantr remove <section|page|feature> <target>"));
+        console.error(error3("Usage: decantr remove <section|page|feature> <target>"));
         process.exitCode = 1;
         break;
       }
@@ -3451,7 +4521,7 @@ async function main() {
         case "section": {
           const id = args[2];
           if (!id) {
-            console.error(error("Usage: decantr remove section <sectionId>"));
+            console.error(error3("Usage: decantr remove section <sectionId>"));
             process.exitCode = 1;
             break;
           }
@@ -3461,7 +4531,7 @@ async function main() {
         case "page": {
           const pagePath = args[2];
           if (!pagePath) {
-            console.error(error("Usage: decantr remove page <section>/<page>"));
+            console.error(error3("Usage: decantr remove page <section>/<page>"));
             process.exitCode = 1;
             break;
           }
@@ -3471,7 +4541,7 @@ async function main() {
         case "feature": {
           const feature = args[2];
           if (!feature) {
-            console.error(error("Usage: decantr remove feature <feature> [--section <id>]"));
+            console.error(error3("Usage: decantr remove feature <feature> [--section <id>]"));
             process.exitCode = 1;
             break;
           }
@@ -3479,7 +4549,7 @@ async function main() {
           break;
         }
         default:
-          console.error(error(`Unknown remove subcommand: ${subcommand}. Use section, page, or feature.`));
+          console.error(error3(`Unknown remove subcommand: ${subcommand}. Use section, page, or feature.`));
           process.exitCode = 1;
       }
       break;
@@ -3488,13 +4558,69 @@ async function main() {
       cmdAnalyze(process.cwd());
       break;
     }
+    case "magic": {
+      const magicFlags = {};
+      const promptParts = [];
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--dry-run") {
+          magicFlags.dryRun = true;
+        } else if (args[i] === "--offline") {
+          magicFlags.offline = true;
+        } else if (args[i].startsWith("--registry=")) {
+          magicFlags.registry = args[i].split("=")[1];
+        } else if (args[i].startsWith("--registry") && args[i + 1]) {
+          magicFlags.registry = args[++i];
+        } else {
+          promptParts.push(args[i]);
+        }
+      }
+      const magicPrompt = promptParts.join(" ").trim();
+      if (!magicPrompt) {
+        console.error(error3("Usage: decantr magic <prompt> [--dry-run] [--offline]"));
+        console.error("");
+        console.error("  Example:");
+        console.error(`    ${CYAN7}decantr magic "AI agent dashboard \u2014 dark, neon, confident"${RESET13}`);
+        process.exitCode = 1;
+        break;
+      }
+      await cmdMagic(magicPrompt, process.cwd(), {
+        dryRun: magicFlags.dryRun,
+        offline: magicFlags.offline,
+        registry: magicFlags.registry
+      });
+      break;
+    }
+    case "export": {
+      let exportTarget;
+      let exportOutput;
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--to" && args[i + 1]) {
+          exportTarget = args[++i];
+        } else if (args[i].startsWith("--to=")) {
+          exportTarget = args[i].split("=")[1];
+        } else if (args[i] === "--output" && args[i + 1]) {
+          exportOutput = args[++i];
+        } else if (args[i].startsWith("--output=")) {
+          exportOutput = args[i].split("=")[1];
+        }
+      }
+      const validTargets = ["shadcn", "tailwind", "css-vars"];
+      if (!exportTarget || !validTargets.includes(exportTarget)) {
+        console.error(error3(`Usage: decantr export --to <${validTargets.join("|")}>`));
+        process.exitCode = 1;
+        break;
+      }
+      await cmdExport(exportTarget, process.cwd(), { output: exportOutput });
+      break;
+    }
     default:
-      console.error(error(`Unknown command: ${command}`));
+      console.error(error3(`Unknown command: ${command}`));
       cmdHelp();
       process.exitCode = 1;
   }
 }
 main().catch((e) => {
-  console.error(error(e.message));
+  console.error(error3(e.message));
+  if (e.stack) console.error(e.stack);
   process.exitCode = 1;
 });