@decantr/cli 2.13.0 → 3.0.0-next.0

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

@@ -22,14 +22,37 @@ import {
   listWorkspaceCandidates,
   listWorkspaceProjects,
   shouldFailWorkspaceHealth
-} from "./chunk-YBSBAJ3E.js";
+} from "./chunk-GXC5IJQY.js";
 import {
+  acceptBrownfieldLocalLaw,
+  acceptStyleBridge,
+  buildGraphArtifacts,
+  changedFiles,
+  cmdGraph,
+  cmdGraphHelp,
+  createBrownfieldCodifyProposal,
+  createLocalLawTaskSummary,
   createProjectHealthReport,
+  createStyleBridgeProposal,
+  createStyleBridgeTaskSummary,
   formatProjectHealthMarkdown,
   formatProjectHealthText,
+  localPatternsPath,
+  localPatternsProposalPath,
+  localRulesPath,
+  localRulesProposalPath,
+  readLocalPatternPack,
   resolveWorkspaceInfo,
-  shouldFailHealth
-} from "./chunk-3A2DLR47.js";
+  routeImpacts,
+  shouldFailHealth,
+  styleBridgeMatches,
+  styleBridgePath,
+  styleBridgeProposalPath,
+  validateLocalLaw,
+  writeBrownfieldCodifyProposal,
+  writeHostedPatternMappingProposal,
+  writeStyleBridgeProposal
+} from "./chunk-WUIFEHWM.js";
 import {
   buildGuardRegistryContext,
   createDoctrineMap,
@@ -49,10 +72,16 @@ import {
 } from "./chunk-MNZKOZW7.js";
 
 // src/index.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync17, readdirSync as readdirSync9, readFileSync as readFileSync23, writeFileSync as writeFileSync20 } from "fs";
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute3, join as join32, relative as relative7, resolve as resolve4 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync15, readdirSync as readdirSync8, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join30, relative as relative6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { evaluateGuard, isV4 as isV49, validateEssence as validateEssence2 } from "@decantr/essence-spec";
+import {
+  buildGraphImpactContext,
+  buildGraphRouteContext,
+  graphPayloadString,
+  summarizeGraphDiff
+} from "@decantr/core";
+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,
@@ -3235,1107 +3264,8 @@ ${YELLOW2}Next step:${RESET2} Review ${BOLD}${reportDisplayPath}${RESET2}, then
 }
 
 // src/commands/ci.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname3, join as join17, relative as relative4, resolve } from "path";
