@decantr/cli 1.7.6 → 1.7.7

package/dist/{chunk-KAEQTVAM.js → chunk-OHQXL7EJ.js}

@@ -14,14 +14,14 @@ import {
   scaffoldProject,
   syncRegistry,
   writeExecutionPackBundleArtifacts
-} from "./chunk-H4H3IQJK.js";
+} from "./chunk-4D5V6GQU.js";
 import {
   buildGuardRegistryContext
 } from "./chunk-KUDAVJOR.js";
 
 // src/index.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync13, existsSync as existsSync24, readdirSync as readdirSync6 } from "fs";
-import { basename, join as join24, dirname as dirname2, isAbsolute, resolve as resolve3 } from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync13, existsSync as existsSync25, readdirSync as readdirSync6 } from "fs";
+import { basename as basename2, join as join26, dirname as dirname2, isAbsolute, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { validateEssence as validateEssence2, evaluateGuard, isV3 as isV36 } from "@decantr/essence-spec";
 import {
@@ -238,7 +238,7 @@ ${CYAN}Detected project configuration:${RESET}`);
     console.log(`  Existing essence: ${YELLOW}yes${RESET}`);
   }
 }
-async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
+async function runInteractivePrompts(detected, archetypes, blueprints, themes, workflowSeed) {
   showDetection(detected);
   const blueprintOptions = [
     { value: "none", label: "none", description: "Start from scratch (blank canvas)" },
@@ -255,7 +255,8 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
     label: t.id,
     description: t.description
   }));
-  const defaultThemeIdx = themeOptions.findIndex((t) => t.value === "luminarum") || 0;
+  const desiredTheme = workflowSeed?.theme || "luminarum";
+  const defaultThemeIdx = Math.max(0, themeOptions.findIndex((t) => t.value === desiredTheme));
   const theme = await select("Choose a theme", themeOptions, Math.max(0, defaultThemeIdx), true);
   const mode = await select(
     "Color mode",
@@ -264,7 +265,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
       { value: "light", label: "light", description: "Light background" },
       { value: "auto", label: "auto", description: "Follow system preference" }
     ],
-    0
+    workflowSeed?.mode === "light" ? 1 : workflowSeed?.mode === "auto" ? 2 : 0
   );
   const shape = await select(
     "Border shape",
@@ -286,7 +287,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
     { value: "angular", label: "angular", description: "Angular" },
     { value: "html", label: "html", description: "Plain HTML/CSS/JS" }
   ];
-  let defaultFrameworkIdx = frameworkOptions.findIndex((f) => f.value === detected.framework);
+  let defaultFrameworkIdx = frameworkOptions.findIndex((f) => f.value === (workflowSeed?.target || detected.framework));
   if (defaultFrameworkIdx < 0) defaultFrameworkIdx = 0;
   const target = await select("Target framework", frameworkOptions, defaultFrameworkIdx, true);
   if (detected.framework !== "unknown" && target !== detected.framework) {
@@ -303,8 +304,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
       { value: "guided", label: "guided", description: "Style, structure, density enforced" },
       { value: "strict", label: "strict", description: "All 5 rules enforced exactly" }
     ],
-    detected.existingEssence ? 1 : 2
-    // Default to guided for existing, strict for new
+    workflowSeed?.guard === "creative" ? 0 : workflowSeed?.guard === "strict" ? 2 : workflowSeed?.guard === "guided" ? 1 : detected.existingEssence ? 1 : 2
   );
   const density = await select(
     "Spacing density",
@@ -313,7 +313,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
       { value: "comfortable", label: "comfortable", description: "Balanced spacing" },
       { value: "spacious", label: "spacious", description: "Generous whitespace" }
     ],
-    1
+    workflowSeed?.density === "compact" ? 0 : workflowSeed?.density === "spacious" ? 2 : 1
   );
   const shellOptions = [
     { value: "sidebar-main", label: "sidebar-main", description: "Collapsible sidebar with main content" },
@@ -322,8 +322,11 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
     { value: "full-bleed", label: "full-bleed", description: "No persistent nav (landing pages)" },
     { value: "minimal-header", label: "minimal-header", description: "Slim header with centered content" }
   ];
-  let defaultShellIdx = 0;
-  if (["nextjs", "nuxt", "astro"].includes(target)) {
+  let defaultShellIdx = shellOptions.findIndex((s) => s.value === workflowSeed?.shell);
+  if (defaultShellIdx < 0) {
+    defaultShellIdx = 0;
+  }
+  if (defaultShellIdx === 0 && ["nextjs", "nuxt", "astro"].includes(target)) {
     defaultShellIdx = shellOptions.findIndex((s) => s.value === "top-nav-main");
   }
   const shell = await select("Default page shell (layout)", shellOptions, Math.max(0, defaultShellIdx), true);
@@ -340,7 +343,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
     shell,
     personality: ["professional"],
     features: [],
-    existing: detected.existingEssence
+    existing: workflowSeed?.existing || detected.existingEssence
   };
 }
 function parseFlags(args, detected) {
@@ -359,20 +362,20 @@ function parseFlags(args, detected) {
   if (args.existing === true) options.existing = true;
   return options;
 }
-function mergeWithDefaults(flags, detected) {
+function mergeWithDefaults(flags, detected, workflowSeed) {
   return {
     blueprint: flags.blueprint,
     archetype: flags.archetype,
-    theme: flags.theme || "luminarum",
-    mode: flags.mode || "dark",
+    theme: flags.theme || workflowSeed?.theme || "luminarum",
+    mode: flags.mode || workflowSeed?.mode || "dark",
     shape: flags.shape || "rounded",
-    target: flags.target || (detected.framework !== "unknown" ? detected.framework : "react"),
-    guard: flags.guard || (detected.existingEssence ? "guided" : "strict"),
-    density: flags.density || "comfortable",
-    shell: flags.shell || "sidebar-main",
+    target: flags.target || workflowSeed?.target || (detected.framework !== "unknown" ? detected.framework : "react"),
+    guard: flags.guard || workflowSeed?.guard || (detected.existingEssence ? "guided" : "strict"),
+    density: flags.density || workflowSeed?.density || "comfortable",
+    shell: flags.shell || workflowSeed?.shell || "sidebar-main",
     personality: flags.personality || ["professional"],
     features: flags.features || [],
-    existing: flags.existing || detected.existingEssence
+    existing: flags.existing || workflowSeed?.existing || detected.existingEssence
   };
 }
 async function runSimplifiedInit(blueprints) {
@@ -1532,8 +1535,8 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
 }
 
 // src/commands/analyze.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync4, writeFileSync as writeFileSync9 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { join as join19 } from "path";
 
 // src/analyzers/routes.ts
 import { existsSync as existsSync12, readdirSync as readdirSync2, statSync } from "fs";
@@ -2231,6 +2234,53 @@ function scanDependencies(projectRoot) {
   return result;
 }
 
+// src/workflow-model.ts
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
+import { join as join18 } from "path";
+function inferSuggestedShell(layout) {
+  if (layout.hasSidebar) return "sidebar-main";
+  if (layout.hasTopNav) return "top-nav-main";
+  return "full-bleed";
+}
+function hasExistingProjectFootprint(detected) {
+  return detected.framework !== "unknown" || detected.packageManager !== "unknown" || detected.hasTypeScript || detected.hasTailwind || detected.existingRuleFiles.length > 0;
+}
+function createBrownfieldInitSeed(detected, layout, styling) {
+  return {
+    version: 1,
+    workflow: "brownfield-adoption",
+    contractOnly: true,
+    registryOptional: true,
+    target: detected.framework !== "unknown" ? detected.framework : "react",
+    shell: inferSuggestedShell(layout),
+    guard: "guided",
+    density: "comfortable",
+    theme: "luminarum",
+    mode: styling.darkMode ? "dark" : "auto",
+    existing: true,
+    notes: [
+      "Use decantr init --existing to attach Decantr contract and context files to this project.",
+      "Registry content is optional during brownfield adoption.",
+      "Use decantr add/remove, decantr theme switch, and registry commands later for hybrid composition."
+    ]
+  };
+}
+function readBrownfieldInitSeed(projectRoot) {
+  const seedPath = join18(projectRoot, ".decantr", "init-seed.json");
+  if (!existsSync18(seedPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync14(seedPath, "utf-8"));
+    if (parsed.workflow !== "brownfield-adoption") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
 // src/commands/analyze.ts
 var BOLD3 = "\x1B[1m";
 var DIM8 = "\x1B[2m";
@@ -2256,6 +2306,7 @@ ${BOLD3}Analyzing project...${RESET8}
   const features = scanFeatures(projectRoot);
   console.log(`${DIM8}Scanning dependencies...${RESET8}`);
   const dependencies = scanDependencies(projectRoot);
+  const initSeed = createBrownfieldInitSeed(project, layout, styling);
   const analysis = {
     version: 1,
     analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2271,14 +2322,29 @@ ${BOLD3}Analyzing project...${RESET8}
     styling,
     layout,
     features,
-    dependencies
+    dependencies,
+    decantr: {
+      workflow: "brownfield-adoption",
+      registryOptional: true,
+      attach: {
+        entrypoint: "decantr analyze",
+        contractOnly: true,
+        initSeedPath: ".decantr/init-seed.json",
+        recommendedCommand: "decantr init --existing --yes"
+      },
+      hybrid: {
+        ownerCommands: ["decantr add", "decantr remove", "decantr theme switch", "decantr registry", "decantr upgrade"]
+      }
+    }
   };
-  const decantrDir = join18(projectRoot, ".decantr");
-  if (!existsSync18(decantrDir)) {
+  const decantrDir = join19(projectRoot, ".decantr");
+  if (!existsSync19(decantrDir)) {
     mkdirSync4(decantrDir, { recursive: true });
   }
-  const outputPath = join18(decantrDir, "analysis.json");
+  const outputPath = join19(decantrDir, "analysis.json");
+  const initSeedPath = join19(decantrDir, "init-seed.json");
   writeFileSync9(outputPath, JSON.stringify(analysis, null, 2) + "\n", "utf-8");
+  writeFileSync9(initSeedPath, JSON.stringify(initSeed, null, 2) + "\n", "utf-8");
   console.log(`
 ${GREEN8}Analysis complete.${RESET8}
 `);
@@ -2303,14 +2369,15 @@ ${GREEN8}Analysis complete.${RESET8}
   console.log(`  Dependencies: ${depCounts || "none categorized"}`);
   console.log(`
 ${DIM8}Written to:${RESET8} ${outputPath}`);
+  console.log(`${DIM8}Init seed:${RESET8} ${initSeedPath}`);
   console.log(`
-${YELLOW5}Next step:${RESET8} Ask your AI assistant to read ${BOLD3}.decantr/analysis.json${RESET8} and set up Decantr
+${YELLOW5}Next step:${RESET8} Run ${BOLD3}decantr init --existing --yes${RESET8} to attach Decantr using the generated brownfield seed.
 `);
 }
 
 // src/commands/magic.ts
-import { join as join19 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { join as join20 } from "path";
+import { existsSync as existsSync20 } from "fs";
 import * as fs from "fs/promises";
 var BOLD4 = "\x1B[1m";
 var DIM9 = "\x1B[2m";
@@ -2538,15 +2605,25 @@ async function cmdMagic(prompt, projectRoot, options) {
     console.log(`   Archetype:    ${intent.archetype}`);
   }
   console.log("");
-  const essencePath = join19(projectRoot, "decantr.essence.json");
-  if (existsSync19(essencePath)) {
+  const essencePath = join20(projectRoot, "decantr.essence.json");
+  if (existsSync20(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 detected = detectProject(projectRoot);
+  if (hasExistingProjectFootprint(detected)) {
+    console.log(`${YELLOW6} Existing project detected.${RESET9}`);
+    console.log(dim(" decantr magic stays greenfield-first and will not silently bootstrap over an existing app."));
+    console.log(dim(" Running brownfield analysis instead so you can attach Decantr deliberately.\n"));
+    cmdAnalyze(projectRoot);
+    console.log(`${BOLD4}Recommended next step:${RESET9} ${cyan("decantr init --existing --yes")}`);
+    console.log("");
+    return;
+  }
   const registryClient = new RegistryClient({
-    cacheDir: join19(projectRoot, ".decantr", "cache"),
+    cacheDir: join20(projectRoot, ".decantr", "cache"),
     apiUrl: options.registry,
     offline: options.offline
   });
@@ -2647,7 +2724,6 @@ async function cmdMagic(prompt, projectRoot, options) {
     return;
   }
   console.log("");
-  const detected = detectProject(projectRoot);
   let archetypeData;
   let composedSections;
   let routeMap;
@@ -2809,14 +2885,14 @@ async function cmdMagic(prompt, projectRoot, options) {
   if (result.gitignoreUpdated) {
     console.log(`   ${dim(".gitignore updated")}`);
   }
-  const contextDir = join19(projectRoot, ".decantr", "context");
+  const contextDir = join20(projectRoot, ".decantr", "context");
   let sectionCount = 0;
   try {
     const files = await fs.readdir(contextDir);
     sectionCount = files.filter((f) => f.startsWith("section-")).length;
   } catch {
   }
-  const treatmentsPath = join19(projectRoot, "src", "styles", "treatments.css");
+  const treatmentsPath = join20(projectRoot, "src", "styles", "treatments.css");
   let hasLayers = false;
   try {
     const css = await fs.readFile(treatmentsPath, "utf-8");
@@ -2841,8 +2917,8 @@ ${GREEN9}${BOLD4}Quality summary:${RESET9}`);
 }
 
 // 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";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, existsSync as existsSync21, mkdirSync as mkdirSync5 } from "fs";
