@decantr/cli 2.11.0 → 2.13.0

package/dist/{chunk-ET4BG746.js → chunk-5MZH6XXQ.js}

@@ -14,7 +14,7 @@ import {
   scaffoldProject,
   syncRegistry,
   writeExecutionPackBundleArtifacts
-} from "./chunk-IQZCIMQJ.js";
+} from "./chunk-SIDKK73N.js";
 import {
   createWorkspaceHealthReport,
   formatWorkspaceHealthMarkdown,
@@ -22,14 +22,14 @@ import {
   listWorkspaceCandidates,
   listWorkspaceProjects,
   shouldFailWorkspaceHealth
-} from "./chunk-NUNUW5IS.js";
+} from "./chunk-YBSBAJ3E.js";
 import {
   createProjectHealthReport,
   formatProjectHealthMarkdown,
   formatProjectHealthText,
   resolveWorkspaceInfo,
   shouldFailHealth
-} from "./chunk-5WPRTVNA.js";
+} from "./chunk-3A2DLR47.js";
 import {
   buildGuardRegistryContext,
   createDoctrineMap,
@@ -46,11 +46,11 @@ import {
   sendCliCommandTelemetry,
   sendNewProjectCompletedTelemetry,
   writeDoctrineMap
-} from "./chunk-4SZ4SEKT.js";
+} from "./chunk-MNZKOZW7.js";
 
 // src/index.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readdirSync as readdirSync9, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute3, join as join31, relative as relative7, resolve as resolve4 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync17, readdirSync as readdirSync9, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "fs";
+import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute3, join as join32, relative as relative7, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { evaluateGuard, isV4 as isV49, validateEssence as validateEssence2 } from "@decantr/essence-spec";
 import {
@@ -68,7 +68,8 @@ import {
 } from "@decantr/registry";
 import {
   auditProject,
-  critiqueFile as critiqueProjectFile
+  critiqueFile as critiqueProjectFile,
+  scanProject as scanProjectReadOnly
 } from "@decantr/verifier";
 
 // src/artifacts.ts
@@ -88,6 +89,7 @@ Commit these when they exist:
 - \`.decantr/project.json\` - workflow, adoption mode, detection, and initialization metadata.
 - \`.decantr/local-patterns.json\` - project-owned Brownfield UI patterns accepted by the team.
 - \`.decantr/rules.json\` - project-owned mechanical rules accepted by the team.
+- \`.decantr/style-bridge.json\` - accepted Hybrid style bridge from Decantr intent to project tokens/classes.
 
 ## Generated Context
 
@@ -3233,8 +3235,8 @@ ${YELLOW2}Next step:${RESET2} Review ${BOLD}${reportDisplayPath}${RESET2}, then
 }
 
 // src/commands/ci.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname3, join as join16, relative as relative4, resolve } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname3, join as join17, relative as relative4, resolve } from "path";
 
 // src/local-law.ts
 import { execFileSync } from "child_process";
@@ -3326,6 +3328,22 @@ function createBrownfieldCodifyProposal(input) {
         componentPaths: evidence.buttonComponents,
         decide: "Define primary, secondary, tertiary, destructive, icon-only, disabled, and loading button variants from this app.",
         classHints: evidence.buttonClassHints,
+        variants: evidence.buttonVariants,
+        sourceEvidence: evidence.buttonSourceEvidence,
+        confidence: confidenceForEvidence({
+          componentCount: evidence.buttonComponents.length,
+          classHintCount: evidence.buttonClassHints.length,
+          variantCount: evidence.buttonVariants.length,
+          sourceEvidenceCount: evidence.buttonSourceEvidence.length
+        }),
+        enforcement: {
+          level: "warn",
+          status: "proposal",
+          notes: [
+            "Treat as advisory until the team confirms variant names and wrapper paths.",
+            "Raise related rules to error only after raw button usage can be fixed without churn."
+          ]
+        },
         evidence: evidence.buttonComponents.length ? evidence.buttonComponents : evidence.buttonClassHints.length ? evidence.buttonClassHints : [
           "No obvious Button wrapper found yet. Add the project-owned wrapper path before strict enforcement."
         ],
@@ -3339,6 +3357,22 @@ function createBrownfieldCodifyProposal(input) {
         componentPaths: evidence.cardComponents,
         decide: "Define the canonical card background, border, radius, shadow, padding, density, and hover treatment.",
         classHints: evidence.cardClassHints,
+        variants: evidence.cardVariants,
+        sourceEvidence: evidence.cardSourceEvidence,
+        confidence: confidenceForEvidence({
+          componentCount: evidence.cardComponents.length,
+          classHintCount: evidence.cardClassHints.length,
+          variantCount: evidence.cardVariants.length,
+          sourceEvidenceCount: evidence.cardSourceEvidence.length
+        }),
+        enforcement: {
+          level: "warn",
+          status: "proposal",
+          notes: [
+            "Use this family to converge repeated surface recipes before enforcing card rules.",
+            "Document route-specific card exceptions before asking CI to block them."
+          ]
+        },
         evidence: evidence.cardComponents.length ? evidence.cardComponents : [
           "No obvious Card wrapper found yet. Add the project-owned wrapper path or class recipe."
         ],
@@ -3351,6 +3385,24 @@ function createBrownfieldCodifyProposal(input) {
         appliesTo: ["routes", "layouts", "navigation shells", "scroll containers"],
         componentPaths: evidence.shellComponents,
         decide: "Define which layout owns max width, gutters, sticky chrome, responsive breakpoints, and scroll containers.",
+        sourceEvidence: collectSourceEvidence(input.projectRoot, sourceFiles, [
+          "layout",
+          "shell",
+          "nav",
+          "sidebar",
+          "container"
+        ]),
+        confidence: confidenceForEvidence({
+          componentCount: evidence.shellComponents.length,
+          sourceEvidenceCount: evidence.shellComponents.length
+        }),
+        enforcement: {
+          level: "advisory",
+          status: "proposal",
+          notes: [
+            "Layout ownership is usually reviewed by humans first because route shells can legitimately differ."
+          ]
+        },
         evidence: evidence.shellComponents.length ? evidence.shellComponents : ["Add root layout, shell, or app frame files that establish route chrome and spacing."],
         forbiddenAlternatives: [
           "Each page inventing independent max-width, padding, or sticky nav rules."
@@ -3363,6 +3415,20 @@ function createBrownfieldCodifyProposal(input) {
         appliesTo: ["inputs", "selects", "textareas", "validation messages", "form actions"],
         componentPaths: evidence.formComponents,
         decide: "Define input height, label placement, error copy, disabled state, required state, and focus treatment.",
+        variants: evidence.formVariants,
+        sourceEvidence: evidence.formSourceEvidence,
+        confidence: confidenceForEvidence({
+          componentCount: evidence.formComponents.length,
+          variantCount: evidence.formVariants.length,
+          sourceEvidenceCount: evidence.formSourceEvidence.length
+        }),
+        enforcement: {
+          level: "warn",
+          status: "proposal",
+          notes: [
+            "Start by mapping field wrappers, labels, error states, and disabled states from source."
+          ]
+        },
         evidence: evidence.formComponents.length ? evidence.formComponents : ["Add form field wrapper paths and validation examples."],
         forbiddenAlternatives: [
           "Unlabeled one-off inputs or validation states that do not match the app standard."
@@ -3375,6 +3441,20 @@ function createBrownfieldCodifyProposal(input) {
         appliesTo: ["theme toggles", "mode-specific classes", "brand variants", "tenant variants"],
         componentPaths: evidence.themeComponents,
         decide: "Document which theme variants exist, where they are toggled, and which tokens/classes are legal per variant.",
+        variants: evidence.themeVariants,
+        sourceEvidence: evidence.themeSourceEvidence,
+        confidence: confidenceForEvidence({
+          componentCount: evidence.themeComponents.length,
+          variantCount: evidence.themeVariants.length,
+          sourceEvidenceCount: evidence.themeSourceEvidence.length
+        }),
+        enforcement: {
+          level: "advisory",
+          status: "proposal",
+          notes: [
+            "Theme variant law should preserve the existing theme provider/tokens before adding any new mode."
+          ]
+        },
         evidence: evidence.themeComponents.length ? evidence.themeComponents : ["If the app has dark/light or brand variants, add the toggles/providers here."],
         forbiddenAlternatives: [
           "Component-local theme forks that bypass shared theme providers or tokens."
@@ -3466,6 +3546,107 @@ function writeBrownfieldCodifyProposal(projectRoot, proposal) {
 `, "utf-8");
   return { patternPath, rulesPath };
 }
