@decantr/cli 2.9.1 → 2.9.3

package/dist/{chunk-TMOCTDYY.js → chunk-XZFKK6V7.js}

@@ -8,15 +8,105 @@ import {
 // src/commands/health.ts
 import { execFileSync } from "child_process";
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { createRequire } from "module";
-import { dirname, isAbsolute, join, resolve } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import {
   auditProject,
   createContractAssertions,
   createEvidenceBundle
 } 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 workspaceRoot = findWorkspaceRoot(absoluteCwd) ?? absoluteCwd;
+  const appRoot = projectArg ? resolve(isAbsolute(projectArg) ? "/" : workspaceRoot, projectArg) : 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/health.ts
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
@@ -29,14 +119,14 @@ 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 = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 function readProjectMetadata(projectRoot) {
-  const projectJsonPath = join(projectRoot, ".decantr", "project.json");
-  if (!existsSync(projectJsonPath)) {
+  const projectJsonPath = join2(projectRoot, ".decantr", "project.json");
+  if (!existsSync2(projectJsonPath)) {
     return { workflowMode: null, adoptionMode: null, autoBrownfield: false };
   }
   try {
-    const data = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+    const data = JSON.parse(readFileSync2(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 {
@@ -49,12 +139,12 @@ function readProjectMetadata(projectRoot) {
   }
 }
 function loadHealthTemplate(name) {
-  const fromDist = join(__dirname, "..", "src", "templates", name);
-  if (existsSync(fromDist)) return readFileSync(fromDist, "utf-8");
-  const fromSrc = join(__dirname, "..", "templates", name);
-  if (existsSync(fromSrc)) return readFileSync(fromSrc, "utf-8");
-  const fromCommandSrc = join(__dirname, "..", "..", "templates", name);
-  if (existsSync(fromCommandSrc)) return readFileSync(fromCommandSrc, "utf-8");
+  const fromDist = join2(__dirname, "..", "src", "templates", name);
+  if (existsSync2(fromDist)) return readFileSync2(fromDist, "utf-8");
+  const fromSrc = join2(__dirname, "..", "templates", name);
+  if (existsSync2(fromSrc)) return readFileSync2(fromSrc, "utf-8");
+  const fromCommandSrc = join2(__dirname, "..", "..", "templates", name);
+  if (existsSync2(fromCommandSrc)) return readFileSync2(fromCommandSrc, "utf-8");
   throw new Error(`Template not found: ${name}`);
 }
 function renderTemplate(template, vars) {
@@ -149,14 +239,14 @@ function writeProjectHealthCiWorkflow(projectRoot, options = {}) {
   const workflowRelativePath = validateWorkflowPath(
     options.workflowPath || DEFAULT_HEALTH_CI_WORKFLOW_PATH
   );
-  const workflowPath = join(projectRoot, workflowRelativePath);
-  const alreadyExists = existsSync(workflowPath);
+  const workflowPath = join2(projectRoot, workflowRelativePath);
+  const alreadyExists = existsSync2(workflowPath);
   if (alreadyExists && !options.force) {
     throw new Error(
       `${workflowRelativePath} already exists. Re-run with --force to replace it, or use --workflow-path <file>.`
     );
   }
-  mkdirSync(dirname(workflowPath), { recursive: true });
+  mkdirSync(dirname2(workflowPath), { recursive: true });
   writeFileSync(workflowPath, renderProjectHealthCiWorkflow(options), "utf-8");
   const projectPath = options.workspace ? void 0 : validateProjectPath(options.projectPath);
   const result = {
@@ -243,23 +333,26 @@ function contractAssertionApplies(assertion, metadata) {
   if (assertion.rule === "tokens-file-present" && metadata.adoptionMode === "contract-only") {
     return false;
   }
+  if (metadata.adoptionMode === "contract-only" && (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 hashFile(path) {
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   try {
-    return createHash("sha256").update(readFileSync(path)).digest("hex");
+    return createHash("sha256").update(readFileSync2(path)).digest("hex");
   } catch {
     return null;
   }
 }
 function readJsonFile(path) {
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    return JSON.parse(readFileSync2(path, "utf-8"));
   } catch {
     return null;
   }
@@ -290,6 +383,90 @@ function commandsForFinding(source) {
       return ["decantr audit", "decantr health"];
   }
 }
+function commandContextForProject(projectRoot) {
+  const workspaceInfo = resolveWorkspaceInfo(projectRoot);
+  const relativeProjectPath = relative(workspaceInfo.workspaceRoot, projectRoot).replace(
+    /\\/g,
+    "/"
+  );
+  const projectPath = relativeProjectPath && !relativeProjectPath.startsWith("..") && !isAbsolute2(relativeProjectPath) ? relativeProjectPath : null;
+  const projectFlag = projectPath ? ` --project ${projectPath}` : "";
+  const essencePath = projectPath ? `${projectPath}/decantr.essence.json` : "decantr.essence.json";
+  return {
+    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) {
+  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 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,
+          evidence: finding.evidence,
+          suggestedFix,
+          commands
+        })
+      }
+    };
+  });
+}
 function buildRemediationPrompt(input) {
   return [
     "You are fixing one Decantr Project Health finding in this local workspace.",
@@ -345,6 +522,69 @@ function createHealthFinding(input) {
     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,
@@ -377,16 +617,16 @@ function isDuplicateFinding(existing, finding) {
 }
 function resolveOptionalPath(projectRoot, path) {
   if (!path) return void 0;
-  return isAbsolute(path) ? path : resolve(projectRoot, path);
+  return isAbsolute2(path) ? path : resolve2(projectRoot, path);
 }
 function hasProjectPlaywright(projectRoot) {
   try {
-    const requireFromProject = createRequire(join(projectRoot, "package.json"));
+    const requireFromProject = createRequire(join2(projectRoot, "package.json"));
     requireFromProject.resolve("playwright");
     return true;
   } catch {
     try {
-      const requireFromProject = createRequire(join(projectRoot, "package.json"));
+      const requireFromProject = createRequire(join2(projectRoot, "package.json"));
       requireFromProject.resolve("@playwright/test");
       return true;
     } catch {
@@ -395,7 +635,7 @@ function hasProjectPlaywright(projectRoot) {
   }
 }
 function loadProjectPlaywright(projectRoot) {
-  const requireFromProject = createRequire(join(projectRoot, "package.json"));
+  const requireFromProject = createRequire(join2(projectRoot, "package.json"));
   for (const packageName of ["playwright", "@playwright/test"]) {
     try {
       const loaded = requireFromProject(packageName);
@@ -485,7 +725,7 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
   const screenshots = [];
   const browserFindings = [];
   const visualRoutes = [];
-  const screenshotDir = join(projectRoot, ".decantr", "evidence", "screenshots");
+  const screenshotDir = join2(projectRoot, ".decantr", "evidence", "screenshots");
   mkdirSync(screenshotDir, { recursive: true });
   let browser = null;
   try {
@@ -496,7 +736,7 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
       const relativePath = browserScreenshotRelativePath(route);
       try {
         await page.goto(url, { waitUntil: "networkidle", timeout: 15e3 });
-        const absoluteScreenshotPath = join(projectRoot, relativePath);
+        const absoluteScreenshotPath = join2(projectRoot, relativePath);
         await page.screenshot({ path: absoluteScreenshotPath, fullPage: true });
         screenshots.push(relativePath);
         visualRoutes.push({
@@ -531,8 +771,8 @@ async function collectBrowserVerification(projectRoot, options, declaredRoutes)
     baseUrl: options.browserBaseUrl,
     routes: visualRoutes
   };
-  const visualManifestPath = join(projectRoot, ".decantr", "evidence", "visual-manifest.json");
-  mkdirSync(dirname(visualManifestPath), { recursive: true });
+  const visualManifestPath = join2(projectRoot, ".decantr", "evidence", "visual-manifest.json");
+  mkdirSync(dirname2(visualManifestPath), { recursive: true });
   writeFileSync(visualManifestPath, JSON.stringify(visualManifest, null, 2) + "\n", "utf-8");
   if (browserFindings.length > 0) {
     const finding = createHealthFinding({
@@ -582,9 +822,9 @@ function flattenDesignTokenKeys(value, prefix = "") {
   return keys;
 }
 function parseDecantrCssTokenNames(projectRoot) {
-  const tokensPath = join(projectRoot, "src", "styles", "tokens.css");
-  if (!existsSync(tokensPath)) return [];
-  const css = readFileSync(tokensPath, "utf-8");
+  const tokensPath = join2(projectRoot, "src", "styles", "tokens.css");
+  if (!existsSync2(tokensPath)) return [];
+  const css = readFileSync2(tokensPath, "utf-8");
   const names = /* @__PURE__ */ new Set();
   for (const match of css.matchAll(/(--d-[\w-]+)\s*:/g)) {
     names.add(match[1]);
@@ -594,8 +834,8 @@ function parseDecantrCssTokenNames(projectRoot) {
 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)) {
+  const sourceLabel = isAbsolute2(designTokensPath ?? "") ? "<design-tokens>" : designTokensPath ?? "<design-tokens>";
+  if (!existsSync2(resolved)) {
     return {
       source: sourceLabel,
       status: "error",
@@ -605,7 +845,7 @@ function collectDesignTokenEvidence(projectRoot, designTokensPath) {
     };
   }
   const decantrTokens = parseDecantrCssTokenNames(projectRoot);
-  const parsed = JSON.parse(readFileSync(resolved, "utf-8"));
+  const parsed = JSON.parse(readFileSync2(resolved, "utf-8"));
   const designKeys = flattenDesignTokenKeys(parsed);
   const missing = decantrTokens.filter((token) => {
     const bare = token.replace(/^--/, "");
@@ -648,19 +888,19 @@ function collectDesignTokenFinding(projectRoot, designTokensPath) {
   });
 }
 function baselinePath(projectRoot) {
-  return join(projectRoot, ".decantr", "health-baseline.json");
+  return join2(projectRoot, ".decantr", "health-baseline.json");
 }
 function baselineDiffPath(projectRoot) {
-  return join(projectRoot, ".decantr", "health-baseline-diff.json");
+  return join2(projectRoot, ".decantr", "health-baseline-diff.json");
 }
 function screenshotHashes(projectRoot) {
   const manifest = readJsonFile(
-    join(projectRoot, ".decantr", "evidence", "visual-manifest.json")
+    join2(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 ?? hashFile(join(projectRoot, route.screenshot))
+      hash: route.screenshotHash ?? hashFile(join2(projectRoot, route.screenshot))
     }));
   }
   return [];
@@ -688,7 +928,7 @@ function changedFilesSinceBaseline(projectRoot) {
 }
 function routeImpactsFromChangedFiles(report, changedFiles) {
   const analysis = readJsonFile(
-    join(report.projectRoot, ".decantr", "analysis.json")
+    join2(report.projectRoot, ".decantr", "analysis.json")
   );
   const routeEntries = analysis?.routes?.routes ?? [];
   const impacted = /* @__PURE__ */ new Set();
@@ -721,7 +961,7 @@ function createHealthBaseline(projectRoot, report) {
 }
 function saveHealthBaseline(projectRoot, report) {
   const path = baselinePath(projectRoot);
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   writeFileSync(
     path,
     JSON.stringify(createHealthBaseline(projectRoot, report), null, 2) + "\n",
@@ -760,7 +1000,7 @@ function compareHealthBaseline(projectRoot, report) {
 }
 function saveHealthBaselineComparison(projectRoot, comparison) {
   const path = baselineDiffPath(projectRoot);
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   writeFileSync(path, JSON.stringify(comparison, null, 2) + "\n", "utf-8");
   return path;
 }
@@ -869,6 +1109,13 @@ async function createProjectHealthReport(projectRoot = process.cwd(), options =
   }
   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 browserVerification = await collectBrowserVerification(
     projectRoot,
     options,
@@ -877,7 +1124,9 @@ async function createProjectHealthReport(projectRoot = process.cwd(), options =
   if (browserVerification?.finding && !isDuplicateFinding(seen, browserVerification.finding)) {
     findings.push(browserVerification.finding);
   }
-  const finalCounts = countFindings(findings);
+  const scopedFindings = scopeHealthFindingsToProject(projectRoot, findings);
+  const finalCounts = countFindings(scopedFindings);
+  const commandContext = commandContextForProject(projectRoot);
   return {
     $schema: PROJECT_HEALTH_SCHEMA_URL,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -901,7 +1150,7 @@ async function createProjectHealthReport(projectRoot = process.cwd(), options =
       runtimeChecked: audit.runtimeAudit.routeHintsChecked,
       runtimeMatched: audit.runtimeAudit.routeHintsMatched,
       runtimeCoverageOk: audit.summary.runtimeAuditChecked ? audit.runtimeAudit.routeHintsCoverageOk : null,
-      issues: routeIssuesFromFindings(findings)
+      issues: routeIssuesFromFindings(scopedFindings)
     },
     packs: {
       manifestPresent: Boolean(manifest),
@@ -913,10 +1162,10 @@ async function createProjectHealthReport(projectRoot = process.cwd(), options =
       generatedAt: typeof manifest?.generatedAt === "string" ? manifest.generatedAt : null
     },
     ci: {
-      recommendedCommand: "decantr ci --fail-on error",
+      recommendedCommand: commandContext.ciCommand,
       failOn: "error"
     },
-    findings
+    findings: scopedFindings
   };
 }
 function colorForStatus(status) {
@@ -926,6 +1175,7 @@ function colorForStatus(status) {
 }
 function formatProjectHealthText(report) {
   const color = colorForStatus(report.status);
+  const commandContext = commandContextForProject(report.projectRoot);
   const lines = [
     `${BOLD}Decantr Project Health${RESET}`,
     "",
@@ -955,7 +1205,7 @@ function formatProjectHealthText(report) {
       if (finding.suggestedFix) {
         lines.push(`    ${DIM}Fix: ${finding.suggestedFix}${RESET}`);
       }
-      lines.push(`    ${DIM}Prompt: decantr health --prompt ${finding.id}${RESET}`);
+      lines.push(`    ${DIM}Prompt: ${commandContext.promptCommand(finding.id)}${RESET}`);
     }
   }
   lines.push("");
@@ -964,6 +1214,7 @@ function formatProjectHealthText(report) {
 `;
 }
 function formatProjectHealthMarkdown(report) {
+  const commandContext = commandContextForProject(report.projectRoot);
   const lines = [
     "# Decantr Project Health",
     "",
@@ -992,7 +1243,7 @@ function formatProjectHealthMarkdown(report) {
         lines.push("- Evidence:");
         for (const evidence of finding.evidence) lines.push(`  - ${evidence}`);
       }
-      lines.push(`- Prompt: \`decantr health --prompt ${finding.id}\``);
+      lines.push(`- Prompt: \`${commandContext.promptCommand(finding.id)}\``);
       lines.push("");
     }
   }
@@ -1014,7 +1265,7 @@ async function createProjectEvidenceBundle(projectRoot, report, options = {}) {
     report,
     audit,
     assertions,
-    workspaceConfigPath: existsSync(join(projectRoot, ".decantr", "workspace.json")) ? join(projectRoot, ".decantr", "workspace.json") : null,
+    workspaceConfigPath: existsSync2(join2(projectRoot, ".decantr", "workspace.json")) ? join2(projectRoot, ".decantr", "workspace.json") : null,
     designTokensPath: resolveOptionalPath(projectRoot, options.designTokensPath) ?? null,
     browser: await browserEvidenceFromOptions(projectRoot, options, report.routes.declared),
     designTokens: collectDesignTokenEvidence(projectRoot, options.designTokensPath)
@@ -1086,17 +1337,25 @@ async function cmdHealth(projectRoot = process.cwd(), options = {}) {
   }
   const format = resolveFormat(options);
   const failOn = options.failOn ?? "error";
-  const basePayload = options.evidence ? `${JSON.stringify(await createProjectEvidenceBundle(projectRoot, report, reportOptions), null, 2)}
+  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 = isAbsolute(options.output) ? options.output : join(projectRoot, options.output);
-    mkdirSync(dirname(outputPath), { recursive: true });
+    const outputPath = isAbsolute2(options.output) ? options.output : join2(projectRoot, options.output);
+    mkdirSync(dirname2(outputPath), { recursive: true });
     writeFileSync(outputPath, payload, "utf-8");
     if (!options.ci) {
       console.log(
         `${GREEN}Wrote Decantr ${options.evidence ? "evidence bundle" : "health report"}:${RESET} ${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:${RESET} ${reason}`);
+        console.log(
+          `${DIM}Static evidence was still written. Install Playwright or rerun without --browser if screenshots are not needed.${RESET}`
+        );
+      }
     }
   } else {
     process.stdout.write(payload);
@@ -1236,6 +1495,8 @@ function parseHealthArgs(args) {
 }
 
 export {
+  listWorkspaceAppCandidates,
+  resolveWorkspaceInfo,
   renderProjectHealthCiWorkflow,
   writeProjectHealthCiWorkflow,
   collectDesignTokenEvidence,

package/dist/{health-Q7XF3I5Z.js → health-MB63O56B.js}

@@ -10,7 +10,7 @@ import {
   renderProjectHealthCiWorkflow,
   shouldFailHealth,
   writeProjectHealthCiWorkflow
-} from "./chunk-TMOCTDYY.js";
+} from "./chunk-XZFKK6V7.js";
 import "./chunk-34TZXWIF.js";
 export {
   cmdHealth,

package/dist/index.js

@@ -1,5 +1,5 @@
-import "./chunk-6UDJDQPT.js";
+import "./chunk-VMNUJOEH.js";
 import "./chunk-RXF7ZYGK.js";
-import "./chunk-FKM4OQDF.js";
-import "./chunk-TMOCTDYY.js";
+import "./chunk-ARR3EPS2.js";
+import "./chunk-XZFKK6V7.js";
 import "./chunk-34TZXWIF.js";

package/dist/{studio-EDQMI6JE.js → studio-6QGXJBVH.js}

@@ -1,9 +1,9 @@
 import {
   createWorkspaceHealthReport
-} from "./chunk-FKM4OQDF.js";
+} from "./chunk-ARR3EPS2.js";
 import {
   createProjectHealthReport
-} from "./chunk-TMOCTDYY.js";
+} from "./chunk-XZFKK6V7.js";
 import {
   sendStudioHealthRefreshedTelemetry,
   sendStudioStartedTelemetry

package/dist/{workspace-JA2RZI6V.js → workspace-OGFYJA4N.js}

@@ -7,8 +7,8 @@ import {
   listWorkspaceProjects,
   parseWorkspaceArgs,
   shouldFailWorkspaceHealth
-} from "./chunk-FKM4OQDF.js";
-import "./chunk-TMOCTDYY.js";
+} from "./chunk-ARR3EPS2.js";
+import "./chunk-XZFKK6V7.js";
 import "./chunk-34TZXWIF.js";
 export {
   cmdWorkspace,