@decantr/cli 2.7.0 → 2.8.0

package/dist/{chunk-ZYHR3BGT.js → chunk-QTPNV5WU.js}

@@ -34,10 +34,10 @@ import {
 } from "./chunk-KT2ROK2D.js";
 
 // src/index.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync13, readdirSync as readdirSync7, readFileSync as readFileSync20, writeFileSync as writeFileSync16 } from "fs";
-import { basename as basename2, dirname as dirname4, isAbsolute, join as join28, resolve as resolve4 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync14, readdirSync as readdirSync8, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "fs";
+import { basename as basename3, dirname as dirname4, isAbsolute, join as join29, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { evaluateGuard, isV4 as isV47, validateEssence as validateEssence2 } from "@decantr/essence-spec";
+import { evaluateGuard, isV4 as isV48, validateEssence as validateEssence2 } from "@decantr/essence-spec";
 import {
   CONTENT_TYPE_TO_API_CONTENT_TYPE as CONTENT_TYPE_TO_API_CONTENT_TYPE3,
   CONTENT_TYPES as GET_CONTENT_TYPES,
@@ -5271,6 +5271,488 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
   console.log(`${YELLOW7}Guard will flag code using old tokens. Run \`decantr check\`.${RESET12}`);
 }
 
+// src/local-law.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync25, mkdirSync as mkdirSync12, readdirSync as readdirSync5, readFileSync as readFileSync18, statSync as statSync5, writeFileSync as writeFileSync15 } from "fs";
+import { basename as basename2, extname, join as join26, relative as relative2, sep } from "path";
+import { isV4 as isV47 } from "@decantr/essence-spec";
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".astro",
+  ".html",
+  ".js",
+  ".jsx",
+  ".svelte",
+  ".ts",
+  ".tsx",
+  ".vue"
+]);
+var UI_TEMPLATE_EXTENSIONS = /* @__PURE__ */ new Set([".astro", ".html", ".jsx", ".svelte", ".tsx", ".vue"]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".decantr",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out"
+]);
+var DEFAULT_RULE_EXTENSIONS = [".astro", ".html", ".jsx", ".svelte", ".tsx", ".vue"];
+function localPatternsProposalPath(projectRoot) {
+  return join26(projectRoot, ".decantr", "local-patterns.proposal.json");
+}
+function localPatternsPath(projectRoot) {
+  return join26(projectRoot, ".decantr", "local-patterns.json");
+}
+function localRulesProposalPath(projectRoot) {
+  return join26(projectRoot, ".decantr", "rules.proposal.json");
+}
+function localRulesPath(projectRoot) {
+  return join26(projectRoot, ".decantr", "rules.json");
+}
+function readLocalPatternPack(projectRoot) {
+  return readJsonFile(localPatternsPath(projectRoot));
+}
+function readLocalRuleManifest(projectRoot) {
+  return readJsonFile(localRulesPath(projectRoot));
+}
+function createBrownfieldCodifyProposal(input) {
+  const sourceFiles = input.fromAudit ? listSourceFiles(input.projectRoot, 800) : [];
+  const evidence = summarizeSourceEvidence(input.projectRoot, sourceFiles);
+  const routes = input.essence && isV47(input.essence) ? Object.keys(input.essence.blueprint.routes ?? {}).sort() : [];
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const patternPack = {
+    version: 2,
+    generatedAt,
+    status: "proposal",
+    source: input.fromAudit ? "decantr codify --from-audit" : "decantr codify",
+    project: {
+      framework: input.detected.framework,
+      packageManager: input.detected.packageManager,
+      hasTailwind: input.detected.hasTailwind,
+      ruleFiles: input.detected.existingRuleFiles,
+      routeCount: routes.length
+    },
+    purpose: "Project-owned Brownfield UI law. Review and edit before accepting; Decantr treats this as authoritative only after it is copied to .decantr/local-patterns.json.",
+    patterns: [
+      {
+        id: "button",
+        label: "Button primitives",
+        role: "Actions and command triggers",
+        appliesTo: [
+          "primary action",
+          "secondary action",
+          "tertiary action",
+          "destructive action",
+          "icon action"
+        ],
+        componentPaths: evidence.buttonComponents,
+        decide: "Define primary, secondary, tertiary, destructive, icon-only, disabled, and loading button variants from this app.",
+        evidence: evidence.buttonComponents.length ? evidence.buttonComponents : [
+          "No obvious Button wrapper found yet. Add the project-owned wrapper path before strict enforcement."
+        ],
+        forbiddenAlternatives: ["New one-off button variants without updating this manifest."]
+      },
+      {
+        id: "surface-card",
+        label: "Cards and surfaces",
+        role: "Cards, panels, and reusable content surfaces",
+        appliesTo: ["cards", "panels", "modals", "list items", "dashboard tiles"],
+        componentPaths: evidence.cardComponents,
+        decide: "Define the canonical card background, border, radius, shadow, padding, density, and hover treatment.",
+        classHints: evidence.cardClassHints,
+        evidence: evidence.cardComponents.length ? evidence.cardComponents : [
+          "No obvious Card wrapper found yet. Add the project-owned wrapper path or class recipe."
+        ],
+        forbiddenAlternatives: ["Flat ad hoc cards with unique color/radius/shadow recipes."]
+      },
+      {
+        id: "page-shell",
+        label: "Page shell and spacing",
+        role: "Route shell, navigation, gutters, max-width, and scroll ownership",
+        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.",
+        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."
+        ]
+      },
+      {
+        id: "form-control",
+        label: "Form controls",
+        role: "Inputs, labels, validation, and form actions",
+        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.",
+        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."
+        ]
+      },
+      {
+        id: "theme-variant",
+        label: "Theme variants",
+        role: "Light, dark, brand, density, and tenant/theme variants observed in the app",
+        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.",
+        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."
+        ]
+      }
+    ],
+    starterRules: [
+      "Prefer project-owned wrappers for repeated primitives once they exist.",
+      "Avoid raw hex/rgb values in component templates unless documented as dynamic data.",
+      "Avoid static inline styles for reusable visual treatment.",
+      "When adding a new route, map it to an existing local pattern before inventing a new visual variant.",
+      "When adding a theme variant, update .decantr/theme-inventory.json and this local pattern pack."
+    ],
+    nextSteps: [
+      "Edit this proposal with real component paths and token/class recipes.",
+      "Run decantr codify --accept after review.",
+      "Use decantr task <route> before LLM edits so local law appears in task context.",
+      "Run decantr verify --brownfield --local-patterns after edits.",
+      "Wire deterministic project rules into ESLint, Biome, Storybook, visual tests, or CI where Decantr should not guess."
+    ]
+  };
+  const ruleManifest = {
+    version: 1,
+    status: "proposal",
+    generatedAt,
+    source: input.fromAudit ? "decantr codify --from-audit" : "decantr codify",
+    purpose: "Mechanical Brownfield checks owned by this project. These rules are intentionally local and stack-agnostic; edit before accepting.",
+    enforcement: {
+      defaultSeverity: "warn",
+      mode: "warn",
+      notes: [
+        "Decantr local rules are a guardrail, not a replacement for ESLint, Biome, type checks, tests, or visual regression.",
+        "Keep rules narrow enough that an LLM can fix findings without rewriting the app.",
+        "Use error severity only after the team agrees the rule is stable."
+      ]
+    },
+    rules: [
+      {
+        id: "no-inline-style",
+        type: "forbid-regex",
+        enabled: true,
+        severity: "warn",
+        description: "Reusable UI should not add static inline style attributes.",
+        includeExtensions: DEFAULT_RULE_EXTENSIONS,
+        pattern: "\\bstyle\\s*=",
+        message: "Inline style found in UI template.",
+        suggestedFix: "Move reusable visual treatment into the project style system, component wrapper, token, or documented local pattern.",
+        maxFindings: 25
+      },
+      {
+        id: "no-raw-color-literals",
+        type: "forbid-regex",
+        enabled: true,
+        severity: "warn",
+        description: "Component templates should not introduce raw hex/rgb color literals.",
+        includeExtensions: DEFAULT_RULE_EXTENSIONS,
+        pattern: "#(?:[0-9a-fA-F]{3,8})\\b|rgba?\\s*\\(",
+        message: "Raw color literal found in UI template.",
+        suggestedFix: "Use an existing project token/class, or document the exception in .decantr/local-patterns.json if the value is data-driven.",
+        maxFindings: 25
+      },
+      {
+        id: "prefer-button-wrapper",
+        type: "forbid-regex",
+        enabled: evidence.buttonComponents.length > 0,
+        severity: "info",
+        description: "Prefer the project-owned button primitive instead of new raw button markup.",
+        includeExtensions: DEFAULT_RULE_EXTENSIONS,
+        pattern: "<button[\\s>]",
+        message: "Raw <button> usage found outside the detected button wrapper.",
+        suggestedFix: "Use the project-owned Button primitive, or add this file to allowedPaths if it is the primitive implementation.",
+        allowedPaths: evidence.buttonComponents,
+        maxFindings: 50
+      }
+    ]
+  };
+  return { patternPack, ruleManifest };
+}
+function writeBrownfieldCodifyProposal(projectRoot, proposal) {
+  const decantrDir = join26(projectRoot, ".decantr");
+  mkdirSync12(decantrDir, { recursive: true });
+  const patternPath = localPatternsProposalPath(projectRoot);
+  const rulesPath = localRulesProposalPath(projectRoot);
+  writeFileSync15(patternPath, `${JSON.stringify(proposal.patternPack, null, 2)}
+`, "utf-8");
+  writeFileSync15(rulesPath, `${JSON.stringify(proposal.ruleManifest, null, 2)}
+`, "utf-8");
+  return { patternPath, rulesPath };
+}
+function acceptBrownfieldLocalLaw(projectRoot) {
+  const patternProposal = readJsonFile(localPatternsProposalPath(projectRoot));
+  const ruleProposal = readJsonFile(localRulesProposalPath(projectRoot));
+  const acceptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let patternAcceptedPath = null;
+  let rulesAcceptedPath = null;
+  if (patternProposal) {
+    patternProposal.status = "accepted";
+    patternProposal.acceptedAt = acceptedAt;
+    patternAcceptedPath = localPatternsPath(projectRoot);
+    writeFileSync15(patternAcceptedPath, `${JSON.stringify(patternProposal, null, 2)}
+`, "utf-8");
+  }
+  if (ruleProposal) {
+    ruleProposal.status = "accepted";
+    ruleProposal.acceptedAt = acceptedAt;
+    rulesAcceptedPath = localRulesPath(projectRoot);
+    writeFileSync15(rulesAcceptedPath, `${JSON.stringify(ruleProposal, null, 2)}
+`, "utf-8");
+  }
+  return { patternAcceptedPath, rulesAcceptedPath };
+}
+function validateLocalLaw(projectRoot) {
+  const patternsPath = localPatternsPath(projectRoot);
+  const rulesPath = localRulesPath(projectRoot);
+  const patternPack = readJsonFile(patternsPath);
+  const ruleManifest = readJsonFile(rulesPath);
+  const warnings = [];
+  if (patternPack) {
+    const patternIds = /* @__PURE__ */ new Set();
+    const patterns = Array.isArray(patternPack.patterns) ? patternPack.patterns : [];
+    if (patterns.length === 0) {
+      warnings.push(".decantr/local-patterns.json has no patterns.");
+    }
+    for (const pattern of patterns) {
+      const id = typeof pattern.id === "string" ? pattern.id.trim() : "";
+      if (!id) warnings.push("A local pattern is missing an id.");
+      if (id && patternIds.has(id)) warnings.push(`Duplicate local pattern id: ${id}`);
+      if (id) patternIds.add(id);
+      const paths = Array.isArray(pattern.componentPaths) ? pattern.componentPaths : [];
+      const evidence = Array.isArray(pattern.evidence) ? pattern.evidence : [];
+      const todoEvidence = Array.isArray(pattern.evidenceToCollect) ? pattern.evidenceToCollect : [];
+      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 (ruleManifest && !Array.isArray(ruleManifest.rules)) {
+    warnings.push(".decantr/rules.json has no rules array.");
+  }
+  const findings = ruleManifest ? scanLocalRules(projectRoot, ruleManifest) : [];
+  return {
+    patternsPath,
+    rulesPath,
+    patternPackPresent: Boolean(patternPack),
+    ruleManifestPresent: Boolean(ruleManifest),
+    warnings,
+    findings
+  };
+}
+function createLocalLawTaskSummary(projectRoot) {
+  const patternPack = readLocalPatternPack(projectRoot);
+  const ruleManifest = readLocalRuleManifest(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") : []
+  }));
+  const rules = (ruleManifest?.rules ?? []).map((rule) => ({
+    id: rule.id,
+    severity: rule.severity,
+    enabled: rule.enabled,
+    description: rule.description
+  }));
+  return {
+    patternsPath: patternPack ? ".decantr/local-patterns.json" : null,
+    rulesPath: ruleManifest ? ".decantr/rules.json" : null,
+    patternCount: patterns.length,
+    ruleCount: rules.length,
+    patterns,
+    rules
+  };
+}
+function changedFiles(projectRoot, since) {
+  const changed = /* @__PURE__ */ new Set();
+  try {
+    const commands = since ? [
+      ["diff", "--name-only", since, "--"],
+      ["diff", "--name-only", "--cached"]
+    ] : [
+      ["diff", "--name-only"],
+      ["diff", "--name-only", "--cached"]
+    ];
+    for (const args of commands) {
+      const output = execFileSync("git", args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const line of output.split(/\r?\n/)) {
+        const file = line.trim();
+        if (file) changed.add(normalizePath(file));
+      }
+    }
+  } catch {
+  }
+  return [...changed].sort();
+}
+function routeImpacts(projectRoot, files) {
+  const analysis = readJsonFile(
+    join26(projectRoot, ".decantr", "analysis.json")
+  );
+  const routeEntries = analysis?.routes?.routes ?? [];
+  const impacted = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    for (const route of routeEntries) {
+      if (route.file && pathMatches(file, route.file)) {
+        if (route.path) impacted.add(route.path);
+      }
+    }
+  }
+  return [...impacted].sort();
+}
+function scanLocalRules(projectRoot, manifest) {
+  const findings = [];
+  const files = listSourceFiles(projectRoot, 1200);
+  for (const rule of manifest.rules ?? []) {
+    if (!rule.enabled || rule.type !== "forbid-regex") continue;
+    const extensions = new Set(
+      rule.includeExtensions?.length ? rule.includeExtensions : DEFAULT_RULE_EXTENSIONS
+    );
+    let regex;
+    try {
+      regex = new RegExp(rule.pattern, "g");
+    } catch {
+      findings.push({
+        ruleId: rule.id,
+        severity: "error",
+        file: ".decantr/rules.json",
+        line: 1,
+        column: 1,
+        excerpt: rule.pattern,
+        message: `Invalid regex for local rule ${rule.id}.`,
+        suggestedFix: "Edit .decantr/rules.json so the pattern is a valid JavaScript regular expression."
+      });
+      continue;
+    }
+    let ruleFindingCount = 0;
+    for (const file of files) {
+      if (!extensions.has(extname(file.absolute))) continue;
+      if (pathAllowed(file.relative, rule.allowedPaths ?? [])) continue;
+      const contents = readFileSync18(file.absolute, "utf-8");
+      for (const match of contents.matchAll(regex)) {
+        const index = match.index ?? 0;
+        const position = lineColumnAt(contents, index);
+        findings.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          file: file.relative,
+          line: position.line,
+          column: position.column,
+          excerpt: lineAt(contents, position.line).trim().slice(0, 180),
+          message: rule.message,
+          suggestedFix: rule.suggestedFix
+        });
+        ruleFindingCount += 1;
+        if (rule.maxFindings && ruleFindingCount >= rule.maxFindings) break;
+      }
+      if (rule.maxFindings && ruleFindingCount >= rule.maxFindings) break;
+    }
+  }
+  return findings;
+}
+function summarizeSourceEvidence(projectRoot, files) {
+  const componentPaths = files.filter((file) => /(^|[/\\])components?([/\\]|$)|(^|[/\\])ui([/\\]|$)/i.test(file.relative)).map((file) => file.relative);
+  const byName = (terms) => componentPaths.filter((file) => terms.some((term) => basename2(file).toLowerCase().includes(term))).slice(0, 12);
+  const themeComponents = componentPaths.filter((file) => /theme|provider|mode|appearance|tenant|brand/i.test(file)).slice(0, 12);
+  const shellComponents = files.filter((file) => /layout|shell|frame|app|root|nav|sidebar/i.test(basename2(file.relative))).map((file) => file.relative).slice(0, 12);
+  return {
+    buttonComponents: byName(["button", "action"]),
+    cardComponents: byName(["card", "panel", "surface", "tile"]),
+    formComponents: byName(["input", "field", "form", "select", "textarea"]),
+    shellComponents,
+    themeComponents,
+    cardClassHints: collectClassHints(projectRoot, files, ["card", "panel", "surface", "tile"])
+  };
+}
+function collectClassHints(projectRoot, files, terms) {
+  const hints = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
+    const content = readFileSync18(join26(projectRoot, file.relative), "utf-8");
+    if (!terms.some((term) => content.toLowerCase().includes(term))) continue;
+    const matches = content.matchAll(/\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`]/g);
+    for (const match of matches) {
+      const value = match[1].trim();
+      if (!/(card|panel|surface|rounded|shadow|border|bg-|p-\d|px-|py-)/i.test(value)) continue;
+      hints.set(value, (hints.get(value) ?? 0) + 1);
+    }
+  }
+  return [...hints.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([hint]) => hint);
+}
+function listSourceFiles(projectRoot, maxFiles) {
+  const files = [];
+  const visit = (dir) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync5(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      if (IGNORED_DIRS.has(entry)) continue;
+      const absolute = join26(dir, entry);
+      let stat;
+      try {
+        stat = statSync5(absolute);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        visit(absolute);
+      } else if (stat.isFile() && SOURCE_EXTENSIONS.has(extname(entry))) {
+        files.push({ absolute, relative: normalizePath(relative2(projectRoot, absolute)) });
+      }
+    }
+  };
+  visit(projectRoot);
+  return files.sort((a, b) => a.relative.localeCompare(b.relative));
+}
+function readJsonFile(path) {
+  if (!existsSync25(path)) return null;
+  try {
+    return JSON.parse(readFileSync18(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function pathAllowed(file, allowedPaths) {
+  return allowedPaths.some((allowedPath) => pathMatches(file, allowedPath));
+}
+function pathMatches(file, pattern) {
+  const normalizedFile = normalizePath(file);
+  const normalizedPattern = normalizePath(pattern);
+  return normalizedFile === normalizedPattern || normalizedFile.endsWith(`/${normalizedPattern}`);
+}
+function normalizePath(path) {
+  return path.split(sep).join("/").replace(/\\/g, "/");
+}
+function lineColumnAt(contents, index) {
+  const before = contents.slice(0, index);
+  const lines = before.split(/\r?\n/);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function lineAt(contents, line) {
+  return contents.split(/\r?\n/)[line - 1] ?? "";
+}
+
 // src/prompts.ts
 import { createInterface } from "readline";
 var BOLD6 = "\x1B[1m";
@@ -5568,8 +6050,8 @@ async function runSimplifiedInit(blueprints) {
 }
 
 // src/theme-commands.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, readdirSync as readdirSync5, readFileSync as readFileSync18, rmSync as rmSync3, writeFileSync as writeFileSync15 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync13, readdirSync as readdirSync6, readFileSync as readFileSync19, rmSync as rmSync3, writeFileSync as writeFileSync16 } from "fs";
+import { join as join27 } from "path";
 var REQUIRED_FIELDS = [
   "$schema",
   "id",
@@ -5629,20 +6111,20 @@ function validateCustomTheme(theme) {
   };
 }
 function createTheme(projectRoot, id, name) {
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  const themePath = join26(customThemesDir, `${id}.json`);
-  const howToPath = join26(customThemesDir, "how-to-theme.md");
-  mkdirSync12(customThemesDir, { recursive: true });
-  if (existsSync25(themePath)) {
+  const customThemesDir = join27(projectRoot, ".decantr", "custom", "themes");
+  const themePath = join27(customThemesDir, `${id}.json`);
+  const howToPath = join27(customThemesDir, "how-to-theme.md");
+  mkdirSync13(customThemesDir, { recursive: true });
+  if (existsSync26(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" already exists at ${themePath}`
     };
   }
   const skeleton = getThemeSkeleton(id, name);
