@decantr/cli 1.7.29 → 1.9.0

package/README.md

@@ -60,6 +60,8 @@ Brownfield analysis also writes `.decantr/doctrine-map.json`, a ranked source-pr
 - supports explicit workflow lanes: greenfield blueprint, greenfield contract-only, brownfield adoption, and hybrid composition
 - generates execution-pack context files for AI coding assistants
 - audits projects against Decantr contracts
+- produces local Project Health reports and a localhost Studio dashboard for end-user drift triage
+- audits local registry content repositories with Content Health reports for schema, reference, and quality coverage
 - searches the registry and showcase benchmark corpus
 - validates, refreshes, and maintains `decantr.essence.json`
 
@@ -77,10 +79,52 @@ decantr rules apply
 decantr magic "AI-native analytics workspace"
 decantr audit
 decantr check
+decantr health --ci --fail-on error
+decantr studio --port 4319 --host 127.0.0.1
+decantr content-health --ci --fail-on error
 decantr registry summary --namespace @official --json
 decantr showcase verification --json
 ```
 
+## Project Health And Studio
+
+`decantr health` is the local project observability command. It composes the existing verifier audit, guard checks, brownfield route drift checks, runtime evidence, and execution-pack files into a `ProjectHealthReport` with a status, score, route summary, pack summary, findings, and AI-ready remediation prompts.
+
+```bash
+decantr health
+decantr health --format json
+decantr health --markdown --output health.md
+decantr health --ci --fail-on error
+decantr health --ci --fail-on warn
+decantr health --prompt <finding-id>
+```
+
+Use `--json` for machines and schema validation, `--markdown` for CI summaries, and `--prompt <finding-id>` when you want a scoped remediation prompt for an AI assistant. `--ci --fail-on error` fails only when blocking errors exist; `--ci --fail-on warn` also fails on warnings.
+
+`decantr studio` starts a local-only dashboard powered by the same report. It uses Node built-ins only and serves `GET /`, `GET /api/health`, and `POST /api/refresh`.
+
+```bash
+decantr studio
+decantr studio --port 4319 --host 127.0.0.1
+```
+
+Studio is for local triage, not Decantr admin telemetry. The tabs cover Overview, Routes, Drift, Findings, Remediation, CI, and Packs without uploading source code, prompts, file paths, or project data.
+
+## Content Health
+
+`decantr content-health` is the local supply-chain observability command for registry content repositories such as `decantr-content`. It is separate from Project Health: Project Health checks an end-user app against its Decantr contract, while Content Health checks published content inputs before they flow into the hosted registry.
+
+```bash
+decantr content-health
+decantr content-health --json
+decantr content-health --markdown --output content-health.md
+decantr content-health --ci --fail-on error
+decantr content-health --ci --fail-on warn
+decantr content-health --prompt <finding-id>
+```
+
+The report validates local `patterns/`, `themes/`, `blueprints/`, `archetypes/`, and `shells/` against the published registry schemas, checks hard references such as blueprint themes and composed archetypes, summarizes softer generation-coverage gaps such as missing pattern coverage, and emits AI-ready remediation prompts. It does not call the hosted registry by default; use the existing registry drift audits when you need live publish parity.
+
 ## Greenfield Certification
 
 Use the built-in certification harness before releases when you want to prove that representative blueprints still scaffold into runnable starter projects:
@@ -155,6 +199,8 @@ Recommended read order for AI-assisted scaffolding:
 
 Treat the compiled execution packs as the source of truth. Use the narrative docs as secondary explanation, start with the shell and route structure first, and run `decantr check` plus `decantr audit` after implementation.
 
+For a broader health pass, run `decantr health` after `refresh`, before opening a pull request, or inside CI. Findings include remediation commands and can be turned into focused AI prompts with `decantr health --prompt <finding-id>`.
+
 For cold-start harness or certification runs, use only the scaffolded workspace files as the contract. If local scaffold files disagree, stop and report the mismatch rather than relying on repo-global Decantr assumptions.
 
 ## Related Packages

package/dist/bin.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import "./chunk-US6RK5QT.js";
-import "./chunk-HULA6E2D.js";
+import "./chunk-PKJSI6IH.js";
+import "./chunk-USOO77A5.js";
 import "./chunk-DI2PLOJ6.js";

package/dist/chunk-DONMNPS7.js

@@ -0,0 +1,466 @@
+import {
+  collectCheckIssues
+} from "./chunk-RSDCWAHD.js";
+
+// src/commands/health.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  auditProject
+} from "@decantr/verifier";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+var PROJECT_HEALTH_SCHEMA_URL = "https://decantr.ai/schemas/project-health-report.v1.json";
+function readProjectMetadata(projectRoot) {
+  const projectJsonPath = join(projectRoot, ".decantr", "project.json");
+  if (!existsSync(projectJsonPath)) {
+    return { workflowMode: null, adoptionMode: null, autoBrownfield: false };
+  }
+  try {
+    const data = JSON.parse(readFileSync(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 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";
+  }
+  return "audit";
+}
+function sourceFromCheckIssue(issue) {
+  if (issue.rule.startsWith("brownfield-")) return "brownfield";
+  if (issue.rule.includes("interaction")) return "interaction";
+  return "check";
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+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 "check":
+      return ["decantr check", "decantr health"];
+    default:
+      return ["decantr audit", "decantr health"];
+  }
+}
+function buildRemediationPrompt(input) {
+  return [
+    "You are fixing one Decantr Project Health finding in this local workspace.",
+    "",
+    "Read `DECANTR.md`, `decantr.essence.json`, and `.decantr/context/scaffold-pack.md` if they exist. 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}`,
+    `Message: ${input.message}`,
+    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.",
+    "",
+    `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 remediation = {
+    summary: input.suggestedFix || `Resolve ${input.category.toLowerCase()} finding.`,
+    commands,
+    prompt: buildRemediationPrompt({
+      id,
+      source: input.source,
+      category: input.category,
+      severity: input.severity,
+      message: input.message,
+      evidence: input.evidence ?? [],
+      suggestedFix: input.suggestedFix,
+      commands
+    })
+  };
+  return {
+    id,
+    source: input.source,
+    category: input.category,
+    severity: input.severity,
+    message: input.message,
+    evidence: input.evidence ?? [],
+    target: input.target,
+    file: input.file,
+    rule: input.rule,
+    suggestedFix: input.suggestedFix,
+    remediation
+  };
+}
+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;
+}
+async function createProjectHealthReport(projectRoot = process.cwd()) {
+  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,
+      baseId: finding.id
+    });
+    if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
+  }
+  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 counts = countFindings(findings);
+  const declaredRoutes = collectDeclaredRoutes(audit.essence);
+  const manifest = audit.packManifest;
+  return {
+    $schema: PROJECT_HEALTH_SCHEMA_URL,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot,
+    status: statusFromCounts(counts),
+    score: scoreFromCounts(counts),
+    summary: {
+      ...counts,
+      findingCount: findings.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(findings)
+    },
+    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
+    },
+    ci: {
+      recommendedCommand: "decantr health --ci --fail-on error",
+      failOn: "error"
+    },
+    findings
+  };
+}
+function colorForStatus(status) {
+  if (status === "healthy") return GREEN;
+  if (status === "warning") return YELLOW;
+  return RED;
+}
+function formatProjectHealthText(report) {
+  const color = colorForStatus(report.status);
+  const lines = [
+    `${BOLD}Decantr Project Health${RESET}`,
+    "",
+    `${color}${report.status.toUpperCase()}${RESET}  score ${report.score}/100`,
+    `${DIM}${report.projectRoot}${RESET}`,
+    "",
+    `${BOLD}Summary:${RESET}`,
+    `  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}`,
+    "",
+    `${BOLD}Findings:${RESET}`
+  ];
+  if (report.findings.length === 0) {
+    lines.push(`  ${GREEN}No findings. Project is healthy.${RESET}`);
+  } else {
+    for (const finding of report.findings) {
+      const findingColor = finding.severity === "error" ? RED : finding.severity === "warn" ? YELLOW : CYAN;
+      lines.push(
+        `  ${findingColor}[${finding.severity.toUpperCase()}]${RESET} ${finding.id}: ${finding.message}`
+      );
+      if (finding.evidence.length > 0) {
+        lines.push(`    ${DIM}${finding.evidence[0]}${RESET}`);
+      }
+      if (finding.suggestedFix) {
+        lines.push(`    ${DIM}Fix: ${finding.suggestedFix}${RESET}`);
+      }
+      lines.push(`    ${DIM}Prompt: decantr health --prompt ${finding.id}${RESET}`);
+    }
+  }
+  lines.push("");
+  lines.push(`${BOLD}CI:${RESET} ${report.ci.recommendedCommand}`);
+  return `${lines.join("\n")}
+`;
+}
+function formatProjectHealthMarkdown(report) {
+  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"}`,
+    "",
+    "## 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}`);
+      lines.push(`- Message: ${finding.message}`);
+      if (finding.suggestedFix) lines.push(`- Fix: ${finding.suggestedFix}`);
+      if (finding.evidence.length > 0) {
+        lines.push("- Evidence:");
+        for (const evidence of finding.evidence) lines.push(`  - ${evidence}`);
+      }
+      lines.push(`- Prompt: \`decantr health --prompt ${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 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 = {}) {
+  const report = await createProjectHealthReport(projectRoot);
+  if (options.promptId) {
+    const finding = report.findings.find((entry) => entry.id === options.promptId);
+    if (!finding) {
+      console.error(`${RED}No health finding found for id: ${options.promptId}${RESET}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(finding.remediation.prompt);
+    return;
+  }
+  const format = resolveFormat(options);
+  const payload = format === "json" ? formatProjectHealthJson(report) : format === "markdown" ? formatProjectHealthMarkdown(report) : formatProjectHealthText(report);
+  if (options.output) {
+    writeFileSync(options.output, payload, "utf-8");
+    if (!options.ci) {
+      console.log(`${GREEN}Wrote Decantr health report:${RESET} ${options.output}`);
+    }
+  } else {
+    process.stdout.write(payload);
+  }
+  if (options.ci && shouldFailHealth(report, options.failOn ?? "error")) {
+    process.exitCode = 1;
+  }
+}
+function parseHealthArgs(args) {
+  const 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 === "--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 {
+  createProjectHealthReport,
+  formatProjectHealthText,
+  formatProjectHealthMarkdown,
+  formatProjectHealthJson,
+  shouldFailHealth,
+  cmdHealth,
+  parseHealthArgs
+};