+import { join as join21, dirname } from "path";
 var GREEN10 = "\x1B[32m";
 var RED8 = "\x1B[31m";
 var DIM10 = "\x1B[2m";
@@ -2988,19 +3064,19 @@ function generateCSSVars(tokens) {
   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)) {
+  const essencePath = join21(projectRoot, "decantr.essence.json");
+  const tokensPath = join21(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync21(essencePath)) {
     console.error(`${RED8}No decantr.essence.json found. Run \`decantr init\` first.${RESET10}`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync20(tokensPath)) {
+  if (!existsSync21(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 tokensCSS = readFileSync15(tokensPath, "utf-8");
   const tokens = parseTokensCSS(tokensCSS);
   if (tokens.size === 0) {
     console.error(`${RED8}No --d-* tokens found in tokens.css.${RESET10}`);
@@ -3009,8 +3085,8 @@ async function cmdExport(target, projectRoot, options = {}) {
   }
   switch (target) {
     case "shadcn": {
-      const cssOut = options.output ?? join20(projectRoot, "src", "styles", "shadcn-theme.css");
-      const jsonOut = join20(projectRoot, "components.json");
+      const cssOut = options.output ?? join21(projectRoot, "src", "styles", "shadcn-theme.css");
+      const jsonOut = join21(projectRoot, "components.json");
       ensureDir(cssOut);
       writeFileSync10(cssOut, generateShadcnCSS(tokens), "utf-8");
       writeFileSync10(jsonOut, generateShadcnComponentsJSON(), "utf-8");
@@ -3020,7 +3096,7 @@ async function cmdExport(target, projectRoot, options = {}) {
       break;
     }
     case "tailwind": {
-      const out = options.output ?? join20(projectRoot, "tailwind.decantr.config.ts");
+      const out = options.output ?? join21(projectRoot, "tailwind.decantr.config.ts");
       ensureDir(out);
       writeFileSync10(out, generateTailwindConfig(tokens), "utf-8");
       console.log(`${GREEN10}Exported Tailwind config:${RESET10}`);
@@ -3028,7 +3104,7 @@ async function cmdExport(target, projectRoot, options = {}) {
       break;
     }
     case "css-vars": {
-      const out = options.output ?? join20(projectRoot, "decantr-tokens.css");
+      const out = options.output ?? join21(projectRoot, "decantr-tokens.css");
       ensureDir(out);
       writeFileSync10(out, generateCSSVars(tokens), "utf-8");
       console.log(`${GREEN10}Exported CSS variables:${RESET10}`);
@@ -3039,14 +3115,14 @@ async function cmdExport(target, projectRoot, options = {}) {
 }
 function ensureDir(filePath) {
   const dir = dirname(filePath);
-  if (!existsSync20(dir)) {
+  if (!existsSync21(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 { join as join22 } from "path";
 import { RegistryAPIClient as RegistryAPIClient2, API_CONTENT_TYPES } from "@decantr/registry";
 var GREEN11 = "\x1B[32m";
 var RED9 = "\x1B[31m";
@@ -3074,7 +3150,7 @@ async function cmdRegistryMirror(projectRoot, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const cacheDir = join21(projectRoot, ".decantr", "cache");
+  const cacheDir = join22(projectRoot, ".decantr", "cache");
   const counts = {};
   const failed = [];
   console.log(`
@@ -3084,19 +3160,19 @@ Mirroring registry content to ${DIM11}.decantr/cache/${RESET11}
     try {
       const result = await apiClient.listContent(type, { namespace: "@official" });
       const items = result.items;
-      const typeDir = join21(cacheDir, "@official", type);
+      const typeDir = join22(cacheDir, "@official", type);
       mkdirSync6(typeDir, { recursive: true });
-      writeFileSync11(join21(typeDir, "index.json"), JSON.stringify(result, null, 2));
+      writeFileSync11(join22(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));
+          writeFileSync11(join22(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
           itemCount++;
         } catch {
-          writeFileSync11(join21(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
+          writeFileSync11(join22(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
           itemCount++;
         }
       }
@@ -3111,8 +3187,8 @@ Mirroring registry content to ${DIM11}.decantr/cache/${RESET11}
     mirrored_at: (/* @__PURE__ */ new Date()).toISOString(),
     counts
   };
-  mkdirSync6(join21(cacheDir), { recursive: true });
-  writeFileSync11(join21(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
+  mkdirSync6(join22(cacheDir), { recursive: true });
+  writeFileSync11(join22(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) {
@@ -3125,98 +3201,160 @@ Mirroring registry content to ${DIM11}.decantr/cache/${RESET11}
 }
 
 // src/commands/new-project.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
-import { join as join23, resolve as resolve2 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync9 } from "fs";
+import { join as join25, resolve as resolve2 } from "path";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 
 // src/offline-content.ts
-import { cpSync, existsSync as existsSync22, mkdirSync as mkdirSync7 } from "fs";
-import { join as join22, resolve } from "path";
+import { cpSync, existsSync as existsSync23, mkdirSync as mkdirSync7 } from "fs";
+import { join as join23, resolve } from "path";
 var CONTENT_TYPES2 = ["archetypes", "blueprints", "patterns", "themes", "shells"];
 function copyIfExists(source, target) {
-  if (!existsSync22(source)) return false;
+  if (!existsSync23(source)) return false;
   if (resolve(source) === resolve(target)) return true;
   cpSync(source, target, { recursive: true });
   return true;
 }
 function hydrateContentRoot(projectDir, contentRoot) {
-  if (!existsSync22(contentRoot)) return false;
-  const customRoot = join22(projectDir, ".decantr", "custom");
-  const cacheRoot = join22(projectDir, ".decantr", "cache", "@official");
+  if (!existsSync23(contentRoot)) return false;
+  const customRoot = join23(projectDir, ".decantr", "custom");
+  const cacheRoot = join23(projectDir, ".decantr", "cache", "@official");
   mkdirSync7(customRoot, { recursive: true });
   mkdirSync7(cacheRoot, { recursive: true });
   let copiedAny = false;
   for (const type of CONTENT_TYPES2) {
-    const sourceDir = join22(contentRoot, type);
-    if (!existsSync22(sourceDir)) continue;
-    cpSync(sourceDir, join22(customRoot, type), { recursive: true });
-    cpSync(sourceDir, join22(cacheRoot, type), { recursive: true });
+    const sourceDir = join23(contentRoot, type);
+    if (!existsSync23(sourceDir)) continue;
+    cpSync(sourceDir, join23(customRoot, type), { recursive: true });
+    cpSync(sourceDir, join23(cacheRoot, type), { recursive: true });
     copiedAny = true;
   }
   return copiedAny;
 }
 function seedOfflineRegistry(projectDir, workspaceRoot) {
-  const projectDecantrRoot = join22(projectDir, ".decantr");
+  const projectDecantrRoot = join23(projectDir, ".decantr");
   mkdirSync7(projectDecantrRoot, { recursive: true });
-  const copiedCache = copyIfExists(join22(workspaceRoot, ".decantr", "cache"), join22(projectDecantrRoot, "cache"));
-  const copiedCustom = copyIfExists(join22(workspaceRoot, ".decantr", "custom"), join22(projectDecantrRoot, "custom"));
+  const configuredContentRoot = process.env.DECANTR_CONTENT_DIR ? resolve(process.env.DECANTR_CONTENT_DIR) : null;
+  if (configuredContentRoot && hydrateContentRoot(projectDir, configuredContentRoot)) {
+    return { seeded: true, strategy: "configured-content-root" };
+  }
+  const copiedCache = copyIfExists(join23(workspaceRoot, ".decantr", "cache"), join23(projectDecantrRoot, "cache"));
+  const copiedCustom = copyIfExists(join23(workspaceRoot, ".decantr", "custom"), join23(projectDecantrRoot, "custom"));
   if (copiedCache || copiedCustom) {
     return { seeded: true, strategy: "workspace-cache" };
   }
-  const configuredContentRoot = process.env.DECANTR_CONTENT_DIR ? resolve(process.env.DECANTR_CONTENT_DIR) : null;
   const siblingContentRoot = resolve(workspaceRoot, "..", "decantr-content");
-  const contentRoot = configuredContentRoot && existsSync22(configuredContentRoot) ? configuredContentRoot : siblingContentRoot;
-  if (hydrateContentRoot(projectDir, contentRoot)) {
-    return {
-      seeded: true,
-      strategy: configuredContentRoot && existsSync22(configuredContentRoot) ? "configured-content-root" : "sibling-content-root"
-    };
+  if (hydrateContentRoot(projectDir, siblingContentRoot)) {
+    return { seeded: true, strategy: "sibling-content-root" };
   }
   return { seeded: false, strategy: null };
 }
 
-// src/commands/new-project.ts
-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}
+// src/bootstrap.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "fs";
+import { basename, join as join24 } from "path";
+import { resolvePackAdapter } from "@decantr/core";
+var reactViteBootstrapAdapter = {
+  id: "react-vite",
+  label: "React + Vite starter",
+  writeProjectFiles(projectDir, title, routingMode) {
+    const srcDir = join24(projectDir, "src");
+    const routerImport = routingMode === "hash" ? "HashRouter" : "BrowserRouter";
+    const packageJson = {
+      name: basename(projectDir) || "decantr-app",
+      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(join24(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+    const viteConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});
 `;
-}
-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}`;
-}
-function detectRoutingMode(projectDir) {
-  try {
-    const essence = JSON.parse(readFileSync15(join23(projectDir, "decantr.essence.json"), "utf-8"));
-    const routing = essence.meta?.platform?.routing;
-    if (routing === "history" || routing === "pathname") {
-      return routing;
-    }
-    return "hash";
-  } catch {
-    return "hash";
-  }
-}
-function writeStarterRuntimeFiles(projectDir, title, routingMode) {
-  const srcDir = join23(projectDir, "src");
-  const routerImport = routingMode === "hash" ? "HashRouter" : "BrowserRouter";
-  const mainTsx = `import { StrictMode } from 'react';
+    writeFileSync12(join24(projectDir, "vite.config.ts"), viteConfig);
+    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(join24(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(join24(projectDir, "tsconfig.app.json"), JSON.stringify(tsconfigApp, null, 2) + "\n");
+    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(join24(projectDir, "index.html"), indexHtml);
+    mkdirSync8(srcDir, { recursive: true });
+    const mainTsx = `import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
 import { ${routerImport} } from 'react-router-dom';
 import { App } from './App';
@@ -3232,8 +3370,8 @@ createRoot(document.getElementById('root')!).render(
   </StrictMode>,
 );
 `;
-  writeFileSync12(join23(srcDir, "main.tsx"), mainTsx);
-  const appTsx = `import { css } from '@decantr/css';
+    writeFileSync12(join24(srcDir, "main.tsx"), mainTsx);
+    const appTsx = `import { css } from '@decantr/css';
 import { Routes, Route } from 'react-router-dom';
 
 function WelcomePage() {
@@ -3267,137 +3405,105 @@ export function App() {
   );
 }
 `;
-  writeFileSync12(join23(srcDir, "App.tsx"), appTsx);
+    writeFileSync12(join24(srcDir, "App.tsx"), appTsx);
+    writeFileSync12(join24(srcDir, "vite-env.d.ts"), '/// <reference types="vite/client" />\n');
+    mkdirSync8(join24(srcDir, "styles"), { recursive: true });
+  }
+};
+var BOOTSTRAP_ADAPTERS = {
+  "react-vite": reactViteBootstrapAdapter
+};
+function resolveBootstrapTarget(target) {
+  const normalizedTarget = (target || "react").toLowerCase();
+  const platformType = "spa";
+  const packAdapter = resolvePackAdapter(normalizedTarget, platformType);
+  return {
+    target: normalizedTarget,
+    platformType,
+    packAdapter,
+    bootstrapAdapterId: BOOTSTRAP_ADAPTERS[packAdapter]?.id ?? null
+  };
+}
+function getBootstrapAdapter(resolution) {
+  if (!resolution.bootstrapAdapterId) {
+    return null;
+  }
+  return BOOTSTRAP_ADAPTERS[resolution.bootstrapAdapterId] ?? null;
+}
+function detectRoutingMode(projectDir) {
+  try {
+    const essence = JSON.parse(readFileSync16(join24(projectDir, "decantr.essence.json"), "utf-8"));
+    const routing = essence.meta?.platform?.routing;
+    if (routing === "history" || routing === "pathname") {
+      return routing;
+    }
+    return "hash";
+  } catch {
+    return "hash";
+  }
+}
+
+// src/commands/new-project.ts
+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 getTargetRoutingMode(target) {
-  return (target || "react").toLowerCase() === "nextjs" ? "pathname" : "hash";
+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 workspaceRoot = process.cwd();
   const projectDir = resolve2(workspaceRoot, projectName);
+  const bootstrapTarget = resolveBootstrapTarget(options.target);
+  const bootstrapAdapter = getBootstrapAdapter(bootstrapTarget);
+  const hasRunnableBootstrap = Boolean(bootstrapAdapter);
   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 (existsSync23(projectDir)) {
+  if (existsSync24(projectDir)) {
     console.error(error2(`Directory "${projectName}" already exists.`));
     process.exitCode = 1;
     return;
   }
   console.log(heading(`Creating ${projectName}...`));
-  mkdirSync8(projectDir, { recursive: true });
+  mkdirSync9(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(join23(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(join23(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(join23(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(join23(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(join23(projectDir, "index.html"), indexHtml);
-  console.log(dim2("  Created index.html"));
-  const srcDir = join23(projectDir, "src");
-  mkdirSync8(srcDir, { recursive: true });
-  writeStarterRuntimeFiles(projectDir, title, getTargetRoutingMode(options.target));
-  writeFileSync12(join23(srcDir, "vite-env.d.ts"), '/// <reference types="vite/client" />\n');
-  mkdirSync8(join23(srcDir, "styles"), { recursive: true });
-  console.log(dim2("  Created src/"));
-  console.log(heading("Installing dependencies..."));
+  if (bootstrapAdapter) {
+    bootstrapAdapter.writeProjectFiles(projectDir, title, "hash");
+    console.log(dim2(`  Bootstrapped ${bootstrapAdapter.label}`));
+  } else {
+    console.log(`${YELLOW8}  No greenfield bootstrap adapter is available yet for target "${bootstrapTarget.target}" (${bootstrapTarget.packAdapter}).${RESET12}`);
+    console.log(dim2("  Continuing with a contract-only Decantr workspace so the command stays target-honest instead of writing the wrong runtime."));
+  }
   const packageManager = detectPackageManager();
-  try {
-    execSync(`${packageManager} install`, { cwd: projectDir, stdio: "inherit" });
-  } catch {
-    console.log(`
+  if (hasRunnableBootstrap) {
+    console.log(heading("Installing dependencies..."));
+    try {
+      execSync(`${packageManager} install`, { cwd: projectDir, stdio: "inherit" });
+    } catch {
+      console.log(`
 ${YELLOW8}Dependency install failed. Run \`${packageManager} install\` manually.${RESET12}`);
+    }
   }
   const requiresOfflineContent = Boolean(options.offline && (options.blueprint || options.archetype));
   const seeded = options.offline ? seedOfflineRegistry(projectDir, workspaceRoot) : { seeded: false, strategy: null };
@@ -3429,10 +3535,12 @@ ${YELLOW8}Dependency install failed. Run \`${packageManager} install\` manually.
   if (options.registry) initFlags.push(`--registry=${options.registry}`);
   try {
     const bundledCliEntrypoint = fileURLToPath(new URL("./bin.js", import.meta.url));
-    const cliEntrypoint = existsSync23(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync23(process.argv[1]) ? process.argv[1] : null;
+    const cliEntrypoint = existsSync24(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync24(process.argv[1]) ? process.argv[1] : null;
     const cliPath = cliEntrypoint ? `"${process.execPath}" "${cliEntrypoint}"` : "npx decantr";
     execSync(`${cliPath} init ${initFlags.join(" ")}`, { cwd: projectDir, stdio: "inherit" });
-    writeStarterRuntimeFiles(projectDir, title, detectRoutingMode(projectDir));
+    if (bootstrapAdapter) {
+      bootstrapAdapter.writeProjectFiles(projectDir, title, detectRoutingMode(projectDir));
+    }
   } catch {
     console.log(`
 ${YELLOW8}Decantr init encountered issues. Run \`decantr init\` manually inside ${projectName}/.${RESET12}`);
@@ -3441,17 +3549,21 @@ ${YELLOW8}Decantr init encountered issues. Run \`decantr init\` manually inside
 \u2713 Project "${projectName}" created!
 `));
   console.log(`  ${cyan2("cd " + projectName)}`);
-  console.log(`  ${cyan2(packageManager + " run dev")}`);
+  if (bootstrapAdapter) {
+    console.log(`  ${cyan2(packageManager + " run dev")}`);
+  } else {
+    console.log(dim2(`  Contract-only mode for target ${bootstrapTarget.target}. Bring your own runtime, or rerun ${cyan2(`decantr new ${projectName} --target=react`)} for the current starter adapter.`));
+  }
   console.log("");
 }
 function detectPackageManager() {
-  if (existsSync23(join23(process.cwd(), "pnpm-lock.yaml")) || existsSync23(join23(process.cwd(), "pnpm-workspace.yaml"))) {
+  if (existsSync24(join25(process.cwd(), "pnpm-lock.yaml")) || existsSync24(join25(process.cwd(), "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync23(join23(process.cwd(), "yarn.lock"))) {
+  if (existsSync24(join25(process.cwd(), "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync23(join23(process.cwd(), "bun.lockb")) || existsSync23(join23(process.cwd(), "bun.lock"))) {
+  if (existsSync24(join25(process.cwd(), "bun.lockb")) || existsSync24(join25(process.cwd(), "bun.lock"))) {
     return "bun";
   }
   return "npm";
@@ -3572,6 +3684,12 @@ function generateCuratedPrompt(ctx) {
   lines.push("- Start with the shell layouts and route structure first, then build section pages route by route.");
   lines.push("- Import src/styles/global.css, src/styles/tokens.css, and src/styles/treatments.css.");
   lines.push("- Use the existing Decantr tokens, treatments, and decorators instead of inventing a new visual system.");
+  lines.push("- If package.json, app entry files, or router/runtime files are absent, create them explicitly for the declared target instead of assuming a hidden starter already exists in the workspace.");
+  lines.push("- Do not use inline visual style values or component-scoped <style> tags as the primary styling path. Colors, spacing, borders, shadows, gradients, and transitions should come from atoms, treatments, decorators, or CSS variables. Inline styles are only acceptable for truly dynamic geometry that cannot be expressed through the contract.");
+  lines.push("- Let shells own spacing, centering, and scroll containers. Pages should not duplicate shell responsibilities with extra full-height wrappers, max-width wrappers, or page-local padding unless the route contract explicitly requires it.");
+  lines.push("- If command_palette or hotkeys are declared in the generated context, implement them as real features. Do not merely acknowledge them in copy or comments.");
+  lines.push("- Treat declared hotkeys as interaction bindings by default, not visible navigation label text, unless the shell or route contract explicitly calls for shown shortcut hints.");
+  lines.push("- If a required decorator class is referenced in the contract but missing from generated CSS, report the contract gap instead of inventing a parallel visual system.");
   lines.push("- Do not modify generated context files unless the task is explicitly to regenerate or refresh Decantr context.");
   lines.push("");
   lines.push("Execution flow:");
@@ -3606,18 +3724,18 @@ function extractHostedAssetPaths(indexHtml) {
   return [...assetPaths];
 }
 function readHostedDistSnapshot(distPath) {
-  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join24(process.cwd(), "dist");
-  const indexPath = join24(resolvedDistPath, "index.html");
-  if (!existsSync24(indexPath)) {
+  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join26(process.cwd(), "dist");
+  const indexPath = join26(resolvedDistPath, "index.html");
+  if (!existsSync25(indexPath)) {
     return void 0;
   }
-  const indexHtml = readFileSync16(indexPath, "utf-8");
+  const indexHtml = readFileSync17(indexPath, "utf-8");
   const assetPaths = extractHostedAssetPaths(indexHtml);
   const assets = {};
   for (const assetPath of assetPaths) {
-    const assetFilePath = join24(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
-    if (existsSync24(assetFilePath)) {
-      assets[assetPath] = readFileSync16(assetFilePath, "utf-8");
+    const assetFilePath = join26(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
+    if (existsSync25(assetFilePath)) {
+      assets[assetPath] = readFileSync17(assetFilePath, "utf-8");
     }
   }
   return {
@@ -3632,24 +3750,24 @@ function isHostedSourceSnapshotFile(path) {
 function readHostedSourceSnapshot(sourcePath) {
   if (!sourcePath) return void 0;
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  if (!existsSync24(resolvedSourcePath)) {
+  if (!existsSync25(resolvedSourcePath)) {
     return void 0;
   }
   const files = {};
   const ignoredDirNames = /* @__PURE__ */ new Set(["node_modules", ".git", ".decantr", "dist", "build", "coverage"]);
-  const rootPrefix = basename(resolvedSourcePath);
+  const rootPrefix = basename2(resolvedSourcePath);
   const walk = (absoluteDir, relativeDir) => {
     for (const entry of readdirSync6(absoluteDir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join24(absoluteDir, entry.name);
-      const relativePath = join24(relativeDir, entry.name).replace(/\\/g, "/");
+      const absolutePath = join26(absoluteDir, entry.name);
+      const relativePath = join26(relativeDir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (!isHostedSourceSnapshotFile(relativePath)) continue;
-      files[relativePath] = readFileSync16(absolutePath, "utf-8");
+      files[relativePath] = readFileSync17(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -3766,19 +3884,19 @@ async function printRegistryIntelligenceSummary(namespace, jsonOutput = false) {
 }
 async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join24(process.cwd(), "decantr.essence.json");
-  if (!existsSync24(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join26(process.cwd(), "decantr.essence.json");
+  if (!existsSync25(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync16(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync17(resolvedPath, "utf-8"));
   const bundle = await client.compileExecutionPacks(
     essence,
     namespace ? { namespace } : void 0
   );
   let writtenContextPaths = [];
   if (writeContext) {
-    const contextDir = join24(process.cwd(), ".decantr", "context");
-    mkdirSync9(contextDir, { recursive: true });
+    const contextDir = join26(process.cwd(), ".decantr", "context");
+    mkdirSync10(contextDir, { recursive: true });
     const written = writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -3801,7 +3919,7 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
   console.log(`  Sections: ${typedBundle.sections.length}`);
   console.log(`  Mutations: ${typedBundle.mutations.length}`);
   if (writeContext) {
-    console.log(`  Context bundle: ${join24(process.cwd(), ".decantr", "context")}`);
+    console.log(`  Context bundle: ${join26(process.cwd(), ".decantr", "context")}`);
     console.log(`  Files written: ${writtenContextPaths.length}`);
   }
   console.log("");
@@ -3813,14 +3931,14 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
 }
 async function printHostedSelectedExecutionPack(packType, id, essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join24(process.cwd(), "decantr.essence.json");
-  if (!existsSync24(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join26(process.cwd(), "decantr.essence.json");
+  if (!existsSync25(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
   if ((packType === "section" || packType === "page" || packType === "mutation") && !id) {
     throw new Error(`Pack type "${packType}" requires an id.`);
   }
-  const essence = JSON.parse(readFileSync16(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync17(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -3831,14 +3949,14 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join24(process.cwd(), ".decantr", "context");
-    mkdirSync9(contextDir, { recursive: true });
-    writeFileSync13(join24(contextDir, "pack-manifest.json"), JSON.stringify(selected.manifest, null, 2) + "\n");
+    const contextDir = join26(process.cwd(), ".decantr", "context");
+    mkdirSync10(contextDir, { recursive: true });
+    writeFileSync13(join26(contextDir, "pack-manifest.json"), JSON.stringify(selected.manifest, null, 2) + "\n");
     const manifestEntry = selected.selector.packType === "scaffold" ? selected.manifest.scaffold : selected.selector.packType === "review" ? selected.manifest.review : selected.selector.packType === "section" ? selected.manifest.sections.find((entry) => entry.id === selected.selector.id) : selected.selector.packType === "page" ? selected.manifest.pages.find((entry) => entry.id === selected.selector.id) : selected.manifest.mutations.find((entry) => entry.id === selected.selector.id);
     const markdownFile = manifestEntry?.markdown ?? `${selected.selector.packType}${selected.selector.id ? `-${selected.selector.id}` : ""}-pack.md`;
     const jsonFile = manifestEntry?.json ?? `${selected.selector.packType}${selected.selector.id ? `-${selected.selector.id}` : ""}-pack.json`;
-    writeFileSync13(join24(contextDir, markdownFile), selected.pack.renderedMarkdown);
-    writeFileSync13(join24(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
+    writeFileSync13(join26(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync13(join26(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -3863,20 +3981,20 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
 }
 async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join24(process.cwd(), "decantr.essence.json");
-  if (!existsSync24(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join26(process.cwd(), "decantr.essence.json");
+  if (!existsSync25(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync16(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync17(resolvedPath, "utf-8"));
   const manifest = await client.getExecutionPackManifest(
     essence,
     namespace ? { namespace } : void 0
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join24(process.cwd(), ".decantr", "context");
-    mkdirSync9(contextDir, { recursive: true });
-    writeFileSync13(join24(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const contextDir = join26(process.cwd(), ".decantr", "context");
+    mkdirSync10(contextDir, { recursive: true });
+    writeFileSync13(join26(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -3897,14 +4015,14 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   }
 }
 async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join24(projectRoot, ".decantr", "context");
-  const reviewPackPath = join24(contextDir, "review-pack.json");
-  const manifestPath = join24(contextDir, "pack-manifest.json");
-  if (existsSync24(reviewPackPath) && existsSync24(manifestPath)) {
+  const contextDir = join26(projectRoot, ".decantr", "context");
+  const reviewPackPath = join26(contextDir, "review-pack.json");
+  const manifestPath = join26(contextDir, "pack-manifest.json");
+  if (existsSync25(reviewPackPath) && existsSync25(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join24(projectRoot, "decantr.essence.json");
-  if (!existsSync24(essencePath)) {
+  const essencePath = join26(projectRoot, "decantr.essence.json");
+  if (!existsSync25(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   const reviewHydration = await hydrateHostedReviewPackIfMissing(projectRoot, namespace);
@@ -3913,9 +4031,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync16(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync17(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync9(contextDir, { recursive: true });
+    mkdirSync10(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -3926,19 +4044,19 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
 }
 async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join24(projectRoot, ".decantr", "context");
-  const reviewPackPath = join24(contextDir, "review-pack.json");
-  const manifestPath = join24(contextDir, "pack-manifest.json");
-  if (existsSync24(reviewPackPath) && existsSync24(manifestPath)) {
+  const contextDir = join26(projectRoot, ".decantr", "context");
+  const reviewPackPath = join26(contextDir, "review-pack.json");
+  const manifestPath = join26(contextDir, "pack-manifest.json");
+  if (existsSync25(reviewPackPath) && existsSync25(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join24(projectRoot, "decantr.essence.json");
-  if (!existsSync24(essencePath)) {
+  const essencePath = join26(projectRoot, "decantr.essence.json");
+  if (!existsSync25(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync16(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync17(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -3946,10 +4064,10 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync9(contextDir, { recursive: true });
-    writeFileSync13(join24(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync13(join24(contextDir, "review-pack.json"), JSON.stringify(selected.pack, null, 2) + "\n");
-    if (!existsSync24(manifestPath)) {
+    mkdirSync10(contextDir, { recursive: true });
+    writeFileSync13(join26(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync13(join26(contextDir, "review-pack.json"), JSON.stringify(selected.pack, null, 2) + "\n");
+    if (!existsSync25(manifestPath)) {
       writeFileSync13(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
@@ -3960,17 +4078,17 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
 async function printHostedFileCritique(sourcePath, namespace, jsonOutput = false, essencePath, treatmentsPath) {
   const client = getPublicAPIClient();
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join24(process.cwd(), "decantr.essence.json");
-  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join24(process.cwd(), "src", "styles", "treatments.css");
-  if (!existsSync24(resolvedSourcePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join26(process.cwd(), "decantr.essence.json");
+  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join26(process.cwd(), "src", "styles", "treatments.css");
+  if (!existsSync25(resolvedSourcePath)) {
     throw new Error(`Source file not found at ${resolvedSourcePath}`);
   }
-  if (!existsSync24(resolvedEssencePath)) {
+  if (!existsSync25(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const code = readFileSync16(resolvedSourcePath, "utf-8");
-  const essence = JSON.parse(readFileSync16(resolvedEssencePath, "utf-8"));
-  const treatmentsCss = existsSync24(resolvedTreatmentsPath) ? readFileSync16(resolvedTreatmentsPath, "utf-8") : void 0;
+  const code = readFileSync17(resolvedSourcePath, "utf-8");
+  const essence = JSON.parse(readFileSync17(resolvedEssencePath, "utf-8"));
+  const treatmentsCss = existsSync25(resolvedTreatmentsPath) ? readFileSync17(resolvedTreatmentsPath, "utf-8") : void 0;
   const report = await client.critiqueFile(
     {
       essence,
@@ -3994,11 +4112,11 @@ async function printHostedFileCritique(sourcePath, namespace, jsonOutput = false
 }
 async function printHostedProjectAudit(namespace, jsonOutput = false, essencePath, distPath, sourcesPath) {
   const client = getPublicAPIClient();
-  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join24(process.cwd(), "decantr.essence.json");
-  if (!existsSync24(resolvedEssencePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join26(process.cwd(), "decantr.essence.json");
+  if (!existsSync25(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const essence = JSON.parse(readFileSync16(resolvedEssencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync17(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -4015,7 +4133,7 @@ async function printHostedProjectAudit(namespace, jsonOutput = false, essencePat
   }
   console.log(heading2("Hosted Project Audit"));
   console.log(`  Essence: ${resolvedEssencePath}`);
-  console.log(`  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join24(process.cwd(), "dist") : "none"}`);
+  console.log(`  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join26(process.cwd(), "dist") : "none"}`);
   console.log(`  Source snapshot: ${sources && sourcesPath ? resolveUserPath(sourcesPath) : "none"}`);
   printProjectAuditReport(report);
 }
@@ -4093,7 +4211,7 @@ async function cmdGet(type, id) {
   }
   const apiType = CONTENT_TYPE_TO_API_CONTENT_TYPE3[type];
   const registryClient = new RegistryClient({
-    cacheDir: join24(process.cwd(), ".decantr", "cache")
+    cacheDir: join26(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
@@ -4102,16 +4220,16 @@ async function cmdGet(type, id) {
   }
   const currentDir = dirname2(fileURLToPath2(import.meta.url));
   const bundledCandidates = [
-    join24(currentDir, "bundled", apiType, `${id}.json`),
+    join26(currentDir, "bundled", apiType, `${id}.json`),
     // Running from src/
-    join24(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
+    join26(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
     // Running from dist/
-    join24(currentDir, "..", "bundled", apiType, `${id}.json`)
+    join26(currentDir, "..", "bundled", apiType, `${id}.json`)
     // Alternative dist layout
   ];
-  const bundledPath = bundledCandidates.find((p) => existsSync24(p)) || null;
+  const bundledPath = bundledCandidates.find((p) => existsSync25(p)) || null;
   if (bundledPath) {
-    const data = JSON.parse(readFileSync16(bundledPath, "utf-8"));
+    const data = JSON.parse(readFileSync17(bundledPath, "utf-8"));
     console.log(JSON.stringify(data, null, 2));
     return;
   }
@@ -4120,10 +4238,10 @@ async function cmdGet(type, id) {
   return;
 }
 async function cmdValidate(path) {
-  const essencePath = path || join24(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join26(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync16(essencePath, "utf-8");
+    raw = readFileSync17(essencePath, "utf-8");
   } catch {
     console.error(error3(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -4177,7 +4295,7 @@ async function cmdList(type, sort, recommended, intelligenceSource) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join24(process.cwd(), ".decantr", "cache")
+    cacheDir: join26(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(
     type,
@@ -4227,6 +4345,11 @@ async function cmdInit(args) {
   const projectRoot = process.cwd();
   console.log(heading2("Decantr Project Setup"));
   const detected = detectProject(projectRoot);
+  const workflowSeed = readBrownfieldInitSeed(projectRoot);
+  const brownfieldAttach = Boolean(workflowSeed) || hasExistingProjectFootprint(detected);
+  if (workflowSeed) {
+    console.log(dim3("  Found .decantr/init-seed.json brownfield guidance."));
+  }
   if (detected.existingEssence && !args.existing) {
     console.log(`${YELLOW9}Warning: decantr.essence.json already exists.${RESET13}`);
     const overwrite = await confirm("Overwrite existing configuration?", false);
@@ -4251,7 +4374,7 @@ async function cmdInit(args) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join24(projectRoot, ".decantr", "cache"),
+    cacheDir: join26(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline
   });
@@ -4265,6 +4388,7 @@ async function cmdInit(args) {
   }
   let selectedBlueprint = "default";
   let registrySource = "cache";
+  const preferContractOnly = brownfieldAttach && !requestedBlueprint && !requestedArchetype;
   if (args.yes) {
     selectedBlueprint = args.blueprint || "default";
   } else if (!apiAvailable) {
@@ -4299,7 +4423,7 @@ ${YELLOW9}You're offline. Scaffolding minimal Decantr project.${RESET13}`);
 ${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 {
+  } else if (!preferContractOnly) {
     console.log(dim3("Fetching registry content..."));
     const blueprintsResult2 = await registryClient.fetchBlueprints();
     registrySource = blueprintsResult2.source.type === "api" ? "api" : "cache";
@@ -4327,9 +4451,9 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
   if (args.yes || selectedBlueprint !== "default") {
     const flags = parseFlags(args, detected);
     flags.blueprint = selectedBlueprint !== "default" ? selectedBlueprint : flags.blueprint;
-    options = mergeWithDefaults(flags, detected);
+    options = mergeWithDefaults(flags, detected, workflowSeed ?? void 0);
   } else {
-    options = await runInteractivePrompts(detected, archetypes, blueprints, themes);
+    options = await runInteractivePrompts(detected, archetypes, blueprints, themes, workflowSeed ?? void 0);
     userExplicit.theme = true;
     userExplicit.mode = true;
     userExplicit.shape = true;
@@ -4512,6 +4636,11 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
   if (result.gitignoreUpdated) {
     console.log(`    ${dim3(".gitignore updated")}`);
   }
+  if (!existsSync25(join26(projectRoot, "package.json"))) {
+    console.log("");
+    console.log(dim3(`  Note: ${cyan3("decantr init")} created Decantr contract/context files only.`));
+    console.log(dim3(`  For a runnable starter in a new directory, prefer ${cyan3("decantr new <name> --blueprint=...")}.`));
+  }
   console.log("");
   console.log("  Next steps:");
   console.log("    1. Read DECANTR.md for methodology, CSS approach, and guard rules");
@@ -4529,7 +4658,7 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
   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 = readFileSync16(result.essencePath, "utf-8");
+  const essenceContent = readFileSync17(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   if (essence.version !== "3.1.0") {
     const validation = validateEssence2(essence);
@@ -4576,16 +4705,16 @@ Validation warnings: ${validation.errors.join(", ")}`));
 }
 async function cmdStatus() {
   const projectRoot = process.cwd();
-  const essencePath = join24(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join24(projectRoot, ".decantr", "project.json");
+  const essencePath = join26(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join26(projectRoot, ".decantr", "project.json");
   console.log(heading2("Decantr Project Status"));
-  if (!existsSync24(essencePath)) {
+  if (!existsSync25(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(readFileSync16(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync17(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
     const essenceVersion = isV36(essence) ? "v3" : "v2";
     console.log(`${BOLD6}Essence:${RESET13}`);
@@ -4634,9 +4763,9 @@ async function cmdStatus() {
   }
   console.log("");
   console.log(`${BOLD6}Sync Status:${RESET13}`);
-  if (existsSync24(projectJsonPath)) {
+  if (existsSync25(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync16(projectJsonPath, "utf-8"));
+      const projectJson = JSON.parse(readFileSync17(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
@@ -4654,7 +4783,7 @@ async function cmdStatus() {
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join24(projectRoot, ".decantr", "cache");
+  const cacheDir = join26(projectRoot, ".decantr", "cache");
   console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
@@ -4843,14 +4972,14 @@ ${BOLD6}Examples:${RESET13}
         process.exitCode = 1;
         return;
       }
-      const themePath = join24(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync24(themePath)) {
+      const themePath = join26(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync25(themePath)) {
         console.error(error3(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync16(themePath, "utf-8"));
+        const theme = JSON.parse(readFileSync17(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
           console.log(success3(`Custom theme "${name}" is valid`));
@@ -4966,9 +5095,9 @@ ${BOLD6}Init Options:${RESET13}
   --registry         Custom registry URL
 
 ${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("new")}         Create a new greenfield workspace and bootstrap the available starter adapter
+  ${cyan3("magic")}       Greenfield-first intent flow; steers existing apps into analyze + init
+  ${cyan3("init")}        Attach Decantr contract/context files to an existing project or empty workspace
   ${cyan3("status")}      Show project status, DNA axioms, and blueprint info
   ${cyan3("sync")}        Sync registry content from API
   ${cyan3("audit")}       Audit the project or critique a specific file against compiled packs
@@ -4986,7 +5115,7 @@ ${BOLD6}Commands:${RESET13}
   ${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("analyze")}     Brownfield entrypoint: scan an existing project and emit attach guidance
   ${cyan3("export")}      Export design tokens to framework format (shadcn, tailwind, css-vars)
   ${cyan3("registry")}    Registry management and intelligence summary
   ${cyan3("upgrade")}     Check for content updates from registry
@@ -4996,7 +5125,7 @@ ${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 init --existing --blueprint=saas-dashboard --theme=luminarum --yes
   decantr status
   decantr audit
   decantr audit src/pages/HomePage.tsx
@@ -5017,6 +5146,15 @@ ${BOLD6}Examples:${RESET13}
   decantr registry audit-project --namespace @official --json
   decantr registry audit-project --namespace @official --dist dist --sources src
   decantr create pattern my-card
+
+${BOLD6}Workflow Model:${RESET13}
+  ${cyan3("Greenfield blueprint")}   decantr new / decantr magic
+  ${cyan3("Brownfield adoption")}    decantr analyze -> decantr init --existing
+  ${cyan3("Hybrid composition")}     decantr add/remove, decantr theme switch, decantr registry, decantr upgrade
+
+${BOLD6}Bootstrap adapters:${RESET13}
+  Current runnable starter adapter: ${cyan3("react-vite")}
+  Other contract targets stay framework-agnostic, but currently initialize in contract-only mode until their starter adapters land.
 `);
 }
 async function main() {
@@ -5095,7 +5233,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-XNUAON3G.js");
+      const { cmdUpgrade } = await import("./upgrade-WE7Y7ZOE.js");
       const applyFlag = args.includes("--apply");
       await cmdUpgrade(process.cwd(), { apply: applyFlag });
       break;