-  writeFileSync15(themePath, JSON.stringify(skeleton, null, 2));
-  if (!existsSync25(howToPath)) {
-    writeFileSync15(howToPath, getHowToThemeDoc());
+  writeFileSync16(themePath, JSON.stringify(skeleton, null, 2));
+  if (!existsSync26(howToPath)) {
+    writeFileSync16(howToPath, getHowToThemeDoc());
   }
   return {
     success: true,
@@ -5650,17 +6132,17 @@ function createTheme(projectRoot, id, name) {
   };
 }
 function listCustomThemes(projectRoot) {
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  if (!existsSync25(customThemesDir)) {
+  const customThemesDir = join27(projectRoot, ".decantr", "custom", "themes");
+  if (!existsSync26(customThemesDir)) {
     return [];
   }
   const themes = [];
   try {
-    const files = readdirSync5(customThemesDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync6(customThemesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = join26(customThemesDir, file);
+      const filePath = join27(customThemesDir, file);
       try {
-        const data = JSON.parse(readFileSync18(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync19(filePath, "utf-8"));
         themes.push({
           id: data.id || file.replace(".json", ""),
           name: data.name || data.id,
@@ -5675,8 +6157,8 @@ function listCustomThemes(projectRoot) {
   return themes;
 }
 function deleteTheme(projectRoot, id) {
-  const themePath = join26(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
-  if (!existsSync25(themePath)) {
+  const themePath = join27(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
+  if (!existsSync26(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" not found at ${themePath}`
@@ -5693,7 +6175,7 @@ function deleteTheme(projectRoot, id) {
   }
 }
 function importTheme(projectRoot, sourcePath) {
-  if (!existsSync25(sourcePath)) {
+  if (!existsSync26(sourcePath)) {
     return {
       success: false,
       errors: [`Source file not found: ${sourcePath}`]
@@ -5701,7 +6183,7 @@ function importTheme(projectRoot, sourcePath) {
   }
   let theme;
   try {
-    theme = JSON.parse(readFileSync18(sourcePath, "utf-8"));
+    theme = JSON.parse(readFileSync19(sourcePath, "utf-8"));
   } catch (e) {
     return {
       success: false,
@@ -5717,14 +6199,14 @@ function importTheme(projectRoot, sourcePath) {
   }
   theme.source = "custom";
   const id = theme.id;
-  const customThemesDir = join26(projectRoot, ".decantr", "custom", "themes");
-  const destPath = join26(customThemesDir, `${id}.json`);
-  mkdirSync12(customThemesDir, { recursive: true });
-  const howToPath = join26(customThemesDir, "how-to-theme.md");
-  if (!existsSync25(howToPath)) {
-    writeFileSync15(howToPath, getHowToThemeDoc());
-  }
-  writeFileSync15(destPath, JSON.stringify(theme, null, 2));
+  const customThemesDir = join27(projectRoot, ".decantr", "custom", "themes");
+  const destPath = join27(customThemesDir, `${id}.json`);
+  mkdirSync13(customThemesDir, { recursive: true });
+  const howToPath = join27(customThemesDir, "how-to-theme.md");
+  if (!existsSync26(howToPath)) {
+    writeFileSync16(howToPath, getHowToThemeDoc());
+  }
+  writeFileSync16(destPath, JSON.stringify(theme, null, 2));
   return {
     success: true,
     path: destPath
@@ -5732,19 +6214,19 @@ function importTheme(projectRoot, sourcePath) {
 }
 
 // src/workspace.ts
-import { existsSync as existsSync26, readdirSync as readdirSync6, readFileSync as readFileSync19 } from "fs";
-import { dirname as dirname3, join as join27, resolve as resolve3 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync7, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname3, join as join28, resolve as resolve3 } from "path";
 function readPackageJson(dir) {
-  const path = join27(dir, "package.json");
-  if (!existsSync26(path)) return null;
+  const path = join28(dir, "package.json");
+  if (!existsSync27(path)) return null;
   try {
-    return JSON.parse(readFileSync19(path, "utf-8"));
+    return JSON.parse(readFileSync20(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function hasWorkspaceMarker(dir) {
-  if (existsSync26(join27(dir, "pnpm-workspace.yaml")) || existsSync26(join27(dir, "turbo.json")) || existsSync26(join27(dir, "nx.json"))) {
+  if (existsSync27(join28(dir, "pnpm-workspace.yaml")) || existsSync27(join28(dir, "turbo.json")) || existsSync27(join28(dir, "nx.json"))) {
     return true;
   }
   const pkg = readPackageJson(dir);
@@ -5760,7 +6242,7 @@ function findWorkspaceRoot(startDir) {
   }
 }
 function looksLikeApp(dir) {
-  if (existsSync26(join27(dir, "next.config.js")) || existsSync26(join27(dir, "next.config.ts")) || existsSync26(join27(dir, "next.config.mjs")) || existsSync26(join27(dir, "vite.config.ts")) || existsSync26(join27(dir, "vite.config.js")) || existsSync26(join27(dir, "angular.json")) || existsSync26(join27(dir, "svelte.config.js")) || existsSync26(join27(dir, "svelte.config.ts")) || existsSync26(join27(dir, "astro.config.mjs")) || existsSync26(join27(dir, "src")) || existsSync26(join27(dir, "app")) || existsSync26(join27(dir, "pages"))) {
+  if (existsSync27(join28(dir, "next.config.js")) || existsSync27(join28(dir, "next.config.ts")) || existsSync27(join28(dir, "next.config.mjs")) || existsSync27(join28(dir, "vite.config.ts")) || existsSync27(join28(dir, "vite.config.js")) || existsSync27(join28(dir, "angular.json")) || existsSync27(join28(dir, "svelte.config.js")) || existsSync27(join28(dir, "svelte.config.ts")) || existsSync27(join28(dir, "astro.config.mjs")) || existsSync27(join28(dir, "src")) || existsSync27(join28(dir, "app")) || existsSync27(join28(dir, "pages"))) {
     return true;
   }
   const pkg = readPackageJson(dir);
@@ -5772,11 +6254,11 @@ function looksLikeApp(dir) {
 function listWorkspaceApps(workspaceRoot) {
   const candidates = [];
   for (const base of ["apps", "packages"]) {
-    const baseDir = join27(workspaceRoot, base);
-    if (!existsSync26(baseDir)) continue;
-    for (const entry of readdirSync6(baseDir, { withFileTypes: true })) {
+    const baseDir = join28(workspaceRoot, base);
+    if (!existsSync27(baseDir)) continue;
+    for (const entry of readdirSync7(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const candidate = join27(baseDir, entry.name);
+      const candidate = join28(baseDir, entry.name);
       if (looksLikeApp(candidate)) {
         candidates.push(`${base}/${entry.name}`);
       }
@@ -6341,18 +6823,18 @@ function extractHostedAssetPaths(indexHtml) {
   return [...assetPaths];
 }
 function readHostedDistSnapshot(distPath) {
-  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join28(process.cwd(), "dist");
-  const indexPath = join28(resolvedDistPath, "index.html");
-  if (!existsSync27(indexPath)) {
+  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join29(process.cwd(), "dist");
+  const indexPath = join29(resolvedDistPath, "index.html");
+  if (!existsSync28(indexPath)) {
     return void 0;
   }
-  const indexHtml = readFileSync20(indexPath, "utf-8");
+  const indexHtml = readFileSync21(indexPath, "utf-8");
   const assetPaths = extractHostedAssetPaths(indexHtml);
   const assets = {};
   for (const assetPath of assetPaths) {
-    const assetFilePath = join28(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
-    if (existsSync27(assetFilePath)) {
-      assets[assetPath] = readFileSync20(assetFilePath, "utf-8");
+    const assetFilePath = join29(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
+    if (existsSync28(assetFilePath)) {
+      assets[assetPath] = readFileSync21(assetFilePath, "utf-8");
     }
   }
   return {
@@ -6367,7 +6849,7 @@ function isHostedSourceSnapshotFile(path) {
 function readHostedSourceSnapshot(sourcePath) {
   if (!sourcePath) return void 0;
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  if (!existsSync27(resolvedSourcePath)) {
+  if (!existsSync28(resolvedSourcePath)) {
     return void 0;
   }
   const files = {};
@@ -6379,19 +6861,19 @@ function readHostedSourceSnapshot(sourcePath) {
     "build",
     "coverage"
   ]);
-  const rootPrefix = basename2(resolvedSourcePath);
+  const rootPrefix = basename3(resolvedSourcePath);
   const walk = (absoluteDir, relativeDir) => {
-    for (const entry of readdirSync7(absoluteDir, { withFileTypes: true })) {
+    for (const entry of readdirSync8(absoluteDir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join28(absoluteDir, entry.name);
-      const relativePath = join28(relativeDir, entry.name).replace(/\\/g, "/");
+      const absolutePath = join29(absoluteDir, entry.name);
+      const relativePath = join29(relativeDir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (!isHostedSourceSnapshotFile(relativePath)) continue;
-      files[relativePath] = readFileSync20(absolutePath, "utf-8");
+      files[relativePath] = readFileSync21(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -6542,16 +7024,16 @@ async function printRegistryIntelligenceSummary(namespace, jsonOutput = false) {
 }
 async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedPath, "utf-8"));
   const bundle = await client.compileExecutionPacks(essence, namespace ? { namespace } : void 0);
   let writtenContextPaths = [];
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync13(contextDir, { recursive: true });
+    const contextDir = join29(process.cwd(), ".decantr", "context");
+    mkdirSync14(contextDir, { recursive: true });
     const written = writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -6576,7 +7058,7 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
   console.log(`  Sections: ${typedBundle.sections.length}`);
   console.log(`  Mutations: ${typedBundle.mutations.length}`);
   if (writeContext) {
-    console.log(`  Context bundle: ${join28(process.cwd(), ".decantr", "context")}`);
+    console.log(`  Context bundle: ${join29(process.cwd(), ".decantr", "context")}`);
     console.log(`  Files written: ${writtenContextPaths.length}`);
   }
   console.log("");
@@ -6588,11 +7070,11 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
   }
 }
 function resolvePagePackIdForRoute(essencePath, route) {
-  if (!existsSync27(essencePath)) {
+  if (!existsSync28(essencePath)) {
     throw new Error(`Essence file not found at ${essencePath}`);
   }
-  const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
-  if (!isV47(essence)) {
+  const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
+  if (!isV48(essence)) {
     throw new Error("Route-based pack resolution requires Essence v4.0.0.");
   }
   const target = essence.blueprint.routes?.[route];
@@ -6606,14 +7088,14 @@ function resolvePagePackIdForRoute(essencePath, route) {
 }
 async function printHostedSelectedExecutionPack(packType, id, essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
   if ((packType === "section" || packType === "page" || packType === "mutation") && !id) {
     throw new Error(`Pack type "${packType}" requires an id.`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -6624,17 +7106,17 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync13(contextDir, { recursive: true });
-    writeFileSync16(
-      join28(contextDir, "pack-manifest.json"),
+    const contextDir = join29(process.cwd(), ".decantr", "context");
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(
+      join29(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`;
-    writeFileSync16(join28(contextDir, markdownFile), selected.pack.renderedMarkdown);
-    writeFileSync16(join28(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
+    writeFileSync17(join29(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync17(join29(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -6659,20 +7141,20 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
 }
 async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedPath, "utf-8"));
   const manifest = await client.getExecutionPackManifest(
     essence,
     namespace ? { namespace } : void 0
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync13(contextDir, { recursive: true });
-    writeFileSync16(join28(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const contextDir = join29(process.cwd(), ".decantr", "context");
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(join29(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -6693,14 +7175,14 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   }
 }
 async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join28(projectRoot, ".decantr", "context");
-  const reviewPackPath = join28(contextDir, "review-pack.json");
-  const manifestPath = join28(contextDir, "pack-manifest.json");
-  if (existsSync27(reviewPackPath) && existsSync27(manifestPath)) {
+  const contextDir = join29(projectRoot, ".decantr", "context");
+  const reviewPackPath = join29(contextDir, "review-pack.json");
+  const manifestPath = join29(contextDir, "pack-manifest.json");
+  if (existsSync28(reviewPackPath) && existsSync28(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) {
+  const essencePath = join29(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   const reviewHydration = await hydrateHostedReviewPackIfMissing(projectRoot, namespace);
@@ -6709,9 +7191,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync13(contextDir, { recursive: true });
+    mkdirSync14(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(contextDir, bundle);
     return { attempted: true, hydrated: true, scope: "bundle" };
   } catch {
@@ -6719,19 +7201,19 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
 }
 async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join28(projectRoot, ".decantr", "context");
-  const reviewPackPath = join28(contextDir, "review-pack.json");
-  const manifestPath = join28(contextDir, "pack-manifest.json");
-  if (existsSync27(reviewPackPath) && existsSync27(manifestPath)) {
+  const contextDir = join29(projectRoot, ".decantr", "context");
+  const reviewPackPath = join29(contextDir, "review-pack.json");
+  const manifestPath = join29(contextDir, "pack-manifest.json");
+  if (existsSync28(reviewPackPath) && existsSync28(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) {
+  const essencePath = join29(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -6739,14 +7221,14 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync13(contextDir, { recursive: true });
-    writeFileSync16(join28(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync16(
-      join28(contextDir, "review-pack.json"),
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(join29(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync17(
+      join29(contextDir, "review-pack.json"),
       JSON.stringify(selected.pack, null, 2) + "\n"
     );
-    if (!existsSync27(manifestPath)) {
-      writeFileSync16(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
+    if (!existsSync28(manifestPath)) {
+      writeFileSync17(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
   } catch {
@@ -6756,17 +7238,17 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
 async function printHostedFileCritique(sourcePath, namespace, jsonOutput = false, essencePath, treatmentsPath) {
   const client = getPublicAPIClient();
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join28(process.cwd(), "src", "styles", "treatments.css");
-  if (!existsSync27(resolvedSourcePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
+  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join29(process.cwd(), "src", "styles", "treatments.css");
+  if (!existsSync28(resolvedSourcePath)) {
     throw new Error(`Source file not found at ${resolvedSourcePath}`);
   }
-  if (!existsSync27(resolvedEssencePath)) {
+  if (!existsSync28(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const code = readFileSync20(resolvedSourcePath, "utf-8");
-  const essence = JSON.parse(readFileSync20(resolvedEssencePath, "utf-8"));
-  const treatmentsCss = existsSync27(resolvedTreatmentsPath) ? readFileSync20(resolvedTreatmentsPath, "utf-8") : void 0;
+  const code = readFileSync21(resolvedSourcePath, "utf-8");
+  const essence = JSON.parse(readFileSync21(resolvedEssencePath, "utf-8"));
+  const treatmentsCss = existsSync28(resolvedTreatmentsPath) ? readFileSync21(resolvedTreatmentsPath, "utf-8") : void 0;
   const report = await client.critiqueFile(
     {
       essence,
@@ -6790,11 +7272,11 @@ async function printHostedFileCritique(sourcePath, namespace, jsonOutput = false
 }
 async function printHostedProjectAudit(namespace, jsonOutput = false, essencePath, distPath, sourcesPath) {
   const client = getPublicAPIClient();
-  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
-  if (!existsSync27(resolvedEssencePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const essence = JSON.parse(readFileSync20(resolvedEssencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -6812,7 +7294,7 @@ async function printHostedProjectAudit(namespace, jsonOutput = false, essencePat
   console.log(heading2("Hosted Project Audit"));
   console.log(`  Essence: ${resolvedEssencePath}`);
   console.log(
-    `  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join28(process.cwd(), "dist") : "none"}`
+    `  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join29(process.cwd(), "dist") : "none"}`
   );
   console.log(
     `  Source snapshot: ${sources && sourcesPath ? resolveUserPath(sourcesPath) : "none"}`
@@ -6915,21 +7397,21 @@ function patternCandidateFromRegistryItem(item, source) {
 function readSuggestCodeContext(route, file) {
   const pieces = [];
   if (file) {
-    const resolved = isAbsolute(file) ? file : join28(process.cwd(), file);
-    if (existsSync27(resolved)) {
-      pieces.push(readFileSync20(resolved, "utf-8"));
+    const resolved = isAbsolute(file) ? file : join29(process.cwd(), file);
+    if (existsSync28(resolved)) {
+      pieces.push(readFileSync21(resolved, "utf-8"));
     }
   }
   if (route) {
-    const analysisPath = join28(process.cwd(), ".decantr", "analysis.json");
-    if (existsSync27(analysisPath)) {
+    const analysisPath = join29(process.cwd(), ".decantr", "analysis.json");
+    if (existsSync28(analysisPath)) {
       try {
-        const analysis = JSON.parse(readFileSync20(analysisPath, "utf-8"));
+        const analysis = JSON.parse(readFileSync21(analysisPath, "utf-8"));
         const routeEntry = analysis.routes?.routes?.find((entry) => entry.path === route);
         if (routeEntry?.file) {
-          const resolved = join28(process.cwd(), routeEntry.file);
-          if (existsSync27(resolved)) {
-            pieces.push(readFileSync20(resolved, "utf-8"));
+          const resolved = join29(process.cwd(), routeEntry.file);
+          if (existsSync28(resolved)) {
+            pieces.push(readFileSync21(resolved, "utf-8"));
           }
         }
       } catch {
@@ -6986,7 +7468,7 @@ async function cmdSuggest(query, options = {}) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join28(process.cwd(), ".decantr", "cache")
+    cacheDir: join29(process.cwd(), ".decantr", "cache")
   });
   const code = options.fromCode || options.file ? readSuggestCodeContext(options.route, options.file) : "";
   const candidates = await loadPatternDiscoveryCandidates(registryClient);
@@ -7048,7 +7530,7 @@ async function cmdGet(type, id) {
   }
   const apiType = CONTENT_TYPE_TO_API_CONTENT_TYPE3[type];
   const registryClient = new RegistryClient({
-    cacheDir: join28(process.cwd(), ".decantr", "cache")
+    cacheDir: join29(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
@@ -7065,10 +7547,10 @@ async function cmdGet(type, id) {
   return;
 }
 async function cmdValidate(path) {
-  const essencePath = path || join28(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join29(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync20(essencePath, "utf-8");
+    raw = readFileSync21(essencePath, "utf-8");
   } catch {
     console.error(error3(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -7082,7 +7564,7 @@ async function cmdValidate(path) {
     process.exitCode = 1;
     return;
   }
-  const detectedVersion = isV47(essence) ? "v4" : "legacy";
+  const detectedVersion = isV48(essence) ? "v4" : "legacy";
   console.log(`${DIM14}Detected essence version: ${detectedVersion}${RESET14}`);
   const result = validateEssence2(essence);
   if (result.valid) {
@@ -7135,7 +7617,7 @@ async function cmdList(type, sort, recommended, intelligenceSource, blueprintSet
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join28(process.cwd(), ".decantr", "cache")
+    cacheDir: join29(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(
     type,
@@ -7218,10 +7700,10 @@ ${CYAN8}Telemetry enabled.${RESET14} Decantr will send privacy-filtered CLI prod
 }
 function readCliPackageVersion() {
   const here = dirname4(fileURLToPath2(import.meta.url));
-  const candidates = [join28(here, "..", "package.json"), join28(here, "..", "..", "package.json")];
+  const candidates = [join29(here, "..", "package.json"), join29(here, "..", "..", "package.json")];
   for (const candidate of candidates) {
     try {
-      const pkg = JSON.parse(readFileSync20(candidate, "utf-8"));
+      const pkg = JSON.parse(readFileSync21(candidate, "utf-8"));
       if (pkg.version) return pkg.version;
     } catch {
     }
@@ -7232,19 +7714,19 @@ function timestampForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function backupExistingEssence(projectRoot, label) {
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync27(essencePath)) return null;
-  const backupPath = join28(
+  const essencePath = join29(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) return null;
+  const backupPath = join29(
     projectRoot,
     `decantr.essence.${label}.${timestampForFile()}.backup.json`
   );
-  writeFileSync16(backupPath, readFileSync20(essencePath, "utf-8"), "utf-8");
+  writeFileSync17(backupPath, readFileSync21(essencePath, "utf-8"), "utf-8");
   return backupPath;
 }
 function writeBrownfieldProjectJson(input) {
-  const decantrDir = join28(input.projectRoot, ".decantr");
-  mkdirSync13(join28(decantrDir, "context"), { recursive: true });
-  mkdirSync13(join28(decantrDir, "cache"), { recursive: true });
+  const decantrDir = join29(input.projectRoot, ".decantr");
+  mkdirSync14(join29(decantrDir, "context"), { recursive: true });
+  mkdirSync14(join29(decantrDir, "cache"), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const projectJson = {
     detected: {
@@ -7285,7 +7767,7 @@ function writeBrownfieldProjectJson(input) {
       }
     }
   };
-  writeFileSync16(join28(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
+  writeFileSync17(join29(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
 }
 async function applyAcceptedBrownfieldProposal(input) {
   const proposal = readBrownfieldProposal(input.projectRoot);
@@ -7301,8 +7783,8 @@ async function applyAcceptedBrownfieldProposal(input) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join28(input.projectRoot, "decantr.essence.json");
-  const hasEssence = existsSync27(essencePath);
+  const essencePath = join29(input.projectRoot, "decantr.essence.json");
+  const hasEssence = existsSync28(essencePath);
   let essence;
   let backupPath = null;
   if (input.mode === "accept" && hasEssence) {
@@ -7316,8 +7798,8 @@ async function applyAcceptedBrownfieldProposal(input) {
     return;
   }
   if (input.mode === "merge" && hasEssence) {
-    const existing = JSON.parse(readFileSync20(essencePath, "utf-8"));
-    if (!isV47(existing)) {
+    const existing = JSON.parse(readFileSync21(essencePath, "utf-8"));
+    if (!isV48(existing)) {
       console.log(
         error3(
           "Existing essence is not v4. Run `decantr migrate --to v4` before merging a brownfield proposal."
@@ -7353,9 +7835,9 @@ async function applyAcceptedBrownfieldProposal(input) {
     assistantBridge: input.assistantBridge,
     mode: input.mode
   });
-  writeFileSync16(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
+  writeFileSync17(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
   const registryClient = new RegistryClient({
-    cacheDir: join28(input.projectRoot, ".decantr", "cache"),
+    cacheDir: join29(input.projectRoot, ".decantr", "cache"),
     offline: true,
     projectRoot: input.projectRoot
   });
@@ -7509,7 +7991,7 @@ async function cmdInit(args) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join28(projectRoot, ".decantr", "cache"),
+    cacheDir: join29(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline,
     projectRoot
@@ -7839,7 +8321,7 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET14}`);
   if (appliedRuleFiles.length > 0) {
     console.log(`    ${dim3(`Rule bridge applied: ${appliedRuleFiles.join(", ")}`)}`);
   }
-  if (!existsSync27(join28(projectRoot, "package.json"))) {
+  if (!existsSync28(join29(projectRoot, "package.json"))) {
     console.log("");
     console.log(
       dim3(`  Note: ${cyan3("decantr init")} created Decantr contract/context files only.`)
@@ -7850,7 +8332,7 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET14}`);
       )
     );
   }
-  const hasCompiledPacks = existsSync27(join28(projectRoot, ".decantr", "context", "scaffold-pack.md"));
+  const hasCompiledPacks = existsSync28(join29(projectRoot, ".decantr", "context", "scaffold-pack.md"));
   console.log("");
   console.log("  Next steps:");
   if (hasCompiledPacks) {
@@ -7890,7 +8372,7 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET14}`);
   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 = readFileSync20(result.essencePath, "utf-8");
+  const essenceContent = readFileSync21(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   const validation = validateEssence2(essence);
   if (!validation.valid) {
@@ -7899,7 +8381,7 @@ Validation warnings: ${validation.errors.join(", ")}`));
   }
   console.log("");
   let promptPages;
-  if (isV47(essence)) {
+  if (isV48(essence)) {
     const allPages = essence.blueprint.sections.flatMap(
       (s) => s.pages.map((p) => ({ ...p, _sectionId: s.id, _shell: s.shell }))
     );
@@ -7946,25 +8428,25 @@ Validation warnings: ${validation.errors.join(", ")}`));
 }
 async function cmdStatus() {
   const projectRoot = process.cwd();
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join28(projectRoot, ".decantr", "project.json");
+  const essencePath = join29(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join29(projectRoot, ".decantr", "project.json");
   console.log(heading2("Decantr Project Status"));
-  if (!existsSync27(essencePath)) {
+  if (!existsSync28(essencePath)) {
     console.log(`${RED11}No decantr.essence.json found.${RESET14}`);
     console.log(dim3('Run "decantr init" to create one.'));
     return;
   }
   try {
-    const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
-    const essenceVersion = isV47(essence) ? "v4" : "legacy";
+    const essenceVersion = isV48(essence) ? "v4" : "legacy";
     console.log(`${BOLD7}Essence:${RESET14}`);
     if (validation.valid) {
       console.log(`  ${GREEN14}Valid${RESET14} (${essenceVersion})`);
     } else {
       console.log(`  ${RED11}Invalid: ${validation.errors.join(", ")}${RESET14}`);
     }
-    if (isV47(essence)) {
+    if (isV48(essence)) {
       const v4 = essence;
       const sections = v4.blueprint.sections;
       const flatPages = sections.flatMap((section) => section.pages ?? []);
@@ -8003,9 +8485,9 @@ async function cmdStatus() {
   }
   console.log("");
   console.log(`${BOLD7}Sync Status:${RESET14}`);
-  if (existsSync27(projectJsonPath)) {
+  if (existsSync28(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync20(projectJsonPath, "utf-8"));
+      const projectJson = JSON.parse(readFileSync21(projectJsonPath, "utf-8"));
       const syncStatus = projectJson.sync?.status || "unknown";
       const lastSync = projectJson.sync?.lastSync || "never";
       const source = projectJson.sync?.registrySource || "unknown";
@@ -8023,7 +8505,7 @@ async function cmdStatus() {
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join28(projectRoot, ".decantr", "cache");
+  const cacheDir = join29(projectRoot, ".decantr", "cache");
   console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
@@ -8218,14 +8700,14 @@ ${BOLD7}Examples:${RESET14}
         process.exitCode = 1;
         return;
       }
-      const themePath = join28(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync27(themePath)) {
+      const themePath = join29(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync28(themePath)) {
         console.error(error3(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync20(themePath, "utf-8"));
+        const theme = JSON.parse(readFileSync21(themePath, "utf-8"));
         const result = validateCustomTheme(theme);
         if (result.valid) {
           console.log(success3(`Custom theme "${name}" is valid`));
@@ -8385,8 +8867,8 @@ async function cmdSetupWorkflow(args) {
   if (detected.existingEssence) {
     console.log(`${BOLD7}Recommended path:${RESET14} maintain an attached Decantr project`);
     console.log(`  ${cyan3('decantr task <route> "<change>"')}  Prepare LLM context before edits`);
-    console.log(`  ${cyan3("decantr verify")}                  Run local health and drift checks`);
-    console.log(`  ${cyan3("decantr codify")}                  Propose project-owned UI patterns`);
+    console.log(`  ${cyan3("decantr verify --brownfield")}     Run local health and drift checks`);
+    console.log(`  ${cyan3("decantr codify --from-audit")}     Propose project-owned local law`);
     return;
   }
   if (hasFootprint) {
@@ -8395,7 +8877,7 @@ async function cmdSetupWorkflow(args) {
     console.log(
       `  ${cyan3("decantr adopt --base-url http://localhost:3000 --evidence --yes")}  Include visual evidence`
     );
-    console.log(`  ${cyan3("decantr codify")}                            Propose local UI law`);
+    console.log(`  ${cyan3("decantr codify --from-audit")}               Propose local UI law`);
     return;
   }
   console.log(`${BOLD7}Recommended path:${RESET14} greenfield start`);
@@ -8416,7 +8898,7 @@ async function cmdAdoptWorkflow(args) {
   const saveBaseline = flagBoolean(flags, "baseline", true) || flagBoolean(flags, "save-baseline");
   const initCi = flagBoolean(flags, "ci") || flagBoolean(flags, "init-ci");
   const assistantBridge = flagString(flags, "assistant-bridge");
-  const hasEssence = existsSync27(join28(projectRoot, "decantr.essence.json"));
+  const hasEssence = existsSync28(join29(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",
@@ -8476,10 +8958,12 @@ async function cmdAdoptWorkflow(args) {
     });
   }
   console.log("");
-  console.log(`${BOLD7}Next useful commands:${RESET14}`);
-  console.log(`  ${cyan3('decantr task <route> "<change>"')}  Give your LLM route-specific context`);
-  console.log(`  ${cyan3("decantr codify")}                  Propose project-owned UI patterns`);
-  console.log(`  ${cyan3("decantr verify --since-baseline")} Compare future work against this baseline`);
+  console.log(`${BOLD7}Brownfield operating loop:${RESET14}`);
+  console.log(`  ${cyan3("decantr codify --from-audit")}          Discover and propose project-owned UI law`);
+  console.log(`  ${cyan3("decantr codify --accept")}              Accept reviewed local patterns and rules`);
+  console.log(`  ${cyan3('decantr task <route> "<change>"')}      Give your LLM route-specific context before edits`);
+  console.log(`  ${cyan3("decantr verify --brownfield --local-patterns")}  Check contract, health, and local law after edits`);
+  console.log(`  ${cyan3("decantr verify --since-baseline")}      Compare future work against this baseline`);
 }
 async function cmdVerifyWorkflow(args) {
   const { flags } = parseLooseArgs(args);
@@ -8500,6 +8984,7 @@ async function cmdVerifyWorkflow(args) {
   const localPatterns = flagBoolean(flags, "local-patterns");
   const evidence = flagBoolean(flags, "evidence");
   const baseUrl = flagString(flags, "base-url");
+  const failOn = flagString(flags, "fail-on") ?? "error";
   const healthArgs = ["health", ...withoutWorkflowOnlyFlags(args)];
   if (flagBoolean(flags, "baseline") && !healthArgs.includes("--save-baseline")) {
     healthArgs.push("--save-baseline");
@@ -8535,16 +9020,51 @@ async function cmdVerifyWorkflow(args) {
   const { cmdHealth, parseHealthArgs } = await import("./health-ETZXWGTW.js");
   await cmdHealth(workspaceInfo.appRoot, parseHealthArgs(healthArgs));
   if (localPatterns) {
-    const localPatternsPath = join28(workspaceInfo.appRoot, ".decantr", "local-patterns.json");
-    if (!existsSync27(localPatternsPath)) {
-      console.log("");
-      console.log(
-        `${YELLOW9}Local pattern pack missing.${RESET14} Run ${cyan3("decantr codify --accept")} after reviewing the proposal.`
-      );
+    const validation = validateLocalLaw(workspaceInfo.appRoot);
+    if (!validation.patternPackPresent) {
+      if (!quietOutput) {
+        console.log("");
+        console.log(
+          `${YELLOW9}Local pattern pack missing.${RESET14} Run ${cyan3("decantr codify --from-audit")}, review the proposal, then run ${cyan3("decantr codify --accept")}.`
+        );
+      }
       process.exitCode = process.exitCode || 1;
     } else {
-      console.log("");
-      console.log(`${GREEN14}Local pattern pack found:${RESET14} ${localPatternsPath}`);
+      const blockingFindings = failOn === "none" ? [] : validation.findings.filter(
+        (finding) => failOn === "warn" ? finding.severity === "warn" || finding.severity === "error" : finding.severity === "error"
+      );
+      const blockingWarnings = failOn === "warn" ? validation.warnings : [];
+      if (!quietOutput) {
+        console.log("");
+        console.log(`${GREEN14}Local pattern pack found:${RESET14} ${validation.patternsPath}`);
+        if (validation.ruleManifestPresent) {
+          console.log(`${GREEN14}Local rule manifest found:${RESET14} ${validation.rulesPath}`);
+        } else {
+          console.log(
+            `${YELLOW9}Local rule manifest missing.${RESET14} Run ${cyan3("decantr codify --from-audit")} to propose .decantr/rules.json.`
+          );
+        }
+        for (const warning of validation.warnings.slice(0, 8)) {
+          console.log(`${YELLOW9}warn${RESET14} ${warning}`);
+        }
+        if (validation.findings.length > 0) {
+          console.log("");
+          console.log(`${BOLD7}Local law findings:${RESET14}`);
+          for (const finding of validation.findings.slice(0, 20)) {
+            console.log(
+              `  ${finding.severity.toUpperCase()} ${finding.ruleId} ${finding.file}:${finding.line}:${finding.column} ${finding.message}`
+            );
+          }
+          if (validation.findings.length > 20) {
+            console.log(dim3(`  ...${validation.findings.length - 20} more finding(s)`));
+          }
+        } else if (validation.ruleManifestPresent) {
+          console.log(`${GREEN14}Local rule checks passed.${RESET14}`);
+        }
+      }
+      if (blockingFindings.length > 0 || blockingWarnings.length > 0) {
+        process.exitCode = process.exitCode || 1;
+      }
     }
   }
   if (guardExitCode && guardExitCode !== 0 && (!process.exitCode || process.exitCode === 0)) {
@@ -8552,9 +9072,9 @@ async function cmdVerifyWorkflow(args) {
   }
 }
 function readJsonIfPresent(path) {
-  if (!existsSync27(path)) return null;
+  if (!existsSync28(path)) return null;
   try {
-    return JSON.parse(readFileSync20(path, "utf-8"));
+    return JSON.parse(readFileSync21(path, "utf-8"));
   } catch {
     return null;
   }
@@ -8565,20 +9085,20 @@ async function cmdTaskWorkflow(args) {
   if (!workspaceInfo) return;
   const routeInput = positional[0];
   if (!routeInput) {
-    console.error(error3('Usage: decantr task <route> ["task summary"] [--project <path>] [--json]'));
+    console.error(error3('Usage: decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]'));
     process.exitCode = 1;
     return;
   }
   const route = routeInput.startsWith("/") ? routeInput : `/${routeInput}`;
   const taskSummary = positional.slice(1).join(" ").trim();
-  const essencePath = join28(workspaceInfo.appRoot, "decantr.essence.json");
+  const essencePath = join29(workspaceInfo.appRoot, "decantr.essence.json");
   const essence = readJsonIfPresent(essencePath);
   if (!essence) {
     console.error(error3("No decantr.essence.json found. Run `decantr adopt` or `decantr init` first."));
     process.exitCode = 1;
     return;
   }
-  if (!isV47(essence)) {
+  if (!isV48(essence)) {
     console.error(error3("Task context requires Essence v4. Run `decantr migrate --to v4` first."));
     process.exitCode = 1;
     return;
@@ -8593,13 +9113,18 @@ 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 = join28(workspaceInfo.appRoot, ".decantr", "context");
-  const manifest = readJsonIfPresent(join28(contextDir, "pack-manifest.json"));
+  const contextDir = join29(workspaceInfo.appRoot, ".decantr", "context");
+  const manifest = readJsonIfPresent(join29(contextDir, "pack-manifest.json"));
   const pagePack = manifest?.pages?.find((entry) => entry.id === target.page);
   const sectionPack = manifest?.sections?.find((entry) => entry.id === target.section);
-  const visualManifest = readJsonIfPresent(join28(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
+  const visualManifest = readJsonIfPresent(join29(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
   const screenshot = visualManifest?.routes?.find((entry) => entry.route === route)?.screenshot;
-  const localPatternsPath = join28(workspaceInfo.appRoot, ".decantr", "local-patterns.json");
+  const localPatternPackPath = localPatternsPath(workspaceInfo.appRoot);
+  const localRuleManifestPath = localRulesPath(workspaceInfo.appRoot);
+  const localLaw = createLocalLawTaskSummary(workspaceInfo.appRoot);
+  const changedSince = flagString(flags, "since");
+  const currentChangedFiles = changedFiles(workspaceInfo.appRoot, changedSince);
+  const changedRoutes = routeImpacts(workspaceInfo.appRoot, currentChangedFiles);
   const context = {
     route,
     task: taskSummary || null,
@@ -8608,14 +9133,19 @@ async function cmdTaskWorkflow(args) {
     shell: page?.shell ?? section?.shell ?? null,
     patterns: page?.layout?.map(extractPatternName) ?? [],
     read: [
-      pagePack ? join28(".decantr/context", pagePack.markdown) : null,
-      sectionPack ? join28(".decantr/context", sectionPack.markdown) : null,
-      manifest?.scaffold?.markdown ? join28(".decantr/context", manifest.scaffold.markdown) : null,
+      pagePack ? join29(".decantr/context", pagePack.markdown) : null,
+      sectionPack ? join29(".decantr/context", sectionPack.markdown) : null,
+      manifest?.scaffold?.markdown ? join29(".decantr/context", manifest.scaffold.markdown) : null,
       ".decantr/context/scaffold.md",
       "DECANTR.md",
-      existsSync27(localPatternsPath) ? ".decantr/local-patterns.json" : null
+      existsSync28(localPatternPackPath) ? ".decantr/local-patterns.json" : null,
+      existsSync28(localRuleManifestPath) ? ".decantr/rules.json" : null
     ].filter(Boolean),
-    screenshot: screenshot ?? null
+    screenshot: screenshot ?? null,
+    localLaw,
+    changedFiles: currentChangedFiles,
+    changedRoutes,
+    verifyCommand: "decantr verify --brownfield --local-patterns"
   };
   if (flagBoolean(flags, "json")) {
     console.log(JSON.stringify(context, null, 2));
@@ -8637,89 +9167,82 @@ async function cmdTaskWorkflow(args) {
     console.log(`${BOLD7}Visual evidence:${RESET14}`);
     console.log(`  ${cyan3(context.screenshot)}`);
   }
+  if (context.localLaw.patternCount > 0 || context.localLaw.ruleCount > 0) {
+    console.log("");
+    console.log(`${BOLD7}Project-owned local law:${RESET14}`);
+    if (context.localLaw.patternsPath) {
+      console.log(`  Patterns: ${cyan3(context.localLaw.patternsPath)} (${context.localLaw.patternCount})`);
+    }
+    if (context.localLaw.rulesPath) {
+      console.log(`  Rules: ${cyan3(context.localLaw.rulesPath)} (${context.localLaw.ruleCount})`);
+    }
+    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}`);
+    }
+  } else {
+    console.log("");
+    console.log(`${BOLD7}Project-owned local law:${RESET14}`);
+    console.log(`  ${YELLOW9}Not codified yet.${RESET14} Run ${cyan3("decantr codify --from-audit")} after adoption.`);
+  }
+  if (context.changedFiles.length > 0) {
+    console.log("");
+    console.log(`${BOLD7}Changed-file context:${RESET14}`);
+    for (const file of context.changedFiles.slice(0, 8)) {
+      console.log(`  ${file}`);
+    }
+    if (context.changedFiles.length > 8) {
+      console.log(dim3(`  ...${context.changedFiles.length - 8} more changed file(s)`));
+    }
+    if (context.changedRoutes.length > 0) {
+      console.log(`  Impacted routes: ${context.changedRoutes.join(", ")}`);
+    }
+  }
   console.log("");
   console.log(`${BOLD7}LLM instruction:${RESET14}`);
   console.log(
-    "  Preserve the existing runtime and styling system. Use the route pack, section context, local patterns, and visual evidence above as the task contract before changing code."
+    "  Preserve the existing runtime and styling system. Use the route pack, section context, local laws, changed-file impact, and visual evidence above as the task contract before changing code."
   );
+  console.log(`  After editing, run ${cyan3(context.verifyCommand)}.`);
 }
 async function cmdCodifyWorkflow(args) {
   const { flags } = parseLooseArgs(args);
   const workspaceInfo = resolveWorkflowProject(flags);
   if (!workspaceInfo) return;
-  const decantrDir = join28(workspaceInfo.appRoot, ".decantr");
-  const proposalPathLocal = join28(decantrDir, "local-patterns.proposal.json");
-  const acceptedPath = join28(decantrDir, "local-patterns.json");
   if (flagBoolean(flags, "accept")) {
-    if (!existsSync27(proposalPathLocal)) {
-      console.error(error3("No .decantr/local-patterns.proposal.json found. Run `decantr codify` first."));
+    if (!existsSync28(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync28(localRulesProposalPath(workspaceInfo.appRoot))) {
+      console.error(
+        error3("No local law proposal found. Run `decantr codify --from-audit` or `decantr codify` first.")
+      );
       process.exitCode = 1;
       return;
     }
-    writeFileSync16(acceptedPath, readFileSync20(proposalPathLocal, "utf-8"), "utf-8");
-    console.log(success3(`Accepted local pattern pack: ${acceptedPath}`));
-    console.log(dim3("Run `decantr verify --local-patterns` to require the pack during verification."));
+    const result2 = acceptBrownfieldLocalLaw(workspaceInfo.appRoot);
+    if (result2.patternAcceptedPath) {
+      console.log(success3(`Accepted local pattern pack: ${result2.patternAcceptedPath}`));
+    }
+    if (result2.rulesAcceptedPath) {
+      console.log(success3(`Accepted local rule manifest: ${result2.rulesAcceptedPath}`));
+    }
+    console.log(dim3("Run `decantr verify --brownfield --local-patterns` after project edits."));
     return;
   }
-  mkdirSync13(decantrDir, { recursive: true });
   const detected = detectProject(workspaceInfo.appRoot);
-  const essence = readJsonIfPresent(join28(workspaceInfo.appRoot, "decantr.essence.json"));
-  const routes = essence && isV47(essence) ? Object.keys(essence.blueprint.routes ?? {}).sort() : [];
-  const proposal = {
-    version: 1,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    status: "proposal",
-    source: "decantr codify",
-    project: {
-      framework: detected.framework,
-      packageManager: detected.packageManager,
-      hasTailwind: detected.hasTailwind,
-      ruleFiles: detected.existingRuleFiles,
-      routeCount: routes.length
-    },
-    purpose: "Project-owned Brownfield UI law. Review and edit before accepting; Decantr does not treat this as authoritative until copied to .decantr/local-patterns.json.",
-    patterns: [
-      {
-        id: "button",
-        role: "Actions and command triggers",
-        decide: "Define primary, secondary, tertiary, destructive, icon-only, and loading button variants from this app.",
-        evidenceToCollect: ["component wrapper path", "allowed classes/tokens", "forbidden raw <button> usage"]
-      },
-      {
-        id: "surface-card",
-        role: "Cards, panels, and content surfaces",
-        decide: "Define the canonical card background, border, radius, shadow, padding, and hover treatment.",
-        evidenceToCollect: ["shared card component", "token/class recipe", "allowed density variants"]
-      },
-      {
-        id: "page-shell",
-        role: "Route shell, nav, spacing, and scroll ownership",
-        decide: "Define which layout owns max width, gutters, sticky chrome, and scroll containers.",
-        evidenceToCollect: ["root layout path", "page template path", "responsive breakpoints"]
-      },
-      {
-        id: "form-control",
-        role: "Inputs, labels, validation, and form actions",
-        decide: "Define input height, label placement, error copy, disabled state, and focus treatment.",
-        evidenceToCollect: ["form field wrapper", "validation pattern", "accessibility expectations"]
-      }
-    ],
-    starterRules: [
-      "Prefer project-owned wrappers for repeated primitives once they exist.",
-      "Avoid raw hex/rgb values in component templates unless explicitly documented as dynamic data.",
-      "Avoid static inline styles for reusable visual treatment.",
-      "When adding a new route, map it to an existing local pattern before inventing a new visual variant."
-    ],
-    nextSteps: [
-      "Edit this proposal with real component paths and token/class recipes.",
-      "Run decantr codify --accept after review.",
-      "Use decantr task <route> before LLM edits so local patterns appear in the task context.",
-      "Wire mechanical enforcement through ESLint/Biome/project tests for rules Decantr cannot reliably infer."
-    ]
-  };
-  writeFileSync16(proposalPathLocal, JSON.stringify(proposal, null, 2) + "\n", "utf-8");
-  console.log(success3(`Wrote local pattern proposal: ${proposalPathLocal}`));
-  console.log(dim3("Review it, add real component paths/token recipes, then run `decantr codify --accept`."));
+  const essence = readJsonIfPresent(join29(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) {
+    console.log(dim3("Proposal includes source-derived component candidates and starter mechanical rules."));
+  }
+  console.log(dim3("Review both files, add real component paths/token recipes, then run `decantr codify --accept`."));
 }
 async function cmdContentWorkflow(args) {
   const subcommand = args[1] ?? "check";
@@ -8761,9 +9284,9 @@ ${BOLD7}Usage:${RESET14}
   decantr setup [--project <path>]
   decantr new <name> [--blueprint=X] [--archetype=X] [--theme=X] [--workflow=greenfield] [--adoption=decantr-css] [--telemetry]
   decantr adopt [--project <path>] [--base-url <url>] [--evidence] [--ci] [--yes]
-  decantr task <route> ["task summary"] [--project <path>] [--json]
+  decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]
   decantr verify [--project <path>] [--brownfield] [--local-patterns] [health options]
-  decantr codify [--accept] [--project <path>]
+  decantr codify [--from-audit] [--accept] [--project <path>]
   decantr studio [--port 4319] [--host 127.0.0.1] [--report decantr-health.json] [--workspace]
 
 ${BOLD7}Advanced primitives:${RESET14}
@@ -8834,9 +9357,9 @@ ${BOLD7}Commands:${RESET14}
   ${cyan3("setup")}       Detect project state and recommend the right Decantr workflow
   ${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 for an AI coding assistant
+  ${cyan3("task")}        Prepare route/task context, local law, evidence, and changed-file impact for an AI coding assistant
   ${cyan3("verify")}      One reliability gate over Project Health, Brownfield checks, baselines, and evidence
-  ${cyan3("codify")}      Propose or accept project-owned Brownfield UI patterns
+  ${cyan3("codify")}      Propose or accept project-owned Brownfield UI patterns and rules
   ${cyan3("studio")}      Open a local Project Health dashboard backed by the same report
   ${cyan3("content")}     Content-author namespace: check, create, publish
 
@@ -8878,7 +9401,7 @@ ${BOLD7}Examples:${RESET14}
   decantr task /feed "add saved recipe actions"
   decantr verify --brownfield --local-patterns
   decantr verify --since-baseline
-  decantr codify
+  decantr codify --from-audit
   decantr codify --accept
   decantr content check --ci --fail-on error
   decantr magic "AI chatbot with dark cyber theme \u2014 bold and futuristic"
@@ -8929,8 +9452,8 @@ ${BOLD7}Workflow Model:${RESET14}
   ${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 --base-url <url> --evidence --yes
-  ${cyan3("Daily LLM work")}          decantr task <route> "<change>" -> decantr verify
-  ${cyan3("Project-owned law")}       decantr codify -> edit proposal -> decantr codify --accept
+  ${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
   ${cyan3("Hybrid composition")}     decantr add/remove, decantr theme switch, decantr registry, decantr upgrade
 
 ${BOLD7}Bootstrap adapters:${RESET14}
@@ -9111,7 +9634,7 @@ ${BOLD7}Examples:${RESET14}
 }
 function cmdAdoptHelp() {
   console.log(`
-${BOLD7}decantr adopt${RESET14} \u2014 Brownfield one-liner: analyze, attach, verify, and show the next step
+${BOLD7}decantr adopt${RESET14} \u2014 Brownfield one-liner: analyze, attach, verify, and show the operating loop
 
 ${BOLD7}Usage:${RESET14}
   decantr adopt [--project <path>] [--yes] [--dry-run]
@@ -9135,6 +9658,7 @@ ${BOLD7}Examples:${RESET14}
   decantr adopt --yes
   decantr adopt --base-url http://localhost:3000 --evidence --yes
   decantr adopt --project apps/web --ci --yes
+  decantr codify --from-audit
 `);
 }
 function cmdVerifyHelp() {
@@ -9151,6 +9675,7 @@ ${BOLD7}Usage:${RESET14}
 ${BOLD7}Examples:${RESET14}
   decantr verify
   decantr verify --brownfield --local-patterns
+  decantr verify --brownfield --local-patterns --fail-on warn
   decantr verify --base-url http://localhost:3000 --evidence
   decantr verify --workspace --changed --since origin/main
   decantr verify init-ci --project apps/web
@@ -9161,25 +9686,27 @@ function cmdTaskHelp() {
 ${BOLD7}decantr task${RESET14} \u2014 Prepare compact route/task context for an AI coding assistant
 
 ${BOLD7}Usage:${RESET14}
-  decantr task <route> ["task summary"] [--project <path>] [--json]
+  decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]
 
 ${BOLD7}Examples:${RESET14}
   decantr task /feed "add saved recipe actions"
+  decantr task /feed "add saved recipe actions" --since origin/main
   decantr task /profile --json
 `);
 }
 function cmdCodifyHelp() {
   console.log(`
-${BOLD7}decantr codify${RESET14} \u2014 Propose or accept project-owned Brownfield UI patterns
+${BOLD7}decantr codify${RESET14} \u2014 Propose or accept project-owned Brownfield UI patterns and rules
 
 ${BOLD7}Usage:${RESET14}
-  decantr codify [--project <path>]
+  decantr codify [--from-audit] [--project <path>]
   decantr codify --accept [--project <path>]
 
 ${BOLD7}Examples:${RESET14}
   decantr codify
+  decantr codify --from-audit
   decantr codify --accept
-  decantr verify --local-patterns
+  decantr verify --brownfield --local-patterns
 `);
 }
 function cmdContentHelp() {
@@ -9254,10 +9781,10 @@ async function main() {
   if (command === "--version" || command === "-v" || command === "version") {
     try {
       const here = dirname4(fileURLToPath2(import.meta.url));
-      const candidates = [join28(here, "..", "package.json"), join28(here, "..", "..", "package.json")];
+      const candidates = [join29(here, "..", "package.json"), join29(here, "..", "..", "package.json")];
       for (const candidate of candidates) {
-        if (existsSync27(candidate)) {
-          const pkg = JSON.parse(readFileSync20(candidate, "utf-8"));
+        if (existsSync28(candidate)) {
+          const pkg = JSON.parse(readFileSync21(candidate, "utf-8"));
           if (pkg.version) {
             console.log(pkg.version);
             return;
@@ -9730,7 +10257,7 @@ async function main() {
           break;
         }
         if (packType === "page" && route && !id) {
-          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join28(process.cwd(), "decantr.essence.json");
+          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join29(process.cwd(), "decantr.essence.json");
           id = resolvePagePackIdForRoute(resolvedPath, route);
         }
         await printHostedSelectedExecutionPack(