+function writeHostedPatternMappingProposal(input) {
+  const decantrDir = join15(input.projectRoot, ".decantr");
+  mkdirSync8(decantrDir, { recursive: true });
+  const existing = readJsonFile(localPatternsProposalPath(input.projectRoot)) ?? readJsonFile(localPatternsPath(input.projectRoot));
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const patternPack = {
+    version: 2,
+    generatedAt,
+    status: "proposal",
+    source: "decantr codify --map-pattern",
+    purpose: existing?.purpose ?? "Project-owned Brownfield/Hybrid UI law. Review and edit before accepting; Decantr treats this as authoritative only after it is copied to .decantr/local-patterns.json.",
+    hybrid: existing?.hybrid ?? {
+      intent: "This local pattern pack maps Decantr concepts onto project-owned components, tokens, classes, and rules without replacing the app runtime.",
+      authorityPrecedence: [
+        "existing production source",
+        "accepted local patterns and rules",
+        "Decantr Essence V4 contract",
+        "hosted registry patterns and execution packs as optional guidance"
+      ],
+      hostedPatternMapping: "Hosted registry patterns are advisory until mapped to project-owned component paths, token recipes, class recipes, and explicit exceptions."
+    },
+    patterns: Array.isArray(existing?.patterns) ? [...existing.patterns] : [],
+    starterRules: Array.isArray(existing?.starterRules) ? existing.starterRules : [],
+    nextSteps: Array.isArray(existing?.nextSteps) ? existing.nextSteps : [
+      "Review this proposal with the team.",
+      "Add project-owned component paths, token hints, class recipes, and exceptions.",
+      "Run decantr codify --accept after review.",
+      "Use decantr task <route> before LLM edits so local law appears in task context."
+    ]
+  };
+  const slug = input.hostedPattern.slug.trim();
+  const existingIds = new Set(
+    (patternPack.patterns ?? []).map((pattern) => typeof pattern.id === "string" ? pattern.id : "").filter(Boolean)
+  );
+  const localPatternId = existingIds.has(slug) ? `${slug}-registry-map` : slug;
+  const mappedPattern = {
+    id: localPatternId,
+    label: input.hostedPattern.name ? `${input.hostedPattern.name} registry mapping` : `${slug} registry mapping`,
+    role: "Hosted registry guidance mapped into project-owned Hybrid law",
+    appliesTo: [
+      ...input.hostedPattern.components ?? [],
+      ...input.hostedPattern.interactions ?? [],
+      ...input.hostedPattern.tags ?? []
+    ].slice(0, 24),
+    componentPaths: [],
+    tokenHints: [],
+    classHints: [],
+    decide: `Map hosted pattern "${slug}" into this app's existing components, tokens, classes, and exceptions before treating it as enforceable.`,
+    hostedPatternRefs: [input.hostedPattern],
+    confidence: {
+      tier: "low",
+      score: 0.25,
+      rationale: [
+        "A hosted registry pattern was selected intentionally.",
+        "No project-owned component path or token recipe has been mapped yet."
+      ]
+    },
+    enforcement: {
+      level: "advisory",
+      status: "needs-mapping",
+      notes: [
+        "This proposal does not change source files.",
+        "Do not enforce this hosted pattern until project-owned implementation details are filled in.",
+        "Use accepted local rules, ESLint, Biome, Storybook, or visual regression for deterministic blocking checks."
+      ]
+    },
+    evidence: [
+      `Hosted pattern ${input.hostedPattern.source}/${slug}${input.hostedPattern.description ? `: ${input.hostedPattern.description}` : ""}`,
+      input.hostedPattern.visualBrief ? `Visual brief: ${input.hostedPattern.visualBrief}` : "Visual brief not provided by the hosted pattern."
+    ],
+    evidenceToCollect: [
+      "Project-owned component path(s) that implement this pattern.",
+      "Allowed token/class recipe(s) for this app.",
+      "Variant names and states that are legal in this project.",
+      "Explicit exceptions where this hosted pattern should not apply."
+    ],
+    forbiddenAlternatives: [
+      "Replacing existing app components solely because a hosted pattern exists.",
+      "Treating hosted registry guidance as enforceable without accepted local law."
+    ]
+  };
+  const index = (patternPack.patterns ?? []).findIndex((pattern) => pattern.id === localPatternId);
+  const replacedExisting = index >= 0;
+  if (replacedExisting) {
+    patternPack.patterns[index] = mappedPattern;
+  } else {
+    patternPack.patterns = [...patternPack.patterns ?? [], mappedPattern];
+  }
+  patternPack.nextSteps = [
+    .../* @__PURE__ */ new Set([
+      ...patternPack.nextSteps ?? [],
+      "Fill the hosted mapping with project-owned component paths, token/class recipes, variants, and exceptions.",
+      "Run decantr codify --accept only after the mapping reflects the existing app.",
+      "Use decantr verify --brownfield --local-patterns after edits to keep mapped local law visible."
+    ])
+  ];
+  const patternPath = localPatternsProposalPath(input.projectRoot);
+  writeFileSync9(patternPath, `${JSON.stringify(patternPack, null, 2)}
+`, "utf-8");
+  return { patternPath, localPatternId, replacedExisting };
+}
 function acceptBrownfieldLocalLaw(projectRoot) {
   const patternProposal = readJsonFile(localPatternsProposalPath(projectRoot));
   const ruleProposal = readJsonFile(localRulesProposalPath(projectRoot));
@@ -3508,11 +3689,17 @@ function validateLocalLaw(projectRoot) {
       const paths = Array.isArray(pattern.componentPaths) ? pattern.componentPaths : [];
       const evidence = Array.isArray(pattern.evidence) ? pattern.evidence : [];
       const todoEvidence = Array.isArray(pattern.evidenceToCollect) ? pattern.evidenceToCollect : [];
+      const hostedRefs = Array.isArray(pattern.hostedPatternRefs) ? pattern.hostedPatternRefs : [];
       if (id && paths.length === 0 && evidence.length === 0 && todoEvidence.length > 0) {
         warnings.push(
           `Local pattern ${id} still reads like a TODO; add concrete component paths or evidence.`
         );
       }
+      if (id && hostedRefs.length > 0 && paths.length === 0) {
+        warnings.push(
+          `Local pattern ${id} maps hosted registry guidance but has no project-owned component path yet.`
+        );
+      }
     }
   }
   if (ruleManifest && !Array.isArray(ruleManifest.rules)) {
@@ -3534,7 +3721,10 @@ function createLocalLawTaskSummary(projectRoot) {
   const patterns = (patternPack?.patterns ?? []).map((pattern) => ({
     id: typeof pattern.id === "string" ? pattern.id : "unknown",
     role: typeof pattern.role === "string" ? pattern.role : null,
-    componentPaths: Array.isArray(pattern.componentPaths) ? pattern.componentPaths.filter((entry) => typeof entry === "string") : []
+    componentPaths: Array.isArray(pattern.componentPaths) ? pattern.componentPaths.filter((entry) => typeof entry === "string") : [],
+    confidenceTier: typeof pattern.confidence === "object" && pattern.confidence !== null && typeof pattern.confidence.tier === "string" ? pattern.confidence.tier : null,
+    enforcementLevel: typeof pattern.enforcement === "object" && pattern.enforcement !== null && typeof pattern.enforcement.level === "string" ? pattern.enforcement.level : null,
+    hostedPatternRefs: Array.isArray(pattern.hostedPatternRefs) ? pattern.hostedPatternRefs.map((ref) => typeof ref?.slug === "string" ? ref.slug : null).filter((slug) => Boolean(slug)) : []
   }));
   const rules = (ruleManifest?.rules ?? []).map((rule) => ({
     id: rule.id,
@@ -3652,6 +3842,50 @@ function summarizeSourceEvidence(projectRoot, files) {
     formComponents: byName(["input", "field", "form", "select", "textarea"]),
     shellComponents,
     themeComponents,
+    buttonVariants: detectVariants(projectRoot, files, {
+      family: "button",
+      terms: ["primary", "secondary", "tertiary", "ghost", "link", "destructive", "icon"]
+    }),
+    cardVariants: detectVariants(projectRoot, files, {
+      family: "surface",
+      terms: ["card", "panel", "surface", "tile", "elevated", "interactive", "glass"]
+    }),
+    formVariants: detectVariants(projectRoot, files, {
+      family: "form",
+      terms: ["error", "invalid", "disabled", "required", "success", "helper"]
+    }),
+    themeVariants: detectVariants(projectRoot, files, {
+      family: "theme",
+      terms: ["dark", "light", "brand", "tenant", "theme", "mode", "density"]
+    }),
+    buttonSourceEvidence: collectSourceEvidence(projectRoot, files, [
+      "button",
+      "primary",
+      "secondary",
+      "tertiary",
+      "destructive"
+    ]),
+    cardSourceEvidence: collectSourceEvidence(projectRoot, files, [
+      "card",
+      "panel",
+      "surface",
+      "rounded",
+      "shadow"
+    ]),
+    formSourceEvidence: collectSourceEvidence(projectRoot, files, [
+      "input",
+      "label",
+      "error",
+      "field",
+      "select"
+    ]),
+    themeSourceEvidence: collectSourceEvidence(projectRoot, files, [
+      "theme",
+      "dark",
+      "light",
+      "brand",
+      "tenant"
+    ]),
     buttonClassHints: collectClassHints(projectRoot, files, [
       "button",
       "btn",
@@ -3665,6 +3899,70 @@ function summarizeSourceEvidence(projectRoot, files) {
     cardClassHints: collectClassHints(projectRoot, files, ["card", "panel", "surface", "tile"])
   };
 }
+function detectVariants(projectRoot, files, input) {
+  const variants = /* @__PURE__ */ new Map();
+  const termPattern = new RegExp(
+    `\\b(${input.terms.map(escapeRegExp).join("|")})(?:[-_:][a-z0-9-]+)?\\b`,
+    "gi"
+  );
+  for (const file of files) {
+    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
+    const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
+    for (const match of content.matchAll(termPattern)) {
+      const raw = (match[0] ?? "").toLowerCase();
+      const id = raw.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+      if (!id || id.length < 3) continue;
+      const position = lineColumnAt(content, match.index ?? 0);
+      const line = lineAt(content, position.line).trim().slice(0, 160);
+      const entry = variants.get(id) ?? { evidence: /* @__PURE__ */ new Set(), count: 0 };
+      entry.count += 1;
+      entry.evidence.add(`${file.relative}:${position.line} ${line}`);
+      variants.set(id, entry);
+    }
+  }
+  return [...variants.entries()].sort((a, b) => b[1].count - a[1].count || a[0].localeCompare(b[0])).slice(0, 8).map(([id, value]) => ({
+    id,
+    label: `${input.family} ${id}`,
+    evidence: [...value.evidence].slice(0, 4),
+    confidence: value.count >= 4 ? "high" : value.count >= 2 ? "medium" : "low"
+  }));
+}
+function collectSourceEvidence(projectRoot, files, terms) {
+  const results = [];
+  const termPattern = new RegExp(terms.map(escapeRegExp).join("|"), "i");
+  for (const file of files) {
+    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
+    const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (!termPattern.test(line)) continue;
+      const signals = terms.filter((term) => line.toLowerCase().includes(term.toLowerCase()));
+      results.push({
+        file: file.relative,
+        line: index + 1,
+        excerpt: line.trim().slice(0, 180),
+        signals: signals.slice(0, 6)
+      });
+      if (results.length >= 16) return results;
+      break;
+    }
+  }
+  return results;
+}
+function confidenceForEvidence(input) {
+  const score = Math.min(
+    1,
+    input.componentCount * 0.28 + (input.classHintCount ?? 0) * 0.08 + (input.variantCount ?? 0) * 0.08 + (input.sourceEvidenceCount ?? 0) * 0.05
+  );
+  const tier = score >= 0.7 ? "high" : score >= 0.4 ? "medium" : "low";
+  const rationale = [
+    input.componentCount > 0 ? `${input.componentCount} likely component path(s) detected` : "no likely component wrapper detected yet",
+    (input.classHintCount ?? 0) > 0 ? `${input.classHintCount} class recipe hint(s) detected` : "no strong class recipe hints detected yet",
+    (input.variantCount ?? 0) > 0 ? `${input.variantCount} possible variant signal(s) detected` : "variant names still need team confirmation"
+  ];
+  return { tier, score: Number(score.toFixed(2)), rationale };
+}
 function collectClassHints(projectRoot, files, terms) {
   const hints = /* @__PURE__ */ new Map();
   const wantsButton = terms.some(
@@ -3677,10 +3975,25 @@ function collectClassHints(projectRoot, files, terms) {
     if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
     const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
     if (!terms.some((term) => content.toLowerCase().includes(term))) continue;
+    if (wantsButton) {
+      const openingTags = content.matchAll(
+        /<([A-Za-z][\w.:/-]*)\b[^>]*\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`][^>]*>/g
+      );
+      for (const match of openingTags) {
+        const tag = match[1];
+        const value = match[2].trim();
+        const tagLooksInteractive = /^(button|a|Link)$/i.test(tag) || /(^|\.)(Button|IconButton|LinkButton|Action)$/i.test(tag);
+        const fileLooksInteractive = /button|action|link/i.test(basename2(file.relative));
+        if (!tagLooksInteractive && !fileLooksInteractive) continue;
+        if (!buttonSignal.test(value) && !fileLooksInteractive) continue;
+        hints.set(value, (hints.get(value) ?? 0) + 1);
+      }
+      continue;
+    }
     const matches = content.matchAll(/\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`]/g);
     for (const match of matches) {
       const value = match[1].trim();
-      const keep = wantsButton && buttonSignal.test(value) || wantsSurface && surfaceSignal.test(value) || !wantsButton && !wantsSurface && (buttonSignal.test(value) || surfaceSignal.test(value));
+      const keep = wantsSurface && surfaceSignal.test(value) || !wantsButton && !wantsSurface && (buttonSignal.test(value) || surfaceSignal.test(value));
       if (!keep) continue;
       hints.set(value, (hints.get(value) ?? 0) + 1);
     }
@@ -3744,10 +4057,284 @@ function lineColumnAt(contents, index) {
     column: lines[lines.length - 1].length + 1
   };
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function lineAt(contents, line) {
   return contents.split(/\r?\n/)[line - 1] ?? "";
 }
 
+// src/style-bridge.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { join as join16 } from "path";
+function styleBridgeProposalPath(projectRoot) {
+  return join16(projectRoot, ".decantr", "style-bridge.proposal.json");
+}
+function styleBridgePath(projectRoot) {
+  return join16(projectRoot, ".decantr", "style-bridge.json");
+}
+function readJsonFile2(path) {
+  if (!existsSync14(path)) return null;
+  try {
+    return JSON.parse(readFileSync12(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, value) {
+  writeFileSync10(path, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function readStyleBridge(projectRoot) {
+  return readJsonFile2(styleBridgePath(projectRoot));
+}
+function readStyleBridgeProposal(projectRoot) {
+  return readJsonFile2(styleBridgeProposalPath(projectRoot));
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function readThemeInventory(projectRoot) {
+  const inventory = readJsonFile2(join16(projectRoot, ".decantr", "theme-inventory.json"));
+  return {
+    modes: stringArray(inventory?.modes),
+    variantIds: Array.isArray(inventory?.variants) ? inventory.variants.map((variant) => variant.id).filter((id) => typeof id === "string") : [],
+    darkModeDetected: typeof inventory?.darkModeDetected === "boolean" ? inventory.darkModeDetected : null
+  };
+}
+function tokenHints(styling, terms) {
+  return styling.cssVariables.filter((name) => terms.test(name)).slice(0, 12);
+}
+function readProjectPatternPack(projectRoot) {
+  return readLocalPatternPack(projectRoot) ?? readJsonFile2(
+    join16(projectRoot, ".decantr", "local-patterns.proposal.json")
+  );
+}
+function classHintsForPattern(projectRoot, ids) {
+  const pack = readProjectPatternPack(projectRoot);
+  const classes = /* @__PURE__ */ new Set();
+  for (const pattern of pack?.patterns ?? []) {
+    if (!ids.includes(String(pattern.id))) continue;
+    for (const hint of pattern.classHints ?? []) classes.add(hint);
+  }
+  return [...classes].slice(0, 12);
+}
+function sourceEvidence(projectRoot, ids) {
+  const pack = readProjectPatternPack(projectRoot);
+  const evidence = /* @__PURE__ */ new Set();
+  for (const pattern of pack?.patterns ?? []) {
+    if (!ids.includes(String(pattern.id))) continue;
+    for (const path of pattern.componentPaths ?? []) evidence.add(path);
+    for (const item of pattern.evidence ?? []) evidence.add(item);
+  }
+  return [...evidence].slice(0, 12);
+}
+function colorTokenNames(styling) {
+  const names = new Set(Object.keys(styling.colors ?? {}));
+  for (const variable of styling.cssVariables) {
+    if (/color|bg|background|surface|text|foreground|border|primary|secondary|accent|muted/i.test(variable)) {
+      names.add(variable);
+    }
+  }
+  return [...names].slice(0, 40);
+}
+function createStyleBridgeProposal(input) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const theme = readThemeInventory(input.projectRoot);
+  const routeCount = input.essence && typeof input.essence === "object" && "blueprint" in input.essence ? Object.keys(input.essence.blueprint?.routes ?? {}).length : 0;
+  const target = input.essence && typeof input.essence === "object" && "meta" in input.essence ? String(input.essence.meta?.target ?? "") || null : null;
+  const darkModeDetected = theme.darkModeDetected ?? input.styling.darkMode;
+  const themeModes = theme.modes.length > 0 ? theme.modes : darkModeDetected ? ["base", "dark"] : ["base"];
+  const themeVariantIds = theme.variantIds.length > 0 ? theme.variantIds : themeModes.filter((mode) => mode !== "base");
+  return {
+    version: 1,
+    status: "proposal",
+    generatedAt,
+    source: "decantr codify --style-bridge",
+    purpose: "Project-owned Hybrid style bridge. It maps Decantr design intent to the existing app styling system without installing Decantr CSS or taking over source.",
+    adoption: {
+      mode: "style-bridge",
+      workflowMode: "brownfield-attach",
+      sourceAuthority: "Existing production source stays authoritative.",
+      styleAuthority: "Use these mappings to translate Decantr concepts into project-owned tokens, classes, and components.",
+      notRuntimeTakeover: true,
+      authorityPrecedence: [
+        "existing production source",
+        "accepted style bridge",
+        "accepted local patterns and rules",
+        "Essence V4 contract",
+        "hosted registry patterns and execution packs as optional guidance"
+      ]
+    },
+    project: {
+      framework: input.detected.framework,
+      packageManager: input.detected.packageManager,
+      target,
+      routeCount
+    },
+    styling: {
+      approach: input.styling.approach,
+      configFile: input.styling.configFile ?? null,
+      darkModeDetected,
+      cssVariables: input.styling.cssVariables.slice(0, 80),
+      colorTokenNames: colorTokenNames(input.styling),
+      themeModes,
+      themeVariantIds
+    },
+    mappings: [
+      {
+        id: "surface",
+        label: "Surfaces and cards",
+        decantrIntent: "surface background, card treatment, border, radius, depth, and hover state",
+        projectAuthority: "Use the app card/surface primitives, tokens, and accepted local law.",
+        tokenHints: tokenHints(input.styling, /surface|card|panel|bg|background|border|shadow|radius/i),
+        classHints: classHintsForPattern(input.projectRoot, ["surface-card"]),
+        sourceEvidence: sourceEvidence(input.projectRoot, ["surface-card"]),
+        guardrails: [
+          "Do not invent a new card color/radius/shadow recipe without updating local law.",
+          "Do not add Decantr CSS d-* classes unless adoption mode changes to decantr-css."
+        ]
+      },
+      {
+        id: "action",
+        label: "Actions and buttons",
+        decantrIntent: "primary, secondary, tertiary, destructive, icon-only, loading, and disabled action states",
+        projectAuthority: "Use the app button/action primitives and local variant names.",
+        tokenHints: tokenHints(input.styling, /primary|secondary|accent|danger|error|destructive|focus/i),
+        classHints: classHintsForPattern(input.projectRoot, ["button"]),
+        sourceEvidence: sourceEvidence(input.projectRoot, ["button"]),
+        guardrails: [
+          "Map any new action style to primary/secondary/tertiary/destructive/icon before coding.",
+          "Avoid raw button markup when a project-owned primitive exists."
+        ]
+      },
+      {
+        id: "focus-accessibility",
+        label: "Focus and accessibility",
+        decantrIntent: "visible focus, keyboard clarity, contrast, and reduced-motion safety",
+        projectAuthority: "Use the app accessibility classes, focus tokens, and framework conventions.",
+        tokenHints: tokenHints(input.styling, /focus|ring|outline|contrast|motion|duration/i),
+        classHints: [],
+        sourceEvidence: [],
+        guardrails: [
+          "Every new interactive control needs visible focus evidence.",
+          "Motion should honor prefers-reduced-motion or an existing app motion helper."
+        ]
+      },
+      {
+        id: "layout-density",
+        label: "Layout density and spacing",
+        decantrIntent: "route gutters, section gaps, component padding, density, and responsive rhythm",
+        projectAuthority: "Use existing layout wrappers, shell primitives, and spacing tokens/classes.",
+        tokenHints: tokenHints(input.styling, /space|spacing|gap|gutter|container|radius/i),
+        classHints: classHintsForPattern(input.projectRoot, ["page-shell"]),
+        sourceEvidence: sourceEvidence(input.projectRoot, ["page-shell"]),
+        guardrails: [
+          "Do not let each page invent independent max-width, gutters, or scroll ownership.",
+          "Use the detected shell/layout authority before adding a new wrapper."
+        ]
+      },
+      {
+        id: "theme-variant",
+        label: "Theme variants",
+        decantrIntent: "light, dark, brand, tenant, seasonal, and density variants",
+        projectAuthority: "Use the app theme provider, data attributes, CSS variables, or Tailwind mode strategy.",
+        tokenHints: tokenHints(input.styling, /theme|dark|light|brand|tenant|mode|color/i),
+        classHints: classHintsForPattern(input.projectRoot, ["theme-variant"]),
+        sourceEvidence: sourceEvidence(input.projectRoot, ["theme-variant"]),
+        guardrails: [
+          "Keep theme modes documented in .decantr/theme-inventory.json and this bridge.",
+          "Do not treat theme switcher container classes as standalone theme variants."
+        ]
+      }
+    ],
+    rules: [
+      "The bridge is advisory until accepted; after acceptance, task/doctor/CI should surface it as Hybrid authority.",
+      "The bridge does not make hosted registry patterns enforceable. Map hosted concepts into local law first.",
+      "Keep deterministic blocking checks in .decantr/rules.json, ESLint, Biome, tests, or visual regression."
+    ],
+    nextSteps: [
+      "Review token and class hints. Replace generic hints with the exact project tokens/classes the team owns.",
+      "Run decantr codify --accept to promote the proposal to .decantr/style-bridge.json.",
+      "Use decantr task <route> before LLM edits so the style bridge appears in task context.",
+      "Run decantr ci or decantr verify after edits to keep local law and Project Health visible."
+    ]
+  };
+}
+function writeStyleBridgeProposal(projectRoot, proposal) {
+  const decantrDir = join16(projectRoot, ".decantr");
+  mkdirSync9(decantrDir, { recursive: true });
+  const path = styleBridgeProposalPath(projectRoot);
+  writeJsonFile(path, proposal);
+  return path;
+}
+function acceptStyleBridge(projectRoot) {
+  const proposal = readStyleBridgeProposal(projectRoot);
+  if (!proposal) return null;
+  const accepted = {
+    ...proposal,
+    status: "accepted",
+    acceptedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const path = styleBridgePath(projectRoot);
+  writeJsonFile(path, accepted);
+  const projectJsonPath = join16(projectRoot, ".decantr", "project.json");
+  const projectJson = readJsonFile2(projectJsonPath) ?? {};
+  const initialized = typeof projectJson.initialized === "object" && projectJson.initialized !== null ? projectJson.initialized : {};
+  writeJsonFile(projectJsonPath, {
+    ...projectJson,
+    initialized: {
+      ...initialized,
+      workflowMode: initialized.workflowMode ?? "brownfield-attach",
+      adoptionMode: "style-bridge"
+    }
+  });
+  return path;
+}
+function createStyleBridgeTaskSummary(projectRoot) {
+  const bridge = readStyleBridge(projectRoot);
+  return {
+    path: bridge ? ".decantr/style-bridge.json" : null,
+    status: bridge?.status ?? null,
+    mappingCount: bridge?.mappings?.length ?? 0,
+    stylingApproach: bridge?.styling?.approach ?? null,
+    themeModes: bridge?.styling?.themeModes ?? [],
+    mappings: bridge?.mappings?.map((mapping) => ({
+      id: mapping.id,
+      label: mapping.label,
+      tokenHints: mapping.tokenHints.slice(0, 6),
+      classHints: mapping.classHints.slice(0, 4),
+      guardrails: mapping.guardrails.slice(0, 3)
+    })) ?? []
+  };
+}
+function styleBridgeMatches(projectRoot, query) {
+  if (!projectRoot) return [];
+  const bridge = readStyleBridge(projectRoot);
+  if (!bridge) return [];
+  const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1).flatMap((term) => term.endsWith("s") && term.length > 3 ? [term, term.slice(0, -1)] : [term]);
+  if (terms.length === 0) return [];
+  return bridge.mappings.map((mapping) => {
+    const haystack = [
+      mapping.id,
+      mapping.label,
+      mapping.decantrIntent,
+      mapping.projectAuthority,
+      ...mapping.tokenHints,
+      ...mapping.classHints,
+      ...mapping.guardrails
+    ].join(" ").toLowerCase();
+    const score = terms.reduce((sum, term) => sum + (haystack.includes(term) ? 1 : 0), 0);
+    return {
+      id: mapping.id,
+      label: mapping.label,
+      score,
+      tokenHints: mapping.tokenHints.slice(0, 4),
+      classHints: mapping.classHints.slice(0, 3)
+    };
+  }).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id)).slice(0, 5);
+}
+
 // src/commands/ci.ts
 var BOLD2 = "\x1B[1m";
 var DIM3 = "\x1B[2m";
@@ -3756,9 +4343,9 @@ var RED2 = "\x1B[31m";
 var RESET3 = "\x1B[0m";
 var CI_SCHEMA = "https://decantr.ai/schemas/decantr-ci-report.v1.json";
 function readJson(path) {
-  if (!existsSync14(path)) return null;
+  if (!existsSync15(path)) return null;
   try {
-    return JSON.parse(readFileSync12(path, "utf-8"));
+    return JSON.parse(readFileSync13(path, "utf-8"));
   } catch {
     return null;
   }
@@ -3802,21 +4389,21 @@ function parseProvider(value) {
   throw new Error("Invalid --provider value. Use github or generic.");
 }
 function detectPackageManager2(root) {
-  const pkg = readJson(join16(root, "package.json"));
+  const pkg = readJson(join17(root, "package.json"));
   const declared = pkg?.packageManager?.split("@")[0];
   if (declared === "pnpm" || declared === "npm" || declared === "yarn" || declared === "bun") {
     return declared;
   }
-  if (existsSync14(join16(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync14(join16(root, "package-lock.json"))) return "npm";
-  if (existsSync14(join16(root, "yarn.lock"))) return "yarn";
-  if (existsSync14(join16(root, "bun.lock")) || existsSync14(join16(root, "bun.lockb"))) return "bun";
+  if (existsSync15(join17(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync15(join17(root, "package-lock.json"))) return "npm";
+  if (existsSync15(join17(root, "yarn.lock"))) return "yarn";
+  if (existsSync15(join17(root, "bun.lock")) || existsSync15(join17(root, "bun.lockb"))) return "bun";
   return "unknown";
 }
 function hasWorkspaceMarker(root) {
-  const pkg = readJson(join16(root, "package.json"));
+  const pkg = readJson(join17(root, "package.json"));
   return Boolean(
-    existsSync14(join16(root, "pnpm-workspace.yaml")) || existsSync14(join16(root, "turbo.json")) || existsSync14(join16(root, "nx.json")) || pkg?.workspaces
+    existsSync15(join17(root, "pnpm-workspace.yaml")) || existsSync15(join17(root, "turbo.json")) || existsSync15(join17(root, "nx.json")) || pkg?.workspaces
   );
 }
 function installCommand(packageManager) {
@@ -3862,7 +4449,7 @@ function decantrCommand(packageManager) {
   }
 }
 function localCliPinned(root) {
-  const pkg = readJson(join16(root, "package.json"));
+  const pkg = readJson(join17(root, "package.json"));
   return Boolean(pkg?.devDependencies?.["@decantr/cli"] || pkg?.dependencies?.["@decantr/cli"]);
 }
 function projectSlug(projectPath) {
@@ -3870,8 +4457,8 @@ function projectSlug(projectPath) {
 }
 function writeOutput(root, path, content) {
   const absolute = resolve(root, path);
-  mkdirSync9(dirname3(absolute), { recursive: true });
-  writeFileSync10(absolute, content, "utf-8");
+  mkdirSync10(dirname3(absolute), { recursive: true });
+  writeFileSync11(absolute, content, "utf-8");
 }
 function summarizeLocalLaw(projectRoot) {
   const validation = validateLocalLaw(projectRoot);
@@ -3893,14 +4480,36 @@ function summarizeLocalLaw(projectRoot) {
     warnCount: validation.findings.filter((finding) => finding.severity === "warn").length + validation.warnings.length
   };
 }
+function summarizeStyleBridge(projectRoot) {
+  const summary = createStyleBridgeTaskSummary(projectRoot);
+  const warnings = [];
+  if (summary.path && summary.mappingCount === 0) {
+    warnings.push(".decantr/style-bridge.json has no mappings.");
+  }
+  return {
+    checked: Boolean(summary.path),
+    present: Boolean(summary.path),
+    status: summary.status,
+    mappingCount: summary.mappingCount,
+    stylingApproach: summary.stylingApproach,
+    themeModes: summary.themeModes,
+    warnings
+  };
+}
 function localLawFails(summary, failOn) {
   if (failOn === "none" || !summary.checked) return false;
   if (summary.errorCount > 0) return true;
   return failOn === "warn" && summary.warnCount > 0;
 }
-function projectCiStatus(health, localLaw) {
+function styleBridgeFails(summary, failOn) {
+  if (failOn === "none" || !summary.checked) return false;
+  return failOn === "warn" && summary.warnings.length > 0;
+}
+function projectCiStatus(health, localLaw, styleBridge) {
   if (health.status === "error" || localLaw.errorCount > 0) return "error";
-  if (health.status === "warning" || localLaw.warnCount > 0) return "warning";
+  if (health.status === "warning" || localLaw.warnCount > 0 || styleBridge.warnings.length > 0) {
+    return "warning";
+  }
   return health.status;
 }
 function formatLocalLawText(summary, health) {
@@ -3916,6 +4525,9 @@ function formatLocalLawText(summary, health) {
   lines.push(
     `  Patterns: ${summary.patternsPresent ? "present" : "missing"} | Rules: ${summary.rulesPresent ? "present" : "missing"}`
   );
+  lines.push(
+    summary.rulesPresent ? "  Enforcement: Decantr scans accepted .decantr/rules.json; this command's --fail-on setting controls whether findings block." : "  Enforcement: advisory only until .decantr/rules.json is accepted."
+  );
   lines.push(`  Findings: ${summary.errorCount} error(s), ${summary.warnCount} warning(s)`);
   for (const warning of summary.warnings.slice(0, 5)) {
     lines.push(`  ${DIM3}[WARN] ${warning}${RESET3}`);
@@ -3933,6 +4545,28 @@ function formatLocalLawText(summary, health) {
   return `${lines.join("\n")}
 `;
 }
+function formatStyleBridgeText(summary) {
+  const lines = ["", `${BOLD2}Project-owned style bridge:${RESET3}`];
+  if (!summary.checked) {
+    lines.push("  Not active for this project.");
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push(
+    `  Present: ${summary.present ? "yes" : "no"} | Mappings: ${summary.mappingCount} | Styling: ${summary.stylingApproach ?? "unknown"}`
+  );
+  lines.push(
+    "  Enforcement: advisory style-intent mapping; pair with accepted local rules, lint, tests, or visual regression when it should block."
+  );
+  if (summary.themeModes.length > 0) {
+    lines.push(`  Theme modes: ${summary.themeModes.join(", ")}`);
+  }
+  for (const warning of summary.warnings.slice(0, 5)) {
+    lines.push(`  ${DIM3}[WARN] ${warning}${RESET3}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
 function formatLocalLawMarkdown(summary, health) {
   const lines = ["## Project-Owned Local Law", ""];
   if (!summary.checked) {
@@ -3948,6 +4582,9 @@ function formatLocalLawMarkdown(summary, health) {
   lines.push(
     `Patterns: **${summary.patternsPresent ? "present" : "missing"}** \xB7 Rules: **${summary.rulesPresent ? "present" : "missing"}**`
   );
+  lines.push(
+    summary.rulesPresent ? "Enforcement: Decantr scans accepted `.decantr/rules.json`; CI blocking depends on `--fail-on`." : "Enforcement: advisory only until `.decantr/rules.json` is accepted."
+  );
   lines.push("");
   lines.push(`Findings: **${summary.errorCount} error(s), ${summary.warnCount} warning(s)**`);
   if (summary.warnings.length > 0) {
@@ -3966,6 +4603,30 @@ function formatLocalLawMarkdown(summary, health) {
   }
   return lines.join("\n");
 }
+function formatStyleBridgeMarkdown(summary) {
+  const lines = ["## Project-Owned Style Bridge", ""];
+  if (!summary.checked) {
+    lines.push("Style bridge is not active for this project.");
+    return lines.join("\n");
+  }
+  lines.push(
+    `Present: **${summary.present ? "yes" : "no"}** \xB7 Mappings: **${summary.mappingCount}** \xB7 Styling: **${summary.stylingApproach ?? "unknown"}**`
+  );
+  lines.push("");
+  lines.push(
+    "Enforcement: advisory style-intent mapping; pair with accepted local rules, lint, tests, or visual regression when it should block."
+  );
+  if (summary.themeModes.length > 0) {
+    lines.push("", `Theme modes: ${summary.themeModes.map((mode) => `\`${mode}\``).join(", ")}`);
+  }
+  if (summary.warnings.length > 0) {
+    lines.push("");
+    for (const warning of summary.warnings.slice(0, 5)) {
+      lines.push(`- Warning: ${warning}`);
+    }
+  }
+  return lines.join("\n");
+}
 function formatProjectCiMarkdown(report) {
   const lines = [
     "# Decantr CI",
@@ -3975,10 +4636,13 @@ function formatProjectCiMarkdown(report) {
     `- Status: **${report.status}**`,
     `- Fail on: \`${report.failOn}\``,
     `- Local law: ${report.localLaw.checked ? `${report.localLaw.errorCount} error(s), ${report.localLaw.warnCount} warning(s)` : "not accepted yet"}`,
+    `- Style bridge: ${report.styleBridge.checked ? `${report.styleBridge.mappingCount} mapping(s)` : "not active"}`,
     "",
     formatProjectHealthMarkdown(report.health),
     "",
-    formatLocalLawMarkdown(report.localLaw, report.health)
+    formatLocalLawMarkdown(report.localLaw, report.health),
+    "",
+    formatStyleBridgeMarkdown(report.styleBridge)
   ];
   return `${lines.join("\n")}
 `;
@@ -4069,7 +4733,7 @@ jobs:
 }
 function writeCiInit(root, options) {
   const workspaceInfo = resolveWorkspaceInfo(root, options.project);
-  if (options.project && !existsSync14(workspaceInfo.appRoot)) {
+  if (options.project && !existsSync15(workspaceInfo.appRoot)) {
     throw new Error(`Project path does not exist: ${options.project}`);
   }
   if (workspaceInfo.requiresProjectSelection && !options.workspace) {
@@ -4092,7 +4756,7 @@ function writeCiInit(root, options) {
   if (provider === "generic") {
     const path2 = ".decantr/ci/decantr-ci.sh";
     const absolute2 = resolve(outputRoot, path2);
-    if (existsSync14(absolute2) && !options.force) {
+    if (existsSync15(absolute2) && !options.force) {
       throw new Error(`${path2} already exists. Re-run with --force to replace it.`);
     }
     writeOutput(
@@ -4113,7 +4777,7 @@ function writeCiInit(root, options) {
   }
   const path = ".github/workflows/decantr-ci.yml";
   const absolute = resolve(outputRoot, path);
-  if (existsSync14(absolute) && !options.force) {
+  if (existsSync15(absolute) && !options.force) {
     throw new Error(`${path} already exists. Re-run with --force to replace it.`);
   }
   writeOutput(
@@ -4162,7 +4826,7 @@ async function runWorkspaceCi(root, options) {
 }
 async function runProjectCi(root, options) {
   const workspaceInfo = resolveWorkspaceInfo(root, options.project);
-  if (options.project && !existsSync14(workspaceInfo.appRoot)) {
+  if (options.project && !existsSync15(workspaceInfo.appRoot)) {
     console.error(`${RED2}Project path does not exist: ${options.project}${RESET3}`);
     return 1;
   }
@@ -4175,6 +4839,7 @@ async function runProjectCi(root, options) {
   const failOn = options.failOn ?? "error";
   const health = await createProjectHealthReport(workspaceInfo.appRoot);
   const localLaw = summarizeLocalLaw(workspaceInfo.appRoot);
+  const styleBridge = summarizeStyleBridge(workspaceInfo.appRoot);
   const projectPath = workspaceInfo.appRoot === workspaceInfo.workspaceRoot ? null : workspaceInfo.appRoot.replace(`${workspaceInfo.workspaceRoot}/`, "");
   const report = {
     $schema: CI_SCHEMA,
@@ -4182,9 +4847,10 @@ async function runProjectCi(root, options) {
     mode: "project",
     projectPath,
     failOn,
-    status: projectCiStatus(health, localLaw),
+    status: projectCiStatus(health, localLaw, styleBridge),
     health,
-    localLaw
+    localLaw,
+    styleBridge
   };
   const json = `${JSON.stringify(report, null, 2)}
 `;
@@ -4195,9 +4861,11 @@ async function runProjectCi(root, options) {
     if (options.json) process.stdout.write(json);
     else if (options.markdown) process.stdout.write(markdown);
     else
-      process.stdout.write(`${formatProjectHealthText(health)}${formatLocalLawText(localLaw, health)}`);
+      process.stdout.write(
+        `${formatProjectHealthText(health)}${formatLocalLawText(localLaw, health)}${formatStyleBridgeText(styleBridge)}`
+      );
   }
-  return shouldFailHealth(health, failOn) || localLawFails(localLaw, failOn) ? 1 : 0;
+  return shouldFailHealth(health, failOn) || localLawFails(localLaw, failOn) || styleBridgeFails(styleBridge, failOn) ? 1 : 0;
 }
 function cmdCiHelp() {
   console.log(`
@@ -4232,8 +4900,8 @@ async function cmdCi(args = ["ci"], root = process.cwd()) {
 }
 
 // src/commands/create.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { join as join18 } from "path";
 import {
   CONTENT_TYPE_TO_API_CONTENT_TYPE,
   CONTENT_TYPES
@@ -4429,23 +5097,23 @@ function cmdCreate(type, name, projectRoot = process.cwd()) {
   }
   const contentType = type;
   const plural = PLURAL[contentType];
-  const customDir = join17(projectRoot, ".decantr", "custom", plural);
-  const filePath = join17(customDir, `${name}.json`);
-  if (existsSync15(filePath)) {
+  const customDir = join18(projectRoot, ".decantr", "custom", plural);
+  const filePath = join18(customDir, `${name}.json`);
+  if (existsSync16(filePath)) {
     console.error(`${type} "${name}" already exists at ${filePath}`);
     process.exitCode = 1;
     return;
   }
-  mkdirSync10(customDir, { recursive: true });
+  mkdirSync11(customDir, { recursive: true });
   const skeleton = getSkeleton(contentType, name, humanizeId(name));
-  writeFileSync11(filePath, JSON.stringify(skeleton, null, 2));
+  writeFileSync12(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/doctor.ts
-import { existsSync as existsSync16, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname4, join as join18, relative as relative5 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync14 } from "fs";
+import { dirname as dirname4, join as join19, relative as relative5 } from "path";
 import { fileURLToPath } from "url";
 import { isV4 as isV44 } from "@decantr/essence-spec";
 import { collectMissingPackManifestFiles } from "@decantr/verifier";
@@ -4457,25 +5125,25 @@ var YELLOW3 = "\x1B[33m";
 var CYAN2 = "\x1B[36m";
 var RESET4 = "\x1B[0m";
 function readJson2(path) {
-  if (!existsSync16(path)) return null;
+  if (!existsSync17(path)) return null;
   try {
-    return JSON.parse(readFileSync13(path, "utf-8"));
+    return JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function isContractOnlyProject(projectRoot) {
-  const projectJson = readJson2(join18(projectRoot, ".decantr", "project.json"));
-  return projectJson?.initialized?.adoptionMode === "contract-only";
+  const projectJson = readJson2(join19(projectRoot, ".decantr", "project.json"));
+  return projectJson?.initialized?.adoptionMode === "contract-only" || projectJson?.initialized?.adoptionMode === "style-bridge";
 }
 function readCliPackageVersion() {
-  const packagePath = join18(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-  const srcPackagePath = join18(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
+  const packagePath = join19(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+  const srcPackagePath = join19(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
   const pkg = readJson2(packagePath) ?? readJson2(srcPackagePath);
   return pkg?.version ?? "unknown";
 }
 function readPackageJson2(dir) {
-  return readJson2(join18(dir, "package.json"));
+  return readJson2(join19(dir, "package.json"));
 }
 function detectPackageManager3(root) {
   const pkg = readPackageJson2(root);
@@ -4483,10 +5151,10 @@ function detectPackageManager3(root) {
   if (declared === "pnpm" || declared === "npm" || declared === "yarn" || declared === "bun") {
     return declared;
   }
-  if (existsSync16(join18(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync16(join18(root, "package-lock.json"))) return "npm";
-  if (existsSync16(join18(root, "yarn.lock"))) return "yarn";
-  if (existsSync16(join18(root, "bun.lock")) || existsSync16(join18(root, "bun.lockb"))) return "bun";
+  if (existsSync17(join19(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync17(join19(root, "package-lock.json"))) return "npm";
+  if (existsSync17(join19(root, "yarn.lock"))) return "yarn";
+  if (existsSync17(join19(root, "bun.lock")) || existsSync17(join19(root, "bun.lockb"))) return "bun";
   return "unknown";
 }
 function localCliDependency(root) {
@@ -4496,7 +5164,7 @@ function localCliDependency(root) {
 function hasWorkspaceMarker2(root) {
   const pkg = readPackageJson2(root);
   return Boolean(
-    existsSync16(join18(root, "pnpm-workspace.yaml")) || existsSync16(join18(root, "turbo.json")) || existsSync16(join18(root, "nx.json")) || pkg?.workspaces
+    existsSync17(join19(root, "pnpm-workspace.yaml")) || existsSync17(join19(root, "turbo.json")) || existsSync17(join19(root, "nx.json")) || pkg?.workspaces
   );
 }
 function pinCliCommand2(packageManager, root) {
@@ -4519,8 +5187,8 @@ function rel(root, path) {
 }
 function hasAnyFile(dir, names) {
   for (const name of names) {
-    const path = join18(dir, name);
-    if (existsSync16(path)) return name;
+    const path = join19(dir, name);
+    if (existsSync17(path)) return name;
   }
   return null;
 }
@@ -4542,7 +5210,7 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
     "libs/design-system"
   ];
   for (const candidate of sharedCandidates) {
-    if (existsSync16(join18(workspaceRoot, candidate))) found.add(candidate);
+    if (existsSync17(join19(workspaceRoot, candidate))) found.add(candidate);
   }
   for (const root of [appRoot, workspaceRoot]) {
     const label = root === appRoot ? "app" : "workspace";
@@ -4553,9 +5221,9 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
       "tailwind.config.cjs"
     ]);
     if (tailwind) found.add(`${label}:${tailwind}`);
-    if (existsSync16(join18(root, ".storybook"))) found.add(`${label}:.storybook`);
-    if (existsSync16(join18(root, "components", "ui"))) found.add(`${label}:components/ui`);
-    if (existsSync16(join18(root, "src", "components", "ui"))) found.add(`${label}:src/components/ui`);
+    if (existsSync17(join19(root, ".storybook"))) found.add(`${label}:.storybook`);
+    if (existsSync17(join19(root, "components", "ui"))) found.add(`${label}:components/ui`);
+    if (existsSync17(join19(root, "src", "components", "ui"))) found.add(`${label}:src/components/ui`);
     if (packageHasDependency(root, ["@storybook/react", "storybook"]))
       found.add(`${label}:storybook`);
     if (packageHasDependency(root, ["tailwindcss"])) found.add(`${label}:tailwindcss`);
@@ -4567,18 +5235,18 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
 }
 function findCiFiles(root) {
   const files = [];
-  const workflows = join18(root, ".github", "workflows");
-  if (existsSync16(workflows)) {
+  const workflows = join19(root, ".github", "workflows");
+  if (existsSync17(workflows)) {
     for (const entry of readdirSync6(workflows, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
-      const path = join18(workflows, entry.name);
-      const text = readFileSync13(path, "utf-8");
+      const path = join19(workflows, entry.name);
+      const text = readFileSync14(path, "utf-8");
       if (text.includes("decantr")) files.push(rel(root, path));
     }
   }
   for (const candidate of ["Jenkinsfile", ".gitlab-ci.yml", "azure-pipelines.yml", "BUILD"]) {
-    const path = join18(root, candidate);
-    if (existsSync16(path) && readFileSync13(path, "utf-8").includes("decantr")) {
+    const path = join19(root, candidate);
+    if (existsSync17(path) && readFileSync14(path, "utf-8").includes("decantr")) {
       files.push(candidate);
     }
   }
@@ -4618,15 +5286,17 @@ function deriveAdoptionLane(input) {
     };
   }
   const hasLocalLaw = input.localPatternsPresent || input.localRulesPresent;
+  const hasStyleBridge = input.styleBridgePresent || input.adoptionMode === "style-bridge";
   if (input.workflowMode === "hybrid-compose") {
     return {
       id: "hybrid-compose",
       label: "Hybrid composition",
       sourceAuthority: "Existing app plus selected Decantr/local law",
-      styleAuthority: input.adoptionMode === "decantr-css" ? "Decantr CSS runtime is active where adopted" : input.adoptionMode === "style-bridge" ? "Style bridge maps Decantr intent into the app styling system" : "Existing app styling system remains primary",
+      styleAuthority: input.adoptionMode === "decantr-css" ? "Decantr CSS runtime is active where adopted" : hasStyleBridge ? "Style bridge maps Decantr intent into the app styling system" : "Existing app styling system remains primary",
       activeAuthorities: [
         "existing source",
         "Essence V4 contract",
+        hasStyleBridge ? "accepted style bridge" : "no style bridge",
         hasLocalLaw ? "accepted local law" : "reviewed Hybrid choices",
         input.packManifestPresent ? "hosted execution packs" : "optional hosted packs"
       ],
@@ -4644,13 +5314,18 @@ function deriveAdoptionLane(input) {
         nextChoice: "Keep Decantr CSS usage explicit and validate route changes with task and verify."
       };
     }
-    if (input.adoptionMode === "style-bridge") {
+    if (hasStyleBridge) {
       return {
         id: "hybrid-style-bridge",
         label: "Hybrid style bridge",
         sourceAuthority: "Existing app plus Decantr intent mapped through a style bridge",
         styleAuthority: "Style bridge over the existing app styling system",
-        activeAuthorities: ["existing source", "Essence V4 contract", "style bridge"],
+        activeAuthorities: [
+          "existing source",
+          "Essence V4 contract",
+          "accepted style bridge",
+          hasLocalLaw ? "accepted local patterns/rules" : "optional local law"
+        ],
         nextChoice: "Use local law to decide which component families the bridge governs before making it strict."
       };
     }
@@ -4708,18 +5383,18 @@ function buildDoctorReport(root, args) {
   const workspaceInfo = resolveWorkspaceInfo(root, projectArg);
   const workspaceRoot = workspaceInfo.workspaceRoot;
   const appRoot = workspaceMode ? workspaceRoot : workspaceInfo.appRoot;
-  const projectMissing = Boolean(projectArg && !existsSync16(appRoot));
+  const projectMissing = Boolean(projectArg && !existsSync17(appRoot));
   const projectPath = appRoot === workspaceRoot ? null : rel(workspaceRoot, appRoot);
   const packageManager = detectPackageManager3(workspaceRoot);
   const cliDependency = localCliDependency(workspaceRoot);
   const detected = detectProject(appRoot);
-  const projectJson = readJson2(join18(appRoot, ".decantr", "project.json"));
-  const essence = readJson2(join18(appRoot, "decantr.essence.json"));
+  const projectJson = readJson2(join19(appRoot, ".decantr", "project.json"));
+  const essence = readJson2(join19(appRoot, "decantr.essence.json"));
   const essenceVersion = essence && typeof essence === "object" && "version" in essence ? String(essence.version) : null;
-  const contextDir = join18(appRoot, ".decantr", "context");
-  const packManifestPresent = existsSync16(join18(contextDir, "pack-manifest.json"));
-  const reviewPackPresent = existsSync16(join18(contextDir, "review-pack.json"));
-  const artifactReadmePresent = existsSync16(join18(appRoot, ARTIFACT_README_PATH));
+  const contextDir = join19(appRoot, ".decantr", "context");
+  const packManifestPresent = existsSync17(join19(contextDir, "pack-manifest.json"));
+  const reviewPackPresent = existsSync17(join19(contextDir, "review-pack.json"));
+  const artifactReadmePresent = existsSync17(join19(appRoot, ARTIFACT_README_PATH));
   const projects = listWorkspaceProjects(workspaceRoot);
   const candidates = listWorkspaceCandidates(workspaceRoot, projects).map((candidate) => ({
     path: candidate.path,
@@ -4729,21 +5404,23 @@ function buildDoctorReport(root, args) {
   const ciFiles = findCiFiles(workspaceRoot);
   const workflowMode = projectJson?.initialized?.workflowMode ?? null;
   const adoptionMode = projectJson?.initialized?.adoptionMode ?? null;
-  const packHydrationOptional = adoptionMode === "contract-only";
-  const localPatternsPresent = existsSync16(localPatternsPath(appRoot));
-  const localRulesPresent = existsSync16(localRulesPath(appRoot));
+  const packHydrationOptional = adoptionMode === "contract-only" || adoptionMode === "style-bridge";
+  const localPatternsPresent = existsSync17(localPatternsPath(appRoot));
+  const localRulesPresent = existsSync17(localRulesPath(appRoot));
+  const styleBridgePresent = existsSync17(styleBridgePath(appRoot));
+  const styleBridgeProposalPresent = existsSync17(styleBridgeProposalPath(appRoot));
   const missingPackReferences = workspaceMode ? projects.flatMap(
-    (project) => collectMissingPackManifestFiles(join18(workspaceRoot, project.path)).map(
+    (project) => collectMissingPackManifestFiles(join19(workspaceRoot, project.path)).map(
       (missing) => `${project.path}/${missing.relativePath}`
     )
   ) : collectMissingPackManifestFiles(appRoot).map((missing) => missing.relativePath);
   const workspaceProjectsMissingManifest = workspaceMode ? projects.map((project) => project.path).filter((projectPath2) => {
-    const projectContextDir = join18(workspaceRoot, projectPath2, ".decantr", "context");
-    return !isContractOnlyProject(join18(workspaceRoot, projectPath2)) && !existsSync16(join18(projectContextDir, "pack-manifest.json"));
+    const projectContextDir = join19(workspaceRoot, projectPath2, ".decantr", "context");
+    return !isContractOnlyProject(join19(workspaceRoot, projectPath2)) && !existsSync17(join19(projectContextDir, "pack-manifest.json"));
   }) : [];
   const workspaceProjectsMissingReviewPack = workspaceMode ? projects.map((project) => project.path).filter((projectPath2) => {
-    const projectContextDir = join18(workspaceRoot, projectPath2, ".decantr", "context");
-    return !isContractOnlyProject(join18(workspaceRoot, projectPath2)) && !existsSync16(join18(projectContextDir, "review-pack.json"));
+    const projectContextDir = join19(workspaceRoot, projectPath2, ".decantr", "context");
+    return !isContractOnlyProject(join19(workspaceRoot, projectPath2)) && !existsSync17(join19(projectContextDir, "review-pack.json"));
   }) : [];
   const issues = [];
   if (projectMissing) {
@@ -4800,7 +5477,7 @@ function buildDoctorReport(root, args) {
       nextCommand: "decantr refresh"
     });
   }
-  if (essenceVersion === "4.0.0" && !packHydrationOptional && (!existsSync16(contextDir) || !packManifestPresent)) {
+  if (essenceVersion === "4.0.0" && !packHydrationOptional && (!existsSync17(contextDir) || !packManifestPresent)) {
     issues.push({
       category: "generated-artifact",
       severity: "warn",
@@ -4832,6 +5509,14 @@ function buildDoctorReport(root, args) {
       nextCommand: projectPath ? `decantr codify --from-audit --project ${projectPath}` : "decantr codify --from-audit"
     });
   }
+  if (adoptionMode === "style-bridge" && !styleBridgePresent) {
+    issues.push({
+      category: "local-law",
+      severity: "warn",
+      message: "This app declares style-bridge adoption, but .decantr/style-bridge.json is missing.",
+      nextCommand: styleBridgeProposalPresent ? projectPath ? `decantr codify --accept --project ${projectPath}` : "decantr codify --accept" : projectPath ? `decantr codify --style-bridge --project ${projectPath}` : "decantr codify --style-bridge"
+    });
+  }
   if ((essenceVersion === "4.0.0" || workspaceMode && projects.length > 0) && ciFiles.length === 0) {
     issues.push({
       category: "ci",
@@ -4859,6 +5544,7 @@ function buildDoctorReport(root, args) {
     adoptionMode,
     localPatternsPresent,
     localRulesPresent,
+    styleBridgePresent,
     designAuthority,
     packManifestPresent
   });
@@ -4880,6 +5566,12 @@ function buildDoctorReport(root, args) {
       appendUnique(recommendedNextCommands, `decantr codify --from-audit${projectFlag}`);
       appendUnique(recommendedNextCommands, `decantr codify --accept${projectFlag}`);
     }
+    if (adoptionMode === "style-bridge" && !styleBridgePresent) {
+      appendUnique(
+        recommendedNextCommands,
+        styleBridgeProposalPresent ? `decantr codify --accept${projectFlag}` : `decantr codify --style-bridge${projectFlag}`
+      );
+    }
     appendUnique(
       recommendedNextCommands,
       issues.find((issue) => issue.category === "generated-artifact")?.nextCommand
@@ -4919,18 +5611,20 @@ function buildDoctorReport(root, args) {
     },
     generatedArtifacts: {
       contextDirPresent: workspaceMode ? projects.some(
-        (project) => existsSync16(join18(workspaceRoot, project.path, ".decantr", "context"))
-      ) : existsSync16(contextDir),
+        (project) => existsSync17(join19(workspaceRoot, project.path, ".decantr", "context"))
+      ) : existsSync17(contextDir),
       packManifestPresent: workspaceMode ? projects.length > 0 && workspaceProjectsMissingManifest.length === 0 : packManifestPresent,
       reviewPackPresent: workspaceMode ? projects.length > 0 && workspaceProjectsMissingReviewPack.length === 0 : reviewPackPresent,
       missingReferencedFiles: missingPackReferences.slice(0, 25)
     },
     localLaw: {
       patternsPresent: localPatternsPresent,
-      rulesPresent: localRulesPresent
+      rulesPresent: localRulesPresent,
+      styleBridgePresent,
+      styleBridgeProposalPresent
     },
     visualEvidence: {
-      manifestPresent: existsSync16(join18(appRoot, ".decantr", "evidence", "visual-manifest.json"))
+      manifestPresent: existsSync17(join19(appRoot, ".decantr", "evidence", "visual-manifest.json"))
     },
     lane,
     designAuthority,
@@ -4978,6 +5672,7 @@ function formatDoctorText(report) {
     `${BOLD3}Local Law:${RESET4}`,
     `  Local patterns: ${report.localLaw.patternsPresent ? "present" : "missing"}`,
     `  Local rules: ${report.localLaw.rulesPresent ? "present" : "missing"}`,
+    `  Style bridge: ${report.localLaw.styleBridgePresent ? "present" : report.localLaw.styleBridgeProposalPresent ? "proposal pending" : "missing"}`,
     "",
     `${BOLD3}Workspace:${RESET4}`,
     `  Attached projects: ${report.workspace.attachedProjects.length}`,
@@ -5037,17 +5732,17 @@ async function cmdDoctor(args = ["doctor"], root = process.cwd()) {
 }
 
 // src/commands/export.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname5, isAbsolute, join as join19 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname5, isAbsolute, join as join20 } from "path";
 var GREEN5 = "\x1B[32m";
 var RED4 = "\x1B[31m";
 var DIM5 = "\x1B[2m";
 var RESET5 = "\x1B[0m";
 function readAdoptionMode(projectRoot) {
-  const projectJsonPath = join19(projectRoot, ".decantr", "project.json");
-  if (!existsSync17(projectJsonPath)) return null;
+  const projectJsonPath = join20(projectRoot, ".decantr", "project.json");
+  if (!existsSync18(projectJsonPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync14(projectJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(projectJsonPath, "utf-8"));
     return typeof parsed.initialized?.adoptionMode === "string" ? parsed.initialized.adoptionMode : null;
   } catch {
     return null;
@@ -5055,7 +5750,7 @@ function readAdoptionMode(projectRoot) {
 }
 function resolveOutputPath(projectRoot, output, fallback) {
   if (!output) return fallback;
-  return isAbsolute(output) ? output : join19(projectRoot, output);
+  return isAbsolute(output) ? output : join20(projectRoot, output);
 }
 var SHADCN_MAP = {
   "--d-bg": "--background",
@@ -5216,21 +5911,21 @@ function generateFigmaTokens(tokens) {
 `;
 }
 async function cmdExport(target, projectRoot, options = {}) {
-  const essencePath = join19(projectRoot, "decantr.essence.json");
-  const tokensPath = join19(projectRoot, "src", "styles", "tokens.css");
-  if (!existsSync17(essencePath)) {
+  const essencePath = join20(projectRoot, "decantr.essence.json");
+  const tokensPath = join20(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync18(essencePath)) {
     console.error(`${RED4}No decantr.essence.json found. Run \`decantr init\` first.${RESET5}`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync17(tokensPath)) {
+  if (!existsSync18(tokensPath)) {
     const adoptionMode = readAdoptionMode(projectRoot);
     const message = adoptionMode === "contract-only" ? `No src/styles/tokens.css found. This export reads Decantr CSS tokens, but this project is contract-only Brownfield and may intentionally use its own Tailwind/Sass token system. Export from the app's token source or adopt a style bridge before using \`decantr export --to ${target}\`.` : "No src/styles/tokens.css found. Run `decantr refresh` to generate tokens.";
     console.error(`${RED4}${message}${RESET5}`);
     process.exitCode = 1;
     return;
   }
-  const tokensCSS = readFileSync14(tokensPath, "utf-8");
+  const tokensCSS = readFileSync15(tokensPath, "utf-8");
   const tokens = parseTokensCSS(tokensCSS);
   if (tokens.size === 0) {
     console.error(`${RED4}No --d-* tokens found in tokens.css.${RESET5}`);
@@ -5242,12 +5937,12 @@ async function cmdExport(target, projectRoot, options = {}) {
       const cssOut = resolveOutputPath(
         projectRoot,
         options.output,
-        join19(projectRoot, "src", "styles", "shadcn-theme.css")
+        join20(projectRoot, "src", "styles", "shadcn-theme.css")
       );
-      const jsonOut = join19(projectRoot, "components.json");
+      const jsonOut = join20(projectRoot, "components.json");
       ensureDir(cssOut);
-      writeFileSync12(cssOut, generateShadcnCSS(tokens), "utf-8");
-      writeFileSync12(jsonOut, generateShadcnComponentsJSON(), "utf-8");
+      writeFileSync13(cssOut, generateShadcnCSS(tokens), "utf-8");
+      writeFileSync13(jsonOut, generateShadcnComponentsJSON(), "utf-8");
       console.log(`${GREEN5}Exported shadcn theme:${RESET5}`);
       console.log(`  ${DIM5}CSS:${RESET5}  ${cssOut}`);
       console.log(`  ${DIM5}JSON:${RESET5} ${jsonOut}`);
@@ -5257,10 +5952,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join19(projectRoot, "tailwind.decantr.config.ts")
+        join20(projectRoot, "tailwind.decantr.config.ts")
       );
       ensureDir(out);
-      writeFileSync12(out, generateTailwindConfig(tokens), "utf-8");
+      writeFileSync13(out, generateTailwindConfig(tokens), "utf-8");
       console.log(`${GREEN5}Exported Tailwind config:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5269,10 +5964,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join19(projectRoot, "decantr-tokens.css")
+        join20(projectRoot, "decantr-tokens.css")
       );
       ensureDir(out);
-      writeFileSync12(out, generateCSSVars(tokens), "utf-8");
+      writeFileSync13(out, generateCSSVars(tokens), "utf-8");
       console.log(`${GREEN5}Exported CSS variables:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5281,10 +5976,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join19(projectRoot, ".decantr", "design", "figma-tokens.json")
+        join20(projectRoot, ".decantr", "design", "figma-tokens.json")
       );
       ensureDir(out);
-      writeFileSync12(out, generateFigmaTokens(tokens), "utf-8");
+      writeFileSync13(out, generateFigmaTokens(tokens), "utf-8");
       console.log(`${GREEN5}Exported Figma/Tokens Studio tokens:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5293,15 +5988,15 @@ async function cmdExport(target, projectRoot, options = {}) {
 }
 function ensureDir(filePath) {
   const dir = dirname5(filePath);
-  if (!existsSync17(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  if (!existsSync18(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
 }
 
 // src/commands/magic.ts
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import * as fs from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var BOLD4 = "\x1B[1m";
 var DIM6 = "\x1B[2m";
 var RESET6 = "\x1B[0m";
@@ -5525,8 +6220,8 @@ async function cmdMagic(prompt, projectRoot, options) {
     console.log(`   Archetype:    ${intent.archetype}`);
   }
   console.log("");
-  const essencePath = join20(projectRoot, "decantr.essence.json");
-  if (existsSync18(essencePath)) {
+  const essencePath = join21(projectRoot, "decantr.essence.json");
+  if (existsSync19(essencePath)) {
     const projectFlag = options.projectLabel ? ` --project ${options.projectLabel}` : "";
     console.log(`${YELLOW4} Decantr is already attached to this project.${RESET6}`);
     console.log(
@@ -5559,7 +6254,7 @@ async function cmdMagic(prompt, projectRoot, options) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join20(projectRoot, ".decantr", "cache"),
+    cacheDir: join21(projectRoot, ".decantr", "cache"),
     apiUrl: options.registry,
     offline: options.offline
   });
@@ -5830,14 +6525,14 @@ async function cmdMagic(prompt, projectRoot, options) {
   if (result.gitignoreUpdated) {
     console.log(`   ${dim(".gitignore updated")}`);
   }
-  const contextDir = join20(projectRoot, ".decantr", "context");
+  const contextDir = join21(projectRoot, ".decantr", "context");
   let sectionCount = 0;
   try {
     const files = await fs.readdir(contextDir);
     sectionCount = files.filter((f) => f.startsWith("section-")).length;
   } catch {
   }
-  const treatmentsPath = join20(projectRoot, "src", "styles", "treatments.css");
+  const treatmentsPath = join21(projectRoot, "src", "styles", "treatments.css");
   let hasLayers = false;
   try {
     const css = await fs.readFile(treatmentsPath, "utf-8");
@@ -5870,8 +6565,8 @@ ${GREEN6}${BOLD4}Quality summary:${RESET6}`);
 }
 
 // src/commands/migrate.ts
-import { copyFileSync, existsSync as existsSync19, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
-import { join as join21 } from "path";
+import { copyFileSync, existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "fs";
+import { join as join22 } from "path";
 import {
   isV4 as isV45,
   migrateToV4,
@@ -5884,12 +6579,12 @@ var YELLOW5 = "\x1B[33m";
 var RESET7 = "\x1B[0m";
 var DIM7 = "\x1B[2m";
 function migrateEssenceFile(essencePath) {
-  if (!existsSync19(essencePath)) {
+  if (!existsSync20(essencePath)) {
     return { success: false, error: `File not found: ${essencePath}` };
   }
   let raw;
   try {
-    raw = readFileSync15(essencePath, "utf-8");
+    raw = readFileSync16(essencePath, "utf-8");
   } catch (e) {
     return { success: false, error: `Could not read ${essencePath}: ${e.message}` };
   }
@@ -5930,7 +6625,7 @@ function migrateEssenceFile(essencePath) {
     };
   }
   try {
-    writeFileSync13(essencePath, JSON.stringify(v4, null, 2) + "\n");
+    writeFileSync14(essencePath, JSON.stringify(v4, null, 2) + "\n");
   } catch (e) {
     return {
       success: false,
@@ -5951,8 +6646,8 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join21(projectRoot, "decantr.essence.json");
-  if (!existsSync19(essencePath)) {
+  const essencePath = join22(projectRoot, "decantr.essence.json");
+  if (!existsSync20(essencePath)) {
     console.error(`${RED5}No decantr.essence.json found. Run \`decantr init\` first.${RESET7}`);
     process.exitCode = 1;
     return;
@@ -5974,7 +6669,7 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
   }
   if (result.essence) {
     const registryClient = new RegistryClient({
-      cacheDir: join21(projectRoot, ".decantr", "cache")
+      cacheDir: join22(projectRoot, ".decantr", "cache")
     });
     await refreshDerivedFiles(projectRoot, result.essence, registryClient);
     console.log(`${GREEN7}Derived context and execution packs refreshed.${RESET7}`);
@@ -5985,50 +6680,50 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
 
 // src/commands/new-project.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13 } from "fs";
-import { join as join23, resolve as resolve3 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14 } from "fs";
+import { join as join24, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/offline-content.ts
-import { cpSync, existsSync as existsSync20, mkdirSync as mkdirSync12 } from "fs";
-import { join as join22, resolve as resolve2 } from "path";
+import { cpSync, existsSync as existsSync21, mkdirSync as mkdirSync13 } from "fs";
+import { join as join23, resolve as resolve2 } from "path";
 var CONTENT_TYPES2 = ["archetypes", "blueprints", "patterns", "themes", "shells"];
 function copyIfExists(source, target) {
-  if (!existsSync20(source)) return false;
+  if (!existsSync21(source)) return false;
   if (resolve2(source) === resolve2(target)) return true;
   cpSync(source, target, { recursive: true });
   return true;
 }
 function hydrateContentRoot(projectDir, contentRoot) {
-  if (!existsSync20(contentRoot)) return false;
-  const customRoot = join22(projectDir, ".decantr", "custom");
-  const cacheRoot = join22(projectDir, ".decantr", "cache", "@official");
-  mkdirSync12(customRoot, { recursive: true });
-  mkdirSync12(cacheRoot, { recursive: true });
+  if (!existsSync21(contentRoot)) return false;
+  const customRoot = join23(projectDir, ".decantr", "custom");
+  const cacheRoot = join23(projectDir, ".decantr", "cache", "@official");
+  mkdirSync13(customRoot, { recursive: true });
+  mkdirSync13(cacheRoot, { recursive: true });
   let copiedAny = false;
   for (const type of CONTENT_TYPES2) {
-    const sourceDir = join22(contentRoot, type);
-    if (!existsSync20(sourceDir)) continue;
-    cpSync(sourceDir, join22(customRoot, type), { recursive: true });
-    cpSync(sourceDir, join22(cacheRoot, type), { recursive: true });
+    const sourceDir = join23(contentRoot, type);
+    if (!existsSync21(sourceDir)) continue;
+    cpSync(sourceDir, join23(customRoot, type), { recursive: true });
+    cpSync(sourceDir, join23(cacheRoot, type), { recursive: true });
     copiedAny = true;
   }
   return copiedAny;
 }
 function seedOfflineRegistry(projectDir, workspaceRoot) {
-  const projectDecantrRoot = join22(projectDir, ".decantr");
-  mkdirSync12(projectDecantrRoot, { recursive: true });
+  const projectDecantrRoot = join23(projectDir, ".decantr");
+  mkdirSync13(projectDecantrRoot, { recursive: true });
   const configuredContentRoot = process.env.DECANTR_CONTENT_DIR ? resolve2(process.env.DECANTR_CONTENT_DIR) : null;
   if (configuredContentRoot && hydrateContentRoot(projectDir, configuredContentRoot)) {
     return { seeded: true, strategy: "configured-content-root" };
   }
   const copiedCache = copyIfExists(
-    join22(workspaceRoot, ".decantr", "cache"),
-    join22(projectDecantrRoot, "cache")
+    join23(workspaceRoot, ".decantr", "cache"),
+    join23(projectDecantrRoot, "cache")
   );
   const copiedCustom = copyIfExists(
-    join22(workspaceRoot, ".decantr", "custom"),
-    join22(projectDecantrRoot, "custom")
+    join23(workspaceRoot, ".decantr", "custom"),
+    join23(projectDecantrRoot, "custom")
   );
   if (copiedCache || copiedCustom) {
     return { seeded: true, strategy: "workspace-cache" };
@@ -6141,7 +6836,7 @@ function runArgvCommand(command, args, cwd) {
 }
 function resolveInitCommand(initFlags) {
   const bundledCliEntrypoint = fileURLToPath2(new URL("./bin.js", import.meta.url));
-  const cliEntrypoint = existsSync21(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync21(process.argv[1]) ? process.argv[1] : null;
+  const cliEntrypoint = existsSync22(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync22(process.argv[1]) ? process.argv[1] : null;
   if (cliEntrypoint) {
     return {
       command: process.execPath,
@@ -6169,7 +6864,7 @@ async function cmdNewProject(projectName, options) {
     process.exitCode = 1;
     return;
   }
-  if (existsSync21(projectDir)) {
+  if (existsSync22(projectDir)) {
     console.error(error(`Directory "${projectName}" already exists.`));
     process.exitCode = 1;
     return;
@@ -6183,7 +6878,7 @@ async function cmdNewProject(projectName, options) {
     return;
   }
   console.log(heading(`Creating ${projectName}...`));
-  mkdirSync13(projectDir, { recursive: true });
+  mkdirSync14(projectDir, { recursive: true });
   console.log(dim2(`  Created ${projectName}/`));
   const title = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   if (shouldBootstrapRuntime && bootstrapAdapter) {
@@ -6282,21 +6977,21 @@ ${YELLOW6}Decantr init encountered issues. Run \`decantr init\` manually inside
   }
 }
 function detectPackageManager4() {
-  if (existsSync21(join23(process.cwd(), "pnpm-lock.yaml")) || existsSync21(join23(process.cwd(), "pnpm-workspace.yaml"))) {
+  if (existsSync22(join24(process.cwd(), "pnpm-lock.yaml")) || existsSync22(join24(process.cwd(), "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync21(join23(process.cwd(), "yarn.lock"))) {
+  if (existsSync22(join24(process.cwd(), "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync21(join23(process.cwd(), "bun.lockb")) || existsSync21(join23(process.cwd(), "bun.lock"))) {
+  if (existsSync22(join24(process.cwd(), "bun.lockb")) || existsSync22(join24(process.cwd(), "bun.lock"))) {
     return "bun";
   }
   return "npm";
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync22, readFileSync as readFileSync16 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
+import { join as join25 } from "path";
 import {
   API_CONTENT_TYPE_TO_CONTENT_TYPE,
   CONTENT_TYPE_TO_API_CONTENT_TYPE as CONTENT_TYPE_TO_API_CONTENT_TYPE2,
@@ -6312,8 +7007,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 = join24(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
-  if (!existsSync22(customPath)) {
+  const customPath = join25(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
+  if (!existsSync23(customPath)) {
     console.error(`Custom ${singularType} "${name}" not found at ${customPath}`);
     console.error(`Create one first: decantr create ${singularType} ${name}`);
     process.exitCode = 1;
@@ -6321,7 +7016,7 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
   }
   let data;
   try {
-    data = JSON.parse(readFileSync16(customPath, "utf-8"));
+    data = JSON.parse(readFileSync17(customPath, "utf-8"));
   } catch {
     console.error(`Failed to parse ${customPath}`);
     process.exitCode = 1;
@@ -6360,8 +7055,8 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
 
 // src/commands/refresh.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync23, readdirSync as readdirSync7, readFileSync as readFileSync17, statSync as statSync6 } from "fs";
-import { isAbsolute as isAbsolute2, join as join25, relative as relative6 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync18, statSync as statSync6 } from "fs";
+import { isAbsolute as isAbsolute2, join as join26, relative as relative6 } from "path";
 import { collectMissingPackManifestFiles as collectMissingPackManifestFiles2 } from "@decantr/verifier";
 import { isV4 as isV46 } from "@decantr/essence-spec";
 var GREEN9 = "\x1B[32m";
@@ -6369,13 +7064,13 @@ var RED7 = "\x1B[31m";
 var DIM9 = "\x1B[2m";
 var RESET9 = "\x1B[0m";
 function hashFile(path) {
-  return createHash("sha256").update(readFileSync17(path)).digest("hex");
+  return createHash("sha256").update(readFileSync18(path)).digest("hex");
 }
 function walkFiles(dir) {
-  if (!existsSync23(dir)) return [];
+  if (!existsSync24(dir)) return [];
   const files = [];
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-    const path = join25(dir, entry.name);
+    const path = join26(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkFiles(path));
     } else if (entry.isFile()) {
@@ -6386,10 +7081,10 @@ function walkFiles(dir) {
 }
 function trackedGeneratedFiles(projectRoot) {
   return [
-    join25(projectRoot, "DECANTR.md"),
-    ...walkFiles(join25(projectRoot, ".decantr", "context")),
-    ...["global.css", "tokens.css", "treatments.css", "decantr-bridge.css"].map((file) => join25(projectRoot, "src", "styles", file)).filter((path) => existsSync23(path))
-  ].filter((path) => existsSync23(path));
+    join26(projectRoot, "DECANTR.md"),
+    ...walkFiles(join26(projectRoot, ".decantr", "context")),
+    ...["global.css", "tokens.css", "treatments.css", "decantr-bridge.css"].map((file) => join26(projectRoot, "src", "styles", file)).filter((path) => existsSync24(path))
+  ].filter((path) => existsSync24(path));
 }
 function snapshotGeneratedFiles(projectRoot) {
   const map = /* @__PURE__ */ new Map();
@@ -6412,33 +7107,33 @@ function fileMtimeMs(path) {
 }
 function newestInputMtime(projectRoot) {
   return Math.max(
-    fileMtimeMs(join25(projectRoot, "decantr.essence.json")),
-    fileMtimeMs(join25(projectRoot, ".decantr", "project.json"))
+    fileMtimeMs(join26(projectRoot, "decantr.essence.json")),
+    fileMtimeMs(join26(projectRoot, ".decantr", "project.json"))
   );
 }
 function isContractOnlyProject2(projectRoot) {
-  const projectJsonPath = join25(projectRoot, ".decantr", "project.json");
-  if (!existsSync23(projectJsonPath)) return false;
+  const projectJsonPath = join26(projectRoot, ".decantr", "project.json");
+  if (!existsSync24(projectJsonPath)) return false;
   try {
-    const projectJson = JSON.parse(readFileSync17(projectJsonPath, "utf-8"));
+    const projectJson = JSON.parse(readFileSync18(projectJsonPath, "utf-8"));
     return projectJson.initialized?.adoptionMode === "contract-only";
   } catch {
     return false;
   }
 }
 function checkRefreshFreshness(projectRoot) {
-  const contextDir = join25(projectRoot, ".decantr", "context");
+  const contextDir = join26(projectRoot, ".decantr", "context");
   const generated = trackedGeneratedFiles(projectRoot);
   const reasons = [];
   const packHydrationOptional = isContractOnlyProject2(projectRoot);
-  if (!existsSync23(join25(projectRoot, "DECANTR.md"))) reasons.push("DECANTR.md is missing.");
-  if (!existsSync23(contextDir)) reasons.push(".decantr/context is missing.");
-  if (!existsSync23(join25(contextDir, "scaffold.md"))) {
+  if (!existsSync24(join26(projectRoot, "DECANTR.md"))) reasons.push("DECANTR.md is missing.");
+  if (!existsSync24(contextDir)) reasons.push(".decantr/context is missing.");
+  if (!existsSync24(join26(contextDir, "scaffold.md"))) {
     reasons.push(".decantr/context/scaffold.md is missing.");
   }
-  if (!packHydrationOptional && !existsSync23(join25(contextDir, "pack-manifest.json"))) {
+  if (!packHydrationOptional && !existsSync24(join26(contextDir, "pack-manifest.json"))) {
     reasons.push(".decantr/context/pack-manifest.json is missing.");
-  } else if (existsSync23(join25(contextDir, "pack-manifest.json"))) {
+  } else if (existsSync24(join26(contextDir, "pack-manifest.json"))) {
     const missingPackFiles = collectMissingPackManifestFiles2(projectRoot);
     if (missingPackFiles.length > 0) {
       reasons.push(
@@ -6491,7 +7186,7 @@ function summarizeChanges(projectRoot, before, after) {
 }
 function displayGeneratedPath(summary, file, displayRoot) {
   if (!displayRoot) return file;
-  const absolutePath = join25(summary.projectRoot, file);
+  const absolutePath = join26(summary.projectRoot, file);
   const relativePath = relative6(displayRoot, absolutePath).replace(/\\/g, "/");
   if (relativePath && !relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
     return relativePath;
@@ -6526,15 +7221,15 @@ function printRefreshSummary(summary, displayRoot) {
   }
 }
 async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
-  const essencePath = join25(projectRoot, "decantr.essence.json");
-  if (!existsSync23(essencePath)) {
+  const essencePath = join26(projectRoot, "decantr.essence.json");
+  if (!existsSync24(essencePath)) {
     console.error(`${RED7}No decantr.essence.json found. Run \`decantr init\` first.${RESET9}`);
     process.exitCode = 1;
     return;
   }
   let essence;
   try {
-    const raw = readFileSync17(essencePath, "utf-8");
+    const raw = readFileSync18(essencePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isV46(parsed)) {
       console.error(
@@ -6560,7 +7255,7 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join25(projectRoot, ".decantr", "cache"),
+    cacheDir: join26(projectRoot, ".decantr", "cache"),
     offline: options.offline
   });
   console.log("Regenerating derived files...\n");
@@ -6591,8 +7286,8 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
 }
 
 // src/commands/registry-mirror.ts
-import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync14 } from "fs";
-import { join as join26 } from "path";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "fs";
+import { join as join27 } from "path";
 import { API_CONTENT_TYPES, RegistryAPIClient as RegistryAPIClient2 } from "@decantr/registry";
 var GREEN10 = "\x1B[32m";
 var RED8 = "\x1B[31m";
@@ -6620,7 +7315,7 @@ async function cmdRegistryMirror(projectRoot, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const cacheDir = join26(projectRoot, ".decantr", "cache");
+  const cacheDir = join27(projectRoot, ".decantr", "cache");
   const counts = {};
   const failed = [];
   console.log(`
@@ -6630,19 +7325,19 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
     try {
       const result = await apiClient.listContent(type, { namespace: "@official" });
       const items = result.items;
-      const typeDir = join26(cacheDir, "@official", type);
-      mkdirSync14(typeDir, { recursive: true });
-      writeFileSync14(join26(typeDir, "index.json"), JSON.stringify(result, null, 2));
+      const typeDir = join27(cacheDir, "@official", type);
+      mkdirSync15(typeDir, { recursive: true });
+      writeFileSync15(join27(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);
-          writeFileSync14(join26(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
+          writeFileSync15(join27(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
           itemCount++;
         } catch {
-          writeFileSync14(join26(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
+          writeFileSync15(join27(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
           itemCount++;
         }
       }
@@ -6657,8 +7352,8 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
     mirrored_at: (/* @__PURE__ */ new Date()).toISOString(),
     counts
   };
-  mkdirSync14(join26(cacheDir), { recursive: true });
-  writeFileSync14(join26(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
+  mkdirSync15(join27(cacheDir), { recursive: true });
+  writeFileSync15(join27(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) {
@@ -6675,8 +7370,8 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
 }
 
 // src/commands/remove.ts
-import { existsSync as existsSync25, readFileSync as readFileSync18, rmSync as rmSync2, writeFileSync as writeFileSync15 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync19, rmSync as rmSync2, writeFileSync as writeFileSync16 } from "fs";
+import { join as join28 } from "path";
 import { isV4 as isV47 } from "@decantr/essence-spec";
 var GREEN11 = "\x1B[32m";
 var RED9 = "\x1B[31m";
@@ -6684,15 +7379,15 @@ var YELLOW8 = "\x1B[33m";
 var DIM11 = "\x1B[2m";
 var RESET11 = "\x1B[0m";
 function readV4Essence2(projectRoot) {
-  const essencePath = join27(projectRoot, "decantr.essence.json");
-  if (!existsSync25(essencePath)) {
+  const essencePath = join28(projectRoot, "decantr.essence.json");
+  if (!existsSync26(essencePath)) {
     console.error(`${RED9}No decantr.essence.json found. Run \`decantr init\` first.${RESET11}`);
     process.exitCode = 1;
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync19(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED9}Could not read essence: ${e.message}${RESET11}`);
     process.exitCode = 1;
@@ -6708,7 +7403,7 @@ function readV4Essence2(projectRoot) {
   return { essence: parsed, essencePath };
 }
 function writeEssence2(essencePath, essence) {
-  writeFileSync15(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync16(essencePath, JSON.stringify(essence, null, 2) + "\n");
 }
 function readFlagValue2(args, name) {
   const prefix = `--${name}=`;
@@ -6780,14 +7475,14 @@ async function cmdRemoveSection(sectionId, args, projectRoot = process.cwd()) {
   sections.splice(idx, 1);
   recomputeGlobalFeatures(essence);
   removeRoutes(essence, sectionId);
-  const contextFile = join27(projectRoot, ".decantr", "context", `${sectionId}.md`);
-  if (existsSync25(contextFile)) {
+  const contextFile = join28(projectRoot, ".decantr", "context", `${sectionId}.md`);
+  if (existsSync26(contextFile)) {
     rmSync2(contextFile);
   }
   writeEssence2(essencePath, essence);
   console.log(`${GREEN11}Removed section "${sectionId}".${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join27(projectRoot, ".decantr", "cache")
+    cacheDir: join28(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
@@ -6830,7 +7525,7 @@ async function cmdRemovePage(path, args, projectRoot = process.cwd()) {
   }
   console.log(`${GREEN11}Removed page "${pageId}" from section "${resolvedSectionId}".${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join27(projectRoot, ".decantr", "cache")
+    cacheDir: join28(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
@@ -6873,15 +7568,15 @@ async function cmdRemoveFeature(feature, args, projectRoot = process.cwd()) {
   const target = sectionId ? `section "${sectionId}" and global` : "global";
   console.log(`${GREEN11}Removed feature "${feature}" from ${target} features.${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join27(projectRoot, ".decantr", "cache")
+    cacheDir: join28(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
 }
 
 // src/commands/sync-drift.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
+import { join as join29 } from "path";
 var GREEN12 = "\x1B[32m";
 var RED10 = "\x1B[31m";
 var YELLOW9 = "\x1B[33m";
@@ -6890,8 +7585,8 @@ var DIM12 = "\x1B[2m";
 var BOLD6 = "\x1B[1m";
 var CYAN6 = "\x1B[36m";
 async function cmdSyncDrift(projectRoot = process.cwd()) {
-  const driftLogPath = join28(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync26(driftLogPath)) {
+  const driftLogPath = join29(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync27(driftLogPath)) {
     console.log(`${GREEN12}No drift log found \u2014 no drift recorded.${RESET12}`);
     console.log(
       `${DIM12}Drift is logged when guard violations are detected during development.${RESET12}`
@@ -6900,7 +7595,7 @@ async function cmdSyncDrift(projectRoot = process.cwd()) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync19(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync20(driftLogPath, "utf-8"));
   } catch {
     console.error(`${RED10}Could not parse drift-log.json${RESET12}`);
     process.exitCode = 1;
@@ -6946,13 +7641,13 @@ ${BOLD6}Unresolved Drift Entries (${unresolved.length})${RESET12}
   console.log("");
 }
 function resolveDriftEntries(projectRoot, options) {
-  const driftLogPath = join28(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync26(driftLogPath)) {
+  const driftLogPath = join29(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync27(driftLogPath)) {
     return { success: true };
   }
   if (options.clear) {
     try {
-      writeFileSync16(driftLogPath, "[]");
+      writeFileSync17(driftLogPath, "[]");
       return { success: true };
     } catch (e) {
       return { success: false, error: `Could not clear drift log: ${e.message}` };
@@ -6960,7 +7655,7 @@ function resolveDriftEntries(projectRoot, options) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync19(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync20(driftLogPath, "utf-8"));
   } catch {
     return { success: false, error: "Could not parse drift-log.json" };
   }
@@ -6979,7 +7674,7 @@ function resolveDriftEntries(projectRoot, options) {
     }
   }
   try {
-    writeFileSync16(driftLogPath, JSON.stringify(entries, null, 2));
+    writeFileSync17(driftLogPath, JSON.stringify(entries, null, 2));
     return { success: true };
   } catch (e) {
     return { success: false, error: `Could not write drift log: ${e.message}` };
@@ -7204,8 +7899,8 @@ function trimTrailingSlashes(value) {
 }
 
 // src/commands/theme-switch.ts
-import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
+import { join as join30 } from "path";
 import { isV4 as isV48 } from "@decantr/essence-spec";
 var GREEN14 = "\x1B[32m";
 var RED11 = "\x1B[31m";
@@ -7222,15 +7917,15 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join29(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) {
+  const essencePath = join30(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) {
     console.error(`${RED11}No decantr.essence.json found. Run \`decantr init\` first.${RESET14}`);
     process.exitCode = 1;
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync21(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED11}Could not read essence: ${e.message}${RESET14}`);
     process.exitCode = 1;
@@ -7281,7 +7976,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     essence.dna.theme.mode = mode;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join29(projectRoot, ".decantr", "cache")
+    cacheDir: join30(projectRoot, ".decantr", "cache")
   });
   try {
     const themeResult = await registryClient.fetchTheme(themeName);
@@ -7296,7 +7991,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     }
   } catch {
   }
-  writeFileSync17(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync18(essencePath, JSON.stringify(essence, null, 2) + "\n");
   console.log(`${GREEN14}Switched theme: ${oldThemeId} \u2192 ${themeName}${RESET14}`);
   if (shape) console.log(`  ${DIM14}Shape: ${shape}${RESET14}`);
   if (mode) console.log(`  ${DIM14}Mode: ${mode}${RESET14}`);
@@ -7604,8 +8299,8 @@ async function runSimplifiedInit(blueprints) {
 }
 
 // src/theme-commands.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync15, readdirSync as readdirSync8, readFileSync as readFileSync21, rmSync as rmSync3, writeFileSync as writeFileSync18 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync16, readdirSync as readdirSync8, readFileSync as readFileSync22, rmSync as rmSync3, writeFileSync as writeFileSync19 } from "fs";
+import { join as join31 } from "path";
 var REQUIRED_FIELDS = [
   "$schema",
   "id",
@@ -7665,20 +8360,20 @@ function validateCustomTheme(theme) {
   };
 }
 function createTheme(projectRoot, id, name) {
-  const customThemesDir = join30(projectRoot, ".decantr", "custom", "themes");
-  const themePath = join30(customThemesDir, `${id}.json`);
-  const howToPath = join30(customThemesDir, "how-to-theme.md");
-  mkdirSync15(customThemesDir, { recursive: true });
-  if (existsSync28(themePath)) {
+  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
+  const themePath = join31(customThemesDir, `${id}.json`);
+  const howToPath = join31(customThemesDir, "how-to-theme.md");
+  mkdirSync16(customThemesDir, { recursive: true });
+  if (existsSync29(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" already exists at ${themePath}`
     };
   }
   const skeleton = getThemeSkeleton(id, name);
-  writeFileSync18(themePath, JSON.stringify(skeleton, null, 2));
-  if (!existsSync28(howToPath)) {
-    writeFileSync18(howToPath, getHowToThemeDoc());
+  writeFileSync19(themePath, JSON.stringify(skeleton, null, 2));
+  if (!existsSync29(howToPath)) {
+    writeFileSync19(howToPath, getHowToThemeDoc());
   }
   return {
     success: true,
@@ -7686,17 +8381,17 @@ function createTheme(projectRoot, id, name) {
   };
 }
 function listCustomThemes(projectRoot) {
-  const customThemesDir = join30(projectRoot, ".decantr", "custom", "themes");
-  if (!existsSync28(customThemesDir)) {
+  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
+  if (!existsSync29(customThemesDir)) {
     return [];
   }
   const themes = [];
   try {
     const files = readdirSync8(customThemesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = join30(customThemesDir, file);
+      const filePath = join31(customThemesDir, file);
       try {
-        const data = JSON.parse(readFileSync21(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync22(filePath, "utf-8"));
         themes.push({
           id: data.id || file.replace(".json", ""),
           name: data.name || data.id,
@@ -7711,8 +8406,8 @@ function listCustomThemes(projectRoot) {
   return themes;
 }
 function deleteTheme(projectRoot, id) {
-  const themePath = join30(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
-  if (!existsSync28(themePath)) {
+  const themePath = join31(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
+  if (!existsSync29(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" not found at ${themePath}`
@@ -7729,7 +8424,7 @@ function deleteTheme(projectRoot, id) {
   }
 }
 function importTheme(projectRoot, sourcePath) {
-  if (!existsSync28(sourcePath)) {
+  if (!existsSync29(sourcePath)) {
     return {
       success: false,
       errors: [`Source file not found: ${sourcePath}`]
@@ -7737,7 +8432,7 @@ function importTheme(projectRoot, sourcePath) {
   }
   let theme;
   try {
-    theme = JSON.parse(readFileSync21(sourcePath, "utf-8"));
+    theme = JSON.parse(readFileSync22(sourcePath, "utf-8"));
   } catch (e) {
     return {
       success: false,
@@ -7753,14 +8448,14 @@ function importTheme(projectRoot, sourcePath) {
   }
   theme.source = "custom";
   const id = theme.id;
-  const customThemesDir = join30(projectRoot, ".decantr", "custom", "themes");
-  const destPath = join30(customThemesDir, `${id}.json`);
-  mkdirSync15(customThemesDir, { recursive: true });
-  const howToPath = join30(customThemesDir, "how-to-theme.md");
-  if (!existsSync28(howToPath)) {
-    writeFileSync18(howToPath, getHowToThemeDoc());
-  }
-  writeFileSync18(destPath, JSON.stringify(theme, null, 2));
+  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
+  const destPath = join31(customThemesDir, `${id}.json`);
+  mkdirSync16(customThemesDir, { recursive: true });
+  const howToPath = join31(customThemesDir, "how-to-theme.md");
+  if (!existsSync29(howToPath)) {
+    writeFileSync19(howToPath, getHowToThemeDoc());
+  }
+  writeFileSync19(destPath, JSON.stringify(theme, null, 2));
   return {
     success: true,
     path: destPath
@@ -8307,18 +9002,18 @@ function extractHostedAssetPaths(indexHtml) {
   return [...assetPaths];
 }
 function readHostedDistSnapshot(distPath) {
-  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join31(process.cwd(), "dist");
-  const indexPath = join31(resolvedDistPath, "index.html");
-  if (!existsSync29(indexPath)) {
+  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join32(process.cwd(), "dist");
+  const indexPath = join32(resolvedDistPath, "index.html");
+  if (!existsSync30(indexPath)) {
     return void 0;
   }
-  const indexHtml = readFileSync22(indexPath, "utf-8");
+  const indexHtml = readFileSync23(indexPath, "utf-8");
   const assetPaths = extractHostedAssetPaths(indexHtml);
   const assets = {};
   for (const assetPath of assetPaths) {
-    const assetFilePath = join31(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
-    if (existsSync29(assetFilePath)) {
-      assets[assetPath] = readFileSync22(assetFilePath, "utf-8");
+    const assetFilePath = join32(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
+    if (existsSync30(assetFilePath)) {
+      assets[assetPath] = readFileSync23(assetFilePath, "utf-8");
     }
   }
   return {
@@ -8333,7 +9028,7 @@ function isHostedSourceSnapshotFile(path) {
 function readHostedSourceSnapshot(sourcePath) {
   if (!sourcePath) return void 0;
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  if (!existsSync29(resolvedSourcePath)) {
+  if (!existsSync30(resolvedSourcePath)) {
     return void 0;
   }
   const files = {};
@@ -8349,15 +9044,15 @@ function readHostedSourceSnapshot(sourcePath) {
   const walk = (absoluteDir, relativeDir) => {
     for (const entry of readdirSync9(absoluteDir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join31(absoluteDir, entry.name);
-      const relativePath = join31(relativeDir, entry.name).replace(/\\/g, "/");
+      const absolutePath = join32(absoluteDir, entry.name);
+      const relativePath = join32(relativeDir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (!isHostedSourceSnapshotFile(relativePath)) continue;
-      files[relativePath] = readFileSync22(absolutePath, "utf-8");
+      files[relativePath] = readFileSync23(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -8550,24 +9245,24 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
 }
 async function compileHostedExecutionPackBundle(essencePath, namespace) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join31(process.cwd(), "decantr.essence.json");
-  if (!existsSync29(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+  if (!existsSync30(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync22(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync23(resolvedPath, "utf-8"));
   const bundle = await client.compileExecutionPacks(essence, namespace ? { namespace } : void 0);
-  const contextDir = join31(dirname6(resolvedPath), ".decantr", "context");
+  const contextDir = join32(dirname6(resolvedPath), ".decantr", "context");
   return { resolvedPath, bundle, contextDir };
 }
 function writeHostedExecutionPackContextArtifacts(contextDir, bundle) {
-  mkdirSync16(contextDir, { recursive: true });
+  mkdirSync17(contextDir, { recursive: true });
   return writeExecutionPackBundleArtifacts(contextDir, bundle);
 }
 function resolvePagePackIdForRoute(essencePath, route) {
-  if (!existsSync29(essencePath)) {
+  if (!existsSync30(essencePath)) {
     throw new Error(`Essence file not found at ${essencePath}`);
   }
-  const essence = JSON.parse(readFileSync22(essencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
   if (!isV49(essence)) {
     throw new Error("Route-based pack resolution requires Essence v4.0.0.");
   }
@@ -8582,14 +9277,14 @@ function resolvePagePackIdForRoute(essencePath, route) {
 }
 async function printHostedSelectedExecutionPack(packType, id, essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join31(process.cwd(), "decantr.essence.json");
-  if (!existsSync29(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+  if (!existsSync30(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(readFileSync22(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync23(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -8600,17 +9295,17 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join31(dirname6(resolvedPath), ".decantr", "context");
-    mkdirSync16(contextDir, { recursive: true });
-    writeFileSync19(
-      join31(contextDir, "pack-manifest.json"),
+    const contextDir = join32(dirname6(resolvedPath), ".decantr", "context");
+    mkdirSync17(contextDir, { recursive: true });
+    writeFileSync20(
+      join32(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`;
-    writeFileSync19(join31(contextDir, markdownFile), selected.pack.renderedMarkdown);
-    writeFileSync19(join31(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
+    writeFileSync20(join32(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync20(join32(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -8635,20 +9330,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) : join31(process.cwd(), "decantr.essence.json");
-  if (!existsSync29(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+  if (!existsSync30(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync22(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync23(resolvedPath, "utf-8"));
   const manifest = await client.getExecutionPackManifest(
     essence,
     namespace ? { namespace } : void 0
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join31(dirname6(resolvedPath), ".decantr", "context");
-    mkdirSync16(contextDir, { recursive: true });
-    writeFileSync19(join31(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const contextDir = join32(dirname6(resolvedPath), ".decantr", "context");
+    mkdirSync17(contextDir, { recursive: true });
+    writeFileSync20(join32(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -8669,14 +9364,14 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   }
 }
 async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join31(projectRoot, ".decantr", "context");
-  const reviewPackPath = join31(contextDir, "review-pack.json");
-  const manifestPath = join31(contextDir, "pack-manifest.json");
-  if (existsSync29(reviewPackPath) && existsSync29(manifestPath)) {
+  const contextDir = join32(projectRoot, ".decantr", "context");
+  const reviewPackPath = join32(contextDir, "review-pack.json");
+  const manifestPath = join32(contextDir, "pack-manifest.json");
+  if (existsSync30(reviewPackPath) && existsSync30(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join31(projectRoot, "decantr.essence.json");
-  if (!existsSync29(essencePath)) {
+  const essencePath = join32(projectRoot, "decantr.essence.json");
+  if (!existsSync30(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   const reviewHydration = await hydrateHostedReviewPackIfMissing(projectRoot, namespace);
@@ -8685,9 +9380,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync22(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync16(contextDir, { recursive: true });
+    mkdirSync17(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(contextDir, bundle);
     return { attempted: true, hydrated: true, scope: "bundle" };
   } catch {
@@ -8695,19 +9390,19 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
 }
 async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join31(projectRoot, ".decantr", "context");
-  const reviewPackPath = join31(contextDir, "review-pack.json");
-  const manifestPath = join31(contextDir, "pack-manifest.json");
-  if (existsSync29(reviewPackPath) && existsSync29(manifestPath)) {
+  const contextDir = join32(projectRoot, ".decantr", "context");
+  const reviewPackPath = join32(contextDir, "review-pack.json");
+  const manifestPath = join32(contextDir, "pack-manifest.json");
+  if (existsSync30(reviewPackPath) && existsSync30(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join31(projectRoot, "decantr.essence.json");
-  if (!existsSync29(essencePath)) {
+  const essencePath = join32(projectRoot, "decantr.essence.json");
+  if (!existsSync30(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync22(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -8715,14 +9410,14 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync16(contextDir, { recursive: true });
-    writeFileSync19(join31(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync19(
-      join31(contextDir, "review-pack.json"),
+    mkdirSync17(contextDir, { recursive: true });
+    writeFileSync20(join32(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync20(
+      join32(contextDir, "review-pack.json"),
       JSON.stringify(selected.pack, null, 2) + "\n"
     );
-    if (!existsSync29(manifestPath)) {
-      writeFileSync19(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
+    if (!existsSync30(manifestPath)) {
+      writeFileSync20(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
   } catch {
@@ -8732,17 +9427,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) : join31(process.cwd(), "decantr.essence.json");
-  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join31(process.cwd(), "src", "styles", "treatments.css");
-  if (!existsSync29(resolvedSourcePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join32(process.cwd(), "src", "styles", "treatments.css");
+  if (!existsSync30(resolvedSourcePath)) {
     throw new Error(`Source file not found at ${resolvedSourcePath}`);
   }
-  if (!existsSync29(resolvedEssencePath)) {
+  if (!existsSync30(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const code = readFileSync22(resolvedSourcePath, "utf-8");
-  const essence = JSON.parse(readFileSync22(resolvedEssencePath, "utf-8"));
-  const treatmentsCss = existsSync29(resolvedTreatmentsPath) ? readFileSync22(resolvedTreatmentsPath, "utf-8") : void 0;
+  const code = readFileSync23(resolvedSourcePath, "utf-8");
+  const essence = JSON.parse(readFileSync23(resolvedEssencePath, "utf-8"));
+  const treatmentsCss = existsSync30(resolvedTreatmentsPath) ? readFileSync23(resolvedTreatmentsPath, "utf-8") : void 0;
   const report = await client.critiqueFile(
     {
       essence,
@@ -8766,11 +9461,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) : join31(process.cwd(), "decantr.essence.json");
-  if (!existsSync29(resolvedEssencePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+  if (!existsSync30(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const essence = JSON.parse(readFileSync22(resolvedEssencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync23(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -8788,7 +9483,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) : join31(process.cwd(), "dist") : "none"}`
+    `  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join32(process.cwd(), "dist") : "none"}`
   );
   console.log(
     `  Source snapshot: ${sources && sourcesPath ? resolveUserPath(sourcesPath) : "none"}`
@@ -8888,24 +9583,43 @@ function patternCandidateFromRegistryItem(item, source) {
     { source, slug }
   );
 }
+function hostedPatternRefFromCandidate(candidate) {
+  const slug = candidate.slug || candidate.id;
+  return {
+    slug,
+    source: candidate.source ?? "registry",
+    name: candidate.name,
+    description: candidate.description,
+    tags: candidate.tags,
+    components: candidate.components,
+    interactions: candidate.interactions,
+    visualBrief: candidate.visual_brief
+  };
+}
+function findPatternCandidateBySlug(candidates, slug) {
+  const normalized = slug.toLowerCase();
+  return candidates.find(
+    (candidate) => candidate.slug?.toLowerCase() === normalized || candidate.id.toLowerCase() === normalized || candidate.name?.toLowerCase() === normalized
+  ) ?? null;
+}
 function readSuggestCodeContext(projectRoot, route, file) {
   const pieces = [];
   if (file) {
-    const resolved = isAbsolute3(file) ? file : join31(projectRoot, file);
-    if (existsSync29(resolved)) {
-      pieces.push(readFileSync22(resolved, "utf-8"));
+    const resolved = isAbsolute3(file) ? file : join32(projectRoot, file);
+    if (existsSync30(resolved)) {
+      pieces.push(readFileSync23(resolved, "utf-8"));
     }
   }
   if (route) {
-    const analysisPath = join31(projectRoot, ".decantr", "analysis.json");
-    if (existsSync29(analysisPath)) {
+    const analysisPath = join32(projectRoot, ".decantr", "analysis.json");
+    if (existsSync30(analysisPath)) {
       try {
-        const analysis = JSON.parse(readFileSync22(analysisPath, "utf-8"));
+        const analysis = JSON.parse(readFileSync23(analysisPath, "utf-8"));
         const routeEntry = analysis.routes?.routes?.find((entry) => entry.path === route);
         if (routeEntry?.file) {
-          const resolved = join31(projectRoot, routeEntry.file);
-          if (existsSync29(resolved)) {
-            pieces.push(readFileSync22(resolved, "utf-8"));
+          const resolved = join32(projectRoot, routeEntry.file);
+          if (existsSync30(resolved)) {
+            pieces.push(readFileSync23(resolved, "utf-8"));
           }
         }
       } catch {
@@ -8989,10 +9703,11 @@ async function cmdSuggest(query, options = {}) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join31(projectRoot, ".decantr", "cache")
+    cacheDir: join32(projectRoot, ".decantr", "cache")
   });
   const code = options.fromCode || options.file ? readSuggestCodeContext(projectRoot, options.route, options.file) : "";
   const localMatches = localPatternMatches(projectRoot, [query, code].filter(Boolean).join("\n"));
+  const bridgeMatches = styleBridgeMatches(projectRoot, [query, code].filter(Boolean).join("\n"));
   const candidates = await loadPatternDiscoveryCandidates(registryClient);
   const matches = rankPatternCandidates(
     {
@@ -9003,7 +9718,7 @@ async function cmdSuggest(query, options = {}) {
     },
     candidates
   );
-  if (matches.length === 0 && localMatches.length === 0) {
+  if (matches.length === 0 && localMatches.length === 0 && bridgeMatches.length === 0) {
     console.log(dim3(`No pattern suggestions for "${query}"`));
     console.log("");
     console.log("Try:");
@@ -9023,6 +9738,14 @@ async function cmdSuggest(query, options = {}) {
       `Pattern suggestions for "${query}"${contextBits.length > 0 ? ` (${contextBits.join(", ")})` : ""}`
     )
   );
+  if (bridgeMatches.length > 0) {
+    console.log(`${BOLD9}Project-owned style bridge:${RESET16}`);
+    for (const match of bridgeMatches) {
+      const hints = [...match.tokenHints, ...match.classHints].slice(0, 3).join(", ");
+      console.log(`  ${cyan3(match.id)}  ${match.label}${hints ? `  ${dim3(hints)}` : ""}`);
+    }
+    console.log("");
+  }
   if (localMatches.length > 0) {
     console.log(`${BOLD9}Project-owned local law:${RESET16}`);
     for (const match of localMatches) {
@@ -9067,7 +9790,7 @@ async function cmdGet(type, id) {
   }
   const apiType = CONTENT_TYPE_TO_API_CONTENT_TYPE3[type];
   const registryClient = new RegistryClient({
-    cacheDir: join31(process.cwd(), ".decantr", "cache")
+    cacheDir: join32(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
@@ -9084,10 +9807,10 @@ async function cmdGet(type, id) {
   return;
 }
 async function cmdValidate(path) {
-  const essencePath = path || join31(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join32(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync22(essencePath, "utf-8");
+    raw = readFileSync23(essencePath, "utf-8");
   } catch {
     console.error(error2(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -9154,7 +9877,7 @@ async function cmdList(type, sort, recommended, intelligenceSource, blueprintSet
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join31(process.cwd(), ".decantr", "cache")
+    cacheDir: join32(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(
     type,
@@ -9237,10 +9960,10 @@ ${CYAN9}Telemetry enabled.${RESET16} Decantr will send privacy-filtered CLI prod
 }
 function readCliPackageVersion2() {
   const here = dirname6(fileURLToPath3(import.meta.url));
-  const candidates = [join31(here, "..", "package.json"), join31(here, "..", "..", "package.json")];
+  const candidates = [join32(here, "..", "package.json"), join32(here, "..", "..", "package.json")];
   for (const candidate of candidates) {
     try {
-      const pkg = JSON.parse(readFileSync22(candidate, "utf-8"));
+      const pkg = JSON.parse(readFileSync23(candidate, "utf-8"));
       if (pkg.version) return pkg.version;
     } catch {
     }
@@ -9251,19 +9974,19 @@ function timestampForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function backupExistingEssence(projectRoot, label) {
-  const essencePath = join31(projectRoot, "decantr.essence.json");
-  if (!existsSync29(essencePath)) return null;
-  const backupPath = join31(
+  const essencePath = join32(projectRoot, "decantr.essence.json");
+  if (!existsSync30(essencePath)) return null;
+  const backupPath = join32(
     projectRoot,
     `decantr.essence.${label}.${timestampForFile()}.backup.json`
   );
-  writeFileSync19(backupPath, readFileSync22(essencePath, "utf-8"), "utf-8");
+  writeFileSync20(backupPath, readFileSync23(essencePath, "utf-8"), "utf-8");
   return backupPath;
 }
 function writeBrownfieldProjectJson(input) {
-  const decantrDir = join31(input.projectRoot, ".decantr");
-  mkdirSync16(join31(decantrDir, "context"), { recursive: true });
-  mkdirSync16(join31(decantrDir, "cache"), { recursive: true });
+  const decantrDir = join32(input.projectRoot, ".decantr");
+  mkdirSync17(join32(decantrDir, "context"), { recursive: true });
+  mkdirSync17(join32(decantrDir, "cache"), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const projectJson = {
     detected: {
@@ -9304,7 +10027,7 @@ function writeBrownfieldProjectJson(input) {
       }
     }
   };
-  writeFileSync19(join31(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
+  writeFileSync20(join32(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
 }
 async function applyAcceptedBrownfieldProposal(input) {
   const proposal = readBrownfieldProposal(input.projectRoot);
@@ -9320,8 +10043,8 @@ async function applyAcceptedBrownfieldProposal(input) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join31(input.projectRoot, "decantr.essence.json");
-  const hasEssence = existsSync29(essencePath);
+  const essencePath = join32(input.projectRoot, "decantr.essence.json");
+  const hasEssence = existsSync30(essencePath);
   let essence;
   let backupPath = null;
   if (input.mode === "accept" && hasEssence) {
@@ -9335,7 +10058,7 @@ async function applyAcceptedBrownfieldProposal(input) {
     return;
   }
   if (input.mode === "merge" && hasEssence) {
-    const existing = JSON.parse(readFileSync22(essencePath, "utf-8"));
+    const existing = JSON.parse(readFileSync23(essencePath, "utf-8"));
     if (!isV49(existing)) {
       console.log(
         error2(
@@ -9372,9 +10095,9 @@ async function applyAcceptedBrownfieldProposal(input) {
     assistantBridge: input.assistantBridge,
     mode: input.mode
   });
-  writeFileSync19(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
+  writeFileSync20(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
   const registryClient = new RegistryClient({
-    cacheDir: join31(input.projectRoot, ".decantr", "cache"),
+    cacheDir: join32(input.projectRoot, ".decantr", "cache"),
     offline: true,
     projectRoot: input.projectRoot
   });
@@ -9553,7 +10276,7 @@ async function cmdInit(args) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join31(projectRoot, ".decantr", "cache"),
+    cacheDir: join32(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline,
     projectRoot
@@ -9885,7 +10608,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
   if (appliedRuleFiles.length > 0) {
     console.log(`    ${dim3(`Rule bridge applied: ${appliedRuleFiles.join(", ")}`)}`);
   }
-  if (!existsSync29(join31(projectRoot, "package.json"))) {
+  if (!existsSync30(join32(projectRoot, "package.json"))) {
     console.log("");
     console.log(
       dim3(`  Note: ${cyan3("decantr init")} created Decantr contract/context files only.`)
@@ -9896,7 +10619,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
       )
     );
   }
-  const hasCompiledPacks = existsSync29(join31(projectRoot, ".decantr", "context", "scaffold-pack.md"));
+  const hasCompiledPacks = existsSync30(join32(projectRoot, ".decantr", "context", "scaffold-pack.md"));
   console.log("");
   console.log("  Next steps:");
   if (hasCompiledPacks) {
@@ -9936,7 +10659,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
   console.log(`    ${cyan3("decantr upgrade")}    Update to latest patterns`);
   console.log(`    ${cyan3("decantr check")}      Detect drift issues`);
   console.log(`    ${cyan3("decantr migrate --to v4")} Migrate older essence files to v4`);
-  const essenceContent = readFileSync22(result.essencePath, "utf-8");
+  const essenceContent = readFileSync23(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   const validation = validateEssence2(essence);
   if (!validation.valid) {
@@ -9991,16 +10714,16 @@ Validation warnings: ${validation.errors.join(", ")}`));
   }
 }
 async function cmdStatus(projectRoot = process.cwd()) {
-  const essencePath = join31(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join31(projectRoot, ".decantr", "project.json");
+  const essencePath = join32(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join32(projectRoot, ".decantr", "project.json");
   console.log(heading2("Decantr Project Status"));
-  if (!existsSync29(essencePath)) {
+  if (!existsSync30(essencePath)) {
     console.log(`${RED12}No decantr.essence.json found.${RESET16}`);
     console.log(dim3('Run "decantr init" to create one.'));
     return;
   }
   try {
-    const essence = JSON.parse(readFileSync22(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
     const essenceVersion = isV49(essence) ? "v4" : "legacy";
     console.log(`${BOLD9}Essence:${RESET16}`);
@@ -10048,9 +10771,9 @@ async function cmdStatus(projectRoot = process.cwd()) {
   }
   console.log("");
   console.log(`${BOLD9}Sync Status:${RESET16}`);
-  if (existsSync29(projectJsonPath)) {
+  if (existsSync30(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync22(projectJsonPath, "utf-8"));
+      const projectJson = JSON.parse(readFileSync23(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
@@ -10068,7 +10791,7 @@ async function cmdStatus(projectRoot = process.cwd()) {
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join31(projectRoot, ".decantr", "cache");
+  const cacheDir = join32(projectRoot, ".decantr", "cache");
   console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
@@ -10262,14 +10985,14 @@ ${BOLD9}Examples:${RESET16}
         process.exitCode = 1;
         return;
       }
-      const themePath = join31(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync29(themePath)) {
+      const themePath = join32(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync30(themePath)) {
         console.error(error2(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync22(themePath, "utf-8"));
+        const theme = JSON.parse(readFileSync23(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
           console.log(success3(`Custom theme "${name}" is valid`));
@@ -10401,7 +11124,7 @@ function withProject(command, projectArg) {
   return projectArg ? `${command} --project ${projectArg}` : command;
 }
 function displayProjectPath(workspaceInfo, projectPath) {
-  const absolutePath = join31(workspaceInfo.appRoot, projectPath);
+  const absolutePath = join32(workspaceInfo.appRoot, projectPath);
   const relativePath = relative7(workspaceInfo.cwd, absolutePath).replace(/\\/g, "/");
   if (relativePath && !relativePath.startsWith("..") && !isAbsolute3(relativePath)) {
     return relativePath;
@@ -10460,6 +11183,7 @@ function printWorkspaceProjectSelection(workspaceInfo, commandName = "command")
   console.log("");
   console.log("Start by attaching one app:");
   console.log(`  ${cyan3(`decantr adopt --project ${candidate} --yes`)}`);
+  console.log(`  ${cyan3(`decantr codify --from-audit --style-bridge --project ${candidate}`)}`);
   console.log("");
   console.log("Optional visual evidence after the app is running:");
   console.log(
@@ -10469,7 +11193,7 @@ function printWorkspaceProjectSelection(workspaceInfo, commandName = "command")
 function printMonorepoSetupGuidance(workspaceInfo) {
   const candidate = firstWorkspaceCandidate(workspaceInfo);
   const attachedProjects = workspaceInfo.appCandidates.filter(
-    (appCandidate) => existsSync29(join31(workspaceInfo.workspaceRoot, appCandidate, "decantr.essence.json"))
+    (appCandidate) => existsSync30(join32(workspaceInfo.workspaceRoot, appCandidate, "decantr.essence.json"))
   );
   const firstAttached = attachedProjects[0];
   console.log(heading2("Decantr Setup"));
@@ -10526,7 +11250,7 @@ function printMonorepoSetupGuidance(workspaceInfo) {
     `  ${cyan3(`decantr adopt --project ${candidate} --yes`)}          Attach Decantr to one app`
   );
   console.log(
-    `  ${cyan3(`decantr codify --from-audit --project ${candidate}`)}  Propose project-owned UI law`
+    `  ${cyan3(`decantr codify --from-audit --style-bridge --project ${candidate}`)}  Propose project-owned UI law and style bridge`
   );
   console.log("");
   console.log(`${BOLD9}Optional visual evidence:${RESET16}`);
@@ -10537,14 +11261,19 @@ function printMonorepoSetupGuidance(workspaceInfo) {
 function resolveWorkflowProject(flags, commandName = "command", options = {}) {
   const projectArg = flagString(flags, "project");
   const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
-  if (projectArg && options.requireExisting !== false && !existsSync29(workspaceInfo.appRoot)) {
+  if (projectArg && options.requireExisting !== false && !existsSync30(workspaceInfo.appRoot)) {
     printProjectNotFound(projectArg, commandName);
     process.exitCode = 1;
     return null;
   }
   if (projectArg && options.requireAppCandidate && workspaceInfo.appCandidates.length > 0) {
     const normalizedProject = normalizedProjectPath(projectArg);
-    const knownCandidate = normalizedProject ? workspaceInfo.appCandidates.includes(normalizedProject) : false;
+    const normalizedWorkspaceProject = normalizedProjectPath(
+      relative7(workspaceInfo.workspaceRoot, workspaceInfo.appRoot)
+    );
+    const knownCandidate = normalizedProject ? workspaceInfo.appCandidates.includes(normalizedProject) || Boolean(
+      normalizedWorkspaceProject && workspaceInfo.appCandidates.includes(normalizedWorkspaceProject)
+    ) : false;
     const forcePackage = flagBoolean(flags, "force-package") || flagBoolean(flags, "allow-package") || flagBoolean(flags, "force");
     if (!knownCandidate && !forcePackage && !options.allowPackageProject) {
       console.error(
@@ -10577,6 +11306,101 @@ function printWorkflowPlan(title, steps) {
   }
   console.log("");
 }
+function scanSeverityColor(finding) {
+  if (finding.severity === "success") return success3("ok");
+  if (finding.severity === "error") return error2("error");
+  if (finding.severity === "warn") return `${YELLOW12}warn${RESET16}`;
+  return cyan3("info");
+}
+function formatScanApplicability(status) {
+  if (status === "strong_fit") return success3("strong fit");
+  if (status === "partial_fit") return `${YELLOW12}partial fit${RESET16}`;
+  if (status === "not_applicable") return dim3("not applicable");
+  return dim3("unknown");
+}
+function printScanReport(report) {
+  console.log(heading2("Decantr Scan"));
+  console.log(dim3("Read-only Brownfield reconnaissance. No files were written."));
+  console.log("");
+  console.log(`${BOLD9}Verdict${RESET16}`);
+  console.log(`  ${formatScanApplicability(report.applicability.status)}  ${report.applicability.label}`);
+  console.log(
+    `  Confidence: ${cyan3(`${report.confidence.score}/100`)} (${report.confidence.level})`
+  );
+  for (const reason of report.applicability.reasons.slice(0, 3)) {
+    console.log(`  ${dim3("-")} ${reason}`);
+  }
+  console.log("");
+  console.log(`${BOLD9}Project${RESET16}`);
+  console.log(`  Framework:      ${cyan3(report.project.framework)}${report.project.frameworkVersion ? ` ${report.project.frameworkVersion}` : ""}`);
+  console.log(`  Package manager:${" "} ${report.project.packageManager}`);
+  console.log(`  Language:       ${report.project.primaryLanguage}`);
+  console.log(`  TypeScript:     ${report.project.hasTypeScript ? "yes" : "no"}`);
+  console.log(`  Decantr:        ${report.project.hasDecantr ? "present" : "not attached"}`);
+  console.log("");
+  console.log(`${BOLD9}Routes And Styling${RESET16}`);
+  console.log(`  Routes:         ${report.routes.count} (${report.routes.strategy})`);
+  for (const route of report.routes.items.slice(0, 8)) {
+    console.log(`    ${cyan3(route.path.padEnd(18))} ${dim3(route.file)}`);
+  }
+  if (report.routes.items.length > 8) {
+    console.log(`    ${dim3(`...${report.routes.items.length - 8} more route(s)`)}`);
+  }
+  console.log(`  Components:     ${report.components.componentCount}`);
+  console.log(
+    `  Styling:        ${report.styling.approach}${report.styling.configFile ? ` (${report.styling.configFile})` : ""}`
+  );
+  console.log(`  CSS variables:  ${report.styling.cssVariableCount}`);
+  console.log(`  Dark mode:      ${report.styling.darkMode ? "yes" : "no"}`);
+  console.log("");
+  if (report.staticHosting.githubPagesLikely || report.pagesProbe) {
+    console.log(`${BOLD9}Published Surface${RESET16}`);
+    console.log(`  GitHub Pages:   ${report.staticHosting.githubPagesLikely ? "likely" : "not detected"}`);
+    if (report.source.publishedSiteUrl) {
+      console.log(`  Site URL:       ${report.source.publishedSiteUrl}`);
+    }
+    if (report.pagesProbe?.checked) {
+      console.log(
+        `  HTTP probe:     ${report.pagesProbe.reachable ? success3("reachable") : `${YELLOW12}unreachable${RESET16}`} ${report.pagesProbe.status ?? ""}`
+      );
+      if (report.pagesProbe.title) console.log(`  Title:          ${report.pagesProbe.title}`);
+    }
+    for (const item of report.staticHosting.evidence.slice(0, 4)) {
+      console.log(`  ${dim3("-")} ${item}`);
+    }
+    console.log("");
+  }
+  console.log(`${BOLD9}Findings${RESET16}`);
+  for (const finding of report.findings.slice(0, 8)) {
+    console.log(`  [${scanSeverityColor(finding)}] ${finding.title}`);
+    console.log(`      ${finding.message}`);
+    if (finding.recommendation) console.log(`      ${dim3(finding.recommendation)}`);
+  }
+  console.log("");
+  console.log(`${BOLD9}Next Commands${RESET16}`);
+  for (const command of report.recommendedCommands) {
+    console.log(`  ${cyan3(command)}`);
+  }
+  console.log("");
+  console.log(dim3(report.privacy.notes[0] ?? "Scan completed without writing files."));
+}
+async function cmdScanWorkflow(args) {
+  const { flags } = parseLooseArgs(args);
+  if (!ensureAllowedFlags(flags, ["project", "json"], "scan")) return;
+  const workspaceInfo = resolveWorkflowProject(flags, "scan");
+  if (!workspaceInfo) return;
+  const jsonOutput = flagBoolean(flags, "json");
+  const projectArg = flagString(flags, "project");
+  const inputValue = projectArg ?? ".";
+  const report = await scanProjectReadOnly(workspaceInfo.appRoot, {
+    input: { kind: "local", value: inputValue }
+  });
+  if (jsonOutput) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  printScanReport(report);
+}
 async function cmdSetupWorkflow(args) {
   const { flags } = parseLooseArgs(args);
   const projectArg = flagString(flags, "project");
@@ -10597,21 +11421,27 @@ async function cmdSetupWorkflow(args) {
   console.log(`  Detected: ${formatDetection(detected)}`);
   console.log("");
   if (detected.existingEssence) {
-    const hasLocalPatterns = existsSync29(localPatternsPath(workspaceInfo.appRoot));
-    const hasLocalRules = existsSync29(localRulesPath(workspaceInfo.appRoot));
+    const hasLocalPatterns = existsSync30(localPatternsPath(workspaceInfo.appRoot));
+    const hasLocalRules = existsSync30(localRulesPath(workspaceInfo.appRoot));
+    const hasStyleBridge = existsSync30(styleBridgePath(workspaceInfo.appRoot));
     const verifyCommand = hasLocalPatterns || hasLocalRules ? "decantr verify --brownfield --local-patterns" : "decantr verify --brownfield";
     console.log(`${BOLD9}Recommended path:${RESET16} maintain an attached Decantr project`);
+    console.log(
+      `  ${cyan3(withProject("decantr doctor", projectArg))}                   Explain current state and next command`
+    );
+    if (!hasLocalPatterns || !hasLocalRules || !hasStyleBridge) {
+      const codifyCommand = hasLocalPatterns && hasLocalRules ? "decantr codify --style-bridge" : "decantr codify --from-audit --style-bridge";
+      console.log(
+        `  ${cyan3(withProject(codifyCommand, projectArg))}     Propose missing local law/style bridge`
+      );
+    }
     console.log(
       `  ${cyan3(withProject('decantr task <route> "<change>"', projectArg))}  Prepare LLM context before edits`
     );
     console.log(
       `  ${cyan3(withProject(verifyCommand, projectArg))}     Run local health and drift checks`
     );
-    if (!hasLocalPatterns || !hasLocalRules) {
-      console.log(
-        `  ${cyan3(withProject("decantr codify --from-audit", projectArg))}     Propose project-owned local law`
-      );
-    }
+    console.log(`  ${cyan3(withProject("decantr ci init", projectArg))}              Wire the app into CI`);
     return;
   }
   if (hasFootprint) {
@@ -10620,7 +11450,7 @@ async function cmdSetupWorkflow(args) {
       `  ${cyan3(withProject("decantr adopt --yes", projectArg))}                       Analyze, attach, and verify`
     );
     console.log(
-      `  ${cyan3(withProject("decantr codify --from-audit", projectArg))}               Propose local UI law`
+      `  ${cyan3(withProject("decantr codify --from-audit --style-bridge", projectArg))}               Propose local UI law and style bridge`
     );
     console.log("");
     console.log(`${BOLD9}Optional visual evidence after the app is running:${RESET16}`);
@@ -10679,7 +11509,7 @@ async function cmdAdoptWorkflow(args) {
   const hydratePacks = flagBoolean(flags, "packs", true) && !flagBoolean(flags, "skip-packs") && !flagBoolean(flags, "offline") && process.env.DECANTR_OFFLINE !== "true";
   const initCi = flagBoolean(flags, "ci") || flagBoolean(flags, "init-ci");
   const assistantBridge = flagString(flags, "assistant-bridge");
-  const hasEssence = existsSync29(join31(projectRoot, "decantr.essence.json"));
+  const hasEssence = existsSync30(join32(projectRoot, "decantr.essence.json"));
   const proposalFlag = flagBoolean(flags, "replace-essence") ? "--replace-essence" : flagBoolean(flags, "merge-proposal") || hasEssence ? "--merge-proposal" : "--accept-proposal";
   const steps = [
     "analyze current app and write .decantr/brownfield intelligence",
@@ -10727,7 +11557,7 @@ async function cmdAdoptWorkflow(args) {
   if (hydratePacks) {
     try {
       const { bundle, contextDir } = await compileHostedExecutionPackBundle(
-        join31(projectRoot, "decantr.essence.json")
+        join32(projectRoot, "decantr.essence.json")
       );
       const written = writeHostedExecutionPackContextArtifacts(
         contextDir,
@@ -10750,7 +11580,7 @@ async function cmdAdoptWorkflow(args) {
     console.log(dim3("Skipping hosted pack hydration in offline mode."));
   }
   if (runVerify) {
-    const { cmdHealth } = await import("./health-ADHNLMX3.js");
+    const { cmdHealth } = await import("./health-B4W7UJBZ.js");
     await cmdHealth(projectRoot, {
       browser: runBrowser,
       browserBaseUrl: baseUrl,
@@ -10768,10 +11598,10 @@ async function cmdAdoptWorkflow(args) {
   console.log("");
   console.log(`${BOLD9}Brownfield operating loop:${RESET16}`);
   console.log(
-    `  ${cyan3(withProject("decantr codify --from-audit", projectArg))}          Discover and propose project-owned UI law`
+    `  ${cyan3(withProject("decantr codify --from-audit --style-bridge", projectArg))}  Propose project-owned UI law and style bridge`
   );
   console.log(
-    `  ${cyan3(withProject("decantr codify --accept", projectArg))}              Accept reviewed local patterns and rules`
+    `  ${cyan3(withProject("decantr codify --accept", projectArg))}              Accept reviewed local patterns, rules, and bridge`
   );
   console.log(
     `  ${cyan3(withProject('decantr task <route> "<change>"', projectArg))}      Give your LLM route-specific context before edits`
@@ -10821,7 +11651,7 @@ async function cmdVerifyWorkflow(args) {
     return;
   }
   if (workspaceMode) {
-    const { cmdWorkspace } = await import("./workspace-YYCRXJNB.js");
+    const { cmdWorkspace } = await import("./workspace-7RU77ZZW.js");
     await cmdWorkspace(process.cwd(), ["workspace", "health", ...withoutWorkflowOnlyFlags(args)]);
     return;
   }
@@ -10854,7 +11684,7 @@ async function cmdVerifyWorkflow(args) {
   }
   let guardExitCode;
   if (brownfield) {
-    const { cmdHeal, collectCheckIssues } = await import("./heal-2UCSPRTK.js");
+    const { cmdHeal, collectCheckIssues } = await import("./heal-IRIDB7IZ.js");
     if (quietOutput) {
       const result = collectCheckIssues(workspaceInfo.appRoot, { brownfield: true });
       guardExitCode = result.issues.some((issue) => issue.type === "error") ? 1 : void 0;
@@ -10864,7 +11694,7 @@ async function cmdVerifyWorkflow(args) {
       process.exitCode = void 0;
     }
   }
-  const { cmdHealth, parseHealthArgs } = await import("./health-ADHNLMX3.js");
+  const { cmdHealth, parseHealthArgs } = await import("./health-B4W7UJBZ.js");
   await cmdHealth(workspaceInfo.appRoot, parseHealthArgs(healthArgs));
   if (localPatterns) {
     const validation = validateLocalLaw(workspaceInfo.appRoot);
@@ -10886,6 +11716,9 @@ async function cmdVerifyWorkflow(args) {
         console.log(`${GREEN16}Local pattern pack found:${RESET16} ${validation.patternsPath}`);
         if (validation.ruleManifestPresent) {
           console.log(`${GREEN16}Local rule manifest found:${RESET16} ${validation.rulesPath}`);
+          console.log(
+            `${DIM16}Enforcement: accepted .decantr/rules.json is the Decantr-scanned layer; --fail-on controls whether findings block.${RESET16}`
+          );
         } else {
           console.log(
             `${YELLOW12}Local rule manifest missing.${RESET16} Run ${cyan3("decantr codify --from-audit")} to propose .decantr/rules.json.`
@@ -10914,14 +11747,25 @@ async function cmdVerifyWorkflow(args) {
       }
     }
   }
+  const styleBridge = createStyleBridgeTaskSummary(workspaceInfo.appRoot);
+  if (!quietOutput && styleBridge.path) {
+    console.log("");
+    console.log(`${GREEN16}Style bridge found:${RESET16} ${styleBridge.path}`);
+    console.log(
+      `${DIM16}${styleBridge.mappingCount} mapping(s), ${styleBridge.stylingApproach ?? "unknown"} styling${styleBridge.themeModes.length > 0 ? `, themes: ${styleBridge.themeModes.join(", ")}` : ""}${RESET16}`
+    );
+    console.log(
+      `${DIM16}Enforcement: advisory style-intent mapping; pair with accepted local rules, lint, tests, or visual regression when it should block.${RESET16}`
+    );
+  }
   if (guardExitCode && guardExitCode !== 0 && (!process.exitCode || process.exitCode === 0)) {
     process.exitCode = guardExitCode;
   }
 }
 function readJsonIfPresent(path) {
-  if (!existsSync29(path)) return null;
+  if (!existsSync30(path)) return null;
   try {
-    return JSON.parse(readFileSync22(path, "utf-8"));
+    return JSON.parse(readFileSync23(path, "utf-8"));
   } catch {
     return null;
   }
@@ -10933,6 +11777,7 @@ function mentionsWord(text, term) {
 function createTaskAuthoritySummary(input) {
   const detected = detectProject(input.projectRoot);
   const hasLocalLaw = input.hasLocalPatterns || input.hasLocalRules;
+  const hasStyleBridge = input.hasStyleBridge || input.adoptionMode === "style-bridge";
   let lane = "Brownfield contract-only";
   let sourceAuthority = "Existing app is authoritative; Decantr supplies contract context.";
   let styleAuthority = "Use the existing styling system.";
@@ -10945,11 +11790,11 @@ function createTaskAuthoritySummary(input) {
     sourceAuthority = "Existing app remains authoritative except where Decantr CSS is explicitly adopted.";
     styleAuthority = "Decantr CSS runtime is active where adopted.";
     activeAuthorities.push("Decantr CSS runtime");
-  } else if (input.workflowMode === "brownfield-attach" && input.adoptionMode === "style-bridge") {
+  } else if (input.workflowMode === "brownfield-attach" && hasStyleBridge) {
     lane = "Hybrid style bridge";
     sourceAuthority = "Existing app remains authoritative; Decantr intent maps through the style bridge.";
     styleAuthority = "Use bridge tokens/classes as a mapping layer onto the app styling system.";
-    activeAuthorities.push("style bridge");
+    activeAuthorities.push("accepted style bridge");
   } else if (input.workflowMode === "brownfield-attach" && hasLocalLaw) {
     lane = "Hybrid local law";
     sourceAuthority = "Existing app plus accepted project-owned UI law are authoritative.";
@@ -11018,7 +11863,7 @@ async function cmdTaskWorkflow(args) {
   }
   const route = routeInput.startsWith("/") ? routeInput : `/${routeInput}`;
   const taskSummary = positional.slice(1).join(" ").trim();
-  const essencePath = join31(workspaceInfo.appRoot, "decantr.essence.json");
+  const essencePath = join32(workspaceInfo.appRoot, "decantr.essence.json");
   const essence = readJsonIfPresent(essencePath);
   if (!essence) {
     console.error(
@@ -11042,16 +11887,22 @@ async function cmdTaskWorkflow(args) {
   }
   const section = essence.blueprint.sections.find((entry) => entry.id === target.section);
   const page = section?.pages.find((entry) => entry.id === target.page);
-  const contextDir = join31(workspaceInfo.appRoot, ".decantr", "context");
-  const manifest = readJsonIfPresent(join31(contextDir, "pack-manifest.json"));
-  const projectJson = readJsonIfPresent(join31(workspaceInfo.appRoot, ".decantr", "project.json"));
+  const contextDir = join32(workspaceInfo.appRoot, ".decantr", "context");
+  const manifest = readJsonIfPresent(join32(contextDir, "pack-manifest.json"));
+  const projectJson = readJsonIfPresent(join32(workspaceInfo.appRoot, ".decantr", "project.json"));
   const pagePack = manifest?.pages?.find((entry) => entry.id === target.page);
   const sectionPack = manifest?.sections?.find((entry) => entry.id === target.section);
-  const visualManifest = readJsonIfPresent(join31(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
+  const visualManifest = readJsonIfPresent(join32(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
   const screenshot = visualManifest?.routes?.find((entry) => entry.route === route)?.screenshot;
   const localPatternPackPath = localPatternsPath(workspaceInfo.appRoot);
   const localRuleManifestPath = localRulesPath(workspaceInfo.appRoot);
+  const acceptedStyleBridgePath = styleBridgePath(workspaceInfo.appRoot);
   const localLaw = createLocalLawTaskSummary(workspaceInfo.appRoot);
+  const styleBridge = createStyleBridgeTaskSummary(workspaceInfo.appRoot);
+  const displayedStyleBridge = {
+    ...styleBridge,
+    path: styleBridge.path ? displayProjectPath(workspaceInfo, styleBridge.path) : null
+  };
   const displayedLocalLaw = {
     ...localLaw,
     patternsPath: localLaw.patternsPath ? displayProjectPath(workspaceInfo, localLaw.patternsPath) : null,
@@ -11064,10 +11915,11 @@ async function cmdTaskWorkflow(args) {
     projectRoot: workspaceInfo.appRoot,
     workflowMode: projectJson?.initialized?.workflowMode ?? null,
     adoptionMode: projectJson?.initialized?.adoptionMode ?? null,
-    hasLocalPatterns: existsSync29(localPatternPackPath),
-    hasLocalRules: existsSync29(localRuleManifestPath),
+    hasLocalPatterns: existsSync30(localPatternPackPath),
+    hasLocalRules: existsSync30(localRuleManifestPath),
     hasPackManifest: Boolean(manifest),
-    taskSummary
+    taskSummary,
+    hasStyleBridge: existsSync30(acceptedStyleBridgePath)
   });
   const context = {
     route,
@@ -11077,17 +11929,19 @@ async function cmdTaskWorkflow(args) {
     shell: page?.shell ?? section?.shell ?? null,
     patterns: page?.layout?.map(extractPatternName) ?? [],
     read: [
-      pagePack ? displayProjectPath(workspaceInfo, join31(".decantr/context", pagePack.markdown)) : null,
-      sectionPack ? displayProjectPath(workspaceInfo, join31(".decantr/context", sectionPack.markdown)) : null,
-      manifest?.scaffold?.markdown ? displayProjectPath(workspaceInfo, join31(".decantr/context", manifest.scaffold.markdown)) : null,
+      pagePack ? displayProjectPath(workspaceInfo, join32(".decantr/context", pagePack.markdown)) : null,
+      sectionPack ? displayProjectPath(workspaceInfo, join32(".decantr/context", sectionPack.markdown)) : null,
+      manifest?.scaffold?.markdown ? displayProjectPath(workspaceInfo, join32(".decantr/context", manifest.scaffold.markdown)) : null,
       displayProjectPath(workspaceInfo, ".decantr/context/scaffold.md"),
       displayProjectPath(workspaceInfo, "DECANTR.md"),
-      existsSync29(localPatternPackPath) ? displayProjectPath(workspaceInfo, ".decantr/local-patterns.json") : null,
-      existsSync29(localRuleManifestPath) ? displayProjectPath(workspaceInfo, ".decantr/rules.json") : null
+      existsSync30(localPatternPackPath) ? displayProjectPath(workspaceInfo, ".decantr/local-patterns.json") : null,
+      existsSync30(localRuleManifestPath) ? displayProjectPath(workspaceInfo, ".decantr/rules.json") : null,
+      existsSync30(acceptedStyleBridgePath) ? displayProjectPath(workspaceInfo, ".decantr/style-bridge.json") : null
     ].filter(Boolean),
     screenshot: screenshot?.startsWith(".decantr/") ? displayProjectPath(workspaceInfo, screenshot) : screenshot ?? null,
     authority,
     localLaw: displayedLocalLaw,
+    styleBridge: displayedStyleBridge,
     changedFiles: currentChangedFiles,
     changedRoutes,
     verifyCommand: withProject("decantr verify --brownfield --local-patterns", projectArg)
@@ -11132,10 +11986,17 @@ async function cmdTaskWorkflow(args) {
     }
     if (context.localLaw.rulesPath) {
       console.log(`  Rules: ${cyan3(context.localLaw.rulesPath)} (${context.localLaw.ruleCount})`);
+      console.log("  Enforcement: accepted local rules are the Decantr-scanned layer.");
     }
     for (const pattern of context.localLaw.patterns.slice(0, 4)) {
       const pathHint = pattern.componentPaths.length > 0 ? ` \u2014 ${pattern.componentPaths.slice(0, 2).join(", ")}` : "";
-      console.log(`  ${pattern.id}: ${pattern.role ?? "local pattern"}${pathHint}`);
+      const authorityHint = [
+        pattern.role ?? "local pattern",
+        pattern.confidenceTier ? `confidence ${pattern.confidenceTier}` : null,
+        pattern.enforcementLevel ? `${pattern.enforcementLevel}` : null,
+        pattern.hostedPatternRefs.length > 0 ? `maps ${pattern.hostedPatternRefs.slice(0, 2).join(", ")}` : null
+      ].filter(Boolean).join(" | ");
+      console.log(`  ${pattern.id}: ${authorityHint}${pathHint}`);
     }
   } else {
     console.log("");
@@ -11144,6 +12005,23 @@ async function cmdTaskWorkflow(args) {
       `  ${YELLOW12}Not codified yet.${RESET16} Run ${cyan3(withProject("decantr codify --from-audit", projectArg))} after adoption.`
     );
   }
+  if (context.styleBridge.path) {
+    console.log("");
+    console.log(`${BOLD9}Project-owned style bridge:${RESET16}`);
+    console.log(
+      `  Bridge: ${cyan3(context.styleBridge.path)} (${context.styleBridge.mappingCount} mappings, ${context.styleBridge.stylingApproach ?? "unknown"} styling)`
+    );
+    console.log(
+      "  Enforcement: advisory mapping layer; accepted local rules or project lint/tests do the blocking."
+    );
+    if (context.styleBridge.themeModes.length > 0) {
+      console.log(`  Theme modes: ${context.styleBridge.themeModes.join(", ")}`);
+    }
+    for (const mapping of context.styleBridge.mappings.slice(0, 4)) {
+      const hints = [...mapping.tokenHints, ...mapping.classHints].slice(0, 4).join(", ");
+      console.log(`  ${mapping.id}: ${mapping.label}${hints ? ` \u2014 ${hints}` : ""}`);
+    }
+  }
   if (context.changedFiles.length > 0) {
     console.log("");
     console.log(`${BOLD9}Changed-file context:${RESET16}`);
@@ -11169,7 +12047,16 @@ async function cmdCodifyWorkflow(args) {
   const projectArg = flagString(flags, "project");
   if (!ensureAllowedFlags(
     flags,
-    ["project", "from-audit", "discover-local-patterns", "codify-local-patterns", "accept"],
+    [
+      "project",
+      "from-audit",
+      "discover-local-patterns",
+      "codify-local-patterns",
+      "style-bridge",
+      "map-pattern",
+      "hosted-pattern",
+      "accept"
+    ],
     "codify"
   )) {
     return;
@@ -11177,25 +12064,29 @@ async function cmdCodifyWorkflow(args) {
   const workspaceInfo = resolveWorkflowProject(flags, "codify");
   if (!workspaceInfo) return;
   if (flagBoolean(flags, "accept")) {
-    if (!existsSync29(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync29(localRulesProposalPath(workspaceInfo.appRoot))) {
+    if (!existsSync30(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync30(localRulesProposalPath(workspaceInfo.appRoot)) && !existsSync30(styleBridgeProposalPath(workspaceInfo.appRoot))) {
       console.error(
         error2(
-          "No local law proposal found. Run `decantr codify --from-audit` or `decantr codify` first."
+          "No codify proposal found. Run `decantr codify --from-audit`, `decantr codify --style-bridge`, or `decantr codify` first."
         )
       );
       process.exitCode = 1;
       return;
     }
-    const result2 = acceptBrownfieldLocalLaw(workspaceInfo.appRoot);
-    if (result2.patternAcceptedPath) {
-      console.log(success3(`Accepted local pattern pack: ${result2.patternAcceptedPath}`));
+    const result = acceptBrownfieldLocalLaw(workspaceInfo.appRoot);
+    const bridgeAcceptedPath = acceptStyleBridge(workspaceInfo.appRoot);
+    if (result.patternAcceptedPath) {
+      console.log(success3(`Accepted local pattern pack: ${result.patternAcceptedPath}`));
     }
-    if (result2.rulesAcceptedPath) {
-      console.log(success3(`Accepted local rule manifest: ${result2.rulesAcceptedPath}`));
+    if (result.rulesAcceptedPath) {
+      console.log(success3(`Accepted local rule manifest: ${result.rulesAcceptedPath}`));
+    }
+    if (bridgeAcceptedPath) {
+      console.log(success3(`Accepted style bridge: ${bridgeAcceptedPath}`));
     }
     console.log(
       dim3(
-        "Hybrid local law is now active: Decantr will treat accepted local patterns and rules as project-owned authority in task and verify flows."
+        bridgeAcceptedPath ? "Hybrid style bridge is now active: Decantr will map design intent through accepted project tokens/classes in task, doctor, suggest, and CI flows." : "Hybrid local law is now active: Decantr will treat accepted local patterns and rules as project-owned authority in task and verify flows."
       )
     );
     console.log(
@@ -11207,19 +12098,84 @@ async function cmdCodifyWorkflow(args) {
   }
   const detected = detectProject(workspaceInfo.appRoot);
   const essence = readJsonIfPresent(
-    join31(workspaceInfo.appRoot, "decantr.essence.json")
+    join32(workspaceInfo.appRoot, "decantr.essence.json")
   );
   const fromAudit = flagBoolean(flags, "from-audit") || flagBoolean(flags, "discover-local-patterns") || flagBoolean(flags, "codify-local-patterns");
-  const proposal = createBrownfieldCodifyProposal({
-    projectRoot: workspaceInfo.appRoot,
-    detected,
-    essence,
-    fromAudit
-  });
-  const result = writeBrownfieldCodifyProposal(workspaceInfo.appRoot, proposal);
-  console.log(success3(`Wrote local pattern proposal: ${result.patternPath}`));
-  console.log(success3(`Wrote local rule proposal: ${result.rulesPath}`));
-  if (fromAudit) {
+  const wantsStyleBridge = flagBoolean(flags, "style-bridge");
+  const mapPatternSlug = flagString(flags, "map-pattern") ?? flagString(flags, "hosted-pattern");
+  if (mapPatternSlug) {
+    const registryClient = new RegistryClient({
+      cacheDir: join32(workspaceInfo.appRoot, ".decantr", "cache")
+    });
+    const candidates = await loadPatternDiscoveryCandidates(registryClient);
+    const candidate = findPatternCandidateBySlug(candidates, mapPatternSlug);
+    if (!candidate) {
+      const suggestions = rankPatternCandidates({ query: mapPatternSlug, limit: 5 }, candidates);
+      console.error(error2(`Could not find pattern "${mapPatternSlug}" to map into local law.`));
+      if (suggestions.length > 0) {
+        console.error(dim3("Closest registry patterns:"));
+        for (const suggestion of suggestions) {
+          const slug2 = suggestion.candidate.slug || suggestion.candidate.id;
+          console.error(dim3(`  ${slug2} - ${suggestion.candidate.name ?? slug2}`));
+        }
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const result = writeHostedPatternMappingProposal({
+      projectRoot: workspaceInfo.appRoot,
+      hostedPattern: hostedPatternRefFromCandidate(candidate)
+    });
+    const slug = candidate.slug || candidate.id;
+    console.log(
+      success3(
+        `${result.replacedExisting ? "Updated" : "Wrote"} hosted pattern mapping proposal: ${result.patternPath}`
+      )
+    );
+    console.log(
+      dim3(
+        `Mapped registry pattern "${slug}" into local pattern "${result.localPatternId}" as advisory Hybrid law. No source files were changed.`
+      )
+    );
+    console.log(
+      dim3(
+        `Fill in project-owned component paths, token/class recipes, variants, and exceptions, then run \`${withProject("decantr codify --accept", projectArg)}\`.`
+      )
+    );
+    return;
+  }
+  const wantsLocalLaw = !wantsStyleBridge || fromAudit;
+  let localResult = null;
+  if (wantsLocalLaw) {
+    const proposal = createBrownfieldCodifyProposal({
+      projectRoot: workspaceInfo.appRoot,
+      detected,
+      essence,
+      fromAudit
+    });
+    localResult = writeBrownfieldCodifyProposal(workspaceInfo.appRoot, proposal);
+  }
+  let styleBridgeResult = null;
+  if (wantsStyleBridge) {
+    const styling = scanStyling(workspaceInfo.appRoot);
+    styleBridgeResult = writeStyleBridgeProposal(
+      workspaceInfo.appRoot,
+      createStyleBridgeProposal({
+        projectRoot: workspaceInfo.appRoot,
+        detected,
+        essence,
+        styling
+      })
+    );
+  }
+  if (localResult) {
+    console.log(success3(`Wrote local pattern proposal: ${localResult.patternPath}`));
+    console.log(success3(`Wrote local rule proposal: ${localResult.rulesPath}`));
+  }
+  if (styleBridgeResult) {
+    console.log(success3(`Wrote style bridge proposal: ${styleBridgeResult}`));
+  }
+  if (fromAudit && localResult) {
     console.log(
       dim3(
         "Proposal includes source-derived component candidates, starter mechanical rules, and Hybrid authority guidance."
@@ -11228,7 +12184,7 @@ async function cmdCodifyWorkflow(args) {
   }
   console.log(
     dim3(
-      `Review both files, add real component paths/token recipes, map hosted pattern ideas into project-owned law, then run \`${withProject("decantr codify --accept", projectArg)}\`.`
+      `Review the proposal files, add real component paths/token/class recipes, map hosted pattern ideas into project-owned law, then run \`${withProject("decantr codify --accept", projectArg)}\`.`
     )
   );
 }
@@ -11277,13 +12233,14 @@ ${BOLD9}decantr${RESET16} \u2014 Design intelligence for AI-generated UI
 
 ${BOLD9}Usage:${RESET16}
   decantr setup [--project <path>]
+  decantr scan [--project <path>] [--json]
   decantr new <name> [--blueprint=X] [--archetype=X] [--theme=X] [--workflow=greenfield] [--adoption=decantr-css] [--telemetry]
   decantr adopt [--project <path>] [--base-url <url>] [--evidence] [--ci] [--no-packs] [--yes]
   decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]
   decantr verify [--project <path>] [--brownfield] [--local-patterns] [health options]
   decantr ci [--project <path>] [--workspace] [--fail-on error|warn|none]
   decantr doctor [--project <path>] [--workspace] [--json]
-  decantr codify [--from-audit] [--accept] [--project <path>]
+  decantr codify [--from-audit] [--style-bridge] [--map-pattern <slug>] [--accept] [--project <path>]
   decantr studio [--port 4319] [--host 127.0.0.1] [--report decantr-health.json] [--workspace]
 
 ${BOLD9}Advanced primitives:${RESET16}
@@ -11353,6 +12310,7 @@ ${BOLD9}Init Options:${RESET16}
 
 ${BOLD9}Commands:${RESET16}
   ${cyan3("setup")}       Detect project state and recommend the right Decantr workflow
+  ${cyan3("scan")}        Read-only Brownfield reconnaissance; no files written
   ${cyan3("new")}         Create a new greenfield workspace and bootstrap the available starter adapter
   ${cyan3("adopt")}       Brownfield one-liner: analyze, attach, verify, and show next steps
   ${cyan3("task")}        Prepare route/task context, local law, evidence, and changed-file impact for an AI coding assistant
@@ -11396,6 +12354,8 @@ ${BOLD9}Advanced commands:${RESET16}
 
 ${BOLD9}Examples:${RESET16}
   decantr setup
+  decantr scan
+  decantr scan --json
   decantr new my-app --blueprint=carbon-ai-portal
   decantr adopt --yes
   decantr adopt --project apps/web --yes
@@ -11407,6 +12367,7 @@ ${BOLD9}Examples:${RESET16}
   decantr ci --project apps/web
   decantr ci init --project apps/web
   decantr codify --from-audit
+  decantr codify --map-pattern hero --project apps/web
   decantr codify --accept
   decantr content check --ci --fail-on error
   decantr magic "AI chatbot with dark cyber theme \u2014 bold and futuristic"
@@ -11454,6 +12415,7 @@ ${BOLD9}Workflow Model:${RESET16}
   ${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 adopt --yes
+  ${cyan3("Brownfield preview")}     decantr scan -> decantr adopt --yes
   ${cyan3("Brownfield monorepo")}    decantr adopt --project apps/web --yes
   ${cyan3("Daily LLM work")}          decantr task <route> "<change>" -> decantr verify --brownfield --local-patterns
   ${cyan3("Project-owned law")}       decantr codify --from-audit -> edit proposal -> decantr codify --accept
@@ -11482,6 +12444,28 @@ ${BOLD9}Examples:${RESET16}
   decantr rules apply --project=apps/web
 `);
 }
+function cmdScanHelp() {
+  console.log(`
+${BOLD9}decantr scan${RESET16} \u2014 Read-only Brownfield reconnaissance
+
+${BOLD9}Usage:${RESET16}
+  decantr scan [--project <path>] [--json]
+
+${BOLD9}Options:${RESET16}
+  --project   App path inside a workspace/monorepo
+  --json      Emit the ScanReportV1 JSON to stdout
+
+${BOLD9}Behavior:${RESET16}
+  Reads local project files, detects frontend framework/routes/styling/static-hosting signals,
+  and prints a terminal report. It does not write .decantr files, install dependencies,
+  build the app, execute scripts, upload source, or open pull requests.
+
+${BOLD9}Examples:${RESET16}
+  decantr scan
+  decantr scan --project apps/web
+  decantr scan --json
+`);
+}
 function isCommandHelpRequest(args) {
   return args[1] === "help" || args.slice(1).some((arg) => arg === "--help" || arg === "-h");
 }
@@ -11703,15 +12687,19 @@ ${BOLD9}Examples:${RESET16}
 }
 function cmdCodifyHelp() {
   console.log(`
-${BOLD9}decantr codify${RESET16} \u2014 Propose or accept project-owned Brownfield UI patterns and rules
+${BOLD9}decantr codify${RESET16} \u2014 Propose or accept project-owned Brownfield UI law and style bridges
 
 ${BOLD9}Usage:${RESET16}
-  decantr codify [--from-audit] [--project <path>]
+  decantr codify [--from-audit] [--style-bridge] [--project <path>]
+  decantr codify --map-pattern <registry-pattern-slug> [--project <path>]
   decantr codify --accept [--project <path>]
 
 ${BOLD9}Examples:${RESET16}
   decantr codify
   decantr codify --from-audit
+  decantr codify --style-bridge
+  decantr codify --from-audit --style-bridge
+  decantr codify --map-pattern hero --project apps/web
   decantr codify --accept
   decantr verify --brownfield --local-patterns
 `);
@@ -11737,6 +12725,9 @@ function printCommandHelp(command, args) {
     case "setup":
       cmdSetupHelp();
       return true;
+    case "scan":
+      cmdScanHelp();
+      return true;
     case "adopt":
       cmdAdoptHelp();
       return true;
@@ -11794,10 +12785,10 @@ async function main() {
   if (command === "--version" || command === "-v" || command === "version") {
     try {
       const here = dirname6(fileURLToPath3(import.meta.url));
-      const candidates = [join31(here, "..", "package.json"), join31(here, "..", "..", "package.json")];
+      const candidates = [join32(here, "..", "package.json"), join32(here, "..", "..", "package.json")];
       for (const candidate of candidates) {
-        if (existsSync29(candidate)) {
-          const pkg = JSON.parse(readFileSync22(candidate, "utf-8"));
+        if (existsSync30(candidate)) {
+          const pkg = JSON.parse(readFileSync23(candidate, "utf-8"));
           if (pkg.version) {
             console.log(pkg.version);
             return;
@@ -11820,6 +12811,10 @@ async function main() {
       await cmdSetupWorkflow(args);
       break;
     }
+    case "scan": {
+      await cmdScanWorkflow(args);
+      break;
+    }
     case "adopt": {
       await cmdAdoptWorkflow(args);
       break;
@@ -11935,7 +12930,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-7ZYWR2GH.js");
+      const { cmdUpgrade } = await import("./upgrade-WBFE6EN7.js");
       const { flags } = parseLooseArgs(args);
       const workspaceInfo = resolveWorkflowProject(flags, "upgrade");
       if (!workspaceInfo) break;
@@ -11950,7 +12945,7 @@ async function main() {
           `${YELLOW12}Note: \`decantr heal\` is deprecated. Use \`decantr check\` instead.${RESET16}`
         );
       }
-      const { cmdHeal } = await import("./heal-2UCSPRTK.js");
+      const { cmdHeal } = await import("./heal-IRIDB7IZ.js");
       const { flags } = parseLooseArgs(args);
       const workspaceInfo = resolveWorkflowProject(flags, "check");
       if (!workspaceInfo) break;
@@ -11975,7 +12970,7 @@ async function main() {
         const { flags } = parseLooseArgs(args);
         const workspaceInfo = resolveWorkflowProject(flags, "health");
         if (!workspaceInfo) break;
-        const { cmdHealth, parseHealthArgs } = await import("./health-ADHNLMX3.js");
+        const { cmdHealth, parseHealthArgs } = await import("./health-B4W7UJBZ.js");
         await cmdHealth(workspaceInfo.appRoot, parseHealthArgs(stripProjectArgs(args)));
       } catch (e) {
         console.error(error2(e.message));
@@ -12003,7 +12998,7 @@ async function main() {
           cmdStudioHelp();
           break;
         }
-        const { cmdStudio, parseStudioArgs } = await import("./studio-GZFCCVSO.js");
+        const { cmdStudio, parseStudioArgs } = await import("./studio-JOEECLI6.js");
         await cmdStudio(process.cwd(), parseStudioArgs(args));
       } catch (e) {
         console.error(error2(e.message));
@@ -12017,7 +13012,7 @@ async function main() {
           cmdWorkspaceHelp();
           break;
         }
-        const { cmdWorkspace } = await import("./workspace-YYCRXJNB.js");
+        const { cmdWorkspace } = await import("./workspace-7RU77ZZW.js");
         await cmdWorkspace(process.cwd(), args);
       } catch (e) {
         console.error(error2(e.message));
@@ -12336,7 +13331,7 @@ async function main() {
           break;
         }
         if (packType === "page" && route && !id) {
-          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join31(process.cwd(), "decantr.essence.json");
+          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
           id = resolvePagePackIdForRoute(resolvedPath, route);
         }
         await printHostedSelectedExecutionPack(