package/dist/{chunk-US6RK5QT.js → chunk-PKJSI6IH.js}

@@ -14,7 +14,7 @@ import {
   scaffoldProject,
   syncRegistry,
   writeExecutionPackBundleArtifacts
-} from "./chunk-HULA6E2D.js";
+} from "./chunk-USOO77A5.js";
 import {
   buildGuardRegistryContext,
   createDoctrineMap,
@@ -6480,6 +6480,9 @@ ${YELLOW9}You're offline. Scaffolding Decantr default.${RESET13}`);
   console.log("");
   console.log("  Commands:");
   console.log(`    ${cyan3("decantr status")}     Project health`);
+  console.log(`    ${cyan3("decantr health")}     Contract health report`);
+  console.log(`    ${cyan3("decantr content-health")} Registry content health report`);
+  console.log(`    ${cyan3("decantr studio")}     Local health dashboard`);
   console.log(`    ${cyan3("decantr search")}     Search registry`);
   console.log(`    ${cyan3("decantr get")}        Fetch content details`);
   console.log(`    ${cyan3("decantr validate")}   Check essence file`);
@@ -6924,6 +6927,7 @@ ${BOLD6}Usage:${RESET13}
   decantr registry get-pack <manifest|scaffold|review|section|page|mutation> [id] [--namespace <namespace>] [--json] [--essence <path>] [--write-context]
   decantr registry critique-file <file> [--namespace <namespace>] [--json] [--essence <path>] [--treatments <path>]
   decantr registry audit-project [--namespace <namespace>] [--json] [--essence <path>] [--dist <path>] [--sources <dir>]
+  decantr content-health [--json] [--markdown] [--ci]
   decantr rules preview [--project=<path>]
   decantr rules apply [--project=<path>]
   decantr validate [path]
@@ -6961,6 +6965,9 @@ ${BOLD6}Commands:${RESET13}
   ${cyan3("magic")}       Greenfield-first intent flow; steers existing apps into analyze + init
   ${cyan3("init")}        Attach Decantr contract/context files to an existing project or empty workspace
   ${cyan3("status")}      Show project status, DNA axioms, and blueprint info
+  ${cyan3("health")}      Generate a local Project Health report [--json] [--markdown] [--ci]
+  ${cyan3("content-health")} Generate a local registry content health report [--json] [--markdown] [--ci]
+  ${cyan3("studio")}      Open a local Project Health dashboard backed by the same report
   ${cyan3("sync")}        Sync registry content from API
   ${cyan3("audit")}       Audit the project or critique a specific file against compiled packs
   ${cyan3("migrate")}     Migrate v2 essence to v3 format (with .v2.backup.json backup)
@@ -6997,6 +7004,10 @@ ${BOLD6}Examples:${RESET13}
   decantr rules preview
   decantr rules apply
   decantr status
+  decantr health
+  decantr health --ci --fail-on error
+  decantr content-health --ci --fail-on error
+  decantr studio
   decantr audit
   decantr audit src/pages/HomePage.tsx
   decantr migrate
@@ -7157,7 +7168,7 @@ async function main() {
       break;
     }
     case "upgrade": {
-      const { cmdUpgrade } = await import("./upgrade-EV23CKA3.js");
+      const { cmdUpgrade } = await import("./upgrade-4NRDVD5N.js");
       const applyFlag = args.includes("--apply");
       await cmdUpgrade(process.cwd(), { apply: applyFlag });
       break;
@@ -7169,12 +7180,42 @@ async function main() {
           `${YELLOW9}Note: \`decantr heal\` is deprecated. Use \`decantr check\` instead.${RESET13}`
         );
       }
-      const { cmdHeal } = await import("./heal-YHLXO5QL.js");
+      const { cmdHeal } = await import("./heal-5JHGCLDX.js");
       const telemetryFlag = args.includes("--telemetry");
       const brownfieldFlag = args.includes("--brownfield");
       await cmdHeal(process.cwd(), { telemetry: telemetryFlag, brownfield: brownfieldFlag });
       break;
     }
+    case "health": {
+      try {
+        const { cmdHealth, parseHealthArgs } = await import("./health-VSL4MROO.js");
+        await cmdHealth(process.cwd(), parseHealthArgs(args));
+      } catch (e) {
+        console.error(error3(e.message));
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "content-health": {
+      try {
+        const { cmdContentHealth, parseContentHealthArgs } = await import("./content-health-QQHBR6XG.js");
+        await cmdContentHealth(process.cwd(), parseContentHealthArgs(args));
+      } catch (e) {
+        console.error(error3(e.message));
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "studio": {
+      try {
+        const { cmdStudio, parseStudioArgs } = await import("./studio-BCTWKXFH.js");
+        await cmdStudio(process.cwd(), parseStudioArgs(args));
+      } catch (e) {
+        console.error(error3(e.message));
+        process.exitCode = 1;
+      }
+      break;
+    }
     case "migrate": {
       await cmdMigrate(process.cwd());
       break;