@decantr/cli 1.7.6 → 1.7.8

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

@@ -14,14 +14,14 @@ import {
   scaffoldProject,
   syncRegistry,
   writeExecutionPackBundleArtifacts
-} from "./chunk-H4H3IQJK.js";
+} from "./chunk-74G2RQDO.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 readFileSync18, 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,8 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes) {
     shell,
     personality: ["professional"],
     features: [],
-    existing: detected.existingEssence
+    existing: workflowSeed?.existing || detected.existingEssence,
+    workflowMode: workflowSeed?.workflowMode
   };
 }
 function parseFlags(args, detected) {
@@ -359,20 +363,21 @@ 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,
+    workflowMode: flags.workflowMode || workflowSeed?.workflowMode
   };
 }
 async function runSimplifiedInit(blueprints) {
@@ -1532,11 +1537,11 @@ 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";
+import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join12, relative } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "api", "_app", "_document"]);
 function shouldSkipDir(name) {
@@ -1627,6 +1632,75 @@ function walkPagesDir(dir, baseDir, segments) {
   }
   return routes;
 }
+var ROUTER_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".ts", ".jsx", ".js"]);
+function collectRouteCandidateFiles(dir, files, depth = 0) {
+  if (depth > 5) return;
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".") || entry === "node_modules") continue;
+    const fullPath = join12(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        collectRouteCandidateFiles(fullPath, files, depth + 1);
+      } else if (stat.isFile()) {
+        const ext = entry.slice(entry.lastIndexOf("."));
+        if (ROUTER_FILE_EXTENSIONS.has(ext)) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+function scanReactRouter(projectRoot) {
+  const candidateDirs = [
+    join12(projectRoot, "src"),
+    projectRoot
+  ];
+  const candidateFiles = [];
+  for (const dir of candidateDirs) {
+    if (existsSync12(dir)) collectRouteCandidateFiles(dir, candidateFiles);
+  }
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const absolutePath of candidateFiles) {
+    let content;
+    try {
+      content = readFileSync11(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const isReactRouterFile = content.includes("react-router-dom") || content.includes("react-router") || content.includes("<Routes") || content.includes("createBrowserRouter") || content.includes("createHashRouter") || content.includes("RouterProvider") || content.includes("HashRouter") || content.includes("BrowserRouter");
+    if (!isReactRouterFile) continue;
+    const relativePath = relative(projectRoot, absolutePath);
+    const pathMatches = /* @__PURE__ */ new Set();
+    for (const match of content.matchAll(/<Route\b[^>]*\bpath=["'`]([^"'`]+)["'`]/g)) {
+      pathMatches.add(match[1]);
+    }
+    for (const match of content.matchAll(/\bpath\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+      pathMatches.add(match[1]);
+    }
+    if (pathMatches.size === 0 && (content.includes("<Routes") || content.includes("RouterProvider"))) {
+      pathMatches.add("/");
+    }
+    for (const path of pathMatches) {
+      if (!routeMap.has(path)) {
+        routeMap.set(path, {
+          path,
+          file: relativePath,
+          hasLayout: false
+        });
+      }
+    }
+  }
+  return [...routeMap.values()];
+}
 function scanRoutes(projectRoot) {
   const appDirs = [
     join12(projectRoot, "src", "app"),
@@ -1652,6 +1726,10 @@ function scanRoutes(projectRoot) {
       }
     }
   }
+  const reactRouterRoutes = scanReactRouter(projectRoot);
+  if (reactRouterRoutes.length > 0) {
+    return { strategy: "react-router", routes: reactRouterRoutes };
+  }
   return { strategy: "none", routes: [] };
 }
 
@@ -1659,6 +1737,16 @@ function scanRoutes(projectRoot) {
 import { existsSync as existsSync13, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
 import { join as join13 } from "path";
 var PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".ts", ".jsx", ".js"]);
+var ROOT_COMPONENT_CANDIDATES = [
+  "src/App.tsx",
+  "src/App.ts",
+  "src/App.jsx",
+  "src/App.js",
+  "App.tsx",
+  "App.ts",
+  "App.jsx",
+  "App.js"
+];
 function countFilesRecursive(dir, extensions) {
   let count = 0;
   let entries;
@@ -1750,6 +1838,18 @@ function scanComponents(projectRoot) {
       }
     }
   }
+  const hasRootAppComponent = ROOT_COMPONENT_CANDIDATES.some(
+    (relativePath) => existsSync13(join13(projectRoot, relativePath))
+  );
+  if (pageCount === 0 && hasRootAppComponent) {
+    pageCount = 1;
+  }
+  if (componentCount === 0 && hasRootAppComponent) {
+    componentCount = 1;
+    if (!componentDirs.includes("src")) {
+      componentDirs.push("src");
+    }
+  }
   return {
     pageCount,
     componentCount,
@@ -1758,7 +1858,7 @@ function scanComponents(projectRoot) {
 }
 
 // src/analyzers/styling.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
 import { join as join14 } from "path";
 var TAILWIND_CONFIGS = [
   "tailwind.config.js",
@@ -1769,11 +1869,17 @@ var TAILWIND_CONFIGS = [
 var GLOBALS_CSS_PATHS = [
   "src/app/globals.css",
   "app/globals.css",
+  "src/styles/global.css",
   "src/styles/globals.css",
   "styles/globals.css",
   "src/index.css",
   "src/global.css"
 ];
+var DECANTR_STYLE_PATHS = [
+  "src/styles/tokens.css",
+  "src/styles/treatments.css",
+  "src/styles/global.css"
+];
 function extractCSSVariables(content) {
   const colors = {};
   const variables = [];
@@ -1790,8 +1896,8 @@ function extractCSSVariables(content) {
   }
   return { colors, variables };
 }
-function detectDarkMode(projectRoot, cssContent) {
-  if (cssContent) {
+function detectDarkMode(projectRoot, cssContents) {
+  for (const cssContent of cssContents) {
     if (cssContent.includes(".dark") || cssContent.includes('[data-theme="dark"]') || cssContent.includes("prefers-color-scheme: dark") || cssContent.includes("color-scheme: dark")) {
       return true;
     }
@@ -1806,7 +1912,7 @@ function detectDarkMode(projectRoot, cssContent) {
     const fullPath = join14(projectRoot, rel);
     if (existsSync14(fullPath)) {
       try {
-        const layoutContent = readFileSync11(fullPath, "utf-8");
+        const layoutContent = readFileSync12(fullPath, "utf-8");
         if (layoutContent.includes('className="dark"') || layoutContent.includes("className='dark'") || layoutContent.includes('class="dark"')) {
           return true;
         }
@@ -1817,7 +1923,7 @@ function detectDarkMode(projectRoot, cssContent) {
   const pkgPath = join14(projectRoot, "package.json");
   if (existsSync14(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps["next-themes"] || allDeps["theme-toggle"] || allDeps["use-dark-mode"]) {
         return true;
@@ -1825,6 +1931,17 @@ function detectDarkMode(projectRoot, cssContent) {
     } catch {
     }
   }
+  const essencePath = join14(projectRoot, "decantr.essence.json");
+  if (existsSync14(essencePath)) {
+    try {
+      const essence = JSON.parse(readFileSync12(essencePath, "utf-8"));
+      const mode = essence.dna?.theme?.mode;
+      if (mode === "dark" || mode === "auto") {
+        return true;
+      }
+    } catch {
+    }
+  }
   return false;
 }
 function scanStyling(projectRoot) {
@@ -1841,8 +1958,12 @@ function scanStyling(projectRoot) {
     const pkgPath = join14(projectRoot, "package.json");
     if (existsSync14(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps["@decantr/css"]) {
+          approach = "decantr-css";
+          configFile = "src/styles/tokens.css";
+        }
         if (allDeps.tailwindcss || allDeps["@tailwindcss/postcss"] || allDeps["@tailwindcss/vite"]) {
           approach = "tailwind";
         }
@@ -1850,25 +1971,44 @@ function scanStyling(projectRoot) {
       }
     }
   }
-  let cssContent = null;
+  const decantrStyleFiles = DECANTR_STYLE_PATHS.filter((rel) => existsSync14(join14(projectRoot, rel)));
+  if (decantrStyleFiles.length >= 2) {
+    approach = "decantr-css";
+    configFile = decantrStyleFiles.join(" + ");
+  }
+  const cssContents = [];
   for (const rel of GLOBALS_CSS_PATHS) {
     const fullPath = join14(projectRoot, rel);
     if (existsSync14(fullPath)) {
       try {
-        cssContent = readFileSync11(fullPath, "utf-8");
+        cssContents.push(readFileSync12(fullPath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  for (const rel of DECANTR_STYLE_PATHS) {
+    if (GLOBALS_CSS_PATHS.includes(rel)) continue;
+    const fullPath = join14(projectRoot, rel);
+    if (existsSync14(fullPath)) {
+      try {
+        cssContents.push(readFileSync12(fullPath, "utf-8"));
       } catch {
       }
-      break;
     }
   }
   let colors = {};
   let cssVariables = [];
-  if (cssContent) {
+  for (const cssContent of cssContents) {
     const extracted = extractCSSVariables(cssContent);
-    colors = extracted.colors;
-    cssVariables = extracted.variables;
+    colors = { ...colors, ...extracted.colors };
+    cssVariables.push(...extracted.variables);
+  }
+  cssVariables = [...new Set(cssVariables)];
+  const darkMode = detectDarkMode(projectRoot, cssContents);
+  if (approach === "unknown" && cssContents.length > 0) {
+    approach = "css";
+    configFile = GLOBALS_CSS_PATHS.find((rel) => existsSync14(join14(projectRoot, rel)));
   }
-  const darkMode = detectDarkMode(projectRoot, cssContent);
   return {
     approach,
     configFile,
@@ -1879,7 +2019,7 @@ function scanStyling(projectRoot) {
 }
 
 // src/analyzers/layout.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "fs";
 import { join as join15 } from "path";
 var SIDEBAR_PATTERNS = ["sidebar", "side-bar", "sidenav", "side-nav", "drawer", "aside"];
 var NAV_PATTERNS = ["nav", "navbar", "header", "top-bar", "topbar", "app-bar", "appbar"];
@@ -1924,7 +2064,7 @@ function checkLayoutFiles(projectRoot) {
     if (!existsSync15(layoutPath)) continue;
     let content;
     try {
-      content = readFileSync12(layoutPath, "utf-8");
+      content = readFileSync13(layoutPath, "utf-8");
     } catch {
       continue;
     }
@@ -1944,7 +2084,7 @@ function checkLayoutFiles(projectRoot) {
       if (!existsSync15(layoutPath)) continue;
       let content;
       try {
-        content = readFileSync12(layoutPath, "utf-8");
+        content = readFileSync13(layoutPath, "utf-8");
       } catch {
         continue;
       }
@@ -1965,17 +2105,40 @@ function inferShellPattern(hasSidebar, hasTopNav, hasFooter) {
   if (hasFooter) return "main-footer";
   return "main-only";
 }
+function inferShellPatternFromDecantrContract(projectRoot) {
+  const essencePath = join15(projectRoot, "decantr.essence.json");
+  if (!existsSync15(essencePath)) return null;
+  try {
+    const essence = JSON.parse(readFileSync13(essencePath, "utf-8"));
+    const sectionShells = essence.blueprint?.sections?.map((section) => section.shell).filter((shell) => typeof shell === "string" && shell.length > 0) ?? [];
+    if (sectionShells.length === 0 && essence.blueprint?.shell) {
+      return `${essence.blueprint.shell} (contract)`;
+    }
+    const uniqueShells = [...new Set(sectionShells)];
+    if (uniqueShells.length === 0) return null;
+    if (uniqueShells.length === 1) return `${uniqueShells[0]} (contract)`;
+    const primarySection = essence.blueprint?.sections?.find((section) => section.role === "primary" && section.shell);
+    if (primarySection?.shell) {
+      return `${primarySection.shell} (primary contract)`;
+    }
+    return `${uniqueShells[0]} (+${uniqueShells.length - 1} shells, contract)`;
+  } catch {
+    return null;
+  }
+}
 function scanLayout(projectRoot) {
   const fromComponents = checkComponentDirs(projectRoot);
   const fromLayouts = checkLayoutFiles(projectRoot);
   const hasSidebar = fromComponents.sidebar || fromLayouts.sidebar;
   const hasTopNav = fromComponents.nav || fromLayouts.nav;
   const hasFooter = fromComponents.footer || fromLayouts.footer;
+  const runtimeShellPattern = inferShellPattern(hasSidebar, hasTopNav, hasFooter);
+  const contractShellPattern = inferShellPatternFromDecantrContract(projectRoot);
   return {
     hasSidebar,
     hasTopNav,
     hasFooter,
-    shellPattern: inferShellPattern(hasSidebar, hasTopNav, hasFooter)
+    shellPattern: runtimeShellPattern === "main-only" && contractShellPattern ? contractShellPattern : runtimeShellPattern
   };
 }
 
@@ -2059,12 +2222,14 @@ function scanFeatures(projectRoot) {
 }
 
 // src/analyzers/dependencies.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
 import { join as join17 } from "path";
 var CATEGORIES = {
   ui: [
     "react",
     "react-dom",
+    "react-router",
+    "react-router-dom",
     "vue",
     "svelte",
     "@angular/core",
@@ -2212,7 +2377,7 @@ function scanDependencies(projectRoot) {
   if (!existsSync17(pkgPath)) return result;
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
   } catch {
     return result;
   }
@@ -2231,6 +2396,54 @@ function scanDependencies(projectRoot) {
   return result;
 }
 
+// src/workflow-model.ts
+import { existsSync as existsSync18, readFileSync as readFileSync15 } 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,
+    workflowMode: "brownfield-attach",
+    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(readFileSync15(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 +2469,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 +2485,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 +2532,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 +2768,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 +2887,6 @@ async function cmdMagic(prompt, projectRoot, options) {
     return;
   }
   console.log("");
-  const detected = detectProject(projectRoot);
   let archetypeData;
   let composedSections;
   let routeMap;
@@ -2809,14 +3048,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 +3080,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 readFileSync16, 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 +3227,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 = readFileSync16(tokensPath, "utf-8");
   const tokens = parseTokensCSS(tokensCSS);
   if (tokens.size === 0) {
     console.error(`${RED8}No --d-* tokens found in tokens.css.${RESET10}`);
@@ -3009,8 +3248,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 +3259,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 +3267,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 +3278,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 +3313,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 +3323,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 +3350,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 +3364,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 readFileSync17, 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 +3533,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 +3568,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(readFileSync17(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 error2(text) {
+  return `${RED10}${text}${RESET12}`;
 }
-function getTargetRoutingMode(target) {
-  return (target || "react").toLowerCase() === "nextjs" ? "pathname" : "hash";
+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 +3698,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 +3712,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";
@@ -3551,9 +3826,11 @@ function extractPatternName(item) {
   }
   return "custom";
 }
-function generateCuratedPrompt(ctx) {
+function generateGreenfieldPrompt(ctx) {
   const lines = [];
-  lines.push("Build this application using the Decantr design system.");
+  lines.push("Build this greenfield application using the Decantr design system.");
+  lines.push("");
+  lines.push("This workspace is a new Decantr scaffold. Use the contract to create or extend the runtime deliberately, not to reverse-engineer a hidden starter.");
   lines.push("");
   lines.push("Treat the compiled execution-pack files as the primary source of truth.");
   lines.push("Use narrative docs only as secondary explanation when the compiled packs are not enough.");
@@ -3572,6 +3849,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:");
@@ -3581,6 +3864,50 @@ function generateCuratedPrompt(ctx) {
   lines.push("- If a required context file is missing or inconsistent, stop and report exactly which file is missing before continuing.");
   return lines.join("\n");
 }
+function generateBrownfieldPrompt(ctx) {
+  const lines = [];
+  lines.push("Attach Decantr to this existing application without rebuilding it from scratch.");
+  lines.push("");
+  lines.push("Preserve the current framework, package manager, router, build tooling, and working runtime structure unless the generated Decantr contract gives you a reviewed reason to change them.");
+  lines.push("");
+  lines.push("Treat .decantr/analysis.json as the factual inventory of the current app.");
+  lines.push("Treat .decantr/init-seed.json as the recommended Decantr attach defaults.");
+  lines.push("Treat the compiled execution-pack files as the Decantr contract you are layering onto the app.");
+  lines.push("Use only files present in this workspace as the source of truth. If the runtime and contract disagree, call out the drift explicitly instead of improvising a rewrite.");
+  lines.push("");
+  lines.push("Read in this order:");
+  lines.push("1. .decantr/analysis.json for the detected framework, routes, styling, layout, and dependencies.");
+  lines.push("2. .decantr/init-seed.json for the intended attach defaults and workflow lane.");
+  lines.push("3. DECANTR.md for guard rules, CSS expectations, and Decantr operating rules.");
+  lines.push("4. .decantr/context/scaffold-pack.md for the compact compiled shell, theme, feature, and route contract.");
+  lines.push("5. .decantr/context/scaffold.md for broader topology, route map, and voice guidance.");
+  lines.push("6. The matching section and page pack files only when you are working on those specific surfaces.");
+  lines.push("");
+  lines.push("Implementation rules:");
+  lines.push("- Preserve existing files and working flows whenever possible. Prefer incremental attachment over whole-app rewrites.");
+  lines.push("- Map existing routes and components onto the declared Decantr sections/pages before creating new files.");
+  lines.push("- If package.json, router files, or style files already exist, extend them deliberately instead of replacing them with a different starter shape.");
+  lines.push("- If Decantr style files are absent, add src/styles/global.css, src/styles/tokens.css, and src/styles/treatments.css in a way that fits the current app structure.");
+  lines.push("- Use the existing Decantr tokens, treatments, and decorators instead of inventing a parallel visual system.");
+  lines.push("- Registry content is optional in this workflow unless the task explicitly asks for blueprint/theme/pattern enrichment.");
+  lines.push("- Do not invent routes, sections, shells, themes, or features that are not present in the compiled packs.");
+  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.");
+  lines.push("- Let shells own spacing, centering, and scroll containers. Preserve app structure, but remove duplicated shell responsibilities when the contract makes them explicit.");
+  lines.push("- If command_palette or hotkeys are declared in the generated context, implement them as real features.");
+  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:");
+  lines.push("- Start by inventorying the current runtime and identifying the safest route/component anchors for attachment.");
+  lines.push("- Align the shared shell and route structure incrementally instead of replacing the app shell wholesale.");
+  lines.push("- Then attach or refine section pages using the matching section and page packs.");
+  lines.push("- After implementation, run decantr check and decantr audit and fix contract or drift issues.");
+  lines.push("- If a required context file or runtime anchor is missing, stop and report exactly what is missing before continuing.");
+  return lines.join("\n");
+}
+function generateCuratedPrompt(ctx) {
+  return ctx.workflow === "brownfield-attach" ? generateBrownfieldPrompt(ctx) : generateGreenfieldPrompt(ctx);
+}
 function getAPIClient() {
   return new RegistryAPIClient3({
     baseUrl: process.env.DECANTR_API_URL || void 0,
@@ -3606,18 +3933,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 = readFileSync18(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] = readFileSync18(assetFilePath, "utf-8");
     }
   }
   return {
@@ -3632,24 +3959,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] = readFileSync18(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -3766,19 +4093,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(readFileSync18(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 +4128,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 +4140,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(readFileSync18(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -3831,14 +4158,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 +4190,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(readFileSync18(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 +4224,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 +4240,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync16(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync18(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync9(contextDir, { recursive: true });
+    mkdirSync10(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -3926,19 +4253,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(readFileSync18(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -3946,10 +4273,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 +4287,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 = readFileSync18(resolvedSourcePath, "utf-8");
+  const essence = JSON.parse(readFileSync18(resolvedEssencePath, "utf-8"));
+  const treatmentsCss = existsSync25(resolvedTreatmentsPath) ? readFileSync18(resolvedTreatmentsPath, "utf-8") : void 0;
   const report = await client.critiqueFile(
     {
       essence,
@@ -3994,11 +4321,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(readFileSync18(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -4015,7 +4342,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 +4420,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 +4429,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(readFileSync18(bundledPath, "utf-8"));
     console.log(JSON.stringify(data, null, 2));
     return;
   }
@@ -4120,10 +4447,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 = readFileSync18(essencePath, "utf-8");
   } catch {
     console.error(error3(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -4177,7 +4504,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 +4554,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 +4583,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 +4597,8 @@ async function cmdInit(args) {
   }
   let selectedBlueprint = "default";
   let registrySource = "cache";
+  const preferContractOnly = brownfieldAttach && !requestedBlueprint && !requestedArchetype;
+  const workflowMode = workflowSeed || brownfieldAttach && !requestedBlueprint && !requestedArchetype ? "brownfield-attach" : "greenfield-scaffold";
   if (args.yes) {
     selectedBlueprint = args.blueprint || "default";
   } else if (!apiAvailable) {
@@ -4299,7 +4633,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,14 +4661,15 @@ ${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;
     userExplicit.personality = true;
   }
+  options.workflowMode = workflowMode;
   let topologyMarkdown = "";
   let archetypeData;
   let composedSections;
@@ -4512,6 +4847,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 +4869,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 = readFileSync18(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   if (essence.version !== "3.1.0") {
     const validation = validateEssence2(essence);
@@ -4551,6 +4891,7 @@ Validation warnings: ${validation.errors.join(", ")}`));
     promptPages = essence.structure || [{ id: "home", shell: options.shell, layout: ["hero"] }];
   }
   const promptCtx = {
+    workflow: options.workflowMode === "brownfield-attach" ? "brownfield-attach" : "greenfield-scaffold",
     archetype: options.archetype || "custom",
     blueprint: options.blueprint,
     theme: options.theme,
@@ -4576,16 +4917,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(readFileSync18(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
     const essenceVersion = isV36(essence) ? "v3" : "v2";
     console.log(`${BOLD6}Essence:${RESET13}`);
@@ -4634,9 +4975,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(readFileSync18(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
@@ -4654,7 +4995,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 +5184,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(readFileSync18(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
           console.log(success3(`Custom theme "${name}" is valid`));
@@ -4966,9 +5307,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 +5327,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 +5337,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 +5358,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 +5445,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-XNUAON3G.js");
+      const { cmdUpgrade } = await import("./upgrade-UXY2WUJH.js");
       const applyFlag = args.includes("--apply");
       await cmdUpgrade(process.cwd(), { apply: applyFlag });
       break;