@decantr/cli 2.7.0 → 2.8.1

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

@@ -15,6 +15,9 @@ import {
   syncRegistry,
   writeExecutionPackBundleArtifacts
 } from "./chunk-V3XAQWKD.js";
+import {
+  resolveWorkspaceInfo
+} from "./chunk-VE6N3XWG.js";
 import {
   buildGuardRegistryContext,
   createDoctrineMap,
@@ -34,10 +37,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 existsSync27, mkdirSync as mkdirSync14, readdirSync as readdirSync7, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
+import { basename as basename3, dirname as dirname3, isAbsolute, join as join28, resolve as resolve3 } 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 +5274,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";
@@ -5282,10 +5767,10 @@ var CYAN7 = "\x1B[36m";
 function ask(question, defaultValue) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const prompt = defaultValue ? `${question} ${DIM13}(${defaultValue})${RESET13}: ` : `${question}: `;
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     rl.question(prompt, (answer) => {
       rl.close();
-      resolve5(answer.trim() || defaultValue || "");
+      resolve4(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -5536,7 +6021,7 @@ function mergeWithDefaults(flags, detected, workflowSeed) {
 }
 async function runSimplifiedInit(blueprints) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const question = (q) => new Promise((resolve5) => rl.question(q, resolve5));
+  const question = (q) => new Promise((resolve4) => rl.question(q, resolve4));
   console.log("\n? What blueprint would you like to scaffold?\n");
   console.log("  1. Decantr default (recommended)");
   console.log("  2. Search registry...\n");
@@ -5568,8 +6053,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 +6114,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 +6135,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 +6160,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 +6178,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 +6186,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,90 +6202,20 @@ 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
   };
 }
 
-// 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";
-function readPackageJson(dir) {
-  const path = join27(dir, "package.json");
-  if (!existsSync26(path)) return null;
-  try {
-    return JSON.parse(readFileSync19(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"))) {
-    return true;
-  }
-  const pkg = readPackageJson(dir);
-  return Boolean(pkg?.workspaces);
-}
-function findWorkspaceRoot(startDir) {
-  let current = resolve3(startDir);
-  while (true) {
-    if (hasWorkspaceMarker(current)) return current;
-    const parent = dirname3(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-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"))) {
-    return true;
-  }
-  const pkg = readPackageJson(dir);
-  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
-  return Boolean(
-    deps.react || deps.next || deps.vue || deps.svelte || deps["@angular/core"] || deps.astro || deps.nuxt
-  );
-}
-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 })) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const candidate = join27(baseDir, entry.name);
-      if (looksLikeApp(candidate)) {
-        candidates.push(`${base}/${entry.name}`);
-      }
-    }
-  }
-  return candidates.sort();
-}
-function resolveWorkspaceInfo(cwd, projectArg) {
-  const absoluteCwd = resolve3(cwd);
-  const workspaceRoot = findWorkspaceRoot(absoluteCwd) ?? absoluteCwd;
-  const appRoot = projectArg ? resolve3(absoluteCwd, projectArg) : absoluteCwd;
-  const appCandidates = listWorkspaceApps(workspaceRoot);
-  const projectScope = workspaceRoot !== appRoot || appCandidates.length > 0 ? "workspace-app" : "single-app";
-  const requiresProjectSelection = !projectArg && workspaceRoot === absoluteCwd && appCandidates.length > 1;
-  return {
-    cwd: absoluteCwd,
-    workspaceRoot,
-    appRoot,
-    projectScope,
-    appCandidates,
-    requiresProjectSelection
-  };
-}
-
 // src/index.ts
 var BOLD7 = "\x1B[1m";
 var DIM14 = "\x1B[2m";
