@decantr/cli 2.13.1 → 3.0.0-next.0

package/dist/chunk-WUIFEHWM.js

@@ -0,0 +1,4573 @@
+import {
+  collectCheckIssues,
+  sendProjectHealthCiFailedTelemetry,
+  sendProjectHealthPromptTelemetry,
+  sendProjectHealthReportTelemetry
+} from "./chunk-MNZKOZW7.js";
+
+// src/commands/health.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import {
+  anchorFindingsToGraph,
+  auditProject,
+  buildProjectHealthRepairPlan,
+  createContractAssertions,
+  createEvidenceBundle,
+  deriveVerificationDiagnostic,
+  KNOWN_VERIFICATION_DIAGNOSTICS
+} from "@decantr/verifier";
+
+// src/workspace.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+function readPackageJson(dir) {
+  const path = join(dir, "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function hasWorkspaceMarker(dir) {
+  if (existsSync(join(dir, "pnpm-workspace.yaml")) || existsSync(join(dir, "turbo.json")) || existsSync(join(dir, "nx.json"))) {
+    return true;
+  }
+  const pkg = readPackageJson(dir);
+  return Boolean(pkg?.workspaces);
+}
+function findWorkspaceRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (hasWorkspaceMarker(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function looksLikeApp(dir, options = {}) {
+  const allowSourceDirs = options.allowSourceDirs ?? true;
+  const allowPackageDeps = options.allowPackageDeps ?? true;
+  const pkg = readPackageJson(dir);
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const hasFrontendDependency = Boolean(
+    deps.react || deps["react-dom"] || deps.next || deps.vue || deps.svelte || deps["@angular/core"] || deps.astro || deps.nuxt
+  );
+  const hasServerOnlyDependency = Boolean(
+    deps.hono || deps.express || deps.fastify || deps.koa || deps["@hapi/hapi"]
+  );
+  if (existsSync(join(dir, "next.config.js")) || existsSync(join(dir, "next.config.ts")) || existsSync(join(dir, "next.config.mjs")) || existsSync(join(dir, "vite.config.ts")) || existsSync(join(dir, "vite.config.js")) || existsSync(join(dir, "angular.json")) || existsSync(join(dir, "svelte.config.js")) || existsSync(join(dir, "svelte.config.ts")) || existsSync(join(dir, "astro.config.mjs"))) {
+    return true;
+  }
+  if (allowSourceDirs && (existsSync(join(dir, "src")) || existsSync(join(dir, "app")) || existsSync(join(dir, "pages")))) {
+    if (hasFrontendDependency) return true;
+    if (hasServerOnlyDependency) return false;
+    return true;
+  }
+  if (!allowPackageDeps) return false;
+  return hasFrontendDependency;
+}
+function listWorkspaceApps(workspaceRoot) {
+  const candidates = [];
+  for (const base of ["apps", "packages"]) {
+    const baseDir = join(workspaceRoot, base);
+    if (!existsSync(baseDir)) continue;
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const candidate = join(baseDir, entry.name);
+      if (looksLikeApp(candidate, {
+        allowSourceDirs: base === "apps",
+        allowPackageDeps: base === "apps"
+      })) {
+        candidates.push(`${base}/${entry.name}`);
+      }
+    }
+  }
+  return candidates.sort();
+}
+function listWorkspaceAppCandidates(workspaceRoot) {
+  return listWorkspaceApps(resolve(workspaceRoot));
+}
+function resolveWorkspaceInfo(cwd, projectArg) {
+  const absoluteCwd = resolve(cwd);
+  const appRoot = projectArg ? resolve(
+    isAbsolute(projectArg) ? projectArg : join(findWorkspaceRoot(absoluteCwd) ?? absoluteCwd, projectArg)
+  ) : absoluteCwd;
+  const workspaceRoot = projectArg && isAbsolute(projectArg) ? findWorkspaceRoot(appRoot) ?? appRoot : findWorkspaceRoot(absoluteCwd) ?? absoluteCwd;
+  const appCandidates = listWorkspaceApps(workspaceRoot);
+  const projectScope = workspaceRoot !== appRoot || appCandidates.length > 0 ? "workspace-app" : "single-app";
+  const requiresProjectSelection = !projectArg && workspaceRoot === absoluteCwd && appCandidates.length > 0;
+  return {
+    cwd: absoluteCwd,
+    workspaceRoot,
+    appRoot,
+    projectScope,
+    appCandidates,
+    requiresProjectSelection
+  };
+}
+
+// src/commands/graph.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative2 } from "path";
+import {
+  buildGraphImpactContext,
+  buildGraphRouteContext,
+  buildContractCapsuleFromSnapshot,
+  buildGraphSnapshotFromEssence,
+  diffGraphSnapshots,
+  GRAPH_DIFF_SCHEMA_URL,
+  GRAPH_MANIFEST_SCHEMA_URL,
+  GRAPH_SCHEMA_VERSION,
+  graphPayloadString,
+  normalizeGraphSnapshot,
+  summarizeGraphDiff
+} from "@decantr/core";
+import { isV4 as isV42 } from "@decantr/essence-spec";
+import {
+  auditComponentReuse,
+  collectProjectSourceFiles
+} from "@decantr/verifier";
+
+// src/local-law.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { basename, extname, join as join2, relative, sep } from "path";
+import { isV4 } 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 join2(projectRoot, ".decantr", "local-patterns.proposal.json");
+}
+function localPatternsPath(projectRoot) {
+  return join2(projectRoot, ".decantr", "local-patterns.json");
+}
+function localRulesProposalPath(projectRoot) {
+  return join2(projectRoot, ".decantr", "rules.proposal.json");
+}
+function localRulesPath(projectRoot) {
+  return join2(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 && isV4(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 = join2(projectRoot, ".decantr");
+  mkdirSync(decantrDir, { recursive: true });
+  const patternPath = localPatternsProposalPath(projectRoot);
+  const rulesPath = localRulesProposalPath(projectRoot);
+  writeFileSync(patternPath, `${JSON.stringify(proposal.patternPack, null, 2)}
+`, "utf-8");
+  writeFileSync(rulesPath, `${JSON.stringify(proposal.ruleManifest, null, 2)}
+`, "utf-8");
+  return { patternPath, rulesPath };
+}
+function writeHostedPatternMappingProposal(input) {
+  const decantrDir = join2(input.projectRoot, ".decantr");
+  mkdirSync(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);
+  writeFileSync(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);
+    writeFileSync(patternAcceptedPath, `${JSON.stringify(patternProposal, null, 2)}
+`, "utf-8");
+  }
+  if (ruleProposal) {
+    ruleProposal.status = "accepted";
+    ruleProposal.acceptedAt = acceptedAt;
+    rulesAcceptedPath = localRulesPath(projectRoot);
+    writeFileSync(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(
+    join2(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 = readFileSync2(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) => basename(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(basename(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 = readFileSync2(join2(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 = readFileSync2(join2(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 = readFileSync2(join2(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(basename(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 = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      if (IGNORED_DIRS.has(entry)) continue;
+      const absolute = join2(dir, entry);
+      let stat;
+      try {
+        stat = statSync(absolute);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        visit(absolute);
+      } else if (stat.isFile() && SOURCE_EXTENSIONS.has(extname(entry))) {
+        files.push({ absolute, relative: normalizePath(relative(projectRoot, absolute)) });
+      }
+    }
+  };
+  visit(projectRoot);
+  return files.sort((a, b) => a.relative.localeCompare(b.relative));
+}
+function readJsonFile(path) {
+  if (!existsSync2(path)) return null;
+  try {
+    return JSON.parse(readFileSync2(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 existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function styleBridgeProposalPath(projectRoot) {
+  return join3(projectRoot, ".decantr", "style-bridge.proposal.json");
+}
+function styleBridgePath(projectRoot) {
+  return join3(projectRoot, ".decantr", "style-bridge.json");
+}
+function readJsonFile2(path) {
+  if (!existsSync3(path)) return null;
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, value) {
+  writeFileSync2(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(join3(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(
+    join3(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 = join3(projectRoot, ".decantr");
+  mkdirSync2(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 = join3(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/graph.ts
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function hashBuffer(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function hashFile(path) {
+  return `sha256:${hashBuffer(readFileSync4(path))}`;
+}
+function hashJson(value) {
+  return `sha256:${hashBuffer(stableJson(value))}`;
+}
+function formatJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function readJsonFile3(path) {
+  if (!existsSync4(path)) return null;
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function visualManifestSourceHash(manifest) {
+  return hashJson({
+    version: manifest.version,
+    localOnly: manifest.localOnly,
+    baseUrl: manifest.baseUrl ?? null,
+    routes: (manifest.routes ?? []).map((route) => ({
+      route: route.route,
+      url: route.url,
+      screenshot: route.screenshot,
+      screenshotHash: route.screenshotHash ?? null,
+      status: route.status,
+      error: route.error
+    }))
+  });
+}
+function stableFindingGraphAnchor(finding) {
+  if (!finding.graph) return void 0;
+  return {
+    node_id: finding.graph.node_id,
+    node_type: finding.graph.node_type,
+    route: finding.graph.route,
+    confidence: finding.graph.confidence,
+    reason: finding.graph.reason
+  };
+}
+function evidenceBundleSourceHash(bundle) {
+  return hashJson({
+    health: bundle.health ? {
+      status: bundle.health.status,
+      score: bundle.health.score,
+      errorCount: bundle.health.errorCount,
+      warnCount: bundle.health.warnCount,
+      infoCount: bundle.health.infoCount,
+      findingCount: bundle.health.findingCount
+    } : null,
+    provenance: Object.entries(bundle.provenance ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => ({
+      key,
+      path: entry.path,
+      present: entry.present,
+      hash: entry.hash ?? null
+    })),
+    findings: (bundle.findings ?? []).map((finding) => ({
+      id: finding.id,
+      code: finding.code,
+      source: finding.source,
+      category: finding.category,
+      severity: finding.severity,
+      message: finding.message,
+      target: finding.target,
+      rule: finding.rule,
+      suggestedFix: finding.suggestedFix,
+      graph: stableFindingGraphAnchor(finding),
+      repair: finding.repair?.id,
+      repairPlan: finding.repairPlan ? {
+        id: finding.repairPlan.id,
+        actions: finding.repairPlan.actions,
+        readTargets: finding.repairPlan.readTargets,
+        commands: finding.repairPlan.commands
+      } : void 0,
+      evidence: finding.evidence,
+      commands: finding.commands
+    }))
+  });
+}
+function healthBaselineDiffSourceHash(diff) {
+  return hashJson({
+    savedAt: diff.savedAt ?? null,
+    statusChanged: diff.statusChanged ?? false,
+    scoreDelta: diff.scoreDelta ?? null,
+    addedFindings: diff.addedFindings ?? [],
+    resolvedFindings: diff.resolvedFindings ?? [],
+    changedFiles: diff.changedFiles ?? [],
+    changedRoutes: diff.changedRoutes ?? [],
+    changedScreenshots: diff.changedScreenshots ?? [],
+    contractDrift: diff.contractDrift ?? []
+  });
+}
+function analysisSourceHash(analysis) {
+  return hashJson({
+    project: {
+      framework: analysis.project?.framework,
+      frameworkVersion: analysis.project?.frameworkVersion,
+      packageManager: analysis.project?.packageManager,
+      hasTypeScript: analysis.project?.hasTypeScript,
+      hasTailwind: analysis.project?.hasTailwind,
+      projectScope: analysis.project?.projectScope
+    },
+    routes: {
+      strategy: analysis.routes?.strategy,
+      routes: (analysis.routes?.routes ?? []).map((route) => ({
+        path: route.path,
+        file: route.file,
+        hasLayout: route.hasLayout
+      }))
+    },
+    styling: {
+      approach: analysis.styling?.approach,
+      configFile: analysis.styling?.configFile,
+      darkMode: analysis.styling?.darkMode,
+      cssVariables: analysis.styling?.cssVariables
+    },
+    layout: {
+      shellPattern: analysis.layout?.shellPattern
+    },
+    features: {
+      detected: analysis.features?.detected
+    }
+  });
+}
+function graphPaths(projectRoot) {
+  const graphDir = join4(projectRoot, ".decantr", "graph");
+  return {
+    graphDir,
+    snapshotsDir: join4(graphDir, "snapshots"),
+    snapshot: join4(graphDir, "graph.snapshot.json"),
+    snapshotHistory: join4(graphDir, "snapshots", "pending.json"),
+    manifest: join4(graphDir, "graph.manifest.json"),
+    diff: join4(graphDir, "graph.diff.json"),
+    capsule: join4(graphDir, "contract-capsule.json")
+  };
+}
+function graphSnapshotHistoryFileName(snapshotId) {
+  return `${snapshotId.replace(/[^a-zA-Z0-9_.-]+/g, "-")}.json`;
+}
+function withSnapshotHistoryPath(paths, snapshotId) {
+  return {
+    ...paths,
+    snapshotHistory: join4(paths.snapshotsDir, graphSnapshotHistoryFileName(snapshotId))
+  };
+}
+function graphSnapshotPathForId(projectRoot, snapshotId) {
+  const paths = graphPaths(projectRoot);
+  if (!snapshotId || snapshotId === "current") return paths.snapshot;
+  return join4(paths.snapshotsDir, graphSnapshotHistoryFileName(snapshotId));
+}
+function readGraphSnapshotSelection(artifacts, snapshotId) {
+  const selector = snapshotId || "current";
+  if (selector === "current") {
+    return {
+      selector,
+      path: artifacts.paths.snapshot,
+      snapshot: artifacts.snapshot
+    };
+  }
+  if (selector === artifacts.snapshot.id) {
+    return {
+      selector,
+      path: artifacts.paths.snapshotHistory,
+      snapshot: artifacts.snapshot
+    };
+  }
+  const path = graphSnapshotPathForId(artifacts.projectRoot, selector);
+  const snapshot = readJsonFile3(path);
+  if (!snapshot) {
+    throw new Error(
+      `Graph snapshot not found: ${selector}. Expected ${pathForDisplay(
+        artifacts.projectRoot,
+        path
+      )}. Run \`decantr graph --json\` to see the current snapshot id and history path.`
+    );
+  }
+  return {
+    selector,
+    path,
+    snapshot: normalizeGraphSnapshot(snapshot)
+  };
+}
+function projectRelativePath(projectRoot, path) {
+  if (!path) return null;
+  const absolutePath = isAbsolute2(path) ? path : join4(projectRoot, path);
+  const relativePath = relative2(projectRoot, absolutePath).replace(/\\/g, "/");
+  if (!relativePath || relativePath.startsWith("..") || isAbsolute2(relativePath)) {
+    return null;
+  }
+  return relativePath;
+}
+function existingProjectRelativePath(projectRoot, path) {
+  const relativePath = projectRelativePath(projectRoot, path);
+  if (!relativePath) return null;
+  return existsSync4(join4(projectRoot, relativePath)) ? relativePath : null;
+}
+function stripJsonComments(value) {
+  return value.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function readCompilerImportResolutionConfig(projectRoot) {
+  for (const name of ["tsconfig.json", "jsconfig.json"]) {
+    const path = join4(projectRoot, name);
+    if (!existsSync4(path)) continue;
+    try {
+      const parsed = JSON.parse(stripJsonComments(readFileSync4(path, "utf-8")));
+      const options = parsed.compilerOptions ?? {};
+      const paths = [];
+      if (options.paths && typeof options.paths === "object" && !Array.isArray(options.paths)) {
+        for (const [pattern, targets] of Object.entries(options.paths)) {
+          if (!Array.isArray(targets)) continue;
+          paths.push({
+            pattern,
+            targets: targets.filter((target) => typeof target === "string")
+          });
+        }
+      }
+      return {
+        baseUrl: typeof options.baseUrl === "string" ? options.baseUrl : null,
+        paths
+      };
+    } catch {
+      return { baseUrl: null, paths: [] };
+    }
+  }
+  return { baseUrl: null, paths: [] };
+}
+function existingImportCandidate(projectRoot, candidate) {
+  const relativeCandidate = projectRelativePath(projectRoot, candidate);
+  if (!relativeCandidate) return null;
+  const candidates = [
+    relativeCandidate,
+    `${relativeCandidate}.ts`,
+    `${relativeCandidate}.tsx`,
+    `${relativeCandidate}.js`,
+    `${relativeCandidate}.jsx`,
+    `${relativeCandidate}.mts`,
+    `${relativeCandidate}.cts`,
+    join4(relativeCandidate, "index.ts").replace(/\\/g, "/"),
+    join4(relativeCandidate, "index.tsx").replace(/\\/g, "/"),
+    join4(relativeCandidate, "index.js").replace(/\\/g, "/"),
+    join4(relativeCandidate, "index.jsx").replace(/\\/g, "/"),
+    join4(relativeCandidate, "index.mts").replace(/\\/g, "/"),
+    join4(relativeCandidate, "index.cts").replace(/\\/g, "/")
+  ];
+  for (const possible of candidates) {
+    if (existsSync4(join4(projectRoot, possible))) return possible;
+  }
+  return null;
+}
+function pathAliasTargetCandidates(source, config) {
+  const candidates = [];
+  for (const alias of config.paths) {
+    const starIndex = alias.pattern.indexOf("*");
+    if (starIndex === -1) {
+      if (alias.pattern !== source) continue;
+      candidates.push(...alias.targets);
+      continue;
+    }
+    const prefix = alias.pattern.slice(0, starIndex);
+    const suffix = alias.pattern.slice(starIndex + 1);
+    if (!source.startsWith(prefix) || !source.endsWith(suffix)) continue;
+    const matched = source.slice(prefix.length, source.length - suffix.length);
+    for (const target of alias.targets) {
+      candidates.push(target.replace("*", matched));
+    }
+  }
+  if (config.baseUrl) {
+    candidates.push(join4(config.baseUrl, source).replace(/\\/g, "/"));
+  }
+  if (source.startsWith("@/")) {
+    const withoutAlias = source.slice(2);
+    candidates.push(`src/${withoutAlias}`, withoutAlias);
+  }
+  return [...new Set(candidates)];
+}
+function resolveImportSourcePath(projectRoot, fromFile, source) {
+  if (source.startsWith(".")) {
+    return existingImportCandidate(projectRoot, join4(dirname2(fromFile), source));
+  }
+  const config = readCompilerImportResolutionConfig(projectRoot);
+  for (const candidate of pathAliasTargetCandidates(source, config)) {
+    const resolved = existingImportCandidate(projectRoot, candidate);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+function projectPathCandidatesFromText(text) {
+  if (!text) return [];
+  const candidates = /* @__PURE__ */ new Set();
+  const pathPattern = /(?:^|[\s([`"'])((?:\.\/|\.\.\/|\/|[A-Za-z0-9_.-]+\/)[A-Za-z0-9_./@-]+\.(?:[cm]?[jt]sx?|css|scss|sass|less|html|json|mdx?|png|jpe?g|webp|svg|gif))(?:[:)\]`"',\s]|$)/g;
+  for (const match of text.matchAll(pathPattern)) {
+    candidates.add(match[1]);
+  }
+  return [...candidates];
+}
+function evidenceBundleFindingSourcePaths(projectRoot, finding) {
+  const candidates = [
+    finding.target,
+    ...(finding.evidence ?? []).flatMap(projectPathCandidatesFromText),
+    ...finding.repairPlan?.readTargets ?? []
+  ];
+  const paths = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const relativePath = existingProjectRelativePath(projectRoot, candidate);
+    if (relativePath) paths.add(relativePath);
+  }
+  return [...paths].sort();
+}
+function graphSlug(value, fallback) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9_.:/-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return slug || fallback;
+}
+function graphEdgeKey(edge) {
+  return [edge.src, edge.relation, edge.dst, String(edge.idx ?? "")].join("\0");
+}
+function addNode(nodes, node) {
+  if (!nodes.has(node.id)) {
+    nodes.set(node.id, node);
+  }
+}
+function addEdge(edges, edge) {
+  edges.set(graphEdgeKey(edge), edge);
+}
+function sourceArtifacts(projectRoot, componentReuseAudit = null) {
+  const sources = [];
+  const essencePath = join4(projectRoot, "decantr.essence.json");
+  sources.push({
+    id: "src:decantr.essence.json",
+    kind: "essence",
+    path: "decantr.essence.json",
+    hash: hashFile(essencePath)
+  });
+  const rulesPath = localRulesPath(projectRoot);
+  if (existsSync4(rulesPath)) {
+    sources.push({
+      id: "src:.decantr/rules.json",
+      kind: "local-rule-manifest",
+      path: ".decantr/rules.json",
+      hash: hashFile(rulesPath)
+    });
+  }
+  const bridgePath = styleBridgePath(projectRoot);
+  if (existsSync4(bridgePath)) {
+    sources.push({
+      id: "src:.decantr/style-bridge.json",
+      kind: "style-bridge-manifest",
+      path: ".decantr/style-bridge.json",
+      hash: hashFile(bridgePath)
+    });
+  }
+  const analysisPath = join4(projectRoot, ".decantr", "analysis.json");
+  const analysis = readJsonFile3(analysisPath);
+  if (analysis) {
+    sources.push({
+      id: "src:.decantr/analysis.json",
+      kind: "brownfield-analysis",
+      path: ".decantr/analysis.json",
+      hash: analysisSourceHash(analysis),
+      payload: {
+        framework: analysis.project?.framework,
+        routeStrategy: analysis.routes?.strategy,
+        routes: analysis.routes?.routes?.length ?? 0,
+        styling: analysis.styling?.approach
+      }
+    });
+    for (const route of analysis.routes?.routes ?? []) {
+      const routeFile = projectRelativePath(projectRoot, route.file);
+      if (!routeFile) continue;
+      const routeFilePath = join4(projectRoot, routeFile);
+      if (!existsSync4(routeFilePath)) continue;
+      sources.push({
+        id: `src:${routeFile}`,
+        kind: "route-source",
+        path: routeFile,
+        hash: hashFile(routeFilePath),
+        payload: {
+          route: route.path,
+          hasLayout: route.hasLayout ?? false,
+          strategy: analysis.routes?.strategy
+        }
+      });
+    }
+  }
+  for (const declaration of componentReuseAudit?.declarations ?? []) {
+    if (!declaration.reusable) continue;
+    const componentFile = projectRelativePath(projectRoot, declaration.file);
+    if (!componentFile) continue;
+    const componentPath = join4(projectRoot, componentFile);
+    if (!existsSync4(componentPath)) continue;
+    if (sources.some((source) => source.id === `src:${componentFile}`)) continue;
+    sources.push({
+      id: `src:${componentFile}`,
+      kind: "component-source",
+      path: componentFile,
+      hash: hashFile(componentPath),
+      payload: {
+        component: declaration.name,
+        exported: declaration.exported,
+        kind: declaration.kind,
+        line: declaration.line
+      }
+    });
+  }
+  for (const importReference of componentReuseAudit?.imports ?? []) {
+    const importingFile = projectRelativePath(projectRoot, importReference.file);
+    if (!importingFile) continue;
+    const importingPath = join4(projectRoot, importingFile);
+    if (existsSync4(importingPath) && !sources.some((source) => source.id === `src:${importingFile}`)) {
+      sources.push({
+        id: `src:${importingFile}`,
+        kind: "code-source",
+        path: importingFile,
+        hash: hashFile(importingPath),
+        payload: {
+          imports: (componentReuseAudit?.imports ?? []).filter(
+            (entry) => projectRelativePath(projectRoot, entry.file) === importingFile
+          ).length
+        }
+      });
+    }
+    const importedFile = resolveImportSourcePath(projectRoot, importingFile, importReference.source);
+    if (!importedFile) continue;
+    const importedPath = join4(projectRoot, importedFile);
+    if (!existsSync4(importedPath)) continue;
+    if (sources.some((source) => source.id === `src:${importedFile}`)) continue;
+    sources.push({
+      id: `src:${importedFile}`,
+      kind: "code-source",
+      path: importedFile,
+      hash: hashFile(importedPath),
+      payload: {
+        importedBy: importingFile
+      }
+    });
+  }
+  const visualManifestPath = join4(projectRoot, ".decantr", "evidence", "visual-manifest.json");
+  const visualManifest = readJsonFile3(visualManifestPath);
+  if (visualManifest) {
+    sources.push({
+      id: "src:.decantr/evidence/visual-manifest.json",
+      kind: "visual-manifest",
+      path: ".decantr/evidence/visual-manifest.json",
+      hash: visualManifestSourceHash(visualManifest),
+      payload: {
+        localOnly: visualManifest.localOnly,
+        baseUrl: visualManifest.baseUrl ?? null,
+        routes: visualManifest.routes?.length ?? 0
+      }
+    });
+    for (const route of visualManifest.routes ?? []) {
+      if (!route.screenshot) continue;
+      const screenshotPath = join4(projectRoot, route.screenshot);
+      if (!existsSync4(screenshotPath)) continue;
+      sources.push({
+        id: `src:${route.screenshot}`,
+        kind: "visual-screenshot",
+        path: route.screenshot,
+        hash: hashFile(screenshotPath),
+        payload: {
+          route: route.route,
+          status: route.status,
+          screenshotHash: route.screenshotHash ?? null
+        }
+      });
+    }
+  }
+  const evidenceBundlePath = join4(projectRoot, ".decantr", "evidence", "latest.json");
+  const evidenceBundle = readJsonFile3(evidenceBundlePath);
+  if (evidenceBundle) {
+    sources.push({
+      id: "src:.decantr/evidence/latest.json",
+      kind: "evidence-bundle",
+      path: ".decantr/evidence/latest.json",
+      hash: evidenceBundleSourceHash(evidenceBundle),
+      payload: {
+        status: evidenceBundle.health?.status,
+        score: evidenceBundle.health?.score,
+        findings: evidenceBundle.findings?.length ?? 0,
+        provenance: Object.keys(evidenceBundle.provenance ?? {}).length,
+        graphSnapshotPresent: evidenceBundle.provenance?.graphSnapshot?.present,
+        graphSnapshotHash: evidenceBundle.provenance?.graphSnapshot?.hash ?? null,
+        contractCapsulePresent: evidenceBundle.provenance?.contractCapsule?.present,
+        contractCapsuleHash: evidenceBundle.provenance?.contractCapsule?.hash ?? null
+      }
+    });
+    const findingSourcePaths = /* @__PURE__ */ new Map();
+    for (const finding of evidenceBundle.findings ?? []) {
+      for (const sourcePath of evidenceBundleFindingSourcePaths(projectRoot, finding)) {
+        findingSourcePaths.set(sourcePath, [
+          ...findingSourcePaths.get(sourcePath) ?? [],
+          finding
+        ]);
+      }
+    }
+    for (const [sourcePath, findings] of findingSourcePaths) {
+      if (sources.some((source) => source.id === `src:${sourcePath}`)) continue;
+      sources.push({
+        id: `src:${sourcePath}`,
+        kind: "finding-source",
+        path: sourcePath,
+        hash: hashFile(join4(projectRoot, sourcePath)),
+        payload: {
+          findings: findings.map((finding) => finding.id),
+          codes: [
+            ...new Set(
+              findings.map((finding) => finding.code).filter((code) => typeof code === "string" && code.length > 0)
+            )
+          ]
+        }
+      });
+    }
+  }
+  const healthBaselineDiffPath = join4(projectRoot, ".decantr", "health-baseline-diff.json");
+  const healthBaselineDiff = readJsonFile3(healthBaselineDiffPath);
+  if (healthBaselineDiff) {
+    for (const changedFile of healthBaselineDiff.changedFiles ?? []) {
+      const sourcePath = existingProjectRelativePath(projectRoot, changedFile);
+      if (!sourcePath) continue;
+      if (sources.some((source) => source.id === `src:${sourcePath}`)) continue;
+      sources.push({
+        id: `src:${sourcePath}`,
+        kind: "baseline-changed-source",
+        path: sourcePath,
+        hash: hashFile(join4(projectRoot, sourcePath)),
+        payload: {
+          role: "baseline-changed-file"
+        }
+      });
+    }
+    sources.push({
+      id: "src:.decantr/health-baseline-diff.json",
+      kind: "health-baseline-diff",
+      path: ".decantr/health-baseline-diff.json",
+      hash: healthBaselineDiffSourceHash(healthBaselineDiff),
+      payload: {
+        changedFiles: healthBaselineDiff.changedFiles?.length ?? 0,
+        changedRoutes: healthBaselineDiff.changedRoutes?.length ?? 0,
+        changedScreenshots: healthBaselineDiff.changedScreenshots?.length ?? 0,
+        contractDrift: healthBaselineDiff.contractDrift?.length ?? 0
+      }
+    });
+  }
+  return dedupeSourceArtifacts(sources);
+}
+function dedupeSourceArtifacts(sources) {
+  return [...new Map(sources.map((source) => [source.id, source])).values()];
+}
+function sourceHash(sources) {
+  return hashJson(
+    sources.map((source) => ({
+      id: source.id,
+      kind: source.kind,
+      path: source.path,
+      hash: source.hash
+    }))
+  );
+}
+function evidenceBundleFindingNodeId(finding) {
+  return `find:${graphSlug(finding.id, "finding")}`;
+}
+function evidenceBundleEvidenceNodeId(finding, index) {
+  return `ev:finding:${graphSlug(finding.id, "finding")}:${index + 1}`;
+}
+function firstFindingSourceArtifactId(nodes, projectRoot, finding) {
+  for (const sourcePath of evidenceBundleFindingSourcePaths(projectRoot, finding)) {
+    const sourceId = `src:${sourcePath}`;
+    if (nodes.has(sourceId)) return sourceId;
+  }
+  return null;
+}
+function routeForScreenshotPath(visualManifest, screenshot) {
+  return visualManifest?.routes?.find((route) => route.screenshot === screenshot)?.route ?? null;
+}
+function augmentProjectGraph(snapshot, projectRoot, sources, componentReuseAudit = null) {
+  const nodes = new Map(snapshot.nodes.map((node) => [node.id, node]));
+  const edges = new Map(snapshot.edges.map((edge) => [graphEdgeKey(edge), edge]));
+  for (const source of sources) {
+    addNode(nodes, {
+      id: source.id,
+      type: "SourceArtifact",
+      payload: source
+    });
+  }
+  const localRules = readLocalRuleManifest(projectRoot);
+  if (localRules) {
+    const sourceId = "src:.decantr/rules.json";
+    for (const rule of localRules.rules ?? []) {
+      const ruleId = `rule:${graphSlug(rule.id, "local-rule")}`;
+      addNode(nodes, {
+        id: ruleId,
+        type: "LocalRule",
+        payload: {
+          ...rule,
+          manifest: {
+            status: localRules.status,
+            source: localRules.source,
+            enforcement: localRules.enforcement
+          }
+        }
+      });
+      addEdge(edges, {
+        src: ruleId,
+        dst: snapshot.project_id,
+        relation: "LOCAL_RULE_APPLIES_TO"
+      });
+      addEdge(edges, {
+        src: ruleId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+    }
+  }
+  const styleBridge = readStyleBridge(projectRoot);
+  if (styleBridge) {
+    const sourceId = "src:.decantr/style-bridge.json";
+    for (const mapping of styleBridge.mappings ?? []) {
+      const bridgeId = `bridge:${graphSlug(mapping.id, "style-bridge")}`;
+      addNode(nodes, {
+        id: bridgeId,
+        type: "StyleBridge",
+        payload: {
+          ...mapping,
+          manifest: {
+            status: styleBridge.status,
+            source: styleBridge.source,
+            adoption: styleBridge.adoption
+          }
+        }
+      });
+      addEdge(edges, {
+        src: bridgeId,
+        dst: snapshot.project_id,
+        relation: "STYLE_BRIDGE_MAPS_TO"
+      });
+      addEdge(edges, {
+        src: bridgeId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      for (const tokenHint of mapping.tokenHints ?? []) {
+        const tokenName = tokenHint.trim();
+        if (!tokenName) continue;
+        const tokenGraphName = tokenName.replace(/^var\((--[^),\s]+).*$/, "$1").replace(/^--/, "");
+        const tokenId = `tkn:${graphSlug(tokenGraphName, "style-token")}`;
+        addNode(nodes, {
+          id: tokenId,
+          type: "Token",
+          payload: {
+            name: tokenName,
+            source: "style-bridge",
+            mapping: mapping.id,
+            intent: mapping.decantrIntent,
+            projectAuthority: mapping.projectAuthority
+          }
+        });
+        addEdge(edges, {
+          src: bridgeId,
+          dst: tokenId,
+          relation: "STYLE_BRIDGE_MAPS_TO",
+          payload: {
+            kind: "token-hint",
+            token: tokenName
+          }
+        });
+        addEdge(edges, {
+          src: tokenId,
+          dst: sourceId,
+          relation: "NODE_DERIVED_FROM_SOURCE"
+        });
+      }
+    }
+  }
+  const analysis = readJsonFile3(
+    join4(projectRoot, ".decantr", "analysis.json")
+  );
+  if (analysis) {
+    const sourceId = "src:.decantr/analysis.json";
+    addEdge(edges, {
+      src: snapshot.project_id,
+      dst: sourceId,
+      relation: "NODE_DERIVED_FROM_SOURCE",
+      payload: {
+        role: "brownfield-analysis"
+      }
+    });
+    for (const route of analysis.routes?.routes ?? []) {
+      if (!route.path) continue;
+      const routeFile = projectRelativePath(projectRoot, route.file);
+      if (!routeFile || !nodes.has(`src:${routeFile}`)) continue;
+      const routeId = `rt:${route.path}`;
+      if (nodes.has(routeId)) {
+        addEdge(edges, {
+          src: routeId,
+          dst: `src:${routeFile}`,
+          relation: "NODE_DERIVED_FROM_SOURCE",
+          payload: {
+            role: "route-implementation",
+            strategy: analysis.routes?.strategy,
+            hasLayout: route.hasLayout ?? false
+          }
+        });
+      }
+      for (const edge of [...edges.values()]) {
+        if (edge.relation !== "PAGE_ROUTED_AT_ROUTE" || edge.dst !== routeId) continue;
+        addEdge(edges, {
+          src: edge.src,
+          dst: `src:${routeFile}`,
+          relation: "NODE_DERIVED_FROM_SOURCE",
+          payload: {
+            role: "page-implementation",
+            route: route.path,
+            strategy: analysis.routes?.strategy
+          }
+        });
+      }
+    }
+  }
+  for (const declaration of componentReuseAudit?.declarations ?? []) {
+    if (!declaration.reusable) continue;
+    const componentFile = projectRelativePath(projectRoot, declaration.file);
+    if (!componentFile || !nodes.has(`src:${componentFile}`)) continue;
+    const componentId = `cmp:${graphSlug(declaration.name, "component")}`;
+    addNode(nodes, {
+      id: componentId,
+      type: "Component",
+      payload: {
+        name: declaration.name,
+        source: "code",
+        exported: declaration.exported,
+        kind: declaration.kind
+      }
+    });
+    addEdge(edges, {
+      src: componentId,
+      dst: `src:${componentFile}`,
+      relation: "NODE_DERIVED_FROM_SOURCE",
+      payload: {
+        role: "component-implementation",
+        line: declaration.line
+      }
+    });
+  }
+  for (const importReference of componentReuseAudit?.imports ?? []) {
+    const importingFile = projectRelativePath(projectRoot, importReference.file);
+    if (!importingFile || !nodes.has(`src:${importingFile}`)) continue;
+    const importedFile = resolveImportSourcePath(projectRoot, importingFile, importReference.source);
+    if (!importedFile || !nodes.has(`src:${importedFile}`)) continue;
+    addEdge(edges, {
+      src: `src:${importingFile}`,
+      dst: `src:${importedFile}`,
+      relation: "SOURCE_IMPORTS_SOURCE",
+      payload: {
+        source: importReference.source,
+        line: importReference.line,
+        defaultImport: importReference.defaultImport,
+        namespaceImport: importReference.namespaceImport,
+        imported: importReference.imported,
+        localNames: importReference.localNames
+      }
+    });
+  }
+  const visualManifest = readJsonFile3(
+    join4(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+  );
+  if (visualManifest) {
+    const sourceId = "src:.decantr/evidence/visual-manifest.json";
+    for (const [index, route] of (visualManifest.routes ?? []).entries()) {
+      const routeSlug = route.route === "/" ? "root" : graphSlug(route.route || `route-${index + 1}`, `route-${index + 1}`);
+      const evidenceId = `ev:visual:${routeSlug}`;
+      const routeId = `rt:${route.route}`;
+      const anchorId = nodes.has(routeId) ? routeId : snapshot.project_id;
+      addNode(nodes, {
+        id: evidenceId,
+        type: "Evidence",
+        payload: {
+          kind: "route-screenshot",
+          route: route.route,
+          url: route.url,
+          screenshot: route.screenshot,
+          screenshotHash: route.screenshotHash ?? null,
+          status: route.status,
+          error: route.error,
+          localOnly: visualManifest.localOnly ?? true
+        }
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      if (route.screenshot && nodes.has(`src:${route.screenshot}`)) {
+        addEdge(edges, {
+          src: evidenceId,
+          dst: `src:${route.screenshot}`,
+          relation: "NODE_DERIVED_FROM_SOURCE",
+          payload: {
+            role: "screenshot"
+          }
+        });
+      }
+      addEdge(edges, {
+        src: evidenceId,
+        dst: anchorId,
+        relation: "EVIDENCE_CAPTURED_FOR",
+        payload: {
+          kind: "visual-route",
+          route: route.route,
+          status: route.status
+        }
+      });
+      if (nodes.has(routeId)) {
+        for (const edge of [...edges.values()]) {
+          if (edge.relation === "PAGE_ROUTED_AT_ROUTE" && edge.dst === routeId) {
+            addEdge(edges, {
+              src: evidenceId,
+              dst: edge.src,
+              relation: "EVIDENCE_CAPTURED_FOR",
+              payload: {
+                kind: "visual-page",
+                route: route.route,
+                status: route.status
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  const evidenceBundle = readJsonFile3(
+    join4(projectRoot, ".decantr", "evidence", "latest.json")
+  );
+  if (evidenceBundle) {
+    const sourceId = "src:.decantr/evidence/latest.json";
+    for (const finding of evidenceBundle.findings ?? []) {
+      const findingId = evidenceBundleFindingNodeId(finding);
+      const fallbackSourceAnchorId = firstFindingSourceArtifactId(nodes, projectRoot, finding);
+      const anchoredAt = finding.graph?.node_id && nodes.has(finding.graph.node_id) ? finding.graph.node_id : fallbackSourceAnchorId ?? finding.graph?.node_id;
+      addNode(nodes, {
+        id: findingId,
+        type: "Finding",
+        payload: {
+          id: finding.id,
+          code: finding.code,
+          source: finding.source,
+          category: finding.category,
+          severity: finding.severity,
+          message: finding.message,
+          target: finding.target,
+          rule: finding.rule,
+          suggestedFix: finding.suggestedFix,
+          remediationSummary: finding.remediationSummary,
+          commands: finding.commands,
+          promptCommand: finding.promptCommand,
+          anchored_at: anchoredAt,
+          graph: stableFindingGraphAnchor(finding),
+          repair_id: finding.repair?.id,
+          repair_plan_id: finding.repairPlan?.id
+        }
+      });
+      addEdge(edges, {
+        src: findingId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      if (finding.graph?.node_id && nodes.has(finding.graph.node_id)) {
+        addEdge(edges, {
+          src: findingId,
+          dst: finding.graph.node_id,
+          relation: "FINDING_ANCHORED_AT",
+          payload: {
+            confidence: finding.graph.confidence,
+            reason: finding.graph.reason
+          }
+        });
+      } else if (fallbackSourceAnchorId) {
+        addEdge(edges, {
+          src: findingId,
+          dst: fallbackSourceAnchorId,
+          relation: "FINDING_ANCHORED_AT",
+          payload: {
+            confidence: "inferred",
+            reason: "finding repair targets or evidence matched a SourceArtifact node"
+          }
+        });
+      }
+      if (finding.rule) {
+        const ruleId = `rule:${graphSlug(finding.rule, "local-rule")}`;
+        if (nodes.has(ruleId)) {
+          addEdge(edges, {
+            src: findingId,
+            dst: ruleId,
+            relation: "FINDING_VIOLATES_RULE"
+          });
+        }
+      }
+      if (finding.repair?.id) {
+        const repairId = `repair:${graphSlug(finding.repair.id, "repair")}`;
+        addNode(nodes, {
+          id: repairId,
+          type: "Repair",
+          payload: {
+            id: finding.repair.id,
+            payload: finding.repair.payload,
+            plan_id: finding.repairPlan?.id,
+            actions: finding.repairPlan?.actions,
+            readTargets: finding.repairPlan?.readTargets,
+            commands: finding.repairPlan?.commands
+          }
+        });
+        addEdge(edges, {
+          src: repairId,
+          dst: findingId,
+          relation: "REPAIR_FIXES_FINDING"
+        });
+        addEdge(edges, {
+          src: repairId,
+          dst: sourceId,
+          relation: "NODE_DERIVED_FROM_SOURCE"
+        });
+      }
+      for (const [index, evidenceText] of (finding.evidence ?? []).entries()) {
+        const evidenceId = evidenceBundleEvidenceNodeId(finding, index);
+        addNode(nodes, {
+          id: evidenceId,
+          type: "Evidence",
+          payload: {
+            kind: "finding-evidence",
+            text: evidenceText,
+            finding: finding.id
+          }
+        });
+        addEdge(edges, {
+          src: evidenceId,
+          dst: findingId,
+          relation: "EVIDENCE_SUPPORTS_FINDING"
+        });
+        addEdge(edges, {
+          src: evidenceId,
+          dst: sourceId,
+          relation: "NODE_DERIVED_FROM_SOURCE"
+        });
+      }
+    }
+  }
+  const healthBaselineDiff = readJsonFile3(
+    join4(projectRoot, ".decantr", "health-baseline-diff.json")
+  );
+  if (healthBaselineDiff) {
+    const sourceId = "src:.decantr/health-baseline-diff.json";
+    const manifestForScreenshotRoutes = readJsonFile3(
+      join4(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+    );
+    for (const route of healthBaselineDiff.changedRoutes ?? []) {
+      const evidenceId = `ev:baseline:route:${graphSlug(route, "route")}`;
+      const routeId = `rt:${route}`;
+      const anchorId = nodes.has(routeId) ? routeId : snapshot.project_id;
+      addNode(nodes, {
+        id: evidenceId,
+        type: "Evidence",
+        payload: {
+          kind: "baseline-route-impact",
+          route
+        }
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: anchorId,
+        relation: "EVIDENCE_CAPTURED_FOR",
+        payload: { kind: "baseline-route-impact" }
+      });
+    }
+    for (const changedFile of healthBaselineDiff.changedFiles ?? []) {
+      const sourcePath = projectRelativePath(projectRoot, changedFile);
+      if (!sourcePath) continue;
+      const sourceArtifactId = `src:${sourcePath}`;
+      if (!nodes.has(sourceArtifactId)) continue;
+      const evidenceId = `ev:baseline:file:${graphSlug(sourcePath, "file")}`;
+      addNode(nodes, {
+        id: evidenceId,
+        type: "Evidence",
+        payload: {
+          kind: "baseline-file-impact",
+          file: sourcePath
+        }
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceArtifactId,
+        relation: "EVIDENCE_CAPTURED_FOR",
+        payload: { kind: "baseline-file-impact" }
+      });
+    }
+    for (const [index, screenshot] of (healthBaselineDiff.changedScreenshots ?? []).entries()) {
+      const route = routeForScreenshotPath(manifestForScreenshotRoutes, screenshot);
+      const routeId = route ? `rt:${route}` : null;
+      const evidenceId = `ev:baseline:screenshot:${index + 1}`;
+      addNode(nodes, {
+        id: evidenceId,
+        type: "Evidence",
+        payload: {
+          kind: "baseline-screenshot-drift",
+          screenshot,
+          route
+        }
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: routeId && nodes.has(routeId) ? routeId : snapshot.project_id,
+        relation: "EVIDENCE_CAPTURED_FOR",
+        payload: { kind: "baseline-screenshot-drift", route }
+      });
+    }
+    for (const [index, drift] of (healthBaselineDiff.contractDrift ?? []).entries()) {
+      const evidenceId = `ev:baseline:contract:${index + 1}`;
+      addNode(nodes, {
+        id: evidenceId,
+        type: "Evidence",
+        payload: {
+          kind: "baseline-contract-drift",
+          text: drift
+        }
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: sourceId,
+        relation: "NODE_DERIVED_FROM_SOURCE"
+      });
+      addEdge(edges, {
+        src: evidenceId,
+        dst: snapshot.project_id,
+        relation: "EVIDENCE_CAPTURED_FOR",
+        payload: { kind: "baseline-contract-drift" }
+      });
+    }
+  }
+  return normalizeGraphSnapshot({
+    ...snapshot,
+    nodes: [...nodes.values()],
+    edges: [...edges.values()]
+  });
+}
+function pathForDisplay(projectRoot, path, displayRoot) {
+  if (!displayRoot) return path.replace(`${projectRoot}/`, "");
+  const relativePath = relative2(displayRoot, path).replace(/\\/g, "/");
+  if (relativePath && !relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
+    return relativePath;
+  }
+  return path;
+}
+function artifactMatches(path, value) {
+  const existing = readJsonFile3(path);
+  return existing ? stableJson(existing) === stableJson(value) : false;
+}
+function buildGraphArtifacts(projectRoot, options = {}) {
+  const essencePath = join4(projectRoot, "decantr.essence.json");
+  if (!existsSync4(essencePath)) {
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync4(essencePath, "utf-8"));
+  if (!isV42(parsed)) {
+    throw new Error("Active graph workflows require Essence v4.0.0.");
+  }
+  const essence = parsed;
+  let paths = graphPaths(projectRoot);
+  const componentReuseAudit = auditComponentReuse(
+    projectRoot,
+    collectProjectSourceFiles(projectRoot)
+  );
+  const sources = sourceArtifacts(projectRoot, componentReuseAudit);
+  const combinedSourceHash = sourceHash(sources);
+  const previousSnapshot = readJsonFile3(paths.snapshot);
+  const createdAt = previousSnapshot?.source_hash === combinedSourceHash ? previousSnapshot.created_at : (/* @__PURE__ */ new Date()).toISOString();
+  const snapshotId = `graph:${combinedSourceHash.replace(/^sha256:/, "").slice(0, 12)}`;
+  paths = withSnapshotHistoryPath(paths, snapshotId);
+  const baseSnapshot = buildGraphSnapshotFromEssence(essence, {
+    snapshotId,
+    parentId: previousSnapshot && previousSnapshot.id !== snapshotId ? previousSnapshot.id : void 0,
+    sourceHash: combinedSourceHash,
+    createdAt,
+    sourceArtifact: sources[0]
+  });
+  const snapshot = augmentProjectGraph(baseSnapshot, projectRoot, sources, componentReuseAudit);
+  const diff = previousSnapshot ? diffGraphSnapshots(previousSnapshot, snapshot) : {
+    $schema: GRAPH_DIFF_SCHEMA_URL,
+    id: `diff:${snapshot.id}:${snapshot.id}`,
+    from: snapshot.id,
+    to: snapshot.id,
+    ops: []
+  };
+  const capsule = buildContractCapsuleFromSnapshot(snapshot, {
+    createdAt: snapshot.created_at,
+    sourceArtifactLimit: options.capsuleSourceLimit
+  });
+  const manifest = {
+    $schema: GRAPH_MANIFEST_SCHEMA_URL,
+    schema_version: GRAPH_SCHEMA_VERSION,
+    snapshot_id: snapshot.id,
+    project_id: snapshot.project_id,
+    generated_at: snapshot.created_at,
+    sources,
+    outputs: {
+      snapshot: ".decantr/graph/graph.snapshot.json",
+      history: ".decantr/graph/snapshots",
+      diff: ".decantr/graph/graph.diff.json"
+    },
+    warnings: []
+  };
+  const staleArtifacts = [
+    [paths.snapshot, snapshot],
+    [paths.snapshotHistory, snapshot],
+    [paths.manifest, manifest],
+    [paths.diff, diff],
+    [paths.capsule, capsule]
+  ].filter(([path, value]) => !artifactMatches(path, value)).map(([path]) => path);
+  return {
+    projectRoot,
+    paths,
+    snapshot,
+    manifest,
+    diff,
+    capsule,
+    staleArtifacts
+  };
+}
+function writeGraphArtifacts(artifacts) {
+  mkdirSync3(artifacts.paths.graphDir, { recursive: true });
+  mkdirSync3(artifacts.paths.snapshotsDir, { recursive: true });
+  writeFileSync3(artifacts.paths.snapshot, formatJson(artifacts.snapshot), "utf-8");
+  writeFileSync3(artifacts.paths.snapshotHistory, formatJson(artifacts.snapshot), "utf-8");
+  writeFileSync3(artifacts.paths.manifest, formatJson(artifacts.manifest), "utf-8");
+  writeFileSync3(artifacts.paths.diff, formatJson(artifacts.diff), "utf-8");
+  writeFileSync3(artifacts.paths.capsule, formatJson(artifacts.capsule), "utf-8");
+}
+function comparisonPayload(diff, includeOps = false, limit = void 0) {
+  const boundedLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? limit : 25;
+  return {
+    from: diff.from,
+    to: diff.to,
+    summary: summarizeGraphDiff(diff),
+    ...includeOps ? {
+      ops: diff.ops.slice(0, boundedLimit),
+      truncated: diff.ops.length > boundedLimit,
+      limit: boundedLimit
+    } : {}
+  };
+}
+function summaryPayload(artifacts, routeContext, impactContext, selected, comparison, impactSelection) {
+  return {
+    projectRoot: artifacts.projectRoot,
+    graphDir: artifacts.paths.graphDir,
+    snapshot: {
+      id: artifacts.snapshot.id,
+      schema_version: artifacts.snapshot.schema_version,
+      source_hash: 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,
+      history: pathForDisplay(artifacts.projectRoot, artifacts.paths.snapshotHistory)
+    },
+    capsule: {
+      cache_key: artifacts.capsule.cache_key,
+      routes: artifacts.capsule.summary.routes,
+      components: artifacts.capsule.summary.components,
+      tokens: artifacts.capsule.summary.tokens,
+      local_rules: artifacts.capsule.summary.local_rules,
+      style_bridge: artifacts.capsule.summary.style_bridge,
+      source_artifacts: artifacts.capsule.summary.source_artifacts,
+      source_artifact_limit: artifacts.capsule.source_artifact_limit,
+      source_artifacts_truncated: artifacts.capsule.source_artifacts_truncated,
+      open_findings: artifacts.capsule.summary.open_findings
+    },
+    diff: {
+      id: artifacts.diff.id,
+      from: artifacts.diff.from,
+      to: artifacts.diff.to,
+      ops: artifacts.diff.ops.length,
+      summary: summarizeGraphDiff(artifacts.diff)
+    },
+    sources: artifacts.manifest.sources.length,
+    staleArtifacts: artifacts.staleArtifacts.map(
+      (path) => pathForDisplay(artifacts.projectRoot, path)
+    ),
+    selectedSnapshot: selected ? {
+      selector: selected.selector,
+      path: pathForDisplay(artifacts.projectRoot, selected.path),
+      id: selected.snapshot.id,
+      source_hash: selected.snapshot.source_hash,
+      nodes: selected.snapshot.summary.nodes,
+      edges: selected.snapshot.summary.edges,
+      findings: selected.snapshot.summary.findings,
+      evidence: selected.snapshot.summary.evidence
+    } : void 0,
+    comparison,
+    routeContext: routeContextPayload(routeContext ?? null, routeContext ? optionsRoute(routeContext) : void 0),
+    impactContext: impactContextPayload(impactContext ?? null, impactSelection)
+  };
+}
+function optionsRoute(routeContext) {
+  return graphPayloadString(routeContext.routeNode.payload, "path") ?? routeContext.routeNode.id.replace(/^rt:/, "");
+}
+function printGraphSummary(artifacts, displayRoot) {
+  console.log(`${GREEN}Generated Decantr typed graph artifacts:${RESET}`);
+  for (const path of [
+    artifacts.paths.snapshot,
+    artifacts.paths.snapshotHistory,
+    artifacts.paths.manifest,
+    artifacts.paths.diff,
+    artifacts.paths.capsule
+  ]) {
+    console.log(`  ${DIM}${pathForDisplay(artifacts.projectRoot, path, displayRoot)}${RESET}`);
+  }
+  console.log("");
+  console.log(
+    `${GREEN}Snapshot:${RESET} ${artifacts.snapshot.summary.nodes} nodes, ${artifacts.snapshot.summary.edges} edges, ${artifacts.diff.ops.length} diff ops`
+  );
+  const diffSummary = summarizeGraphDiff(artifacts.diff);
+  const typedDiffHints = [
+    diffSummary.findings.added > 0 ? `${diffSummary.findings.added} finding added` : null,
+    diffSummary.findings.resolved > 0 ? `${diffSummary.findings.resolved} finding resolved` : null,
+    diffSummary.evidence.added > 0 ? `${diffSummary.evidence.added} evidence added` : null
+  ].filter(Boolean);
+  if (typedDiffHints.length > 0) {
+    console.log(`${GREEN}Diff:${RESET} ${typedDiffHints.join(", ")}`);
+  }
+  console.log(`${GREEN}Sources:${RESET} ${artifacts.manifest.sources.length} local artifact(s)`);
+  console.log(
+    `${GREEN}Capsule:${RESET} ${artifacts.capsule.summary.routes} routes, ${artifacts.capsule.summary.local_rules} local rules, ${artifacts.capsule.summary.style_bridge} style bridge mappings`
+  );
+}
+function graphAvailableRoutes(snapshot) {
+  return snapshot.nodes.filter((node) => node.type === "Route").map((node) => graphPayloadString(node.payload, "path") ?? node.id.replace(/^rt:/, "")).sort();
+}
+function routeContextPayload(routeContext, route) {
+  if (!route) return void 0;
+  if (!routeContext) {
+    return {
+      route,
+      found: false
+    };
+  }
+  return {
+    route,
+    found: true,
+    snapshotId: routeContext.snapshotId,
+    sourceHash: routeContext.sourceHash,
+    ranking: routeContext.ranking,
+    summary: routeContext.summary,
+    ids: routeContext.ids,
+    ranked: routeContext.ranked,
+    nodes: routeContext.nodes,
+    edges: routeContext.edges
+  };
+}
+function graphSourceNodeIdForFile(projectRoot, snapshot, file) {
+  if (!file) return null;
+  const trimmed = file.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("src:") && snapshot.nodes.some((node) => node.id === trimmed)) {
+    return trimmed;
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  const directRelative = projectRelativePath(projectRoot, trimmed);
+  if (directRelative) candidates.add(directRelative);
+  try {
+    const workspaceRelative = projectRelativePath(projectRoot, resolvePathFromCwd(trimmed));
+    if (workspaceRelative) candidates.add(workspaceRelative);
+  } catch {
+  }
+  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 resolvePathFromCwd(path) {
+  return isAbsolute2(path) ? path : join4(process.cwd(), path);
+}
+function impactContextPayload(impactContext, selection) {
+  if (!selection) return void 0;
+  if (!impactContext) {
+    return {
+      node: selection.node,
+      file: selection.file,
+      resolvedNodeIds: selection.resolvedNodeIds,
+      found: false
+    };
+  }
+  return {
+    node: selection.node,
+    file: selection.file,
+    resolvedNodeIds: selection.resolvedNodeIds,
+    found: true,
+    snapshotId: impactContext.snapshotId,
+    sourceHash: impactContext.sourceHash,
+    missingNodeIds: impactContext.missingNodeIds,
+    seedNodes: impactContext.seedNodes,
+    ranking: impactContext.ranking,
+    summary: impactContext.summary,
+    ids: impactContext.ids,
+    ranked: impactContext.ranked,
+    nodes: impactContext.nodes,
+    edges: impactContext.edges
+  };
+}
+function printRouteContextSummary(routeContext) {
+  const routeSummary = routeContext.summary;
+  const hints = [
+    routeContext.ids.patterns.length > 0 ? `patterns ${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("");
+  console.log(
+    `${GREEN}Route subgraph:${RESET} ${routeSummary.nodes} nodes, ${routeSummary.edges} edges${hints.length > 0 ? `; ${hints.join("; ")}` : ""}`
+  );
+  const ranked = routeContext.ranked.slice(0, 8);
+  if (ranked.length > 0) {
+    console.log(
+      `${GREEN}Top nodes:${RESET} ${ranked.map((node) => `${node.id} (${node.reason})`).join(", ")}`
+    );
+  }
+}
+function printImpactContextSummary(impactContext) {
+  const summary = impactContext.summary;
+  const hints = [
+    summary.routes > 0 ? `${summary.routes} route(s)` : null,
+    summary.pages > 0 ? `${summary.pages} page(s)` : null,
+    summary.components > 0 ? `${summary.components} component(s)` : null,
+    summary.openFindings > 0 ? `${summary.openFindings} finding(s)` : null,
+    summary.evidence > 0 ? `${summary.evidence} evidence node(s)` : null
+  ].filter(Boolean);
+  console.log("");
+  console.log(
+    `${GREEN}Impact subgraph:${RESET} ${summary.nodes} nodes, ${summary.edges} edges${summary.truncated ? ` (truncated from ${summary.totalNodes}/${summary.totalEdges})` : ""}${hints.length > 0 ? `; ${hints.join("; ")}` : ""}`
+  );
+  const ranked = impactContext.ranked.slice(0, 8);
+  if (ranked.length > 0) {
+    console.log(
+      `${GREEN}Top impact nodes:${RESET} ${ranked.map((node) => `${node.id} (${node.reason})`).join(", ")}`
+    );
+  }
+}
+function printSelectedSnapshotSummary(artifacts, selected, comparison, displayRoot) {
+  if (selected.selector !== "current") {
+    console.log("");
+    console.log(
+      `${GREEN}Selected snapshot:${RESET} ${selected.snapshot.id} (${selected.snapshot.summary.nodes} nodes, ${selected.snapshot.summary.edges} edges)`
+    );
+    console.log(
+      `  ${DIM}${pathForDisplay(artifacts.projectRoot, selected.path, displayRoot)}${RESET}`
+    );
+  }
+  if (comparison) {
+    console.log("");
+    console.log(
+      `${GREEN}Snapshot diff:${RESET} ${comparison.from ?? "empty"} -> ${comparison.to}, ${comparison.summary.total} op(s)`
+    );
+    const hints = [
+      comparison.summary.findings.added > 0 ? `${comparison.summary.findings.added} finding added` : null,
+      comparison.summary.findings.resolved > 0 ? `${comparison.summary.findings.resolved} finding resolved` : null,
+      comparison.summary.evidence.added > 0 ? `${comparison.summary.evidence.added} evidence added` : null
+    ].filter(Boolean);
+    if (hints.length > 0) {
+      console.log(`${GREEN}Diff detail:${RESET} ${hints.join(", ")}`);
+    }
+  }
+}
+function cmdGraphHelp() {
+  console.log(`decantr graph [--project <path>] [--route <route>] [--node <id>] [--file <path>] [--task <text>] [--snapshot-id <id>] [--compare-to <id>] [--capsule-source-limit <count>] [--check] [--json]
+
+Build Decantr's typed Contract graph artifacts from the project-owned Essence,
+accepted local rules, accepted style bridge, Brownfield analysis, and local evidence.
+
+Outputs:
+  .decantr/graph/graph.snapshot.json
+  .decantr/graph/snapshots/<snapshot-id>.json
+  .decantr/graph/graph.manifest.json
+  .decantr/graph/graph.diff.json
+  .decantr/graph/contract-capsule.json
+
+Options:
+  --project <path>  Run against a workspace app/package
+  --route <route>    Include the route-scoped graph subgraph in output
+  --node <id>        Include impact context for a graph node, such as cmp:button
+  --file <path>      Include impact context for a source file, such as src/app/page.tsx
+  --impact           Require impact context when --node or --file is present
+  --task <text>      Boost route/impact ranking with task keywords
+  --snapshot-id <id> Inspect "current" or a snapshot from .decantr/graph/snapshots
+  --compare-to <id>  Diff the selected snapshot against another snapshot or "current"
+  --include-diff-ops Include bounded diff operations in JSON output
+  --limit <count>    Limit JSON diff operations or impact nodes
+  --capsule-source-limit <count>
+                    Limit SourceArtifact path handles in contract-capsule.json
+  --check           Verify artifacts are present and current without writing
+  --json            Print machine-readable summary
+`);
+}
+async function cmdGraph(projectRoot = process.cwd(), options = {}) {
+  let artifacts = null;
+  try {
+    artifacts = buildGraphArtifacts(projectRoot, {
+      capsuleSourceLimit: options.capsuleSourceLimit
+    });
+  } catch (error) {
+    console.error(`${RED}${error.message}${RESET}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!artifacts) {
+    console.error(`${RED}No decantr.essence.json found. Run \`decantr init\` first.${RESET}`);
+    process.exitCode = 1;
+    return;
+  }
+  let selectedSnapshot;
+  let comparison;
+  try {
+    selectedSnapshot = readGraphSnapshotSelection(artifacts, options.snapshotId);
+    if (options.compareTo) {
+      const baseline = readGraphSnapshotSelection(artifacts, options.compareTo);
+      comparison = comparisonPayload(
+        diffGraphSnapshots(baseline.snapshot, selectedSnapshot.snapshot),
+        options.includeDiffOps,
+        options.limit
+      );
+    }
+  } catch (error) {
+    console.error(`${RED}${error.message}${RESET}`);
+    process.exitCode = 1;
+    return;
+  }
+  const routeContext = options.route ? buildGraphRouteContext(selectedSnapshot.snapshot, options.route, { task: options.task }) : void 0;
+  if (options.route && !routeContext) {
+    console.error(`${RED}Route not found in Decantr typed graph: ${options.route}${RESET}`);
+    console.error(
+      `${DIM}Known routes: ${graphAvailableRoutes(selectedSnapshot.snapshot).join(", ") || "none"}${RESET}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const fileNodeId = graphSourceNodeIdForFile(projectRoot, selectedSnapshot.snapshot, options.file);
+  if (options.file && !fileNodeId) {
+    console.error(`${RED}Source file not found in Decantr typed graph: ${options.file}${RESET}`);
+    console.error(
+      `${DIM}Run \`decantr analyze\` and \`decantr graph\` after the file is visible in Brownfield route or component evidence.${RESET}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (options.impact && !options.node && !options.file) {
+    console.error(`${RED}--impact requires --node <graph-node-id> or --file <path>.${RESET}`);
+    process.exitCode = 1;
+    return;
+  }
+  const impactSeedIds = [
+    ...new Set([options.node, fileNodeId].filter((value) => Boolean(value)))
+  ];
+  const impactSelection = impactSeedIds.length > 0 ? {
+    node: options.node,
+    file: options.file,
+    resolvedNodeIds: impactSeedIds
+  } : void 0;
+  const impactContext = impactSeedIds.length > 0 ? buildGraphImpactContext(selectedSnapshot.snapshot, impactSeedIds, {
+    task: options.task,
+    limit: options.limit
+  }) : void 0;
+  if (impactSeedIds.length > 0 && !impactContext) {
+    console.error(
+      `${RED}Impact seed not found in Decantr typed graph: ${impactSeedIds.join(", ")}${RESET}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (options.check) {
+    const stale = artifacts.staleArtifacts.length > 0;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ...summaryPayload(
+              artifacts,
+              routeContext,
+              impactContext,
+              selectedSnapshot,
+              comparison,
+              impactSelection
+            ),
+            stale
+          },
+          null,
+          2
+        )
+      );
+    } else if (stale) {
+      console.log(`${RED}Decantr typed graph artifacts are stale.${RESET}`);
+      for (const path of artifacts.staleArtifacts) {
+        console.log(`  ${pathForDisplay(artifacts.projectRoot, path, options.displayRoot)}`);
+      }
+      console.log(`${DIM}Run \`decantr graph\` to regenerate graph artifacts.${RESET}`);
+    } else {
+      console.log(`${GREEN}Decantr typed graph artifacts are current.${RESET}`);
+    }
+    printSelectedSnapshotSummary(artifacts, selectedSnapshot, comparison, options.displayRoot);
+    if (routeContext) printRouteContextSummary(routeContext);
+    if (impactContext) printImpactContextSummary(impactContext);
+    if (stale) process.exitCode = 1;
+    return;
+  }
+  writeGraphArtifacts(artifacts);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...summaryPayload(
+            artifacts,
+            routeContext,
+            impactContext,
+            selectedSnapshot,
+            comparison,
+            impactSelection
+          ),
+          wrote: true
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    printGraphSummary(artifacts, options.displayRoot);
+    printSelectedSnapshotSummary(artifacts, selectedSnapshot, comparison, options.displayRoot);
+    if (routeContext) printRouteContextSummary(routeContext);
+    if (impactContext) printImpactContextSummary(impactContext);
+  }
+}
+
+// src/commands/health.ts
+var BOLD = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var RESET2 = "\x1B[0m";
+var RED2 = "\x1B[31m";
+var GREEN2 = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+var PROJECT_HEALTH_SCHEMA_URL = "https://decantr.ai/schemas/project-health-report.v1.json";
+var DEFAULT_HEALTH_CI_WORKFLOW_PATH = ".github/workflows/decantr-health.yml";
+var DEFAULT_HEALTH_CI_REPORT_PATH = "decantr-health.md";
+var DEFAULT_HEALTH_CI_JSON_PATH = "decantr-health.json";
+var DEFAULT_HEALTH_CI_CLI_VERSION = "latest";
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+function readProjectMetadata(projectRoot) {
+  const projectJsonPath = join5(projectRoot, ".decantr", "project.json");
+  if (!existsSync5(projectJsonPath)) {
+    return { workflowMode: null, adoptionMode: null, autoBrownfield: false };
+  }
+  try {
+    const data = JSON.parse(readFileSync5(projectJsonPath, "utf-8"));
+    const workflowMode = typeof data.initialized?.workflowMode === "string" ? data.initialized.workflowMode : null;
+    const adoptionMode = typeof data.initialized?.adoptionMode === "string" ? data.initialized.adoptionMode : null;
+    return {
+      workflowMode,
+      adoptionMode,
+      autoBrownfield: workflowMode === "brownfield-attach"
+    };
+  } catch {
+    return { workflowMode: null, adoptionMode: null, autoBrownfield: false };
+  }
+}
+function loadHealthTemplate(name) {
+  const fromDist = join5(__dirname, "..", "src", "templates", name);
+  if (existsSync5(fromDist)) return readFileSync5(fromDist, "utf-8");
+  const fromSrc = join5(__dirname, "..", "templates", name);
+  if (existsSync5(fromSrc)) return readFileSync5(fromSrc, "utf-8");
+  const fromCommandSrc = join5(__dirname, "..", "..", "templates", name);
+  if (existsSync5(fromCommandSrc)) return readFileSync5(fromCommandSrc, "utf-8");
+  throw new Error(`Template not found: ${name}`);
+}
+function renderTemplate(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+function normalizeCliPackageSpecifier(version) {
+  const value = (version || DEFAULT_HEALTH_CI_CLI_VERSION).trim();
+  if (!value) return `@decantr/cli@${DEFAULT_HEALTH_CI_CLI_VERSION}`;
+  const versionToken = value.startsWith("@decantr/cli@") ? value.slice("@decantr/cli@".length) : value;
+  if (!/^[A-Za-z0-9._~^*-]+$/.test(versionToken)) {
+    throw new Error(
+      "Invalid --cli-version value. Use a package version or dist-tag such as latest, 2.0.0, or next."
+    );
+  }
+  return `@decantr/cli@${versionToken}`;
+}
+function normalizeHealthFailOn(value) {
+  const failOn = value ?? "error";
+  if (!["error", "warn", "none"].includes(failOn)) {
+    throw new Error("Invalid --fail-on value. Use error, warn, or none.");
+  }
+  return failOn;
+}
+function validateWorkflowPath(value) {
+  const normalized = value.trim();
+  if (!normalized || normalized.startsWith("/") || normalized.startsWith("-") || normalized.includes("..") || normalized.includes("\\") || /\s/.test(normalized)) {
+    throw new Error(
+      "Invalid --workflow-path value. Use a relative path without spaces or parent-directory segments."
+    );
+  }
+  return normalized;
+}
+function validateArtifactPath(value, flag) {
+  const normalized = value.trim();
+  if (!normalized || normalized.startsWith("/") || normalized.startsWith("-") || normalized.includes("..") || normalized.includes("\\") || /\s/.test(normalized)) {
+    throw new Error(
+      `Invalid ${flag} value. Use a relative artifact path without spaces or parent-directory segments.`
+    );
+  }
+  return normalized;
+}
+function validateProjectPath(value) {
+  if (value === void 0) return void 0;
+  const raw = value.trim();
+  if (!raw || raw === ".") return void 0;
+  const normalized = raw.replace(/^\.\/+/, "").replace(/\/+$/, "");
+  if (!normalized || normalized.startsWith("/") || normalized.startsWith("-") || normalized.includes("..") || normalized.includes("\\") || /\s/.test(normalized) || !/^[A-Za-z0-9._@/-]+$/.test(normalized)) {
+    throw new Error(
+      "Invalid --project value. Use a relative project path without spaces or parent-directory segments."
+    );
+  }
+  const segments = normalized.split("/");
+  if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error(
+      "Invalid --project value. Use a relative project path without empty or parent-directory segments."
+    );
+  }
+  return normalized;
+}
+function prefixArtifactPath(projectPath, artifactPath) {
+  return projectPath ? `${projectPath}/${artifactPath}` : artifactPath;
+}
+function renderProjectHealthCiWorkflow(options = {}) {
+  const failOn = normalizeHealthFailOn(options.failOn);
+  const projectPath = options.workspace ? void 0 : validateProjectPath(options.projectPath);
+  const reportPath = validateArtifactPath(
+    options.reportPath || (options.workspace ? ".decantr/workspace-health.md" : DEFAULT_HEALTH_CI_REPORT_PATH),
+    "--report-path"
+  );
+  const jsonPath = validateArtifactPath(
+    options.jsonPath || (options.workspace ? ".decantr/workspace-health.json" : DEFAULT_HEALTH_CI_JSON_PATH),
+    "--json-path"
+  );
+  const template = loadHealthTemplate("decantr-health.workflow.yml.template");
+  return renderTemplate(template, {
+    CLI_PACKAGE: normalizeCliPackageSpecifier(options.cliVersion),
+    FAIL_ON: failOn,
+    HEALTH_COMMAND: options.workspace ? "workspace health" : "health",
+    PROJECT_WORKING_DIRECTORY: projectPath ? `        working-directory: ${projectPath}
+` : "",
+    REPORT_PATH: reportPath,
+    JSON_PATH: jsonPath,
+    REPORT_ARTIFACT_PATH: prefixArtifactPath(projectPath, reportPath),
+    JSON_ARTIFACT_PATH: prefixArtifactPath(projectPath, jsonPath)
+  });
+}
+function writeProjectHealthCiWorkflow(projectRoot, options = {}) {
+  const workflowRelativePath = validateWorkflowPath(
+    options.workflowPath || DEFAULT_HEALTH_CI_WORKFLOW_PATH
+  );
+  const workflowPath = join5(projectRoot, workflowRelativePath);
+  const alreadyExists = existsSync5(workflowPath);
+  if (alreadyExists && !options.force) {
+    throw new Error(
+      `${workflowRelativePath} already exists. Re-run with --force to replace it, or use --workflow-path <file>.`
+    );
+  }
+  mkdirSync4(dirname3(workflowPath), { recursive: true });
+  writeFileSync4(workflowPath, renderProjectHealthCiWorkflow(options), "utf-8");
+  const projectPath = options.workspace ? void 0 : validateProjectPath(options.projectPath);
+  const result = {
+    path: workflowRelativePath,
+    created: !alreadyExists,
+    cliPackage: normalizeCliPackageSpecifier(options.cliVersion),
+    failOn: normalizeHealthFailOn(options.failOn)
+  };
+  if (projectPath) result.projectPath = projectPath;
+  if (options.workspace) result.workspace = true;
+  return result;
+}
+function collectDeclaredRoutes(essence) {
+  if (!essence || typeof essence !== "object") return [];
+  const record = essence;
+  const blueprint = record.blueprint;
+  if (!blueprint || typeof blueprint !== "object") return [];
+  const bp = blueprint;
+  const routes = /* @__PURE__ */ new Set();
+  if (bp.routes && typeof bp.routes === "object" && !Array.isArray(bp.routes)) {
+    for (const route of Object.keys(bp.routes)) {
+      routes.add(route);
+    }
+  }
+  const flatPages = Array.isArray(bp.pages) ? bp.pages : [];
+  for (const page of flatPages) {
+    if (page && typeof page === "object") {
+      const route = page.route;
+      if (typeof route === "string") routes.add(route);
+    }
+  }
+  const sections = Array.isArray(bp.sections) ? bp.sections : [];
+  for (const section of sections) {
+    if (!section || typeof section !== "object") continue;
+    const pages = section.pages;
+    if (!Array.isArray(pages)) continue;
+    for (const page of pages) {
+      if (page && typeof page === "object") {
+        const route = page.route;
+        if (typeof route === "string") routes.add(route);
+      }
+    }
+  }
+  return [...routes].sort();
+}
+function severityFromCheckIssue(issue) {
+  return issue.type === "error" ? "error" : "warn";
+}
+function sourceFromAuditFinding(finding) {
+  const category = finding.category.toLowerCase();
+  const id = finding.id.toLowerCase();
+  const rule = finding.rule?.toLowerCase() ?? "";
+  if (category.includes("runtime") || category.includes("document") || category.includes("performance")) {
+    return "runtime";
+  }
+  if (category.includes("pack") || category.includes("review contract")) {
+    return "pack";
+  }
+  if (category.includes("interaction") || id.includes("interaction") || rule.includes("interaction")) {
+    return "interaction";
+  }
+  if (category.includes("style bridge") || id.includes("style-bridge") || rule.includes("style-bridge")) {
+    return "style-bridge";
+  }
+  return "audit";
+}
+function sourceFromCheckIssue(issue) {
+  if (issue.rule.startsWith("brownfield-")) return "brownfield";
+  if (issue.rule.includes("interaction")) return "interaction";
+  return "check";
+}
+function normalizeHealthCategory(category, source) {
+  const lower = category.toLowerCase();
+  if (source === "pack" || lower.includes("execution pack") || lower.includes("review contract") || lower.includes("context")) {
+    return "Generated Artifact";
+  }
+  if (source === "brownfield") return "Brownfield Contract";
+  if (source === "design-token" || lower.includes("design-token")) return "Design Token";
+  if (source === "style-bridge" || lower.includes("style bridge")) return "Style Bridge";
+  if (source === "graph") return "Typed Contract Graph";
+  if (lower.includes("accessibility")) return "Accessibility";
+  if (source === "runtime") return "Runtime";
+  if (source === "browser") return "Visual Evidence";
+  if (source === "interaction") return "Interaction";
+  if (source === "assertion") return `Contract ${category}`;
+  return category;
+}
+function contractAssertionApplies(assertion, metadata) {
+  const projectOwnedStyling = metadata.adoptionMode === "contract-only" || metadata.adoptionMode === "style-bridge";
+  if (assertion.rule === "tokens-file-present" && projectOwnedStyling) {
+    return false;
+  }
+  if (projectOwnedStyling && (assertion.rule === "pack-manifest-present" || assertion.rule === "review-pack-present")) {
+    return false;
+  }
+  return true;
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function hashFile2(path) {
+  if (!existsSync5(path)) return null;
+  try {
+    return createHash2("sha256").update(readFileSync5(path)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function readJsonFile4(path) {
+  if (!existsSync5(path)) return null;
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readProjectGraphSnapshot(projectRoot) {
+  return readJsonFile4(
+    join5(projectRoot, ".decantr", "graph", "graph.snapshot.json")
+  );
+}
+function anchorProjectHealthFindings(projectRoot, findings) {
+  return anchorFindingsToGraph(readProjectGraphSnapshot(projectRoot), findings);
+}
+function inspectProjectHealthGraph(projectRoot) {
+  const graphDir = join5(projectRoot, ".decantr", "graph");
+  const snapshotPath = join5(graphDir, "graph.snapshot.json");
+  const manifestPath = join5(graphDir, "graph.manifest.json");
+  const diffPath = join5(graphDir, "graph.diff.json");
+  const capsulePath = join5(graphDir, "contract-capsule.json");
+  const projectMetadataPresent = existsSync5(join5(projectRoot, ".decantr", "project.json"));
+  const graphDirPresent = existsSync5(graphDir);
+  const snapshot = readProjectGraphSnapshot(projectRoot);
+  const capsule = readJsonFile4(capsulePath);
+  try {
+    const artifacts = buildGraphArtifacts(projectRoot);
+    const current = artifacts ? artifacts.staleArtifacts.length === 0 : projectMetadataPresent ? false : null;
+    return {
+      present: graphDirPresent,
+      ready: current === true && existsSync5(snapshotPath) && existsSync5(capsulePath),
+      current,
+      snapshotPresent: existsSync5(snapshotPath),
+      manifestPresent: existsSync5(manifestPath),
+      diffPresent: existsSync5(diffPath),
+      capsulePresent: existsSync5(capsulePath),
+      snapshotId: snapshot?.id ?? artifacts?.snapshot.id ?? null,
+      sourceHash: snapshot?.source_hash ?? artifacts?.snapshot.source_hash ?? null,
+      contractHash: capsule?.contract_hash ?? artifacts?.capsule.contract_hash ?? null,
+      contractCacheKey: capsule?.contract_cache_key ?? artifacts?.capsule.contract_cache_key ?? null,
+      sourceArtifactCount: snapshot?.nodes.filter((node) => node.type === "SourceArtifact").length ?? artifacts?.snapshot.nodes.filter((node) => node.type === "SourceArtifact").length ?? capsule?.summary?.source_artifacts ?? 0,
+      capsuleSourceArtifactLimit: capsule?.source_artifact_limit ?? artifacts?.capsule.source_artifact_limit ?? null,
+      capsuleSourceArtifactsTruncated: capsule?.source_artifacts_truncated ?? artifacts?.capsule.source_artifacts_truncated ?? null,
+      staleArtifacts: artifacts ? artifacts.staleArtifacts.map((path) => relative3(projectRoot, path).replace(/\\/g, "/")) : [],
+      error: null
+    };
+  } catch (error) {
+    return {
+      present: graphDirPresent,
+      ready: false,
+      current: graphDirPresent || projectMetadataPresent ? false : null,
+      snapshotPresent: existsSync5(snapshotPath),
+      manifestPresent: existsSync5(manifestPath),
+      diffPresent: existsSync5(diffPath),
+      capsulePresent: existsSync5(capsulePath),
+      snapshotId: snapshot?.id ?? null,
+      sourceHash: snapshot?.source_hash ?? null,
+      contractHash: capsule?.contract_hash ?? null,
+      contractCacheKey: capsule?.contract_cache_key ?? null,
+      sourceArtifactCount: snapshot?.nodes.filter((node) => node.type === "SourceArtifact").length ?? capsule?.summary?.source_artifacts ?? 0,
+      capsuleSourceArtifactLimit: capsule?.source_artifact_limit ?? null,
+      capsuleSourceArtifactsTruncated: capsule?.source_artifacts_truncated ?? null,
+      staleArtifacts: [],
+      error: error.message
+    };
+  }
+}
+function collectGraphArtifactFindings(projectRoot, graph) {
+  const graphDirPresent = existsSync5(join5(projectRoot, ".decantr", "graph"));
+  const projectMetadataPresent = existsSync5(join5(projectRoot, ".decantr", "project.json"));
+  if (!graphDirPresent && !projectMetadataPresent) {
+    return [];
+  }
+  if (graph.error) {
+    return [
+      createHealthFinding({
+        source: "graph",
+        category: "Typed Contract Graph",
+        severity: "warn",
+        message: `Typed Contract graph could not be derived: ${graph.error}`,
+        evidence: [
+          "Graph derivation reads decantr.essence.json, local rules, style bridge, Brownfield analysis, reusable component declarations, visual manifest, and saved evidence bundle artifacts."
+        ],
+        target: ".decantr/graph",
+        rule: "typed-graph-current",
+        suggestedFix: graph.error.includes("Essence v4") ? "Run `decantr migrate --to v4`, then run `decantr graph`." : "Repair the Decantr contract, then run `decantr graph`.",
+        baseId: "typed-graph-current"
+      })
+    ];
+  }
+  if (graph.current !== false || graph.staleArtifacts.length === 0) {
+    return [];
+  }
+  return [
+    createHealthFinding({
+      source: "graph",
+      category: "Typed Contract Graph",
+      severity: "warn",
+      message: "Typed Contract graph artifacts are missing or stale.",
+      evidence: graph.staleArtifacts.slice(0, 8),
+      target: ".decantr/graph",
+      rule: "typed-graph-current",
+      suggestedFix: "Run `decantr graph` to regenerate graph snapshot, history, diff, manifest, and capsule.",
+      baseId: "typed-graph-current"
+    })
+  ];
+}
+function commandsForFinding(source) {
+  switch (source) {
+    case "brownfield":
+      return ["decantr analyze", "decantr init --existing --merge-proposal", "decantr health"];
+    case "pack":
+      return [
+        "decantr refresh",
+        "decantr registry get-pack review --write-context",
+        "decantr health"
+      ];
+    case "runtime":
+      return ["npm run build", "decantr health"];
+    case "interaction":
+      return ["decantr check --strict", "decantr health"];
+    case "assertion":
+      return ["decantr refresh", "decantr health --evidence"];
+    case "browser":
+      return ["decantr health --browser", "decantr health --evidence"];
+    case "design-token":
+      return ["decantr export --to figma-tokens", "decantr health --evidence"];
+    case "style-bridge":
+      return ["decantr codify --style-bridge", "decantr verify --evidence"];
+    case "graph":
+      return ["decantr graph", "decantr health"];
+    case "check":
+      return ["decantr check", "decantr health"];
+    default:
+      return ["decantr audit", "decantr health"];
+  }
+}
+function detectPackageManager(root) {
+  const pkg = readJsonFile4(join5(root, "package.json"));
+  const declared = pkg?.packageManager?.split("@")[0];
+  if (declared === "pnpm" || declared === "npm" || declared === "yarn" || declared === "bun") {
+    return declared;
+  }
+  if (existsSync5(join5(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync5(join5(root, "package-lock.json"))) return "npm";
+  if (existsSync5(join5(root, "yarn.lock"))) return "yarn";
+  if (existsSync5(join5(root, "bun.lock")) || existsSync5(join5(root, "bun.lockb"))) return "bun";
+  return "unknown";
+}
+function buildCommandForProject(workspaceRoot, projectPath) {
+  const packageManager = detectPackageManager(workspaceRoot);
+  if (projectPath) {
+    switch (packageManager) {
+      case "pnpm":
+        return `pnpm --dir ${projectPath} build`;
+      case "yarn":
+        return `yarn --cwd ${projectPath} build`;
+      case "bun":
+        return `bun --cwd ${projectPath} run build`;
+      case "npm":
+        return `npm --prefix ${projectPath} run build`;
+      default:
+        return `cd ${projectPath} && npm run build`;
+    }
+  }
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm build";
+    case "yarn":
+      return "yarn build";
+    case "bun":
+      return "bun run build";
+    case "npm":
+      return "npm run build";
+    default:
+      return "npm run build";
+  }
+}
+function commandContextForProject(projectRoot) {
+  const workspaceInfo = resolveWorkspaceInfo(projectRoot);
+  const relativeProjectPath = relative3(workspaceInfo.workspaceRoot, projectRoot).replace(
+    /\\/g,
+    "/"
+  );
+  const projectPath = relativeProjectPath && !relativeProjectPath.startsWith("..") && !isAbsolute3(relativeProjectPath) ? relativeProjectPath : null;
+  const projectFlag = projectPath ? ` --project ${projectPath}` : "";
+  const essencePath = projectPath ? `${projectPath}/decantr.essence.json` : "decantr.essence.json";
+  return {
+    projectPath,
+    buildCommand: buildCommandForProject(workspaceInfo.workspaceRoot, projectPath),
+    compilePacksCommand: `decantr registry compile-packs ${essencePath} --write-context`,
+    verifyCommand: `decantr verify${projectFlag}`,
+    ciCommand: `decantr ci${projectFlag} --fail-on error`,
+    promptCommand: (id) => `decantr health${projectFlag} --prompt ${id}`
+  };
+}
+function rewriteHealthCommand(command, context) {
+  if (command === "npm run build") return context.buildCommand;
+  let rewritten = command.replace(
+    /decantr registry compile-packs decantr\.essence\.json --write-context/g,
+    context.compilePacksCommand
+  );
+  if (!context.projectPath) return rewritten;
+  rewritten = rewritten.replace(
+    /^decantr init --existing\b/,
+    `decantr init --project ${context.projectPath} --existing`
+  );
+  rewritten = rewritten.replace(
+    /^decantr analyze\b/,
+    `decantr analyze --project ${context.projectPath}`
+  );
+  rewritten = rewritten.replace(
+    /^decantr check\b/,
+    `decantr check --project ${context.projectPath}`
+  );
+  rewritten = rewritten.replace(
+    /^decantr graph\b/,
+    `decantr graph --project ${context.projectPath}`
+  );
+  rewritten = rewritten.replace(/^decantr audit\b/, context.verifyCommand);
+  rewritten = rewritten.replace(/^decantr health\b/, context.verifyCommand);
+  return rewritten;
+}
+function rewriteSuggestedFixForProject(suggestedFix, context) {
+  if (!suggestedFix) return suggestedFix;
+  return suggestedFix.replace(
+    /decantr registry compile-packs decantr\.essence\.json --write-context/g,
+    context.compilePacksCommand
+  );
+}
+function commandsForProjectFinding(finding, context) {
+  const isPackHydrationFinding = finding.source === "pack" || /pack-manifest|review-pack|compile-packs/i.test(
+    `${finding.id} ${finding.rule ?? ""} ${finding.suggestedFix ?? ""}`
+  );
+  if (isPackHydrationFinding) {
+    return [context.compilePacksCommand, context.verifyCommand];
+  }
+  return [
+    ...new Set(
+      finding.remediation.commands.map((command) => rewriteHealthCommand(command, context))
+    )
+  ];
+}
+function scopeHealthFindingsToProject(projectRoot, findings) {
+  const context = commandContextForProject(projectRoot);
+  return findings.map((finding) => {
+    const suggestedFix = rewriteSuggestedFixForProject(finding.suggestedFix, context);
+    const commands = commandsForProjectFinding(finding, context);
+    return {
+      ...finding,
+      suggestedFix,
+      remediation: {
+        summary: suggestedFix || finding.remediation.summary,
+        commands,
+        prompt: buildRemediationPrompt({
+          id: finding.id,
+          source: finding.source,
+          category: finding.category,
+          severity: finding.severity,
+          message: finding.message,
+          code: finding.code,
+          evidence: finding.evidence,
+          suggestedFix,
+          graph: finding.graph,
+          repair: finding.repair,
+          commands,
+          projectPath: context.projectPath
+        })
+      }
+    };
+  });
+}
+function buildRemediationPrompt(input) {
+  const prefix = input.projectPath ? `${input.projectPath}/` : "";
+  const readTargets = [
+    `${prefix}DECANTR.md`,
+    `${prefix}decantr.essence.json`,
+    `${prefix}.decantr/context/scaffold-pack.md`,
+    `${prefix}.decantr/context/scaffold.md`
+  ];
+  return [
+    "You are fixing one Decantr Project Health finding in this local workspace.",
+    "",
+    `Read project-scoped Decantr files if they exist: ${readTargets.map((target) => `\`${target}\``).join(", ")}. For route or page work, read the matching page/section packs before editing.`,
+    "",
+    `Finding: ${input.id}`,
+    `Source: ${input.source}`,
+    `Severity: ${input.severity}`,
+    `Category: ${input.category}`,
+    input.code ? `Code: ${input.code}` : null,
+    `Message: ${input.message}`,
+    input.graph ? `Graph anchor: ${input.graph.node_type} ${input.graph.node_id} (${input.graph.confidence}; snapshot ${input.graph.snapshot_id})` : null,
+    input.repair ? `Repair: ${input.repair.id}` : null,
+    input.evidence.length > 0 ? `Evidence:
+${input.evidence.map((entry) => `- ${entry}`).join("\n")}` : null,
+    input.suggestedFix ? `Suggested fix: ${input.suggestedFix}` : null,
+    "",
+    "Make the smallest coherent code or contract change that resolves this finding. Preserve the existing framework, routing, styling system, and Decantr workflow mode unless the finding explicitly requires a contract update.",
+    "Do not rewrite unrelated routes, replace the styling system, remove existing product behavior, or regenerate Decantr artifacts unless the finding is about stale or missing generated context.",
+    "",
+    `After the fix, run:
+${input.commands.map((command) => `- ${command}`).join("\n")}`
+  ].filter((line) => Boolean(line)).join("\n");
+}
+function createHealthFinding(input) {
+  const idBase = input.baseId || input.rule || `${input.category}-${input.message}`;
+  const id = `${input.source}-${slugify(idBase)}`;
+  const commands = commandsForFinding(input.source);
+  const category = normalizeHealthCategory(input.category, input.source);
+  const diagnostic = deriveVerificationDiagnostic({
+    id,
+    source: input.source,
+    category,
+    message: input.message,
+    rule: input.rule,
+    target: input.target,
+    file: input.file,
+    suggestedFix: input.suggestedFix,
+    evidence: input.evidence
+  });
+  const code = input.code ?? diagnostic.code;
+  const repair = input.repair ?? diagnostic.repair;
+  const remediation = {
+    summary: input.suggestedFix || `Resolve ${category.toLowerCase()} finding.`,
+    commands,
+    prompt: buildRemediationPrompt({
+      id,
+      source: input.source,
+      category,
+      severity: input.severity,
+      message: input.message,
+      code,
+      evidence: input.evidence ?? [],
+      suggestedFix: input.suggestedFix,
+      repair,
+      commands
+    })
+  };
+  return {
+    id,
+    code,
+    source: input.source,
+    category,
+    severity: input.severity,
+    message: input.message,
+    evidence: input.evidence ?? [],
+    target: input.target,
+    file: input.file,
+    rule: input.rule,
+    suggestedFix: input.suggestedFix,
+    repair,
+    remediation
+  };
+}
+function collectContractPackConsistencyFindings(projectRoot, essence, manifest) {
+  if (!essence || typeof essence !== "object") return [];
+  const record = essence;
+  const blueprint = record.blueprint;
+  if (!blueprint || typeof blueprint !== "object") return [];
+  const bp = blueprint;
+  const routes = bp.routes && typeof bp.routes === "object" && !Array.isArray(bp.routes) ? bp.routes : {};
+  const routeTargets = new Set(
+    Object.values(routes).filter(
+      (entry) => Boolean(entry) && typeof entry === "object"
+    ).map((entry) => `${String(entry.section ?? "")}/${String(entry.page ?? "")}`)
+  );
+  const pages = [];
+  for (const section of Array.isArray(bp.sections) ? bp.sections : []) {
+    if (!section || typeof section !== "object") continue;
+    const sectionRecord = section;
+    const sectionId = typeof sectionRecord.id === "string" ? sectionRecord.id : "unknown";
+    for (const page of Array.isArray(sectionRecord.pages) ? sectionRecord.pages : []) {
+      if (!page || typeof page !== "object") continue;
+      const pageRecord = page;
+      const pageId = typeof pageRecord.id === "string" ? pageRecord.id : "unknown";
+      const route = typeof pageRecord.route === "string" ? pageRecord.route : null;
+      pages.push({ section: sectionId, page: pageId, route });
+    }
+  }
+  const findings = [];
+  const routeLess = pages.filter(
+    (page) => !page.route && !routeTargets.has(`${page.section}/${page.page}`)
+  );
+  if (routeLess.length > 0) {
+    findings.push(
+      createHealthFinding({
+        source: "assertion",
+        category: "Contract Route Topology",
+        severity: "error",
+        message: "One or more blueprint pages have no route and cannot be addressed by task-time context.",
+        evidence: routeLess.slice(0, 8).map(
+          (page) => `${page.section}/${page.page} has no page.route or blueprint.routes entry`
+        ),
+        rule: "page-route-required",
+        suggestedFix: "Add a route for each page or rerun the add-page flow with a route-aware Decantr CLI.",
+        baseId: "page-route-required"
+      })
+    );
+  }
+  const pagePackCount = manifest && "pages" in manifest && Array.isArray(manifest.pages) ? manifest.pages.length : 0;
+  if (manifest && pages.length !== pagePackCount) {
+    const context = commandContextForProject(projectRoot);
+    findings.push(
+      createHealthFinding({
+        source: "pack",
+        category: "Generated Artifacts",
+        severity: "warn",
+        message: `Compiled page pack count (${pagePackCount}) does not match the contract page count (${pages.length}).`,
+        evidence: ["Page packs should be regenerated after adding, removing, or re-routing pages."],
+        rule: "page-pack-count-mismatch",
+        suggestedFix: context.compilePacksCommand,
+        baseId: "page-pack-count-mismatch"
+      })
+    );
+  }
+  return findings;
+}
+function countFindings(findings) {
+  return {
+    errorCount: findings.filter((finding) => finding.severity === "error").length,
+    warnCount: findings.filter((finding) => finding.severity === "warn").length,
+    infoCount: findings.filter((finding) => finding.severity === "info").length
+  };
+}
+function statusFromCounts(counts) {
+  if (counts.errorCount > 0) return "error";
+  if (counts.warnCount > 0) return "warning";
+  return "healthy";
+}
+function scoreFromCounts(counts) {
+  return Math.max(
+    0,
+    Math.min(100, 100 - counts.errorCount * 15 - counts.warnCount * 5 - counts.infoCount)
+  );
+}
+function routeIssuesFromFindings(findings) {
+  const issues = findings.filter(
+    (finding) => finding.category.toLowerCase().includes("route") || finding.rule?.toLowerCase().includes("route") || finding.id.toLowerCase().includes("route")
+  ).map((finding) => finding.message);
+  return [...new Set(issues)];
+}
+function isDuplicateFinding(existing, finding) {
+  const key = `${finding.rule ?? finding.id}|${finding.message}`;
+  if (existing.has(key)) return true;
+  existing.add(key);
+  return false;
+}
+function resolveOptionalPath(projectRoot, path) {
+  if (!path) return void 0;
+  return isAbsolute3(path) ? path : resolve2(projectRoot, path);
+}
+function hasProjectPlaywright(projectRoot) {
+  try {
+    const requireFromProject = createRequire(join5(projectRoot, "package.json"));
+    requireFromProject.resolve("playwright");
+    return true;
+  } catch {
+    try {
+      const requireFromProject = createRequire(join5(projectRoot, "package.json"));
+      requireFromProject.resolve("@playwright/test");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function loadProjectPlaywright(projectRoot) {
+  const requireFromProject = createRequire(join5(projectRoot, "package.json"));
+  for (const packageName of ["playwright", "@playwright/test"]) {
+    try {
+      const loaded = requireFromProject(packageName);
+      if (loaded.chromium?.launch) return loaded;
+    } catch {
+    }
+  }
+  return null;
+}
+function browserRouteUrl(baseUrl, route) {
+  return new URL(route || "/", baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
+}
+function browserScreenshotRelativePath(route) {
+  const name = slugify(route === "/" ? "root" : route) || "root";
+  return `.decantr/evidence/screenshots/${name}.png`;
+}
+async function collectBrowserVerification(projectRoot, options, declaredRoutes) {
+  if (!options.browser) return null;
+  if (!hasProjectPlaywright(projectRoot)) {
+    const finding = createHealthFinding({
+      source: "browser",
+      category: "Browser Verification",
+      severity: options.requireBrowser ? "error" : "warn",
+      message: "Browser verification was requested, but Playwright is not installed in this project.",
+      evidence: ["Expected dependency: playwright or @playwright/test"],
+      rule: "browser-playwright-missing",
+      suggestedFix: "Install Playwright in the project or omit browser/base-url evidence for static-only health checks.",
+      baseId: "playwright-missing"
+    });
+    return {
+      finding,
+      evidence: {
+        enabled: true,
+        status: "unavailable",
+        baseUrl: options.browserBaseUrl ?? null,
+        screenshots: [],
+        findings: [finding.message]
+      }
+    };
+  }
+  if (!options.browserBaseUrl) {
+    const finding = createHealthFinding({
+      source: "browser",
+      category: "Browser Verification",
+      severity: options.requireBrowser ? "error" : "warn",
+      message: "Browser verification was requested, but no base URL was provided for rendered route checks.",
+      evidence: ["Pass --base-url <url> or set DECANTR_BROWSER_BASE_URL."],
+      rule: "browser-base-url-missing",
+      suggestedFix: "Start the app and rerun with `decantr health --browser --base-url <url>`.",
+      baseId: "base-url-missing"
+    });
+    return {
+      finding,
+      evidence: {
+        enabled: true,
+        status: "unavailable",
+        baseUrl: null,
+        screenshots: [],
+        findings: [finding.message]
+      }
+    };
+  }
+  const playwright = loadProjectPlaywright(projectRoot);
+  if (!playwright) {
+    const finding = createHealthFinding({
+      source: "browser",
+      category: "Browser Verification",
+      severity: options.requireBrowser ? "error" : "warn",
+      message: "Playwright is installed, but Decantr could not load a Chromium browser adapter.",
+      evidence: ["Expected chromium.launch from playwright or @playwright/test."],
+      rule: "browser-adapter-missing",
+      suggestedFix: "Repair the local Playwright install and rerun `decantr health --browser`.",
+      baseId: "adapter-missing"
+    });
+    return {
+      finding,
+      evidence: {
+        enabled: true,
+        status: "unavailable",
+        baseUrl: options.browserBaseUrl,
+        screenshots: [],
+        findings: [finding.message]
+      }
+    };
+  }
+  const routes = (declaredRoutes.length > 0 ? declaredRoutes : ["/"]).slice(0, 12);
+  const screenshots = [];
+  const browserFindings = [];
+  const visualRoutes = [];
+  const screenshotDir = join5(projectRoot, ".decantr", "evidence", "screenshots");
+  mkdirSync4(screenshotDir, { recursive: true });
+  let browser = null;
+  try {
+    browser = await playwright.chromium.launch({ headless: true });
+    const page = await browser.newPage();
+    for (const route of routes) {
+      const url = browserRouteUrl(options.browserBaseUrl, route);
+      const relativePath = browserScreenshotRelativePath(route);
+      try {
+        await page.goto(url, { waitUntil: "networkidle", timeout: 15e3 });
+        const absoluteScreenshotPath = join5(projectRoot, relativePath);
+        await page.screenshot({ path: absoluteScreenshotPath, fullPage: true });
+        screenshots.push(relativePath);
+        visualRoutes.push({
+          route,
+          url,
+          screenshot: relativePath,
+          screenshotHash: hashFile2(absoluteScreenshotPath),
+          status: "captured"
+        });
+      } catch (error) {
+        const message = error.message;
+        browserFindings.push(`${route}: ${message}`);
+        visualRoutes.push({
+          route,
+          url,
+          screenshot: null,
+          screenshotHash: null,
+          status: "failed",
+          error: message
+        });
+      }
+    }
+  } catch (error) {
+    browserFindings.push(error.message);
+  } finally {
+    if (browser) await browser.close();
+  }
+  const visualManifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    localOnly: true,
+    baseUrl: options.browserBaseUrl,
+    routes: visualRoutes
+  };
+  const visualManifestPath = join5(projectRoot, ".decantr", "evidence", "visual-manifest.json");
+  mkdirSync4(dirname3(visualManifestPath), { recursive: true });
+  writeFileSync4(visualManifestPath, JSON.stringify(visualManifest, null, 2) + "\n", "utf-8");
+  if (browserFindings.length > 0) {
+    const finding = createHealthFinding({
+      source: "browser",
+      category: "Browser Verification",
+      severity: options.requireBrowser ? "error" : "warn",
+      message: "Browser verification could not render every declared route.",
+      evidence: browserFindings.slice(0, 5),
+      rule: "browser-route-verification-failed",
+      suggestedFix: "Start the app at the provided base URL, fix route render errors, and rerun `decantr health --browser --evidence`.",
+      baseId: "route-verification-failed"
+    });
+    return {
+      finding,
+      evidence: {
+        enabled: true,
+        status: "failed",
+        baseUrl: options.browserBaseUrl,
+        screenshots,
+        findings: browserFindings
+      }
+    };
+  }
+  return {
+    finding: null,
+    evidence: {
+      enabled: true,
+      status: "passed",
+      baseUrl: options.browserBaseUrl,
+      screenshots,
+      findings: []
+    }
+  };
+}
+function flattenDesignTokenKeys(value, prefix = "") {
+  const keys = /* @__PURE__ */ new Set();
+  if (!value || typeof value !== "object" || Array.isArray(value)) return keys;
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    const key = prefix ? `${prefix}.${rawKey}` : rawKey;
+    if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) && ("$value" in rawValue || "value" in rawValue)) {
+      keys.add(key);
+      keys.add(rawKey);
+    } else if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+      for (const nested of flattenDesignTokenKeys(rawValue, key)) keys.add(nested);
+    }
+  }
+  return keys;
+}
+function parseDecantrCssTokenNames(projectRoot) {
+  const tokensPath = join5(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync5(tokensPath)) return [];
+  const css = readFileSync5(tokensPath, "utf-8");
+  const names = /* @__PURE__ */ new Set();
+  for (const match of css.matchAll(/(--d-[\w-]+)\s*:/g)) {
+    names.add(match[1]);
+  }
+  return [...names].sort();
+}
+function collectDesignTokenEvidence(projectRoot, designTokensPath) {
+  const resolved = resolveOptionalPath(projectRoot, designTokensPath);
+  if (!resolved) return void 0;
+  const sourceLabel = isAbsolute3(designTokensPath ?? "") ? "<design-tokens>" : designTokensPath ?? "<design-tokens>";
+  if (!existsSync5(resolved)) {
+    return {
+      source: sourceLabel,
+      status: "error",
+      compared: 0,
+      matched: 0,
+      missing: ["design-token-source-missing"]
+    };
+  }
+  const decantrTokens = parseDecantrCssTokenNames(projectRoot);
+  const parsed = JSON.parse(readFileSync5(resolved, "utf-8"));
+  const designKeys = flattenDesignTokenKeys(parsed);
+  const missing = decantrTokens.filter((token) => {
+    const bare = token.replace(/^--/, "");
+    return !designKeys.has(token) && !designKeys.has(bare) && !designKeys.has(bare.replace(/^d-/, ""));
+  });
+  return {
+    source: sourceLabel,
+    status: missing.length === 0 ? "passed" : "warning",
+    compared: decantrTokens.length,
+    matched: decantrTokens.length - missing.length,
+    missing
+  };
+}
+function collectDesignTokenFinding(projectRoot, designTokensPath) {
+  const evidence = collectDesignTokenEvidence(projectRoot, designTokensPath);
+  if (!evidence) return null;
+  if (evidence.status === "passed") {
+    return createHealthFinding({
+      source: "design-token",
+      category: "Design Tokens",
+      severity: "info",
+      message: "Imported design-token source covers Decantr token names.",
+      evidence: [`matched=${evidence.matched}/${evidence.compared}`],
+      rule: "design-token-coverage",
+      baseId: "coverage-passed"
+    });
+  }
+  return createHealthFinding({
+    source: "design-token",
+    category: "Design Tokens",
+    severity: evidence.status === "error" ? "error" : "warn",
+    message: "Imported design-token source does not cover all Decantr token names.",
+    evidence: [
+      `matched=${evidence.matched}/${evidence.compared}`,
+      evidence.missing.slice(0, 12).join(", ") || "No Decantr CSS tokens found."
+    ],
+    rule: "design-token-coverage",
+    suggestedFix: "Update the Figma/Tokens Studio export or Decantr token mapping so shared UI policy can be verified.",
+    baseId: "coverage-missing"
+  });
+}
+function baselinePath(projectRoot) {
+  return join5(projectRoot, ".decantr", "health-baseline.json");
+}
+function baselineDiffPath(projectRoot) {
+  return join5(projectRoot, ".decantr", "health-baseline-diff.json");
+}
+function screenshotHashes(projectRoot) {
+  const manifest = readJsonFile4(
+    join5(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+  );
+  if (manifest?.routes) {
+    return manifest.routes.filter((route) => typeof route.screenshot === "string").map((route) => ({
+      path: route.screenshot,
+      hash: route.screenshotHash ?? hashFile2(join5(projectRoot, route.screenshot))
+    }));
+  }
+  return [];
+}
+function changedFilesSinceBaseline(projectRoot) {
+  const changed = /* @__PURE__ */ new Set();
+  try {
+    for (const args of [
+      ["diff", "--name-only"],
+      ["diff", "--name-only", "--cached"]
+    ]) {
+      const output = execFileSync2("git", args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const entry of output.split(/\r?\n/)) {
+        const file = entry.trim();
+        if (file) changed.add(file);
+      }
+    }
+  } catch {
+  }
+  return [...changed].sort();
+}
+function routeImpactsFromChangedFiles(report, changedFiles2) {
+  const analysis = readJsonFile4(
+    join5(report.projectRoot, ".decantr", "analysis.json")
+  );
+  const routeEntries = analysis?.routes?.routes ?? [];
+  const impacted = /* @__PURE__ */ new Set();
+  for (const file of changedFiles2) {
+    for (const route of routeEntries) {
+      if (route.file && (file === route.file || file.endsWith(route.file))) {
+        if (route.path) impacted.add(route.path);
+      }
+    }
+  }
+  return [...impacted].sort();
+}
+function createHealthBaseline(projectRoot, report) {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: report.status,
+    score: report.score,
+    findings: report.findings.map((finding) => ({
+      id: finding.id,
+      severity: finding.severity,
+      source: finding.source,
+      message: finding.message
+    })),
+    routes: report.routes.declared,
+    packs: report.packs,
+    screenshots: screenshotHashes(projectRoot),
+    changedFilesCommand: "git diff --name-only + --cached"
+  };
+}
+function saveHealthBaseline(projectRoot, report) {
+  const path = baselinePath(projectRoot);
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(
+    path,
+    JSON.stringify(createHealthBaseline(projectRoot, report), null, 2) + "\n",
+    "utf-8"
+  );
+  return path;
+}
+function compareHealthBaseline(projectRoot, report) {
+  const path = baselinePath(projectRoot);
+  const baseline = readJsonFile4(path);
+  const currentFindingIds = new Set(report.findings.map((finding) => finding.id));
+  const baselineFindingIds = new Set(baseline?.findings.map((finding) => finding.id) ?? []);
+  const changedFiles2 = changedFilesSinceBaseline(projectRoot);
+  const currentScreenshots = new Map(
+    screenshotHashes(projectRoot).map((entry) => [entry.path, entry.hash])
+  );
+  const changedScreenshots = baseline?.screenshots.filter(
+    (entry) => currentScreenshots.has(entry.path) && currentScreenshots.get(entry.path) !== entry.hash
+  ).map((entry) => entry.path) ?? [];
+  const contractDrift = [
+    baseline && baseline.routes.join("\n") !== report.routes.declared.join("\n") ? "Declared route set changed since baseline." : null,
+    baseline && baseline.packs.generatedAt !== report.packs.generatedAt ? "Execution-pack generation timestamp changed since baseline." : null
+  ].filter((entry) => Boolean(entry));
+  return {
+    baselinePath: path,
+    savedAt: baseline?.generatedAt ?? null,
+    statusChanged: baseline ? baseline.status !== report.status : false,
+    scoreDelta: baseline ? report.score - baseline.score : null,
+    addedFindings: [...currentFindingIds].filter((id) => !baselineFindingIds.has(id)).sort(),
+    resolvedFindings: [...baselineFindingIds].filter((id) => !currentFindingIds.has(id)).sort(),
+    changedFiles: changedFiles2,
+    changedRoutes: routeImpactsFromChangedFiles(report, changedFiles2),
+    changedScreenshots,
+    contractDrift
+  };
+}
+function saveHealthBaselineComparison(projectRoot, comparison) {
+  const path = baselineDiffPath(projectRoot);
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, JSON.stringify(comparison, null, 2) + "\n", "utf-8");
+  return path;
+}
+function visualBaselineFindings(comparison) {
+  if (!comparison || comparison.changedScreenshots.length === 0) return [];
+  return [
+    createHealthFinding({
+      source: "browser",
+      category: "Visual Baseline",
+      severity: "warn",
+      message: "Screenshot hashes changed since the saved Decantr health baseline.",
+      evidence: [
+        `Baseline: ${comparison.baselinePath}`,
+        `Changed screenshots: ${comparison.changedScreenshots.join(", ")}`
+      ],
+      target: comparison.changedScreenshots[0],
+      rule: "visual-baseline-screenshot-drift",
+      suggestedFix: "Review the changed screenshots. If the visual change is intentional, save a new baseline; otherwise repair the UI drift and rerun browser evidence.",
+      repair: {
+        id: "review-visual-baseline-drift",
+        payload: {
+          baseline_path: comparison.baselinePath,
+          changed_screenshots: comparison.changedScreenshots
+        }
+      },
+      baseId: "visual-baseline-screenshot-drift"
+    })
+  ];
+}
+function withAdditionalHealthFindings(projectRoot, report, additions) {
+  if (additions.length === 0) return report;
+  const seen = new Set(
+    report.findings.map((finding) => `${finding.rule ?? finding.id}|${finding.message}`)
+  );
+  const nextFindings = [
+    ...report.findings,
+    ...additions.filter((finding) => !isDuplicateFinding(seen, finding)).map((finding) => ({
+      ...finding,
+      repairPlan: buildProjectHealthRepairPlan(projectRoot, finding)
+    }))
+  ];
+  const counts = countFindings(nextFindings);
+  return {
+    ...report,
+    status: statusFromCounts(counts),
+    score: scoreFromCounts(counts),
+    summary: {
+      ...report.summary,
+      ...counts,
+      findingCount: nextFindings.length
+    },
+    routes: {
+      ...report.routes,
+      issues: routeIssuesFromFindings(nextFindings)
+    },
+    findings: nextFindings
+  };
+}
+function formatBaselineComparisonText(comparison) {
+  const lines = [
+    "",
+    `${BOLD}Continuity:${RESET2}`,
+    `  Baseline: ${comparison.savedAt ?? "missing"} (${comparison.baselinePath})`,
+    `  Score delta: ${comparison.scoreDelta == null ? "n/a" : comparison.scoreDelta >= 0 ? `+${comparison.scoreDelta}` : String(comparison.scoreDelta)}`,
+    `  Added findings: ${comparison.addedFindings.length}`,
+    `  Resolved findings: ${comparison.resolvedFindings.length}`,
+    `  Changed files: ${comparison.changedFiles.length}`,
+    `  Route impact: ${comparison.changedRoutes.length > 0 ? comparison.changedRoutes.join(", ") : "none detected"}`,
+    `  Screenshot drift: ${comparison.changedScreenshots.length}`,
+    `  Contract drift: ${comparison.contractDrift.length > 0 ? comparison.contractDrift.join(" ") : "none detected"}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function browserEvidenceFromOptions(projectRoot, options, declaredRoutes) {
+  if (!options.browser) return void 0;
+  const result = await collectBrowserVerification(projectRoot, options, declaredRoutes);
+  return result?.evidence;
+}
+async function createProjectHealthReport(projectRoot = process.cwd(), options = {}) {
+  const metadata = readProjectMetadata(projectRoot);
+  const audit = await auditProject(projectRoot);
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const finding of audit.findings) {
+    const healthFinding = createHealthFinding({
+      source: sourceFromAuditFinding(finding),
+      category: finding.category,
+      severity: finding.severity,
+      message: finding.message,
+      evidence: finding.evidence,
+      target: finding.target,
+      file: finding.file,
+      rule: finding.rule,
+      suggestedFix: finding.suggestedFix,
+      code: finding.code,
+      repair: finding.repair,
+      baseId: finding.id
+    });
+    if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
+  }
+  for (const contractAssertion of createContractAssertions(projectRoot, audit)) {
+    if (!contractAssertionApplies(contractAssertion, metadata)) continue;
+    if (contractAssertion.status !== "failed") continue;
+    const healthFinding = createHealthFinding({
+      source: "assertion",
+      category: `Contract ${contractAssertion.category}`,
+      severity: contractAssertion.severity,
+      message: contractAssertion.message,
+      evidence: contractAssertion.evidence,
+      target: contractAssertion.target,
+      rule: contractAssertion.rule,
+      suggestedFix: contractAssertion.suggestedFix,
+      baseId: contractAssertion.id
+    });
+    if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
+  }
+  const designTokenFinding = collectDesignTokenFinding(projectRoot, options.designTokensPath);
+  if (designTokenFinding && !isDuplicateFinding(seen, designTokenFinding)) {
+    findings.push(designTokenFinding);
+  }
+  try {
+    const check = collectCheckIssues(projectRoot, { brownfield: metadata.autoBrownfield });
+    for (const issue of check.issues) {
+      const source = sourceFromCheckIssue(issue);
+      const healthFinding = createHealthFinding({
+        source,
+        category: source === "brownfield" ? "Brownfield Drift" : "Contract Check",
+        severity: severityFromCheckIssue(issue),
+        message: issue.message,
+        evidence: [`Rule: ${issue.rule}`],
+        rule: issue.rule,
+        suggestedFix: issue.suggestion,
+        baseId: issue.rule
+      });
+      if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
+    }
+  } catch (e) {
+    const healthFinding = createHealthFinding({
+      source: "check",
+      category: "Contract Check",
+      severity: "error",
+      message: `Decantr check could not complete: ${e.message}`,
+      evidence: ["The health command could not run the local check pass."],
+      rule: "check-failed",
+      suggestedFix: "Repair the local Decantr contract and rerun `decantr health`.",
+      baseId: "check-failed"
+    });
+    if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
+  }
+  if (!audit.valid && findings.every((finding) => finding.severity !== "error")) {
+    findings.push(
+      createHealthFinding({
+        source: "audit",
+        category: "Project Contract",
+        severity: "error",
+        message: "Project audit is not valid.",
+        evidence: ["The verifier returned valid=false."],
+        rule: "project-audit-invalid",
+        suggestedFix: "Resolve blocking audit findings and rerun `decantr health`."
+      })
+    );
+  }
+  const declaredRoutes = collectDeclaredRoutes(audit.essence);
+  const manifest = audit.packManifest;
+  for (const consistencyFinding of collectContractPackConsistencyFindings(
+    projectRoot,
+    audit.essence,
+    manifest
+  )) {
+    if (!isDuplicateFinding(seen, consistencyFinding)) findings.push(consistencyFinding);
+  }
+  const graph = inspectProjectHealthGraph(projectRoot);
+  for (const graphFinding of collectGraphArtifactFindings(projectRoot, graph)) {
+    if (!isDuplicateFinding(seen, graphFinding)) findings.push(graphFinding);
+  }
+  const browserVerification = await collectBrowserVerification(
+    projectRoot,
+    options,
+    declaredRoutes
+  );
+  if (browserVerification?.finding && !isDuplicateFinding(seen, browserVerification.finding)) {
+    findings.push(browserVerification.finding);
+  }
+  const anchoredFindings = anchorProjectHealthFindings(projectRoot, findings);
+  const scopedFindings = scopeHealthFindingsToProject(projectRoot, anchoredFindings);
+  const repairPlanFindings = scopedFindings.map((finding) => ({
+    ...finding,
+    repairPlan: buildProjectHealthRepairPlan(projectRoot, finding)
+  }));
+  const finalCounts = countFindings(repairPlanFindings);
+  const commandContext = commandContextForProject(projectRoot);
+  return {
+    $schema: PROJECT_HEALTH_SCHEMA_URL,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot,
+    status: statusFromCounts(finalCounts),
+    score: scoreFromCounts(finalCounts),
+    summary: {
+      ...finalCounts,
+      findingCount: repairPlanFindings.length,
+      workflowMode: metadata.workflowMode,
+      adoptionMode: metadata.adoptionMode,
+      essenceVersion: audit.summary.essenceVersion,
+      pageCount: audit.summary.pageCount,
+      runtimeAuditChecked: audit.summary.runtimeAuditChecked,
+      runtimePassed: audit.summary.runtimePassed,
+      packManifestPresent: audit.summary.packManifestPresent,
+      reviewPackPresent: audit.summary.reviewPackPresent
+    },
+    routes: {
+      declared: declaredRoutes,
+      runtimeChecked: audit.runtimeAudit.routeHintsChecked,
+      runtimeMatched: audit.runtimeAudit.routeHintsMatched,
+      runtimeCoverageOk: audit.summary.runtimeAuditChecked ? audit.runtimeAudit.routeHintsCoverageOk : null,
+      issues: routeIssuesFromFindings(repairPlanFindings)
+    },
+    packs: {
+      manifestPresent: Boolean(manifest),
+      reviewPackPresent: Boolean(manifest?.review ?? audit.reviewPack),
+      scaffoldPackPresent: Boolean(manifest?.scaffold),
+      sectionPackCount: manifest?.sections.length ?? 0,
+      pagePackCount: manifest?.pages.length ?? 0,
+      mutationPackCount: manifest?.mutations?.length ?? 0,
+      generatedAt: typeof manifest?.generatedAt === "string" ? manifest.generatedAt : null
+    },
+    graph,
+    ci: {
+      recommendedCommand: commandContext.ciCommand,
+      failOn: "error"
+    },
+    findings: repairPlanFindings
+  };
+}
+function colorForStatus(status) {
+  if (status === "healthy") return GREEN2;
+  if (status === "warning") return YELLOW;
+  return RED2;
+}
+function formatProjectHealthText(report) {
+  const color = colorForStatus(report.status);
+  const commandContext = commandContextForProject(report.projectRoot);
+  const lines = [
+    `${BOLD}Decantr Project Health${RESET2}`,
+    "",
+    `${color}${report.status.toUpperCase()}${RESET2}  score ${report.score}/100`,
+    `${DIM2}${report.projectRoot}${RESET2}`,
+    "",
+    `${BOLD}Summary:${RESET2}`,
+    `  Findings: ${report.summary.errorCount} error(s), ${report.summary.warnCount} warn(s), ${report.summary.infoCount} info`,
+    `  Essence: ${report.summary.essenceVersion ?? "missing"} | pages ${report.summary.pageCount}`,
+    `  Workflow: ${report.summary.workflowMode ?? "unknown"} | adoption ${report.summary.adoptionMode ?? "unknown"}`,
+    `  Runtime audit: ${report.summary.runtimeAuditChecked ? report.summary.runtimePassed ? "passed" : "failed" : "not checked"}`,
+    `  Packs: manifest ${report.packs.manifestPresent ? "present" : "missing"} | review ${report.packs.reviewPackPresent ? "present" : "missing"} | pages ${report.packs.pagePackCount}`,
+    `  Graph: ${report.graph.current === null ? "not attached" : report.graph.current ? "current" : "stale"} | capsule ${report.graph.capsulePresent ? "present" : "missing"} | sources ${report.graph.sourceArtifactCount}`,
+    "",
+    `${BOLD}Findings:${RESET2}`
+  ];
+  if (report.findings.length === 0) {
+    lines.push(`  ${GREEN2}No findings. Project is healthy.${RESET2}`);
+  } else {
+    for (const finding of report.findings) {
+      const findingColor = finding.severity === "error" ? RED2 : finding.severity === "warn" ? YELLOW : CYAN;
+      lines.push(
+        `  ${findingColor}[${finding.severity.toUpperCase()}]${RESET2} ${finding.id}: ${finding.message}`
+      );
+      if (finding.evidence.length > 0) {
+        lines.push(`    ${DIM2}${finding.evidence[0]}${RESET2}`);
+      }
+      if (finding.code) {
+        lines.push(`    ${DIM2}Code: ${finding.code}${RESET2}`);
+      }
+      if (finding.graph) {
+        lines.push(
+          `    ${DIM2}Graph: ${finding.graph.node_type} ${finding.graph.node_id} (${finding.graph.confidence})${RESET2}`
+        );
+      }
+      if (finding.repair) {
+        lines.push(`    ${DIM2}Repair: ${finding.repair.id}${RESET2}`);
+      }
+      if (finding.suggestedFix) {
+        lines.push(`    ${DIM2}Fix: ${finding.suggestedFix}${RESET2}`);
+      }
+      lines.push(`    ${DIM2}Prompt: ${commandContext.promptCommand(finding.id)}${RESET2}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}CI:${RESET2} ${report.ci.recommendedCommand}`);
+  return `${lines.join("\n")}
+`;
+}
+function formatProjectHealthMarkdown(report) {
+  const commandContext = commandContextForProject(report.projectRoot);
+  const lines = [
+    "# Decantr Project Health",
+    "",
+    `- Status: **${report.status}**`,
+    `- Score: **${report.score}/100**`,
+    `- Project: \`${report.projectRoot}\``,
+    `- Findings: ${report.summary.errorCount} error(s), ${report.summary.warnCount} warn(s), ${report.summary.infoCount} info`,
+    `- Runtime audit: ${report.summary.runtimeAuditChecked ? report.summary.runtimePassed ? "passed" : "failed" : "not checked"}`,
+    `- Packs: manifest ${report.packs.manifestPresent ? "present" : "missing"}, review ${report.packs.reviewPackPresent ? "present" : "missing"}`,
+    `- Graph: ${report.graph.current === null ? "not attached" : report.graph.current ? "current" : "stale"}, capsule ${report.graph.capsulePresent ? "present" : "missing"}, sources ${report.graph.sourceArtifactCount}`,
+    "",
+    "## Findings",
+    ""
+  ];
+  if (report.findings.length === 0) {
+    lines.push("No findings. Project is healthy.");
+  } else {
+    for (const finding of report.findings) {
+      lines.push(`### ${finding.id}`);
+      lines.push("");
+      lines.push(`- Severity: ${finding.severity}`);
+      lines.push(`- Source: ${finding.source}`);
+      lines.push(`- Category: ${finding.category}`);
+      if (finding.code) lines.push(`- Code: ${finding.code}`);
+      lines.push(`- Message: ${finding.message}`);
+      if (finding.suggestedFix) lines.push(`- Fix: ${finding.suggestedFix}`);
+      if (finding.graph) {
+        lines.push(
+          `- Graph: \`${finding.graph.node_type} ${finding.graph.node_id}\` (${finding.graph.confidence})`
+        );
+      }
+      if (finding.repair) lines.push(`- Repair: \`${finding.repair.id}\``);
+      if (finding.evidence.length > 0) {
+        lines.push("- Evidence:");
+        for (const evidence of finding.evidence) lines.push(`  - ${evidence}`);
+      }
+      lines.push(`- Prompt: \`${commandContext.promptCommand(finding.id)}\``);
+      lines.push("");
+    }
+  }
+  lines.push("## CI");
+  lines.push("");
+  lines.push(`\`${report.ci.recommendedCommand}\``);
+  return `${lines.join("\n")}
+`;
+}
+function formatProjectHealthJson(report) {
+  return `${JSON.stringify(report, null, 2)}
+`;
+}
+function diagnosticCatalogPayload() {
+  return {
+    diagnostics: KNOWN_VERIFICATION_DIAGNOSTICS.map((entry) => ({
+      code: entry.code,
+      family: entry.family,
+      rule: entry.rule,
+      repairId: entry.repairId
+    })).sort((a, b) => a.code.localeCompare(b.code) || a.rule.localeCompare(b.rule))
+  };
+}
+function formatDiagnosticCatalogJson() {
+  return `${JSON.stringify(diagnosticCatalogPayload(), null, 2)}
+`;
+}
+function formatDiagnosticCatalogMarkdown() {
+  const lines = [
+    "# Decantr Diagnostic Codes",
+    "",
+    "| Code | Family | Rule | Repair ID |",
+    "| --- | --- | --- | --- |",
+    ...diagnosticCatalogPayload().diagnostics.map(
+      (entry) => `| \`${entry.code}\` | \`${entry.family}\` | \`${entry.rule}\` | \`${entry.repairId}\` |`
+    ),
+    ""
+  ];
+  return lines.join("\n");
+}
+function formatDiagnosticCatalogText() {
+  return [
+    "Decantr Diagnostic Codes",
+    ...diagnosticCatalogPayload().diagnostics.map(
+      (entry) => `${entry.code.padEnd(12)} ${entry.rule.padEnd(42)} ${entry.repairId}`
+    ),
+    ""
+  ].join("\n");
+}
+async function createProjectEvidenceBundle(projectRoot, report, options = {}) {
+  const audit = await auditProject(projectRoot);
+  const assertions = createContractAssertions(projectRoot, audit);
+  return createEvidenceBundle({
+    projectRoot,
+    report,
+    audit,
+    assertions,
+    workspaceConfigPath: existsSync5(join5(projectRoot, ".decantr", "workspace.json")) ? join5(projectRoot, ".decantr", "workspace.json") : null,
+    designTokensPath: resolveOptionalPath(projectRoot, options.designTokensPath) ?? null,
+    browser: await browserEvidenceFromOptions(projectRoot, options, report.routes.declared),
+    designTokens: collectDesignTokenEvidence(projectRoot, options.designTokensPath)
+  });
+}
+function resolveFormat(options) {
+  if (options.json) return "json";
+  if (options.markdown) return "markdown";
+  return options.format ?? "text";
+}
+function shouldFailHealth(report, failOn) {
+  if (failOn === "none") return false;
+  if (failOn === "warn") return report.summary.errorCount > 0 || report.summary.warnCount > 0;
+  return report.summary.errorCount > 0;
+}
+async function cmdHealth(projectRoot = process.cwd(), options = {}) {
+  if (options.initCi) {
+    try {
+      const result = writeProjectHealthCiWorkflow(projectRoot, options.initCi);
+      const action = result.created ? "Created" : "Updated";
+      console.log(`${GREEN2}${action} Decantr Project Health workflow:${RESET2} ${result.path}`);
+      console.log(`${DIM2}CLI package: ${result.cliPackage}${RESET2}`);
+      if (result.projectPath) {
+        console.log(`${DIM2}Project: ${result.projectPath}${RESET2}`);
+      }
+      if (result.workspace) {
+        console.log(`${DIM2}Workspace mode enabled.${RESET2}`);
+      }
+      console.log(
+        `${DIM2}CI gate: decantr ${result.workspace ? "workspace health" : "health"} --ci --fail-on ${result.failOn}${RESET2}`
+      );
+    } catch (e) {
+      console.error(`${RED2}${e.message}${RESET2}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (options.diagnostics) {
+    const format2 = resolveFormat(options);
+    const payload2 = format2 === "json" ? formatDiagnosticCatalogJson() : format2 === "markdown" ? formatDiagnosticCatalogMarkdown() : formatDiagnosticCatalogText();
+    if (options.output) {
+      const outputPath = isAbsolute3(options.output) ? options.output : join5(projectRoot, options.output);
+      mkdirSync4(dirname3(outputPath), { recursive: true });
+      writeFileSync4(outputPath, payload2, "utf-8");
+      if (!options.ci) {
+        console.log(`${GREEN2}Wrote Decantr diagnostic catalog:${RESET2} ${options.output}`);
+      }
+    } else {
+      process.stdout.write(payload2);
+    }
+    return;
+  }
+  const startedAt = Date.now();
+  const reportOptions = {
+    browser: options.browser,
+    requireBrowser: options.requireBrowser,
+    browserBaseUrl: options.browserBaseUrl ?? process.env.DECANTR_BROWSER_BASE_URL,
+    designTokensPath: options.designTokensPath
+  };
+  let report = await createProjectHealthReport(projectRoot, reportOptions);
+  const baselineComparison = options.sinceBaseline ? compareHealthBaseline(projectRoot, report) : null;
+  report = withAdditionalHealthFindings(
+    projectRoot,
+    report,
+    visualBaselineFindings(baselineComparison)
+  );
+  const baselineComparisonPath = baselineComparison ? saveHealthBaselineComparison(projectRoot, baselineComparison) : null;
+  if (options.promptId) {
+    const finding = report.findings.find((entry) => entry.id === options.promptId);
+    await sendProjectHealthReportTelemetry({
+      ci: options.ci ?? false,
+      durationMs: Date.now() - startedAt,
+      projectRoot,
+      report
+    });
+    await sendProjectHealthPromptTelemetry({
+      ci: options.ci ?? false,
+      finding,
+      projectRoot,
+      report
+    });
+    if (!finding) {
+      console.error(`${RED2}No health finding found for id: ${options.promptId}${RESET2}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(finding.remediation.prompt);
+    return;
+  }
+  const format = resolveFormat(options);
+  const failOn = options.failOn ?? "error";
+  const evidenceBundle = options.evidence ? await createProjectEvidenceBundle(projectRoot, report, reportOptions) : null;
+  const basePayload = options.evidence ? `${JSON.stringify(evidenceBundle, null, 2)}
+` : format === "json" ? formatProjectHealthJson(report) : format === "markdown" ? formatProjectHealthMarkdown(report) : formatProjectHealthText(report);
+  const payload = baselineComparison && !options.evidence && format === "text" ? `${basePayload}${formatBaselineComparisonText(baselineComparison)}` : basePayload;
+  if (options.output) {
+    const outputPath = isAbsolute3(options.output) ? options.output : join5(projectRoot, options.output);
+    mkdirSync4(dirname3(outputPath), { recursive: true });
+    writeFileSync4(outputPath, payload, "utf-8");
+    if (!options.ci) {
+      console.log(
+        `${GREEN2}Wrote Decantr ${options.evidence ? "evidence bundle" : "health report"}:${RESET2} ${options.output}`
+      );
+      if (options.browser && evidenceBundle?.browser?.status === "unavailable") {
+        const reason = evidenceBundle.browser.findings[0] ?? "Playwright is not available to Decantr in this project.";
+        console.log(`${YELLOW}Browser evidence unavailable:${RESET2} ${reason}`);
+        console.log(
+          `${DIM2}Static evidence was still written. Install Playwright or omit --browser/--base-url evidence if screenshots are not needed.${RESET2}`
+        );
+      }
+    }
+  } else {
+    process.stdout.write(payload);
+  }
+  await sendProjectHealthReportTelemetry({
+    ci: options.ci ?? false,
+    durationMs: Date.now() - startedAt,
+    failOn,
+    format,
+    outputWritten: Boolean(options.output),
+    projectRoot,
+    report
+  });
+  if (options.saveBaseline) {
+    const path = saveHealthBaseline(projectRoot, report);
+    if (!options.ci && !options.output && format !== "json" && !options.evidence) {
+      console.log(`${GREEN2}Saved Decantr health baseline:${RESET2} ${path}`);
+    } else if (!options.ci && options.output) {
+      console.log(`${GREEN2}Saved Decantr health baseline:${RESET2} ${path}`);
+    }
+  }
+  if (baselineComparisonPath && !options.ci && options.output) {
+    console.log(
+      `${GREEN2}Wrote Decantr health baseline comparison:${RESET2} ${baselineComparisonPath}`
+    );
+  }
+  if (options.ci && shouldFailHealth(report, failOn)) {
+    if (failOn !== "none") {
+      await sendProjectHealthCiFailedTelemetry({
+        ci: true,
+        durationMs: Date.now() - startedAt,
+        failOn,
+        format,
+        outputWritten: Boolean(options.output),
+        projectRoot,
+        report
+      });
+    }
+    process.exitCode = 1;
+  }
+}
+function parseHealthArgs(args) {
+  const options = {};
+  if (args[1] === "init-ci") {
+    options.initCi = {};
+    for (let index = 2; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === "--force") {
+        options.initCi.force = true;
+      } else if (arg === "--fail-on" && args[index + 1]) {
+        options.initCi.failOn = args[++index];
+      } else if (arg.startsWith("--fail-on=")) {
+        options.initCi.failOn = arg.split("=")[1];
+      } else if ((arg === "--cli-version" || arg === "--cli") && args[index + 1]) {
+        options.initCi.cliVersion = args[++index];
+      } else if (arg.startsWith("--cli-version=")) {
+        options.initCi.cliVersion = arg.split("=")[1];
+      } else if (arg.startsWith("--cli=")) {
+        options.initCi.cliVersion = arg.split("=")[1];
+      } else if (arg === "--workflow-path" && args[index + 1]) {
+        options.initCi.workflowPath = args[++index];
+      } else if (arg.startsWith("--workflow-path=")) {
+        options.initCi.workflowPath = arg.split("=")[1];
+      } else if (arg === "--report-path" && args[index + 1]) {
+        options.initCi.reportPath = args[++index];
+      } else if (arg.startsWith("--report-path=")) {
+        options.initCi.reportPath = arg.split("=")[1];
+      } else if (arg === "--json-path" && args[index + 1]) {
+        options.initCi.jsonPath = args[++index];
+      } else if (arg.startsWith("--json-path=")) {
+        options.initCi.jsonPath = arg.split("=")[1];
+      } else if (arg === "--project" && args[index + 1]) {
+        options.initCi.projectPath = args[++index];
+      } else if (arg.startsWith("--project=")) {
+        options.initCi.projectPath = arg.split("=")[1];
+      } else if (arg === "--workspace") {
+        options.initCi.workspace = true;
+      }
+    }
+    normalizeHealthFailOn(options.initCi.failOn);
+    if (!options.initCi.workspace) validateProjectPath(options.initCi.projectPath);
+    return options;
+  }
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--markdown") {
+      options.markdown = true;
+    } else if (arg === "--evidence") {
+      options.evidence = true;
+      options.json = true;
+    } else if (arg === "--browser") {
+      options.browser = true;
+    } else if (arg === "--require-browser") {
+      options.browser = true;
+      options.requireBrowser = true;
+    } else if (arg === "--save-baseline") {
+      options.saveBaseline = true;
+    } else if (arg === "--since-baseline") {
+      options.sinceBaseline = true;
+    } else if (arg === "--diagnostics") {
+      options.diagnostics = true;
+    } else if (arg === "--base-url" && args[index + 1]) {
+      options.browserBaseUrl = args[++index];
+    } else if (arg.startsWith("--base-url=")) {
+      options.browserBaseUrl = arg.split("=")[1];
+    } else if (arg === "--design-tokens" && args[index + 1]) {
+      options.designTokensPath = args[++index];
+    } else if (arg.startsWith("--design-tokens=")) {
+      options.designTokensPath = arg.split("=")[1];
+    } else if (arg === "--ci") {
+      options.ci = true;
+    } else if (arg === "--format" && args[index + 1]) {
+      options.format = args[++index];
+    } else if (arg.startsWith("--format=")) {
+      options.format = arg.split("=")[1];
+    } else if (arg === "--output" && args[index + 1]) {
+      options.output = args[++index];
+    } else if (arg.startsWith("--output=")) {
+      options.output = arg.split("=")[1];
+    } else if (arg === "--fail-on" && args[index + 1]) {
+      options.failOn = args[++index];
+    } else if (arg.startsWith("--fail-on=")) {
+      options.failOn = arg.split("=")[1];
+    } else if (arg === "--prompt" && args[index + 1]) {
+      options.promptId = args[++index];
+    } else if (arg.startsWith("--prompt=")) {
+      options.promptId = arg.split("=")[1];
+    }
+  }
+  if (options.format && !["text", "json", "markdown"].includes(options.format)) {
+    throw new Error("Invalid --format value. Use text, json, or markdown.");
+  }
+  if (options.failOn && !["error", "warn", "none"].includes(options.failOn)) {
+    throw new Error("Invalid --fail-on value. Use error, warn, or none.");
+  }
+  return options;
+}
+
+export {
+  localPatternsProposalPath,
+  localPatternsPath,
+  localRulesProposalPath,
+  localRulesPath,
+  readLocalPatternPack,
+  createBrownfieldCodifyProposal,
+  writeBrownfieldCodifyProposal,
+  writeHostedPatternMappingProposal,
+  acceptBrownfieldLocalLaw,
+  validateLocalLaw,
+  createLocalLawTaskSummary,
+  changedFiles,
+  routeImpacts,
+  styleBridgeProposalPath,
+  styleBridgePath,
+  createStyleBridgeProposal,
+  writeStyleBridgeProposal,
+  acceptStyleBridge,
+  createStyleBridgeTaskSummary,
+  styleBridgeMatches,
+  listWorkspaceAppCandidates,
+  resolveWorkspaceInfo,
+  buildGraphArtifacts,
+  cmdGraphHelp,
+  cmdGraph,
+  renderProjectHealthCiWorkflow,
+  writeProjectHealthCiWorkflow,
+  collectDesignTokenEvidence,
+  createProjectHealthReport,
+  formatProjectHealthText,
+  formatProjectHealthMarkdown,
+  formatProjectHealthJson,
+  formatDiagnosticCatalogJson,
+  formatDiagnosticCatalogMarkdown,
+  formatDiagnosticCatalogText,
+  createProjectEvidenceBundle,
+  shouldFailHealth,
+  cmdHealth,
+  parseHealthArgs
+};