@harness-engineering/core 0.13.0 → 0.13.1

package/dist/index.js

@@ -273,6 +273,7 @@ var import_types = require("@harness-engineering/types");
 // src/shared/fs-utils.ts
 var import_fs = require("fs");
 var import_util = require("util");
+var import_node_path = require("path");
 var import_glob = require("glob");
 var accessAsync = (0, import_util.promisify)(import_fs.access);
 var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
@@ -295,6 +296,9 @@ async function readFileContent(path20) {
 async function findFiles(pattern, cwd = process.cwd()) {
   return (0, import_glob.glob)(pattern, { cwd, absolute: true });
 }
+function relativePosix(from, to) {
+  return (0, import_node_path.relative)(from, to).replaceAll("\\", "/");
+}
 
 // src/validation/file-structure.ts
 async function validateFileStructure(projectPath, conventions) {
@@ -656,7 +660,7 @@ async function checkDocCoverage(domain, options = {}) {
   try {
     const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
     const filteredSourceFiles = sourceFiles.filter((file) => {
-      const relativePath = (0, import_path2.relative)(sourceDir, file);
+      const relativePath = relativePosix(sourceDir, file);
       return !excludePatterns.some((pattern) => {
         return (0, import_minimatch.minimatch)(relativePath, pattern, { dot: true }) || (0, import_minimatch.minimatch)(file, pattern, { dot: true });
       });
@@ -679,7 +683,7 @@ async function checkDocCoverage(domain, options = {}) {
     const undocumented = [];
     const gaps = [];
     for (const sourceFile of filteredSourceFiles) {
-      const relativePath = (0, import_path2.relative)(sourceDir, sourceFile);
+      const relativePath = relativePosix(sourceDir, sourceFile);
       const fileName = (0, import_path2.basename)(sourceFile);
       const isDocumented = documentedPaths.has(relativePath) || documentedPaths.has(fileName) || documentedPaths.has(`src/${relativePath}`);
       if (isDocumented) {
@@ -739,7 +743,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
     totalLinks: agentsTotalLinks
   } = agentsResult.value;
   const existingFiles = await findFiles("**/*", rootDir);
-  const relativeExistingFiles = existingFiles.map((f) => (0, import_path3.relative)(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)
@@ -780,7 +784,7 @@ var DEFAULT_SECTIONS = [
 function groupByDirectory(files, rootDir) {
   const groups = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const relativePath = (0, import_path4.relative)(rootDir, file);
+    const relativePath = relativePosix(rootDir, file);
     const dir = (0, import_path4.dirname)(relativePath);
     if (!groups.has(dir)) {
       groups.set(dir, []);
@@ -836,7 +840,7 @@ async function generateAgentsMap(config, graphSections) {
         allFiles.push(...files);
       }
       const filteredFiles = allFiles.filter((file) => {
-        const relativePath = (0, import_path4.relative)(rootDir, file);
+        const relativePath = relativePosix(rootDir, file);
         return !matchesExcludePattern(relativePath, excludePaths);
       });
       lines.push("## Repository Structure");
@@ -864,11 +868,11 @@ async function generateAgentsMap(config, graphSections) {
         }
         const sectionFiles = await findFiles(section.pattern, rootDir);
         const filteredSectionFiles = sectionFiles.filter((file) => {
-          const relativePath = (0, import_path4.relative)(rootDir, file);
+          const relativePath = relativePosix(rootDir, file);
           return !matchesExcludePattern(relativePath, excludePaths);
         });
         for (const file of filteredSectionFiles.slice(0, 20)) {
-          lines.push(formatFileLink((0, import_path4.relative)(rootDir, file)));
+          lines.push(formatFileLink(relativePosix(rootDir, file)));
         }
         if (filteredSectionFiles.length > 20) {
           lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
@@ -1139,8 +1143,8 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
 function checkLayerViolations(graph, layers, rootDir) {
   const violations = [];
   for (const edge of graph.edges) {
-    const fromRelative = (0, import_path5.relative)(rootDir, edge.from);
-    const toRelative = (0, import_path5.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;
@@ -2335,7 +2339,7 @@ async function buildSnapshot(config) {
     sourceFilePaths.push(...files2);
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
-    const rel = (0, import_path6.relative)(rootDir, f);
+    const rel = relativePosix(rootDir, f);
     return !excludePatterns.some((p) => (0, import_minimatch3.minimatch)(rel, p));
   });
   const files = [];
@@ -2867,9 +2871,8 @@ async function detectDeadCode(snapshot, graphDeadCodeData) {
 
 // src/entropy/detectors/patterns.ts
 var import_minimatch4 = require("minimatch");
-var import_path9 = require("path");
 function fileMatchesPattern(filePath, pattern, rootDir) {
-  const relativePath = (0, import_path9.relative)(rootDir, filePath);
+  const relativePath = relativePosix(rootDir, filePath);
   return (0, import_minimatch4.minimatch)(relativePath, pattern);
 }
 function checkConfigPattern(pattern, file, rootDir) {
@@ -3465,7 +3468,7 @@ async function detectCouplingViolations(snapshot, config, graphData) {
 
 // src/entropy/detectors/size-budget.ts
 var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 function parseSize(size) {
   const match = size.trim().match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
   if (!match) return 0;
@@ -3492,7 +3495,7 @@ function dirSize(dirPath) {
   }
   for (const entry of entries) {
     if (entry === "node_modules" || entry === ".git") continue;
-    const fullPath = (0, import_node_path.join)(dirPath, entry);
+    const fullPath = (0, import_node_path2.join)(dirPath, entry);
     try {
       const stat = (0, import_node_fs.statSync)(fullPath);
       if (stat.isDirectory()) {
@@ -3512,7 +3515,7 @@ async function detectSizeBudgetViolations(rootDir, config) {
   let packagesChecked = 0;
   for (const [pkgPath, budget] of Object.entries(budgets)) {
     packagesChecked++;
-    const distPath = (0, import_node_path.join)(rootDir, pkgPath, "dist");
+    const distPath = (0, import_node_path2.join)(rootDir, pkgPath, "dist");
     const currentSize = dirSize(distPath);
     if (budget.warn) {
       const budgetBytes = parseSize(budget.warn);
@@ -3893,7 +3896,7 @@ var EntropyAnalyzer = class {
 // src/entropy/fixers/safe-fixes.ts
 var fs3 = __toESM(require("fs"));
 var import_util2 = require("util");
-var import_path10 = require("path");
+var import_path9 = require("path");
 var readFile5 = (0, import_util2.promisify)(fs3.readFile);
 var writeFile3 = (0, import_util2.promisify)(fs3.writeFile);
 var unlink2 = (0, import_util2.promisify)(fs3.unlink);
@@ -3909,7 +3912,7 @@ function createDeadFileFixes(deadCodeReport) {
   return deadCodeReport.deadFiles.map((file) => ({
     type: "dead-files",
     file: file.path,
-    description: `Delete dead file (${file.reason}): ${(0, import_path10.basename)(file.path)}`,
+    description: `Delete dead file (${file.reason}): ${(0, import_path9.basename)(file.path)}`,
     action: "delete-file",
     safe: true,
     reversible: true
@@ -3992,9 +3995,9 @@ function previewFix(fix) {
   }
 }
 async function createBackup(filePath, backupDir) {
-  const backupPath = (0, import_path10.join)(backupDir, `${Date.now()}-${(0, import_path10.basename)(filePath)}`);
+  const backupPath = (0, import_path9.join)(backupDir, `${Date.now()}-${(0, import_path9.basename)(filePath)}`);
   try {
-    await mkdir2((0, import_path10.dirname)(backupPath), { recursive: true });
+    await mkdir2((0, import_path9.dirname)(backupPath), { recursive: true });
     await copyFile2(filePath, backupPath);
     return (0, import_types.Ok)(backupPath);
   } catch (e) {
@@ -4330,11 +4333,11 @@ function validatePatternConfig(config) {
 
 // src/performance/baseline-manager.ts
 var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var BaselineManager = class {
   baselinesPath;
   constructor(projectRoot) {
-    this.baselinesPath = (0, import_node_path2.join)(projectRoot, ".harness", "perf", "baselines.json");
+    this.baselinesPath = (0, import_node_path3.join)(projectRoot, ".harness", "perf", "baselines.json");
   }
   /**
    * Load the baselines file from disk.
@@ -4374,7 +4377,7 @@ var BaselineManager = class {
       updatedFrom: commitHash,
       benchmarks
     };
-    const dir = (0, import_node_path2.dirname)(this.baselinesPath);
+    const dir = (0, import_node_path3.dirname)(this.baselinesPath);
     if (!(0, import_node_fs2.existsSync)(dir)) {
       (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
     }
@@ -5365,7 +5368,7 @@ async function requestMultiplePeerReviews(requests) {
 
 // src/feedback/logging/file-sink.ts
 var import_fs2 = require("fs");
-var import_path11 = require("path");
+var import_path10 = require("path");
 var FileSink = class {
   name = "file";
   filePath;
@@ -5388,7 +5391,7 @@ var FileSink = class {
   }
   ensureDirectory() {
     if (!this.initialized) {
-      const dir = (0, import_path11.dirname)(this.filePath);
+      const dir = (0, import_path10.dirname)(this.filePath);
       if (!(0, import_fs2.existsSync)(dir)) {
         (0, import_fs2.mkdirSync)(dir, { recursive: true });
       }
@@ -5535,14 +5538,10 @@ var ConstraintRuleSchema = import_zod3.z.object({
   // forward-compat for governs edges
 });
 
-// src/architecture/collectors/circular-deps.ts
-var import_node_path3 = require("path");
-
 // src/architecture/collectors/hash.ts
 var import_node_crypto = require("crypto");
 function violationId(relativePath, category, normalizedDetail) {
-  const path20 = relativePath.replace(/\\/g, "/");
-  const input = `${path20}:${category}:${normalizedDetail}`;
+  const input = `${relativePath}:${category}:${normalizedDetail}`;
   return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
 }
 function constraintRuleId(category, scope, description) {
@@ -5606,8 +5605,8 @@ var CircularDepsCollector = class {
     }
     const { cycles, largestCycle } = result.value;
     const violations = cycles.map((cycle) => {
-      const cyclePath = cycle.cycle.map((f) => (0, import_node_path3.relative)(rootDir, f)).join(" -> ");
-      const firstFile = (0, import_node_path3.relative)(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,
@@ -5628,7 +5627,6 @@ var CircularDepsCollector = class {
 };
 
 // src/architecture/collectors/layer-violations.ts
-var import_node_path4 = require("path");
 var LayerViolationCollector = class {
   category = "layer-violations";
   getRules(_config, _rootDir) {
@@ -5672,8 +5670,8 @@ var LayerViolationCollector = class {
       (v) => v.reason === "WRONG_LAYER"
     );
     const violations = layerViolations.map((v) => {
-      const relFile = (0, import_node_path4.relative)(rootDir, v.file);
-      const relImport = (0, import_node_path4.relative)(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),
@@ -5695,7 +5693,6 @@ var LayerViolationCollector = class {
 };
 
 // src/architecture/collectors/complexity.ts
-var import_node_path5 = require("path");
 var ComplexityCollector = class {
   category = "complexity";
   getRules(_config, _rootDir) {
@@ -5756,7 +5753,7 @@ var ComplexityCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = (0, import_node_path5.relative)(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}:${v.function}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -5782,7 +5779,6 @@ var ComplexityCollector = class {
 };
 
 // src/architecture/collectors/coupling.ts
-var import_node_path6 = require("path");
 var CouplingCollector = class {
   category = "coupling";
   getRules(_config, _rootDir) {
@@ -5833,7 +5829,7 @@ var CouplingCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = (0, import_node_path6.relative)(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -5856,7 +5852,6 @@ var CouplingCollector = class {
 };
 
 // src/architecture/collectors/forbidden-imports.ts
-var import_node_path7 = require("path");
 var ForbiddenImportCollector = class {
   category = "forbidden-imports";
   getRules(_config, _rootDir) {
@@ -5900,8 +5895,8 @@ var ForbiddenImportCollector = class {
       (v) => v.reason === "FORBIDDEN_IMPORT"
     );
     const violations = forbidden.map((v) => {
-      const relFile = (0, import_node_path7.relative)(rootDir, v.file);
-      const relImport = (0, import_node_path7.relative)(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),
@@ -5924,7 +5919,7 @@ var ForbiddenImportCollector = class {
 
 // src/architecture/collectors/module-size.ts
 var import_promises2 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path4 = require("path");
 async function discoverModules(rootDir) {
   const modules = [];
   async function scanDir(dir) {
@@ -5940,7 +5935,7 @@ async function discoverModules(rootDir) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
         continue;
       }
-      const fullPath = (0, import_node_path8.join)(dir, entry.name);
+      const fullPath = (0, import_node_path4.join)(dir, entry.name);
       if (entry.isDirectory()) {
         subdirs.push(fullPath);
       } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
@@ -5957,10 +5952,10 @@ async function discoverModules(rootDir) {
         }
       }
       modules.push({
-        modulePath: (0, import_node_path8.relative)(rootDir, dir),
+        modulePath: relativePosix(rootDir, dir),
         fileCount: tsFiles.length,
         totalLoc,
-        files: tsFiles.map((f) => (0, import_node_path8.relative)(rootDir, f))
+        files: tsFiles.map((f) => relativePosix(rootDir, f))
       });
     }
     for (const sub of subdirs) {
@@ -6052,16 +6047,16 @@ var ModuleSizeCollector = class {
 
 // src/architecture/collectors/dep-depth.ts
 var import_promises3 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path5 = require("path");
 function extractImportSources(content, filePath) {
   const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
   const dynamicRegex = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
   const sources = [];
-  const dir = (0, import_node_path9.dirname)(filePath);
+  const dir = (0, import_node_path5.dirname)(filePath);
   for (const regex of [importRegex, dynamicRegex]) {
     let match;
     while ((match = regex.exec(content)) !== null) {
-      let resolved = (0, import_node_path9.resolve)(dir, match[1]);
+      let resolved = (0, import_node_path5.resolve)(dir, match[1]);
       if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
         resolved += ".ts";
       }
@@ -6082,7 +6077,7 @@ async function collectTsFiles(dir) {
     for (const entry of entries) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
         continue;
-      const fullPath = (0, import_node_path9.join)(d, entry.name);
+      const fullPath = (0, import_node_path5.join)(d, entry.name);
       if (entry.isDirectory()) {
         await scan(fullPath);
       } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
@@ -6136,7 +6131,7 @@ var DepDepthCollector = class {
     }
     const moduleMap = /* @__PURE__ */ new Map();
     for (const file of allFiles) {
-      const relDir = (0, import_node_path9.relative)(rootDir, (0, import_node_path9.dirname)(file));
+      const relDir = relativePosix(rootDir, (0, import_node_path5.dirname)(file));
       if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
       moduleMap.get(relDir).push(file);
     }
@@ -6280,11 +6275,11 @@ function detectStaleConstraints(store, windowDays = 30, category) {
 // src/architecture/baseline-manager.ts
 var import_node_fs3 = require("fs");
 var import_node_crypto2 = require("crypto");
-var import_node_path10 = require("path");
+var import_node_path6 = require("path");
 var ArchBaselineManager = class {
   baselinesPath;
   constructor(projectRoot, baselinePath) {
-    this.baselinesPath = baselinePath ? (0, import_node_path10.join)(projectRoot, baselinePath) : (0, import_node_path10.join)(projectRoot, ".harness", "arch", "baselines.json");
+    this.baselinesPath = baselinePath ? (0, import_node_path6.join)(projectRoot, baselinePath) : (0, import_node_path6.join)(projectRoot, ".harness", "arch", "baselines.json");
   }
   /**
    * Snapshot the current metric results into an ArchBaseline.
@@ -6345,7 +6340,7 @@ var ArchBaselineManager = class {
    * Uses atomic write (write to temp file, then rename) to prevent corruption.
    */
   save(baseline) {
-    const dir = (0, import_node_path10.dirname)(this.baselinesPath);
+    const dir = (0, import_node_path6.dirname)(this.baselinesPath);
     if (!(0, import_node_fs3.existsSync)(dir)) {
       (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
     }
@@ -8399,238 +8394,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",
@@ -9005,7 +9032,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) {
@@ -9023,7 +9050,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",
@@ -9042,7 +9069,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 = [];
@@ -10904,7 +10931,7 @@ Run "harness update" to upgrade.`;
 }
 
 // src/index.ts
-var VERSION = "0.11.0";
+var VERSION = "0.13.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_DESCRIPTORS,