@@ -6328,7 +6743,7 @@ function getPublicAPIClient() {
   });
 }
 function resolveUserPath(inputPath, cwd = process.cwd()) {
-  return isAbsolute(inputPath) ? inputPath : resolve4(cwd, inputPath);
+  return isAbsolute(inputPath) ? inputPath : resolve3(cwd, inputPath);
 }
 function extractHostedAssetPaths(indexHtml) {
   const assetPaths = /* @__PURE__ */ new Set();
@@ -6379,7 +6794,7 @@ 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 })) {
       if (ignoredDirNames.has(entry.name)) continue;
@@ -6551,7 +6966,7 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
   let writtenContextPaths = [];
   if (writeContext) {
     const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync13(contextDir, { recursive: true });
+    mkdirSync14(contextDir, { recursive: true });
     const written = writeExecutionPackBundleArtifacts(
       contextDir,
       bundle
@@ -6592,7 +7007,7 @@ function resolvePagePackIdForRoute(essencePath, route) {
     throw new Error(`Essence file not found at ${essencePath}`);
   }
   const essence = JSON.parse(readFileSync20(essencePath, "utf-8"));
-  if (!isV47(essence)) {
+  if (!isV48(essence)) {
     throw new Error("Route-based pack resolution requires Essence v4.0.0.");
   }
   const target = essence.blueprint.routes?.[route];
@@ -6625,16 +7040,16 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   let writtenContextDir = null;
   if (writeContext) {
     const contextDir = join28(process.cwd(), ".decantr", "context");
-    mkdirSync13(contextDir, { recursive: true });
-    writeFileSync16(
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(
       join28(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(join28(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync17(join28(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -6671,8 +7086,8 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   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");
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(join28(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -6711,7 +7126,7 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
     const client = getPublicAPIClient();
     const essence = JSON.parse(readFileSync20(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 {
@@ -6739,14 +7154,14 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync13(contextDir, { recursive: true });
-    writeFileSync16(join28(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync16(
+    mkdirSync14(contextDir, { recursive: true });
+    writeFileSync17(join28(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync17(
       join28(contextDir, "review-pack.json"),
       JSON.stringify(selected.pack, null, 2) + "\n"
     );
     if (!existsSync27(manifestPath)) {
-      writeFileSync16(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
+      writeFileSync17(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
   } catch {
@@ -7082,7 +7497,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) {
@@ -7217,7 +7632,7 @@ ${CYAN8}Telemetry enabled.${RESET14} Decantr will send privacy-filtered CLI prod
   console.log(`${DIM14}Set "telemetry": false in .decantr/project.json to opt out.${RESET14}`);
 }
 function readCliPackageVersion() {
-  const here = dirname4(fileURLToPath2(import.meta.url));
+  const here = dirname3(fileURLToPath2(import.meta.url));
   const candidates = [join28(here, "..", "package.json"), join28(here, "..", "..", "package.json")];
   for (const candidate of candidates) {
     try {
@@ -7238,13 +7653,13 @@ function backupExistingEssence(projectRoot, label) {
     projectRoot,
     `decantr.essence.${label}.${timestampForFile()}.backup.json`
   );
-  writeFileSync16(backupPath, readFileSync20(essencePath, "utf-8"), "utf-8");
+  writeFileSync17(backupPath, readFileSync20(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 });
+  mkdirSync14(join28(decantrDir, "context"), { recursive: true });
+  mkdirSync14(join28(decantrDir, "cache"), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const projectJson = {
     detected: {
@@ -7285,7 +7700,7 @@ function writeBrownfieldProjectJson(input) {
       }
     }
   };
-  writeFileSync16(join28(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
+  writeFileSync17(join28(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
 }
 async function applyAcceptedBrownfieldProposal(input) {
   const proposal = readBrownfieldProposal(input.projectRoot);
@@ -7317,7 +7732,7 @@ async function applyAcceptedBrownfieldProposal(input) {
   }
   if (input.mode === "merge" && hasEssence) {
     const existing = JSON.parse(readFileSync20(essencePath, "utf-8"));
-    if (!isV47(existing)) {
+    if (!isV48(existing)) {
       console.log(
         error3(
           "Existing essence is not v4. Run `decantr migrate --to v4` before merging a brownfield proposal."
@@ -7353,7 +7768,7 @@ 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"),
     offline: true,
@@ -7414,8 +7829,7 @@ async function applyAcceptedBrownfieldProposal(input) {
 async function cmdInit(args) {
   const workspaceInfo = resolveWorkspaceInfo(process.cwd(), args.project);
   if (args.yes && workspaceInfo.requiresProjectSelection) {
-    console.log(error3("This looks like a workspace root with multiple app candidates."));
-    console.log(dim3(`Use --project=<path>. Candidates: ${workspaceInfo.appCandidates.join(", ")}`));
+    printWorkspaceProjectSelection(workspaceInfo, "init");
     process.exitCode = 1;
     return;
   }
@@ -7899,7 +8313,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 }))
     );
@@ -7957,14 +8371,14 @@ async function cmdStatus() {
   try {
     const essence = JSON.parse(readFileSync20(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 ?? []);
@@ -8353,12 +8767,69 @@ function withoutWorkflowOnlyFlags(args) {
   }
   return stripped;
 }
-function resolveWorkflowProject(flags) {
+function withProject(command, projectArg) {
+  return projectArg ? `${command} --project ${projectArg}` : command;
+}
+function firstWorkspaceCandidate(workspaceInfo) {
+  return workspaceInfo.appCandidates[0] ?? "apps/web";
+}
+function printWorkspaceProjectSelection(workspaceInfo, commandName = "command") {
+  const candidate = firstWorkspaceCandidate(workspaceInfo);
+  const noun = commandName === "adopt" ? "Brownfield adoption" : `decantr ${commandName}`;
+  console.log(error3(`${noun} needs an app path.`));
+  console.log("");
+  console.log(`${BOLD7}This looks like a monorepo.${RESET14}`);
+  console.log("Install Decantr at the workspace root, then attach it to one app with --project.");
+  console.log("");
+  console.log("App candidates:");
+  for (const appCandidate of workspaceInfo.appCandidates) {
+    console.log(`  ${appCandidate}`);
+  }
+  console.log("");
+  console.log("Start by attaching one app:");
+  console.log(`  ${cyan3(`decantr adopt --project ${candidate} --yes`)}`);
+  console.log("");
+  console.log("Optional visual evidence after the app is running:");
+  console.log(
+    `  ${cyan3(`decantr verify --project ${candidate} --base-url http://localhost:3000 --evidence`)}`
+  );
+}
+function printMonorepoSetupGuidance(workspaceInfo) {
+  const candidate = firstWorkspaceCandidate(workspaceInfo);
+  console.log(heading2("Decantr Setup"));
+  console.log(`${BOLD7}This looks like a monorepo.${RESET14}`);
+  console.log(`  Workspace root: ${workspaceInfo.workspaceRoot}`);
+  console.log("");
+  console.log(
+    "Install Decantr at the workspace root, then attach it to the app you want Decantr to govern."
+  );
+  console.log("");
+  console.log("App candidates:");
+  for (const appCandidate of workspaceInfo.appCandidates) {
+    console.log(`  ${appCandidate}`);
+  }
+  console.log("");
+  console.log(`${BOLD7}Start here:${RESET14}`);
+  console.log(
+    `  ${cyan3("decantr workspace list")}                         Show attached projects and app candidates`
+  );
+  console.log(
+    `  ${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`
+  );
+  console.log("");
+  console.log(`${BOLD7}Optional visual evidence:${RESET14}`);
+  console.log(
+    `  ${cyan3(`decantr verify --project ${candidate} --base-url http://localhost:3000 --evidence`)}`
+  );
+}
+function resolveWorkflowProject(flags, commandName = "command") {
   const projectArg = flagString(flags, "project");
   const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
   if (workspaceInfo.requiresProjectSelection) {
-    console.log(error3("This looks like a workspace root with multiple app candidates."));
-    console.log(dim3(`Use --project=<path>. Candidates: ${workspaceInfo.appCandidates.join(", ")}`));
+    printWorkspaceProjectSelection(workspaceInfo, commandName);
     process.exitCode = 1;
     return null;
   }
@@ -8374,8 +8845,17 @@ function printWorkflowPlan(title, steps) {
 }
 async function cmdSetupWorkflow(args) {
   const { flags } = parseLooseArgs(args);
-  const workspaceInfo = resolveWorkflowProject(flags);
-  if (!workspaceInfo) return;
+  const projectArg = flagString(flags, "project");
+  const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
+  if (!projectArg && workspaceInfo.workspaceRoot === workspaceInfo.cwd && workspaceInfo.appCandidates.length > 0) {
+    printMonorepoSetupGuidance(workspaceInfo);
+    return;
+  }
+  if (workspaceInfo.requiresProjectSelection) {
+    printWorkspaceProjectSelection(workspaceInfo, "setup");
+    process.exitCode = 1;
+    return;
+  }
   const detected = detectProject(workspaceInfo.appRoot);
   const hasFootprint = detected.framework !== "unknown" || detected.packageManager !== "unknown" || detected.hasTypeScript || detected.hasTailwind || detected.existingRuleFiles.length > 0;
   console.log(heading2("Decantr Setup"));
@@ -8384,18 +8864,30 @@ async function cmdSetupWorkflow(args) {
   console.log("");
   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(withProject('decantr task <route> "<change>"', projectArg))}  Prepare LLM context before edits`
+    );
+    console.log(
+      `  ${cyan3(withProject("decantr verify --brownfield", projectArg))}     Run local health and drift checks`
+    );
+    console.log(
+      `  ${cyan3(withProject("decantr codify --from-audit", projectArg))}     Propose project-owned local law`
+    );
     return;
   }
   if (hasFootprint) {
     console.log(`${BOLD7}Recommended path:${RESET14} brownfield adoption`);
-    console.log(`  ${cyan3("decantr adopt --yes")}                       Analyze, attach, and verify`);
     console.log(
-      `  ${cyan3("decantr adopt --base-url http://localhost:3000 --evidence --yes")}  Include visual evidence`
+      `  ${cyan3(withProject("decantr adopt --yes", projectArg))}                       Analyze, attach, and verify`
+    );
+    console.log(
+      `  ${cyan3(withProject("decantr codify --from-audit", projectArg))}               Propose local UI law`
+    );
+    console.log("");
+    console.log(`${BOLD7}Optional visual evidence after the app is running:${RESET14}`);
+    console.log(
+      `  ${cyan3(withProject("decantr verify --base-url http://localhost:3000 --evidence", projectArg))}`
     );
-    console.log(`  ${cyan3("decantr codify")}                            Propose local UI law`);
     return;
   }
   console.log(`${BOLD7}Recommended path:${RESET14} greenfield start`);
@@ -8404,9 +8896,10 @@ async function cmdSetupWorkflow(args) {
 }
 async function cmdAdoptWorkflow(args) {
   const { flags } = parseLooseArgs(args);
-  const workspaceInfo = resolveWorkflowProject(flags);
+  const workspaceInfo = resolveWorkflowProject(flags, "adopt");
   if (!workspaceInfo) return;
   const projectRoot = workspaceInfo.appRoot;
+  const projectArg = flagString(flags, "project");
   const dryRun = flagBoolean(flags, "dry-run");
   const yes = flagBoolean(flags, "yes") || flagBoolean(flags, "y");
   const baseUrl = flagString(flags, "base-url");
@@ -8476,10 +8969,22 @@ 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(withProject("decantr codify --from-audit", projectArg))}          Discover and propose project-owned UI law`
+  );
+  console.log(
+    `  ${cyan3(withProject("decantr codify --accept", projectArg))}              Accept reviewed local patterns and rules`
+  );
+  console.log(
+    `  ${cyan3(withProject('decantr task <route> "<change>"', projectArg))}      Give your LLM route-specific context before edits`
+  );
+  console.log(
+    `  ${cyan3(withProject("decantr verify --brownfield --local-patterns", projectArg))}  Check contract, health, and local law after edits`
+  );
+  console.log(
+    `  ${cyan3(withProject("decantr verify --since-baseline", projectArg))}      Compare future work against this baseline`
+  );
 }
 async function cmdVerifyWorkflow(args) {
   const { flags } = parseLooseArgs(args);
@@ -8490,16 +8995,17 @@ async function cmdVerifyWorkflow(args) {
     return;
   }
   if (workspaceMode) {
-    const { cmdWorkspace } = await import("./workspace-KSFWRZEX.js");
+    const { cmdWorkspace } = await import("./workspace-U7J3CJY3.js");
     await cmdWorkspace(process.cwd(), ["workspace", "health", ...withoutWorkflowOnlyFlags(args)]);
     return;
   }
-  const workspaceInfo = resolveWorkflowProject(flags);
+  const workspaceInfo = resolveWorkflowProject(flags, "verify");
   if (!workspaceInfo) return;
   const brownfield = flagBoolean(flags, "brownfield");
   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 +9041,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)) {
@@ -8561,11 +9102,15 @@ function readJsonIfPresent(path) {
 }
 async function cmdTaskWorkflow(args) {
   const { flags, positional } = parseLooseArgs(args);
-  const workspaceInfo = resolveWorkflowProject(flags);
+  const workspaceInfo = resolveWorkflowProject(flags, "task");
   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;
   }
@@ -8574,11 +9119,13 @@ async function cmdTaskWorkflow(args) {
   const essencePath = join28(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."));
+    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;
@@ -8599,7 +9146,12 @@ async function cmdTaskWorkflow(args) {
   const sectionPack = manifest?.sections?.find((entry) => entry.id === target.section);
   const visualManifest = readJsonIfPresent(join28(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,
@@ -8613,9 +9165,14 @@ async function cmdTaskWorkflow(args) {
       manifest?.scaffold?.markdown ? join28(".decantr/context", manifest.scaffold.markdown) : null,
       ".decantr/context/scaffold.md",
       "DECANTR.md",
-      existsSync27(localPatternsPath) ? ".decantr/local-patterns.json" : null
+      existsSync27(localPatternPackPath) ? ".decantr/local-patterns.json" : null,
+      existsSync27(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,95 +9194,105 @@ 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);
+  const workspaceInfo = resolveWorkflowProject(flags, "codify");
   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 (!existsSync27(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync27(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(
+    join28(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";
   if (subcommand === "check" || subcommand === "health") {
     const { cmdContentHealth, parseContentHealthArgs } = await import("./content-health-QQHBR6XG.js");
-    await cmdContentHealth(process.cwd(), parseContentHealthArgs(["content-health", ...args.slice(2)]));
+    await cmdContentHealth(
+      process.cwd(),
+      parseContentHealthArgs(["content-health", ...args.slice(2)])
+    );
     return;
   }
   if (subcommand === "create") {
@@ -8761,9 +9328,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 +9401,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
 
@@ -8874,11 +9441,13 @@ ${BOLD7}Advanced commands:${RESET14}
 ${BOLD7}Examples:${RESET14}
   decantr setup
   decantr new my-app --blueprint=carbon-ai-portal
-  decantr adopt --base-url http://localhost:3000 --evidence --yes
+  decantr adopt --yes
+  decantr adopt --project apps/web --yes
   decantr task /feed "add saved recipe actions"
   decantr verify --brownfield --local-patterns
+  decantr verify --base-url http://localhost:3000 --evidence
   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"
@@ -8928,9 +9497,10 @@ ${BOLD7}Examples:${RESET14}
 ${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("Brownfield adoption")}    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
   ${cyan3("Hybrid composition")}     decantr add/remove, decantr theme switch, decantr registry, decantr upgrade
 
 ${BOLD7}Bootstrap adapters:${RESET14}
@@ -9003,7 +9573,7 @@ ${BOLD7}Examples:${RESET14}
 }
 function cmdWorkspaceHelp() {
   console.log(`
-${BOLD7}decantr workspace${RESET14} \u2014 Inspect Decantr projects across a monorepo
+${BOLD7}decantr workspace${RESET14} \u2014 Inspect Decantr projects and app candidates across a monorepo
 
 ${BOLD7}Usage:${RESET14}
   decantr workspace list [--json]
@@ -9012,6 +9582,7 @@ ${BOLD7}Usage:${RESET14}
 
 ${BOLD7}Examples:${RESET14}
   decantr workspace list
+  decantr adopt --project apps/web --yes
   decantr workspace health
   decantr workspace health --json --output .decantr/workspace-health.json
   decantr workspace health --changed --since origin/main
@@ -9111,11 +9682,11 @@ ${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]
-  decantr adopt --base-url <url> [--evidence] [--ci] [--yes]
+  decantr adopt [--project <path>] --base-url <url> [--evidence] [--ci] [--yes]
 
 ${BOLD7}Options:${RESET14}
   --project           App path inside a workspace/monorepo
@@ -9133,8 +9704,10 @@ ${BOLD7}Options:${RESET14}
 
 ${BOLD7}Examples:${RESET14}
   decantr adopt --yes
-  decantr adopt --base-url http://localhost:3000 --evidence --yes
+  decantr adopt --project apps/web --yes
+  decantr adopt --project apps/web --base-url http://localhost:3000 --evidence --yes
   decantr adopt --project apps/web --ci --yes
+  decantr codify --from-audit --project apps/web
 `);
 }
 function cmdVerifyHelp() {
@@ -9151,6 +9724,8 @@ ${BOLD7}Usage:${RESET14}
 ${BOLD7}Examples:${RESET14}
   decantr verify
   decantr verify --brownfield --local-patterns
+  decantr verify --brownfield --local-patterns --project apps/web
+  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 +9736,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() {
@@ -9253,7 +9830,7 @@ async function main() {
   }
   if (command === "--version" || command === "-v" || command === "version") {
     try {
-      const here = dirname4(fileURLToPath2(import.meta.url));
+      const here = dirname3(fileURLToPath2(import.meta.url));
       const candidates = [join28(here, "..", "package.json"), join28(here, "..", "..", "package.json")];
       for (const candidate of candidates) {
         if (existsSync27(candidate)) {
@@ -9436,7 +10013,7 @@ async function main() {
           cmdStudioHelp();
           break;
         }
-        const { cmdStudio, parseStudioArgs } = await import("./studio-MKLBUC3A.js");
+        const { cmdStudio, parseStudioArgs } = await import("./studio-G3YOU5YF.js");
         await cmdStudio(process.cwd(), parseStudioArgs(args));
       } catch (e) {
         console.error(error3(e.message));
@@ -9450,7 +10027,7 @@ async function main() {
           cmdWorkspaceHelp();
           break;
         }
-        const { cmdWorkspace } = await import("./workspace-KSFWRZEX.js");
+        const { cmdWorkspace } = await import("./workspace-U7J3CJY3.js");
         await cmdWorkspace(process.cwd(), args);
       } catch (e) {
         console.error(error3(e.message));
@@ -9886,10 +10463,7 @@ async function main() {
       }
       const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
       if (workspaceInfo.requiresProjectSelection) {
-        console.log(error3("This looks like a workspace root with multiple app candidates."));
-        console.log(
-          dim3(`Use --project=<path>. Candidates: ${workspaceInfo.appCandidates.join(", ")}`)
-        );
+        printWorkspaceProjectSelection(workspaceInfo, "analyze");
         process.exitCode = 1;
         break;
       }
@@ -9916,6 +10490,11 @@ async function main() {
         }
       }
       const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
+      if (workspaceInfo.requiresProjectSelection) {
+        printWorkspaceProjectSelection(workspaceInfo, "rules");
+        process.exitCode = 1;
+        break;
+      }
       const detected = detectProject(workspaceInfo.appRoot);
       if (subcommand === "preview") {
         console.log(