@decantr/cli 1.7.28 → 1.7.29

package/dist/{chunk-56VBV4MT.js → chunk-US6RK5QT.js}

@@ -14,18 +14,23 @@ import {
   scaffoldProject,
   syncRegistry,
   writeExecutionPackBundleArtifacts
-} from "./chunk-GCDFX7UE.js";
+} from "./chunk-HULA6E2D.js";
 import {
   buildGuardRegistryContext,
+  createDoctrineMap,
+  scanAmbientContext,
   scanProjectInteractions,
-  sendCliCommandTelemetry
-} from "./chunk-RRRHQ45P.js";
+  scanRoutes,
+  scanStyling,
+  sendCliCommandTelemetry,
+  writeDoctrineMap
+} from "./chunk-DI2PLOJ6.js";
 
 // src/index.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync11, readdirSync as readdirSync7, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
-import { basename as basename2, dirname as dirname4, isAbsolute, join as join28, resolve as resolve4 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync12, readdirSync as readdirSync6, readFileSync as readFileSync19, writeFileSync as writeFileSync15 } from "fs";
+import { basename as basename2, dirname as dirname4, isAbsolute, join as join27, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { evaluateGuard, isV3 as isV36, validateEssence as validateEssence2 } from "@decantr/essence-spec";
+import { evaluateGuard, isV3 as isV37, validateEssence as validateEssence2 } from "@decantr/essence-spec";
 import {
   CONTENT_TYPE_TO_API_CONTENT_TYPE as CONTENT_TYPE_TO_API_CONTENT_TYPE3,
   CONTENT_TYPES as GET_CONTENT_TYPES,
@@ -274,7 +279,7 @@ function buildAssistantBridgeContent(input) {
   lines.push("# Decantr Assistant Bridge");
   lines.push("");
   lines.push(
-    "Use this bridge when an AI assistant works in a repository that already has local rules."
+    "Use this bridge when an AI assistant works in a repository that already has local rules and Decantr has compiled them into a brownfield contract."
   );
   lines.push("");
   lines.push(`- Workflow mode: ${input.workflowMode}`);
@@ -289,13 +294,13 @@ function buildAssistantBridgeContent(input) {
   lines.push("");
   lines.push(START);
   lines.push(
-    "Before implementing Decantr-scoped work, read `DECANTR.md`, `decantr.essence.json`, and the compiled packs in `.decantr/context/`."
+    "Before implementing Decantr-scoped work, read `decantr.essence.json`, `.decantr/brownfield-report.md`, `.decantr/doctrine-map.json`, `.decantr/ambient-context.json`, and the compiled packs in `.decantr/context/`."
   );
   lines.push(
-    "For brownfield adoption, preserve existing framework, routing, styling, package manager, and build conventions unless the Decantr contract explicitly requires a reviewed change."
+    "Treat Decantr as the reconciled contract layer and the original project docs/rules as cited evidence; if they conflict, stop and report the conflict instead of guessing."
   );
   lines.push(
-    "Use `.decantr/context/scaffold-pack.md` as the primary compact contract, then read matching section/page packs for the surface being changed."
+    "For brownfield adoption, preserve existing framework, routing, styling, package manager, data boundaries, and build conventions unless the Decantr contract explicitly records a reviewed change."
   );
   lines.push(
     "Do not install `@decantr/css` or rewrite styling unless the project adoption mode says `decantr-css` or the task explicitly asks for it."
@@ -315,8 +320,9 @@ function writeAssistantBridgePreview(input) {
 function bridgeBlock() {
   return [
     START,
-    "Before implementing Decantr-scoped work, read `DECANTR.md`, `decantr.essence.json`, and `.decantr/context/scaffold-pack.md` first.",
-    "For brownfield adoption, preserve existing framework, routing, styling, package manager, and build conventions unless the Decantr contract explicitly requires a reviewed change.",
+    "Before implementing Decantr-scoped work, read `decantr.essence.json`, `.decantr/brownfield-report.md`, `.decantr/doctrine-map.json`, `.decantr/ambient-context.json`, and `.decantr/context/scaffold-pack.md` first.",
+    "Treat Decantr as the reconciled contract layer and the original project docs/rules as cited evidence; if they conflict, stop and report the conflict instead of guessing.",
+    "For brownfield adoption, preserve existing framework, routing, styling, package manager, data boundaries, and build conventions unless the Decantr contract explicitly records a reviewed change.",
     "Do not install `@decantr/css` or rewrite styling unless the project adoption mode says `decantr-css` or the task explicitly asks for it.",
     END,
     ""
@@ -345,6 +351,16 @@ description: Decantr project contract and brownfield adoption bridge
 alwaysApply: true
 ---
 
+${bridgeBlock()}`;
+  if (existsSync3(path) && readFileSync3(path, "utf-8") === content) return false;
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync3(path, content);
+  return true;
+}
+function writeClaudeRule(projectRoot) {
+  const path = join3(projectRoot, ".claude", "rules", "decantr.md");
+  const content = `# Decantr Brownfield Bridge
+
 ${bridgeBlock()}`;
   if (existsSync3(path) && readFileSync3(path, "utf-8") === content) return false;
   mkdirSync2(dirname(path), { recursive: true });
@@ -353,7 +369,13 @@ ${bridgeBlock()}`;
 }
 function applyAssistantBridge(projectRoot, detected) {
   const updated = [];
-  const markdownTargets = ["CLAUDE.md", "AGENTS.md", "GEMINI.md", "copilot-instructions.md"];
+  const markdownTargets = [
+    "CLAUDE.md",
+    "AGENTS.md",
+    "GEMINI.md",
+    "copilot-instructions.md",
+    ".github/copilot-instructions.md"
+  ];
   for (const target of markdownTargets) {
     if (detected.existingRuleFiles.includes(target) && upsertMarkdownBlock(join3(projectRoot, target))) {
       updated.push(target);
@@ -362,6 +384,12 @@ function applyAssistantBridge(projectRoot, detected) {
   if (detected.existingRuleFiles.includes(".cursorrules")) {
     if (upsertMarkdownBlock(join3(projectRoot, ".cursorrules"))) updated.push(".cursorrules");
   }
+  if (detected.existingRuleFiles.includes(".windsurfrules")) {
+    if (upsertMarkdownBlock(join3(projectRoot, ".windsurfrules"))) updated.push(".windsurfrules");
+  }
+  if (detected.existingRuleFiles.includes(".claude/rules")) {
+    if (writeClaudeRule(projectRoot)) updated.push(".claude/rules/decantr.md");
+  }
   if (detected.existingRuleFiles.includes(".cursor/rules")) {
     if (writeCursorRule(projectRoot)) updated.push(".cursor/rules/decantr.mdc");
   }
@@ -371,13 +399,540 @@ function applyAssistantBridge(projectRoot, detected) {
   return updated;
 }
 
+// src/brownfield-proposal.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+import { isV3 as isV32 } from "@decantr/essence-spec";
+function slugify(value, fallback) {
+  const slug = value.replace(/^\//, "").replace(/:[^/]+/g, "param").replace(/\*/g, "all").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return slug || fallback;
+}
+var ROUTE_DOMAINS = [
+  {
+    sectionId: "observed-auth",
+    role: "gateway",
+    label: "Authentication",
+    description: "Observed authentication, sign-in, sign-up, callback, and account-entry surfaces.",
+    featureHints: ["auth"],
+    priority: 10
+  },
+  {
+    sectionId: "observed-rbac",
+    role: "auxiliary",
+    label: "RBAC and User Administration",
+    description: "Observed role, permission, user-management, and access-control administration surfaces.",
+    featureHints: ["admin", "team", "settings", "auth"],
+    priority: 30
+  },
+  {
+    sectionId: "observed-billing",
+    role: "auxiliary",
+    label: "Billing",
+    description: "Observed billing, subscription, plan, payment, invoice, and checkout surfaces.",
+    featureHints: ["billing", "admin"],
+    priority: 34
+  },
+  {
+    sectionId: "observed-admin",
+    role: "auxiliary",
+    label: "Administration",
+    description: "Observed administrative and operational management surfaces.",
+    featureHints: ["admin", "team"],
+    priority: 36
+  },
+  {
+    sectionId: "observed-settings",
+    role: "auxiliary",
+    label: "Settings",
+    description: "Observed account, profile, client-settings, organization, and user-preference surfaces.",
+    featureHints: ["settings", "profile", "team"],
+    priority: 38
+  },
+  {
+    sectionId: "observed-api-access",
+    role: "auxiliary",
+    label: "API Access",
+    description: "Observed developer, API key, token, and credential-management surfaces.",
+    featureHints: ["api-keys", "admin"],
+    priority: 40
+  },
+  {
+    sectionId: "observed-reporting",
+    role: "primary",
+    label: "Reporting",
+    description: "Observed reporting, analytics, metrics, dashboard, and compliance surfaces.",
+    featureHints: ["dashboard", "admin"],
+    priority: 58
+  },
+  {
+    sectionId: "observed-facilities",
+    role: "primary",
+    label: "Facilities",
+    description: "Observed facility, location, bin, lifecycle, and operational surfaces.",
+    featureHints: ["file-upload", "dashboard"],
+    priority: 60
+  },
+  {
+    sectionId: "observed-lab-results",
+    role: "primary",
+    label: "Lab Results",
+    description: "Observed lab result, report detail, compliance, and evidence-review surfaces.",
+    featureHints: ["dashboard", "file-upload"],
+    priority: 62
+  },
+  {
+    sectionId: "observed-ai-insights",
+    role: "primary",
+    label: "AI Insights",
+    description: "Observed AI insight, assistant, intelligence, recommendation, and automation surfaces.",
+    featureHints: ["dashboard", "chat"],
+    priority: 64
+  },
+  {
+    sectionId: "observed-communications",
+    role: "primary",
+    label: "Communications",
+    description: "Observed chat, message, inbox, notification, and announcement surfaces.",
+    featureHints: ["chat", "notifications"],
+    priority: 66
+  },
+  {
+    sectionId: "observed-brand-portal",
+    role: "primary",
+    label: "Brand Portal",
+    description: "Observed brand, asset, media, gallery, and upload surfaces.",
+    featureHints: ["file-upload", "content"],
+    priority: 68
+  },
+  {
+    sectionId: "observed-content",
+    role: "primary",
+    label: "Content",
+    description: "Observed CMS, editor, article, post, catalog, and content-management surfaces.",
+    featureHints: ["content", "search"],
+    priority: 70
+  },
+  {
+    sectionId: "observed-dashboard",
+    role: "primary",
+    label: "Dashboard",
+    description: "Observed dashboard, overview, workspace, and primary application surfaces.",
+    featureHints: ["dashboard", "search"],
+    priority: 72
+  },
+  {
+    sectionId: "observed-public",
+    role: "public",
+    label: "Public",
+    description: "Observed public-facing, marketing, docs, blog, legal, contact, and home routes.",
+    featureHints: ["content", "search"],
+    priority: 0
+  },
+  {
+    sectionId: "observed-primary",
+    role: "primary",
+    label: "Primary Application",
+    description: "Observed primary application routes from the existing application.",
+    featureHints: [],
+    priority: 90
+  }
+];
+function routeDomain(path) {
+  const lower = path.toLowerCase();
+  if (/\/(login|signin|sign-in|signup|sign-up|register|auth|callback|reset-password|forgot-password)/.test(
+    lower
+  )) {
+    return ROUTE_DOMAINS[0];
+  }
+  if (/\/(rbac|roles?|permissions?|manage-rbac|manage-users|user-management|access-control)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-rbac");
+  }
+  if (/\/(billing|subscription|subscriptions|pricing|plans|checkout|payment|payments|stripe|invoice|invoices)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-billing");
+  }
+  if (/\/(admin|moderation|moderate|system-logs)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-admin");
+  }
+  if (/\/(settings|profile|account|client-settings|user-settings|preferences|organization|org|team|members)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-settings");
+  }
+  if (/\/(api-keys?|api-key-management|developer|developers|tokens?|credentials?)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-api-access");
+  }
+  if (/\/(reports?|analytics|metrics|stats|compliance|environmental|operations)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-reporting");
+  }
+  if (/\/(facilities|facility|locations?|bins?|lifecycle)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-facilities");
+  }
+  if (/\/(lab-results?|lab|results?)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-lab-results");
+  }
+  if (/\/(ai-insights?|insights?|ai|assistant|automation|recommendations?)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-ai-insights");
+  }
+  if (/\/(chat|messages?|messaging|conversations?|inbox|notifications?|alerts?)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-communications");
+  }
+  if (/\/(brand|brand-portal|assets?|media|gallery|uploads?)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-brand-portal");
+  }
+  if (/\/(content|cms|editor|posts?|articles?|catalog|library|registry|marketplace)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-content");
+  }
+  if (path === "/" || /\/(about|contact|pricing|blog|docs|legal|privacy|terms|marketing)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-public");
+  }
+  if (/\/(dashboard|overview|workspace|home)\b/.test(lower)) {
+    return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-dashboard");
+  }
+  return ROUTE_DOMAINS.find((domain) => domain.sectionId === "observed-primary");
+}
+function platformForTarget(target, routeStrategy) {
+  const normalized = target.toLowerCase();
+  if (routeStrategy === "app-router" || routeStrategy === "pages-router" || routeStrategy === "mixed-next-router" || routeStrategy === "sveltekit-router" || routeStrategy === "nuxt-router") {
+    return { type: "ssr", routing: "pathname" };
+  }
+  if (normalized === "nextjs" || normalized === "nuxt" || normalized === "astro") {
+    return { type: "ssr", routing: "pathname" };
+  }
+  if (routeStrategy === "react-router") return { type: "spa", routing: "history" };
+  if (normalized === "html") return { type: "static", routing: "pathname" };
+  return { type: "spa", routing: "history" };
+}
+function featuresForSection(sectionId, features) {
+  const domain = ROUTE_DOMAINS.find((candidate) => candidate.sectionId === sectionId);
+  if (domain && domain.featureHints.length > 0) {
+    return features.filter((f) => domain.featureHints.includes(f));
+  }
+  return features;
+}
+function doctrineEffects(ambient) {
+  const effects = {};
+  if (ambient.summary["security-data"] > 0) {
+    effects["doctrine-security-data"] = "Preserve existing auth, middleware, schema, migration, RLS, and data-boundary rules unless the user explicitly approves a reviewed migration.";
+  }
+  if (ambient.summary["design-system"] > 0) {
+    effects["doctrine-design-system"] = "Preserve existing design-system tokens, component conventions, and styling framework unless the user explicitly opts into style migration.";
+  }
+  if (ambient.summary["workflow-ci"] > 0) {
+    effects["doctrine-workflow-ci"] = "Use existing package-manager, build, test, lint, deployment, and CI conventions as validation evidence.";
+  }
+  if (ambient.summary["feature-business"] > 0) {
+    effects["doctrine-feature-business"] = "Treat initiative, memory, and feature docs as business-domain evidence; verify stale risks before enforcing them.";
+  }
+  return Object.keys(effects).length > 0 ? effects : void 0;
+}
+function createBrownfieldProposal(input) {
+  const target = input.project.framework !== "unknown" ? input.project.framework : "generic-web";
+  const shell = input.layout.shellPattern || "observed-existing-shell";
+  const routeMap = {};
+  const sectionMap = /* @__PURE__ */ new Map();
+  const observedRoutes = input.routes.routes.length > 0 ? input.routes.routes : [{ path: "/", file: ".", hasLayout: false }];
+  for (const route of observedRoutes) {
+    const classified = routeDomain(route.path);
+    const section = sectionMap.get(classified.sectionId) ?? {
+      id: classified.sectionId,
+      role: classified.role,
+      shell,
+      features: featuresForSection(classified.sectionId, input.features.detected),
+      description: classified.description,
+      pages: [],
+      directives: [
+        `Semantic domain: ${classified.label}. Use this as an observed product-domain grouping, not a scaffold category.`,
+        "Preserve existing route files, layouts, data boundaries, and styling conventions unless the user explicitly approves a migration."
+      ]
+    };
+    const pageId = route.path === "/" ? "home" : slugify(route.path, "observed-page");
+    if (!section.pages.some((page) => page.id === pageId)) {
+      section.pages.push({
+        id: pageId,
+        route: route.path,
+        layout: ["existing-surface"],
+        directives: [
+          `Observed source: ${route.file}. Treat this route as existing product surface, not scaffold territory.`
+        ]
+      });
+    }
+    routeMap[route.path] = { section: section.id, page: pageId };
+    sectionMap.set(section.id, section);
+  }
+  const sections = [...sectionMap.values()].sort((a, b) => {
+    const aPriority = ROUTE_DOMAINS.find((domain) => domain.sectionId === a.id)?.priority ?? 99;
+    const bPriority = ROUTE_DOMAINS.find((domain) => domain.sectionId === b.id)?.priority ?? 99;
+    return aPriority - bPriority || a.id.localeCompare(b.id);
+  });
+  const essence = {
+    version: "3.1.0",
+    dna: {
+      theme: {
+        id: "existing",
+        mode: input.styling.darkMode ? "dark" : "auto",
+        shape: "rounded"
+      },
+      spacing: {
+        base_unit: 4,
+        scale: "observed",
+        density: "comfortable",
+        content_gap: "_gap4"
+      },
+      typography: {
+        scale: "observed",
+        heading_weight: 600,
+        body_weight: 400
+      },
+      color: {
+        palette: input.styling.approach === "unknown" ? "observed" : input.styling.approach,
+        accent_count: Math.max(1, Object.keys(input.styling.colors).length),
+        cvd_preference: "auto"
+      },
+      radius: {
+        philosophy: "observed",
+        base: 8
+      },
+      elevation: {
+        system: "observed",
+        max_levels: 3
+      },
+      motion: {
+        preference: input.dependencies.ui.includes("framer-motion") ? "expressive" : "subtle",
+        duration_scale: 1,
+        reduce_motion: true
+      },
+      accessibility: {
+        wcag_level: "AA",
+        focus_visible: true,
+        skip_nav: true
+      },
+      personality: ["observed brownfield product"],
+      constraints: {
+        mode: "existing project wins",
+        typography: "derive from existing docs, CSS variables, and component conventions",
+        borders: "derive from existing design system",
+        corners: "derive from existing design system",
+        shadows: "derive from existing design system",
+        effects: doctrineEffects(input.ambient)
+      }
+    },
+    blueprint: {
+      sections,
+      features: input.features.detected,
+      routes: routeMap
+    },
+    meta: {
+      archetype: "observed-brownfield",
+      target,
+      platform: platformForTarget(target, input.routes.strategy),
+      guard: {
+        mode: "guided",
+        dna_enforcement: "error",
+        blueprint_enforcement: "warn",
+        interactions_enforcement: "warn"
+      },
+      navigation: {
+        command_palette: false
+      }
+    }
+  };
+  return {
+    version: 1,
+    kind: "brownfield-observed-essence",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "proposed",
+    essence,
+    evidence: {
+      routeCount: input.routes.routes.length,
+      componentCount: input.components.componentCount,
+      featureCount: input.features.detected.length,
+      ambientContextCount: input.ambient.items.length,
+      stylingApproach: input.styling.approach,
+      shell,
+      semanticSectionCount: sections.length
+    },
+    conflicts: input.ambient.conflicts,
+    staleRisks: input.ambient.staleRisks,
+    acceptance: {
+      create: "decantr init --existing --accept-proposal",
+      merge: "decantr init --existing --merge-proposal",
+      replace: "decantr init --existing --replace-essence"
+    }
+  };
+}
+function proposalPath(projectRoot) {
+  return join4(projectRoot, ".decantr", "observed-essence.proposal.json");
+}
+function writeBrownfieldProposal(projectRoot, proposal) {
+  const decantrDir = join4(projectRoot, ".decantr");
+  mkdirSync3(decantrDir, { recursive: true });
+  writeFileSync4(proposalPath(projectRoot), JSON.stringify(proposal, null, 2) + "\n", "utf-8");
+}
+function readBrownfieldProposal(projectRoot) {
+  const path = proposalPath(projectRoot);
+  if (!existsSync4(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
+    if (parsed.kind !== "brownfield-observed-essence" || !isV32(parsed.essence)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function generateBrownfieldReport(proposal, ambient, doctrine) {
+  const lines = [];
+  lines.push("# Decantr Brownfield Report");
+  lines.push("");
+  lines.push("Decantr analyzed this app as an existing product. The proposal below is observed from the codebase and ambient project doctrine; it is not a Decantr scaffold.");
+  lines.push("");
+  lines.push("## Proposal");
+  lines.push("");
+  lines.push(`- Routes observed: ${proposal.evidence.routeCount}`);
+  lines.push(`- Semantic sections inferred: ${proposal.evidence.semanticSectionCount}`);
+  lines.push(`- Components observed: ${proposal.evidence.componentCount}`);
+  lines.push(`- Features observed: ${proposal.evidence.featureCount}`);
+  lines.push(`- Styling approach: ${proposal.evidence.stylingApproach}`);
+  lines.push(`- Shell signal: ${proposal.evidence.shell}`);
+  lines.push(`- Ambient context items: ${proposal.evidence.ambientContextCount}`);
+  lines.push(`- Theme posture: existing project wins`);
+  if (doctrine) {
+    lines.push(`- Doctrine sources ranked: ${doctrine.sources.length}`);
+    lines.push(`- Highest precedence source: ${doctrine.sources[0]?.path ?? "none"}`);
+  }
+  lines.push("");
+  lines.push("## Immediate Value");
+  lines.push("");
+  lines.push("- Converts scattered brownfield routes, styling signals, docs, rules, schemas, and CI evidence into one Decantr contract without scaffolding runtime code.");
+  lines.push("- Gives assistants a compiled contract layer while keeping original docs/rules available as cited evidence.");
+  lines.push("- Enables `decantr check --brownfield` to catch route drift, unsafe defaults, doctrine conflicts, and missing context.");
+  lines.push("");
+  lines.push("## Non-Goals By Default");
+  lines.push("");
+  lines.push("- Does not install Decantr CSS, switch themes, replace layouts, rewrite docs, mutate assistant rules, or import registry patterns unless explicitly requested.");
+  lines.push("- Does not treat stale migration or completion summaries as current doctrine without verification.");
+  lines.push("");
+  lines.push("## Accepted Evidence");
+  lines.push("");
+  lines.push("- Existing framework, routes, layout shell, feature names, styling signals, and ambient doctrine were used as evidence for the proposal.");
+  lines.push("- Decantr registry content, Decantr CSS, and default Decantr themes were not accepted as brownfield defaults.");
+  lines.push("");
+  lines.push("## Uncertain Evidence");
+  lines.push("");
+  const uncertain = [];
+  if (proposal.evidence.routeCount === 0) uncertain.push("No explicit route declarations were found; proposal uses `/` as a placeholder observation.");
+  if (proposal.evidence.stylingApproach === "unknown") uncertain.push("Styling approach was not confidently detected.");
+  if (proposal.evidence.ambientContextCount === 0) uncertain.push("No ambient docs, rules, CI, schema, or project-memory files were detected.");
+  if (uncertain.length === 0) {
+    lines.push("- No major uncertainty detected by the first-pass scanners.");
+  } else {
+    for (const item of uncertain) lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("## Acceptance");
+  lines.push("");
+  lines.push(`- Create initial essence: \`${proposal.acceptance.create}\``);
+  lines.push(`- Merge into existing essence: \`${proposal.acceptance.merge}\``);
+  lines.push(`- Replace existing essence: \`${proposal.acceptance.replace}\``);
+  lines.push("");
+  lines.push("## Ambient Context Summary");
+  lines.push("");
+  for (const [role, count] of Object.entries(ambient.summary)) {
+    if (count > 0) lines.push(`- ${role}: ${count}`);
+  }
+  lines.push("");
+  if (doctrine) {
+    lines.push("## Doctrine Precedence");
+    lines.push("");
+    for (const source of doctrine.sources.slice(0, 12)) {
+      lines.push(
+        `- ${source.path}: ${source.area}, precedence ${source.precedence}, ${source.currency}`
+      );
+    }
+    if (doctrine.sources.length > 12) {
+      lines.push(`- +${doctrine.sources.length - 12} more source(s) in .decantr/doctrine-map.json`);
+    }
+    lines.push("");
+    lines.push("## Doctrine Resolution Suggestions");
+    lines.push("");
+    if (doctrine.resolutions.length === 0) {
+      lines.push("- No doctrine resolution suggestions were needed.");
+    } else {
+      for (const resolution of doctrine.resolutions.slice(0, 8)) {
+        lines.push(`- ${resolution.issue} ${resolution.recommendation}`);
+        if (resolution.preferredSources.length > 0) {
+          lines.push(`  Preferred evidence: ${resolution.preferredSources.join(", ")}`);
+        }
+      }
+      if (doctrine.resolutions.length > 8) {
+        lines.push(`- +${doctrine.resolutions.length - 8} more resolution suggestion(s) in .decantr/doctrine-map.json`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("## Notable Context Evidence");
+  lines.push("");
+  const notable = ambient.items.slice(0, 30);
+  if (notable.length === 0) {
+    lines.push("- None detected.");
+  } else {
+    for (const item of notable) {
+      const cite = item.safeToCite ? "safe to cite" : "do not cite directly";
+      lines.push(`- ${item.path} (${item.role}, ${item.type}, ${cite}, confidence ${item.confidence.toFixed(2)})`);
+    }
+    if (ambient.items.length > notable.length) {
+      lines.push(`- +${ambient.items.length - notable.length} more item(s) in .decantr/ambient-context.json`);
+    }
+  }
+  lines.push("");
+  lines.push("## Conflicts And Stale Risks");
+  lines.push("");
+  if (proposal.conflicts.length === 0 && proposal.staleRisks.length === 0) {
+    lines.push("- No obvious doctrine conflicts or stale-document risks were detected.");
+  } else {
+    for (const conflict of proposal.conflicts) lines.push(`- Conflict: ${conflict}`);
+    for (const risk of proposal.staleRisks.slice(0, 8)) lines.push(`- Stale risk: ${risk}`);
+  }
+  lines.push("");
+  lines.push("## Assistant Posture");
+  lines.push("");
+  lines.push("LLMs should treat Decantr as the compiled contract layer and the original files as cited evidence. Do not migrate, rewrite, or delete existing docs/rules unless the user explicitly asks for doctrine migration.");
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+function mergeEssenceWithProposal(existing, proposal) {
+  const next = JSON.parse(JSON.stringify(existing));
+  const proposed = proposal.essence;
+  next.version = "3.1.0";
+  next.blueprint.features = [
+    .../* @__PURE__ */ new Set([...next.blueprint.features ?? [], ...proposed.blueprint.features ?? []])
+  ];
+  next.blueprint.routes = {
+    ...proposed.blueprint.routes ?? {},
+    ...next.blueprint.routes ?? {}
+  };
+  const existingSections = new Map((next.blueprint.sections ?? []).map((section) => [section.id, section]));
+  for (const proposedSection of proposed.blueprint.sections ?? []) {
+    const current = existingSections.get(proposedSection.id);
+    if (!current) {
+      existingSections.set(proposedSection.id, proposedSection);
+      continue;
+    }
+    const pageIds = new Set(current.pages.map((page) => page.id));
+    current.pages.push(...proposedSection.pages.filter((page) => !pageIds.has(page.id)));
+    current.features = [.../* @__PURE__ */ new Set([...current.features ?? [], ...proposedSection.features ?? []])];
+  }
+  next.blueprint.sections = [...existingSections.values()];
+  delete next.blueprint.pages;
+  delete next.blueprint.shell;
+  return next;
+}
+
 // src/commands/analyze.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
 
 // src/analyzers/components.ts
-import { existsSync as existsSync4, readdirSync, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
 var PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".ts", ".jsx", ".js"]);
 var ROOT_COMPONENT_CANDIDATES = [
   "src/App.tsx",
@@ -399,7 +954,7 @@ function countFilesRecursive(dir, extensions) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join4(dir, entry);
+    const fullPath = join5(dir, entry);
     try {
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
@@ -425,7 +980,7 @@ function countPageFiles(dir) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join4(dir, entry);
+    const fullPath = join5(dir, entry);
     try {
       const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
@@ -443,27 +998,27 @@ function countPageFiles(dir) {
 function scanComponents(projectRoot) {
   let pageCount = 0;
   const componentDirs = [];
-  const appDirs = [join4(projectRoot, "src", "app"), join4(projectRoot, "app")];
+  const appDirs = [join5(projectRoot, "src", "app"), join5(projectRoot, "app")];
   for (const dir of appDirs) {
-    if (existsSync4(dir)) {
+    if (existsSync5(dir)) {
       pageCount += countPageFiles(dir);
     }
   }
-  const pagesDirs = [join4(projectRoot, "src", "pages"), join4(projectRoot, "pages")];
+  const pagesDirs = [join5(projectRoot, "src", "pages"), join5(projectRoot, "pages")];
   for (const dir of pagesDirs) {
-    if (existsSync4(dir)) {
+    if (existsSync5(dir)) {
       pageCount += countFilesRecursive(dir, PAGE_EXTENSIONS);
     }
   }
   let componentCount = 0;
   const componentPaths = [
-    join4(projectRoot, "src", "components"),
-    join4(projectRoot, "components"),
-    join4(projectRoot, "src", "ui"),
-    join4(projectRoot, "ui")
+    join5(projectRoot, "src", "components"),
+    join5(projectRoot, "components"),
+    join5(projectRoot, "src", "ui"),
+    join5(projectRoot, "ui")
   ];
   for (const dir of componentPaths) {
-    if (existsSync4(dir)) {
+    if (existsSync5(dir)) {
       const count = countFilesRecursive(dir, PAGE_EXTENSIONS);
       if (count > 0) {
         componentCount += count;
@@ -473,7 +1028,7 @@ function scanComponents(projectRoot) {
     }
   }
   const hasRootAppComponent = ROOT_COMPONENT_CANDIDATES.some(
-    (relativePath) => existsSync4(join4(projectRoot, relativePath))
+    (relativePath) => existsSync5(join5(projectRoot, relativePath))
   );
   if (pageCount === 0 && hasRootAppComponent) {
     pageCount = 1;
@@ -492,8 +1047,8 @@ function scanComponents(projectRoot) {
 }
 
 // src/analyzers/dependencies.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 var CATEGORIES = {
   ui: [
     "react",
@@ -615,6 +1170,8 @@ var CATEGORIES = {
     "@emotion/react",
     "@emotion/styled",
     "styled-jsx",
+    "bootstrap",
+    "react-bootstrap",
     "linaria",
     "vanilla-extract",
     "clsx",
@@ -643,11 +1200,11 @@ function scanDependencies(projectRoot) {
     styling: [],
     other: []
   };
-  const pkgPath = join5(projectRoot, "package.json");
-  if (!existsSync5(pkgPath)) return result;
+  const pkgPath = join6(projectRoot, "package.json");
+  if (!existsSync6(pkgPath)) return result;
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
   } catch {
     return result;
   }
@@ -667,8 +1224,8 @@ function scanDependencies(projectRoot) {
 }
 
 // src/analyzers/features.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
 var FEATURE_PATTERNS = {
   auth: [
     "login",
@@ -721,7 +1278,7 @@ function collectPaths(dir, baseDir, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry.startsWith("_") || entry === "node_modules" || entry === "api")
       continue;
-    const fullPath = join6(dir, entry);
+    const fullPath = join7(dir, entry);
     const relPath = fullPath.slice(baseDir.length + 1);
     paths.push(relPath);
     try {
@@ -737,16 +1294,18 @@ function scanFeatures(projectRoot) {
   const detected = [];
   const evidence = {};
   const scanDirs = [
-    join6(projectRoot, "src", "app"),
-    join6(projectRoot, "app"),
-    join6(projectRoot, "src", "pages"),
-    join6(projectRoot, "pages"),
-    join6(projectRoot, "src", "components"),
-    join6(projectRoot, "components")
+    join7(projectRoot, "src", "app"),
+    join7(projectRoot, "app"),
+    join7(projectRoot, "src", "routes"),
+    join7(projectRoot, "src", "pages"),
+    join7(projectRoot, "pages"),
+    join7(projectRoot, "src", "views"),
+    join7(projectRoot, "src", "components"),
+    join7(projectRoot, "components")
   ];
   const allPaths = [];
   for (const dir of scanDirs) {
-    if (existsSync6(dir)) {
+    if (existsSync7(dir)) {
       allPaths.push(...collectPaths(dir, projectRoot));
     }
   }
@@ -770,8 +1329,8 @@ function scanFeatures(projectRoot) {
 }
 
 // src/analyzers/layout.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } 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"];
 var FOOTER_PATTERNS = ["footer", "bottom-bar", "bottombar"];
@@ -782,12 +1341,12 @@ function containsPattern(text, patterns) {
 function checkComponentDirs(projectRoot) {
   const result = { sidebar: false, nav: false, footer: false };
   const componentDirs = [
-    join7(projectRoot, "src", "components"),
-    join7(projectRoot, "components"),
-    join7(projectRoot, "src", "ui")
+    join8(projectRoot, "src", "components"),
+    join8(projectRoot, "components"),
+    join8(projectRoot, "src", "ui")
   ];
   for (const dir of componentDirs) {
-    if (!existsSync7(dir)) continue;
+    if (!existsSync8(dir)) continue;
     let entries;
     try {
       entries = readdirSync3(dir);
@@ -806,16 +1365,16 @@ function checkComponentDirs(projectRoot) {
 function checkLayoutFiles(projectRoot) {
   const result = { sidebar: false, nav: false, footer: false };
   const layoutPaths = [
-    join7(projectRoot, "src", "app", "layout.tsx"),
-    join7(projectRoot, "src", "app", "layout.jsx"),
-    join7(projectRoot, "app", "layout.tsx"),
-    join7(projectRoot, "app", "layout.jsx")
+    join8(projectRoot, "src", "app", "layout.tsx"),
+    join8(projectRoot, "src", "app", "layout.jsx"),
+    join8(projectRoot, "app", "layout.tsx"),
+    join8(projectRoot, "app", "layout.jsx")
   ];
   for (const layoutPath of layoutPaths) {
-    if (!existsSync7(layoutPath)) continue;
+    if (!existsSync8(layoutPath)) continue;
     let content;
     try {
-      content = readFileSync5(layoutPath, "utf-8");
+      content = readFileSync6(layoutPath, "utf-8");
     } catch {
       continue;
     }
@@ -826,16 +1385,16 @@ function checkLayoutFiles(projectRoot) {
   const subLayoutDirs = ["dashboard", "admin", "app"];
   for (const sub of subLayoutDirs) {
     const paths = [
-      join7(projectRoot, "src", "app", sub, "layout.tsx"),
-      join7(projectRoot, "src", "app", sub, "layout.jsx"),
-      join7(projectRoot, "app", sub, "layout.tsx"),
-      join7(projectRoot, "app", sub, "layout.jsx")
+      join8(projectRoot, "src", "app", sub, "layout.tsx"),
+      join8(projectRoot, "src", "app", sub, "layout.jsx"),
+      join8(projectRoot, "app", sub, "layout.tsx"),
+      join8(projectRoot, "app", sub, "layout.jsx")
     ];
     for (const layoutPath of paths) {
-      if (!existsSync7(layoutPath)) continue;
+      if (!existsSync8(layoutPath)) continue;
       let content;
       try {
-        content = readFileSync5(layoutPath, "utf-8");
+        content = readFileSync6(layoutPath, "utf-8");
       } catch {
         continue;
       }
@@ -857,10 +1416,10 @@ function inferShellPattern(hasSidebar, hasTopNav, hasFooter) {
   return "main-only";
 }
 function inferShellPatternFromDecantrContract(projectRoot) {
-  const essencePath = join7(projectRoot, "decantr.essence.json");
-  if (!existsSync7(essencePath)) return null;
+  const essencePath = join8(projectRoot, "decantr.essence.json");
+  if (!existsSync8(essencePath)) return null;
   try {
-    const essence = JSON.parse(readFileSync5(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync6(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)`;
@@ -895,375 +1454,19 @@ function scanLayout(projectRoot) {
   };
 }
 
-// src/analyzers/routes.ts
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import { join as join8, relative } from "path";
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "api", "_app", "_document"]);
-function shouldSkipDir(name) {
-  return name.startsWith("_") || name.startsWith(".") || SKIP_DIRS.has(name);
-}
-function segmentToRoute(segment) {
-  if (segment.startsWith("(") && segment.endsWith(")")) {
-    return null;
-  }
-  if (segment.startsWith("[") && segment.endsWith("]")) {
-    const param = segment.slice(1, -1);
-    if (param.startsWith("...")) {
-      return `:${param.slice(3)}*`;
-    }
-    if (param.startsWith("[...") && param.endsWith("]")) {
-      return `:${param.slice(4, -1)}*`;
-    }
-    return `:${param}`;
-  }
-  return segment;
-}
-function walkAppDir(dir, baseDir, segments) {
-  const routes = [];
-  let entries;
-  try {
-    entries = readdirSync4(dir);
-  } catch {
-    return routes;
-  }
-  const hasPage = entries.some(
-    (e) => e === "page.tsx" || e === "page.ts" || e === "page.jsx" || e === "page.js"
-  );
-  const hasLayout = entries.some(
-    (e) => e === "layout.tsx" || e === "layout.ts" || e === "layout.jsx" || e === "layout.js"
-  );
-  if (hasPage) {
-    const routePath = "/" + segments.filter((s) => s !== "").join("/");
-    const pageFile = entries.find((e) => e.startsWith("page."));
-    routes.push({
-      path: routePath || "/",
-      file: relative(baseDir, join8(dir, pageFile)),
-      hasLayout
-    });
-  }
-  for (const entry of entries) {
-    if (shouldSkipDir(entry)) continue;
-    const fullPath = join8(dir, entry);
-    try {
-      if (!statSync4(fullPath).isDirectory()) continue;
-    } catch {
-      continue;
-    }
-    const routeSegment = segmentToRoute(entry);
-    const nextSegments = routeSegment === null ? [...segments] : [...segments, routeSegment];
-    routes.push(...walkAppDir(fullPath, baseDir, nextSegments));
-  }
-  return routes;
-}
-function walkPagesDir(dir, baseDir, segments) {
-  const routes = [];
-  let entries;
-  try {
-    entries = readdirSync4(dir);
-  } catch {
-    return routes;
-  }
-  for (const entry of entries) {
-    if (shouldSkipDir(entry)) continue;
-    const fullPath = join8(dir, entry);
-    try {
-      const stat = statSync4(fullPath);
-      if (stat.isDirectory()) {
-        const routeSegment = segmentToRoute(entry);
-        const nextSegments = routeSegment === null ? [...segments] : [...segments, routeSegment];
-        routes.push(...walkPagesDir(fullPath, baseDir, nextSegments));
-      } else if (stat.isFile()) {
-        const match = entry.match(/^(.+)\.(tsx?|jsx?|mdx?)$/);
-        if (!match) continue;
-        const name = match[1];
-        if (name.startsWith("_")) continue;
-        const routeSegment = name === "index" ? "" : segmentToRoute(name) ?? name;
-        const routePath = "/" + [...segments, routeSegment].filter((s) => s !== "").join("/");
-        routes.push({
-          path: routePath || "/",
-          file: relative(baseDir, fullPath),
-          hasLayout: false
-        });
-      }
-    } catch {
-    }
-  }
-  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 = readdirSync4(dir);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join8(dir, entry);
-    try {
-      const stat = statSync4(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 {
-    }
-  }
-}
-function scanReactRouter(projectRoot) {
-  const candidateDirs = [join8(projectRoot, "src"), projectRoot];
-  const candidateFiles = [];
-  for (const dir of candidateDirs) {
-    if (existsSync8(dir)) collectRouteCandidateFiles(dir, candidateFiles);
-  }
-  const routeMap = /* @__PURE__ */ new Map();
-  for (const absolutePath of candidateFiles) {
-    let content;
-    try {
-      content = readFileSync6(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 = [join8(projectRoot, "src", "app"), join8(projectRoot, "app")];
-  for (const appDir of appDirs) {
-    if (existsSync8(appDir)) {
-      const routes = walkAppDir(appDir, projectRoot, []);
-      if (routes.length > 0) {
-        return { strategy: "app-router", routes };
-      }
-    }
-  }
-  const pagesDirs = [join8(projectRoot, "src", "pages"), join8(projectRoot, "pages")];
-  for (const pagesDir of pagesDirs) {
-    if (existsSync8(pagesDir)) {
-      const routes = walkPagesDir(pagesDir, projectRoot, []);
-      if (routes.length > 0) {
-        return { strategy: "pages-router", routes };
-      }
-    }
-  }
-  const reactRouterRoutes = scanReactRouter(projectRoot);
-  if (reactRouterRoutes.length > 0) {
-    return { strategy: "react-router", routes: reactRouterRoutes };
-  }
-  return { strategy: "none", routes: [] };
-}
-
-// src/analyzers/styling.ts
+// src/detect.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { join as join9 } from "path";
-var TAILWIND_CONFIGS = [
-  "tailwind.config.js",
-  "tailwind.config.ts",
-  "tailwind.config.mjs",
-  "tailwind.config.cjs"
-];
-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 = [];
-  const varRegex = /--([\w-]+)\s*:\s*([^;]+)/g;
-  let match;
-  while ((match = varRegex.exec(content)) !== null) {
-    const name = match[1];
-    const value = match[2].trim();
-    variables.push(`--${name}`);
-    const colorPatterns = [
-      "primary",
-      "secondary",
-      "accent",
-      "bg",
-      "fg",
-      "border",
-      "success",
-      "warning",
-      "error",
-      "surface",
-      "muted"
-    ];
-    if (value.startsWith("#") || value.startsWith("rgb") || value.startsWith("hsl") || colorPatterns.some((p) => name.includes(p))) {
-      colors[name] = value;
-    }
-  }
-  return { colors, variables };
-}
-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;
-    }
-  }
-  const layoutPaths = [
-    "src/app/layout.tsx",
-    "app/layout.tsx",
-    "src/app/layout.jsx",
-    "app/layout.jsx"
-  ];
-  for (const rel of layoutPaths) {
-    const fullPath = join9(projectRoot, rel);
-    if (existsSync9(fullPath)) {
-      try {
-        const layoutContent = readFileSync7(fullPath, "utf-8");
-        if (layoutContent.includes('className="dark"') || layoutContent.includes("className='dark'") || layoutContent.includes('class="dark"')) {
-          return true;
-        }
-      } catch {
-      }
-    }
-  }
-  const pkgPath = join9(projectRoot, "package.json");
-  if (existsSync9(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
-      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (allDeps["next-themes"] || allDeps["theme-toggle"] || allDeps["use-dark-mode"]) {
-        return true;
-      }
-    } catch {
-    }
-  }
-  const essencePath = join9(projectRoot, "decantr.essence.json");
-  if (existsSync9(essencePath)) {
-    try {
-      const essence = JSON.parse(readFileSync7(essencePath, "utf-8"));
-      const mode = essence.dna?.theme?.mode;
-      if (mode === "dark" || mode === "auto") {
-        return true;
-      }
-    } catch {
-    }
-  }
-  return false;
-}
-function scanStyling(projectRoot) {
-  let approach = "unknown";
-  let configFile;
-  for (const cfg of TAILWIND_CONFIGS) {
-    if (existsSync9(join9(projectRoot, cfg))) {
-      approach = "tailwind";
-      configFile = cfg;
-      break;
-    }
-  }
-  if (approach === "unknown") {
-    const pkgPath = join9(projectRoot, "package.json");
-    if (existsSync9(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync7(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";
-        }
-      } catch {
-      }
-    }
-  }
-  const decantrStyleFiles = DECANTR_STYLE_PATHS.filter((rel) => existsSync9(join9(projectRoot, rel)));
-  if (decantrStyleFiles.length >= 2) {
-    approach = "decantr-css";
-    configFile = decantrStyleFiles.join(" + ");
-  }
-  const cssContents = [];
-  for (const rel of GLOBALS_CSS_PATHS) {
-    const fullPath = join9(projectRoot, rel);
-    if (existsSync9(fullPath)) {
-      try {
-        cssContents.push(readFileSync7(fullPath, "utf-8"));
-      } catch {
-      }
-    }
-  }
-  for (const rel of DECANTR_STYLE_PATHS) {
-    if (GLOBALS_CSS_PATHS.includes(rel)) continue;
-    const fullPath = join9(projectRoot, rel);
-    if (existsSync9(fullPath)) {
-      try {
-        cssContents.push(readFileSync7(fullPath, "utf-8"));
-      } catch {
-      }
-    }
-  }
-  let colors = {};
-  let cssVariables = [];
-  for (const cssContent of cssContents) {
-    const extracted = extractCSSVariables(cssContent);
-    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) => existsSync9(join9(projectRoot, rel)));
-  }
-  return {
-    approach,
-    configFile,
-    colors,
-    darkMode,
-    cssVariables
-  };
-}
-
-// src/detect.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
 var RULE_FILES = [
   "CLAUDE.md",
+  ".claude/rules",
   ".cursorrules",
   ".cursor/rules",
   "AGENTS.md",
   "GEMINI.md",
-  "copilot-instructions.md"
+  "copilot-instructions.md",
+  ".github/copilot-instructions.md",
+  ".windsurfrules"
 ];
 function detectProject(projectRoot = process.cwd()) {
   const result = {
@@ -1275,52 +1478,52 @@ function detectProject(projectRoot = process.cwd()) {
     existingEssence: false,
     projectRoot
   };
-  result.existingEssence = existsSync10(join10(projectRoot, "decantr.essence.json"));
+  result.existingEssence = existsSync9(join9(projectRoot, "decantr.essence.json"));
   for (const ruleFile of RULE_FILES) {
-    if (existsSync10(join10(projectRoot, ruleFile))) {
+    if (existsSync9(join9(projectRoot, ruleFile))) {
       result.existingRuleFiles.push(ruleFile);
     }
   }
-  if (existsSync10(join10(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync9(join9(projectRoot, "pnpm-lock.yaml"))) {
     result.packageManager = "pnpm";
-  } else if (existsSync10(join10(projectRoot, "yarn.lock"))) {
+  } else if (existsSync9(join9(projectRoot, "yarn.lock"))) {
     result.packageManager = "yarn";
-  } else if (existsSync10(join10(projectRoot, "bun.lockb"))) {
+  } else if (existsSync9(join9(projectRoot, "bun.lockb"))) {
     result.packageManager = "bun";
-  } else if (existsSync10(join10(projectRoot, "package-lock.json"))) {
+  } else if (existsSync9(join9(projectRoot, "package-lock.json"))) {
     result.packageManager = "npm";
   }
-  result.hasTypeScript = existsSync10(join10(projectRoot, "tsconfig.json"));
-  result.hasTailwind = existsSync10(join10(projectRoot, "tailwind.config.js")) || existsSync10(join10(projectRoot, "tailwind.config.ts")) || existsSync10(join10(projectRoot, "tailwind.config.mjs")) || existsSync10(join10(projectRoot, "tailwind.config.cjs"));
-  if (existsSync10(join10(projectRoot, "next.config.js")) || existsSync10(join10(projectRoot, "next.config.ts")) || existsSync10(join10(projectRoot, "next.config.mjs"))) {
+  result.hasTypeScript = existsSync9(join9(projectRoot, "tsconfig.json"));
+  result.hasTailwind = existsSync9(join9(projectRoot, "tailwind.config.js")) || existsSync9(join9(projectRoot, "tailwind.config.ts")) || existsSync9(join9(projectRoot, "tailwind.config.mjs")) || existsSync9(join9(projectRoot, "tailwind.config.cjs"));
+  if (existsSync9(join9(projectRoot, "next.config.js")) || existsSync9(join9(projectRoot, "next.config.ts")) || existsSync9(join9(projectRoot, "next.config.mjs"))) {
     result.framework = "nextjs";
     result.version = getPackageVersion(projectRoot, "next");
     return result;
   }
-  if (existsSync10(join10(projectRoot, "nuxt.config.js")) || existsSync10(join10(projectRoot, "nuxt.config.ts"))) {
+  if (existsSync9(join9(projectRoot, "nuxt.config.js")) || existsSync9(join9(projectRoot, "nuxt.config.ts"))) {
     result.framework = "nuxt";
     result.version = getPackageVersion(projectRoot, "nuxt");
     return result;
   }
-  if (existsSync10(join10(projectRoot, "astro.config.mjs")) || existsSync10(join10(projectRoot, "astro.config.ts"))) {
+  if (existsSync9(join9(projectRoot, "astro.config.mjs")) || existsSync9(join9(projectRoot, "astro.config.ts"))) {
     result.framework = "astro";
     result.version = getPackageVersion(projectRoot, "astro");
     return result;
   }
-  if (existsSync10(join10(projectRoot, "svelte.config.js")) || existsSync10(join10(projectRoot, "svelte.config.ts"))) {
+  if (existsSync9(join9(projectRoot, "svelte.config.js")) || existsSync9(join9(projectRoot, "svelte.config.ts"))) {
     result.framework = "svelte";
     result.version = getPackageVersion(projectRoot, "svelte");
     return result;
   }
-  if (existsSync10(join10(projectRoot, "angular.json"))) {
+  if (existsSync9(join9(projectRoot, "angular.json"))) {
     result.framework = "angular";
     result.version = getPackageVersion(projectRoot, "@angular/core");
     return result;
   }
-  const packageJsonPath = join10(projectRoot, "package.json");
-  if (existsSync10(packageJsonPath)) {
+  const packageJsonPath = join9(projectRoot, "package.json");
+  if (existsSync9(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
       const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
       if (deps.next) {
         result.framework = "nextjs";
@@ -1347,18 +1550,18 @@ function detectProject(projectRoot = process.cwd()) {
     } catch {
     }
   }
-  if (result.framework === "unknown" && !existsSync10(packageJsonPath)) {
-    if (existsSync10(join10(projectRoot, "index.html"))) {
+  if (result.framework === "unknown" && !existsSync9(packageJsonPath)) {
+    if (existsSync9(join9(projectRoot, "index.html"))) {
       result.framework = "html";
     }
   }
   return result;
 }
 function getPackageVersion(projectRoot, packageName) {
-  const packageJsonPath = join10(projectRoot, "package.json");
-  if (!existsSync10(packageJsonPath)) return void 0;
+  const packageJsonPath = join9(projectRoot, "package.json");
+  if (!existsSync9(packageJsonPath)) return void 0;
   try {
-    const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
     const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
     const version = deps[packageName];
     return version?.replace(/^\^|~/, "");
@@ -1391,8 +1594,8 @@ function formatDetection(detected) {
 }
 
 // src/workflow-model.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
 function inferSuggestedShell(layout) {
   if (layout.hasSidebar) return "sidebar-main";
   if (layout.hasTopNav) return "top-nav-main";
@@ -1468,7 +1671,7 @@ function createBrownfieldInitSeed(detected, layout, styling) {
     shell: inferSuggestedShell(layout),
     guard: "guided",
     density: "comfortable",
-    theme: "luminarum",
+    theme: "existing",
     mode: styling.darkMode ? "dark" : "auto",
     existing: true,
     notes: [
@@ -1479,12 +1682,12 @@ function createBrownfieldInitSeed(detected, layout, styling) {
   };
 }
 function readBrownfieldInitSeed(projectRoot) {
-  const seedPath = join11(projectRoot, ".decantr", "init-seed.json");
-  if (!existsSync11(seedPath)) {
+  const seedPath = join10(projectRoot, ".decantr", "init-seed.json");
+  if (!existsSync10(seedPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(readFileSync9(seedPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(seedPath, "utf-8"));
     if (parsed.workflow !== "brownfield-adoption") {
       return null;
     }
@@ -1519,8 +1722,21 @@ ${BOLD}Analyzing project...${RESET2}
   const features = scanFeatures(projectRoot);
   console.log(`${DIM2}Scanning dependencies...${RESET2}`);
   const dependencies = scanDependencies(projectRoot);
+  console.log(`${DIM2}Scanning ambient project context...${RESET2}`);
+  const ambient = scanAmbientContext(projectRoot);
+  const doctrine = createDoctrineMap(ambient);
   const initSeed = createBrownfieldInitSeed(project, layout, styling);
   initSeed.projectScope = workspace?.projectScope ?? "single-app";
+  const proposal = createBrownfieldProposal({
+    project,
+    routes,
+    components,
+    styling,
+    layout,
+    features,
+    dependencies,
+    ambient
+  });
   const analysis = {
     version: 1,
     analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1549,7 +1765,8 @@ ${BOLD}Analyzing project...${RESET2}
         contractOnly: true,
         adoptionMode: "contract-only",
         initSeedPath: ".decantr/init-seed.json",
-        recommendedCommand: "decantr init --existing --yes --adoption=contract-only"
+        proposalPath: ".decantr/observed-essence.proposal.json",
+        recommendedCommand: "decantr init --existing --accept-proposal"
       },
       hybrid: {
         ownerCommands: [
@@ -1568,6 +1785,9 @@ ${BOLD}Analyzing project...${RESET2}
       routeAnchors: routes.routes.map((route) => route.path),
       stylingAnchors: [styling.configFile].filter(Boolean),
       ruleFiles: project.existingRuleFiles,
+      ambientContextPath: ".decantr/ambient-context.json",
+      doctrineMapPath: ".decantr/doctrine-map.json",
+      proposalPath: ".decantr/observed-essence.proposal.json",
       preserve: [
         "framework",
         "package manager",
@@ -1577,14 +1797,21 @@ ${BOLD}Analyzing project...${RESET2}
       ]
     }
   };
-  const decantrDir = join12(projectRoot, ".decantr");
-  if (!existsSync12(decantrDir)) {
-    mkdirSync3(decantrDir, { recursive: true });
-  }
-  const outputPath = join12(decantrDir, "analysis.json");
-  const initSeedPath = join12(decantrDir, "init-seed.json");
-  writeFileSync4(outputPath, JSON.stringify(analysis, null, 2) + "\n", "utf-8");
-  writeFileSync4(initSeedPath, JSON.stringify(initSeed, null, 2) + "\n", "utf-8");
+  const decantrDir = join11(projectRoot, ".decantr");
+  if (!existsSync11(decantrDir)) {
+    mkdirSync4(decantrDir, { recursive: true });
+  }
+  const outputPath = join11(decantrDir, "analysis.json");
+  const initSeedPath = join11(decantrDir, "init-seed.json");
+  const ambientPath = join11(decantrDir, "ambient-context.json");
+  const doctrinePath = join11(decantrDir, "doctrine-map.json");
+  const reportPath = join11(decantrDir, "brownfield-report.md");
+  writeFileSync5(outputPath, JSON.stringify(analysis, null, 2) + "\n", "utf-8");
+  writeFileSync5(initSeedPath, JSON.stringify(initSeed, null, 2) + "\n", "utf-8");
+  writeFileSync5(ambientPath, JSON.stringify(ambient, null, 2) + "\n", "utf-8");
+  writeDoctrineMap(projectRoot, doctrine);
+  writeBrownfieldProposal(projectRoot, proposal);
+  writeFileSync5(reportPath, generateBrownfieldReport(proposal, ambient, doctrine), "utf-8");
   console.log(`
 ${GREEN2}Analysis complete.${RESET2}
 `);
@@ -1605,6 +1832,8 @@ ${GREEN2}Analysis complete.${RESET2}
   console.log(
     `  Features:     ${features.detected.length > 0 ? features.detected.join(", ") : "none detected"}`
   );
+  console.log(`  Context:      ${ambient.items.length} ambient item(s)`);
+  console.log(`  Doctrine:     ${doctrine.sources.length} ranked source(s)`);
   const depCounts = [
     dependencies.ui.length && `${dependencies.ui.length} ui`,
     dependencies.auth.length && `${dependencies.auth.length} auth`,
@@ -1616,16 +1845,20 @@ ${GREEN2}Analysis complete.${RESET2}
   console.log(`
 ${DIM2}Written to:${RESET2} ${outputPath}`);
   console.log(`${DIM2}Init seed:${RESET2} ${initSeedPath}`);
+  console.log(`${DIM2}Ambient context:${RESET2} ${ambientPath}`);
+  console.log(`${DIM2}Doctrine map:${RESET2} ${doctrinePath}`);
+  console.log(`${DIM2}Observed proposal:${RESET2} ${join11(decantrDir, "observed-essence.proposal.json")}`);
+  console.log(`${DIM2}Brownfield report:${RESET2} ${reportPath}`);
   console.log(
     `
-${YELLOW}Next step:${RESET2} Run ${BOLD}decantr init --existing --yes --adoption=contract-only${RESET2} to attach Decantr using the generated brownfield seed.
+${YELLOW}Next step:${RESET2} Review ${BOLD}.decantr/brownfield-report.md${RESET2}, then run ${BOLD}decantr init --existing --accept-proposal${RESET2} to attach Decantr using the observed proposal.
 `
   );
 }
 
 // src/commands/create.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join12 } from "path";
 import {
   CONTENT_TYPE_TO_API_CONTENT_TYPE,
   CONTENT_TYPES
@@ -1821,23 +2054,23 @@ function cmdCreate(type, name, projectRoot = process.cwd()) {
   }
   const contentType = type;
   const plural = PLURAL[contentType];
-  const customDir = join13(projectRoot, ".decantr", "custom", plural);
-  const filePath = join13(customDir, `${name}.json`);
-  if (existsSync13(filePath)) {
+  const customDir = join12(projectRoot, ".decantr", "custom", plural);
+  const filePath = join12(customDir, `${name}.json`);
+  if (existsSync12(filePath)) {
     console.error(`${type} "${name}" already exists at ${filePath}`);
     process.exitCode = 1;
     return;
   }
-  mkdirSync4(customDir, { recursive: true });
+  mkdirSync5(customDir, { recursive: true });
   const skeleton = getSkeleton(contentType, name, humanizeId(name));
-  writeFileSync5(filePath, JSON.stringify(skeleton, null, 2));
+  writeFileSync6(filePath, JSON.stringify(skeleton, null, 2));
   console.log(`Created ${type} "${name}" at ${filePath}`);
   console.log(`Edit it, then publish with: decantr publish ${type} ${name}`);
 }
 
 // src/commands/export.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname2, join as join14 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname2, join as join13 } from "path";
 var GREEN3 = "\x1B[32m";
 var RED2 = "\x1B[31m";
 var DIM3 = "\x1B[2m";
@@ -1987,21 +2220,21 @@ function generateCSSVars(tokens) {
   return lines.join("\n");
 }
 async function cmdExport(target, projectRoot, options = {}) {
-  const essencePath = join14(projectRoot, "decantr.essence.json");
-  const tokensPath = join14(projectRoot, "src", "styles", "tokens.css");
-  if (!existsSync14(essencePath)) {
+  const essencePath = join13(projectRoot, "decantr.essence.json");
+  const tokensPath = join13(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync13(essencePath)) {
     console.error(`${RED2}No decantr.essence.json found. Run \`decantr init\` first.${RESET3}`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync14(tokensPath)) {
+  if (!existsSync13(tokensPath)) {
     console.error(
       `${RED2}No src/styles/tokens.css found. Run \`decantr refresh\` to generate tokens.${RESET3}`
     );
     process.exitCode = 1;
     return;
   }
-  const tokensCSS = readFileSync10(tokensPath, "utf-8");
+  const tokensCSS = readFileSync9(tokensPath, "utf-8");
   const tokens = parseTokensCSS(tokensCSS);
   if (tokens.size === 0) {
     console.error(`${RED2}No --d-* tokens found in tokens.css.${RESET3}`);
@@ -2010,28 +2243,28 @@ async function cmdExport(target, projectRoot, options = {}) {
   }
   switch (target) {
     case "shadcn": {
-      const cssOut = options.output ?? join14(projectRoot, "src", "styles", "shadcn-theme.css");
-      const jsonOut = join14(projectRoot, "components.json");
+      const cssOut = options.output ?? join13(projectRoot, "src", "styles", "shadcn-theme.css");
+      const jsonOut = join13(projectRoot, "components.json");
       ensureDir(cssOut);
-      writeFileSync6(cssOut, generateShadcnCSS(tokens), "utf-8");
-      writeFileSync6(jsonOut, generateShadcnComponentsJSON(), "utf-8");
+      writeFileSync7(cssOut, generateShadcnCSS(tokens), "utf-8");
+      writeFileSync7(jsonOut, generateShadcnComponentsJSON(), "utf-8");
       console.log(`${GREEN3}Exported shadcn theme:${RESET3}`);
       console.log(`  ${DIM3}CSS:${RESET3}  ${cssOut}`);
       console.log(`  ${DIM3}JSON:${RESET3} ${jsonOut}`);
       break;
     }
     case "tailwind": {
-      const out = options.output ?? join14(projectRoot, "tailwind.decantr.config.ts");
+      const out = options.output ?? join13(projectRoot, "tailwind.decantr.config.ts");
       ensureDir(out);
-      writeFileSync6(out, generateTailwindConfig(tokens), "utf-8");
+      writeFileSync7(out, generateTailwindConfig(tokens), "utf-8");
       console.log(`${GREEN3}Exported Tailwind config:${RESET3}`);
       console.log(`  ${DIM3}File:${RESET3} ${out}`);
       break;
     }
     case "css-vars": {
-      const out = options.output ?? join14(projectRoot, "decantr-tokens.css");
+      const out = options.output ?? join13(projectRoot, "decantr-tokens.css");
       ensureDir(out);
-      writeFileSync6(out, generateCSSVars(tokens), "utf-8");
+      writeFileSync7(out, generateCSSVars(tokens), "utf-8");
       console.log(`${GREEN3}Exported CSS variables:${RESET3}`);
       console.log(`  ${DIM3}File:${RESET3} ${out}`);
       break;
@@ -2040,15 +2273,15 @@ async function cmdExport(target, projectRoot, options = {}) {
 }
 function ensureDir(filePath) {
   const dir = dirname2(filePath);
-  if (!existsSync14(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  if (!existsSync13(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
 }
 
 // src/commands/magic.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import * as fs from "fs/promises";
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 var BOLD2 = "\x1B[1m";
 var DIM4 = "\x1B[2m";
 var RESET4 = "\x1B[0m";
@@ -2276,8 +2509,8 @@ async function cmdMagic(prompt, projectRoot, options) {
     console.log(`   Archetype:    ${intent.archetype}`);
   }
   console.log("");
-  const essencePath = join15(projectRoot, "decantr.essence.json");
-  if (existsSync15(essencePath)) {
+  const essencePath = join14(projectRoot, "decantr.essence.json");
+  if (existsSync14(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;
@@ -2295,12 +2528,14 @@ async function cmdMagic(prompt, projectRoot, options) {
       dim(" Running brownfield analysis instead so you can attach Decantr deliberately.\n")
     );
     cmdAnalyze(projectRoot);
-    console.log(`${BOLD2}Recommended next step:${RESET4} ${cyan("decantr init --existing --yes")}`);
+    console.log(
+      `${BOLD2}Recommended next step:${RESET4} ${cyan("decantr init --existing --accept-proposal")}`
+    );
     console.log("");
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join15(projectRoot, ".decantr", "cache"),
+    cacheDir: join14(projectRoot, ".decantr", "cache"),
     apiUrl: options.registry,
     offline: options.offline
   });
@@ -2571,14 +2806,14 @@ async function cmdMagic(prompt, projectRoot, options) {
   if (result.gitignoreUpdated) {
     console.log(`   ${dim(".gitignore updated")}`);
   }
-  const contextDir = join15(projectRoot, ".decantr", "context");
+  const contextDir = join14(projectRoot, ".decantr", "context");
   let sectionCount = 0;
   try {
     const files = await fs.readdir(contextDir);
     sectionCount = files.filter((f) => f.startsWith("section-")).length;
   } catch {
   }
-  const treatmentsPath = join15(projectRoot, "src", "styles", "treatments.css");
+  const treatmentsPath = join14(projectRoot, "src", "styles", "treatments.css");
   let hasLayers = false;
   try {
     const css = await fs.readFile(treatmentsPath, "utf-8");
@@ -2611,21 +2846,21 @@ ${GREEN4}${BOLD2}Quality summary:${RESET4}`);
 }
 
 // src/commands/migrate.ts
-import { copyFileSync, existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
-import { join as join16 } from "path";
-import { isV3 as isV32, migrateV2ToV3, validateEssence } from "@decantr/essence-spec";
+import { copyFileSync, existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { join as join15 } from "path";
+import { isV3 as isV33, migrateV2ToV3, validateEssence } from "@decantr/essence-spec";
 var GREEN5 = "\x1B[32m";
 var RED4 = "\x1B[31m";
 var YELLOW3 = "\x1B[33m";
 var RESET5 = "\x1B[0m";
 var DIM5 = "\x1B[2m";
 function migrateEssenceFile(essencePath) {
-  if (!existsSync16(essencePath)) {
+  if (!existsSync15(essencePath)) {
     return { success: false, error: `File not found: ${essencePath}` };
   }
   let raw;
   try {
-    raw = readFileSync11(essencePath, "utf-8");
+    raw = readFileSync10(essencePath, "utf-8");
   } catch (e) {
     return { success: false, error: `Could not read ${essencePath}: ${e.message}` };
   }
@@ -2635,7 +2870,7 @@ function migrateEssenceFile(essencePath) {
   } catch (e) {
     return { success: false, error: `Invalid JSON: ${e.message}` };
   }
-  if (isV32(essence)) {
+  if (isV33(essence)) {
     return { success: true, alreadyV3: true };
   }
   const preValidation = validateEssence(essence);
@@ -2666,7 +2901,7 @@ function migrateEssenceFile(essencePath) {
     };
   }
   try {
-    writeFileSync7(essencePath, JSON.stringify(v3, null, 2) + "\n");
+    writeFileSync8(essencePath, JSON.stringify(v3, null, 2) + "\n");
   } catch (e) {
     return {
       success: false,
@@ -2677,8 +2912,8 @@ function migrateEssenceFile(essencePath) {
   return { success: true, backupPath };
 }
 async function cmdMigrate(projectRoot = process.cwd()) {
-  const essencePath = join16(projectRoot, "decantr.essence.json");
-  if (!existsSync16(essencePath)) {
+  const essencePath = join15(projectRoot, "decantr.essence.json");
+  if (!existsSync15(essencePath)) {
     console.error(`${RED4}No decantr.essence.json found. Run \`decantr init\` first.${RESET5}`);
     process.exitCode = 1;
     return;
@@ -2704,13 +2939,13 @@ async function cmdMigrate(projectRoot = process.cwd()) {
 
 // src/commands/new-project.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync8 } from "fs";
-import { join as join19, resolve as resolve2 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9 } from "fs";
+import { join as join18, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/bootstrap.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
-import { basename, join as join17 } from "path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { basename, join as join16 } from "path";
 import { resolvePackAdapter } from "@decantr/core";
 var reactViteBootstrapAdapter = {
   id: "react-vite",
@@ -2734,7 +2969,7 @@ var reactViteBootstrapAdapter = {
     distDir: "dist"
   },
   writeProjectFiles(projectDir, title, routingMode) {
-    const srcDir = join17(projectDir, "src");
+    const srcDir = join16(projectDir, "src");
     const routerImport = routingMode === "hash" ? "HashRouter" : "BrowserRouter";
     const packageJson = {
       name: basename(projectDir) || "decantr-app",
@@ -2766,7 +3001,7 @@ var reactViteBootstrapAdapter = {
         vite: "^6.0.0"
       }
     };
-    writeFileSync8(join17(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+    writeFileSync9(join16(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
     const viteConfig = `import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 
@@ -2774,7 +3009,7 @@ export default defineConfig({
   plugins: [react()],
 });
 `;
-    writeFileSync8(join17(projectDir, "vite.config.ts"), viteConfig);
+    writeFileSync9(join16(projectDir, "vite.config.ts"), viteConfig);
     const tsconfig = {
       compilerOptions: {
         target: "ES2020",
@@ -2796,7 +3031,7 @@ export default defineConfig({
       },
       include: ["src"]
     };
-    writeFileSync8(join17(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+    writeFileSync9(join16(projectDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
     const tsconfigApp = {
       compilerOptions: {
         tsBuildInfoFile: "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
@@ -2819,8 +3054,8 @@ export default defineConfig({
       },
       include: ["src"]
     };
-    writeFileSync8(
-      join17(projectDir, "tsconfig.app.json"),
+    writeFileSync9(
+      join16(projectDir, "tsconfig.app.json"),
       JSON.stringify(tsconfigApp, null, 2) + "\n"
     );
     const indexHtml = `<!doctype html>
@@ -2836,8 +3071,8 @@ export default defineConfig({
   </body>
 </html>
 `;
-    writeFileSync8(join17(projectDir, "index.html"), indexHtml);
-    mkdirSync6(srcDir, { recursive: true });
+    writeFileSync9(join16(projectDir, "index.html"), indexHtml);
+    mkdirSync7(srcDir, { recursive: true });
     const mainTsx = `import { StrictMode } from 'react';
 import { createRoot } from 'react-dom/client';
 import { ${routerImport} } from 'react-router-dom';
@@ -2854,7 +3089,7 @@ createRoot(document.getElementById('root')!).render(
   </StrictMode>,
 );
 `;
-    writeFileSync8(join17(srcDir, "main.tsx"), mainTsx);
+    writeFileSync9(join16(srcDir, "main.tsx"), mainTsx);
     const appTsx = `import { css } from '@decantr/css';
 import { Routes, Route } from 'react-router-dom';
 
@@ -2889,9 +3124,9 @@ export function App() {
   );
 }
 `;
-    writeFileSync8(join17(srcDir, "App.tsx"), appTsx);
-    writeFileSync8(join17(srcDir, "vite-env.d.ts"), '/// <reference types="vite/client" />\n');
-    mkdirSync6(join17(srcDir, "styles"), { recursive: true });
+    writeFileSync9(join16(srcDir, "App.tsx"), appTsx);
+    writeFileSync9(join16(srcDir, "vite-env.d.ts"), '/// <reference types="vite/client" />\n');
+    mkdirSync7(join16(srcDir, "styles"), { recursive: true });
   }
 };
 var nextAppAdapter = {
@@ -2916,8 +3151,8 @@ var nextAppAdapter = {
     distDir: ".next"
   },
   writeProjectFiles(projectDir, title) {
-    const appDir = join17(projectDir, "app");
-    const stylesDir = join17(projectDir, "src", "styles");
+    const appDir = join16(projectDir, "app");
+    const stylesDir = join16(projectDir, "src", "styles");
     const packageJson = {
       name: basename(projectDir) || "decantr-next-app",
       private: true,
@@ -2942,11 +3177,11 @@ var nextAppAdapter = {
         typescript: "^5.7.0"
       }
     };
-    writeFileSync8(join17(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
-    writeFileSync8(join17(projectDir, "next.config.ts"), 'import type { NextConfig } from "next";\n\nconst nextConfig: NextConfig = {};\n\nexport default nextConfig;\n');
-    writeFileSync8(join17(projectDir, "next-env.d.ts"), '/// <reference types="next" />\n/// <reference types="next/image-types/global" />\n\n// This file is generated by Next.js.\n');
-    writeFileSync8(
-      join17(projectDir, "tsconfig.json"),
+    writeFileSync9(join16(projectDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n");
+    writeFileSync9(join16(projectDir, "next.config.ts"), 'import type { NextConfig } from "next";\n\nconst nextConfig: NextConfig = {};\n\nexport default nextConfig;\n');
+    writeFileSync9(join16(projectDir, "next-env.d.ts"), '/// <reference types="next" />\n/// <reference types="next/image-types/global" />\n\n// This file is generated by Next.js.\n');
+    writeFileSync9(
+      join16(projectDir, "tsconfig.json"),
       JSON.stringify(
         {
           compilerOptions: {
@@ -2972,10 +3207,10 @@ var nextAppAdapter = {
         2
       ) + "\n"
     );
-    mkdirSync6(appDir, { recursive: true });
-    mkdirSync6(stylesDir, { recursive: true });
-    writeFileSync8(
-      join17(appDir, "layout.tsx"),
+    mkdirSync7(appDir, { recursive: true });
+    mkdirSync7(stylesDir, { recursive: true });
+    writeFileSync9(
+      join16(appDir, "layout.tsx"),
       `import type { Metadata } from 'next';
 import '../src/styles/global.css';
 import '../src/styles/tokens.css';
@@ -2995,8 +3230,8 @@ export default function RootLayout({ children }: Readonly<{ children: React.Reac
 }
 `
     );
-    writeFileSync8(
-      join17(appDir, "page.tsx"),
+    writeFileSync9(
+      join16(appDir, "page.tsx"),
       `import { css } from '@decantr/css';
 
 export default function HomePage() {
@@ -3066,7 +3301,7 @@ function getBootstrapAdapter(resolution) {
 }
 function detectRoutingMode(projectDir) {
   try {
-    const essence = JSON.parse(readFileSync12(join17(projectDir, "decantr.essence.json"), "utf-8"));
+    const essence = JSON.parse(readFileSync11(join16(projectDir, "decantr.essence.json"), "utf-8"));
     const routing = essence.meta?.platform?.routing;
     if (routing === "history" || routing === "pathname") {
       return routing;
@@ -3078,45 +3313,45 @@ function detectRoutingMode(projectDir) {
 }
 
 // src/offline-content.ts
-import { cpSync, existsSync as existsSync17, mkdirSync as mkdirSync7 } from "fs";
-import { join as join18, resolve } from "path";
+import { cpSync, existsSync as existsSync16, mkdirSync as mkdirSync8 } from "fs";
+import { join as join17, resolve } from "path";
 var CONTENT_TYPES2 = ["archetypes", "blueprints", "patterns", "themes", "shells"];
 function copyIfExists(source, target) {
-  if (!existsSync17(source)) return false;
+  if (!existsSync16(source)) return false;
   if (resolve(source) === resolve(target)) return true;
   cpSync(source, target, { recursive: true });
   return true;
 }
 function hydrateContentRoot(projectDir, contentRoot) {
-  if (!existsSync17(contentRoot)) return false;
-  const customRoot = join18(projectDir, ".decantr", "custom");
-  const cacheRoot = join18(projectDir, ".decantr", "cache", "@official");
-  mkdirSync7(customRoot, { recursive: true });
-  mkdirSync7(cacheRoot, { recursive: true });
+  if (!existsSync16(contentRoot)) return false;
+  const customRoot = join17(projectDir, ".decantr", "custom");
+  const cacheRoot = join17(projectDir, ".decantr", "cache", "@official");
+  mkdirSync8(customRoot, { recursive: true });
+  mkdirSync8(cacheRoot, { recursive: true });
   let copiedAny = false;
   for (const type of CONTENT_TYPES2) {
-    const sourceDir = join18(contentRoot, type);
-    if (!existsSync17(sourceDir)) continue;
-    cpSync(sourceDir, join18(customRoot, type), { recursive: true });
-    cpSync(sourceDir, join18(cacheRoot, type), { recursive: true });
+    const sourceDir = join17(contentRoot, type);
+    if (!existsSync16(sourceDir)) continue;
+    cpSync(sourceDir, join17(customRoot, type), { recursive: true });
+    cpSync(sourceDir, join17(cacheRoot, type), { recursive: true });
     copiedAny = true;
   }
   return copiedAny;
 }
 function seedOfflineRegistry(projectDir, workspaceRoot) {
-  const projectDecantrRoot = join18(projectDir, ".decantr");
-  mkdirSync7(projectDecantrRoot, { recursive: true });
+  const projectDecantrRoot = join17(projectDir, ".decantr");
+  mkdirSync8(projectDecantrRoot, { recursive: true });
   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(
-    join18(workspaceRoot, ".decantr", "cache"),
-    join18(projectDecantrRoot, "cache")
+    join17(workspaceRoot, ".decantr", "cache"),
+    join17(projectDecantrRoot, "cache")
   );
   const copiedCustom = copyIfExists(
-    join18(workspaceRoot, ".decantr", "custom"),
-    join18(projectDecantrRoot, "custom")
+    join17(workspaceRoot, ".decantr", "custom"),
+    join17(projectDecantrRoot, "custom")
   );
   if (copiedCache || copiedCustom) {
     return { seeded: true, strategy: "workspace-cache" };
@@ -3207,7 +3442,7 @@ function runArgvCommand(command, args, cwd) {
 }
 function resolveInitCommand(initFlags) {
   const bundledCliEntrypoint = fileURLToPath(new URL("./bin.js", import.meta.url));
-  const cliEntrypoint = existsSync18(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync18(process.argv[1]) ? process.argv[1] : null;
+  const cliEntrypoint = existsSync17(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync17(process.argv[1]) ? process.argv[1] : null;
   if (cliEntrypoint) {
     return {
       command: process.execPath,
@@ -3234,7 +3469,7 @@ async function cmdNewProject(projectName, options) {
     process.exitCode = 1;
     return;
   }
-  if (existsSync18(projectDir)) {
+  if (existsSync17(projectDir)) {
     console.error(error2(`Directory "${projectName}" already exists.`));
     process.exitCode = 1;
     return;
@@ -3248,7 +3483,7 @@ async function cmdNewProject(projectName, options) {
     return;
   }
   console.log(heading(`Creating ${projectName}...`));
-  mkdirSync8(projectDir, { recursive: true });
+  mkdirSync9(projectDir, { recursive: true });
   console.log(dim2(`  Created ${projectName}/`));
   const title = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   if (shouldBootstrapRuntime && bootstrapAdapter) {
@@ -3339,21 +3574,21 @@ ${YELLOW4}Decantr init encountered issues. Run \`decantr init\` manually inside
   console.log("");
 }
 function detectPackageManager() {
-  if (existsSync18(join19(process.cwd(), "pnpm-lock.yaml")) || existsSync18(join19(process.cwd(), "pnpm-workspace.yaml"))) {
+  if (existsSync17(join18(process.cwd(), "pnpm-lock.yaml")) || existsSync17(join18(process.cwd(), "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync18(join19(process.cwd(), "yarn.lock"))) {
+  if (existsSync17(join18(process.cwd(), "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync18(join19(process.cwd(), "bun.lockb")) || existsSync18(join19(process.cwd(), "bun.lock"))) {
+  if (existsSync17(join18(process.cwd(), "bun.lockb")) || existsSync17(join18(process.cwd(), "bun.lock"))) {
     return "bun";
   }
   return "npm";
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { join as join19 } from "path";
 import {
   API_CONTENT_TYPE_TO_CONTENT_TYPE,
   CONTENT_TYPE_TO_API_CONTENT_TYPE as CONTENT_TYPE_TO_API_CONTENT_TYPE2,
@@ -3369,8 +3604,8 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
   }
   const singularType = API_CONTENT_TYPE_TO_CONTENT_TYPE[type] || type;
   const pluralType = CONTENT_TYPE_TO_API_CONTENT_TYPE2[type] || CONTENT_TYPE_TO_API_CONTENT_TYPE2[singularType] || `${type}s`;
-  const customPath = join20(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
-  if (!existsSync19(customPath)) {
+  const customPath = join19(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
+  if (!existsSync18(customPath)) {
     console.error(`Custom ${singularType} "${name}" not found at ${customPath}`);
     console.error(`Create one first: decantr create ${singularType} ${name}`);
     process.exitCode = 1;
@@ -3378,7 +3613,7 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
   }
   let data;
   try {
-    data = JSON.parse(readFileSync13(customPath, "utf-8"));
+    data = JSON.parse(readFileSync12(customPath, "utf-8"));
   } catch {
     console.error(`Failed to parse ${customPath}`);
     process.exitCode = 1;
@@ -3416,25 +3651,25 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
 }
 
 // src/commands/refresh.ts
-import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
-import { join as join21 } from "path";
-import { isV3 as isV33 } from "@decantr/essence-spec";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { join as join20 } from "path";
+import { isV3 as isV34 } from "@decantr/essence-spec";
 var GREEN7 = "\x1B[32m";
 var RED6 = "\x1B[31m";
 var DIM7 = "\x1B[2m";
 var RESET7 = "\x1B[0m";
 async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
-  const essencePath = join21(projectRoot, "decantr.essence.json");
-  if (!existsSync20(essencePath)) {
+  const essencePath = join20(projectRoot, "decantr.essence.json");
+  if (!existsSync19(essencePath)) {
     console.error(`${RED6}No decantr.essence.json found. Run \`decantr init\` first.${RESET7}`);
     process.exitCode = 1;
     return;
   }
   let essence;
   try {
-    const raw = readFileSync14(essencePath, "utf-8");
+    const raw = readFileSync13(essencePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (!isV33(parsed)) {
+    if (!isV34(parsed)) {
       console.error(`${RED6}Essence is not v3. Run \`decantr migrate\` first.${RESET7}`);
       process.exitCode = 1;
       return;
@@ -3446,7 +3681,7 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join21(projectRoot, ".decantr", "cache"),
+    cacheDir: join20(projectRoot, ".decantr", "cache"),
     offline: options.offline
   });
   console.log("Regenerating derived files...\n");
@@ -3466,8 +3701,8 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
 }
 
 // src/commands/registry-mirror.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join22 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { join as join21 } from "path";
 import { API_CONTENT_TYPES, RegistryAPIClient as RegistryAPIClient2 } from "@decantr/registry";
 var GREEN8 = "\x1B[32m";
 var RED7 = "\x1B[31m";
@@ -3495,7 +3730,7 @@ async function cmdRegistryMirror(projectRoot, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const cacheDir = join22(projectRoot, ".decantr", "cache");
+  const cacheDir = join21(projectRoot, ".decantr", "cache");
   const counts = {};
   const failed = [];
   console.log(`
@@ -3505,19 +3740,19 @@ Mirroring registry content to ${DIM8}.decantr/cache/${RESET8}
     try {
       const result = await apiClient.listContent(type, { namespace: "@official" });
       const items = result.items;
-      const typeDir = join22(cacheDir, "@official", type);
-      mkdirSync9(typeDir, { recursive: true });
-      writeFileSync9(join22(typeDir, "index.json"), JSON.stringify(result, null, 2));
+      const typeDir = join21(cacheDir, "@official", type);
+      mkdirSync10(typeDir, { recursive: true });
+      writeFileSync10(join21(typeDir, "index.json"), JSON.stringify(result, null, 2));
       let itemCount = 0;
       for (const item of items) {
         const slug = item.slug || item.id;
         if (!slug) continue;
         try {
           const fullItem = await apiClient.getContent(type, "@official", slug);
-          writeFileSync9(join22(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
+          writeFileSync10(join21(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
           itemCount++;
         } catch {
-          writeFileSync9(join22(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
+          writeFileSync10(join21(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
           itemCount++;
         }
       }
@@ -3532,8 +3767,8 @@ Mirroring registry content to ${DIM8}.decantr/cache/${RESET8}
     mirrored_at: (/* @__PURE__ */ new Date()).toISOString(),
     counts
   };
-  mkdirSync9(join22(cacheDir), { recursive: true });
-  writeFileSync9(join22(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
+  mkdirSync10(join21(cacheDir), { recursive: true });
+  writeFileSync10(join21(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
   const totalItems = Object.values(counts).reduce((a, b) => a + b, 0);
   console.log("");
   if (failed.length > 0) {
@@ -3550,29 +3785,29 @@ Mirroring registry content to ${DIM8}.decantr/cache/${RESET8}
 }
 
 // src/commands/remove.ts
-import { existsSync as existsSync22, readFileSync as readFileSync15, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "fs";
-import { join as join23 } from "path";
-import { isV3 as isV34, migrateV30ToV31 as migrateV30ToV312 } from "@decantr/essence-spec";
+import { existsSync as existsSync21, readFileSync as readFileSync14, rmSync as rmSync2, writeFileSync as writeFileSync11 } from "fs";
+import { join as join22 } from "path";
+import { isV3 as isV35, migrateV30ToV31 as migrateV30ToV312 } from "@decantr/essence-spec";
 var GREEN9 = "\x1B[32m";
 var RED8 = "\x1B[31m";
 var DIM9 = "\x1B[2m";
 var RESET9 = "\x1B[0m";
 function readAndMigrate2(projectRoot) {
-  const essencePath = join23(projectRoot, "decantr.essence.json");
-  if (!existsSync22(essencePath)) {
+  const essencePath = join22(projectRoot, "decantr.essence.json");
+  if (!existsSync21(essencePath)) {
     console.error(`${RED8}No decantr.essence.json found. Run \`decantr init\` first.${RESET9}`);
     process.exitCode = 1;
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync14(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED8}Could not read essence: ${e.message}${RESET9}`);
     process.exitCode = 1;
     return null;
   }
-  if (!isV34(parsed)) {
+  if (!isV35(parsed)) {
     console.error(`${RED8}Essence is not v3. Run \`decantr migrate\` first.${RESET9}`);
     process.exitCode = 1;
     return null;
@@ -3581,7 +3816,7 @@ function readAndMigrate2(projectRoot) {
   return { essence, essencePath };
 }
 function writeEssence2(essencePath, essence) {
-  writeFileSync10(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync11(essencePath, JSON.stringify(essence, null, 2) + "\n");
 }
 function recomputeGlobalFeatures(essence) {
   const all = /* @__PURE__ */ new Set();
@@ -3623,14 +3858,14 @@ async function cmdRemoveSection(sectionId, args, projectRoot = process.cwd()) {
   sections.splice(idx, 1);
   recomputeGlobalFeatures(essence);
   removeRoutes(essence, sectionId);
-  const contextFile = join23(projectRoot, ".decantr", "context", `${sectionId}.md`);
-  if (existsSync22(contextFile)) {
+  const contextFile = join22(projectRoot, ".decantr", "context", `${sectionId}.md`);
+  if (existsSync21(contextFile)) {
     rmSync2(contextFile);
   }
   writeEssence2(essencePath, essence);
   console.log(`${GREEN9}Removed section "${sectionId}".${RESET9}`);
   const registryClient = new RegistryClient({
-    cacheDir: join23(projectRoot, ".decantr", "cache")
+    cacheDir: join22(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN9}Derived files refreshed.${RESET9}`);
@@ -3666,7 +3901,7 @@ async function cmdRemovePage(path, args, projectRoot = process.cwd()) {
   writeEssence2(essencePath, essence);
   console.log(`${GREEN9}Removed page "${pageId}" from section "${sectionId}".${RESET9}`);
   const registryClient = new RegistryClient({
-    cacheDir: join23(projectRoot, ".decantr", "cache")
+    cacheDir: join22(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN9}Derived files refreshed.${RESET9}`);
@@ -3707,15 +3942,15 @@ async function cmdRemoveFeature(feature, args, projectRoot = process.cwd()) {
   const target = sectionId ? `section "${sectionId}" and global` : "global";
   console.log(`${GREEN9}Removed feature "${feature}" from ${target} features.${RESET9}`);
   const registryClient = new RegistryClient({
-    cacheDir: join23(projectRoot, ".decantr", "cache")
+    cacheDir: join22(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN9}Derived files refreshed.${RESET9}`);
 }
 
 // src/commands/sync-drift.ts
-import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
+import { join as join23 } from "path";
 var GREEN10 = "\x1B[32m";
 var RED9 = "\x1B[31m";
 var YELLOW6 = "\x1B[33m";
@@ -3724,8 +3959,8 @@ var DIM10 = "\x1B[2m";
 var BOLD4 = "\x1B[1m";
 var CYAN5 = "\x1B[36m";
 async function cmdSyncDrift(projectRoot = process.cwd()) {
-  const driftLogPath = join24(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync23(driftLogPath)) {
+  const driftLogPath = join23(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync22(driftLogPath)) {
     console.log(`${GREEN10}No drift log found \u2014 no drift recorded.${RESET10}`);
     console.log(
       `${DIM10}Drift is logged when guard violations are detected during development.${RESET10}`
@@ -3734,7 +3969,7 @@ async function cmdSyncDrift(projectRoot = process.cwd()) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync16(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync15(driftLogPath, "utf-8"));
   } catch {
     console.error(`${RED9}Could not parse drift-log.json${RESET10}`);
     process.exitCode = 1;
@@ -3780,13 +4015,13 @@ ${BOLD4}Unresolved Drift Entries (${unresolved.length})${RESET10}
   console.log("");
 }
 function resolveDriftEntries(projectRoot, options) {
-  const driftLogPath = join24(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync23(driftLogPath)) {
+  const driftLogPath = join23(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync22(driftLogPath)) {
     return { success: true };
   }
   if (options.clear) {
     try {
-      writeFileSync11(driftLogPath, "[]");
+      writeFileSync12(driftLogPath, "[]");
       return { success: true };
     } catch (e) {
       return { success: false, error: `Could not clear drift log: ${e.message}` };
@@ -3794,7 +4029,7 @@ function resolveDriftEntries(projectRoot, options) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync16(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync15(driftLogPath, "utf-8"));
   } catch {
     return { success: false, error: "Could not parse drift-log.json" };
   }
@@ -3813,7 +4048,7 @@ function resolveDriftEntries(projectRoot, options) {
     }
   }
   try {
-    writeFileSync11(driftLogPath, JSON.stringify(entries, null, 2));
+    writeFileSync12(driftLogPath, JSON.stringify(entries, null, 2));
     return { success: true };
   } catch (e) {
     return { success: false, error: `Could not write drift log: ${e.message}` };
@@ -3821,9 +4056,9 @@ function resolveDriftEntries(projectRoot, options) {
 }
 
 // src/commands/theme-switch.ts
-import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "fs";
-import { join as join25 } from "path";
-import { isV3 as isV35, migrateV30ToV31 as migrateV30ToV313 } from "@decantr/essence-spec";
+import { existsSync as existsSync23, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
+import { join as join24 } from "path";
+import { isV3 as isV36, migrateV30ToV31 as migrateV30ToV313 } from "@decantr/essence-spec";
 var GREEN11 = "\x1B[32m";
 var RED10 = "\x1B[31m";
 var YELLOW7 = "\x1B[33m";
@@ -3839,21 +4074,21 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join25(projectRoot, "decantr.essence.json");
-  if (!existsSync24(essencePath)) {
+  const essencePath = join24(projectRoot, "decantr.essence.json");
+  if (!existsSync23(essencePath)) {
     console.error(`${RED10}No decantr.essence.json found. Run \`decantr init\` first.${RESET11}`);
     process.exitCode = 1;
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync16(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED10}Could not read essence: ${e.message}${RESET11}`);
     process.exitCode = 1;
     return;
   }
-  if (!isV35(parsed)) {
+  if (!isV36(parsed)) {
     console.error(`${RED10}Essence is not v3. Run \`decantr migrate\` first.${RESET11}`);
     process.exitCode = 1;
     return;
@@ -3896,7 +4131,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     essence.dna.theme.mode = mode;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join25(projectRoot, ".decantr", "cache")
+    cacheDir: join24(projectRoot, ".decantr", "cache")
   });
   try {
     const themeResult = await registryClient.fetchTheme(themeName);
@@ -3911,7 +4146,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     }
   } catch {
   }
-  writeFileSync12(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync13(essencePath, JSON.stringify(essence, null, 2) + "\n");
   console.log(`${GREEN11}Switched theme: ${oldThemeId} \u2192 ${themeName}${RESET11}`);
   if (shape) console.log(`  ${DIM11}Shape: ${shape}${RESET11}`);
   if (mode) console.log(`  ${DIM11}Mode: ${mode}${RESET11}`);
@@ -3992,6 +4227,7 @@ ${CYAN6}Detected project configuration:${RESET12}`);
 }
 async function runInteractivePrompts(detected, archetypes, blueprints, themes, workflowSeed) {
   showDetection(detected);
+  const existingProject = Boolean(workflowSeed?.existing) || detected.existingEssence || hasExistingProjectFootprint(detected);
   const blueprintOptions = [
     { value: "none", label: "none", description: "Start from scratch (blank canvas)" },
     ...blueprints.map((b) => ({
@@ -4002,12 +4238,21 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes, w
   ];
   const blueprint = await select("What are you building?", blueprintOptions, 0, true);
   const isBlank = blueprint === "none";
-  const themeOptions = themes.map((t) => ({
-    value: t.id,
-    label: t.id,
-    description: t.description
-  }));
-  const desiredTheme = workflowSeed?.theme || "luminarum";
+  const themeOptions = [
+    ...existingProject ? [
+      {
+        value: "existing",
+        label: "existing",
+        description: "Preserve the existing styling system"
+      }
+    ] : [],
+    ...themes.map((t) => ({
+      value: t.id,
+      label: t.id,
+      description: t.description
+    }))
+  ];
+  const desiredTheme = workflowSeed?.theme || (existingProject ? "existing" : "luminarum");
   const defaultThemeIdx = Math.max(
     0,
     themeOptions.findIndex((t) => t.value === desiredTheme)
@@ -4020,7 +4265,7 @@ async function runInteractivePrompts(detected, archetypes, blueprints, themes, w
       { value: "light", label: "light", description: "Light background" },
       { value: "auto", label: "auto", description: "Follow system preference" }
     ],
-    workflowSeed?.mode === "light" ? 1 : workflowSeed?.mode === "auto" ? 2 : 0
+    workflowSeed?.mode === "light" ? 1 : workflowSeed?.mode === "auto" || existingProject ? 2 : 0
   );
   const shape = await select(
     "Border shape",
@@ -4153,17 +4398,18 @@ function parseFlags(args, detected) {
   return options;
 }
 function mergeWithDefaults(flags, detected, workflowSeed) {
+  const existingProject = flags.existing || workflowSeed?.existing || detected.existingEssence || hasExistingProjectFootprint(detected);
   return {
     blueprint: flags.blueprint,
     archetype: flags.archetype,
-    theme: flags.theme || workflowSeed?.theme || "luminarum",
-    mode: flags.mode || workflowSeed?.mode || "dark",
+    theme: flags.theme || workflowSeed?.theme || (existingProject ? "existing" : "luminarum"),
+    mode: flags.mode || workflowSeed?.mode || (existingProject ? "auto" : "dark"),
     shape: flags.shape || "rounded",
     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"],
+    shell: flags.shell || workflowSeed?.shell || (existingProject ? "observed-existing-shell" : "sidebar-main"),
+    personality: flags.personality || (existingProject ? ["observed brownfield product"] : ["professional"]),
     features: flags.features || [],
     existing: flags.existing || workflowSeed?.existing || detected.existingEssence,
     workflowMode: flags.workflowMode || workflowSeed?.workflowMode,
@@ -4207,8 +4453,8 @@ async function runSimplifiedInit(blueprints) {
 }
 
 // src/theme-commands.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync10, readdirSync as readdirSync5, readFileSync as readFileSync18, rmSync as rmSync3, writeFileSync as writeFileSync13 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync11, readdirSync as readdirSync4, readFileSync as readFileSync17, rmSync as rmSync3, writeFileSync as writeFileSync14 } from "fs";
+import { join as join25 } from "path";
 var REQUIRED_FIELDS = [
   "$schema",
   "id",
@@ -4268,20 +4514,20 @@ function validateCustomTheme(theme) {
   };
 }
 function createTheme(projectRoot, id, name) {
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  const themePath = join26(customThemesDir, `${id}.json`);
-  const howToPath = join26(customThemesDir, "how-to-theme.md");
-  mkdirSync10(customThemesDir, { recursive: true });
-  if (existsSync25(themePath)) {
+  const customThemesDir = join25(projectRoot, ".decantr", "custom", "themes");
+  const themePath = join25(customThemesDir, `${id}.json`);
+  const howToPath = join25(customThemesDir, "how-to-theme.md");
+  mkdirSync11(customThemesDir, { recursive: true });
+  if (existsSync24(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" already exists at ${themePath}`
     };
   }
   const skeleton = getThemeSkeleton(id, name);
-  writeFileSync13(themePath, JSON.stringify(skeleton, null, 2));
-  if (!existsSync25(howToPath)) {
-    writeFileSync13(howToPath, getHowToThemeDoc());
+  writeFileSync14(themePath, JSON.stringify(skeleton, null, 2));
+  if (!existsSync24(howToPath)) {
+    writeFileSync14(howToPath, getHowToThemeDoc());
   }
   return {
     success: true,
@@ -4289,17 +4535,17 @@ function createTheme(projectRoot, id, name) {
   };
 }
 function listCustomThemes(projectRoot) {
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  if (!existsSync25(customThemesDir)) {
+  const customThemesDir = join25(projectRoot, ".decantr", "custom", "themes");
+  if (!existsSync24(customThemesDir)) {
     return [];
   }
   const themes = [];
   try {
-    const files = readdirSync5(customThemesDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync4(customThemesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = join26(customThemesDir, file);
+      const filePath = join25(customThemesDir, file);
       try {
-        const data = JSON.parse(readFileSync18(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync17(filePath, "utf-8"));
         themes.push({
           id: data.id || file.replace(".json", ""),
           name: data.name || data.id,
@@ -4314,8 +4560,8 @@ function listCustomThemes(projectRoot) {
   return themes;
 }
 function deleteTheme(projectRoot, id) {
-  const themePath = join26(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
-  if (!existsSync25(themePath)) {
+  const themePath = join25(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
+  if (!existsSync24(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" not found at ${themePath}`
@@ -4332,7 +4578,7 @@ function deleteTheme(projectRoot, id) {
   }
 }
 function importTheme(projectRoot, sourcePath) {
-  if (!existsSync25(sourcePath)) {
+  if (!existsSync24(sourcePath)) {
     return {
       success: false,
       errors: [`Source file not found: ${sourcePath}`]
@@ -4340,7 +4586,7 @@ function importTheme(projectRoot, sourcePath) {
   }
   let theme;
   try {
-    theme = JSON.parse(readFileSync18(sourcePath, "utf-8"));
+    theme = JSON.parse(readFileSync17(sourcePath, "utf-8"));
   } catch (e) {
     return {
       success: false,
@@ -4356,14 +4602,14 @@ function importTheme(projectRoot, sourcePath) {
   }
   theme.source = "custom";
   const id = theme.id;
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  const destPath = join26(customThemesDir, `${id}.json`);
-  mkdirSync10(customThemesDir, { recursive: true });
-  const howToPath = join26(customThemesDir, "how-to-theme.md");
-  if (!existsSync25(howToPath)) {
-    writeFileSync13(howToPath, getHowToThemeDoc());
-  }
-  writeFileSync13(destPath, JSON.stringify(theme, null, 2));
+  const customThemesDir = join25(projectRoot, ".decantr", "custom", "themes");
+  const destPath = join25(customThemesDir, `${id}.json`);
+  mkdirSync11(customThemesDir, { recursive: true });
+  const howToPath = join25(customThemesDir, "how-to-theme.md");
+  if (!existsSync24(howToPath)) {
+    writeFileSync14(howToPath, getHowToThemeDoc());
+  }
+  writeFileSync14(destPath, JSON.stringify(theme, null, 2));
   return {
     success: true,
     path: destPath
@@ -4371,19 +4617,19 @@ function importTheme(projectRoot, sourcePath) {
 }
 
 // src/workspace.ts
-import { existsSync as existsSync26, readdirSync as readdirSync6, readFileSync as readFileSync19 } from "fs";
-import { dirname as dirname3, join as join27, resolve as resolve3 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync5, readFileSync as readFileSync18 } from "fs";
+import { dirname as dirname3, join as join26, resolve as resolve3 } from "path";
 function readPackageJson(dir) {
-  const path = join27(dir, "package.json");
-  if (!existsSync26(path)) return null;
+  const path = join26(dir, "package.json");
+  if (!existsSync25(path)) return null;
   try {
-    return JSON.parse(readFileSync19(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function hasWorkspaceMarker(dir) {
-  if (existsSync26(join27(dir, "pnpm-workspace.yaml")) || existsSync26(join27(dir, "turbo.json")) || existsSync26(join27(dir, "nx.json"))) {
+  if (existsSync25(join26(dir, "pnpm-workspace.yaml")) || existsSync25(join26(dir, "turbo.json")) || existsSync25(join26(dir, "nx.json"))) {
     return true;
   }
   const pkg = readPackageJson(dir);
@@ -4399,7 +4645,7 @@ function findWorkspaceRoot(startDir) {
   }
 }
 function looksLikeApp(dir) {
-  if (existsSync26(join27(dir, "next.config.js")) || existsSync26(join27(dir, "next.config.ts")) || existsSync26(join27(dir, "next.config.mjs")) || existsSync26(join27(dir, "vite.config.ts")) || existsSync26(join27(dir, "vite.config.js")) || existsSync26(join27(dir, "angular.json")) || existsSync26(join27(dir, "svelte.config.js")) || existsSync26(join27(dir, "svelte.config.ts")) || existsSync26(join27(dir, "astro.config.mjs")) || existsSync26(join27(dir, "src")) || existsSync26(join27(dir, "app")) || existsSync26(join27(dir, "pages"))) {
+  if (existsSync25(join26(dir, "next.config.js")) || existsSync25(join26(dir, "next.config.ts")) || existsSync25(join26(dir, "next.config.mjs")) || existsSync25(join26(dir, "vite.config.ts")) || existsSync25(join26(dir, "vite.config.js")) || existsSync25(join26(dir, "angular.json")) || existsSync25(join26(dir, "svelte.config.js")) || existsSync25(join26(dir, "svelte.config.ts")) || existsSync25(join26(dir, "astro.config.mjs")) || existsSync25(join26(dir, "src")) || existsSync25(join26(dir, "app")) || existsSync25(join26(dir, "pages"))) {
     return true;
   }
   const pkg = readPackageJson(dir);
@@ -4411,11 +4657,11 @@ function looksLikeApp(dir) {
 function listWorkspaceApps(workspaceRoot) {
   const candidates = [];
   for (const base of ["apps", "packages"]) {
-    const baseDir = join27(workspaceRoot, base);
-    if (!existsSync26(baseDir)) continue;
-    for (const entry of readdirSync6(baseDir, { withFileTypes: true })) {
+    const baseDir = join26(workspaceRoot, base);
+    if (!existsSync25(baseDir)) continue;
+    for (const entry of readdirSync5(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const candidate = join27(baseDir, entry.name);
+      const candidate = join26(baseDir, entry.name);
       if (looksLikeApp(candidate)) {
         candidates.push(`${base}/${entry.name}`);
       }
@@ -4797,7 +5043,8 @@ function generateBrownfieldPrompt(ctx) {
   lines.push("");
   if (ctx.analysisArtifacts) {
     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 .decantr/doctrine-map.json, .decantr/ambient-context.json, and .decantr/brownfield-report.md as the ranked doctrine inventory and conflict report.");
+    lines.push("Treat the accepted observed proposal as the source of Decantr route/section coverage.");
   } else {
     lines.push(
       "No Decantr analysis seed is present. Start by inventorying the app before changing runtime files."
@@ -4815,16 +5062,18 @@ function generateBrownfieldPrompt(ctx) {
     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("2. .decantr/doctrine-map.json for ranked source precedence across security/data, architecture, design-system, workflow, feature, and assistant evidence.");
+    lines.push("3. .decantr/ambient-context.json for assistant rules, docs, design-system, CI, schema, and workflow evidence.");
+    lines.push("4. .decantr/brownfield-report.md for conflicts, stale risks, and acceptance context.");
+    lines.push("5. 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."
+      "6. .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."
+      "7. .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."
+      "8. The matching section and page pack files only when you are working on those specific surfaces."
     );
   } else {
     lines.push("1. Inventory existing framework, routes, styling, layout, rule files, and dependencies.");
@@ -4899,7 +5148,7 @@ function generateBrownfieldPrompt(ctx) {
   );
   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."
+    "- After implementation, run decantr check --brownfield 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."
@@ -4934,18 +5183,18 @@ function extractHostedAssetPaths(indexHtml) {
   return [...assetPaths];
 }
 function readHostedDistSnapshot(distPath) {
-  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join28(process.cwd(), "dist");
-  const indexPath = join28(resolvedDistPath, "index.html");
-  if (!existsSync27(indexPath)) {
+  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join27(process.cwd(), "dist");
+  const indexPath = join27(resolvedDistPath, "index.html");
+  if (!existsSync26(indexPath)) {
     return void 0;
   }
-  const indexHtml = readFileSync20(indexPath, "utf-8");
+  const indexHtml = readFileSync19(indexPath, "utf-8");
   const assetPaths = extractHostedAssetPaths(indexHtml);
   const assets = {};
   for (const assetPath of assetPaths) {
-    const assetFilePath = join28(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
-    if (existsSync27(assetFilePath)) {
-      assets[assetPath] = readFileSync20(assetFilePath, "utf-8");
+    const assetFilePath = join27(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
+    if (existsSync26(assetFilePath)) {
+      assets[assetPath] = readFileSync19(assetFilePath, "utf-8");
     }
   }
   return {
@@ -4960,7 +5209,7 @@ function isHostedSourceSnapshotFile(path) {
 function readHostedSourceSnapshot(sourcePath) {
   if (!sourcePath) return void 0;
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  if (!existsSync27(resolvedSourcePath)) {
+  if (!existsSync26(resolvedSourcePath)) {
     return void 0;
   }
   const files = {};
@@ -4974,17 +5223,17 @@ function readHostedSourceSnapshot(sourcePath) {
   ]);
   const rootPrefix = basename2(resolvedSourcePath);
   const walk = (absoluteDir, relativeDir) => {
-    for (const entry of readdirSync7(absoluteDir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(absoluteDir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join28(absoluteDir, entry.name);
-      const relativePath = join28(relativeDir, entry.name).replace(/\\/g, "/");
+      const absolutePath = join27(absoluteDir, entry.name);
+      const relativePath = join27(relativeDir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (!isHostedSourceSnapshotFile(relativePath)) continue;
-      files[relativePath] = readFileSync20(absolutePath, "utf-8");
+      files[relativePath] = readFileSync19(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -5135,16 +5384,16 @@ async function printRegistryIntelligenceSummary(namespace, jsonOutput = false) {
 }
 async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join27(process.cwd(), "decantr.essence.json");
+  if (!existsSync26(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync19(resolvedPath, "utf-8"));
   const bundle = await client.compileExecutionPacks(essence, namespace ? { namespace } : void 0);
   let writtenContextPaths = [];
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync11(contextDir, { recursive: true });
+    const contextDir = join27(process.cwd(), ".decantr", "context");
+    mkdirSync12(contextDir, { recursive: true });
     const written = writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -5169,7 +5418,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: ${join28(process.cwd(), ".decantr", "context")}`);
+    console.log(`  Context bundle: ${join27(process.cwd(), ".decantr", "context")}`);
     console.log(`  Files written: ${writtenContextPaths.length}`);
   }
   console.log("");
@@ -5182,14 +5431,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) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join27(process.cwd(), "decantr.essence.json");
+  if (!existsSync26(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(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync19(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -5200,17 +5449,17 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync11(contextDir, { recursive: true });
-    writeFileSync14(
-      join28(contextDir, "pack-manifest.json"),
+    const contextDir = join27(process.cwd(), ".decantr", "context");
+    mkdirSync12(contextDir, { recursive: true });
+    writeFileSync15(
+      join27(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`;
-    writeFileSync14(join28(contextDir, markdownFile), selected.pack.renderedMarkdown);
-    writeFileSync14(join28(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
+    writeFileSync15(join27(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync15(join27(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -5235,20 +5484,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) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join27(process.cwd(), "decantr.essence.json");
+  if (!existsSync26(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync19(resolvedPath, "utf-8"));
   const manifest = await client.getExecutionPackManifest(
     essence,
     namespace ? { namespace } : void 0
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync11(contextDir, { recursive: true });
-    writeFileSync14(join28(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const contextDir = join27(process.cwd(), ".decantr", "context");
+    mkdirSync12(contextDir, { recursive: true });
+    writeFileSync15(join27(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -5269,14 +5518,14 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   }
 }
 async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join28(projectRoot, ".decantr", "context");
-  const reviewPackPath = join28(contextDir, "review-pack.json");
-  const manifestPath = join28(contextDir, "pack-manifest.json");
-  if (existsSync27(reviewPackPath) && existsSync27(manifestPath)) {
+  const contextDir = join27(projectRoot, ".decantr", "context");
+  const reviewPackPath = join27(contextDir, "review-pack.json");
+  const manifestPath = join27(contextDir, "pack-manifest.json");
+  if (existsSync26(reviewPackPath) && existsSync26(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) {
+  const essencePath = join27(projectRoot, "decantr.essence.json");
+  if (!existsSync26(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   const reviewHydration = await hydrateHostedReviewPackIfMissing(projectRoot, namespace);
@@ -5285,9 +5534,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync19(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync11(contextDir, { recursive: true });
+    mkdirSync12(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(contextDir, bundle);
     return { attempted: true, hydrated: true, scope: "bundle" };
   } catch {
@@ -5295,19 +5544,19 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
 }
 async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join28(projectRoot, ".decantr", "context");
-  const reviewPackPath = join28(contextDir, "review-pack.json");
-  const manifestPath = join28(contextDir, "pack-manifest.json");
-  if (existsSync27(reviewPackPath) && existsSync27(manifestPath)) {
+  const contextDir = join27(projectRoot, ".decantr", "context");
+  const reviewPackPath = join27(contextDir, "review-pack.json");
+  const manifestPath = join27(contextDir, "pack-manifest.json");
+  if (existsSync26(reviewPackPath) && existsSync26(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) {
+  const essencePath = join27(projectRoot, "decantr.essence.json");
+  if (!existsSync26(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync19(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -5315,14 +5564,14 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync11(contextDir, { recursive: true });
-    writeFileSync14(join28(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync14(
-      join28(contextDir, "review-pack.json"),
+    mkdirSync12(contextDir, { recursive: true });
+    writeFileSync15(join27(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync15(
+      join27(contextDir, "review-pack.json"),
       JSON.stringify(selected.pack, null, 2) + "\n"
     );
-    if (!existsSync27(manifestPath)) {
-      writeFileSync14(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
+    if (!existsSync26(manifestPath)) {
+      writeFileSync15(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
   } catch {
@@ -5332,17 +5581,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) : join28(process.cwd(), "decantr.essence.json");
-  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join28(process.cwd(), "src", "styles", "treatments.css");
-  if (!existsSync27(resolvedSourcePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join27(process.cwd(), "decantr.essence.json");
+  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join27(process.cwd(), "src", "styles", "treatments.css");
+  if (!existsSync26(resolvedSourcePath)) {
     throw new Error(`Source file not found at ${resolvedSourcePath}`);
   }
-  if (!existsSync27(resolvedEssencePath)) {
+  if (!existsSync26(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const code = readFileSync20(resolvedSourcePath, "utf-8");
-  const essence = JSON.parse(readFileSync20(resolvedEssencePath, "utf-8"));
-  const treatmentsCss = existsSync27(resolvedTreatmentsPath) ? readFileSync20(resolvedTreatmentsPath, "utf-8") : void 0;
+  const code = readFileSync19(resolvedSourcePath, "utf-8");
+  const essence = JSON.parse(readFileSync19(resolvedEssencePath, "utf-8"));
+  const treatmentsCss = existsSync26(resolvedTreatmentsPath) ? readFileSync19(resolvedTreatmentsPath, "utf-8") : void 0;
   const report = await client.critiqueFile(
     {
       essence,
@@ -5366,11 +5615,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) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedEssencePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join27(process.cwd(), "decantr.essence.json");
+  if (!existsSync26(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedEssencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync19(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -5388,7 +5637,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) : join28(process.cwd(), "dist") : "none"}`
+    `  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join27(process.cwd(), "dist") : "none"}`
   );
   console.log(
     `  Source snapshot: ${sources && sourcesPath ? resolveUserPath(sourcesPath) : "none"}`
@@ -5469,7 +5718,7 @@ async function cmdGet(type, id) {
   }
   const apiType = CONTENT_TYPE_TO_API_CONTENT_TYPE3[type];
   const registryClient = new RegistryClient({
-    cacheDir: join28(process.cwd(), ".decantr", "cache")
+    cacheDir: join27(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
@@ -5478,16 +5727,16 @@ async function cmdGet(type, id) {
   }
   const currentDir = dirname4(fileURLToPath2(import.meta.url));
   const bundledCandidates = [
-    join28(currentDir, "bundled", apiType, `${id}.json`),
+    join27(currentDir, "bundled", apiType, `${id}.json`),
     // Running from src/
-    join28(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
+    join27(currentDir, "..", "src", "bundled", apiType, `${id}.json`),
     // Running from dist/
-    join28(currentDir, "..", "bundled", apiType, `${id}.json`)
+    join27(currentDir, "..", "bundled", apiType, `${id}.json`)
     // Alternative dist layout
   ];
-  const bundledPath = bundledCandidates.find((p) => existsSync27(p)) || null;
+  const bundledPath = bundledCandidates.find((p) => existsSync26(p)) || null;
   if (bundledPath) {
-    const data = JSON.parse(readFileSync20(bundledPath, "utf-8"));
+    const data = JSON.parse(readFileSync19(bundledPath, "utf-8"));
     console.log(JSON.stringify(data, null, 2));
     return;
   }
@@ -5496,10 +5745,10 @@ async function cmdGet(type, id) {
   return;
 }
 async function cmdValidate(path) {
-  const essencePath = path || join28(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join27(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync20(essencePath, "utf-8");
+    raw = readFileSync19(essencePath, "utf-8");
   } catch {
     console.error(error3(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -5513,7 +5762,7 @@ async function cmdValidate(path) {
     process.exitCode = 1;
     return;
   }
-  const detectedVersion = isV36(essence) ? "v3" : "v2";
+  const detectedVersion = isV37(essence) ? "v3" : "v2";
   console.log(`${DIM13}Detected essence version: ${detectedVersion}${RESET13}`);
   const result = validateEssence2(essence);
   if (result.valid) {
@@ -5568,7 +5817,7 @@ async function cmdList(type, sort, recommended, intelligenceSource) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join28(process.cwd(), ".decantr", "cache")
+    cacheDir: join27(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(
     type,
@@ -5614,6 +5863,176 @@ async function cmdList(type, sort, recommended, intelligenceSource) {
     }
   }
 }
+function readCliPackageVersion() {
+  const here = dirname4(fileURLToPath2(import.meta.url));
+  const candidates = [join27(here, "..", "package.json"), join27(here, "..", "..", "package.json")];
+  for (const candidate of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync19(candidate, "utf-8"));
+      if (pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+function timestampForFile() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function backupExistingEssence(projectRoot, label) {
+  const essencePath = join27(projectRoot, "decantr.essence.json");
+  if (!existsSync26(essencePath)) return null;
+  const backupPath = join27(projectRoot, `decantr.essence.${label}.${timestampForFile()}.backup.json`);
+  writeFileSync15(backupPath, readFileSync19(essencePath, "utf-8"), "utf-8");
+  return backupPath;
+}
+function writeBrownfieldProjectJson(input) {
+  const decantrDir = join27(input.projectRoot, ".decantr");
+  mkdirSync12(join27(decantrDir, "context"), { recursive: true });
+  mkdirSync12(join27(decantrDir, "cache"), { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const projectJson = {
+    detected: {
+      framework: input.detected.framework,
+      version: input.detected.version || null,
+      packageManager: input.detected.packageManager,
+      hasTypeScript: input.detected.hasTypeScript,
+      hasTailwind: input.detected.hasTailwind,
+      existingRuleFiles: input.detected.existingRuleFiles,
+      workspaceRoot: input.workspaceInfo.workspaceRoot,
+      appRoot: input.workspaceInfo.appRoot
+    },
+    sync: {
+      status: "needs-sync",
+      lastSync: now,
+      registrySource: "cache",
+      cachedContent: {
+        archetypes: [],
+        patterns: [],
+        themes: []
+      }
+    },
+    initialized: {
+      at: now,
+      via: "cli",
+      version: readCliPackageVersion(),
+      flags: `--existing --${input.mode === "replace" ? "replace-essence" : input.mode === "merge" ? "merge-proposal" : "accept-proposal"}`,
+      workflowMode: "brownfield-attach",
+      adoptionMode: "contract-only",
+      contentSource: "none",
+      assistantBridge: input.assistantBridge,
+      projectScope: input.workspaceInfo.projectScope,
+      adapterId: null,
+      analysisArtifacts: true,
+      acceptedProposal: {
+        mode: input.mode,
+        path: ".decantr/observed-essence.proposal.json"
+      }
+    }
+  };
+  writeFileSync15(join27(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
+}
+async function applyAcceptedBrownfieldProposal(input) {
+  const proposal = readBrownfieldProposal(input.projectRoot);
+  if (!proposal) {
+    console.log(error3(`No observed brownfield proposal found at ${proposalPath(input.projectRoot)}.`));
+    console.log(dim3("Run `decantr analyze` first, review `.decantr/brownfield-report.md`, then accept or merge the proposal."));
+    process.exitCode = 1;
+    return;
+  }
+  const essencePath = join27(input.projectRoot, "decantr.essence.json");
+  const hasEssence = existsSync26(essencePath);
+  let essence;
+  let backupPath = null;
+  if (input.mode === "accept" && hasEssence) {
+    console.log(error3("Refusing to accept proposal over an existing decantr.essence.json."));
+    console.log(dim3("Use `--merge-proposal` to preserve the existing contract or `--replace-essence` for an explicit destructive replacement."));
+    process.exitCode = 1;
+    return;
+  }
+  if (input.mode === "merge" && hasEssence) {
+    const existing = JSON.parse(readFileSync19(essencePath, "utf-8"));
+    if (!isV37(existing)) {
+      console.log(error3("Existing essence is not v3. Run `decantr migrate` before merging a brownfield proposal."));
+      process.exitCode = 1;
+      return;
+    }
+    essence = mergeEssenceWithProposal(existing, proposal);
+  } else {
+    essence = proposal.essence;
+  }
+  const validation = validateEssence2(essence);
+  if (!validation.valid) {
+    console.log(error3("Brownfield proposal produced an invalid Decantr essence. No files were changed."));
+    for (const validationError of validation.errors) {
+      console.log(`  ${RED11}${validationError}${RESET13}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  if (input.mode === "merge" && hasEssence) {
+    backupPath = backupExistingEssence(input.projectRoot, "merge");
+  } else if (input.mode === "replace" && hasEssence) {
+    backupPath = backupExistingEssence(input.projectRoot, "replace");
+  }
+  writeBrownfieldProjectJson({
+    projectRoot: input.projectRoot,
+    detected: input.detected,
+    workspaceInfo: input.workspaceInfo,
+    assistantBridge: input.assistantBridge,
+    mode: input.mode
+  });
+  writeFileSync15(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
+  const registryClient = new RegistryClient({
+    cacheDir: join27(input.projectRoot, ".decantr", "cache"),
+    offline: true,
+    projectRoot: input.projectRoot
+  });
+  const refreshResult = await refreshDerivedFiles(input.projectRoot, essence, registryClient, void 0, {
+    isInitialScaffold: true,
+    workflowMode: "brownfield-attach",
+    adoptionMode: "contract-only",
+    analysisArtifacts: true
+  });
+  let assistantBridgePath = null;
+  if (input.assistantBridge === "preview" || input.assistantBridge === "apply") {
+    assistantBridgePath = writeAssistantBridgePreview({
+      projectRoot: input.projectRoot,
+      detected: input.detected,
+      workflowMode: "brownfield-attach",
+      assistantBridge: input.assistantBridge
+    });
+  }
+  const appliedRuleFiles = input.assistantBridge === "apply" ? applyAssistantBridge(input.projectRoot, input.detected) : [];
+  console.log(success3("\nBrownfield proposal accepted.\n"));
+  console.log("  Files created/updated:");
+  console.log(`    ${cyan3("decantr.essence.json")}    Observed brownfield contract`);
+  console.log(`    ${cyan3("DECANTR.md")}              Reconciled assistant guidance`);
+  console.log(`    ${cyan3(".decantr/project.json")}  Brownfield attach metadata`);
+  console.log(`    ${cyan3(".decantr/context/")}      Generated contract context`);
+  if (assistantBridgePath) {
+    console.log(`    ${cyan3(".decantr/context/assistant-bridge.md")} Assistant bridge preview`);
+  }
+  if (appliedRuleFiles.length > 0) {
+    console.log(`    ${dim3(`Rule bridge applied: ${appliedRuleFiles.join(", ")}`)}`);
+  }
+  if (backupPath) {
+    console.log(`    ${dim3(`Backup: ${backupPath}`)}`);
+  }
+  console.log("");
+  console.log("  Generated context:");
+  for (const contextFile of refreshResult.contextFiles.slice(0, 8)) {
+    console.log(`    ${dim3(contextFile.replace(`${input.projectRoot}/`, ""))}`);
+  }
+  if (refreshResult.contextFiles.length > 8) {
+    console.log(`    ${dim3(`(+${refreshResult.contextFiles.length - 8} more)`)}`);
+  }
+  console.log("");
+  console.log("  Next steps:");
+  console.log(`    1. Run ${cyan3("decantr check --brownfield")} to verify contract coverage`);
+  console.log(`    2. Read ${cyan3(".decantr/brownfield-report.md")} for unresolved doctrine risks`);
+  console.log(`    3. Use ${cyan3("decantr rules preview")} before mutating assistant rule files`);
+  console.log("");
+}
 async function cmdInit(args) {
   const workspaceInfo = resolveWorkspaceInfo(process.cwd(), args.project);
   if (args.yes && workspaceInfo.requiresProjectSelection) {
@@ -5654,6 +6073,37 @@ async function cmdInit(args) {
     offline: args.offline,
     projectScope: workspaceInfo.projectScope
   });
+  const proposalMode = args["replace-essence"] ? "replace" : args["merge-proposal"] ? "merge" : args["accept-proposal"] ? "accept" : null;
+  if (proposalMode) {
+    await applyAcceptedBrownfieldProposal({
+      projectRoot,
+      detected,
+      workspaceInfo,
+      mode: proposalMode,
+      assistantBridge: policy.assistantBridge
+    });
+    return;
+  }
+  if (policy.workflowMode === "brownfield-attach" && detected.existingEssence) {
+    console.log(error3("Refusing to overwrite existing decantr.essence.json in brownfield attach mode."));
+    console.log(
+      dim3(
+        "Run `decantr analyze`, then use `decantr init --existing --merge-proposal` or the explicit destructive `--replace-essence`."
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (policy.workflowMode === "brownfield-attach" && readBrownfieldProposal(projectRoot)) {
+    console.log(error3("Observed brownfield proposal found, but it was not accepted."));
+    console.log(
+      dim3(
+        "Review `.decantr/brownfield-report.md`, then run `decantr init --existing --accept-proposal`."
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
   const preferContractOnly = policy.contentSource === "none" && (policy.workflowMode === "brownfield-attach" || policy.workflowMode === "greenfield-contract-only");
   const shouldUseRegistry = !preferContractOnly || policy.registryRequired;
   let offlineSeed = {
@@ -5678,7 +6128,7 @@ async function cmdInit(args) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join28(projectRoot, ".decantr", "cache"),
+    cacheDir: join27(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline,
     projectRoot
@@ -6005,7 +6455,7 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
   if (appliedRuleFiles.length > 0) {
     console.log(`    ${dim3(`Rule bridge applied: ${appliedRuleFiles.join(", ")}`)}`);
   }
-  if (!existsSync27(join28(projectRoot, "package.json"))) {
+  if (!existsSync26(join27(projectRoot, "package.json"))) {
     console.log("");
     console.log(
       dim3(`  Note: ${cyan3("decantr init")} created Decantr contract/context files only.`)
@@ -6036,7 +6486,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 = readFileSync20(result.essencePath, "utf-8");
+  const essenceContent = readFileSync19(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   if (essence.version !== "3.1.0") {
     const validation = validateEssence2(essence);
@@ -6047,7 +6497,7 @@ Validation warnings: ${validation.errors.join(", ")}`));
   }
   console.log("");
   let promptPages;
-  if (isV36(essence)) {
+  if (isV37(essence)) {
     const allPages = essence.blueprint.sections ? essence.blueprint.sections.flatMap(
       (s) => s.pages.map((p) => ({ ...p, _sectionId: s.id, _shell: s.shell }))
     ) : essence.blueprint.pages || [];
@@ -6093,25 +6543,25 @@ Validation warnings: ${validation.errors.join(", ")}`));
 }
 async function cmdStatus() {
   const projectRoot = process.cwd();
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join28(projectRoot, ".decantr", "project.json");
+  const essencePath = join27(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join27(projectRoot, ".decantr", "project.json");
   console.log(heading2("Decantr Project Status"));
-  if (!existsSync27(essencePath)) {
+  if (!existsSync26(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(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync19(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
-    const essenceVersion = isV36(essence) ? "v3" : "v2";
+    const essenceVersion = isV37(essence) ? "v3" : "v2";
     console.log(`${BOLD6}Essence:${RESET13}`);
     if (validation.valid) {
       console.log(`  ${GREEN13}Valid${RESET13} (${essenceVersion})`);
     } else {
       console.log(`  ${RED11}Invalid: ${validation.errors.join(", ")}${RESET13}`);
     }
-    if (isV36(essence)) {
+    if (isV37(essence)) {
       const v3 = essence;
       const sections = v3.blueprint.sections ?? [];
       const flatPages = sections.length > 0 ? sections.flatMap((section) => section.pages ?? []) : v3.blueprint.pages ?? [];
@@ -6159,9 +6609,9 @@ async function cmdStatus() {
   }
   console.log("");
   console.log(`${BOLD6}Sync Status:${RESET13}`);
-  if (existsSync27(projectJsonPath)) {
+  if (existsSync26(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync20(projectJsonPath, "utf-8"));
+      const projectJson = JSON.parse(readFileSync19(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
@@ -6179,7 +6629,7 @@ async function cmdStatus() {
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join28(projectRoot, ".decantr", "cache");
+  const cacheDir = join27(projectRoot, ".decantr", "cache");
   console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
@@ -6374,14 +6824,14 @@ ${BOLD6}Examples:${RESET13}
         process.exitCode = 1;
         return;
       }
-      const themePath = join28(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync27(themePath)) {
+      const themePath = join27(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync26(themePath)) {
         console.error(error3(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync20(themePath, "utf-8"));
+        const theme = JSON.parse(readFileSync19(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
           console.log(success3(`Custom theme "${name}" is valid`));
@@ -6462,6 +6912,7 @@ ${BOLD6}Usage:${RESET13}
   decantr audit [file]
   decantr migrate
   decantr check
+  decantr check --brownfield
   decantr sync-drift
   decantr search <query> [--type <type>] [--sort <recommended|recent|name>] [--recommended] [--source <authored|benchmark|hybrid>]
   decantr suggest <query> [--type <type>]
@@ -6473,6 +6924,7 @@ ${BOLD6}Usage:${RESET13}
   decantr registry get-pack <manifest|scaffold|review|section|page|mutation> [id] [--namespace <namespace>] [--json] [--essence <path>] [--write-context]
   decantr registry critique-file <file> [--namespace <namespace>] [--json] [--essence <path>] [--treatments <path>]
   decantr registry audit-project [--namespace <namespace>] [--json] [--essence <path>] [--dist <path>] [--sources <dir>]
+  decantr rules preview [--project=<path>]
   decantr rules apply [--project=<path>]
   decantr validate [path]
   decantr theme <subcommand>
@@ -6488,13 +6940,16 @@ ${BOLD6}Init Options:${RESET13}
   --theme            Theme ID
   --mode             Color mode: dark | light | auto
   --shape            Border shape: pill | rounded | sharp
-  --target           Framework: react | vue | svelte | nextjs | html
+  --target           Framework: react | vue | svelte | angular | nextjs | nuxt | astro | html
   --guard            Guard mode: creative | guided | strict
   --density          Spacing: compact | comfortable | spacious
   --shell            Default shell layout
   --workflow         Workflow: greenfield | brownfield | hybrid
   --adoption         Adoption: contract-only | style-bridge | decantr-css
   --assistant-bridge Assistant rules: none | preview | apply
+  --accept-proposal  Brownfield: accept observed proposal when no essence exists
+  --merge-proposal   Brownfield: merge observed proposal into an existing essence
+  --replace-essence  Brownfield: explicit destructive proposal replacement with backup
   --project          App path inside a workspace/monorepo
   --existing         Initialize in existing project
   --offline          Force offline mode
@@ -6509,7 +6964,7 @@ ${BOLD6}Commands:${RESET13}
   ${cyan3("sync")}        Sync registry content from API
   ${cyan3("audit")}       Audit the project or critique a specific file against compiled packs
   ${cyan3("migrate")}     Migrate v2 essence to v3 format (with .v2.backup.json backup)
-  ${cyan3("check")}       Detect drift issues (validate + guard rules) [--telemetry]
+  ${cyan3("check")}       Detect drift issues (validate + guard rules) [--telemetry] [--brownfield]
   ${cyan3("sync-drift")}  Review and resolve drift log entries
   ${cyan3("search")}      Search the registry
   ${cyan3("suggest")}     Suggest patterns or alternatives for a query
@@ -6533,16 +6988,19 @@ ${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 --existing --adoption=contract-only --yes
+  decantr analyze
+  decantr init --existing --accept-proposal
+  decantr init --existing --merge-proposal
   decantr init --existing --adoption=style-bridge --assistant-bridge=preview
   decantr init --workflow=greenfield --adoption=contract-only
   decantr init --project=apps/web --yes
+  decantr rules preview
   decantr rules apply
   decantr status
   decantr audit
   decantr audit src/pages/HomePage.tsx
   decantr migrate
-  decantr check
+  decantr check --brownfield
   decantr sync-drift
   decantr search dashboard
   decantr suggest leaderboard
@@ -6562,7 +7020,7 @@ ${BOLD6}Examples:${RESET13}
 ${BOLD6}Workflow Model:${RESET13}
   ${cyan3("Greenfield blueprint")}   decantr new my-app --blueprint=X --workflow=greenfield --adoption=decantr-css
   ${cyan3("Greenfield contract")}    decantr init --workflow=greenfield --adoption=contract-only
-  ${cyan3("Brownfield adoption")}    decantr analyze -> decantr init --existing --adoption=contract-only
+  ${cyan3("Brownfield adoption")}    decantr analyze -> decantr init --existing --accept-proposal -> decantr check --brownfield
   ${cyan3("Hybrid composition")}     decantr add/remove, decantr theme switch, decantr registry, decantr upgrade
 
 ${BOLD6}Bootstrap adapters:${RESET13}
@@ -6570,6 +7028,24 @@ ${BOLD6}Bootstrap adapters:${RESET13}
   Unsupported targets resolve through ${cyan3("generic-web")} contract-only mode until their starter adapters land.
 `);
 }
+function cmdRulesHelp() {
+  console.log(`
+${BOLD6}decantr rules${RESET13} \u2014 Preview or apply assistant bridge snippets
+
+${BOLD6}Usage:${RESET13}
+  decantr rules preview [--project=<path>]
+  decantr rules apply [--project=<path>]
+
+${BOLD6}Subcommands:${RESET13}
+  ${cyan3("preview")}  Print target-specific Decantr bridge guidance without mutating rule files
+  ${cyan3("apply")}    Idempotently write Decantr bridge blocks to supported assistant rule files
+
+${BOLD6}Examples:${RESET13}
+  decantr rules preview
+  decantr rules preview --project=apps/web
+  decantr rules apply --project=apps/web
+`);
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -6581,12 +7057,12 @@ async function main() {
     try {
       const here = dirname4(fileURLToPath2(import.meta.url));
       const candidates = [
-        join28(here, "..", "package.json"),
-        join28(here, "..", "..", "package.json")
+        join27(here, "..", "package.json"),
+        join27(here, "..", "..", "package.json")
       ];
       for (const candidate of candidates) {
-        if (existsSync27(candidate)) {
-          const pkg = JSON.parse(readFileSync20(candidate, "utf-8"));
+        if (existsSync26(candidate)) {
+          const pkg = JSON.parse(readFileSync19(candidate, "utf-8"));
           if (pkg.version) {
             console.log(pkg.version);
             return;
@@ -6650,6 +7126,12 @@ async function main() {
           initArgs.offline = true;
         } else if (arg === "--existing") {
           initArgs.existing = true;
+        } else if (arg === "--accept-proposal") {
+          initArgs["accept-proposal"] = true;
+        } else if (arg === "--merge-proposal") {
+          initArgs["merge-proposal"] = true;
+        } else if (arg === "--replace-essence") {
+          initArgs["replace-essence"] = true;
         } else if (arg.startsWith("--")) {
           const [key, value] = arg.slice(2).split("=");
           if (value) {
@@ -6675,7 +7157,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-XMY6LIPS.js");
+      const { cmdUpgrade } = await import("./upgrade-EV23CKA3.js");
       const applyFlag = args.includes("--apply");
       await cmdUpgrade(process.cwd(), { apply: applyFlag });
       break;
@@ -6687,9 +7169,10 @@ async function main() {
           `${YELLOW9}Note: \`decantr heal\` is deprecated. Use \`decantr check\` instead.${RESET13}`
         );
       }
-      const { cmdHeal } = await import("./heal-SWUFIYU5.js");
+      const { cmdHeal } = await import("./heal-YHLXO5QL.js");
       const telemetryFlag = args.includes("--telemetry");
-      await cmdHeal(process.cwd(), { telemetry: telemetryFlag });
+      const brownfieldFlag = args.includes("--brownfield");
+      await cmdHeal(process.cwd(), { telemetry: telemetryFlag, brownfield: brownfieldFlag });
       break;
     }
     case "migrate": {
@@ -7087,8 +7570,12 @@ async function main() {
     }
     case "rules": {
       const subcommand = args[1];
-      if (subcommand !== "apply") {
-        console.error(error3("Usage: decantr rules apply [--project=<path>]"));
+      if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        cmdRulesHelp();
+        break;
+      }
+      if (subcommand !== "apply" && subcommand !== "preview") {
+        console.error(error3("Usage: decantr rules <preview|apply> [--project=<path>]"));
         process.exitCode = 1;
         break;
       }
@@ -7102,6 +7589,16 @@ async function main() {
       }
       const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
       const detected = detectProject(workspaceInfo.appRoot);
+      if (subcommand === "preview") {
+        console.log(
+          buildAssistantBridgeContent({
+            detected,
+            workflowMode: "brownfield-attach",
+            assistantBridge: "preview"
+          })
+        );
+        break;
+      }
       const updated = applyAssistantBridge(workspaceInfo.appRoot, detected);
       if (updated.length === 0) {
         console.log(dim3("Assistant bridge rule files are already up to date."));