@decantr/cli 2.3.1 → 2.4.1

package/dist/{chunk-3H3HWDJA.js → chunk-OD46PCR6.js}

@@ -8,11 +8,14 @@ import {
 } from "./chunk-IEW2QFYI.js";
 
 // src/commands/health.ts
+import { createRequire } from "module";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, isAbsolute, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import {
-  auditProject
+  auditProject,
+  createContractAssertions,
+  createEvidenceBundle
 } from "@decantr/verifier";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
@@ -120,16 +123,20 @@ function prefixArtifactPath(projectPath, artifactPath) {
 }
 function renderProjectHealthCiWorkflow(options = {}) {
   const failOn = normalizeHealthFailOn(options.failOn);
-  const projectPath = validateProjectPath(options.projectPath);
+  const projectPath = options.workspace ? void 0 : validateProjectPath(options.projectPath);
   const reportPath = validateArtifactPath(
-    options.reportPath || DEFAULT_HEALTH_CI_REPORT_PATH,
+    options.reportPath || (options.workspace ? ".decantr/workspace-health.md" : DEFAULT_HEALTH_CI_REPORT_PATH),
     "--report-path"
   );
-  const jsonPath = validateArtifactPath(options.jsonPath || DEFAULT_HEALTH_CI_JSON_PATH, "--json-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,
@@ -151,7 +158,7 @@ function writeProjectHealthCiWorkflow(projectRoot, options = {}) {
   }
   mkdirSync(dirname(workflowPath), { recursive: true });
   writeFileSync(workflowPath, renderProjectHealthCiWorkflow(options), "utf-8");
-  const projectPath = validateProjectPath(options.projectPath);
+  const projectPath = options.workspace ? void 0 : validateProjectPath(options.projectPath);
   const result = {
     path: workflowRelativePath,
     created: !alreadyExists,
@@ -159,6 +166,7 @@ function writeProjectHealthCiWorkflow(projectRoot, options = {}) {
     failOn: normalizeHealthFailOn(options.failOn)
   };
   if (projectPath) result.projectPath = projectPath;
+  if (options.workspace) result.workspace = true;
   return result;
 }
 function collectDeclaredRoutes(essence) {
@@ -230,6 +238,12 @@ function commandsForFinding(source) {
       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 "check":
       return ["decantr check", "decantr health"];
     default:
@@ -252,6 +266,7 @@ ${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")}`
@@ -316,7 +331,256 @@ function isDuplicateFinding(existing, finding) {
   existing.add(key);
   return false;
 }
-async function createProjectHealthReport(projectRoot = process.cwd()) {
+function resolveOptionalPath(projectRoot, path) {
+  if (!path) return void 0;
+  return isAbsolute(path) ? path : resolve(projectRoot, path);
+}
+function hasProjectPlaywright(projectRoot) {
+  try {
+    const requireFromProject = createRequire(join(projectRoot, "package.json"));
+    requireFromProject.resolve("playwright");
+    return true;
+  } catch {
+    try {
+      const requireFromProject = createRequire(join(projectRoot, "package.json"));
+      requireFromProject.resolve("@playwright/test");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function loadProjectPlaywright(projectRoot) {
+  const requireFromProject = createRequire(join(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 rerun without `--browser` for static-only evidence.",
+      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 screenshotDir = join(projectRoot, ".decantr", "evidence", "screenshots");
+  mkdirSync(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 });
+        await page.screenshot({ path: join(projectRoot, relativePath), fullPage: true });
+        screenshots.push(relativePath);
+      } catch (error) {
+        browserFindings.push(`${route}: ${error.message}`);
+      }
+    }
+  } catch (error) {
+    browserFindings.push(error.message);
+  } finally {
+    if (browser) await browser.close();
+  }
+  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 = join(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync(tokensPath)) return [];
+  const css = readFileSync(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 = isAbsolute(designTokensPath ?? "") ? "<design-tokens>" : designTokensPath ?? "<design-tokens>";
+  if (!existsSync(resolved)) {
+    return {
+      source: sourceLabel,
+      status: "error",
+      compared: 0,
+      matched: 0,
+      missing: ["design-token-source-missing"]
+    };
+  }
+  const decantrTokens = parseDecantrCssTokenNames(projectRoot);
+  const parsed = JSON.parse(readFileSync(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"
+  });
+}
+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 = [];
@@ -336,6 +600,25 @@ async function createProjectHealthReport(projectRoot = process.cwd()) {
     });
     if (!isDuplicateFinding(seen, healthFinding)) findings.push(healthFinding);
   }
+  for (const contractAssertion of createContractAssertions(projectRoot, audit)) {
+    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) {
@@ -378,17 +661,21 @@ async function createProjectHealthReport(projectRoot = process.cwd()) {
       })
     );
   }
-  const counts = countFindings(findings);
   const declaredRoutes = collectDeclaredRoutes(audit.essence);
   const manifest = audit.packManifest;
+  const browserVerification = await collectBrowserVerification(projectRoot, options, declaredRoutes);
+  if (browserVerification?.finding && !isDuplicateFinding(seen, browserVerification.finding)) {
+    findings.push(browserVerification.finding);
+  }
+  const finalCounts = countFindings(findings);
   return {
     $schema: PROJECT_HEALTH_SCHEMA_URL,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     projectRoot,
-    status: statusFromCounts(counts),
-    score: scoreFromCounts(counts),
+    status: statusFromCounts(finalCounts),
+    score: scoreFromCounts(finalCounts),
     summary: {
-      ...counts,
+      ...finalCounts,
       findingCount: findings.length,
       workflowMode: metadata.workflowMode,
       adoptionMode: metadata.adoptionMode,
@@ -509,6 +796,20 @@ function formatProjectHealthJson(report) {
   return `${JSON.stringify(report, null, 2)}
 `;
 }
+async function createProjectEvidenceBundle(projectRoot, report, options = {}) {
+  const audit = await auditProject(projectRoot);
+  const assertions = createContractAssertions(projectRoot, audit);
+  return createEvidenceBundle({
+    projectRoot,
+    report,
+    audit,
+    assertions,
+    workspaceConfigPath: existsSync(join(projectRoot, ".decantr", "workspace.json")) ? join(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";
@@ -529,7 +830,12 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
       if (result.projectPath) {
         console.log(`${DIM}Project: ${result.projectPath}${RESET}`);
       }
-      console.log(`${DIM}CI gate: decantr health --ci --fail-on ${result.failOn}${RESET}`);
+      if (result.workspace) {
+        console.log(`${DIM}Workspace mode enabled.${RESET}`);
+      }
+      console.log(
+        `${DIM}CI gate: decantr ${result.workspace ? "workspace health" : "health"} --ci --fail-on ${result.failOn}${RESET}`
+      );
     } catch (e) {
       console.error(`${RED}${e.message}${RESET}`);
       process.exitCode = 1;
@@ -537,7 +843,13 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
     return;
   }
   const startedAt = Date.now();
-  const report = await createProjectHealthReport(projectRoot);
+  const reportOptions = {
+    browser: options.browser,
+    requireBrowser: options.requireBrowser,
+    browserBaseUrl: options.browserBaseUrl ?? process.env.DECANTR_BROWSER_BASE_URL,
+    designTokensPath: options.designTokensPath
+  };
+  const report = await createProjectHealthReport(projectRoot, reportOptions);
   if (options.promptId) {
     const finding = report.findings.find((entry) => entry.id === options.promptId);
     await sendProjectHealthReportTelemetry({
@@ -562,11 +874,16 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
   }
   const format = resolveFormat(options);
   const failOn = options.failOn ?? "error";
-  const payload = format === "json" ? formatProjectHealthJson(report) : format === "markdown" ? formatProjectHealthMarkdown(report) : formatProjectHealthText(report);
+  const payload = options.evidence ? `${JSON.stringify(await createProjectEvidenceBundle(projectRoot, report, reportOptions), null, 2)}
+` : format === "json" ? formatProjectHealthJson(report) : format === "markdown" ? formatProjectHealthMarkdown(report) : formatProjectHealthText(report);
   if (options.output) {
-    writeFileSync(options.output, payload, "utf-8");
+    const outputPath = isAbsolute(options.output) ? options.output : join(projectRoot, options.output);
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, payload, "utf-8");
     if (!options.ci) {
-      console.log(`${GREEN}Wrote Decantr health report:${RESET} ${options.output}`);
+      console.log(
+        `${GREEN}Wrote Decantr ${options.evidence ? "evidence bundle" : "health report"}:${RESET} ${options.output}`
+      );
     }
   } else {
     process.stdout.write(payload);
@@ -629,10 +946,12 @@ function parseHealthArgs(args) {
         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);
-    validateProjectPath(options.initCi.projectPath);
+    if (!options.initCi.workspace) validateProjectPath(options.initCi.projectPath);
     return options;
   }
   for (let index = 1; index < args.length; index += 1) {
@@ -641,6 +960,22 @@ function parseHealthArgs(args) {
       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 === "--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]) {
@@ -673,10 +1008,12 @@ function parseHealthArgs(args) {
 export {
   renderProjectHealthCiWorkflow,
   writeProjectHealthCiWorkflow,
+  collectDesignTokenEvidence,
   createProjectHealthReport,
   formatProjectHealthText,
   formatProjectHealthMarkdown,
   formatProjectHealthJson,
+  createProjectEvidenceBundle,
   shouldFailHealth,
   cmdHealth,
   parseHealthArgs

package/dist/{chunk-WDA4SHIQ.js → chunk-P4NUDLWB.js}

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from "path";
 import { API_CONTENT_TYPES, RegistryAPIClient } from "@decantr/registry";
 var DEFAULT_API_URL = "https://api.decantr.ai/v1";
+var REGISTRY_SYNC_PAGE_SIZE = 100;
 var ALL_CONTENT_TYPES = API_CONTENT_TYPES;
 function loadFromCache(cacheDir, contentType, id, namespace) {
   const nsDir = namespace ? join(cacheDir, namespace) : cacheDir;
@@ -21,6 +22,62 @@ function saveToCache(cacheDir, contentType, id, data, namespace = "@official") {
   const cachePath = id ? join(dir, `${id}.json`) : join(dir, "index.json");
   writeFileSync(cachePath, JSON.stringify(data, null, 2));
 }
+function contentCacheKey(item) {
+  if (!item || typeof item !== "object") return null;
+  const record = item;
+  const data = record.data && typeof record.data === "object" ? record.data : null;
+  return typeof record.slug === "string" && record.slug || data && typeof data.id === "string" && data.id || data && typeof data.slug === "string" && data.slug || typeof record.id === "string" && record.id || null;
+}
+function normalizeCacheItem(item, fallbackId) {
+  if (!item || typeof item !== "object") return item;
+  const record = item;
+  const data = record.data && typeof record.data === "object" ? record.data : null;
+  if (data) {
+    return {
+      ...data,
+      id: typeof data.id === "string" ? data.id : fallbackId
+    };
+  }
+  return {
+    ...record,
+    publicId: typeof record.id === "string" && record.id !== fallbackId ? record.id : void 0,
+    id: fallbackId
+  };
+}
+async function fetchAllContent(apiClient, contentType, params = {}) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  let total = null;
+  let offset = 0;
+  for (let page = 0; page < 200; page++) {
+    const result = await apiClient.listContent(contentType, {
+      ...params,
+      limit: REGISTRY_SYNC_PAGE_SIZE,
+      offset
+    });
+    if (total == null && typeof result.total === "number") {
+      total = result.total;
+    }
+    let newItems = 0;
+    for (const item of result.items) {
+      const key = contentCacheKey(item) ?? `offset:${offset + newItems}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      items.push(item);
+      newItems++;
+    }
+    if (result.items.length === 0) break;
+    if (total != null && items.length >= total) break;
+    if (newItems === 0) break;
+    offset += result.items.length;
+  }
+  return {
+    items,
+    total: total ?? items.length,
+    limit: REGISTRY_SYNC_PAGE_SIZE,
+    offset: 0
+  };
+}
 var RegistryClient = class {
   cacheDir;
   apiUrl;
@@ -81,7 +138,7 @@ var RegistryClient = class {
     let source = { type: "cache" };
     if (!this.offline) {
       try {
-        const apiResult = await this.apiClient.listContent(contentType, {
+        const apiResult = await fetchAllContent(this.apiClient, contentType, {
           namespace,
           sort,
           recommended,
@@ -196,15 +253,17 @@ async function syncRegistry(cacheDir, apiUrl = DEFAULT_API_URL) {
   }
   for (const type of ALL_CONTENT_TYPES) {
     try {
-      const result = await apiClient.listContent(type, { namespace: "@official" });
+      const result = await fetchAllContent(apiClient, type, { namespace: "@official" });
       saveToCache(cacheDir, type, null, result, "@official");
       for (const item of result.items) {
-        const slug = item.slug;
-        const data = item.data;
-        const innerSlug = data?.id || data?.slug;
-        const cacheKey = slug || innerSlug || item.id;
+        const cacheKey = contentCacheKey(item);
         if (cacheKey) {
-          saveToCache(cacheDir, type, cacheKey, item, "@official");
+          let cacheItem = normalizeCacheItem(item, cacheKey);
+          try {
+            cacheItem = await apiClient.getContent(type, "@official", cacheKey);
+          } catch {
+          }
+          saveToCache(cacheDir, type, cacheKey, cacheItem, "@official");
         }
       }
       synced.push(type);
@@ -3910,6 +3969,44 @@ function buildFlagsString(options) {
   }
   return flags.join(" ");
 }
+function serializeConstraintValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function normalizeBlueprintDesignConstraints(designConstraints) {
+  if (!designConstraints || typeof designConstraints !== "object" || Array.isArray(designConstraints)) {
+    return void 0;
+  }
+  const constraints = {};
+  const effects = {};
+  for (const [key, value] of Object.entries(designConstraints)) {
+    if (key === "effects" && value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [effectKey, effectValue] of Object.entries(value)) {
+        const serialized2 = serializeConstraintValue(effectValue);
+        if (serialized2) effects[effectKey] = serialized2;
+      }
+      continue;
+    }
+    const serialized = serializeConstraintValue(value);
+    if (!serialized) continue;
+    if (key === "mode" && typeof value === "string") constraints.mode = value;
+    else if (key === "typography" && typeof value === "string") constraints.typography = value;
+    else if (key === "borders" && typeof value === "string") constraints.borders = value;
+    else if (key === "corners" && typeof value === "string") constraints.corners = value;
+    else if (key === "shadows" && typeof value === "string") constraints.shadows = value;
+    else effects[key] = serialized;
+  }
+  if (Object.keys(effects).length > 0) {
+    constraints.effects = effects;
+  }
+  return Object.keys(constraints).length > 0 ? constraints : void 0;
+}
 function generateTaskContextV4(templateName, essence) {
   const template = loadTemplate(templateName);
   const sections = essence.blueprint.sections;
@@ -4167,8 +4264,11 @@ async function scaffoldProject(projectRoot, options, detected, registry, archety
     if (blueprintData?.personality?.length) {
       essenceV4.dna.personality = typeof blueprintData.personality === "string" ? [blueprintData.personality] : blueprintData.personality;
     }
-    if (blueprintData?.design_constraints) {
-      essenceV4.dna.constraints = blueprintData.design_constraints;
+    const normalizedDesignConstraints = normalizeBlueprintDesignConstraints(
+      blueprintData?.design_constraints
+    );
+    if (normalizedDesignConstraints) {
+      essenceV4.dna.constraints = normalizedDesignConstraints;
     }
     if (blueprintData?.seo_hints) {
       essenceV4.meta.seo = blueprintData.seo_hints;

package/dist/{health-EENY3BFS.js → health-ZXOPGNBZ.js}

@@ -1,5 +1,7 @@
 import {
   cmdHealth,
+  collectDesignTokenEvidence,
+  createProjectEvidenceBundle,
   createProjectHealthReport,
   formatProjectHealthJson,
   formatProjectHealthMarkdown,
@@ -8,11 +10,13 @@ import {
   renderProjectHealthCiWorkflow,
   shouldFailHealth,
   writeProjectHealthCiWorkflow
-} from "./chunk-3H3HWDJA.js";
+} from "./chunk-OD46PCR6.js";
 import "./chunk-NBJCO4G5.js";
 import "./chunk-IEW2QFYI.js";
 export {
   cmdHealth,
+  collectDesignTokenEvidence,
+  createProjectEvidenceBundle,
   createProjectHealthReport,
   formatProjectHealthJson,
   formatProjectHealthMarkdown,