@harness-engineering/cli 1.13.0 → 1.13.1

package/dist/{chunk-KELT6K6M.js → chunk-PQ5YK4AY.js}

@@ -3,27 +3,23 @@ import {
   Ok
 } from "./chunk-MHBMTPW7.js";
 
-// ../core/dist/chunk-ZHGBWFYD.mjs
+// ../core/dist/chunk-D6VFA6AS.mjs
 import { z } from "zod";
-import { relative as relative2 } from "path";
 import { createHash } from "crypto";
 import { minimatch } from "minimatch";
 import { access, constants, readFile } from "fs";
 import { promisify } from "util";
+import { relative } from "path";
 import { glob } from "glob";
-import { dirname, resolve, relative } from "path";
-import { relative as relative3 } from "path";
+import { dirname, resolve } from "path";
 import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from "fs";
 import { randomBytes } from "crypto";
 import { join, dirname as dirname2 } from "path";
-import { relative as relative4 } from "path";
 import { readFile as readFile2 } from "fs/promises";
-import { relative as relative5 } from "path";
-import { relative as relative6 } from "path";
 import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join2, relative as relative7 } from "path";
+import { join as join2 } from "path";
 import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { join as join3, relative as relative8, dirname as dirname3, resolve as resolve2 } from "path";