-
-// src/local-law.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync11, statSync as statSync5, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename2, extname, join as join15, relative as relative3, sep } from "path";
-import { isV4 as isV43 } 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 join15(projectRoot, ".decantr", "local-patterns.proposal.json");
-}
-function localPatternsPath(projectRoot) {
-  return join15(projectRoot, ".decantr", "local-patterns.json");
-}
-function localRulesProposalPath(projectRoot) {
-  return join15(projectRoot, ".decantr", "rules.proposal.json");
-}
-function localRulesPath(projectRoot) {
-  return join15(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 && isV43(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/Hybrid UI law. Review and edit before accepting; Decantr treats this as authoritative only after it is copied to .decantr/local-patterns.json.",
-    hybrid: {
-      intent: "This local pattern pack is the first Hybrid authority layer: it maps Decantr concepts onto project-owned components, tokens, classes, and rules without replacing the app runtime.",
-      authorityPrecedence: [
-        "existing production source",
-        "accepted local patterns and rules",
-        "Decantr Essence V4 contract",
-        "hosted registry patterns and execution packs as optional guidance"
-      ],
-      hostedPatternMapping: "Use hosted patterns as vocabulary and review guidance. Before enforcing one, map it to a project-owned component path, class recipe, token recipe, or explicit exception here."
-    },
-    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.",
-        classHints: evidence.buttonClassHints,
-        variants: evidence.buttonVariants,
-        sourceEvidence: evidence.buttonSourceEvidence,
-        confidence: confidenceForEvidence({
-          componentCount: evidence.buttonComponents.length,
-          classHintCount: evidence.buttonClassHints.length,
-          variantCount: evidence.buttonVariants.length,
-          sourceEvidenceCount: evidence.buttonSourceEvidence.length
-        }),
-        enforcement: {
-          level: "warn",
-          status: "proposal",
-          notes: [
-            "Treat as advisory until the team confirms variant names and wrapper paths.",
-            "Raise related rules to error only after raw button usage can be fixed without churn."
-          ]
-        },
-        evidence: evidence.buttonComponents.length ? evidence.buttonComponents : evidence.buttonClassHints.length ? evidence.buttonClassHints : [
-          "No obvious Button wrapper found yet. Add the project-owned wrapper path before strict enforcement."
-        ],
-        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,
-        variants: evidence.cardVariants,
-        sourceEvidence: evidence.cardSourceEvidence,
-        confidence: confidenceForEvidence({
-          componentCount: evidence.cardComponents.length,
-          classHintCount: evidence.cardClassHints.length,
-          variantCount: evidence.cardVariants.length,
-          sourceEvidenceCount: evidence.cardSourceEvidence.length
-        }),
-        enforcement: {
-          level: "warn",
-          status: "proposal",
-          notes: [
-            "Use this family to converge repeated surface recipes before enforcing card rules.",
-            "Document route-specific card exceptions before asking CI to block them."
-          ]
-        },
-        evidence: evidence.cardComponents.length ? evidence.cardComponents : [
-          "No obvious Card wrapper found yet. Add the project-owned wrapper path or class recipe."
-        ],
-        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.",
-        sourceEvidence: collectSourceEvidence(input.projectRoot, sourceFiles, [
-          "layout",
-          "shell",
-          "nav",
-          "sidebar",
-          "container"
-        ]),
-        confidence: confidenceForEvidence({
-          componentCount: evidence.shellComponents.length,
-          sourceEvidenceCount: evidence.shellComponents.length
-        }),
-        enforcement: {
-          level: "advisory",
-          status: "proposal",
-          notes: [
-            "Layout ownership is usually reviewed by humans first because route shells can legitimately differ."
-          ]
-        },
-        evidence: evidence.shellComponents.length ? evidence.shellComponents : ["Add root layout, shell, or app frame files that establish route chrome and spacing."],
-        forbiddenAlternatives: [
-          "Each page inventing independent max-width, padding, or sticky nav rules."
-        ]
-      },
-      {
-        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.",
-        variants: evidence.formVariants,
-        sourceEvidence: evidence.formSourceEvidence,
-        confidence: confidenceForEvidence({
-          componentCount: evidence.formComponents.length,
-          variantCount: evidence.formVariants.length,
-          sourceEvidenceCount: evidence.formSourceEvidence.length
-        }),
-        enforcement: {
-          level: "warn",
-          status: "proposal",
-          notes: [
-            "Start by mapping field wrappers, labels, error states, and disabled states from source."
-          ]
-        },
-        evidence: evidence.formComponents.length ? evidence.formComponents : ["Add form field wrapper paths and validation examples."],
-        forbiddenAlternatives: [
-          "Unlabeled one-off inputs or validation states that do not match the app standard."
-        ]
-      },
-      {
-        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.",
-        variants: evidence.themeVariants,
-        sourceEvidence: evidence.themeSourceEvidence,
-        confidence: confidenceForEvidence({
-          componentCount: evidence.themeComponents.length,
-          variantCount: evidence.themeVariants.length,
-          sourceEvidenceCount: evidence.themeSourceEvidence.length
-        }),
-        enforcement: {
-          level: "advisory",
-          status: "proposal",
-          notes: [
-            "Theme variant law should preserve the existing theme provider/tokens before adding any new mode."
-          ]
-        },
-        evidence: evidence.themeComponents.length ? evidence.themeComponents : ["If the app has dark/light or brand variants, add the toggles/providers here."],
-        forbiddenAlternatives: [
-          "Component-local theme forks that bypass shared theme providers or tokens."
-        ]
-      }
-    ],
-    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.",
-      "Map hosted Decantr patterns into project-owned local law before making them enforceable."
-    ],
-    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.",
-      "For Hybrid adoption, start with warn-level local rules and raise severities only after the team agrees the law is stable.",
-      "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/Hybrid 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 = join15(projectRoot, ".decantr");
-  mkdirSync8(decantrDir, { recursive: true });
-  const patternPath = localPatternsProposalPath(projectRoot);
-  const rulesPath = localRulesProposalPath(projectRoot);
-  writeFileSync9(patternPath, `${JSON.stringify(proposal.patternPack, null, 2)}
-`, "utf-8");
-  writeFileSync9(rulesPath, `${JSON.stringify(proposal.ruleManifest, null, 2)}
-`, "utf-8");
-  return { patternPath, rulesPath };
-}
-function writeHostedPatternMappingProposal(input) {
-  const decantrDir = join15(input.projectRoot, ".decantr");
-  mkdirSync8(decantrDir, { recursive: true });
-  const existing = readJsonFile(localPatternsProposalPath(input.projectRoot)) ?? readJsonFile(localPatternsPath(input.projectRoot));
-  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const patternPack = {
-    version: 2,
-    generatedAt,
-    status: "proposal",
-    source: "decantr codify --map-pattern",
-    purpose: existing?.purpose ?? "Project-owned Brownfield/Hybrid UI law. Review and edit before accepting; Decantr treats this as authoritative only after it is copied to .decantr/local-patterns.json.",
-    hybrid: existing?.hybrid ?? {
-      intent: "This local pattern pack maps Decantr concepts onto project-owned components, tokens, classes, and rules without replacing the app runtime.",
-      authorityPrecedence: [
-        "existing production source",
-        "accepted local patterns and rules",
-        "Decantr Essence V4 contract",
-        "hosted registry patterns and execution packs as optional guidance"
-      ],
-      hostedPatternMapping: "Hosted registry patterns are advisory until mapped to project-owned component paths, token recipes, class recipes, and explicit exceptions."
-    },
-    patterns: Array.isArray(existing?.patterns) ? [...existing.patterns] : [],
-    starterRules: Array.isArray(existing?.starterRules) ? existing.starterRules : [],
-    nextSteps: Array.isArray(existing?.nextSteps) ? existing.nextSteps : [
-      "Review this proposal with the team.",
-      "Add project-owned component paths, token hints, class recipes, and exceptions.",
-      "Run decantr codify --accept after review.",
-      "Use decantr task <route> before LLM edits so local law appears in task context."
-    ]
-  };
-  const slug = input.hostedPattern.slug.trim();
-  const existingIds = new Set(
-    (patternPack.patterns ?? []).map((pattern) => typeof pattern.id === "string" ? pattern.id : "").filter(Boolean)
-  );
-  const localPatternId = existingIds.has(slug) ? `${slug}-registry-map` : slug;
-  const mappedPattern = {
-    id: localPatternId,
-    label: input.hostedPattern.name ? `${input.hostedPattern.name} registry mapping` : `${slug} registry mapping`,
-    role: "Hosted registry guidance mapped into project-owned Hybrid law",
-    appliesTo: [
-      ...input.hostedPattern.components ?? [],
-      ...input.hostedPattern.interactions ?? [],
-      ...input.hostedPattern.tags ?? []
-    ].slice(0, 24),
-    componentPaths: [],
-    tokenHints: [],
-    classHints: [],
-    decide: `Map hosted pattern "${slug}" into this app's existing components, tokens, classes, and exceptions before treating it as enforceable.`,
-    hostedPatternRefs: [input.hostedPattern],
-    confidence: {
-      tier: "low",
-      score: 0.25,
-      rationale: [
-        "A hosted registry pattern was selected intentionally.",
-        "No project-owned component path or token recipe has been mapped yet."
-      ]
-    },
-    enforcement: {
-      level: "advisory",
-      status: "needs-mapping",
-      notes: [
-        "This proposal does not change source files.",
-        "Do not enforce this hosted pattern until project-owned implementation details are filled in.",
-        "Use accepted local rules, ESLint, Biome, Storybook, or visual regression for deterministic blocking checks."
-      ]
-    },
-    evidence: [
-      `Hosted pattern ${input.hostedPattern.source}/${slug}${input.hostedPattern.description ? `: ${input.hostedPattern.description}` : ""}`,
-      input.hostedPattern.visualBrief ? `Visual brief: ${input.hostedPattern.visualBrief}` : "Visual brief not provided by the hosted pattern."
-    ],
-    evidenceToCollect: [
-      "Project-owned component path(s) that implement this pattern.",
-      "Allowed token/class recipe(s) for this app.",
-      "Variant names and states that are legal in this project.",
-      "Explicit exceptions where this hosted pattern should not apply."
-    ],
-    forbiddenAlternatives: [
-      "Replacing existing app components solely because a hosted pattern exists.",
-      "Treating hosted registry guidance as enforceable without accepted local law."
-    ]
-  };
-  const index = (patternPack.patterns ?? []).findIndex((pattern) => pattern.id === localPatternId);
-  const replacedExisting = index >= 0;
-  if (replacedExisting) {
-    patternPack.patterns[index] = mappedPattern;
-  } else {
-    patternPack.patterns = [...patternPack.patterns ?? [], mappedPattern];
-  }
-  patternPack.nextSteps = [
-    .../* @__PURE__ */ new Set([
-      ...patternPack.nextSteps ?? [],
-      "Fill the hosted mapping with project-owned component paths, token/class recipes, variants, and exceptions.",
-      "Run decantr codify --accept only after the mapping reflects the existing app.",
-      "Use decantr verify --brownfield --local-patterns after edits to keep mapped local law visible."
-    ])
-  ];
-  const patternPath = localPatternsProposalPath(input.projectRoot);
-  writeFileSync9(patternPath, `${JSON.stringify(patternPack, null, 2)}
-`, "utf-8");
-  return { patternPath, localPatternId, replacedExisting };
-}
-function acceptBrownfieldLocalLaw(projectRoot) {
-  const patternProposal = readJsonFile(localPatternsProposalPath(projectRoot));
-  const ruleProposal = readJsonFile(localRulesProposalPath(projectRoot));
-  const acceptedAt = (/* @__PURE__ */ new Date()).toISOString();
-  let patternAcceptedPath = null;
-  let rulesAcceptedPath = null;
-  if (patternProposal) {
-    patternProposal.status = "accepted";
-    patternProposal.acceptedAt = acceptedAt;
-    patternAcceptedPath = localPatternsPath(projectRoot);
-    writeFileSync9(patternAcceptedPath, `${JSON.stringify(patternProposal, null, 2)}
-`, "utf-8");
-  }
-  if (ruleProposal) {
-    ruleProposal.status = "accepted";
-    ruleProposal.acceptedAt = acceptedAt;
-    rulesAcceptedPath = localRulesPath(projectRoot);
-    writeFileSync9(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 : [];
-      const hostedRefs = Array.isArray(pattern.hostedPatternRefs) ? pattern.hostedPatternRefs : [];
-      if (id && paths.length === 0 && evidence.length === 0 && todoEvidence.length > 0) {
-        warnings.push(
-          `Local pattern ${id} still reads like a TODO; add concrete component paths or evidence.`
-        );
-      }
-      if (id && hostedRefs.length > 0 && paths.length === 0) {
-        warnings.push(
-          `Local pattern ${id} maps hosted registry guidance but has no project-owned component path yet.`
-        );
-      }
-    }
-  }
-  if (ruleManifest && !Array.isArray(ruleManifest.rules)) {
-    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") : [],
-    confidenceTier: typeof pattern.confidence === "object" && pattern.confidence !== null && typeof pattern.confidence.tier === "string" ? pattern.confidence.tier : null,
-    enforcementLevel: typeof pattern.enforcement === "object" && pattern.enforcement !== null && typeof pattern.enforcement.level === "string" ? pattern.enforcement.level : null,
-    hostedPatternRefs: Array.isArray(pattern.hostedPatternRefs) ? pattern.hostedPatternRefs.map((ref) => typeof ref?.slug === "string" ? ref.slug : null).filter((slug) => Boolean(slug)) : []
-  }));
-  const rules = (ruleManifest?.rules ?? []).map((rule) => ({
-    id: rule.id,
-    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(
-    join15(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 = readFileSync11(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,
-    buttonVariants: detectVariants(projectRoot, files, {
-      family: "button",
-      terms: ["primary", "secondary", "tertiary", "ghost", "link", "destructive", "icon"]
-    }),
-    cardVariants: detectVariants(projectRoot, files, {
-      family: "surface",
-      terms: ["card", "panel", "surface", "tile", "elevated", "interactive", "glass"]
-    }),
-    formVariants: detectVariants(projectRoot, files, {
-      family: "form",
-      terms: ["error", "invalid", "disabled", "required", "success", "helper"]
-    }),
-    themeVariants: detectVariants(projectRoot, files, {
-      family: "theme",
-      terms: ["dark", "light", "brand", "tenant", "theme", "mode", "density"]
-    }),
-    buttonSourceEvidence: collectSourceEvidence(projectRoot, files, [
-      "button",
-      "primary",
-      "secondary",
-      "tertiary",
-      "destructive"
-    ]),
-    cardSourceEvidence: collectSourceEvidence(projectRoot, files, [
-      "card",
-      "panel",
-      "surface",
-      "rounded",
-      "shadow"
-    ]),
-    formSourceEvidence: collectSourceEvidence(projectRoot, files, [
-      "input",
-      "label",
-      "error",
-      "field",
-      "select"
-    ]),
-    themeSourceEvidence: collectSourceEvidence(projectRoot, files, [
-      "theme",
-      "dark",
-      "light",
-      "brand",
-      "tenant"
-    ]),
-    buttonClassHints: collectClassHints(projectRoot, files, [
-      "button",
-      "btn",
-      "action",
-      "primary",
-      "secondary",
-      "tertiary",
-      "ghost",
-      "link"
-    ]),
-    cardClassHints: collectClassHints(projectRoot, files, ["card", "panel", "surface", "tile"])
-  };
-}
-function detectVariants(projectRoot, files, input) {
-  const variants = /* @__PURE__ */ new Map();
-  const termPattern = new RegExp(
-    `\\b(${input.terms.map(escapeRegExp).join("|")})(?:[-_:][a-z0-9-]+)?\\b`,
-    "gi"
-  );
-  for (const file of files) {
-    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
-    const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
-    for (const match of content.matchAll(termPattern)) {
-      const raw = (match[0] ?? "").toLowerCase();
-      const id = raw.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
-      if (!id || id.length < 3) continue;
-      const position = lineColumnAt(content, match.index ?? 0);
-      const line = lineAt(content, position.line).trim().slice(0, 160);
-      const entry = variants.get(id) ?? { evidence: /* @__PURE__ */ new Set(), count: 0 };
-      entry.count += 1;
-      entry.evidence.add(`${file.relative}:${position.line} ${line}`);
-      variants.set(id, entry);
-    }
-  }
-  return [...variants.entries()].sort((a, b) => b[1].count - a[1].count || a[0].localeCompare(b[0])).slice(0, 8).map(([id, value]) => ({
-    id,
-    label: `${input.family} ${id}`,
-    evidence: [...value.evidence].slice(0, 4),
-    confidence: value.count >= 4 ? "high" : value.count >= 2 ? "medium" : "low"
-  }));
-}
-function collectSourceEvidence(projectRoot, files, terms) {
-  const results = [];
-  const termPattern = new RegExp(terms.map(escapeRegExp).join("|"), "i");
-  for (const file of files) {
-    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
-    const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
-    const lines = content.split(/\r?\n/);
-    for (let index = 0; index < lines.length; index += 1) {
-      const line = lines[index];
-      if (!termPattern.test(line)) continue;
-      const signals = terms.filter((term) => line.toLowerCase().includes(term.toLowerCase()));
-      results.push({
-        file: file.relative,
-        line: index + 1,
-        excerpt: line.trim().slice(0, 180),
-        signals: signals.slice(0, 6)
-      });
-      if (results.length >= 16) return results;
-      break;
-    }
-  }
-  return results;
-}
-function confidenceForEvidence(input) {
-  const score = Math.min(
-    1,
-    input.componentCount * 0.28 + (input.classHintCount ?? 0) * 0.08 + (input.variantCount ?? 0) * 0.08 + (input.sourceEvidenceCount ?? 0) * 0.05
-  );
-  const tier = score >= 0.7 ? "high" : score >= 0.4 ? "medium" : "low";
-  const rationale = [
-    input.componentCount > 0 ? `${input.componentCount} likely component path(s) detected` : "no likely component wrapper detected yet",
-    (input.classHintCount ?? 0) > 0 ? `${input.classHintCount} class recipe hint(s) detected` : "no strong class recipe hints detected yet",
-    (input.variantCount ?? 0) > 0 ? `${input.variantCount} possible variant signal(s) detected` : "variant names still need team confirmation"
-  ];
-  return { tier, score: Number(score.toFixed(2)), rationale };
-}
-function collectClassHints(projectRoot, files, terms) {
-  const hints = /* @__PURE__ */ new Map();
-  const wantsButton = terms.some(
-    (term) => /^(button|btn|action|primary|secondary|tertiary|ghost|link)$/i.test(term)
-  );
-  const wantsSurface = terms.some((term) => /^(card|panel|surface|tile)$/i.test(term));
-  const buttonSignal = /button|btn|action|primary|secondary|tertiary|ghost|link|destructive|icon/i;
-  const surfaceSignal = /card|panel|surface|tile|rounded|shadow|border|bg-|p-\d|px-|py-/i;
-  for (const file of files) {
-    if (!UI_TEMPLATE_EXTENSIONS.has(extname(file.absolute))) continue;
-    const content = readFileSync11(join15(projectRoot, file.relative), "utf-8");
-    if (!terms.some((term) => content.toLowerCase().includes(term))) continue;
-    if (wantsButton) {
-      const openingTags = content.matchAll(
-        /<([A-Za-z][\w.:/-]*)\b[^>]*\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`][^>]*>/g
-      );
-      for (const match of openingTags) {
-        const tag = match[1];
-        const value = match[2].trim();
-        const tagLooksInteractive = /^(button|a|Link)$/i.test(tag) || /(^|\.)(Button|IconButton|LinkButton|Action)$/i.test(tag);
-        const fileLooksInteractive = /button|action|link/i.test(basename2(file.relative));
-        if (!tagLooksInteractive && !fileLooksInteractive) continue;
-        if (!buttonSignal.test(value) && !fileLooksInteractive) continue;
-        hints.set(value, (hints.get(value) ?? 0) + 1);
-      }
-      continue;
-    }
-    const matches = content.matchAll(/\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`]/g);
-    for (const match of matches) {
-      const value = match[1].trim();
-      const keep = wantsSurface && surfaceSignal.test(value) || !wantsButton && !wantsSurface && (buttonSignal.test(value) || surfaceSignal.test(value));
-      if (!keep) 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 = join15(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(relative3(projectRoot, absolute)) });
-      }
-    }
-  };
-  visit(projectRoot);
-  return files.sort((a, b) => a.relative.localeCompare(b.relative));
-}
-function readJsonFile(path) {
-  if (!existsSync13(path)) return null;
-  try {
-    return JSON.parse(readFileSync11(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 escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function lineAt(contents, line) {
-  return contents.split(/\r?\n/)[line - 1] ?? "";
-}
-
-// src/style-bridge.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
-import { join as join16 } from "path";
-function styleBridgeProposalPath(projectRoot) {
-  return join16(projectRoot, ".decantr", "style-bridge.proposal.json");
-}
-function styleBridgePath(projectRoot) {
-  return join16(projectRoot, ".decantr", "style-bridge.json");
-}
-function readJsonFile2(path) {
-  if (!existsSync14(path)) return null;
-  try {
-    return JSON.parse(readFileSync12(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeJsonFile(path, value) {
-  writeFileSync10(path, `${JSON.stringify(value, null, 2)}
-`, "utf-8");
-}
-function readStyleBridge(projectRoot) {
-  return readJsonFile2(styleBridgePath(projectRoot));
-}
-function readStyleBridgeProposal(projectRoot) {
-  return readJsonFile2(styleBridgeProposalPath(projectRoot));
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
-}
-function readThemeInventory(projectRoot) {
-  const inventory = readJsonFile2(join16(projectRoot, ".decantr", "theme-inventory.json"));
-  return {
-    modes: stringArray(inventory?.modes),
-    variantIds: Array.isArray(inventory?.variants) ? inventory.variants.map((variant) => variant.id).filter((id) => typeof id === "string") : [],
-    darkModeDetected: typeof inventory?.darkModeDetected === "boolean" ? inventory.darkModeDetected : null
-  };
-}
-function tokenHints(styling, terms) {
-  return styling.cssVariables.filter((name) => terms.test(name)).slice(0, 12);
-}
-function readProjectPatternPack(projectRoot) {
-  return readLocalPatternPack(projectRoot) ?? readJsonFile2(
-    join16(projectRoot, ".decantr", "local-patterns.proposal.json")
-  );
-}
-function classHintsForPattern(projectRoot, ids) {
-  const pack = readProjectPatternPack(projectRoot);
-  const classes = /* @__PURE__ */ new Set();
-  for (const pattern of pack?.patterns ?? []) {
-    if (!ids.includes(String(pattern.id))) continue;
-    for (const hint of pattern.classHints ?? []) classes.add(hint);
-  }
-  return [...classes].slice(0, 12);
-}
-function sourceEvidence(projectRoot, ids) {
-  const pack = readProjectPatternPack(projectRoot);
-  const evidence = /* @__PURE__ */ new Set();
-  for (const pattern of pack?.patterns ?? []) {
-    if (!ids.includes(String(pattern.id))) continue;
-    for (const path of pattern.componentPaths ?? []) evidence.add(path);
-    for (const item of pattern.evidence ?? []) evidence.add(item);
-  }
-  return [...evidence].slice(0, 12);
-}
-function colorTokenNames(styling) {
-  const names = new Set(Object.keys(styling.colors ?? {}));
-  for (const variable of styling.cssVariables) {
-    if (/color|bg|background|surface|text|foreground|border|primary|secondary|accent|muted/i.test(variable)) {
-      names.add(variable);
-    }
-  }
-  return [...names].slice(0, 40);
-}
-function createStyleBridgeProposal(input) {
-  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const theme = readThemeInventory(input.projectRoot);
-  const routeCount = input.essence && typeof input.essence === "object" && "blueprint" in input.essence ? Object.keys(input.essence.blueprint?.routes ?? {}).length : 0;
-  const target = input.essence && typeof input.essence === "object" && "meta" in input.essence ? String(input.essence.meta?.target ?? "") || null : null;
-  const darkModeDetected = theme.darkModeDetected ?? input.styling.darkMode;
-  const themeModes = theme.modes.length > 0 ? theme.modes : darkModeDetected ? ["base", "dark"] : ["base"];
-  const themeVariantIds = theme.variantIds.length > 0 ? theme.variantIds : themeModes.filter((mode) => mode !== "base");
-  return {
-    version: 1,
-    status: "proposal",
-    generatedAt,
-    source: "decantr codify --style-bridge",
-    purpose: "Project-owned Hybrid style bridge. It maps Decantr design intent to the existing app styling system without installing Decantr CSS or taking over source.",
-    adoption: {
-      mode: "style-bridge",
-      workflowMode: "brownfield-attach",
-      sourceAuthority: "Existing production source stays authoritative.",
-      styleAuthority: "Use these mappings to translate Decantr concepts into project-owned tokens, classes, and components.",
-      notRuntimeTakeover: true,
-      authorityPrecedence: [
-        "existing production source",
-        "accepted style bridge",
-        "accepted local patterns and rules",
-        "Essence V4 contract",
-        "hosted registry patterns and execution packs as optional guidance"
-      ]
-    },
-    project: {
-      framework: input.detected.framework,
-      packageManager: input.detected.packageManager,
-      target,
-      routeCount
-    },
-    styling: {
-      approach: input.styling.approach,
-      configFile: input.styling.configFile ?? null,
-      darkModeDetected,
-      cssVariables: input.styling.cssVariables.slice(0, 80),
-      colorTokenNames: colorTokenNames(input.styling),
-      themeModes,
-      themeVariantIds
-    },
-    mappings: [
-      {
-        id: "surface",
-        label: "Surfaces and cards",
-        decantrIntent: "surface background, card treatment, border, radius, depth, and hover state",
-        projectAuthority: "Use the app card/surface primitives, tokens, and accepted local law.",
-        tokenHints: tokenHints(input.styling, /surface|card|panel|bg|background|border|shadow|radius/i),
-        classHints: classHintsForPattern(input.projectRoot, ["surface-card"]),
-        sourceEvidence: sourceEvidence(input.projectRoot, ["surface-card"]),
-        guardrails: [
-          "Do not invent a new card color/radius/shadow recipe without updating local law.",
-          "Do not add Decantr CSS d-* classes unless adoption mode changes to decantr-css."
-        ]
-      },
-      {
-        id: "action",
-        label: "Actions and buttons",
-        decantrIntent: "primary, secondary, tertiary, destructive, icon-only, loading, and disabled action states",
-        projectAuthority: "Use the app button/action primitives and local variant names.",
-        tokenHints: tokenHints(input.styling, /primary|secondary|accent|danger|error|destructive|focus/i),
-        classHints: classHintsForPattern(input.projectRoot, ["button"]),
-        sourceEvidence: sourceEvidence(input.projectRoot, ["button"]),
-        guardrails: [
-          "Map any new action style to primary/secondary/tertiary/destructive/icon before coding.",
-          "Avoid raw button markup when a project-owned primitive exists."
-        ]
-      },
-      {
-        id: "focus-accessibility",
-        label: "Focus and accessibility",
-        decantrIntent: "visible focus, keyboard clarity, contrast, and reduced-motion safety",
-        projectAuthority: "Use the app accessibility classes, focus tokens, and framework conventions.",
-        tokenHints: tokenHints(input.styling, /focus|ring|outline|contrast|motion|duration/i),
-        classHints: [],
-        sourceEvidence: [],
-        guardrails: [
-          "Every new interactive control needs visible focus evidence.",
-          "Motion should honor prefers-reduced-motion or an existing app motion helper."
-        ]
-      },
-      {
-        id: "layout-density",
-        label: "Layout density and spacing",
-        decantrIntent: "route gutters, section gaps, component padding, density, and responsive rhythm",
-        projectAuthority: "Use existing layout wrappers, shell primitives, and spacing tokens/classes.",
-        tokenHints: tokenHints(input.styling, /space|spacing|gap|gutter|container|radius/i),
-        classHints: classHintsForPattern(input.projectRoot, ["page-shell"]),
-        sourceEvidence: sourceEvidence(input.projectRoot, ["page-shell"]),
-        guardrails: [
-          "Do not let each page invent independent max-width, gutters, or scroll ownership.",
-          "Use the detected shell/layout authority before adding a new wrapper."
-        ]
-      },
-      {
-        id: "theme-variant",
-        label: "Theme variants",
-        decantrIntent: "light, dark, brand, tenant, seasonal, and density variants",
-        projectAuthority: "Use the app theme provider, data attributes, CSS variables, or Tailwind mode strategy.",
-        tokenHints: tokenHints(input.styling, /theme|dark|light|brand|tenant|mode|color/i),
-        classHints: classHintsForPattern(input.projectRoot, ["theme-variant"]),
-        sourceEvidence: sourceEvidence(input.projectRoot, ["theme-variant"]),
-        guardrails: [
-          "Keep theme modes documented in .decantr/theme-inventory.json and this bridge.",
-          "Do not treat theme switcher container classes as standalone theme variants."
-        ]
-      }
-    ],
-    rules: [
-      "The bridge is advisory until accepted; after acceptance, task/doctor/CI should surface it as Hybrid authority.",
-      "The bridge does not make hosted registry patterns enforceable. Map hosted concepts into local law first.",
-      "Keep deterministic blocking checks in .decantr/rules.json, ESLint, Biome, tests, or visual regression."
-    ],
-    nextSteps: [
-      "Review token and class hints. Replace generic hints with the exact project tokens/classes the team owns.",
-      "Run decantr codify --accept to promote the proposal to .decantr/style-bridge.json.",
-      "Use decantr task <route> before LLM edits so the style bridge appears in task context.",
-      "Run decantr ci or decantr verify after edits to keep local law and Project Health visible."
-    ]
-  };
-}
-function writeStyleBridgeProposal(projectRoot, proposal) {
-  const decantrDir = join16(projectRoot, ".decantr");
-  mkdirSync9(decantrDir, { recursive: true });
-  const path = styleBridgeProposalPath(projectRoot);
-  writeJsonFile(path, proposal);
-  return path;
-}
-function acceptStyleBridge(projectRoot) {
-  const proposal = readStyleBridgeProposal(projectRoot);
-  if (!proposal) return null;
-  const accepted = {
-    ...proposal,
-    status: "accepted",
-    acceptedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const path = styleBridgePath(projectRoot);
-  writeJsonFile(path, accepted);
-  const projectJsonPath = join16(projectRoot, ".decantr", "project.json");
-  const projectJson = readJsonFile2(projectJsonPath) ?? {};
-  const initialized = typeof projectJson.initialized === "object" && projectJson.initialized !== null ? projectJson.initialized : {};
-  writeJsonFile(projectJsonPath, {
-    ...projectJson,
-    initialized: {
-      ...initialized,
-      workflowMode: initialized.workflowMode ?? "brownfield-attach",
-      adoptionMode: "style-bridge"
-    }
-  });
-  return path;
-}
-function createStyleBridgeTaskSummary(projectRoot) {
-  const bridge = readStyleBridge(projectRoot);
-  return {
-    path: bridge ? ".decantr/style-bridge.json" : null,
-    status: bridge?.status ?? null,
-    mappingCount: bridge?.mappings?.length ?? 0,
-    stylingApproach: bridge?.styling?.approach ?? null,
-    themeModes: bridge?.styling?.themeModes ?? [],
-    mappings: bridge?.mappings?.map((mapping) => ({
-      id: mapping.id,
-      label: mapping.label,
-      tokenHints: mapping.tokenHints.slice(0, 6),
-      classHints: mapping.classHints.slice(0, 4),
-      guardrails: mapping.guardrails.slice(0, 3)
-    })) ?? []
-  };
-}
-function styleBridgeMatches(projectRoot, query) {
-  if (!projectRoot) return [];
-  const bridge = readStyleBridge(projectRoot);
-  if (!bridge) return [];
-  const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1).flatMap((term) => term.endsWith("s") && term.length > 3 ? [term, term.slice(0, -1)] : [term]);
-  if (terms.length === 0) return [];
-  return bridge.mappings.map((mapping) => {
-    const haystack = [
-      mapping.id,
-      mapping.label,
-      mapping.decantrIntent,
-      mapping.projectAuthority,
-      ...mapping.tokenHints,
-      ...mapping.classHints,
-      ...mapping.guardrails
-    ].join(" ").toLowerCase();
-    const score = terms.reduce((sum, term) => sum + (haystack.includes(term) ? 1 : 0), 0);
-    return {
-      id: mapping.id,
-      label: mapping.label,
-      score,
-      tokenHints: mapping.tokenHints.slice(0, 4),
-      classHints: mapping.classHints.slice(0, 3)
-    };
-  }).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id)).slice(0, 5);
-}
-
-// src/commands/ci.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname3, join as join15, relative as relative3, resolve } from "path";
 var BOLD2 = "\x1B[1m";
 var DIM3 = "\x1B[2m";
 var GREEN3 = "\x1B[32m";
@@ -4343,9 +3273,9 @@ var RED2 = "\x1B[31m";
 var RESET3 = "\x1B[0m";
 var CI_SCHEMA = "https://decantr.ai/schemas/decantr-ci-report.v1.json";
 function readJson(path) {
-  if (!existsSync15(path)) return null;
+  if (!existsSync13(path)) return null;
   try {
-    return JSON.parse(readFileSync13(path, "utf-8"));
+    return JSON.parse(readFileSync11(path, "utf-8"));
   } catch {
     return null;
   }
@@ -4389,21 +3319,21 @@ function parseProvider(value) {
   throw new Error("Invalid --provider value. Use github or generic.");
 }
 function detectPackageManager2(root) {
-  const pkg = readJson(join17(root, "package.json"));
+  const pkg = readJson(join15(root, "package.json"));
   const declared = pkg?.packageManager?.split("@")[0];
   if (declared === "pnpm" || declared === "npm" || declared === "yarn" || declared === "bun") {
     return declared;
   }
-  if (existsSync15(join17(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync15(join17(root, "package-lock.json"))) return "npm";
-  if (existsSync15(join17(root, "yarn.lock"))) return "yarn";
-  if (existsSync15(join17(root, "bun.lock")) || existsSync15(join17(root, "bun.lockb"))) return "bun";
+  if (existsSync13(join15(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync13(join15(root, "package-lock.json"))) return "npm";
+  if (existsSync13(join15(root, "yarn.lock"))) return "yarn";
+  if (existsSync13(join15(root, "bun.lock")) || existsSync13(join15(root, "bun.lockb"))) return "bun";
   return "unknown";
 }
 function hasWorkspaceMarker(root) {
-  const pkg = readJson(join17(root, "package.json"));
+  const pkg = readJson(join15(root, "package.json"));
   return Boolean(
-    existsSync15(join17(root, "pnpm-workspace.yaml")) || existsSync15(join17(root, "turbo.json")) || existsSync15(join17(root, "nx.json")) || pkg?.workspaces
+    existsSync13(join15(root, "pnpm-workspace.yaml")) || existsSync13(join15(root, "turbo.json")) || existsSync13(join15(root, "nx.json")) || pkg?.workspaces
   );
 }
 function installCommand(packageManager) {
@@ -4449,7 +3379,7 @@ function decantrCommand(packageManager) {
   }
 }
 function localCliPinned(root) {
-  const pkg = readJson(join17(root, "package.json"));
+  const pkg = readJson(join15(root, "package.json"));
   return Boolean(pkg?.devDependencies?.["@decantr/cli"] || pkg?.dependencies?.["@decantr/cli"]);
 }
 function projectSlug(projectPath) {
@@ -4457,8 +3387,8 @@ function projectSlug(projectPath) {
 }
 function writeOutput(root, path, content) {
   const absolute = resolve(root, path);
-  mkdirSync10(dirname3(absolute), { recursive: true });
-  writeFileSync11(absolute, content, "utf-8");
+  mkdirSync8(dirname3(absolute), { recursive: true });
+  writeFileSync9(absolute, content, "utf-8");
 }
 function summarizeLocalLaw(projectRoot) {
   const validation = validateLocalLaw(projectRoot);
@@ -4733,7 +3663,7 @@ jobs:
 }
 function writeCiInit(root, options) {
   const workspaceInfo = resolveWorkspaceInfo(root, options.project);
-  if (options.project && !existsSync15(workspaceInfo.appRoot)) {
+  if (options.project && !existsSync13(workspaceInfo.appRoot)) {
     throw new Error(`Project path does not exist: ${options.project}`);
   }
   if (workspaceInfo.requiresProjectSelection && !options.workspace) {
@@ -4743,7 +3673,7 @@ function writeCiInit(root, options) {
     );
   }
   const outputRoot = workspaceInfo.workspaceRoot;
-  const projectPath = options.project ?? (options.workspace || workspaceInfo.appRoot === workspaceInfo.workspaceRoot ? void 0 : relative4(workspaceInfo.workspaceRoot, workspaceInfo.appRoot).replace(/\\/g, "/"));
+  const projectPath = options.project ?? (options.workspace || workspaceInfo.appRoot === workspaceInfo.workspaceRoot ? void 0 : relative3(workspaceInfo.workspaceRoot, workspaceInfo.appRoot).replace(/\\/g, "/"));
   const packageManager = detectPackageManager2(outputRoot);
   const command = decantrCommand(packageManager);
   const failOn = options.failOn ?? "error";
@@ -4756,7 +3686,7 @@ function writeCiInit(root, options) {
   if (provider === "generic") {
     const path2 = ".decantr/ci/decantr-ci.sh";
     const absolute2 = resolve(outputRoot, path2);
-    if (existsSync15(absolute2) && !options.force) {
+    if (existsSync13(absolute2) && !options.force) {
       throw new Error(`${path2} already exists. Re-run with --force to replace it.`);
     }
     writeOutput(
@@ -4777,7 +3707,7 @@ function writeCiInit(root, options) {
   }
   const path = ".github/workflows/decantr-ci.yml";
   const absolute = resolve(outputRoot, path);
-  if (existsSync15(absolute) && !options.force) {
+  if (existsSync13(absolute) && !options.force) {
     throw new Error(`${path} already exists. Re-run with --force to replace it.`);
   }
   writeOutput(
@@ -4826,7 +3756,7 @@ async function runWorkspaceCi(root, options) {
 }
 async function runProjectCi(root, options) {
   const workspaceInfo = resolveWorkspaceInfo(root, options.project);
-  if (options.project && !existsSync15(workspaceInfo.appRoot)) {
+  if (options.project && !existsSync13(workspaceInfo.appRoot)) {
     console.error(`${RED2}Project path does not exist: ${options.project}${RESET3}`);
     return 1;
   }
@@ -4900,8 +3830,8 @@ async function cmdCi(args = ["ci"], root = process.cwd()) {
 }
 
 // src/commands/create.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "fs";
+import { join as join16 } from "path";
 import {
   CONTENT_TYPE_TO_API_CONTENT_TYPE,
   CONTENT_TYPES
@@ -5097,25 +4027,25 @@ function cmdCreate(type, name, projectRoot = process.cwd()) {
   }
   const contentType = type;
   const plural = PLURAL[contentType];
-  const customDir = join18(projectRoot, ".decantr", "custom", plural);
-  const filePath = join18(customDir, `${name}.json`);
-  if (existsSync16(filePath)) {
+  const customDir = join16(projectRoot, ".decantr", "custom", plural);
+  const filePath = join16(customDir, `${name}.json`);
+  if (existsSync14(filePath)) {
     console.error(`${type} "${name}" already exists at ${filePath}`);
     process.exitCode = 1;
     return;
   }
-  mkdirSync11(customDir, { recursive: true });
+  mkdirSync9(customDir, { recursive: true });
   const skeleton = getSkeleton(contentType, name, humanizeId(name));
-  writeFileSync12(filePath, JSON.stringify(skeleton, null, 2));
+  writeFileSync10(filePath, JSON.stringify(skeleton, null, 2));
   console.log(`Created ${type} "${name}" at ${filePath}`);
   console.log(`Edit it, then publish with: decantr publish ${type} ${name}`);
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname4, join as join19, relative as relative5 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname4, join as join17, relative as relative4 } from "path";
 import { fileURLToPath } from "url";
-import { isV4 as isV44 } from "@decantr/essence-spec";
+import { isV4 as isV43 } from "@decantr/essence-spec";
 import { collectMissingPackManifestFiles } from "@decantr/verifier";
 var BOLD3 = "\x1B[1m";
 var DIM4 = "\x1B[2m";
@@ -5125,25 +4055,25 @@ var YELLOW3 = "\x1B[33m";
 var CYAN2 = "\x1B[36m";
 var RESET4 = "\x1B[0m";
 function readJson2(path) {
-  if (!existsSync17(path)) return null;
+  if (!existsSync15(path)) return null;
   try {
-    return JSON.parse(readFileSync14(path, "utf-8"));
+    return JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function isContractOnlyProject(projectRoot) {
-  const projectJson = readJson2(join19(projectRoot, ".decantr", "project.json"));
+  const projectJson = readJson2(join17(projectRoot, ".decantr", "project.json"));
   return projectJson?.initialized?.adoptionMode === "contract-only" || projectJson?.initialized?.adoptionMode === "style-bridge";
 }
 function readCliPackageVersion() {
-  const packagePath = join19(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-  const srcPackagePath = join19(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
+  const packagePath = join17(dirname4(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+  const srcPackagePath = join17(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
   const pkg = readJson2(packagePath) ?? readJson2(srcPackagePath);
   return pkg?.version ?? "unknown";
 }
 function readPackageJson2(dir) {
-  return readJson2(join19(dir, "package.json"));
+  return readJson2(join17(dir, "package.json"));
 }
 function detectPackageManager3(root) {
   const pkg = readPackageJson2(root);
@@ -5151,10 +4081,10 @@ function detectPackageManager3(root) {
   if (declared === "pnpm" || declared === "npm" || declared === "yarn" || declared === "bun") {
     return declared;
   }
-  if (existsSync17(join19(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync17(join19(root, "package-lock.json"))) return "npm";
-  if (existsSync17(join19(root, "yarn.lock"))) return "yarn";
-  if (existsSync17(join19(root, "bun.lock")) || existsSync17(join19(root, "bun.lockb"))) return "bun";
+  if (existsSync15(join17(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync15(join17(root, "package-lock.json"))) return "npm";
+  if (existsSync15(join17(root, "yarn.lock"))) return "yarn";
+  if (existsSync15(join17(root, "bun.lock")) || existsSync15(join17(root, "bun.lockb"))) return "bun";
   return "unknown";
 }
 function localCliDependency(root) {
@@ -5164,7 +4094,7 @@ function localCliDependency(root) {
 function hasWorkspaceMarker2(root) {
   const pkg = readPackageJson2(root);
   return Boolean(
-    existsSync17(join19(root, "pnpm-workspace.yaml")) || existsSync17(join19(root, "turbo.json")) || existsSync17(join19(root, "nx.json")) || pkg?.workspaces
+    existsSync15(join17(root, "pnpm-workspace.yaml")) || existsSync15(join17(root, "turbo.json")) || existsSync15(join17(root, "nx.json")) || pkg?.workspaces
   );
 }
 function pinCliCommand2(packageManager, root) {
@@ -5182,13 +4112,13 @@ function pinCliCommand2(packageManager, root) {
   }
 }
 function rel(root, path) {
-  const value = relative5(root, path).replace(/\\/g, "/");
+  const value = relative4(root, path).replace(/\\/g, "/");
   return value || ".";
 }
 function hasAnyFile(dir, names) {
   for (const name of names) {
-    const path = join19(dir, name);
-    if (existsSync17(path)) return name;
+    const path = join17(dir, name);
+    if (existsSync15(path)) return name;
   }
   return null;
 }
@@ -5210,7 +4140,7 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
     "libs/design-system"
   ];
   for (const candidate of sharedCandidates) {
-    if (existsSync17(join19(workspaceRoot, candidate))) found.add(candidate);
+    if (existsSync15(join17(workspaceRoot, candidate))) found.add(candidate);
   }
   for (const root of [appRoot, workspaceRoot]) {
     const label = root === appRoot ? "app" : "workspace";
@@ -5221,9 +4151,9 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
       "tailwind.config.cjs"
     ]);
     if (tailwind) found.add(`${label}:${tailwind}`);
-    if (existsSync17(join19(root, ".storybook"))) found.add(`${label}:.storybook`);
-    if (existsSync17(join19(root, "components", "ui"))) found.add(`${label}:components/ui`);
-    if (existsSync17(join19(root, "src", "components", "ui"))) found.add(`${label}:src/components/ui`);
+    if (existsSync15(join17(root, ".storybook"))) found.add(`${label}:.storybook`);
+    if (existsSync15(join17(root, "components", "ui"))) found.add(`${label}:components/ui`);
+    if (existsSync15(join17(root, "src", "components", "ui"))) found.add(`${label}:src/components/ui`);
     if (packageHasDependency(root, ["@storybook/react", "storybook"]))
       found.add(`${label}:storybook`);
     if (packageHasDependency(root, ["tailwindcss"])) found.add(`${label}:tailwindcss`);
@@ -5235,18 +4165,18 @@ function detectDesignAuthority(workspaceRoot, appRoot) {
 }
 function findCiFiles(root) {
   const files = [];
-  const workflows = join19(root, ".github", "workflows");
-  if (existsSync17(workflows)) {
-    for (const entry of readdirSync6(workflows, { withFileTypes: true })) {
+  const workflows = join17(root, ".github", "workflows");
+  if (existsSync15(workflows)) {
+    for (const entry of readdirSync5(workflows, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
-      const path = join19(workflows, entry.name);
-      const text = readFileSync14(path, "utf-8");
+      const path = join17(workflows, entry.name);
+      const text = readFileSync12(path, "utf-8");
       if (text.includes("decantr")) files.push(rel(root, path));
     }
   }
   for (const candidate of ["Jenkinsfile", ".gitlab-ci.yml", "azure-pipelines.yml", "BUILD"]) {
-    const path = join19(root, candidate);
-    if (existsSync17(path) && readFileSync14(path, "utf-8").includes("decantr")) {
+    const path = join17(root, candidate);
+    if (existsSync15(path) && readFileSync12(path, "utf-8").includes("decantr")) {
       files.push(candidate);
     }
   }
@@ -5372,6 +4302,28 @@ function deriveAdoptionLane(input) {
     nextChoice: "Use task and verify to keep generated routes aligned with the compiled contract."
   };
 }
+function inspectGraphArtifacts(appRoot, workspaceRoot) {
+  const snapshotPath = join17(appRoot, ".decantr", "graph", "graph.snapshot.json");
+  const capsulePath = join17(appRoot, ".decantr", "graph", "contract-capsule.json");
+  try {
+    const artifacts = buildGraphArtifacts(appRoot);
+    return {
+      snapshotPresent: existsSync15(snapshotPath),
+      capsulePresent: existsSync15(capsulePath),
+      artifactsCurrent: artifacts ? artifacts.staleArtifacts.length === 0 : null,
+      staleArtifacts: artifacts ? artifacts.staleArtifacts.map((path) => rel(workspaceRoot, path)) : [],
+      error: null
+    };
+  } catch (error3) {
+    return {
+      snapshotPresent: existsSync15(snapshotPath),
+      capsulePresent: existsSync15(capsulePath),
+      artifactsCurrent: false,
+      staleArtifacts: [],
+      error: error3.message
+    };
+  }
+}
 function buildDoctorReport(root, args) {
   let projectArg;
   for (let index = 1; index < args.length; index += 1) {
@@ -5383,18 +4335,18 @@ function buildDoctorReport(root, args) {
   const workspaceInfo = resolveWorkspaceInfo(root, projectArg);
   const workspaceRoot = workspaceInfo.workspaceRoot;
   const appRoot = workspaceMode ? workspaceRoot : workspaceInfo.appRoot;
-  const projectMissing = Boolean(projectArg && !existsSync17(appRoot));
+  const projectMissing = Boolean(projectArg && !existsSync15(appRoot));
   const projectPath = appRoot === workspaceRoot ? null : rel(workspaceRoot, appRoot);
   const packageManager = detectPackageManager3(workspaceRoot);
   const cliDependency = localCliDependency(workspaceRoot);
   const detected = detectProject(appRoot);
-  const projectJson = readJson2(join19(appRoot, ".decantr", "project.json"));
-  const essence = readJson2(join19(appRoot, "decantr.essence.json"));
+  const projectJson = readJson2(join17(appRoot, ".decantr", "project.json"));
+  const essence = readJson2(join17(appRoot, "decantr.essence.json"));
   const essenceVersion = essence && typeof essence === "object" && "version" in essence ? String(essence.version) : null;
-  const contextDir = join19(appRoot, ".decantr", "context");
-  const packManifestPresent = existsSync17(join19(contextDir, "pack-manifest.json"));
-  const reviewPackPresent = existsSync17(join19(contextDir, "review-pack.json"));
-  const artifactReadmePresent = existsSync17(join19(appRoot, ARTIFACT_README_PATH));
+  const contextDir = join17(appRoot, ".decantr", "context");
+  const packManifestPresent = existsSync15(join17(contextDir, "pack-manifest.json"));
+  const reviewPackPresent = existsSync15(join17(contextDir, "review-pack.json"));
+  const artifactReadmePresent = existsSync15(join17(appRoot, ARTIFACT_README_PATH));
   const projects = listWorkspaceProjects(workspaceRoot);
   const candidates = listWorkspaceCandidates(workspaceRoot, projects).map((candidate) => ({
     path: candidate.path,
@@ -5405,22 +4357,23 @@ function buildDoctorReport(root, args) {
   const workflowMode = projectJson?.initialized?.workflowMode ?? null;
   const adoptionMode = projectJson?.initialized?.adoptionMode ?? null;
   const packHydrationOptional = adoptionMode === "contract-only" || adoptionMode === "style-bridge";
-  const localPatternsPresent = existsSync17(localPatternsPath(appRoot));
-  const localRulesPresent = existsSync17(localRulesPath(appRoot));
-  const styleBridgePresent = existsSync17(styleBridgePath(appRoot));
-  const styleBridgeProposalPresent = existsSync17(styleBridgeProposalPath(appRoot));
+  const localPatternsPresent = existsSync15(localPatternsPath(appRoot));
+  const localRulesPresent = existsSync15(localRulesPath(appRoot));
+  const styleBridgePresent = existsSync15(styleBridgePath(appRoot));
+  const styleBridgeProposalPresent = existsSync15(styleBridgeProposalPath(appRoot));
+  const graphArtifacts = inspectGraphArtifacts(appRoot, workspaceRoot);
   const missingPackReferences = workspaceMode ? projects.flatMap(
-    (project) => collectMissingPackManifestFiles(join19(workspaceRoot, project.path)).map(
+    (project) => collectMissingPackManifestFiles(join17(workspaceRoot, project.path)).map(
       (missing) => `${project.path}/${missing.relativePath}`
     )
   ) : collectMissingPackManifestFiles(appRoot).map((missing) => missing.relativePath);
   const workspaceProjectsMissingManifest = workspaceMode ? projects.map((project) => project.path).filter((projectPath2) => {
-    const projectContextDir = join19(workspaceRoot, projectPath2, ".decantr", "context");
-    return !isContractOnlyProject(join19(workspaceRoot, projectPath2)) && !existsSync17(join19(projectContextDir, "pack-manifest.json"));
+    const projectContextDir = join17(workspaceRoot, projectPath2, ".decantr", "context");
+    return !isContractOnlyProject(join17(workspaceRoot, projectPath2)) && !existsSync15(join17(projectContextDir, "pack-manifest.json"));
   }) : [];
   const workspaceProjectsMissingReviewPack = workspaceMode ? projects.map((project) => project.path).filter((projectPath2) => {
-    const projectContextDir = join19(workspaceRoot, projectPath2, ".decantr", "context");
-    return !isContractOnlyProject(join19(workspaceRoot, projectPath2)) && !existsSync17(join19(projectContextDir, "review-pack.json"));
+    const projectContextDir = join17(workspaceRoot, projectPath2, ".decantr", "context");
+    return !isContractOnlyProject(join17(workspaceRoot, projectPath2)) && !existsSync15(join17(projectContextDir, "review-pack.json"));
   }) : [];
   const issues = [];
   if (projectMissing) {
@@ -5437,7 +4390,7 @@ function buildDoctorReport(root, args) {
       message: "No decantr.essence.json found for this app.",
       nextCommand: projectPath ? `decantr adopt --project ${projectPath} --yes` : "decantr adopt --yes"
     });
-  } else if (essenceVersion && !isV44(essence)) {
+  } else if (essenceVersion && !isV43(essence)) {
     issues.push({
       category: "migration",
       severity: "error",
@@ -5477,7 +4430,7 @@ function buildDoctorReport(root, args) {
       nextCommand: "decantr refresh"
     });
   }
-  if (essenceVersion === "4.0.0" && !packHydrationOptional && (!existsSync17(contextDir) || !packManifestPresent)) {
+  if (essenceVersion === "4.0.0" && !packHydrationOptional && (!existsSync15(contextDir) || !packManifestPresent)) {
     issues.push({
       category: "generated-artifact",
       severity: "warn",
@@ -5493,6 +4446,14 @@ function buildDoctorReport(root, args) {
       nextCommand: projectPath ? `decantr registry compile-packs ${projectPath}/decantr.essence.json --write-context` : "decantr registry compile-packs decantr.essence.json --write-context"
     });
   }
+  if (essenceVersion === "4.0.0" && (Boolean(projectJson) || graphArtifacts.snapshotPresent || graphArtifacts.capsulePresent) && (graphArtifacts.error || graphArtifacts.artifactsCurrent === false)) {
+    issues.push({
+      category: "graph",
+      severity: "warn",
+      message: graphArtifacts.error ? `Typed Contract graph could not be derived: ${graphArtifacts.error}` : "Typed Contract graph artifacts are missing or stale.",
+      nextCommand: projectPath ? `decantr graph --project ${projectPath}` : "decantr graph"
+    });
+  }
   if (workspaceMode && (workspaceProjectsMissingManifest.length > 0 || workspaceProjectsMissingReviewPack.length > 0 || missingPackReferences.length > 0)) {
     issues.push({
       category: "generated-artifact",
@@ -5562,6 +4523,10 @@ function buildDoctorReport(root, args) {
       recommendedNextCommands,
       issues.find((issue) => issue.category === "ci" && issue.message.includes("not pinned"))?.nextCommand
     );
+    appendUnique(
+      recommendedNextCommands,
+      issues.find((issue) => issue.category === "graph")?.nextCommand
+    );
     if (workflowMode === "brownfield-attach" && !localPatternsPresent) {
       appendUnique(recommendedNextCommands, `decantr codify --from-audit${projectFlag}`);
       appendUnique(recommendedNextCommands, `decantr codify --accept${projectFlag}`);
@@ -5611,11 +4576,16 @@ function buildDoctorReport(root, args) {
     },
     generatedArtifacts: {
       contextDirPresent: workspaceMode ? projects.some(
-        (project) => existsSync17(join19(workspaceRoot, project.path, ".decantr", "context"))
-      ) : existsSync17(contextDir),
+        (project) => existsSync15(join17(workspaceRoot, project.path, ".decantr", "context"))
+      ) : existsSync15(contextDir),
       packManifestPresent: workspaceMode ? projects.length > 0 && workspaceProjectsMissingManifest.length === 0 : packManifestPresent,
       reviewPackPresent: workspaceMode ? projects.length > 0 && workspaceProjectsMissingReviewPack.length === 0 : reviewPackPresent,
-      missingReferencedFiles: missingPackReferences.slice(0, 25)
+      missingReferencedFiles: missingPackReferences.slice(0, 25),
+      graphSnapshotPresent: graphArtifacts.snapshotPresent,
+      graphCapsulePresent: graphArtifacts.capsulePresent,
+      graphArtifactsCurrent: graphArtifacts.artifactsCurrent,
+      graphStaleArtifacts: graphArtifacts.staleArtifacts.slice(0, 25),
+      graphError: graphArtifacts.error
     },
     localLaw: {
       patternsPresent: localPatternsPresent,
@@ -5624,7 +4594,7 @@ function buildDoctorReport(root, args) {
       styleBridgeProposalPresent
     },
     visualEvidence: {
-      manifestPresent: existsSync17(join19(appRoot, ".decantr", "evidence", "visual-manifest.json"))
+      manifestPresent: existsSync15(join17(appRoot, ".decantr", "evidence", "visual-manifest.json"))
     },
     lane,
     designAuthority,
@@ -5668,6 +4638,8 @@ function formatDoctorText(report) {
     `  Review pack: ${report.generatedArtifacts.reviewPackPresent ? "present" : "missing"}`,
     `  Manifest references: ${report.generatedArtifacts.missingReferencedFiles.length === 0 ? "complete" : `${report.generatedArtifacts.missingReferencedFiles.length} missing`}`,
     `  Artifact guide: ${report.project.artifactReadmePresent ? "present" : "missing"}`,
+    `  Typed graph: ${report.generatedArtifacts.graphError ? "error" : report.generatedArtifacts.graphArtifactsCurrent === true ? "current" : report.generatedArtifacts.graphArtifactsCurrent === false ? "stale or missing" : "not generated"}`,
+    `  Graph capsule: ${report.generatedArtifacts.graphCapsulePresent ? "present" : "missing"}`,
     "",
     `${BOLD3}Local Law:${RESET4}`,
     `  Local patterns: ${report.localLaw.patternsPresent ? "present" : "missing"}`,
@@ -5732,17 +4704,17 @@ async function cmdDoctor(args = ["doctor"], root = process.cwd()) {
 }
 
 // src/commands/export.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname5, isAbsolute, join as join20 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname5, isAbsolute, join as join18 } from "path";
 var GREEN5 = "\x1B[32m";
 var RED4 = "\x1B[31m";
 var DIM5 = "\x1B[2m";
 var RESET5 = "\x1B[0m";
 function readAdoptionMode(projectRoot) {
-  const projectJsonPath = join20(projectRoot, ".decantr", "project.json");
-  if (!existsSync18(projectJsonPath)) return null;
+  const projectJsonPath = join18(projectRoot, ".decantr", "project.json");
+  if (!existsSync16(projectJsonPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync15(projectJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(projectJsonPath, "utf-8"));
     return typeof parsed.initialized?.adoptionMode === "string" ? parsed.initialized.adoptionMode : null;
   } catch {
     return null;
@@ -5750,7 +4722,7 @@ function readAdoptionMode(projectRoot) {
 }
 function resolveOutputPath(projectRoot, output, fallback) {
   if (!output) return fallback;
-  return isAbsolute(output) ? output : join20(projectRoot, output);
+  return isAbsolute(output) ? output : join18(projectRoot, output);
 }
 var SHADCN_MAP = {
   "--d-bg": "--background",
@@ -5911,21 +4883,21 @@ function generateFigmaTokens(tokens) {
 `;
 }
 async function cmdExport(target, projectRoot, options = {}) {
-  const essencePath = join20(projectRoot, "decantr.essence.json");
-  const tokensPath = join20(projectRoot, "src", "styles", "tokens.css");
-  if (!existsSync18(essencePath)) {
+  const essencePath = join18(projectRoot, "decantr.essence.json");
+  const tokensPath = join18(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync16(essencePath)) {
     console.error(`${RED4}No decantr.essence.json found. Run \`decantr init\` first.${RESET5}`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync18(tokensPath)) {
+  if (!existsSync16(tokensPath)) {
     const adoptionMode = readAdoptionMode(projectRoot);
     const message = adoptionMode === "contract-only" ? `No src/styles/tokens.css found. This export reads Decantr CSS tokens, but this project is contract-only Brownfield and may intentionally use its own Tailwind/Sass token system. Export from the app's token source or adopt a style bridge before using \`decantr export --to ${target}\`.` : "No src/styles/tokens.css found. Run `decantr refresh` to generate tokens.";
     console.error(`${RED4}${message}${RESET5}`);
     process.exitCode = 1;
     return;
   }
-  const tokensCSS = readFileSync15(tokensPath, "utf-8");
+  const tokensCSS = readFileSync13(tokensPath, "utf-8");
   const tokens = parseTokensCSS(tokensCSS);
   if (tokens.size === 0) {
     console.error(`${RED4}No --d-* tokens found in tokens.css.${RESET5}`);
@@ -5937,12 +4909,12 @@ async function cmdExport(target, projectRoot, options = {}) {
       const cssOut = resolveOutputPath(
         projectRoot,
         options.output,
-        join20(projectRoot, "src", "styles", "shadcn-theme.css")
+        join18(projectRoot, "src", "styles", "shadcn-theme.css")
       );
-      const jsonOut = join20(projectRoot, "components.json");
+      const jsonOut = join18(projectRoot, "components.json");
       ensureDir(cssOut);
-      writeFileSync13(cssOut, generateShadcnCSS(tokens), "utf-8");
-      writeFileSync13(jsonOut, generateShadcnComponentsJSON(), "utf-8");
+      writeFileSync11(cssOut, generateShadcnCSS(tokens), "utf-8");
+      writeFileSync11(jsonOut, generateShadcnComponentsJSON(), "utf-8");
       console.log(`${GREEN5}Exported shadcn theme:${RESET5}`);
       console.log(`  ${DIM5}CSS:${RESET5}  ${cssOut}`);
       console.log(`  ${DIM5}JSON:${RESET5} ${jsonOut}`);
@@ -5952,10 +4924,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join20(projectRoot, "tailwind.decantr.config.ts")
+        join18(projectRoot, "tailwind.decantr.config.ts")
       );
       ensureDir(out);
-      writeFileSync13(out, generateTailwindConfig(tokens), "utf-8");
+      writeFileSync11(out, generateTailwindConfig(tokens), "utf-8");
       console.log(`${GREEN5}Exported Tailwind config:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5964,10 +4936,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join20(projectRoot, "decantr-tokens.css")
+        join18(projectRoot, "decantr-tokens.css")
       );
       ensureDir(out);
-      writeFileSync13(out, generateCSSVars(tokens), "utf-8");
+      writeFileSync11(out, generateCSSVars(tokens), "utf-8");
       console.log(`${GREEN5}Exported CSS variables:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5976,10 +4948,10 @@ async function cmdExport(target, projectRoot, options = {}) {
       const out = resolveOutputPath(
         projectRoot,
         options.output,
-        join20(projectRoot, ".decantr", "design", "figma-tokens.json")
+        join18(projectRoot, ".decantr", "design", "figma-tokens.json")
       );
       ensureDir(out);
-      writeFileSync13(out, generateFigmaTokens(tokens), "utf-8");
+      writeFileSync11(out, generateFigmaTokens(tokens), "utf-8");
       console.log(`${GREEN5}Exported Figma/Tokens Studio tokens:${RESET5}`);
       console.log(`  ${DIM5}File:${RESET5} ${out}`);
       break;
@@ -5988,15 +4960,15 @@ async function cmdExport(target, projectRoot, options = {}) {
 }
 function ensureDir(filePath) {
   const dir = dirname5(filePath);
-  if (!existsSync18(dir)) {
-    mkdirSync12(dir, { recursive: true });
+  if (!existsSync16(dir)) {
+    mkdirSync10(dir, { recursive: true });
   }
 }
 
 // src/commands/magic.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import * as fs from "fs/promises";
-import { join as join21 } from "path";
+import { join as join19 } from "path";
 var BOLD4 = "\x1B[1m";
 var DIM6 = "\x1B[2m";
 var RESET6 = "\x1B[0m";
@@ -6220,8 +5192,8 @@ async function cmdMagic(prompt, projectRoot, options) {
     console.log(`   Archetype:    ${intent.archetype}`);
   }
   console.log("");
-  const essencePath = join21(projectRoot, "decantr.essence.json");
-  if (existsSync19(essencePath)) {
+  const essencePath = join19(projectRoot, "decantr.essence.json");
+  if (existsSync17(essencePath)) {
     const projectFlag = options.projectLabel ? ` --project ${options.projectLabel}` : "";
     console.log(`${YELLOW4} Decantr is already attached to this project.${RESET6}`);
     console.log(
@@ -6254,7 +5226,7 @@ async function cmdMagic(prompt, projectRoot, options) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join21(projectRoot, ".decantr", "cache"),
+    cacheDir: join19(projectRoot, ".decantr", "cache"),
     apiUrl: options.registry,
     offline: options.offline
   });
@@ -6525,14 +5497,14 @@ async function cmdMagic(prompt, projectRoot, options) {
   if (result.gitignoreUpdated) {
     console.log(`   ${dim(".gitignore updated")}`);
   }
-  const contextDir = join21(projectRoot, ".decantr", "context");
+  const contextDir = join19(projectRoot, ".decantr", "context");
   let sectionCount = 0;
   try {
     const files = await fs.readdir(contextDir);
     sectionCount = files.filter((f) => f.startsWith("section-")).length;
   } catch {
   }
-  const treatmentsPath = join21(projectRoot, "src", "styles", "treatments.css");
+  const treatmentsPath = join19(projectRoot, "src", "styles", "treatments.css");
   let hasLayers = false;
   try {
     const css = await fs.readFile(treatmentsPath, "utf-8");
@@ -6565,10 +5537,10 @@ ${GREEN6}${BOLD4}Quality summary:${RESET6}`);
 }
 
 // src/commands/migrate.ts
-import { copyFileSync, existsSync as existsSync20, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "fs";
-import { join as join22 } from "path";
+import { copyFileSync, existsSync as existsSync18, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
+import { join as join20 } from "path";
 import {
-  isV4 as isV45,
+  isV4 as isV44,
   migrateToV4,
   validateEssence,
   validateLegacyEssenceForMigration
@@ -6579,12 +5551,12 @@ var YELLOW5 = "\x1B[33m";
 var RESET7 = "\x1B[0m";
 var DIM7 = "\x1B[2m";
 function migrateEssenceFile(essencePath) {
-  if (!existsSync20(essencePath)) {
+  if (!existsSync18(essencePath)) {
     return { success: false, error: `File not found: ${essencePath}` };
   }
   let raw;
   try {
-    raw = readFileSync16(essencePath, "utf-8");
+    raw = readFileSync14(essencePath, "utf-8");
   } catch (e) {
     return { success: false, error: `Could not read ${essencePath}: ${e.message}` };
   }
@@ -6594,7 +5566,7 @@ function migrateEssenceFile(essencePath) {
   } catch (e) {
     return { success: false, error: `Invalid JSON: ${e.message}` };
   }
-  if (isV45(essence)) {
+  if (isV44(essence)) {
     return { success: true, alreadyV4: true, essence };
   }
   const preValidation = validateLegacyEssenceForMigration(essence);
@@ -6625,7 +5597,7 @@ function migrateEssenceFile(essencePath) {
     };
   }
   try {
-    writeFileSync14(essencePath, JSON.stringify(v4, null, 2) + "\n");
+    writeFileSync12(essencePath, JSON.stringify(v4, null, 2) + "\n");
   } catch (e) {
     return {
       success: false,
@@ -6646,8 +5618,8 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join22(projectRoot, "decantr.essence.json");
-  if (!existsSync20(essencePath)) {
+  const essencePath = join20(projectRoot, "decantr.essence.json");
+  if (!existsSync18(essencePath)) {
     console.error(`${RED5}No decantr.essence.json found. Run \`decantr init\` first.${RESET7}`);
     process.exitCode = 1;
     return;
@@ -6669,7 +5641,7 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
   }
   if (result.essence) {
     const registryClient = new RegistryClient({
-      cacheDir: join22(projectRoot, ".decantr", "cache")
+      cacheDir: join20(projectRoot, ".decantr", "cache")
     });
     await refreshDerivedFiles(projectRoot, result.essence, registryClient);
     console.log(`${GREEN7}Derived context and execution packs refreshed.${RESET7}`);
@@ -6680,50 +5652,50 @@ async function cmdMigrate(projectRoot = process.cwd(), args = []) {
 
 // src/commands/new-project.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync14 } from "fs";
-import { join as join24, resolve as resolve3 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12 } from "fs";
+import { join as join22, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/offline-content.ts
-import { cpSync, existsSync as existsSync21, mkdirSync as mkdirSync13 } from "fs";
-import { join as join23, resolve as resolve2 } from "path";
+import { cpSync, existsSync as existsSync19, mkdirSync as mkdirSync11 } from "fs";
+import { join as join21, resolve as resolve2 } from "path";
 var CONTENT_TYPES2 = ["archetypes", "blueprints", "patterns", "themes", "shells"];
 function copyIfExists(source, target) {
-  if (!existsSync21(source)) return false;
+  if (!existsSync19(source)) return false;
   if (resolve2(source) === resolve2(target)) return true;
   cpSync(source, target, { recursive: true });
   return true;
 }
 function hydrateContentRoot(projectDir, contentRoot) {
-  if (!existsSync21(contentRoot)) return false;
-  const customRoot = join23(projectDir, ".decantr", "custom");
-  const cacheRoot = join23(projectDir, ".decantr", "cache", "@official");
-  mkdirSync13(customRoot, { recursive: true });
-  mkdirSync13(cacheRoot, { recursive: true });
+  if (!existsSync19(contentRoot)) return false;
+  const customRoot = join21(projectDir, ".decantr", "custom");
+  const cacheRoot = join21(projectDir, ".decantr", "cache", "@official");
+  mkdirSync11(customRoot, { recursive: true });
+  mkdirSync11(cacheRoot, { recursive: true });
   let copiedAny = false;
   for (const type of CONTENT_TYPES2) {
-    const sourceDir = join23(contentRoot, type);
-    if (!existsSync21(sourceDir)) continue;
-    cpSync(sourceDir, join23(customRoot, type), { recursive: true });
-    cpSync(sourceDir, join23(cacheRoot, type), { recursive: true });
+    const sourceDir = join21(contentRoot, type);
+    if (!existsSync19(sourceDir)) continue;
+    cpSync(sourceDir, join21(customRoot, type), { recursive: true });
+    cpSync(sourceDir, join21(cacheRoot, type), { recursive: true });
     copiedAny = true;
   }
   return copiedAny;
 }
 function seedOfflineRegistry(projectDir, workspaceRoot) {
-  const projectDecantrRoot = join23(projectDir, ".decantr");
-  mkdirSync13(projectDecantrRoot, { recursive: true });
+  const projectDecantrRoot = join21(projectDir, ".decantr");
+  mkdirSync11(projectDecantrRoot, { recursive: true });
   const configuredContentRoot = process.env.DECANTR_CONTENT_DIR ? resolve2(process.env.DECANTR_CONTENT_DIR) : null;
   if (configuredContentRoot && hydrateContentRoot(projectDir, configuredContentRoot)) {
     return { seeded: true, strategy: "configured-content-root" };
   }
   const copiedCache = copyIfExists(
-    join23(workspaceRoot, ".decantr", "cache"),
-    join23(projectDecantrRoot, "cache")
+    join21(workspaceRoot, ".decantr", "cache"),
+    join21(projectDecantrRoot, "cache")
   );
   const copiedCustom = copyIfExists(
-    join23(workspaceRoot, ".decantr", "custom"),
-    join23(projectDecantrRoot, "custom")
+    join21(workspaceRoot, ".decantr", "custom"),
+    join21(projectDecantrRoot, "custom")
   );
   if (copiedCache || copiedCustom) {
     return { seeded: true, strategy: "workspace-cache" };
@@ -6836,7 +5808,7 @@ function runArgvCommand(command, args, cwd) {
 }
 function resolveInitCommand(initFlags) {
   const bundledCliEntrypoint = fileURLToPath2(new URL("./bin.js", import.meta.url));
-  const cliEntrypoint = existsSync22(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync22(process.argv[1]) ? process.argv[1] : null;
+  const cliEntrypoint = existsSync20(bundledCliEntrypoint) ? bundledCliEntrypoint : process.argv[1] && existsSync20(process.argv[1]) ? process.argv[1] : null;
   if (cliEntrypoint) {
     return {
       command: process.execPath,
@@ -6864,7 +5836,7 @@ async function cmdNewProject(projectName, options) {
     process.exitCode = 1;
     return;
   }
-  if (existsSync22(projectDir)) {
+  if (existsSync20(projectDir)) {
     console.error(error(`Directory "${projectName}" already exists.`));
     process.exitCode = 1;
     return;
@@ -6878,7 +5850,7 @@ async function cmdNewProject(projectName, options) {
     return;
   }
   console.log(heading(`Creating ${projectName}...`));
-  mkdirSync14(projectDir, { recursive: true });
+  mkdirSync12(projectDir, { recursive: true });
   console.log(dim2(`  Created ${projectName}/`));
   const title = projectName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   if (shouldBootstrapRuntime && bootstrapAdapter) {
@@ -6977,21 +5949,21 @@ ${YELLOW6}Decantr init encountered issues. Run \`decantr init\` manually inside
   }
 }
 function detectPackageManager4() {
-  if (existsSync22(join24(process.cwd(), "pnpm-lock.yaml")) || existsSync22(join24(process.cwd(), "pnpm-workspace.yaml"))) {
+  if (existsSync20(join22(process.cwd(), "pnpm-lock.yaml")) || existsSync20(join22(process.cwd(), "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync22(join24(process.cwd(), "yarn.lock"))) {
+  if (existsSync20(join22(process.cwd(), "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync22(join24(process.cwd(), "bun.lockb")) || existsSync22(join24(process.cwd(), "bun.lock"))) {
+  if (existsSync20(join22(process.cwd(), "bun.lockb")) || existsSync20(join22(process.cwd(), "bun.lock"))) {
     return "bun";
   }
   return "npm";
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync23, readFileSync as readFileSync17 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync15 } from "fs";
+import { join as join23 } from "path";
 import {
   API_CONTENT_TYPE_TO_CONTENT_TYPE,
   CONTENT_TYPE_TO_API_CONTENT_TYPE as CONTENT_TYPE_TO_API_CONTENT_TYPE2,
@@ -7007,8 +5979,8 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
   }
   const singularType = API_CONTENT_TYPE_TO_CONTENT_TYPE[type] || type;
   const pluralType = CONTENT_TYPE_TO_API_CONTENT_TYPE2[type] || CONTENT_TYPE_TO_API_CONTENT_TYPE2[singularType] || `${type}s`;
-  const customPath = join25(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
-  if (!existsSync23(customPath)) {
+  const customPath = join23(projectRoot, ".decantr", "custom", pluralType, `${name}.json`);
+  if (!existsSync21(customPath)) {
     console.error(`Custom ${singularType} "${name}" not found at ${customPath}`);
     console.error(`Create one first: decantr create ${singularType} ${name}`);
     process.exitCode = 1;
@@ -7016,7 +5988,7 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
   }
   let data;
   try {
-    data = JSON.parse(readFileSync17(customPath, "utf-8"));
+    data = JSON.parse(readFileSync15(customPath, "utf-8"));
   } catch {
     console.error(`Failed to parse ${customPath}`);
     process.exitCode = 1;
@@ -7055,22 +6027,22 @@ async function cmdPublish(type, name, projectRoot = process.cwd()) {
 
 // src/commands/refresh.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync18, statSync as statSync6 } from "fs";
-import { isAbsolute as isAbsolute2, join as join26, relative as relative6 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync6, readFileSync as readFileSync16, statSync as statSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join24, relative as relative5 } from "path";
 import { collectMissingPackManifestFiles as collectMissingPackManifestFiles2 } from "@decantr/verifier";
-import { isV4 as isV46 } from "@decantr/essence-spec";
+import { isV4 as isV45 } from "@decantr/essence-spec";
 var GREEN9 = "\x1B[32m";
 var RED7 = "\x1B[31m";
 var DIM9 = "\x1B[2m";
 var RESET9 = "\x1B[0m";
 function hashFile(path) {
-  return createHash("sha256").update(readFileSync18(path)).digest("hex");
+  return createHash("sha256").update(readFileSync16(path)).digest("hex");
 }
 function walkFiles(dir) {
-  if (!existsSync24(dir)) return [];
+  if (!existsSync22(dir)) return [];
   const files = [];
-  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-    const path = join26(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const path = join24(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkFiles(path));
     } else if (entry.isFile()) {
@@ -7081,10 +6053,10 @@ function walkFiles(dir) {
 }
 function trackedGeneratedFiles(projectRoot) {
   return [
-    join26(projectRoot, "DECANTR.md"),
-    ...walkFiles(join26(projectRoot, ".decantr", "context")),
-    ...["global.css", "tokens.css", "treatments.css", "decantr-bridge.css"].map((file) => join26(projectRoot, "src", "styles", file)).filter((path) => existsSync24(path))
-  ].filter((path) => existsSync24(path));
+    join24(projectRoot, "DECANTR.md"),
+    ...walkFiles(join24(projectRoot, ".decantr", "context")),
+    ...["global.css", "tokens.css", "treatments.css", "decantr-bridge.css"].map((file) => join24(projectRoot, "src", "styles", file)).filter((path) => existsSync22(path))
+  ].filter((path) => existsSync22(path));
 }
 function snapshotGeneratedFiles(projectRoot) {
   const map = /* @__PURE__ */ new Map();
@@ -7100,40 +6072,40 @@ function snapshotGeneratedFiles(projectRoot) {
 }
 function fileMtimeMs(path) {
   try {
-    return statSync6(path).mtimeMs;
+    return statSync5(path).mtimeMs;
   } catch {
     return 0;
   }
 }
 function newestInputMtime(projectRoot) {
   return Math.max(
-    fileMtimeMs(join26(projectRoot, "decantr.essence.json")),
-    fileMtimeMs(join26(projectRoot, ".decantr", "project.json"))
+    fileMtimeMs(join24(projectRoot, "decantr.essence.json")),
+    fileMtimeMs(join24(projectRoot, ".decantr", "project.json"))
   );
 }
 function isContractOnlyProject2(projectRoot) {
-  const projectJsonPath = join26(projectRoot, ".decantr", "project.json");
-  if (!existsSync24(projectJsonPath)) return false;
+  const projectJsonPath = join24(projectRoot, ".decantr", "project.json");
+  if (!existsSync22(projectJsonPath)) return false;
   try {
-    const projectJson = JSON.parse(readFileSync18(projectJsonPath, "utf-8"));
+    const projectJson = JSON.parse(readFileSync16(projectJsonPath, "utf-8"));
     return projectJson.initialized?.adoptionMode === "contract-only";
   } catch {
     return false;
   }
 }
 function checkRefreshFreshness(projectRoot) {
-  const contextDir = join26(projectRoot, ".decantr", "context");
+  const contextDir = join24(projectRoot, ".decantr", "context");
   const generated = trackedGeneratedFiles(projectRoot);
   const reasons = [];
   const packHydrationOptional = isContractOnlyProject2(projectRoot);
-  if (!existsSync24(join26(projectRoot, "DECANTR.md"))) reasons.push("DECANTR.md is missing.");
-  if (!existsSync24(contextDir)) reasons.push(".decantr/context is missing.");
-  if (!existsSync24(join26(contextDir, "scaffold.md"))) {
+  if (!existsSync22(join24(projectRoot, "DECANTR.md"))) reasons.push("DECANTR.md is missing.");
+  if (!existsSync22(contextDir)) reasons.push(".decantr/context is missing.");
+  if (!existsSync22(join24(contextDir, "scaffold.md"))) {
     reasons.push(".decantr/context/scaffold.md is missing.");
   }
-  if (!packHydrationOptional && !existsSync24(join26(contextDir, "pack-manifest.json"))) {
+  if (!packHydrationOptional && !existsSync22(join24(contextDir, "pack-manifest.json"))) {
     reasons.push(".decantr/context/pack-manifest.json is missing.");
-  } else if (existsSync24(join26(contextDir, "pack-manifest.json"))) {
+  } else if (existsSync22(join24(contextDir, "pack-manifest.json"))) {
     const missingPackFiles = collectMissingPackManifestFiles2(projectRoot);
     if (missingPackFiles.length > 0) {
       reasons.push(
@@ -7186,8 +6158,8 @@ function summarizeChanges(projectRoot, before, after) {
 }
 function displayGeneratedPath(summary, file, displayRoot) {
   if (!displayRoot) return file;
-  const absolutePath = join26(summary.projectRoot, file);
-  const relativePath = relative6(displayRoot, absolutePath).replace(/\\/g, "/");
+  const absolutePath = join24(summary.projectRoot, file);
+  const relativePath = relative5(displayRoot, absolutePath).replace(/\\/g, "/");
   if (relativePath && !relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
     return relativePath;
   }
@@ -7221,17 +6193,17 @@ function printRefreshSummary(summary, displayRoot) {
   }
 }
 async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
-  const essencePath = join26(projectRoot, "decantr.essence.json");
-  if (!existsSync24(essencePath)) {
+  const essencePath = join24(projectRoot, "decantr.essence.json");
+  if (!existsSync22(essencePath)) {
     console.error(`${RED7}No decantr.essence.json found. Run \`decantr init\` first.${RESET9}`);
     process.exitCode = 1;
     return;
   }
   let essence;
   try {
-    const raw = readFileSync18(essencePath, "utf-8");
+    const raw = readFileSync16(essencePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (!isV46(parsed)) {
+    if (!isV45(parsed)) {
       console.error(
         `${RED7}Active workflows require Essence v4.0.0. Run \`decantr migrate --to v4\` first.${RESET9}`
       );
@@ -7255,7 +6227,7 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join26(projectRoot, ".decantr", "cache"),
+    cacheDir: join24(projectRoot, ".decantr", "cache"),
     offline: options.offline
   });
   console.log("Regenerating derived files...\n");
@@ -7286,8 +6258,8 @@ async function cmdRefresh(projectRoot = process.cwd(), options = {}) {
 }
 
 // src/commands/registry-mirror.ts
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "fs";
-import { join as join27 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync13 } from "fs";
+import { join as join25 } from "path";
 import { API_CONTENT_TYPES, RegistryAPIClient as RegistryAPIClient2 } from "@decantr/registry";
 var GREEN10 = "\x1B[32m";
 var RED8 = "\x1B[31m";
@@ -7315,7 +6287,7 @@ async function cmdRegistryMirror(projectRoot, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const cacheDir = join27(projectRoot, ".decantr", "cache");
+  const cacheDir = join25(projectRoot, ".decantr", "cache");
   const counts = {};
   const failed = [];
   console.log(`
@@ -7325,19 +6297,19 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
     try {
       const result = await apiClient.listContent(type, { namespace: "@official" });
       const items = result.items;
-      const typeDir = join27(cacheDir, "@official", type);
-      mkdirSync15(typeDir, { recursive: true });
-      writeFileSync15(join27(typeDir, "index.json"), JSON.stringify(result, null, 2));
+      const typeDir = join25(cacheDir, "@official", type);
+      mkdirSync13(typeDir, { recursive: true });
+      writeFileSync13(join25(typeDir, "index.json"), JSON.stringify(result, null, 2));
       let itemCount = 0;
       for (const item of items) {
         const slug = item.slug || item.id;
         if (!slug) continue;
         try {
           const fullItem = await apiClient.getContent(type, "@official", slug);
-          writeFileSync15(join27(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
+          writeFileSync13(join25(typeDir, `${slug}.json`), JSON.stringify(fullItem, null, 2));
           itemCount++;
         } catch {
-          writeFileSync15(join27(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
+          writeFileSync13(join25(typeDir, `${slug}.json`), JSON.stringify(item, null, 2));
           itemCount++;
         }
       }
@@ -7352,8 +6324,8 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
     mirrored_at: (/* @__PURE__ */ new Date()).toISOString(),
     counts
   };
-  mkdirSync15(join27(cacheDir), { recursive: true });
-  writeFileSync15(join27(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
+  mkdirSync13(join25(cacheDir), { recursive: true });
+  writeFileSync13(join25(cacheDir, "mirror-manifest.json"), JSON.stringify(manifest, null, 2));
   const totalItems = Object.values(counts).reduce((a, b) => a + b, 0);
   console.log("");
   if (failed.length > 0) {
@@ -7370,30 +6342,30 @@ Mirroring registry content to ${DIM10}.decantr/cache/${RESET10}
 }
 
 // src/commands/remove.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, rmSync as rmSync2, writeFileSync as writeFileSync16 } from "fs";
-import { join as join28 } from "path";
-import { isV4 as isV47 } from "@decantr/essence-spec";
+import { existsSync as existsSync24, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync14 } from "fs";
+import { join as join26 } from "path";
+import { isV4 as isV46 } from "@decantr/essence-spec";
 var GREEN11 = "\x1B[32m";
 var RED9 = "\x1B[31m";
 var YELLOW8 = "\x1B[33m";
 var DIM11 = "\x1B[2m";
 var RESET11 = "\x1B[0m";
 function readV4Essence2(projectRoot) {
-  const essencePath = join28(projectRoot, "decantr.essence.json");
-  if (!existsSync26(essencePath)) {
+  const essencePath = join26(projectRoot, "decantr.essence.json");
+  if (!existsSync24(essencePath)) {
     console.error(`${RED9}No decantr.essence.json found. Run \`decantr init\` first.${RESET11}`);
     process.exitCode = 1;
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync17(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED9}Could not read essence: ${e.message}${RESET11}`);
     process.exitCode = 1;
     return null;
   }
-  if (!isV47(parsed)) {
+  if (!isV46(parsed)) {
     console.error(
       `${RED9}Active workflows require Essence v4.0.0. Run \`decantr migrate --to v4\` first.${RESET11}`
     );
@@ -7403,7 +6375,7 @@ function readV4Essence2(projectRoot) {
   return { essence: parsed, essencePath };
 }
 function writeEssence2(essencePath, essence) {
-  writeFileSync16(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync14(essencePath, JSON.stringify(essence, null, 2) + "\n");
 }
 function readFlagValue2(args, name) {
   const prefix = `--${name}=`;
@@ -7475,14 +6447,14 @@ async function cmdRemoveSection(sectionId, args, projectRoot = process.cwd()) {
   sections.splice(idx, 1);
   recomputeGlobalFeatures(essence);
   removeRoutes(essence, sectionId);
-  const contextFile = join28(projectRoot, ".decantr", "context", `${sectionId}.md`);
-  if (existsSync26(contextFile)) {
+  const contextFile = join26(projectRoot, ".decantr", "context", `${sectionId}.md`);
+  if (existsSync24(contextFile)) {
     rmSync2(contextFile);
   }
   writeEssence2(essencePath, essence);
   console.log(`${GREEN11}Removed section "${sectionId}".${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join28(projectRoot, ".decantr", "cache")
+    cacheDir: join26(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
@@ -7525,7 +6497,7 @@ async function cmdRemovePage(path, args, projectRoot = process.cwd()) {
   }
   console.log(`${GREEN11}Removed page "${pageId}" from section "${resolvedSectionId}".${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join28(projectRoot, ".decantr", "cache")
+    cacheDir: join26(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
@@ -7568,15 +6540,15 @@ async function cmdRemoveFeature(feature, args, projectRoot = process.cwd()) {
   const target = sectionId ? `section "${sectionId}" and global` : "global";
   console.log(`${GREEN11}Removed feature "${feature}" from ${target} features.${RESET11}`);
   const registryClient = new RegistryClient({
-    cacheDir: join28(projectRoot, ".decantr", "cache")
+    cacheDir: join26(projectRoot, ".decantr", "cache")
   });
   await refreshDerivedFiles(projectRoot, essence, registryClient);
   console.log(`${GREEN11}Derived files refreshed.${RESET11}`);
 }
 
 // src/commands/sync-drift.ts
-import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
+import { join as join27 } from "path";
 var GREEN12 = "\x1B[32m";
 var RED10 = "\x1B[31m";
 var YELLOW9 = "\x1B[33m";
@@ -7585,8 +6557,8 @@ var DIM12 = "\x1B[2m";
 var BOLD6 = "\x1B[1m";
 var CYAN6 = "\x1B[36m";
 async function cmdSyncDrift(projectRoot = process.cwd()) {
-  const driftLogPath = join29(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync27(driftLogPath)) {
+  const driftLogPath = join27(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync25(driftLogPath)) {
     console.log(`${GREEN12}No drift log found \u2014 no drift recorded.${RESET12}`);
     console.log(
       `${DIM12}Drift is logged when guard violations are detected during development.${RESET12}`
@@ -7595,7 +6567,7 @@ async function cmdSyncDrift(projectRoot = process.cwd()) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync20(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync18(driftLogPath, "utf-8"));
   } catch {
     console.error(`${RED10}Could not parse drift-log.json${RESET12}`);
     process.exitCode = 1;
@@ -7641,13 +6613,13 @@ ${BOLD6}Unresolved Drift Entries (${unresolved.length})${RESET12}
   console.log("");
 }
 function resolveDriftEntries(projectRoot, options) {
-  const driftLogPath = join29(projectRoot, ".decantr", "drift-log.json");
-  if (!existsSync27(driftLogPath)) {
+  const driftLogPath = join27(projectRoot, ".decantr", "drift-log.json");
+  if (!existsSync25(driftLogPath)) {
     return { success: true };
   }
   if (options.clear) {
     try {
-      writeFileSync17(driftLogPath, "[]");
+      writeFileSync15(driftLogPath, "[]");
       return { success: true };
     } catch (e) {
       return { success: false, error: `Could not clear drift log: ${e.message}` };
@@ -7655,7 +6627,7 @@ function resolveDriftEntries(projectRoot, options) {
   }
   let entries;
   try {
-    entries = JSON.parse(readFileSync20(driftLogPath, "utf-8"));
+    entries = JSON.parse(readFileSync18(driftLogPath, "utf-8"));
   } catch {
     return { success: false, error: "Could not parse drift-log.json" };
   }
@@ -7674,7 +6646,7 @@ function resolveDriftEntries(projectRoot, options) {
     }
   }
   try {
-    writeFileSync17(driftLogPath, JSON.stringify(entries, null, 2));
+    writeFileSync15(driftLogPath, JSON.stringify(entries, null, 2));
     return { success: true };
   } catch (e) {
     return { success: false, error: `Could not write drift log: ${e.message}` };
@@ -7899,9 +6871,9 @@ function trimTrailingSlashes(value) {
 }
 
 // src/commands/theme-switch.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
-import { join as join30 } from "path";
-import { isV4 as isV48 } from "@decantr/essence-spec";
+import { existsSync as existsSync26, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
+import { join as join28 } from "path";
+import { isV4 as isV47 } from "@decantr/essence-spec";
 var GREEN14 = "\x1B[32m";
 var RED11 = "\x1B[31m";
 var YELLOW10 = "\x1B[33m";
@@ -7917,21 +6889,21 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join30(projectRoot, "decantr.essence.json");
-  if (!existsSync28(essencePath)) {
+  const essencePath = join28(projectRoot, "decantr.essence.json");
+  if (!existsSync26(essencePath)) {
     console.error(`${RED11}No decantr.essence.json found. Run \`decantr init\` first.${RESET14}`);
     process.exitCode = 1;
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(essencePath, "utf-8"));
+    parsed = JSON.parse(readFileSync19(essencePath, "utf-8"));
   } catch (e) {
     console.error(`${RED11}Could not read essence: ${e.message}${RESET14}`);
     process.exitCode = 1;
     return;
   }
-  if (!isV48(parsed)) {
+  if (!isV47(parsed)) {
     console.error(
       `${RED11}Active workflows require Essence v4.0.0. Run \`decantr migrate --to v4\` first.${RESET14}`
     );
@@ -7976,7 +6948,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     essence.dna.theme.mode = mode;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join30(projectRoot, ".decantr", "cache")
+    cacheDir: join28(projectRoot, ".decantr", "cache")
   });
   try {
     const themeResult = await registryClient.fetchTheme(themeName);
@@ -7991,7 +6963,7 @@ async function cmdThemeSwitch(themeName, args, projectRoot = process.cwd()) {
     }
   } catch {
   }
-  writeFileSync18(essencePath, JSON.stringify(essence, null, 2) + "\n");
+  writeFileSync16(essencePath, JSON.stringify(essence, null, 2) + "\n");
   console.log(`${GREEN14}Switched theme: ${oldThemeId} \u2192 ${themeName}${RESET14}`);
   if (shape) console.log(`  ${DIM14}Shape: ${shape}${RESET14}`);
   if (mode) console.log(`  ${DIM14}Mode: ${mode}${RESET14}`);
@@ -8299,8 +7271,8 @@ async function runSimplifiedInit(blueprints) {
 }
 
 // src/theme-commands.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readdirSync as readdirSync8, readFileSync as readFileSync22, rmSync as rmSync3, writeFileSync as writeFileSync19 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readdirSync as readdirSync7, readFileSync as readFileSync20, rmSync as rmSync3, writeFileSync as writeFileSync17 } from "fs";
+import { join as join29 } from "path";
 var REQUIRED_FIELDS = [
   "$schema",
   "id",
@@ -8360,20 +7332,20 @@ function validateCustomTheme(theme) {
   };
 }
 function createTheme(projectRoot, id, name) {
-  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
-  const themePath = join31(customThemesDir, `${id}.json`);
-  const howToPath = join31(customThemesDir, "how-to-theme.md");
-  mkdirSync16(customThemesDir, { recursive: true });
-  if (existsSync29(themePath)) {
+  const customThemesDir = join29(projectRoot, ".decantr", "custom", "themes");
+  const themePath = join29(customThemesDir, `${id}.json`);
+  const howToPath = join29(customThemesDir, "how-to-theme.md");
+  mkdirSync14(customThemesDir, { recursive: true });
+  if (existsSync27(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" already exists at ${themePath}`
     };
   }
   const skeleton = getThemeSkeleton(id, name);
-  writeFileSync19(themePath, JSON.stringify(skeleton, null, 2));
-  if (!existsSync29(howToPath)) {
-    writeFileSync19(howToPath, getHowToThemeDoc());
+  writeFileSync17(themePath, JSON.stringify(skeleton, null, 2));
+  if (!existsSync27(howToPath)) {
+    writeFileSync17(howToPath, getHowToThemeDoc());
   }
   return {
     success: true,
@@ -8381,17 +7353,17 @@ function createTheme(projectRoot, id, name) {
   };
 }
 function listCustomThemes(projectRoot) {
-  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
-  if (!existsSync29(customThemesDir)) {
+  const customThemesDir = join29(projectRoot, ".decantr", "custom", "themes");
+  if (!existsSync27(customThemesDir)) {
     return [];
   }
   const themes = [];
   try {
-    const files = readdirSync8(customThemesDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync7(customThemesDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = join31(customThemesDir, file);
+      const filePath = join29(customThemesDir, file);
       try {
-        const data = JSON.parse(readFileSync22(filePath, "utf-8"));
+        const data = JSON.parse(readFileSync20(filePath, "utf-8"));
         themes.push({
           id: data.id || file.replace(".json", ""),
           name: data.name || data.id,
@@ -8406,8 +7378,8 @@ function listCustomThemes(projectRoot) {
   return themes;
 }
 function deleteTheme(projectRoot, id) {
-  const themePath = join31(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
-  if (!existsSync29(themePath)) {
+  const themePath = join29(projectRoot, ".decantr", "custom", "themes", `${id}.json`);
+  if (!existsSync27(themePath)) {
     return {
       success: false,
       error: `Theme "${id}" not found at ${themePath}`
@@ -8424,7 +7396,7 @@ function deleteTheme(projectRoot, id) {
   }
 }
 function importTheme(projectRoot, sourcePath) {
-  if (!existsSync29(sourcePath)) {
+  if (!existsSync27(sourcePath)) {
     return {
       success: false,
       errors: [`Source file not found: ${sourcePath}`]
@@ -8432,7 +7404,7 @@ function importTheme(projectRoot, sourcePath) {
   }
   let theme;
   try {
-    theme = JSON.parse(readFileSync22(sourcePath, "utf-8"));
+    theme = JSON.parse(readFileSync20(sourcePath, "utf-8"));
   } catch (e) {
     return {
       success: false,
@@ -8448,14 +7420,14 @@ function importTheme(projectRoot, sourcePath) {
   }
   theme.source = "custom";
   const id = theme.id;
-  const customThemesDir = join31(projectRoot, ".decantr", "custom", "themes");
-  const destPath = join31(customThemesDir, `${id}.json`);
-  mkdirSync16(customThemesDir, { recursive: true });
-  const howToPath = join31(customThemesDir, "how-to-theme.md");
-  if (!existsSync29(howToPath)) {
-    writeFileSync19(howToPath, getHowToThemeDoc());
-  }
-  writeFileSync19(destPath, JSON.stringify(theme, null, 2));
+  const customThemesDir = join29(projectRoot, ".decantr", "custom", "themes");
+  const destPath = join29(customThemesDir, `${id}.json`);
+  mkdirSync14(customThemesDir, { recursive: true });
+  const howToPath = join29(customThemesDir, "how-to-theme.md");
+  if (!existsSync27(howToPath)) {
+    writeFileSync17(howToPath, getHowToThemeDoc());
+  }
+  writeFileSync17(destPath, JSON.stringify(theme, null, 2));
   return {
     success: true,
     path: destPath
@@ -9002,18 +7974,18 @@ function extractHostedAssetPaths(indexHtml) {
   return [...assetPaths];
 }
 function readHostedDistSnapshot(distPath) {
-  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join32(process.cwd(), "dist");
-  const indexPath = join32(resolvedDistPath, "index.html");
-  if (!existsSync30(indexPath)) {
+  const resolvedDistPath = distPath ? resolveUserPath(distPath) : join30(process.cwd(), "dist");
+  const indexPath = join30(resolvedDistPath, "index.html");
+  if (!existsSync28(indexPath)) {
     return void 0;
   }
-  const indexHtml = readFileSync23(indexPath, "utf-8");
+  const indexHtml = readFileSync21(indexPath, "utf-8");
   const assetPaths = extractHostedAssetPaths(indexHtml);
   const assets = {};
   for (const assetPath of assetPaths) {
-    const assetFilePath = join32(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
-    if (existsSync30(assetFilePath)) {
-      assets[assetPath] = readFileSync23(assetFilePath, "utf-8");
+    const assetFilePath = join30(resolvedDistPath, assetPath.replace(/^[/\\]+/, ""));
+    if (existsSync28(assetFilePath)) {
+      assets[assetPath] = readFileSync21(assetFilePath, "utf-8");
     }
   }
   return {
@@ -9028,7 +8000,7 @@ function isHostedSourceSnapshotFile(path) {
 function readHostedSourceSnapshot(sourcePath) {
   if (!sourcePath) return void 0;
   const resolvedSourcePath = resolveUserPath(sourcePath);
-  if (!existsSync30(resolvedSourcePath)) {
+  if (!existsSync28(resolvedSourcePath)) {
     return void 0;
   }
   const files = {};
@@ -9040,19 +8012,19 @@ function readHostedSourceSnapshot(sourcePath) {
     "build",
     "coverage"
   ]);
-  const rootPrefix = basename3(resolvedSourcePath);
+  const rootPrefix = basename2(resolvedSourcePath);
   const walk = (absoluteDir, relativeDir) => {
-    for (const entry of readdirSync9(absoluteDir, { withFileTypes: true })) {
+    for (const entry of readdirSync8(absoluteDir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join32(absoluteDir, entry.name);
-      const relativePath = join32(relativeDir, entry.name).replace(/\\/g, "/");
+      const absolutePath = join30(absoluteDir, entry.name);
+      const relativePath = join30(relativeDir, entry.name).replace(/\\/g, "/");
       if (entry.isDirectory()) {
         walk(absolutePath, relativePath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (!isHostedSourceSnapshotFile(relativePath)) continue;
-      files[relativePath] = readFileSync23(absolutePath, "utf-8");
+      files[relativePath] = readFileSync21(absolutePath, "utf-8");
     }
   };
   walk(resolvedSourcePath, rootPrefix);
@@ -9245,25 +8217,25 @@ async function printHostedExecutionPackBundle(essencePath, namespace, jsonOutput
 }
 async function compileHostedExecutionPackBundle(essencePath, namespace) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
-  if (!existsSync30(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join30(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync23(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedPath, "utf-8"));
   const bundle = await client.compileExecutionPacks(essence, namespace ? { namespace } : void 0);
-  const contextDir = join32(dirname6(resolvedPath), ".decantr", "context");
+  const contextDir = join30(dirname6(resolvedPath), ".decantr", "context");
   return { resolvedPath, bundle, contextDir };
 }
 function writeHostedExecutionPackContextArtifacts(contextDir, bundle) {
-  mkdirSync17(contextDir, { recursive: true });
+  mkdirSync15(contextDir, { recursive: true });
   return writeExecutionPackBundleArtifacts(contextDir, bundle);
 }
 function resolvePagePackIdForRoute(essencePath, route) {
-  if (!existsSync30(essencePath)) {
+  if (!existsSync28(essencePath)) {
     throw new Error(`Essence file not found at ${essencePath}`);
   }
-  const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
-  if (!isV49(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];
@@ -9277,14 +8249,14 @@ function resolvePagePackIdForRoute(essencePath, route) {
 }
 async function printHostedSelectedExecutionPack(packType, id, essencePath, namespace, jsonOutput = false, writeContext = false) {
   const client = getPublicAPIClient();
-  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
-  if (!existsSync30(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join30(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(readFileSync23(resolvedPath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedPath, "utf-8"));
   const selected = await client.selectExecutionPack(
     {
       essence,
@@ -9295,17 +8267,17 @@ async function printHostedSelectedExecutionPack(packType, id, essencePath, names
   );
   let writtenContextDir = null;
   if (writeContext) {
-    const contextDir = join32(dirname6(resolvedPath), ".decantr", "context");
-    mkdirSync17(contextDir, { recursive: true });
-    writeFileSync20(
-      join32(contextDir, "pack-manifest.json"),
+    const contextDir = join30(dirname6(resolvedPath), ".decantr", "context");
+    mkdirSync15(contextDir, { recursive: true });
+    writeFileSync18(
+      join30(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`;
-    writeFileSync20(join32(contextDir, markdownFile), selected.pack.renderedMarkdown);
-    writeFileSync20(join32(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
+    writeFileSync18(join30(contextDir, markdownFile), selected.pack.renderedMarkdown);
+    writeFileSync18(join30(contextDir, jsonFile), JSON.stringify(selected.pack, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -9330,20 +8302,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) : join32(process.cwd(), "decantr.essence.json");
-  if (!existsSync30(resolvedPath)) {
+  const resolvedPath = essencePath ? resolveUserPath(essencePath) : join30(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedPath)) {
     throw new Error(`Essence file not found at ${resolvedPath}`);
   }
-  const essence = JSON.parse(readFileSync23(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 = join32(dirname6(resolvedPath), ".decantr", "context");
-    mkdirSync17(contextDir, { recursive: true });
-    writeFileSync20(join32(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const contextDir = join30(dirname6(resolvedPath), ".decantr", "context");
+    mkdirSync15(contextDir, { recursive: true });
+    writeFileSync18(join30(contextDir, "pack-manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
     writtenContextDir = contextDir;
   }
   if (jsonOutput) {
@@ -9364,14 +8336,14 @@ async function printHostedExecutionPackManifest(essencePath, namespace, jsonOutp
   }
 }
 async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join32(projectRoot, ".decantr", "context");
-  const reviewPackPath = join32(contextDir, "review-pack.json");
-  const manifestPath = join32(contextDir, "pack-manifest.json");
-  if (existsSync30(reviewPackPath) && existsSync30(manifestPath)) {
+  const contextDir = join30(projectRoot, ".decantr", "context");
+  const reviewPackPath = join30(contextDir, "review-pack.json");
+  const manifestPath = join30(contextDir, "pack-manifest.json");
+  if (existsSync28(reviewPackPath) && existsSync28(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join32(projectRoot, "decantr.essence.json");
-  if (!existsSync30(essencePath)) {
+  const essencePath = join30(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   const reviewHydration = await hydrateHostedReviewPackIfMissing(projectRoot, namespace);
@@ -9380,9 +8352,9 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const bundle = await client.compileExecutionPacks(essence, { namespace });
-    mkdirSync17(contextDir, { recursive: true });
+    mkdirSync15(contextDir, { recursive: true });
     writeExecutionPackBundleArtifacts(contextDir, bundle);
     return { attempted: true, hydrated: true, scope: "bundle" };
   } catch {
@@ -9390,19 +8362,19 @@ async function hydrateHostedExecutionPacksIfMissing(projectRoot, namespace = "@o
   }
 }
 async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@official") {
-  const contextDir = join32(projectRoot, ".decantr", "context");
-  const reviewPackPath = join32(contextDir, "review-pack.json");
-  const manifestPath = join32(contextDir, "pack-manifest.json");
-  if (existsSync30(reviewPackPath) && existsSync30(manifestPath)) {
+  const contextDir = join30(projectRoot, ".decantr", "context");
+  const reviewPackPath = join30(contextDir, "review-pack.json");
+  const manifestPath = join30(contextDir, "pack-manifest.json");
+  if (existsSync28(reviewPackPath) && existsSync28(manifestPath)) {
     return { attempted: false, hydrated: false };
   }
-  const essencePath = join32(projectRoot, "decantr.essence.json");
-  if (!existsSync30(essencePath)) {
+  const essencePath = join30(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) {
     return { attempted: false, hydrated: false };
   }
   try {
     const client = getPublicAPIClient();
-    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const selected = await client.selectExecutionPack(
       {
         essence,
@@ -9410,14 +8382,14 @@ async function hydrateHostedReviewPackIfMissing(projectRoot, namespace = "@offic
       },
       { namespace }
     );
-    mkdirSync17(contextDir, { recursive: true });
-    writeFileSync20(join32(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
-    writeFileSync20(
-      join32(contextDir, "review-pack.json"),
+    mkdirSync15(contextDir, { recursive: true });
+    writeFileSync18(join30(contextDir, "review-pack.md"), selected.pack.renderedMarkdown);
+    writeFileSync18(
+      join30(contextDir, "review-pack.json"),
       JSON.stringify(selected.pack, null, 2) + "\n"
     );
-    if (!existsSync30(manifestPath)) {
-      writeFileSync20(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
+    if (!existsSync28(manifestPath)) {
+      writeFileSync18(manifestPath, JSON.stringify(selected.manifest, null, 2) + "\n");
     }
     return { attempted: true, hydrated: true, scope: "review" };
   } catch {
@@ -9427,17 +8399,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) : join32(process.cwd(), "decantr.essence.json");
-  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join32(process.cwd(), "src", "styles", "treatments.css");
-  if (!existsSync30(resolvedSourcePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join30(process.cwd(), "decantr.essence.json");
+  const resolvedTreatmentsPath = treatmentsPath ? resolveUserPath(treatmentsPath) : join30(process.cwd(), "src", "styles", "treatments.css");
+  if (!existsSync28(resolvedSourcePath)) {
     throw new Error(`Source file not found at ${resolvedSourcePath}`);
   }
-  if (!existsSync30(resolvedEssencePath)) {
+  if (!existsSync28(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const code = readFileSync23(resolvedSourcePath, "utf-8");
-  const essence = JSON.parse(readFileSync23(resolvedEssencePath, "utf-8"));
-  const treatmentsCss = existsSync30(resolvedTreatmentsPath) ? readFileSync23(resolvedTreatmentsPath, "utf-8") : void 0;
+  const 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,
@@ -9461,11 +8433,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) : join32(process.cwd(), "decantr.essence.json");
-  if (!existsSync30(resolvedEssencePath)) {
+  const resolvedEssencePath = essencePath ? resolveUserPath(essencePath) : join30(process.cwd(), "decantr.essence.json");
+  if (!existsSync28(resolvedEssencePath)) {
     throw new Error(`Essence file not found at ${resolvedEssencePath}`);
   }
-  const essence = JSON.parse(readFileSync23(resolvedEssencePath, "utf-8"));
+  const essence = JSON.parse(readFileSync21(resolvedEssencePath, "utf-8"));
   const dist = readHostedDistSnapshot(distPath);
   const sources = readHostedSourceSnapshot(sourcesPath);
   const report = await client.auditProject(
@@ -9483,7 +8455,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) : join32(process.cwd(), "dist") : "none"}`
+    `  Dist snapshot: ${dist ? distPath ? resolveUserPath(distPath) : join30(process.cwd(), "dist") : "none"}`
   );
   console.log(
     `  Source snapshot: ${sources && sourcesPath ? resolveUserPath(sourcesPath) : "none"}`
@@ -9605,21 +8577,21 @@ function findPatternCandidateBySlug(candidates, slug) {
 function readSuggestCodeContext(projectRoot, route, file) {
   const pieces = [];
   if (file) {
-    const resolved = isAbsolute3(file) ? file : join32(projectRoot, file);
-    if (existsSync30(resolved)) {
-      pieces.push(readFileSync23(resolved, "utf-8"));
+    const resolved = isAbsolute3(file) ? file : join30(projectRoot, file);
+    if (existsSync28(resolved)) {
+      pieces.push(readFileSync21(resolved, "utf-8"));
     }
   }
   if (route) {
-    const analysisPath = join32(projectRoot, ".decantr", "analysis.json");
-    if (existsSync30(analysisPath)) {
+    const analysisPath = join30(projectRoot, ".decantr", "analysis.json");
+    if (existsSync28(analysisPath)) {
       try {
-        const analysis = JSON.parse(readFileSync23(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 = join32(projectRoot, routeEntry.file);
-          if (existsSync30(resolved)) {
-            pieces.push(readFileSync23(resolved, "utf-8"));
+          const resolved = join30(projectRoot, routeEntry.file);
+          if (existsSync28(resolved)) {
+            pieces.push(readFileSync21(resolved, "utf-8"));
           }
         }
       } catch {
@@ -9703,7 +8675,7 @@ async function cmdSuggest(query, options = {}) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join32(projectRoot, ".decantr", "cache")
+    cacheDir: join30(projectRoot, ".decantr", "cache")
   });
   const code = options.fromCode || options.file ? readSuggestCodeContext(projectRoot, options.route, options.file) : "";
   const localMatches = localPatternMatches(projectRoot, [query, code].filter(Boolean).join("\n"));
@@ -9790,7 +8762,7 @@ async function cmdGet(type, id) {
   }
   const apiType = CONTENT_TYPE_TO_API_CONTENT_TYPE3[type];
   const registryClient = new RegistryClient({
-    cacheDir: join32(process.cwd(), ".decantr", "cache")
+    cacheDir: join30(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentItem(apiType, id);
   if (result) {
@@ -9807,10 +8779,10 @@ async function cmdGet(type, id) {
   return;
 }
 async function cmdValidate(path) {
-  const essencePath = path || join32(process.cwd(), "decantr.essence.json");
+  const essencePath = path || join30(process.cwd(), "decantr.essence.json");
   let raw;
   try {
-    raw = readFileSync23(essencePath, "utf-8");
+    raw = readFileSync21(essencePath, "utf-8");
   } catch {
     console.error(error2(`Could not read ${essencePath}`));
     process.exitCode = 1;
@@ -9824,7 +8796,7 @@ async function cmdValidate(path) {
     process.exitCode = 1;
     return;
   }
-  const detectedVersion = isV49(essence) ? "v4" : "legacy";
+  const detectedVersion = isV48(essence) ? "v4" : "legacy";
   console.log(`${DIM16}Detected essence version: ${detectedVersion}${RESET16}`);
   const result = validateEssence2(essence);
   if (result.valid) {
@@ -9877,7 +8849,7 @@ async function cmdList(type, sort, recommended, intelligenceSource, blueprintSet
     return;
   }
   const registryClient = new RegistryClient({
-    cacheDir: join32(process.cwd(), ".decantr", "cache")
+    cacheDir: join30(process.cwd(), ".decantr", "cache")
   });
   const result = await registryClient.fetchContentList(
     type,
@@ -9960,10 +8932,10 @@ ${CYAN9}Telemetry enabled.${RESET16} Decantr will send privacy-filtered CLI prod
 }
 function readCliPackageVersion2() {
   const here = dirname6(fileURLToPath3(import.meta.url));
-  const candidates = [join32(here, "..", "package.json"), join32(here, "..", "..", "package.json")];
+  const candidates = [join30(here, "..", "package.json"), join30(here, "..", "..", "package.json")];
   for (const candidate of candidates) {
     try {
-      const pkg = JSON.parse(readFileSync23(candidate, "utf-8"));
+      const pkg = JSON.parse(readFileSync21(candidate, "utf-8"));
       if (pkg.version) return pkg.version;
     } catch {
     }
@@ -9974,19 +8946,19 @@ function timestampForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function backupExistingEssence(projectRoot, label) {
-  const essencePath = join32(projectRoot, "decantr.essence.json");
-  if (!existsSync30(essencePath)) return null;
-  const backupPath = join32(
+  const essencePath = join30(projectRoot, "decantr.essence.json");
+  if (!existsSync28(essencePath)) return null;
+  const backupPath = join30(
     projectRoot,
     `decantr.essence.${label}.${timestampForFile()}.backup.json`
   );
-  writeFileSync20(backupPath, readFileSync23(essencePath, "utf-8"), "utf-8");
+  writeFileSync18(backupPath, readFileSync21(essencePath, "utf-8"), "utf-8");
   return backupPath;
 }
 function writeBrownfieldProjectJson(input) {
-  const decantrDir = join32(input.projectRoot, ".decantr");
-  mkdirSync17(join32(decantrDir, "context"), { recursive: true });
-  mkdirSync17(join32(decantrDir, "cache"), { recursive: true });
+  const decantrDir = join30(input.projectRoot, ".decantr");
+  mkdirSync15(join30(decantrDir, "context"), { recursive: true });
+  mkdirSync15(join30(decantrDir, "cache"), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const projectJson = {
     detected: {
@@ -10027,7 +8999,7 @@ function writeBrownfieldProjectJson(input) {
       }
     }
   };
-  writeFileSync20(join32(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
+  writeFileSync18(join30(decantrDir, "project.json"), JSON.stringify(projectJson, null, 2) + "\n");
 }
 async function applyAcceptedBrownfieldProposal(input) {
   const proposal = readBrownfieldProposal(input.projectRoot);
@@ -10043,8 +9015,8 @@ async function applyAcceptedBrownfieldProposal(input) {
     process.exitCode = 1;
     return;
   }
-  const essencePath = join32(input.projectRoot, "decantr.essence.json");
-  const hasEssence = existsSync30(essencePath);
+  const essencePath = join30(input.projectRoot, "decantr.essence.json");
+  const hasEssence = existsSync28(essencePath);
   let essence;
   let backupPath = null;
   if (input.mode === "accept" && hasEssence) {
@@ -10058,8 +9030,8 @@ async function applyAcceptedBrownfieldProposal(input) {
     return;
   }
   if (input.mode === "merge" && hasEssence) {
-    const existing = JSON.parse(readFileSync23(essencePath, "utf-8"));
-    if (!isV49(existing)) {
+    const existing = JSON.parse(readFileSync21(essencePath, "utf-8"));
+    if (!isV48(existing)) {
       console.log(
         error2(
           "Existing essence is not v4. Run `decantr migrate --to v4` before merging a brownfield proposal."
@@ -10095,9 +9067,9 @@ async function applyAcceptedBrownfieldProposal(input) {
     assistantBridge: input.assistantBridge,
     mode: input.mode
   });
-  writeFileSync20(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
+  writeFileSync18(essencePath, JSON.stringify(essence, null, 2) + "\n", "utf-8");
   const registryClient = new RegistryClient({
-    cacheDir: join32(input.projectRoot, ".decantr", "cache"),
+    cacheDir: join30(input.projectRoot, ".decantr", "cache"),
     offline: true,
     projectRoot: input.projectRoot
   });
@@ -10124,7 +9096,7 @@ async function applyAcceptedBrownfieldProposal(input) {
   }
   const appliedRuleFiles = input.assistantBridge === "apply" ? applyAssistantBridge(input.projectRoot, input.detected) : [];
   console.log(success3("\nBrownfield proposal accepted.\n"));
-  const projectLabel = input.workspaceInfo.appRoot !== input.workspaceInfo.workspaceRoot ? relative7(input.workspaceInfo.workspaceRoot, input.workspaceInfo.appRoot).replace(/\\/g, "/") : void 0;
+  const projectLabel = input.workspaceInfo.appRoot !== input.workspaceInfo.workspaceRoot ? relative6(input.workspaceInfo.workspaceRoot, input.workspaceInfo.appRoot).replace(/\\/g, "/") : void 0;
   console.log("  Files created/updated:");
   console.log(
     `    ${cyan3(displayProjectPath(input.workspaceInfo, "decantr.essence.json"))}    Observed brownfield contract`
@@ -10276,7 +9248,7 @@ async function cmdInit(args) {
     }
   }
   const registryClient = new RegistryClient({
-    cacheDir: join32(projectRoot, ".decantr", "cache"),
+    cacheDir: join30(projectRoot, ".decantr", "cache"),
     apiUrl: args.registry,
     offline: args.offline,
     projectRoot
@@ -10608,7 +9580,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
   if (appliedRuleFiles.length > 0) {
     console.log(`    ${dim3(`Rule bridge applied: ${appliedRuleFiles.join(", ")}`)}`);
   }
-  if (!existsSync30(join32(projectRoot, "package.json"))) {
+  if (!existsSync28(join30(projectRoot, "package.json"))) {
     console.log("");
     console.log(
       dim3(`  Note: ${cyan3("decantr init")} created Decantr contract/context files only.`)
@@ -10619,7 +9591,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
       )
     );
   }
-  const hasCompiledPacks = existsSync30(join32(projectRoot, ".decantr", "context", "scaffold-pack.md"));
+  const hasCompiledPacks = existsSync28(join30(projectRoot, ".decantr", "context", "scaffold-pack.md"));
   console.log("");
   console.log("  Next steps:");
   if (hasCompiledPacks) {
@@ -10659,7 +9631,7 @@ ${YELLOW12}You're offline. Scaffolding Decantr default.${RESET16}`);
   console.log(`    ${cyan3("decantr upgrade")}    Update to latest patterns`);
   console.log(`    ${cyan3("decantr check")}      Detect drift issues`);
   console.log(`    ${cyan3("decantr migrate --to v4")} Migrate older essence files to v4`);
-  const essenceContent = readFileSync23(result.essencePath, "utf-8");
+  const essenceContent = readFileSync21(result.essencePath, "utf-8");
   const essence = JSON.parse(essenceContent);
   const validation = validateEssence2(essence);
   if (!validation.valid) {
@@ -10668,7 +9640,7 @@ Validation warnings: ${validation.errors.join(", ")}`));
   }
   console.log("");
   let promptPages;
-  if (isV49(essence)) {
+  if (isV48(essence)) {
     const allPages = essence.blueprint.sections.flatMap(
       (s) => s.pages.map((p) => ({ ...p, _sectionId: s.id, _shell: s.shell }))
     );
@@ -10714,25 +9686,25 @@ Validation warnings: ${validation.errors.join(", ")}`));
   }
 }
 async function cmdStatus(projectRoot = process.cwd()) {
-  const essencePath = join32(projectRoot, "decantr.essence.json");
-  const projectJsonPath = join32(projectRoot, ".decantr", "project.json");
+  const essencePath = join30(projectRoot, "decantr.essence.json");
+  const projectJsonPath = join30(projectRoot, ".decantr", "project.json");
   console.log(heading2("Decantr Project Status"));
-  if (!existsSync30(essencePath)) {
+  if (!existsSync28(essencePath)) {
     console.log(`${RED12}No decantr.essence.json found.${RESET16}`);
     console.log(dim3('Run "decantr init" to create one.'));
     return;
   }
   try {
-    const essence = JSON.parse(readFileSync23(essencePath, "utf-8"));
+    const essence = JSON.parse(readFileSync21(essencePath, "utf-8"));
     const validation = validateEssence2(essence);
-    const essenceVersion = isV49(essence) ? "v4" : "legacy";
+    const essenceVersion = isV48(essence) ? "v4" : "legacy";
     console.log(`${BOLD9}Essence:${RESET16}`);
     if (validation.valid) {
       console.log(`  ${GREEN16}Valid${RESET16} (${essenceVersion})`);
     } else {
       console.log(`  ${RED12}Invalid: ${validation.errors.join(", ")}${RESET16}`);
     }
-    if (isV49(essence)) {
+    if (isV48(essence)) {
       const v4 = essence;
       const sections = v4.blueprint.sections;
       const flatPages = sections.flatMap((section) => section.pages ?? []);
@@ -10771,9 +9743,9 @@ async function cmdStatus(projectRoot = process.cwd()) {
   }
   console.log("");
   console.log(`${BOLD9}Sync Status:${RESET16}`);
-  if (existsSync30(projectJsonPath)) {
+  if (existsSync28(projectJsonPath)) {
     try {
-      const projectJson = JSON.parse(readFileSync23(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";
@@ -10791,7 +9763,7 @@ async function cmdStatus(projectRoot = process.cwd()) {
 }
 async function cmdSync() {
   const projectRoot = process.cwd();
-  const cacheDir = join32(projectRoot, ".decantr", "cache");
+  const cacheDir = join30(projectRoot, ".decantr", "cache");
   console.log(heading2("Syncing registry content..."));
   const result = await syncRegistry(cacheDir);
   if (result.synced.length > 0) {
@@ -10985,14 +9957,14 @@ ${BOLD9}Examples:${RESET16}
         process.exitCode = 1;
         return;
       }
-      const themePath = join32(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
-      if (!existsSync30(themePath)) {
+      const themePath = join30(projectRoot, ".decantr", "custom", "themes", `${name}.json`);
+      if (!existsSync28(themePath)) {
         console.error(error2(`Theme "${name}" not found at ${themePath}`));
         process.exitCode = 1;
         return;
       }
       try {
-        const theme = JSON.parse(readFileSync23(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`));
@@ -11124,13 +10096,42 @@ function withProject(command, projectArg) {
   return projectArg ? `${command} --project ${projectArg}` : command;
 }
 function displayProjectPath(workspaceInfo, projectPath) {
-  const absolutePath = join32(workspaceInfo.appRoot, projectPath);
-  const relativePath = relative7(workspaceInfo.cwd, absolutePath).replace(/\\/g, "/");
+  const absolutePath = join30(workspaceInfo.appRoot, projectPath);
+  const relativePath = relative6(workspaceInfo.cwd, absolutePath).replace(/\\/g, "/");
   if (relativePath && !relativePath.startsWith("..") && !isAbsolute3(relativePath)) {
     return relativePath;
   }
   return absolutePath;
 }
+function projectRelativeGraphPath(projectRoot, filePath) {
+  const relativePath = relative6(projectRoot, isAbsolute3(filePath) ? filePath : resolve4(filePath));
+  if (relativePath && !relativePath.startsWith("..") && !isAbsolute3(relativePath)) {
+    return relativePath.replace(/\\/g, "/");
+  }
+  return null;
+}
+function graphSourceNodeIdForTaskFile(projectRoot, snapshot, filePath) {
+  const trimmed = filePath.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("src:") && snapshot.nodes.some((node) => node.id === trimmed)) {
+    return trimmed;
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(trimmed.replace(/\\/g, "/").replace(/^\.\//, ""));
+  const cwdRelative = projectRelativeGraphPath(projectRoot, trimmed);
+  if (cwdRelative) candidates.add(cwdRelative);
+  const projectRelative = projectRelativeGraphPath(projectRoot, join30(projectRoot, trimmed));
+  if (projectRelative) candidates.add(projectRelative);
+  for (const candidate of candidates) {
+    const nodeId = `src:${candidate}`;
+    if (snapshot.nodes.some((node) => node.id === nodeId)) return nodeId;
+  }
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "SourceArtifact") return false;
+    const path = graphPayloadString(node.payload, "path");
+    return Boolean(path && (path === trimmed || candidates.has(path)));
+  })?.id ?? null;
+}
 function stripProjectArgs(args, startIndex = 1) {
   const stripped = [args[0]];
   for (let index = startIndex; index < args.length; index += 1) {
@@ -11193,7 +10194,7 @@ function printWorkspaceProjectSelection(workspaceInfo, commandName = "command")
 function printMonorepoSetupGuidance(workspaceInfo) {
   const candidate = firstWorkspaceCandidate(workspaceInfo);
   const attachedProjects = workspaceInfo.appCandidates.filter(
-    (appCandidate) => existsSync30(join32(workspaceInfo.workspaceRoot, appCandidate, "decantr.essence.json"))
+    (appCandidate) => existsSync28(join30(workspaceInfo.workspaceRoot, appCandidate, "decantr.essence.json"))
   );
   const firstAttached = attachedProjects[0];
   console.log(heading2("Decantr Setup"));
@@ -11261,7 +10262,7 @@ function printMonorepoSetupGuidance(workspaceInfo) {
 function resolveWorkflowProject(flags, commandName = "command", options = {}) {
   const projectArg = flagString(flags, "project");
   const workspaceInfo = resolveWorkspaceInfo(process.cwd(), projectArg);
-  if (projectArg && options.requireExisting !== false && !existsSync30(workspaceInfo.appRoot)) {
+  if (projectArg && options.requireExisting !== false && !existsSync28(workspaceInfo.appRoot)) {
     printProjectNotFound(projectArg, commandName);
     process.exitCode = 1;
     return null;
@@ -11269,7 +10270,7 @@ function resolveWorkflowProject(flags, commandName = "command", options = {}) {
   if (projectArg && options.requireAppCandidate && workspaceInfo.appCandidates.length > 0) {
     const normalizedProject = normalizedProjectPath(projectArg);
     const normalizedWorkspaceProject = normalizedProjectPath(
-      relative7(workspaceInfo.workspaceRoot, workspaceInfo.appRoot)
+      relative6(workspaceInfo.workspaceRoot, workspaceInfo.appRoot)
     );
     const knownCandidate = normalizedProject ? workspaceInfo.appCandidates.includes(normalizedProject) || Boolean(
       normalizedWorkspaceProject && workspaceInfo.appCandidates.includes(normalizedWorkspaceProject)
@@ -11318,6 +10319,129 @@ function formatScanApplicability(status) {
   if (status === "not_applicable") return dim3("not applicable");
   return dim3("unknown");
 }
+function formatScanGraphPreviewStatus(status) {
+  if (status === "current") return success3("current");
+  if (status === "stale") return `${YELLOW12}stale or missing${RESET16}`;
+  if (status === "needs_migration") return `${YELLOW12}needs migration${RESET16}`;
+  if (status === "not_attached") return dim3("not attached");
+  return dim3("unavailable");
+}
+function relativeGraphArtifactPath(projectRoot, artifactPath) {
+  return relative6(projectRoot, artifactPath).replace(/\\/g, "/");
+}
+function buildScanGraphPreview(workspaceInfo, projectArg) {
+  let artifacts;
+  try {
+    artifacts = buildGraphArtifacts(workspaceInfo.appRoot);
+  } catch (error3) {
+    const message = error3.message;
+    const needsMigration = message.includes("Essence v4");
+    return {
+      status: needsMigration ? "needs_migration" : "unavailable",
+      canPreview: false,
+      readOnly: true,
+      message: needsMigration ? "Existing Decantr contract needs Essence v4 before a typed Contract graph can be previewed." : message,
+      nextCommand: needsMigration ? withProject("decantr migrate --to v4", projectArg) : null,
+      staleArtifacts: [],
+      snapshot: null,
+      capsule: null,
+      diff: null
+    };
+  }
+  if (!artifacts) {
+    return {
+      status: "not_attached",
+      canPreview: false,
+      readOnly: true,
+      message: "No decantr.essence.json found. Adopt the project to create the first typed Contract graph baseline.",
+      nextCommand: withProject("decantr adopt --yes", projectArg),
+      staleArtifacts: [],
+      snapshot: null,
+      capsule: null,
+      diff: null
+    };
+  }
+  const stale = artifacts.staleArtifacts.length > 0;
+  const diffSummary = summarizeGraphDiff(artifacts.diff);
+  return {
+    status: stale ? "stale" : "current",
+    canPreview: true,
+    readOnly: true,
+    message: stale ? "A typed Contract graph can be derived now, but saved graph artifacts are missing or stale." : "Typed Contract graph artifacts are current with the project-owned contract sources.",
+    nextCommand: stale ? withProject("decantr graph", projectArg) : null,
+    staleArtifacts: artifacts.staleArtifacts.map(
+      (path) => displayProjectPath(workspaceInfo, relativeGraphArtifactPath(artifacts.projectRoot, path))
+    ),
+    snapshot: {
+      id: artifacts.snapshot.id,
+      schemaVersion: artifacts.snapshot.schema_version,
+      sourceHash: artifacts.snapshot.source_hash,
+      nodes: artifacts.snapshot.summary.nodes,
+      edges: artifacts.snapshot.summary.edges,
+      findings: artifacts.snapshot.summary.findings,
+      evidence: artifacts.snapshot.summary.evidence,
+      sourceArtifacts: artifacts.snapshot.nodes.filter((node) => node.type === "SourceArtifact").length
+    },
+    capsule: {
+      cacheKey: artifacts.capsule.cache_key,
+      routes: artifacts.capsule.summary.routes,
+      components: artifacts.capsule.summary.components,
+      tokens: artifacts.capsule.summary.tokens,
+      localRules: artifacts.capsule.summary.local_rules,
+      styleBridge: artifacts.capsule.summary.style_bridge,
+      sourceArtifacts: artifacts.capsule.summary.source_artifacts,
+      sourceArtifactLimit: artifacts.capsule.source_artifact_limit,
+      sourceArtifactsTruncated: artifacts.capsule.source_artifacts_truncated,
+      openFindings: artifacts.capsule.summary.open_findings
+    },
+    diff: {
+      ops: diffSummary.total,
+      findingsAdded: diffSummary.findings.added,
+      findingsResolved: diffSummary.findings.resolved,
+      evidenceAdded: diffSummary.evidence.added
+    }
+  };
+}
+function printScanGraphPreview(preview) {
+  if (!preview) return;
+  console.log(`${BOLD9}Typed Contract Graph${RESET16}`);
+  console.log(`  Status:         ${formatScanGraphPreviewStatus(preview.status)}`);
+  console.log(`  Read-only:      ${preview.readOnly ? "yes" : "no"}`);
+  if (preview.snapshot && preview.capsule) {
+    console.log(
+      `  Snapshot:       ${preview.snapshot.nodes} nodes, ${preview.snapshot.edges} edges`
+    );
+    console.log(
+      `  Evidence:       ${preview.snapshot.findings} finding nodes, ${preview.snapshot.evidence} evidence nodes, ${preview.snapshot.sourceArtifacts} sources`
+    );
+    console.log(
+      `  Capsule:        ${preview.capsule.routes} routes, ${preview.capsule.localRules} local rules, ${preview.capsule.styleBridge} style bridge mappings`
+    );
+    const sourceArtifactIndex = preview.capsule.sourceArtifactsTruncated ? `${preview.capsule.sourceArtifactLimit}/${preview.capsule.sourceArtifacts} source handles` : `${preview.capsule.sourceArtifacts} source handles`;
+    console.log(`  Source handles: ${sourceArtifactIndex}`);
+    if (preview.diff) {
+      const diffHints = [
+        preview.diff.findingsAdded > 0 ? `${preview.diff.findingsAdded} finding added` : null,
+        preview.diff.findingsResolved > 0 ? `${preview.diff.findingsResolved} finding resolved` : null,
+        preview.diff.evidenceAdded > 0 ? `${preview.diff.evidenceAdded} evidence added` : null
+      ].filter(Boolean);
+      console.log(
+        `  Diff:           ${preview.diff.ops} ops${diffHints.length > 0 ? ` (${diffHints.join(", ")})` : ""}`
+      );
+    }
+  }
+  console.log(`  ${dim3(preview.message)}`);
+  if (preview.staleArtifacts.length > 0) {
+    console.log(`  Stale artifacts:${" "} ${preview.staleArtifacts.slice(0, 3).join(", ")}`);
+    if (preview.staleArtifacts.length > 3) {
+      console.log(`                  ${dim3(`...${preview.staleArtifacts.length - 3} more`)}`);
+    }
+  }
+  if (preview.nextCommand) {
+    console.log(`  Next:           ${cyan3(preview.nextCommand)}`);
+  }
+  console.log("");
+}
 function printScanReport(report) {
   console.log(heading2("Decantr Scan"));
   console.log(dim3("Read-only Brownfield reconnaissance. No files were written."));
@@ -11338,6 +10462,7 @@ function printScanReport(report) {
   console.log(`  TypeScript:     ${report.project.hasTypeScript ? "yes" : "no"}`);
   console.log(`  Decantr:        ${report.project.hasDecantr ? "present" : "not attached"}`);
   console.log("");
+  printScanGraphPreview(report.graphPreview);
   console.log(`${BOLD9}Routes And Styling${RESET16}`);
   console.log(`  Routes:         ${report.routes.count} (${report.routes.strategy})`);
   for (const route of report.routes.items.slice(0, 8)) {
@@ -11395,11 +10520,13 @@ async function cmdScanWorkflow(args) {
   const report = await scanProjectReadOnly(workspaceInfo.appRoot, {
     input: { kind: "local", value: inputValue }
   });
+  const graphPreview = buildScanGraphPreview(workspaceInfo, projectArg);
+  const reportWithGraph = { ...report, graphPreview };
   if (jsonOutput) {
-    console.log(JSON.stringify(report, null, 2));
+    console.log(JSON.stringify(reportWithGraph, null, 2));
     return;
   }
-  printScanReport(report);
+  printScanReport(reportWithGraph);
 }
 async function cmdSetupWorkflow(args) {
   const { flags } = parseLooseArgs(args);
@@ -11421,9 +10548,9 @@ async function cmdSetupWorkflow(args) {
   console.log(`  Detected: ${formatDetection(detected)}`);
   console.log("");
   if (detected.existingEssence) {
-    const hasLocalPatterns = existsSync30(localPatternsPath(workspaceInfo.appRoot));
-    const hasLocalRules = existsSync30(localRulesPath(workspaceInfo.appRoot));
-    const hasStyleBridge = existsSync30(styleBridgePath(workspaceInfo.appRoot));
+    const hasLocalPatterns = existsSync28(localPatternsPath(workspaceInfo.appRoot));
+    const hasLocalRules = existsSync28(localRulesPath(workspaceInfo.appRoot));
+    const hasStyleBridge = existsSync28(styleBridgePath(workspaceInfo.appRoot));
     const verifyCommand = hasLocalPatterns || hasLocalRules ? "decantr verify --brownfield --local-patterns" : "decantr verify --brownfield";
     console.log(`${BOLD9}Recommended path:${RESET16} maintain an attached Decantr project`);
     console.log(
@@ -11509,7 +10636,7 @@ async function cmdAdoptWorkflow(args) {
   const hydratePacks = flagBoolean(flags, "packs", true) && !flagBoolean(flags, "skip-packs") && !flagBoolean(flags, "offline") && process.env.DECANTR_OFFLINE !== "true";
   const initCi = flagBoolean(flags, "ci") || flagBoolean(flags, "init-ci");
   const assistantBridge = flagString(flags, "assistant-bridge");
-  const hasEssence = existsSync30(join32(projectRoot, "decantr.essence.json"));
+  const hasEssence = existsSync28(join30(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",
@@ -11518,6 +10645,7 @@ async function cmdAdoptWorkflow(args) {
   if (hydratePacks) {
     steps.push("hydrate hosted execution packs into the app context");
   }
+  steps.push("write typed Contract graph baseline");
   if (runVerify) {
     steps.push(
       runBrowser ? "verify with Project Health, browser evidence, visual manifest, and baseline" : "verify with Project Health and baseline"
@@ -11557,7 +10685,7 @@ async function cmdAdoptWorkflow(args) {
   if (hydratePacks) {
     try {
       const { bundle, contextDir } = await compileHostedExecutionPackBundle(
-        join32(projectRoot, "decantr.essence.json")
+        join30(projectRoot, "decantr.essence.json")
       );
       const written = writeHostedExecutionPackContextArtifacts(
         contextDir,
@@ -11579,8 +10707,10 @@ async function cmdAdoptWorkflow(args) {
   } else if (flagBoolean(flags, "offline") || process.env.DECANTR_OFFLINE === "true") {
     console.log(dim3("Skipping hosted pack hydration in offline mode."));
   }
+  await cmdGraph(projectRoot, { displayRoot: process.cwd() });
+  if (process.exitCode && process.exitCode !== 0) return;
   if (runVerify) {
-    const { cmdHealth } = await import("./health-B4W7UJBZ.js");
+    const { cmdHealth } = await import("./health-ASR7RWZJ.js");
     await cmdHealth(projectRoot, {
       browser: runBrowser,
       browserBaseUrl: baseUrl,
@@ -11651,7 +10781,7 @@ async function cmdVerifyWorkflow(args) {
     return;
   }
   if (workspaceMode) {
-    const { cmdWorkspace } = await import("./workspace-7RU77ZZW.js");
+    const { cmdWorkspace } = await import("./workspace-2FFQEEQQ.js");
     await cmdWorkspace(process.cwd(), ["workspace", "health", ...withoutWorkflowOnlyFlags(args)]);
     return;
   }
@@ -11694,7 +10824,7 @@ async function cmdVerifyWorkflow(args) {
       process.exitCode = void 0;
     }
   }
-  const { cmdHealth, parseHealthArgs } = await import("./health-B4W7UJBZ.js");
+  const { cmdHealth, parseHealthArgs } = await import("./health-ASR7RWZJ.js");
   await cmdHealth(workspaceInfo.appRoot, parseHealthArgs(healthArgs));
   if (localPatterns) {
     const validation = validateLocalLaw(workspaceInfo.appRoot);
@@ -11763,9 +10893,9 @@ async function cmdVerifyWorkflow(args) {
   }
 }
 function readJsonIfPresent(path) {
-  if (!existsSync30(path)) return null;
+  if (!existsSync28(path)) return null;
   try {
-    return JSON.parse(readFileSync23(path, "utf-8"));
+    return JSON.parse(readFileSync21(path, "utf-8"));
   } catch {
     return null;
   }
@@ -11863,7 +10993,7 @@ async function cmdTaskWorkflow(args) {
   }
   const route = routeInput.startsWith("/") ? routeInput : `/${routeInput}`;
   const taskSummary = positional.slice(1).join(" ").trim();
-  const essencePath = join32(workspaceInfo.appRoot, "decantr.essence.json");
+  const essencePath = join30(workspaceInfo.appRoot, "decantr.essence.json");
   const essence = readJsonIfPresent(essencePath);
   if (!essence) {
     console.error(
@@ -11872,7 +11002,7 @@ async function cmdTaskWorkflow(args) {
     process.exitCode = 1;
     return;
   }
-  if (!isV49(essence)) {
+  if (!isV48(essence)) {
     console.error(error2("Task context requires Essence v4. Run `decantr migrate --to v4` first."));
     process.exitCode = 1;
     return;
@@ -11887,16 +11017,22 @@ async function cmdTaskWorkflow(args) {
   }
   const section = essence.blueprint.sections.find((entry) => entry.id === target.section);
   const page = section?.pages.find((entry) => entry.id === target.page);
-  const contextDir = join32(workspaceInfo.appRoot, ".decantr", "context");
-  const manifest = readJsonIfPresent(join32(contextDir, "pack-manifest.json"));
-  const projectJson = readJsonIfPresent(join32(workspaceInfo.appRoot, ".decantr", "project.json"));
+  const contextDir = join30(workspaceInfo.appRoot, ".decantr", "context");
+  const manifest = readJsonIfPresent(join30(contextDir, "pack-manifest.json"));
+  const projectJson = readJsonIfPresent(join30(workspaceInfo.appRoot, ".decantr", "project.json"));
   const pagePack = manifest?.pages?.find((entry) => entry.id === target.page);
   const sectionPack = manifest?.sections?.find((entry) => entry.id === target.section);
-  const visualManifest = readJsonIfPresent(join32(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
+  const visualManifest = readJsonIfPresent(join30(workspaceInfo.appRoot, ".decantr", "evidence", "visual-manifest.json"));
   const screenshot = visualManifest?.routes?.find((entry) => entry.route === route)?.screenshot;
   const localPatternPackPath = localPatternsPath(workspaceInfo.appRoot);
   const localRuleManifestPath = localRulesPath(workspaceInfo.appRoot);
   const acceptedStyleBridgePath = styleBridgePath(workspaceInfo.appRoot);
+  const graphDir = join30(workspaceInfo.appRoot, ".decantr", "graph");
+  const contractCapsulePath = join30(graphDir, "contract-capsule.json");
+  const graphSnapshotPath = join30(graphDir, "graph.snapshot.json");
+  const contractCapsule = readJsonIfPresent(contractCapsulePath);
+  const graphSnapshot = readJsonIfPresent(graphSnapshotPath);
+  const routeGraphContext = buildGraphRouteContext(graphSnapshot, route, { task: taskSummary });
   const localLaw = createLocalLawTaskSummary(workspaceInfo.appRoot);
   const styleBridge = createStyleBridgeTaskSummary(workspaceInfo.appRoot);
   const displayedStyleBridge = {
@@ -11911,15 +11047,29 @@ async function cmdTaskWorkflow(args) {
   const changedSince = flagString(flags, "since");
   const currentChangedFiles = changedFiles(workspaceInfo.appRoot, changedSince);
   const changedRoutes = routeImpacts(workspaceInfo.appRoot, currentChangedFiles);
+  const changedFileSourceNodes = graphSnapshot ? currentChangedFiles.map((file) => ({
+    file,
+    nodeId: graphSourceNodeIdForTaskFile(workspaceInfo.appRoot, graphSnapshot, file)
+  })) : [];
+  const changedFileSourceNodeIds = [
+    ...new Set(
+      changedFileSourceNodes.map((entry) => entry.nodeId).filter((nodeId) => Boolean(nodeId))
+    )
+  ];
+  const changedFileMissingFiles = graphSnapshot ? changedFileSourceNodes.filter((entry) => !entry.nodeId).map((entry) => entry.file) : currentChangedFiles;
+  const changedFileGraphContext = graphSnapshot && changedFileSourceNodeIds.length > 0 ? buildGraphImpactContext(graphSnapshot, changedFileSourceNodeIds, {
+    task: taskSummary,
+    limit: 120
+  }) : null;
   const authority = createTaskAuthoritySummary({
     projectRoot: workspaceInfo.appRoot,
     workflowMode: projectJson?.initialized?.workflowMode ?? null,
     adoptionMode: projectJson?.initialized?.adoptionMode ?? null,
-    hasLocalPatterns: existsSync30(localPatternPackPath),
-    hasLocalRules: existsSync30(localRuleManifestPath),
+    hasLocalPatterns: existsSync28(localPatternPackPath),
+    hasLocalRules: existsSync28(localRuleManifestPath),
     hasPackManifest: Boolean(manifest),
     taskSummary,
-    hasStyleBridge: existsSync30(acceptedStyleBridgePath)
+    hasStyleBridge: existsSync28(acceptedStyleBridgePath)
   });
   const context = {
     route,
@@ -11929,15 +11079,56 @@ async function cmdTaskWorkflow(args) {
     shell: page?.shell ?? section?.shell ?? null,
     patterns: page?.layout?.map(extractPatternName) ?? [],
     read: [
-      pagePack ? displayProjectPath(workspaceInfo, join32(".decantr/context", pagePack.markdown)) : null,
-      sectionPack ? displayProjectPath(workspaceInfo, join32(".decantr/context", sectionPack.markdown)) : null,
-      manifest?.scaffold?.markdown ? displayProjectPath(workspaceInfo, join32(".decantr/context", manifest.scaffold.markdown)) : null,
+      pagePack ? displayProjectPath(workspaceInfo, join30(".decantr/context", pagePack.markdown)) : null,
+      sectionPack ? displayProjectPath(workspaceInfo, join30(".decantr/context", sectionPack.markdown)) : null,
+      manifest?.scaffold?.markdown ? displayProjectPath(workspaceInfo, join30(".decantr/context", manifest.scaffold.markdown)) : null,
       displayProjectPath(workspaceInfo, ".decantr/context/scaffold.md"),
       displayProjectPath(workspaceInfo, "DECANTR.md"),
-      existsSync30(localPatternPackPath) ? displayProjectPath(workspaceInfo, ".decantr/local-patterns.json") : null,
-      existsSync30(localRuleManifestPath) ? displayProjectPath(workspaceInfo, ".decantr/rules.json") : null,
-      existsSync30(acceptedStyleBridgePath) ? displayProjectPath(workspaceInfo, ".decantr/style-bridge.json") : null
+      existsSync28(localPatternPackPath) ? displayProjectPath(workspaceInfo, ".decantr/local-patterns.json") : null,
+      existsSync28(localRuleManifestPath) ? displayProjectPath(workspaceInfo, ".decantr/rules.json") : null,
+      existsSync28(acceptedStyleBridgePath) ? displayProjectPath(workspaceInfo, ".decantr/style-bridge.json") : null,
+      contractCapsule ? displayProjectPath(workspaceInfo, ".decantr/graph/contract-capsule.json") : null,
+      routeGraphContext && !contractCapsule ? displayProjectPath(workspaceInfo, ".decantr/graph/graph.snapshot.json") : null
     ].filter(Boolean),
+    graph: contractCapsule || graphSnapshot ? {
+      capsule: contractCapsule ? {
+        path: displayProjectPath(workspaceInfo, ".decantr/graph/contract-capsule.json"),
+        snapshotId: contractCapsule.snapshot_id ?? null,
+        cacheKey: contractCapsule.cache_key ?? null,
+        contractHash: contractCapsule.contract_hash ?? null,
+        contractCacheKey: contractCapsule.contract_cache_key ?? null,
+        summary: contractCapsule.summary ?? null
+      } : null,
+      snapshot: graphSnapshot ? {
+        path: displayProjectPath(workspaceInfo, ".decantr/graph/graph.snapshot.json"),
+        id: graphSnapshot.id ?? null,
+        sourceHash: graphSnapshot.source_hash ?? null,
+        summary: graphSnapshot.summary ?? null
+      } : null,
+      routeContext: routeGraphContext ? {
+        path: displayProjectPath(workspaceInfo, ".decantr/graph/graph.snapshot.json"),
+        ...routeGraphContext
+      } : null,
+      changedFileContext: currentChangedFiles.length > 0 ? {
+        path: displayProjectPath(
+          workspaceInfo,
+          ".decantr/graph/graph.snapshot.json"
+        ),
+        changedFiles: currentChangedFiles.slice(0, 40),
+        resolvedNodeIds: changedFileSourceNodeIds,
+        missingFiles: changedFileMissingFiles.slice(0, 40),
+        impact: changedFileGraphContext ? {
+          snapshotId: changedFileGraphContext.snapshotId,
+          sourceHash: changedFileGraphContext.sourceHash,
+          ranking: changedFileGraphContext.ranking,
+          summary: changedFileGraphContext.summary,
+          ids: changedFileGraphContext.ids,
+          ranked: changedFileGraphContext.ranked.slice(0, 24),
+          nodes: changedFileGraphContext.nodes,
+          edges: changedFileGraphContext.edges
+        } : null
+      } : null
+    } : null,
     screenshot: screenshot?.startsWith(".decantr/") ? displayProjectPath(workspaceInfo, screenshot) : screenshot ?? null,
     authority,
     localLaw: displayedLocalLaw,
@@ -11966,6 +11157,55 @@ async function cmdTaskWorkflow(args) {
     console.log(`${BOLD9}Visual evidence:${RESET16}`);
     console.log(`  ${cyan3(context.screenshot)}`);
   }
+  if (context.graph?.capsule || context.graph?.snapshot) {
+    console.log("");
+    console.log(`${BOLD9}Typed contract graph:${RESET16}`);
+    if (context.graph.capsule) {
+      console.log(`  Capsule: ${cyan3(context.graph.capsule.path)}`);
+      if (context.graph.capsule.cacheKey) {
+        console.log(`  Cache key: ${context.graph.capsule.cacheKey}`);
+      }
+      if (context.graph.capsule.contractCacheKey && context.graph.capsule.contractCacheKey !== context.graph.capsule.cacheKey) {
+        console.log(`  Contract cache key: ${context.graph.capsule.contractCacheKey}`);
+      }
+    }
+    if (context.graph.snapshot) {
+      const summary = context.graph.snapshot.summary;
+      const counts = summary && typeof summary.nodes === "number" && typeof summary.edges === "number" ? ` (${summary.nodes} nodes, ${summary.edges} edges)` : "";
+      console.log(`  Snapshot: ${cyan3(context.graph.snapshot.path)}${counts}`);
+    }
+    if (context.graph.routeContext) {
+      const routeSummary = context.graph.routeContext.summary;
+      const routeFindings = context.graph.routeContext.nodes.filter((node) => node.type === "Finding").map((node) => graphPayloadString(node.payload, "code") ?? node.id).slice(0, 4);
+      const routeSources = context.graph.routeContext.nodes.filter((node) => node.type === "SourceArtifact").map((node) => graphPayloadString(node.payload, "path") ?? node.id.replace(/^src:/, "")).slice(0, 4);
+      const routeHints = [
+        context.graph.routeContext.ids.patterns.length > 0 ? `patterns ${context.graph.routeContext.ids.patterns.join(", ")}` : null,
+        routeSummary.openFindings > 0 ? `${routeSummary.openFindings} finding(s)` : null,
+        routeSummary.evidence > 0 ? `${routeSummary.evidence} evidence node(s)` : null,
+        routeSummary.sourceArtifacts > 0 ? `${routeSummary.sourceArtifacts} source artifact(s)` : null
+      ].filter(Boolean);
+      console.log(
+        `  Route subgraph: ${routeSummary.nodes} nodes, ${routeSummary.edges} edges${routeHints.length > 0 ? `; ${routeHints.join("; ")}` : ""}`
+      );
+      if (routeFindings.length > 0) {
+        console.log(`  Route findings: ${routeFindings.join(", ")}`);
+      }
+      if (routeSources.length > 0) {
+        console.log(`  Route sources: ${routeSources.join(", ")}`);
+      }
+    }
+    if (context.graph.changedFileContext?.impact) {
+      const impact = context.graph.changedFileContext.impact;
+      const impactHints = [
+        impact.ids.routes.length > 0 ? `routes ${impact.ids.routes.join(", ")}` : null,
+        impact.summary.pages > 0 ? `${impact.summary.pages} page(s)` : null,
+        impact.summary.openFindings > 0 ? `${impact.summary.openFindings} finding(s)` : null
+      ].filter(Boolean);
+      console.log(
+        `  Changed-file impact: ${impact.summary.nodes} nodes, ${impact.summary.edges} edges${impactHints.length > 0 ? `; ${impactHints.join("; ")}` : ""}`
+      );
+    }
+  }
   console.log("");
   console.log(`${BOLD9}Authority for this task:${RESET16}`);
   console.log(`  Lane: ${context.authority.lane}`);
@@ -12038,7 +11278,7 @@ async function cmdTaskWorkflow(args) {
   console.log("");
   console.log(`${BOLD9}LLM instruction:${RESET16}`);
   console.log(
-    "  Preserve the active authority above. Use the route pack, section context, local laws, changed-file impact, and visual evidence as the task contract before changing code."
+    "  Preserve the active authority above. Use the route pack, section context, typed route graph, local laws, changed-file impact, and visual evidence as the task contract before changing code."
   );
   console.log(`  After editing, run ${cyan3(context.verifyCommand)}.`);
 }
@@ -12064,7 +11304,7 @@ async function cmdCodifyWorkflow(args) {
   const workspaceInfo = resolveWorkflowProject(flags, "codify");
   if (!workspaceInfo) return;
   if (flagBoolean(flags, "accept")) {
-    if (!existsSync30(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync30(localRulesProposalPath(workspaceInfo.appRoot)) && !existsSync30(styleBridgeProposalPath(workspaceInfo.appRoot))) {
+    if (!existsSync28(localPatternsProposalPath(workspaceInfo.appRoot)) && !existsSync28(localRulesProposalPath(workspaceInfo.appRoot)) && !existsSync28(styleBridgeProposalPath(workspaceInfo.appRoot))) {
       console.error(
         error2(
           "No codify proposal found. Run `decantr codify --from-audit`, `decantr codify --style-bridge`, or `decantr codify` first."
@@ -12098,14 +11338,14 @@ async function cmdCodifyWorkflow(args) {
   }
   const detected = detectProject(workspaceInfo.appRoot);
   const essence = readJsonIfPresent(
-    join32(workspaceInfo.appRoot, "decantr.essence.json")
+    join30(workspaceInfo.appRoot, "decantr.essence.json")
   );
   const fromAudit = flagBoolean(flags, "from-audit") || flagBoolean(flags, "discover-local-patterns") || flagBoolean(flags, "codify-local-patterns");
   const wantsStyleBridge = flagBoolean(flags, "style-bridge");
   const mapPatternSlug = flagString(flags, "map-pattern") ?? flagString(flags, "hosted-pattern");
   if (mapPatternSlug) {
     const registryClient = new RegistryClient({
-      cacheDir: join32(workspaceInfo.appRoot, ".decantr", "cache")
+      cacheDir: join30(workspaceInfo.appRoot, ".decantr", "cache")
     });
     const candidates = await loadPatternDiscoveryCandidates(registryClient);
     const candidate = findPatternCandidateBySlug(candidates, mapPatternSlug);
@@ -12229,7 +11469,7 @@ async function cmdContentWorkflow(args) {
 }
 function cmdHelp() {
   console.log(`
-${BOLD9}decantr${RESET16} \u2014 Design intelligence for AI-generated UI
+${BOLD9}decantr${RESET16} \u2014 AI Frontend Governance for codebases touched by AI agents
 
 ${BOLD9}Usage:${RESET16}
   decantr setup [--project <path>]
@@ -12238,6 +11478,7 @@ ${BOLD9}Usage:${RESET16}
   decantr adopt [--project <path>] [--base-url <url>] [--evidence] [--ci] [--no-packs] [--yes]
   decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]
   decantr verify [--project <path>] [--brownfield] [--local-patterns] [health options]
+  decantr graph [--project <path>] [--route <route>] [--node <id>] [--file <path>] [--task <text>] [--snapshot-id <id>] [--compare-to <id>] [--capsule-source-limit <count>] [--check] [--json]
   decantr ci [--project <path>] [--workspace] [--fail-on error|warn|none]
   decantr doctor [--project <path>] [--workspace] [--json]
   decantr codify [--from-audit] [--style-bridge] [--map-pattern <slug>] [--accept] [--project <path>]
@@ -12254,6 +11495,7 @@ ${BOLD9}Advanced primitives:${RESET16}
   decantr check
   decantr check --brownfield
   decantr sync-drift
+  decantr graph [--project <path>] [--route <route>] [--node <id>] [--file <path>] [--task <text>] [--snapshot-id <id>] [--compare-to <id>] [--capsule-source-limit <count>] [--check] [--json]
   decantr search <query> [--type <type>] [--sort <recommended|recent|name>] [--recommended] [--source <authored|benchmark|hybrid>]
   decantr suggest <query> [--type <type>] [--route <route>] [--file <path>] [--from-code]
   decantr get <type> <id>
@@ -12266,6 +11508,7 @@ ${BOLD9}Advanced primitives:${RESET16}
   decantr registry audit-project [--namespace <namespace>] [--json] [--essence <path>] [--dist <path>] [--sources <dir>]
   decantr health [--format text|json|markdown] [--ci] [--fail-on error|warn|none]
   decantr health --evidence [--browser] [--base-url <url>] [--design-tokens <path>]
+  decantr health --diagnostics [--json|--markdown]
   decantr health --save-baseline | --since-baseline
   decantr health init-ci [legacy alias for decantr ci init]
   decantr ci init [--project <path>] [--workspace] [--provider github|generic] [--force]
@@ -12315,6 +11558,7 @@ ${BOLD9}Commands:${RESET16}
   ${cyan3("adopt")}       Brownfield one-liner: analyze, attach, verify, and show next steps
   ${cyan3("task")}        Prepare route/task context, local law, evidence, and changed-file impact for an AI coding assistant
   ${cyan3("verify")}      One reliability gate over Project Health, Brownfield checks, baselines, and evidence
+  ${cyan3("graph")}       Build typed Contract graph artifacts and the agent cache capsule
   ${cyan3("ci")}          Non-mutating CI gate and CI integration generator
   ${cyan3("doctor")}      Explain Decantr state, artifact ownership, and the next command
   ${cyan3("codify")}      Propose or accept project-owned Brownfield UI patterns and rules
@@ -12327,21 +11571,22 @@ ${BOLD9}Advanced commands:${RESET16}
   ${cyan3("status")}      Show project status, DNA axioms, and blueprint info
   ${cyan3("health")}      Advanced Project Health primitive [--json] [--markdown] [--ci]; use decantr ci for automation
   ${cyan3("workspace")}   Discover and aggregate health across Decantr projects in a monorepo
-  ${cyan3("content-health")} Generate a local registry content health report [--json] [--markdown] [--ci]
-  ${cyan3("sync")}        Sync registry content from API
+  ${cyan3("content-health")} Generate a local official-vocabulary health report [--json] [--markdown] [--ci]
+  ${cyan3("sync")}        Sync official vocabulary from API
   ${cyan3("audit")}       Audit the project or critique a specific file against compiled packs
   ${cyan3("migrate")}     Migrate older essence files to v4 format (with .pre-v4.backup.json backup)
   ${cyan3("check")}       Detect drift issues (validate + guard rules) [--telemetry] [--brownfield]
   ${cyan3("sync-drift")}  Review and resolve drift log entries
-  ${cyan3("search")}      Search the registry
+  ${cyan3("graph")}       Generate .decantr/graph snapshot, history, manifest, diff, and contract capsule
+  ${cyan3("search")}      Search official/community vocabulary
   ${cyan3("suggest")}     Suggest patterns or alternatives for a query
-  ${cyan3("get")}         Get full details of a registry item
+  ${cyan3("get")}         Get full details of a vocabulary item
   ${cyan3("list")}        List items by type
   ${cyan3("showcase")}    Inspect audited showcase benchmark metadata
   ${cyan3("validate")}    Validate an Essence v4 file
   ${cyan3("theme")}       Manage custom themes (create, list, validate, delete, import)
   ${cyan3("create")}      Create a custom content item (pattern, theme, blueprint, etc.)
-  ${cyan3("publish")}     Publish a custom content item to the community registry
+  ${cyan3("publish")}     Publish a custom vocabulary item to the community content service
   ${cyan3("login")}       Authenticate with the Decantr registry
   ${cyan3("logout")}      Remove stored credentials
   ${cyan3("analyze")}     Brownfield entrypoint: scan an existing project and emit attach guidance
@@ -12361,6 +11606,11 @@ ${BOLD9}Examples:${RESET16}
   decantr adopt --project apps/web --yes
   decantr task /feed "add saved recipe actions"
   decantr verify --brownfield --local-patterns
+  decantr graph --project apps/web
+  decantr graph --project apps/web --route /feed --task "improve loading" --json
+  decantr graph --project apps/web --file src/app/page.tsx --impact --json
+  decantr graph --project apps/web --compare-to graph:previous --include-diff-ops --json
+  decantr graph --check --json
   decantr verify --base-url http://localhost:3000 --evidence
   decantr verify --since-baseline
   decantr doctor --project apps/web
@@ -12418,6 +11668,7 @@ ${BOLD9}Workflow Model:${RESET16}
   ${cyan3("Brownfield preview")}     decantr scan -> decantr adopt --yes
   ${cyan3("Brownfield monorepo")}    decantr adopt --project apps/web --yes
   ${cyan3("Daily LLM work")}          decantr task <route> "<change>" -> decantr verify --brownfield --local-patterns
+  ${cyan3("Typed contract graph")}    decantr graph -> agent session loads .decantr/graph/contract-capsule.json
   ${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
 
@@ -12480,6 +11731,7 @@ ${BOLD9}Usage:${RESET16}
   decantr health --ci [--fail-on error|warn|none]
   decantr health --prompt <finding-id>
   decantr health --evidence [--browser] [--design-tokens <path>]
+  decantr health --diagnostics [--json|--markdown]
   decantr health --browser --base-url <url> --evidence
   decantr health --save-baseline
   decantr health --since-baseline
@@ -12494,6 +11746,7 @@ ${BOLD9}Options:${RESET16}
   --fail-on     CI threshold: error, warn, or none
   --prompt      Print an AI-ready remediation prompt for a finding
   --evidence    Emit a local Evidence Bundle JSON artifact
+  --diagnostics Print the stable diagnostic code and repair ID catalog
   --browser     Include optional rendered-browser setup/evidence checks
   --base-url    Base URL for rendered route checks when --browser is enabled
   --save-baseline Save the current health state for later comparison
@@ -12506,6 +11759,7 @@ ${BOLD9}Examples:${RESET16}
   decantr health --markdown --output decantr-health.md
   decantr ci --project apps/web
   decantr health --prompt audit-essence-missing
+  decantr health --diagnostics --markdown
   decantr health --evidence --output .decantr/evidence/latest.json
   decantr ci init --project apps/web
   decantr ci init --workspace
@@ -12530,7 +11784,7 @@ ${BOLD9}Examples:${RESET16}
 }
 function cmdContentHealthHelp() {
   console.log(`
-${BOLD9}decantr content-health${RESET16} \u2014 Generate a local registry content health report
+${BOLD9}decantr content-health${RESET16} \u2014 Generate a local official-vocabulary health report
 
 ${BOLD9}Usage:${RESET16}
   decantr content-health [--format text|json|markdown] [--output <file>]
@@ -12679,6 +11933,10 @@ ${BOLD9}decantr task${RESET16} \u2014 Prepare compact route/task context for an
 ${BOLD9}Usage:${RESET16}
   decantr task <route> ["task summary"] [--project <path>] [--since origin/main] [--json]
 
+${BOLD9}Behavior:${RESET16}
+  Includes the typed contract capsule path when .decantr/graph exists. Run decantr graph first
+  when you want graph-backed agent context in CLI-only workflows.
+
 ${BOLD9}Examples:${RESET16}
   decantr task /feed "add saved recipe actions"
   decantr task /feed "add saved recipe actions" --since origin/main
@@ -12706,7 +11964,7 @@ ${BOLD9}Examples:${RESET16}
 }
 function cmdContentHelp() {
   console.log(`
-${BOLD9}decantr content${RESET16} \u2014 Content-author namespace for registry content repositories
+${BOLD9}decantr content${RESET16} \u2014 Content-author namespace for official-vocabulary repositories
 
 ${BOLD9}Usage:${RESET16}
   decantr content check [content-health options]
@@ -12734,6 +11992,9 @@ function printCommandHelp(command, args) {
     case "verify":
       cmdVerifyHelp();
       return true;
+    case "graph":
+      cmdGraphHelp();
+      return true;
     case "ci":
       cmdCiHelp();
       return true;
@@ -12785,10 +12046,10 @@ async function main() {
   if (command === "--version" || command === "-v" || command === "version") {
     try {
       const here = dirname6(fileURLToPath3(import.meta.url));
-      const candidates = [join32(here, "..", "package.json"), join32(here, "..", "..", "package.json")];
+      const candidates = [join30(here, "..", "package.json"), join30(here, "..", "..", "package.json")];
       for (const candidate of candidates) {
-        if (existsSync30(candidate)) {
-          const pkg = JSON.parse(readFileSync23(candidate, "utf-8"));
+        if (existsSync28(candidate)) {
+          const pkg = JSON.parse(readFileSync21(candidate, "utf-8"));
           if (pkg.version) {
             console.log(pkg.version);
             return;
@@ -12827,6 +12088,51 @@ async function main() {
       await cmdVerifyWorkflow(args);
       break;
     }
+    case "graph": {
+      const { flags } = parseLooseArgs(args);
+      if (!ensureAllowedFlags(
+        flags,
+        [
+          "project",
+          "route",
+          "node",
+          "file",
+          "task",
+          "snapshot-id",
+          "compare-to",
+          "include-diff-ops",
+          "impact",
+          "limit",
+          "capsule-source-limit",
+          "check",
+          "json"
+        ],
+        "graph"
+      ))
+        break;
+      const workspaceInfo = resolveWorkflowProject(flags, "graph");
+      if (!workspaceInfo) break;
+      const limitArg = flagString(flags, "limit");
+      const limit = limitArg ? Number(limitArg) : void 0;
+      const capsuleSourceLimitArg = flagString(flags, "capsule-source-limit");
+      const capsuleSourceLimit = capsuleSourceLimitArg ? Number(capsuleSourceLimitArg) : void 0;
+      await cmdGraph(workspaceInfo.appRoot, {
+        check: flagBoolean(flags, "check"),
+        json: flagBoolean(flags, "json"),
+        route: flagString(flags, "route"),
+        node: flagString(flags, "node"),
+        file: flagString(flags, "file"),
+        impact: flagBoolean(flags, "impact"),
+        task: flagString(flags, "task"),
+        snapshotId: flagString(flags, "snapshot-id"),
+        compareTo: flagString(flags, "compare-to"),
+        includeDiffOps: flagBoolean(flags, "include-diff-ops"),
+        limit,
+        capsuleSourceLimit,
+        displayRoot: workspaceInfo.cwd
+      });
+      break;
+    }
     case "ci": {
       await cmdCi(args, process.cwd());
       break;
@@ -12970,7 +12276,7 @@ async function main() {
         const { flags } = parseLooseArgs(args);
         const workspaceInfo = resolveWorkflowProject(flags, "health");
         if (!workspaceInfo) break;
-        const { cmdHealth, parseHealthArgs } = await import("./health-B4W7UJBZ.js");
+        const { cmdHealth, parseHealthArgs } = await import("./health-ASR7RWZJ.js");
         await cmdHealth(workspaceInfo.appRoot, parseHealthArgs(stripProjectArgs(args)));
       } catch (e) {
         console.error(error2(e.message));
@@ -12998,7 +12304,7 @@ async function main() {
           cmdStudioHelp();
           break;
         }
-        const { cmdStudio, parseStudioArgs } = await import("./studio-JOEECLI6.js");
+        const { cmdStudio, parseStudioArgs } = await import("./studio-R65NXPJW.js");
         await cmdStudio(process.cwd(), parseStudioArgs(args));
       } catch (e) {
         console.error(error2(e.message));
@@ -13012,7 +12318,7 @@ async function main() {
           cmdWorkspaceHelp();
           break;
         }
-        const { cmdWorkspace } = await import("./workspace-7RU77ZZW.js");
+        const { cmdWorkspace } = await import("./workspace-2FFQEEQQ.js");
         await cmdWorkspace(process.cwd(), args);
       } catch (e) {
         console.error(error2(e.message));
@@ -13109,7 +12415,7 @@ async function main() {
       if (!query && (route || file || fromCode)) {
         query = [
           route ? `route ${route}` : null,
-          file ? `file ${basename3(file)}` : null,
+          file ? `file ${basename2(file)}` : null,
           fromCode ? "source code patterns" : null
         ].filter((entry) => Boolean(entry)).join(" ");
       }
@@ -13331,7 +12637,7 @@ async function main() {
           break;
         }
         if (packType === "page" && route && !id) {
-          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join32(process.cwd(), "decantr.essence.json");
+          const resolvedPath = essencePath ? resolveUserPath(essencePath) : join30(process.cwd(), "decantr.essence.json");
           id = resolvePagePackIdForRoute(resolvedPath, route);
         }
         await printHostedSelectedExecutionPack(