+import { join as join3, dirname as dirname3, resolve as resolve2 } from "path";
 var ArchMetricCategorySchema = z.enum([
   "circular-deps",
   "layer-violations",
@@ -106,8 +102,7 @@ var ConstraintRuleSchema = z.object({
   // forward-compat for governs edges
 });
 function violationId(relativePath, category, normalizedDetail) {
-  const path20 = relativePath.replace(/\\/g, "/");
-  const input = `${path20}:${category}:${normalizedDetail}`;
+  const input = `${relativePath}:${category}:${normalizedDetail}`;
   return createHash("sha256").update(input).digest("hex");
 }
 function constraintRuleId(category, scope, description) {
@@ -158,6 +153,9 @@ async function readFileContent(path20) {
 async function findFiles(pattern, cwd = process.cwd()) {
   return glob(pattern, { cwd, absolute: true });
 }
+function relativePosix(from, to) {
+  return relative(from, to).replaceAll("\\", "/");
+}
 function resolveImportPath(importSource, fromFile, _rootDir) {
   if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
     return null;
@@ -209,8 +207,8 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
 function checkLayerViolations(graph, layers, rootDir) {
   const violations = [];
   for (const edge of graph.edges) {
-    const fromRelative = relative(rootDir, edge.from);
-    const toRelative = relative(rootDir, edge.to);
+    const fromRelative = relativePosix(rootDir, edge.from);
+    const toRelative = relativePosix(rootDir, edge.to);
     const fromLayer = resolveFileToLayer(fromRelative, layers);
     const toLayer = resolveFileToLayer(toRelative, layers);
     if (!fromLayer || !toLayer) continue;
@@ -436,8 +434,8 @@ var CircularDepsCollector = class {
     }
     const { cycles, largestCycle } = result.value;
     const violations = cycles.map((cycle) => {
-      const cyclePath = cycle.cycle.map((f) => relative2(rootDir, f)).join(" -> ");
-      const firstFile = relative2(rootDir, cycle.cycle[0]);
+      const cyclePath = cycle.cycle.map((f) => relativePosix(rootDir, f)).join(" -> ");
+      const firstFile = relativePosix(rootDir, cycle.cycle[0]);
       return {
         id: violationId(firstFile, this.category, cyclePath),
         file: firstFile,
@@ -499,8 +497,8 @@ var LayerViolationCollector = class {
       (v) => v.reason === "WRONG_LAYER"
     );
     const violations = layerViolations.map((v) => {
-      const relFile = relative3(rootDir, v.file);
-      const relImport = relative3(rootDir, v.imports);
+      const relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -980,7 +978,7 @@ var ComplexityCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = relative4(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}:${v.function}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1202,7 +1200,7 @@ var CouplingCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = relative5(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1266,8 +1264,8 @@ var ForbiddenImportCollector = class {
       (v) => v.reason === "FORBIDDEN_IMPORT"
     );
     const violations = forbidden.map((v) => {
-      const relFile = relative6(rootDir, v.file);
-      const relImport = relative6(rootDir, v.imports);
+      const relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `forbidden import: ${relFile} -> ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -1319,10 +1317,10 @@ async function discoverModules(rootDir) {
         }
       }
       modules.push({
-        modulePath: relative7(rootDir, dir),
+        modulePath: relativePosix(rootDir, dir),
         fileCount: tsFiles.length,
         totalLoc,
-        files: tsFiles.map((f) => relative7(rootDir, f))
+        files: tsFiles.map((f) => relativePosix(rootDir, f))
       });
     }
     for (const sub of subdirs) {
@@ -1494,7 +1492,7 @@ var DepDepthCollector = class {
     }
     const moduleMap = /* @__PURE__ */ new Map();
     for (const file of allFiles) {
-      const relDir = relative8(rootDir, dirname3(file));
+      const relDir = relativePosix(rootDir, dirname3(file));
       if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
       moduleMap.get(relDir).push(file);
     }
@@ -1743,19 +1741,18 @@ var archMatchers = {
 // ../core/dist/index.mjs
 import { join as join4, dirname as dirname4 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
-import { basename, relative as relative9 } from "path";
-import { join as join22, basename as basename2, relative as relative22 } from "path";
-import { relative as relative32, basename as basename3, dirname as dirname22 } from "path";
+import { basename } from "path";
+import { join as join22, basename as basename2 } from "path";
+import { basename as basename3, dirname as dirname22 } from "path";
 import { z as z2 } from "zod";
 import * as fs from "fs/promises";
 import * as fs2 from "fs/promises";
 import { parse } from "@typescript-eslint/typescript-estree";
-import { join as join32, resolve as resolve3, relative as relative42 } from "path";
+import { join as join32, resolve as resolve3 } from "path";
 import { minimatch as minimatch22 } from "minimatch";
 import { dirname as dirname32, resolve as resolve22 } from "path";
 import { dirname as dirname42, resolve as resolve32 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
-import { relative as relative52 } from "path";
 import { readdirSync, statSync } from "fs";
 import { join as join42 } from "path";
 import * as fs3 from "fs";
@@ -2157,7 +2154,7 @@ async function checkDocCoverage(domain, options = {}) {
   try {
     const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
     const filteredSourceFiles = sourceFiles.filter((file) => {
-      const relativePath = relative9(sourceDir, file);
+      const relativePath = relativePosix(sourceDir, file);
       return !excludePatterns.some((pattern) => {
         return minimatch2(relativePath, pattern, { dot: true }) || minimatch2(file, pattern, { dot: true });
       });
@@ -2180,7 +2177,7 @@ async function checkDocCoverage(domain, options = {}) {
     const undocumented = [];
     const gaps = [];
     for (const sourceFile of filteredSourceFiles) {
-      const relativePath = relative9(sourceDir, sourceFile);
+      const relativePath = relativePosix(sourceDir, sourceFile);
       const fileName = basename(sourceFile);
       const isDocumented = documentedPaths.has(relativePath) || documentedPaths.has(fileName) || documentedPaths.has(`src/${relativePath}`);
       if (isDocumented) {
@@ -2237,7 +2234,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
     totalLinks: agentsTotalLinks
   } = agentsResult.value;
   const existingFiles = await findFiles("**/*", rootDir);
-  const relativeExistingFiles = existingFiles.map((f) => relative22(rootDir, f));
+  const relativeExistingFiles = existingFiles.map((f) => relativePosix(rootDir, f));
   const brokenLinks = agentsBrokenLinks.map((link) => {
     const section = sections.find(
       (s) => s.links.some((l) => l.path === link.path && l.line === link.line)
@@ -2275,7 +2272,7 @@ var DEFAULT_SECTIONS = [
 function groupByDirectory(files, rootDir) {
   const groups = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const relativePath = relative32(rootDir, file);
+    const relativePath = relativePosix(rootDir, file);
     const dir = dirname22(relativePath);
     if (!groups.has(dir)) {
       groups.set(dir, []);
@@ -2331,7 +2328,7 @@ async function generateAgentsMap(config, graphSections) {
         allFiles.push(...files);
       }
       const filteredFiles = allFiles.filter((file) => {
-        const relativePath = relative32(rootDir, file);
+        const relativePath = relativePosix(rootDir, file);
         return !matchesExcludePattern(relativePath, excludePaths);
       });
       lines.push("## Repository Structure");
@@ -2359,11 +2356,11 @@ async function generateAgentsMap(config, graphSections) {
         }
         const sectionFiles = await findFiles(section.pattern, rootDir);
         const filteredSectionFiles = sectionFiles.filter((file) => {
-          const relativePath = relative32(rootDir, file);
+          const relativePath = relativePosix(rootDir, file);
           return !matchesExcludePattern(relativePath, excludePaths);
         });
         for (const file of filteredSectionFiles.slice(0, 20)) {
-          lines.push(formatFileLink(relative32(rootDir, file)));
+          lines.push(formatFileLink(relativePosix(rootDir, file)));
         }
         if (filteredSectionFiles.length > 20) {
           lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
@@ -3548,7 +3545,7 @@ async function buildSnapshot(config) {
     sourceFilePaths.push(...files2);
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
-    const rel = relative42(rootDir, f);
+    const rel = relativePosix(rootDir, f);
     return !excludePatterns.some((p) => minimatch22(rel, p));
   });
   const files = [];
@@ -4072,7 +4069,7 @@ async function detectDeadCode(snapshot, graphDeadCodeData) {
   return Ok(report);
 }
 function fileMatchesPattern(filePath, pattern, rootDir) {
-  const relativePath = relative52(rootDir, filePath);
+  const relativePath = relativePosix(rootDir, filePath);
   return minimatch3(relativePath, pattern);
 }
 function checkConfigPattern(pattern, file, rootDir) {
@@ -7943,238 +7940,270 @@ var ALL_CHECKS = [
   "phase-gate",
   "arch"
 ];
-async function runSingleCheck(name, projectRoot, config) {
-  const start = Date.now();
+async function runValidateCheck(projectRoot, config) {
   const issues = [];
-  try {
-    switch (name) {
-      case "validate": {
-        const agentsPath = path12.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
-        const result = await validateAgentsMap(agentsPath);
-        if (!result.ok) {
-          issues.push({ severity: "error", message: result.error.message });
-        } else if (!result.value.valid) {
-          if (result.value.errors) {
-            for (const err of result.value.errors) {
-              issues.push({ severity: "error", message: err.message });
-            }
-          }
-          for (const section of result.value.missingSections) {
-            issues.push({ severity: "warning", message: `Missing section: ${section}` });
-          }
-          for (const link of result.value.brokenLinks) {
-            issues.push({
-              severity: "warning",
-              message: `Broken link: ${link.text} \u2192 ${link.path}`,
-              file: link.path
-            });
-          }
-        }
-        break;
+  const agentsPath = path12.join(projectRoot, config.agentsMapPath ?? "AGENTS.md");
+  const result = await validateAgentsMap(agentsPath);
+  if (!result.ok) {
+    issues.push({ severity: "error", message: result.error.message });
+  } else if (!result.value.valid) {
+    if (result.value.errors) {
+      for (const err of result.value.errors) {
+        issues.push({ severity: "error", message: err.message });
       }
-      case "deps": {
-        const rawLayers = config.layers;
-        if (rawLayers && rawLayers.length > 0) {
-          const parser = new TypeScriptParser();
-          const layers = rawLayers.map(
-            (l) => defineLayer(
-              l.name,
-              Array.isArray(l.patterns) ? l.patterns : [l.pattern],
-              l.allowedDependencies
-            )
-          );
-          const result = await validateDependencies({
-            layers,
-            rootDir: projectRoot,
-            parser
-          });
-          if (!result.ok) {
-            issues.push({ severity: "error", message: result.error.message });
-          } else if (result.value.violations.length > 0) {
-            for (const v of result.value.violations) {
-              issues.push({
-                severity: "error",
-                message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-        }
-        break;
+    }
+    for (const section of result.value.missingSections) {
+      issues.push({ severity: "warning", message: `Missing section: ${section}` });
+    }
+    for (const link of result.value.brokenLinks) {
+      issues.push({
+        severity: "warning",
+        message: `Broken link: ${link.text} \u2192 ${link.path}`,
+        file: link.path
+      });
+    }
+  }
+  return issues;
+}
+async function runDepsCheck(projectRoot, config) {
+  const issues = [];
+  const rawLayers = config.layers;
+  if (rawLayers && rawLayers.length > 0) {
+    const parser = new TypeScriptParser();
+    const layers = rawLayers.map(
+      (l) => defineLayer(
+        l.name,
+        Array.isArray(l.patterns) ? l.patterns : [l.pattern],
+        l.allowedDependencies
+      )
+    );
+    const result = await validateDependencies({
+      layers,
+      rootDir: projectRoot,
+      parser
+    });
+    if (!result.ok) {
+      issues.push({ severity: "error", message: result.error.message });
+    } else if (result.value.violations.length > 0) {
+      for (const v of result.value.violations) {
+        issues.push({
+          severity: "error",
+          message: `${v.reason}: ${v.file} imports ${v.imports} (${v.fromLayer} \u2192 ${v.toLayer})`,
+          file: v.file,
+          line: v.line
+        });
       }
-      case "docs": {
-        const docsDir = path12.join(projectRoot, config.docsDir ?? "docs");
-        const entropyConfig = config.entropy || {};
-        const result = await checkDocCoverage("project", {
-          docsDir,
-          sourceDir: projectRoot,
-          excludePatterns: entropyConfig.excludePatterns || [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ]
+    }
+  }
+  return issues;
+}
+async function runDocsCheck(projectRoot, config) {
+  const issues = [];
+  const docsDir = path12.join(projectRoot, config.docsDir ?? "docs");
+  const entropyConfig = config.entropy || {};
+  const result = await checkDocCoverage("project", {
+    docsDir,
+    sourceDir: projectRoot,
+    excludePatterns: entropyConfig.excludePatterns || [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ]
+  });
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else if (result.value.gaps.length > 0) {
+    for (const gap of result.value.gaps) {
+      issues.push({
+        severity: "warning",
+        message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
+        file: gap.file
+      });
+    }
+  }
+  return issues;
+}
+async function runEntropyCheck(projectRoot, _config) {
+  const issues = [];
+  const analyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: { drift: true, deadCode: true, patterns: false }
+  });
+  const result = await analyzer.analyze();
+  if (!result.ok) {
+    issues.push({ severity: "warning", message: result.error.message });
+  } else {
+    const report = result.value;
+    if (report.drift) {
+      for (const drift of report.drift.drifts) {
+        issues.push({
+          severity: "warning",
+          message: `Doc drift (${drift.type}): ${drift.details}`,
+          file: drift.docFile,
+          line: drift.line
         });
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else if (result.value.gaps.length > 0) {
-          for (const gap of result.value.gaps) {
-            issues.push({
-              severity: "warning",
-              message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
-              file: gap.file
-            });
-          }
-        }
-        break;
       }
-      case "entropy": {
-        const analyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: { drift: true, deadCode: true, patterns: false }
+    }
+    if (report.deadCode) {
+      for (const dead of report.deadCode.deadExports) {
+        issues.push({
+          severity: "warning",
+          message: `Dead export: ${dead.name}`,
+          file: dead.file,
+          line: dead.line
         });
-        const result = await analyzer.analyze();
-        if (!result.ok) {
-          issues.push({ severity: "warning", message: result.error.message });
-        } else {
-          const report = result.value;
-          if (report.drift) {
-            for (const drift of report.drift.drifts) {
-              issues.push({
-                severity: "warning",
-                message: `Doc drift (${drift.type}): ${drift.details}`,
-                file: drift.docFile,
-                line: drift.line
-              });
-            }
-          }
-          if (report.deadCode) {
-            for (const dead of report.deadCode.deadExports) {
-              issues.push({
-                severity: "warning",
-                message: `Dead export: ${dead.name}`,
-                file: dead.file,
-                line: dead.line
-              });
-            }
-          }
-        }
-        break;
       }
-      case "security": {
-        const securityConfig = parseSecurityConfig(config.security);
-        if (!securityConfig.enabled) break;
-        const scanner = new SecurityScanner(securityConfig);
-        scanner.configureForProject(projectRoot);
-        const { glob: globFn } = await import("glob");
-        const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
-          cwd: projectRoot,
-          ignore: securityConfig.exclude ?? [
-            "**/node_modules/**",
-            "**/dist/**",
-            "**/*.test.ts",
-            "**/fixtures/**"
-          ],
-          absolute: true
+    }
+  }
+  return issues;
+}
+async function runSecurityCheck(projectRoot, config) {
+  const issues = [];
+  const securityConfig = parseSecurityConfig(config.security);
+  if (!securityConfig.enabled) return issues;
+  const scanner = new SecurityScanner(securityConfig);
+  scanner.configureForProject(projectRoot);
+  const { glob: globFn } = await import("glob");
+  const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
+    cwd: projectRoot,
+    ignore: securityConfig.exclude ?? [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.test.ts",
+      "**/fixtures/**"
+    ],
+    absolute: true
+  });
+  const scanResult = await scanner.scanFiles(sourceFiles);
+  for (const finding of scanResult.findings) {
+    issues.push({
+      severity: finding.severity === "info" ? "warning" : finding.severity,
+      message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
+      file: finding.file,
+      line: finding.line
+    });
+  }
+  return issues;
+}
+async function runPerfCheck(projectRoot, config) {
+  const issues = [];
+  const perfConfig = config.performance || {};
+  const perfAnalyzer = new EntropyAnalyzer({
+    rootDir: projectRoot,
+    analyze: {
+      complexity: perfConfig.complexity || true,
+      coupling: perfConfig.coupling || true,
+      sizeBudget: perfConfig.sizeBudget || false
+    }
+  });
+  const perfResult = await perfAnalyzer.analyze();
+  if (!perfResult.ok) {
+    issues.push({ severity: "warning", message: perfResult.error.message });
+  } else {
+    const perfReport = perfResult.value;
+    if (perfReport.complexity) {
+      for (const v of perfReport.complexity.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file,
+          line: v.line
         });
-        const scanResult = await scanner.scanFiles(sourceFiles);
-        for (const finding of scanResult.findings) {
-          issues.push({
-            severity: finding.severity === "info" ? "warning" : finding.severity,
-            message: `[${finding.ruleId}] ${finding.message}: ${finding.match}`,
-            file: finding.file,
-            line: finding.line
-          });
-        }
-        break;
       }
-      case "perf": {
-        const perfConfig = config.performance || {};
-        const perfAnalyzer = new EntropyAnalyzer({
-          rootDir: projectRoot,
-          analyze: {
-            complexity: perfConfig.complexity || true,
-            coupling: perfConfig.coupling || true,
-            sizeBudget: perfConfig.sizeBudget || false
-          }
+    }
+    if (perfReport.coupling) {
+      for (const v of perfReport.coupling.violations) {
+        issues.push({
+          severity: v.severity === "info" ? "warning" : v.severity,
+          message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
+          file: v.file
         });
-        const perfResult = await perfAnalyzer.analyze();
-        if (!perfResult.ok) {
-          issues.push({ severity: "warning", message: perfResult.error.message });
-        } else {
-          const perfReport = perfResult.value;
-          if (perfReport.complexity) {
-            for (const v of perfReport.complexity.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.function} in ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file,
-                line: v.line
-              });
-            }
-          }
-          if (perfReport.coupling) {
-            for (const v of perfReport.coupling.violations) {
-              issues.push({
-                severity: v.severity === "info" ? "warning" : v.severity,
-                message: `[Tier ${v.tier}] ${v.metric}: ${v.file} (${v.value} > ${v.threshold})`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
       }
-      case "phase-gate": {
-        const phaseGates = config.phaseGates;
-        if (!phaseGates?.enabled) {
-          break;
-        }
+    }
+  }
+  return issues;
+}
+async function runPhaseGateCheck(_projectRoot, config) {
+  const issues = [];
+  const phaseGates = config.phaseGates;
+  if (!phaseGates?.enabled) {
+    return issues;
+  }
+  issues.push({
+    severity: "warning",
+    message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+  });
+  return issues;
+}
+async function runArchCheck(projectRoot, config) {
+  const issues = [];
+  const rawArchConfig = config.architecture;
+  const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
+  if (!archConfig.enabled) return issues;
+  const results = await runAll(archConfig, projectRoot);
+  const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
+  const baseline = baselineManager.load();
+  if (baseline) {
+    const diffResult = diff(results, baseline);
+    if (!diffResult.passed) {
+      for (const v of diffResult.newViolations) {
         issues.push({
-          severity: "warning",
-          message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+          severity: v.severity,
+          message: `[${v.category || "arch"}] NEW: ${v.detail}`,
+          file: v.file
         });
-        break;
       }
-      case "arch": {
-        const rawArchConfig = config.architecture;
-        const archConfig = ArchConfigSchema.parse(rawArchConfig ?? {});
-        if (!archConfig.enabled) break;
-        const results = await runAll(archConfig, projectRoot);
-        const baselineManager = new ArchBaselineManager(projectRoot, archConfig.baselinePath);
-        const baseline = baselineManager.load();
-        if (baseline) {
-          const diffResult = diff(results, baseline);
-          if (!diffResult.passed) {
-            for (const v of diffResult.newViolations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${v.category || "arch"}] NEW: ${v.detail}`,
-                file: v.file
-              });
-            }
-            for (const r of diffResult.regressions) {
-              issues.push({
-                severity: "error",
-                message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
-              });
-            }
-          }
-        } else {
-          for (const result of results) {
-            for (const v of result.violations) {
-              issues.push({
-                severity: v.severity,
-                message: `[${result.category}] ${v.detail}`,
-                file: v.file
-              });
-            }
-          }
-        }
-        break;
+      for (const r of diffResult.regressions) {
+        issues.push({
+          severity: "error",
+          message: `[${r.category}] REGRESSION: ${r.currentValue} > ${r.baselineValue} (delta: ${r.delta})`
+        });
+      }
+    }
+  } else {
+    for (const result of results) {
+      for (const v of result.violations) {
+        issues.push({
+          severity: v.severity,
+          message: `[${result.category}] ${v.detail}`,
+          file: v.file
+        });
       }
     }
+  }
+  return issues;
+}
+async function runSingleCheck(name, projectRoot, config) {
+  const start = Date.now();
+  const issues = [];
+  try {
+    switch (name) {
+      case "validate":
+        issues.push(...await runValidateCheck(projectRoot, config));
+        break;
+      case "deps":
+        issues.push(...await runDepsCheck(projectRoot, config));
+        break;
+      case "docs":
+        issues.push(...await runDocsCheck(projectRoot, config));
+        break;
+      case "entropy":
+        issues.push(...await runEntropyCheck(projectRoot, config));
+        break;
+      case "security":
+        issues.push(...await runSecurityCheck(projectRoot, config));
+        break;
+      case "perf":
+        issues.push(...await runPerfCheck(projectRoot, config));
+        break;
+      case "phase-gate":
+        issues.push(...await runPhaseGateCheck(projectRoot, config));
+        break;
+      case "arch":
+        issues.push(...await runArchCheck(projectRoot, config));
+        break;
+    }
   } catch (error) {
     issues.push({
       severity: "error",
@@ -8539,7 +8568,7 @@ async function readContextFile(projectRoot, filePath, reason) {
   if (!result.ok) return null;
   const content = result.value;
   const lines = content.split("\n").length;
-  const relPath = path14.isAbsolute(filePath) ? path14.relative(projectRoot, filePath) : filePath;
+  const relPath = path14.isAbsolute(filePath) ? relativePosix(projectRoot, filePath) : filePath;
   return { path: relPath, content, reason, lines };
 }
 function extractImportSources2(content) {
@@ -8557,7 +8586,7 @@ async function resolveImportPath2(projectRoot, fromFile, importSource) {
   const fromDir = path14.dirname(path14.join(projectRoot, fromFile));
   const basePath = path14.resolve(fromDir, importSource);
   if (!isWithinProject(basePath, projectRoot)) return null;
-  const relBase = path14.relative(projectRoot, basePath);
+  const relBase = relativePosix(projectRoot, basePath);
   const candidates = [
     relBase + ".ts",
     relBase + ".tsx",
@@ -8576,7 +8605,7 @@ async function findTestFiles(projectRoot, sourceFile) {
   const baseName = path14.basename(sourceFile, path14.extname(sourceFile));
   const pattern = `**/${baseName}.{test,spec}.{ts,tsx,mts}`;
   const results = await findFiles(pattern, projectRoot);
-  return results.map((f) => path14.relative(projectRoot, f));
+  return results.map((f) => relativePosix(projectRoot, f));
 }
 async function gatherImportContext(projectRoot, changedFiles, budget) {
   const contextFiles = [];
@@ -10369,7 +10398,7 @@ function getUpdateNotification(currentVersion) {
   return `Update available: v${currentVersion} -> v${state.latestVersion}
 Run "harness update" to upgrade.`;
 }
-var VERSION = "0.11.0";
+var VERSION = "0.13.0";
 
 export {
   ArchMetricCategorySchema,