@harness-engineering/core 0.5.0 → 0.7.0

package/dist/index.js

@@ -37,7 +37,6 @@ __export(index_exports, {
   DEFAULT_STATE: () => DEFAULT_STATE,
   EntropyAnalyzer: () => EntropyAnalyzer,
   EntropyConfigSchema: () => EntropyConfigSchema,
-  Err: () => Err,
   FailureEntrySchema: () => FailureEntrySchema,
   FileSink: () => FileSink,
   GateConfigSchema: () => GateConfigSchema,
@@ -47,7 +46,6 @@ __export(index_exports, {
   NoOpExecutor: () => NoOpExecutor,
   NoOpSink: () => NoOpSink,
   NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
-  Ok: () => Ok,
   PatternConfigSchema: () => PatternConfigSchema,
   REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
   TypeScriptParser: () => TypeScriptParser,
@@ -58,9 +56,7 @@ __export(index_exports, {
   applyFixes: () => applyFixes,
   archiveFailures: () => archiveFailures,
   buildDependencyGraph: () => buildDependencyGraph,
-  buildReachabilityMap: () => buildReachabilityMap,
   buildSnapshot: () => buildSnapshot,
-  checkConfigPattern: () => checkConfigPattern,
   checkDocCoverage: () => checkDocCoverage,
   configureFeedback: () => configureFeedback,
   contextBudget: () => contextBudget,
@@ -79,28 +75,23 @@ __export(index_exports, {
   executeWorkflow: () => executeWorkflow,
   extractMarkdownLinks: () => extractMarkdownLinks,
   extractSections: () => extractSections,
-  findPossibleMatches: () => findPossibleMatches,
   generateAgentsMap: () => generateAgentsMap,
   generateSuggestions: () => generateSuggestions,
   getActionEmitter: () => getActionEmitter,
   getFeedbackConfig: () => getFeedbackConfig,
   getPhaseCategories: () => getPhaseCategories,
-  isErr: () => isErr,
-  isOk: () => isOk,
-  levenshteinDistance: () => levenshteinDistance,
   loadFailures: () => loadFailures,
   loadHandoff: () => loadHandoff,
   loadRelevantLearnings: () => loadRelevantLearnings,
   loadState: () => loadState,
   logAgentAction: () => logAgentAction,
   parseDiff: () => parseDiff,
-  parseDocumentationFile: () => parseDocumentationFile,
   previewFix: () => previewFix,
   requestMultiplePeerReviews: () => requestMultiplePeerReviews,
   requestPeerReview: () => requestPeerReview,
   resetFeedbackConfig: () => resetFeedbackConfig,
-  resolveEntryPoints: () => resolveEntryPoints,
   resolveFileToLayer: () => resolveFileToLayer,
+  runCIChecks: () => runCIChecks,
   runMechanicalGate: () => runMechanicalGate,
   runMultiTurnPipeline: () => runMultiTurnPipeline,
   runPipeline: () => runPipeline,
@@ -119,22 +110,6 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 __reExport(index_exports, require("@harness-engineering/types"), module.exports);
 
-// src/shared/result.ts
-var Ok = (value) => ({
-  ok: true,
-  value
-});
-function isOk(result) {
-  return result.ok === true;
-}
-var Err = (error) => ({
-  ok: false,
-  error
-});
-function isErr(result) {
-  return result.ok === false;
-}
-
 // src/shared/errors.ts
 function createError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
@@ -143,26 +118,29 @@ function createEntropyError(code, message, details = {}, suggestions = []) {
   return { code, message, details, suggestions };
 }
 
+// src/shared/result.ts
+var import_types = require("@harness-engineering/types");
+
 // src/shared/fs-utils.ts
 var import_fs = require("fs");
 var import_util = require("util");
 var import_glob = require("glob");
 var accessAsync = (0, import_util.promisify)(import_fs.access);
 var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
-async function fileExists(path2) {
+async function fileExists(path3) {
   try {
-    await accessAsync(path2, import_fs.constants.F_OK);
+    await accessAsync(path3, import_fs.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function readFileContent(path2) {
+async function readFileContent(path3) {
   try {
-    const content = await readFileAsync(path2, "utf-8");
-    return Ok(content);
+    const content = await readFileAsync(path3, "utf-8");
+    return (0, import_types.Ok)(content);
   } catch (error) {
-    return Err(error);
+    return (0, import_types.Err)(error);
   }
 }
 async function findFiles(pattern, cwd = process.cwd()) {
@@ -192,14 +170,14 @@ async function validateFileStructure(projectPath, conventions) {
     unexpected,
     conformance
   };
-  return Ok(validation);
+  return (0, import_types.Ok)(validation);
 }
 
 // src/validation/config.ts
 function validateConfig(data, schema) {
   const result = schema.safeParse(data);
   if (result.success) {
-    return Ok(result.data);
+    return (0, import_types.Ok)(result.data);
   }
   const zodErrors = result.error;
   const firstError = zodErrors.errors[0];
@@ -207,15 +185,15 @@ function validateConfig(data, schema) {
   let message = "Configuration validation failed";
   const suggestions = [];
   if (firstError) {
-    const path2 = firstError.path.join(".");
-    const pathDisplay = path2 ? ` at "${path2}"` : "";
+    const path3 = firstError.path.join(".");
+    const pathDisplay = path3 ? ` at "${path3}"` : "";
     if (firstError.code === "invalid_type") {
       const received = firstError.received;
       const expected = firstError.expected;
       if (received === "undefined") {
         code = "MISSING_FIELD";
         message = `Missing required field${pathDisplay}: ${firstError.message}`;
-        suggestions.push(`Field "${path2}" is required and must be of type "${expected}"`);
+        suggestions.push(`Field "${path3}" is required and must be of type "${expected}"`);
       } else {
         code = "INVALID_TYPE";
         message = `Invalid type${pathDisplay}: ${firstError.message}`;
@@ -235,7 +213,7 @@ function validateConfig(data, schema) {
     },
     suggestions
   );
-  return Err(error);
+  return (0, import_types.Err)(error);
 }
 
 // src/validation/commit-message.ts
@@ -261,12 +239,12 @@ function validateCommitMessage(message, format = "conventional") {
       { message },
       ["Provide a valid commit message"]
     );
-    return Err(error);
+    return (0, import_types.Err)(error);
   }
   if (format === "conventional" || format === "angular") {
     return validateConventionalCommit(message);
   }
-  return Ok({
+  return (0, import_types.Ok)({
     valid: true,
     breaking: false,
     issues: []
@@ -282,7 +260,7 @@ function validateConventionalCommit(message) {
       { message },
       ["Provide a commit message with at least a header line"]
     );
-    return Err(error);
+    return (0, import_types.Err)(error);
   }
   const match = headerLine.match(CONVENTIONAL_PATTERN);
   if (!match) {
@@ -296,7 +274,7 @@ function validateConventionalCommit(message) {
         "Example: feat(core): add new feature"
       ]
     );
-    return Err(error);
+    return (0, import_types.Err)(error);
   }
   const type = match[1];
   const scope = match[3];
@@ -327,7 +305,7 @@ function validateConventionalCommit(message) {
       { message, issues, type, scope },
       ["Review and fix the validation issues above"]
     );
-    return Err(error);
+    return (0, import_types.Err)(error);
   }
   const result = {
     valid: true,
@@ -336,7 +314,7 @@ function validateConventionalCommit(message) {
     breaking: hasBreakingChange,
     issues: []
   };
-  return Ok(result);
+  return (0, import_types.Ok)(result);
 }
 
 // src/context/types.ts
@@ -428,27 +406,27 @@ function extractSections(content) {
     return result;
   });
 }
-function isExternalLink(path2) {
-  return path2.startsWith("http://") || path2.startsWith("https://") || path2.startsWith("#") || path2.startsWith("mailto:");
+function isExternalLink(path3) {
+  return path3.startsWith("http://") || path3.startsWith("https://") || path3.startsWith("#") || path3.startsWith("mailto:");
 }
 function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? (0, import_path.join)(baseDir, linkPath) : linkPath;
 }
-async function validateAgentsMap(path2 = "./AGENTS.md") {
-  const contentResult = await readFileContent(path2);
+async function validateAgentsMap(path3 = "./AGENTS.md") {
+  const contentResult = await readFileContent(path3);
   if (!contentResult.ok) {
-    return Err(
+    return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to read AGENTS.md: ${contentResult.error.message}`,
-        { path: path2 },
+        { path: path3 },
         ["Ensure the file exists", "Check file permissions"]
       )
     );
   }
   const content = contentResult.value;
   const sections = extractSections(content);
-  const baseDir = (0, import_path.dirname)(path2);
+  const baseDir = (0, import_path.dirname)(path3);
   const sectionTitles = sections.map((s) => s.title);
   const missingSections = REQUIRED_SECTIONS.filter(
     (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
@@ -478,7 +456,7 @@ async function validateAgentsMap(path2 = "./AGENTS.md") {
     );
   }
   const valid = missingSections.length === 0 && brokenLinks.length === 0;
-  return Ok({
+  return (0, import_types.Ok)({
     valid,
     sections,
     totalLinks: allLinks.length,
@@ -555,7 +533,7 @@ async function checkDocCoverage(domain, options = {}) {
     }
     const total = documented.length + undocumented.length;
     const coveragePercentage = total > 0 ? Math.round(documented.length / total * 100) : 100;
-    return Ok({
+    return (0, import_types.Ok)({
       domain,
       documented,
       undocumented,
@@ -563,7 +541,7 @@ async function checkDocCoverage(domain, options = {}) {
       gaps
     });
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to analyze documentation coverage: ${error.message}`,
@@ -576,8 +554,8 @@ async function checkDocCoverage(domain, options = {}) {
 
 // src/context/knowledge-map.ts
 var import_path3 = require("path");
-function suggestFix(path2, existingFiles) {
-  const targetName = (0, import_path3.basename)(path2).toLowerCase();
+function suggestFix(path3, existingFiles) {
+  const targetName = (0, import_path3.basename)(path3).toLowerCase();
   const similar = existingFiles.find((file) => {
     const fileName = (0, import_path3.basename)(file).toLowerCase();
     return fileName.includes(targetName) || targetName.includes(fileName);
@@ -585,13 +563,13 @@ function suggestFix(path2, existingFiles) {
   if (similar) {
     return `Did you mean "${similar}"?`;
   }
-  return `Create the file "${path2}" or remove the link`;
+  return `Create the file "${path3}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
   const agentsPath = (0, import_path3.join)(rootDir, "AGENTS.md");
   const agentsResult = await validateAgentsMap(agentsPath);
   if (!agentsResult.ok) {
-    return Err(agentsResult.error);
+    return (0, import_types.Err)(agentsResult.error);
   }
   const {
     sections,
@@ -615,7 +593,7 @@ async function validateKnowledgeMap(rootDir = process.cwd()) {
   });
   const validLinks = agentsTotalLinks - brokenLinks.length;
   const integrity = agentsTotalLinks > 0 ? Math.round(validLinks / agentsTotalLinks * 100) : 100;
-  return Ok({
+  return (0, import_types.Ok)({
     totalLinks: agentsTotalLinks,
     brokenLinks,
     validLinks,
@@ -724,9 +702,9 @@ async function generateAgentsMap(config) {
       "> Document your development workflow: branching strategy, testing commands, deployment process."
     );
     lines.push("");
-    return Ok(lines.join("\n"));
+    return (0, import_types.Ok)(lines.join("\n"));
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       createError(
         "PARSE_ERROR",
         `Failed to generate AGENTS.md: ${error.message}`,
@@ -901,7 +879,7 @@ async function buildDependencyGraph(files, parser) {
       }
     }
   }
-  return Ok({ nodes, edges });
+  return (0, import_types.Ok)({ nodes, edges });
 }
 function checkLayerViolations(graph, layers, rootDir) {
   const violations = [];
@@ -931,7 +909,7 @@ async function validateDependencies(config) {
   const healthResult = await parser.health();
   if (!healthResult.ok || !healthResult.value.available) {
     if (fallbackBehavior === "skip") {
-      return Ok({
+      return (0, import_types.Ok)({
         valid: true,
         violations: [],
         graph: { nodes: [], edges: [] },
@@ -941,7 +919,7 @@ async function validateDependencies(config) {
     }
     if (fallbackBehavior === "warn") {
       console.warn(`Parser ${parser.name} unavailable, skipping validation`);
-      return Ok({
+      return (0, import_types.Ok)({
         valid: true,
         violations: [],
         graph: { nodes: [], edges: [] },
@@ -949,7 +927,7 @@ async function validateDependencies(config) {
         reason: "Parser unavailable"
       });
     }
-    return Err(
+    return (0, import_types.Err)(
       createError(
         "PARSER_UNAVAILABLE",
         `Parser ${parser.name} is not available`,
@@ -968,10 +946,10 @@ async function validateDependencies(config) {
   const uniqueFiles = [...new Set(allFiles)];
   const graphResult = await buildDependencyGraph(uniqueFiles, parser);
   if (!graphResult.ok) {
-    return Err(graphResult.error);
+    return (0, import_types.Err)(graphResult.error);
   }
   const violations = checkLayerViolations(graphResult.value, layers, rootDir);
-  return Ok({
+  return (0, import_types.Ok)({
     valid: violations.length === 0,
     violations,
     graph: graphResult.value
@@ -1055,7 +1033,7 @@ function detectCircularDeps(graph) {
     };
   });
   const largestCycle = cycles.reduce((max, c) => Math.max(max, c.size), 0);
-  return Ok({
+  return (0, import_types.Ok)({
     hasCycles: cycles.length > 0,
     cycles,
     largestCycle
@@ -1077,13 +1055,13 @@ function createBoundaryValidator(schema, name) {
     parse(input) {
       const result = schema.safeParse(input);
       if (result.success) {
-        return Ok(result.data);
+        return (0, import_types.Ok)(result.data);
       }
       const suggestions = result.error.issues.map((issue) => {
-        const path2 = issue.path.join(".");
-        return path2 ? `${path2}: ${issue.message}` : issue.message;
+        const path3 = issue.path.join(".");
+        return path3 ? `${path3}: ${issue.message}` : issue.message;
       });
-      return Err(
+      return (0, import_types.Err)(
         createError(
           "BOUNDARY_ERROR",
           `Boundary validation failed for ${name}`,
@@ -1098,7 +1076,7 @@ function createBoundaryValidator(schema, name) {
     },
     validate(input) {
       const result = schema.safeParse(input);
-      return Ok(result.success);
+      return (0, import_types.Ok)(result.success);
     }
   };
 }
@@ -1119,7 +1097,7 @@ function validateBoundaries(boundaries, data) {
       });
     }
   }
-  return Ok({
+  return (0, import_types.Ok)({
     valid: violations.length === 0,
     violations
   });
@@ -1150,11 +1128,11 @@ function walk(node, visitor) {
 var TypeScriptParser = class {
   name = "typescript";
   extensions = [".ts", ".tsx", ".mts", ".cts"];
-  async parseFile(path2) {
-    const contentResult = await readFileContent(path2);
+  async parseFile(path3) {
+    const contentResult = await readFileContent(path3);
     if (!contentResult.ok) {
-      return Err(
-        createParseError("NOT_FOUND", `File not found: ${path2}`, { path: path2 }, [
+      return (0, import_types.Err)(
+        createParseError("NOT_FOUND", `File not found: ${path3}`, { path: path3 }, [
           "Check that the file exists",
           "Verify the path is correct"
         ])
@@ -1164,18 +1142,18 @@ var TypeScriptParser = class {
       const ast = (0, import_typescript_estree.parse)(contentResult.value, {
         loc: true,
         range: true,
-        jsx: path2.endsWith(".tsx"),
+        jsx: path3.endsWith(".tsx"),
         errorOnUnknownASTType: false
       });
-      return Ok({
+      return (0, import_types.Ok)({
         type: "Program",
         body: ast,
         language: "typescript"
       });
     } catch (e) {
       const error = e;
-      return Err(
-        createParseError("SYNTAX_ERROR", `Failed to parse ${path2}: ${error.message}`, { path: path2 }, [
+      return (0, import_types.Err)(
+        createParseError("SYNTAX_ERROR", `Failed to parse ${path3}: ${error.message}`, { path: path3 }, [
           "Check for syntax errors in the file",
           "Ensure valid TypeScript syntax"
         ])
@@ -1228,7 +1206,7 @@ var TypeScriptParser = class {
         }
       }
     });
-    return Ok(imports);
+    return (0, import_types.Ok)(imports);
   }
   extractExports(ast) {
     const exports2 = [];
@@ -1333,10 +1311,10 @@ var TypeScriptParser = class {
         });
       }
     });
-    return Ok(exports2);
+    return (0, import_types.Ok)(exports2);
   }
   async health() {
-    return Ok({ available: true, version: "7.0.0" });
+    return (0, import_types.Ok)({ available: true, version: "7.0.0" });
   }
 };
 
@@ -1346,7 +1324,7 @@ var import_minimatch2 = require("minimatch");
 async function resolveEntryPoints(rootDir, explicitEntries) {
   if (explicitEntries && explicitEntries.length > 0) {
     const resolved = explicitEntries.map((e) => (0, import_path6.resolve)(rootDir, e));
-    return Ok(resolved);
+    return (0, import_types.Ok)(resolved);
   }
   const pkgPath = (0, import_path6.join)(rootDir, "package.json");
   if (await fileExists(pkgPath)) {
@@ -1384,7 +1362,7 @@ async function resolveEntryPoints(rootDir, explicitEntries) {
           }
         }
         if (entries.length > 0) {
-          return Ok(entries);
+          return (0, import_types.Ok)(entries);
         }
       } catch {
       }
@@ -1394,10 +1372,10 @@ async function resolveEntryPoints(rootDir, explicitEntries) {
   for (const conv of conventions) {
     const convPath = (0, import_path6.join)(rootDir, conv);
     if (await fileExists(convPath)) {
-      return Ok([convPath]);
+      return (0, import_types.Ok)([convPath]);
     }
   }
-  return Err(
+  return (0, import_types.Err)(
     createEntropyError(
       "ENTRY_POINT_NOT_FOUND",
       "Could not resolve entry points",
@@ -1459,22 +1437,22 @@ function extractInlineRefs(content) {
   }
   return refs;
 }
-async function parseDocumentationFile(path2) {
-  const contentResult = await readFileContent(path2);
+async function parseDocumentationFile(path3) {
+  const contentResult = await readFileContent(path3);
   if (!contentResult.ok) {
-    return Err(
+    return (0, import_types.Err)(
       createEntropyError(
         "PARSE_ERROR",
-        `Failed to read documentation file: ${path2}`,
-        { file: path2 },
+        `Failed to read documentation file: ${path3}`,
+        { file: path3 },
         ["Check that the file exists"]
       )
     );
   }
   const content = contentResult.value;
-  const type = path2.endsWith(".md") ? "markdown" : "text";
-  return Ok({
-    path: path2,
+  const type = path3.endsWith(".md") ? "markdown" : "text";
+  return (0, import_types.Ok)({
+    path: path3,
     type,
     content,
     codeBlocks: extractCodeBlocks(content),
@@ -1590,7 +1568,7 @@ async function buildSnapshot(config) {
   const rootDir = (0, import_path6.resolve)(config.rootDir);
   const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
   if (!entryPointsResult.ok) {
-    return Err(entryPointsResult.error);
+    return (0, import_types.Err)(entryPointsResult.error);
   }
   const includePatterns = config.include || ["**/*.ts", "**/*.tsx"];
   const excludePatterns = config.exclude || [
@@ -1644,7 +1622,7 @@ async function buildSnapshot(config) {
   const exportMap = buildExportMap(files);
   const codeReferences = extractAllCodeReferences(docs);
   const buildTime = Date.now() - startTime;
-  return Ok({
+  return (0, import_types.Ok)({
     files,
     dependencyGraph,
     exportMap,
@@ -1795,7 +1773,7 @@ async function detectDocDrift(snapshot, config) {
   const exampleDrifts = drifts.filter((d) => d.type === "example-code").length;
   const structureDrifts = drifts.filter((d) => d.type === "structure").length;
   const severity = drifts.length === 0 ? "none" : drifts.length <= 3 ? "low" : drifts.length <= 10 ? "medium" : "high";
-  return Ok({
+  return (0, import_types.Ok)({
     drifts,
     stats: {
       docsScanned: snapshot.docs.length,
@@ -2047,7 +2025,7 @@ async function detectDeadCode(snapshot) {
       estimatedDeadLines
     }
   };
-  return Ok(report);
+  return (0, import_types.Ok)(report);
 }
 
 // src/entropy/detectors/patterns.ts
@@ -2204,7 +2182,7 @@ async function detectPatternViolations(snapshot, config) {
   const warningCount = violations.filter((v) => v.severity === "warning").length;
   const totalChecks = snapshot.files.length * patterns.length;
   const passRate = totalChecks > 0 ? (totalChecks - violations.length) / totalChecks : 1;
-  return Ok({
+  return (0, import_types.Ok)({
     violations,
     stats: {
       filesChecked: snapshot.files.length,
@@ -2352,7 +2330,7 @@ var EntropyAnalyzer = class {
     const startTime = Date.now();
     const snapshotResult = await buildSnapshot(this.config);
     if (!snapshotResult.ok) {
-      return Err(snapshotResult.error);
+      return (0, import_types.Err)(snapshotResult.error);
     }
     this.snapshot = snapshotResult.value;
     let driftReport;
@@ -2417,7 +2395,7 @@ var EntropyAnalyzer = class {
       report.patterns = patternReport;
     }
     this.report = report;
-    return Ok(report);
+    return (0, import_types.Ok)(report);
   }
   /**
    * Get the built snapshot (must call analyze first)
@@ -2459,7 +2437,7 @@ var EntropyAnalyzer = class {
    */
   async ensureSnapshot() {
     if (this.snapshot) {
-      return Ok(this.snapshot);
+      return (0, import_types.Ok)(this.snapshot);
     }
     return this.buildSnapshot();
   }
@@ -2469,7 +2447,7 @@ var EntropyAnalyzer = class {
   async detectDrift(config) {
     const snapshotResult = await this.ensureSnapshot();
     if (!snapshotResult.ok) {
-      return Err(snapshotResult.error);
+      return (0, import_types.Err)(snapshotResult.error);
     }
     return detectDocDrift(snapshotResult.value, config || {});
   }
@@ -2479,7 +2457,7 @@ var EntropyAnalyzer = class {
   async detectDeadCode() {
     const snapshotResult = await this.ensureSnapshot();
     if (!snapshotResult.ok) {
-      return Err(snapshotResult.error);
+      return (0, import_types.Err)(snapshotResult.error);
     }
     return detectDeadCode(snapshotResult.value);
   }
@@ -2489,7 +2467,7 @@ var EntropyAnalyzer = class {
   async detectPatterns(config) {
     const snapshotResult = await this.ensureSnapshot();
     if (!snapshotResult.ok) {
-      return Err(snapshotResult.error);
+      return (0, import_types.Err)(snapshotResult.error);
     }
     return detectPatternViolations(snapshotResult.value, config);
   }
@@ -2564,9 +2542,9 @@ async function createBackup(filePath, backupDir) {
   try {
     await mkdir2((0, import_path10.dirname)(backupPath), { recursive: true });
     await copyFile2(filePath, backupPath);
-    return Ok(backupPath);
+    return (0, import_types.Ok)(backupPath);
   } catch (e) {
-    return Err(
+    return (0, import_types.Err)(
       createEntropyError(
         "BACKUP_FAILED",
         `Failed to create backup: ${filePath}`,
@@ -2578,7 +2556,7 @@ async function createBackup(filePath, backupDir) {
 }
 async function applySingleFix(fix, config) {
   if (config.dryRun) {
-    return Ok(fix);
+    return (0, import_types.Ok)(fix);
   }
   try {
     switch (fix.action) {
@@ -2586,7 +2564,7 @@ async function applySingleFix(fix, config) {
         if (config.createBackup && config.backupDir) {
           const backupResult = await createBackup(fix.file, config.backupDir);
           if (!backupResult.ok) {
-            return Err({ fix, error: backupResult.error.message });
+            return (0, import_types.Err)({ fix, error: backupResult.error.message });
           }
         }
         await unlink2(fix.file);
@@ -2615,9 +2593,9 @@ async function applySingleFix(fix, config) {
         }
         break;
     }
-    return Ok(fix);
+    return (0, import_types.Ok)(fix);
   } catch (e) {
-    return Err({ fix, error: e.message });
+    return (0, import_types.Err)({ fix, error: e.message });
   }
 }
 async function applyFixes(fixes, config) {
@@ -2648,7 +2626,7 @@ async function applyFixes(fixes, config) {
       errors.push(result.error);
     }
   }
-  return Ok({
+  return (0, import_types.Ok)({
     applied,
     skipped,
     errors,
@@ -2757,7 +2735,7 @@ function validatePatternConfig(config) {
   const result = PatternConfigSchema.safeParse(config);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-    return Err(
+    return (0, import_types.Err)(
       createEntropyError(
         "CONFIG_VALIDATION_ERROR",
         `Invalid pattern config: ${issues}`,
@@ -2766,23 +2744,23 @@ function validatePatternConfig(config) {
       )
     );
   }
-  return Ok(result.data);
+  return (0, import_types.Ok)(result.data);
 }
 
 // src/feedback/telemetry/noop.ts
 var NoOpTelemetryAdapter = class {
   name = "noop";
   async health() {
-    return Ok({ available: true, message: "NoOp adapter - no real telemetry" });
+    return (0, import_types.Ok)({ available: true, message: "NoOp adapter - no real telemetry" });
   }
   async getMetrics() {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   async getTraces() {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   async getLogs() {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
 };
 
@@ -2803,7 +2781,7 @@ var NoOpExecutor = class {
   name = "noop";
   processes = /* @__PURE__ */ new Map();
   async health() {
-    return Ok({ available: true, message: "NoOp executor - no real agent spawning" });
+    return (0, import_types.Ok)({ available: true, message: "NoOp executor - no real agent spawning" });
   }
   async spawn(config) {
     const id = generateId();
@@ -2814,31 +2792,31 @@ var NoOpExecutor = class {
       config
     };
     this.processes.set(id, process2);
-    return Ok(process2);
+    return (0, import_types.Ok)(process2);
   }
   async status(processId) {
     const process2 = this.processes.get(processId);
     if (!process2) {
-      return Err({
+      return (0, import_types.Err)({
         code: "AGENT_SPAWN_ERROR",
         message: "Process not found",
         details: { agentId: processId },
         suggestions: ["Check if the process ID is correct"]
       });
     }
-    return Ok(process2);
+    return (0, import_types.Ok)(process2);
   }
   async wait(processId) {
     const process2 = this.processes.get(processId);
     if (!process2) {
-      return Err({
+      return (0, import_types.Err)({
         code: "AGENT_SPAWN_ERROR",
         message: "Process not found",
         details: { agentId: processId },
         suggestions: ["Check if the process ID is correct"]
       });
     }
-    return Ok({
+    return (0, import_types.Ok)({
       agentId: processId,
       agentType: process2.config.type,
       approved: true,
@@ -2850,7 +2828,7 @@ var NoOpExecutor = class {
   }
   async kill(processId) {
     this.processes.delete(processId);
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   }
 };
 
@@ -2868,7 +2846,7 @@ var ConsoleSink = class {
   async write(action) {
     const output = this.options.format === "json" ? JSON.stringify(action) : this.formatPretty(action);
     console.log(output);
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   }
   formatPretty(action) {
     const status = action.status === "completed" ? "\u2713" : action.status === "failed" ? "\u2717" : "\u2192";
@@ -2909,7 +2887,7 @@ function resetFeedbackConfig() {
 function parseDiff(diff) {
   try {
     if (!diff.trim()) {
-      return Ok({ diff, files: [] });
+      return (0, import_types.Ok)({ diff, files: [] });
     }
     const files = [];
     const newFileRegex = /new file mode/;
@@ -2939,9 +2917,9 @@ function parseDiff(diff) {
         deletions
       });
     }
-    return Ok({ diff, files });
+    return (0, import_types.Ok)({ diff, files });
   } catch (error) {
-    return Err({
+    return (0, import_types.Err)({
       code: "DIFF_PARSE_ERROR",
       message: "Failed to parse git diff",
       details: { reason: String(error) },
@@ -2951,7 +2929,7 @@ function parseDiff(diff) {
 }
 async function analyzeDiff(changes, options) {
   if (!options?.enabled) {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   const items = [];
   let itemId = 0;
@@ -3023,7 +3001,7 @@ async function analyzeDiff(changes, options) {
       }
     }
   }
-  return Ok(items);
+  return (0, import_types.Ok)(items);
 }
 
 // src/feedback/review/checklist.ts
@@ -3144,7 +3122,7 @@ var ChecklistBuilder = class {
       },
       duration: Date.now() - startTime
     };
-    return Ok(checklist);
+    return (0, import_types.Ok)(checklist);
   }
 };
 
@@ -3235,7 +3213,7 @@ async function logAgentAction(action) {
       await sink.write(fullAction);
     }
   }
-  return Ok(fullAction);
+  return (0, import_types.Ok)(fullAction);
 }
 function trackAction(type, context) {
   const startTime = Date.now();
@@ -3278,7 +3256,7 @@ async function requestPeerReview(agentType, context, options) {
   const config = getFeedbackConfig();
   const executor = config.executor;
   if (!executor) {
-    return Err({
+    return (0, import_types.Err)({
       code: "AGENT_SPAWN_ERROR",
       message: "No agent executor configured",
       details: {},
@@ -3331,7 +3309,7 @@ async function requestPeerReview(agentType, context, options) {
       summary: `Agent spawned: ${spawnResult.value.id}`,
       data: { processId: spawnResult.value.id }
     });
-    return Ok({
+    return (0, import_types.Ok)({
       agentId: spawnResult.value.id,
       agentType,
       approved: false,
@@ -3346,7 +3324,7 @@ async function requestPeerReview(agentType, context, options) {
       code: "AGENT_SPAWN_ERROR",
       message: String(error)
     });
-    return Err({
+    return (0, import_types.Err)({
       code: "AGENT_SPAWN_ERROR",
       message: "Failed to request peer review",
       details: { reason: String(error) },
@@ -3356,7 +3334,7 @@ async function requestPeerReview(agentType, context, options) {
 }
 async function requestMultiplePeerReviews(requests) {
   if (requests.length === 0) {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   const results = await Promise.all(
     requests.map(
@@ -3365,9 +3343,9 @@ async function requestMultiplePeerReviews(requests) {
   );
   const firstError = results.find((r) => !r.ok);
   if (firstError && !firstError.ok) {
-    return Err(firstError.error);
+    return (0, import_types.Err)(firstError.error);
   }
-  return Ok(results.map((r) => r.value));
+  return (0, import_types.Ok)(results.map((r) => r.value));
 }
 
 // src/feedback/logging/file-sink.ts
@@ -3409,9 +3387,9 @@ var FileSink = class {
       if (this.buffer.length >= (this.options.bufferSize ?? 1)) {
         return this.flush();
       }
-      return Ok(void 0);
+      return (0, import_types.Ok)(void 0);
     } catch (error) {
-      return Err({
+      return (0, import_types.Err)({
         code: "SINK_ERROR",
         message: "Failed to write action to file",
         details: { reason: String(error) },
@@ -3421,7 +3399,7 @@ var FileSink = class {
   }
   async flush() {
     if (this.buffer.length === 0) {
-      return Ok(void 0);
+      return (0, import_types.Ok)(void 0);
     }
     try {
       this.ensureDirectory();
@@ -3432,9 +3410,9 @@ var FileSink = class {
       } else {
         (0, import_fs2.appendFileSync)(this.filePath, content);
       }
-      return Ok(void 0);
+      return (0, import_types.Ok)(void 0);
     } catch (error) {
-      return Err({
+      return (0, import_types.Err)({
         code: "SINK_ERROR",
         message: "Failed to flush actions to file",
         details: { reason: String(error) },
@@ -3454,7 +3432,7 @@ var FileSink = class {
 var NoOpSink = class {
   name = "noop";
   async write() {
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   }
 };
 
@@ -3552,18 +3530,18 @@ var GATE_CONFIG_FILE = "gate.json";
 async function loadState(projectPath) {
   const statePath = path.join(projectPath, HARNESS_DIR, STATE_FILE);
   if (!fs2.existsSync(statePath)) {
-    return Ok({ ...DEFAULT_STATE });
+    return (0, import_types.Ok)({ ...DEFAULT_STATE });
   }
   try {
     const raw = fs2.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HarnessStateSchema.safeParse(parsed);
     if (!result.success) {
-      return Err(new Error(`Invalid state file ${statePath}: ${result.error.message}`));
+      return (0, import_types.Err)(new Error(`Invalid state file ${statePath}: ${result.error.message}`));
     }
-    return Ok(result.data);
+    return (0, import_types.Ok)(result.data);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to load state from ${statePath}: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3576,9 +3554,9 @@ async function saveState(projectPath, state) {
   try {
     fs2.mkdirSync(harnessDir, { recursive: true });
     fs2.writeFileSync(statePath, JSON.stringify(state, null, 2));
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(`Failed to save state: ${error instanceof Error ? error.message : String(error)}`)
     );
   }
@@ -3609,9 +3587,9 @@ ${entry}`);
     } else {
       fs2.appendFileSync(learningsPath, entry);
     }
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to append learning: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3621,7 +3599,7 @@ ${entry}`);
 async function loadRelevantLearnings(projectPath, skillName) {
   const learningsPath = path.join(projectPath, HARNESS_DIR, LEARNINGS_FILE);
   if (!fs2.existsSync(learningsPath)) {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   try {
     const content = fs2.readFileSync(learningsPath, "utf-8");
@@ -3645,12 +3623,12 @@ async function loadRelevantLearnings(projectPath, skillName) {
       entries.push(currentBlock.join("\n"));
     }
     if (!skillName) {
-      return Ok(entries);
+      return (0, import_types.Ok)(entries);
     }
     const filtered = entries.filter((entry) => entry.includes(`[skill:${skillName}]`));
-    return Ok(filtered);
+    return (0, import_types.Ok)(filtered);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to load learnings: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3673,9 +3651,9 @@ ${entry}`);
     } else {
       fs2.appendFileSync(failuresPath, entry);
     }
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to append failure: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3685,7 +3663,7 @@ ${entry}`);
 async function loadFailures(projectPath) {
   const failuresPath = path.join(projectPath, HARNESS_DIR, FAILURES_FILE);
   if (!fs2.existsSync(failuresPath)) {
-    return Ok([]);
+    return (0, import_types.Ok)([]);
   }
   try {
     const content = fs2.readFileSync(failuresPath, "utf-8");
@@ -3701,9 +3679,9 @@ async function loadFailures(projectPath) {
         });
       }
     }
-    return Ok(entries);
+    return (0, import_types.Ok)(entries);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to load failures: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3714,7 +3692,7 @@ async function archiveFailures(projectPath) {
   const harnessDir = path.join(projectPath, HARNESS_DIR);
   const failuresPath = path.join(harnessDir, FAILURES_FILE);
   if (!fs2.existsSync(failuresPath)) {
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   }
   try {
     const archiveDir = path.join(harnessDir, "archive");
@@ -3727,9 +3705,9 @@ async function archiveFailures(projectPath) {
       counter++;
     }
     fs2.renameSync(failuresPath, path.join(archiveDir, archiveName));
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to archive failures: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3742,9 +3720,9 @@ async function saveHandoff(projectPath, handoff) {
   try {
     fs2.mkdirSync(harnessDir, { recursive: true });
     fs2.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
-    return Ok(void 0);
+    return (0, import_types.Ok)(void 0);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(`Failed to save handoff: ${error instanceof Error ? error.message : String(error)}`)
     );
   }
@@ -3752,18 +3730,18 @@ async function saveHandoff(projectPath, handoff) {
 async function loadHandoff(projectPath) {
   const handoffPath = path.join(projectPath, HARNESS_DIR, HANDOFF_FILE);
   if (!fs2.existsSync(handoffPath)) {
-    return Ok(null);
+    return (0, import_types.Ok)(null);
   }
   try {
     const raw = fs2.readFileSync(handoffPath, "utf-8");
     const parsed = JSON.parse(raw);
     const result = HandoffSchema.safeParse(parsed);
     if (!result.success) {
-      return Err(new Error(`Invalid handoff file: ${result.error.message}`));
+      return (0, import_types.Err)(new Error(`Invalid handoff file: ${result.error.message}`));
     }
-    return Ok(result.data);
+    return (0, import_types.Ok)(result.data);
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(`Failed to load handoff: ${error instanceof Error ? error.message : String(error)}`)
     );
   }
@@ -3824,12 +3802,12 @@ async function runMechanicalGate(projectPath) {
         });
       }
     }
-    return Ok({
+    return (0, import_types.Ok)({
       passed: results.length === 0 || results.every((r) => r.passed),
       checks: results
     });
   } catch (error) {
-    return Err(
+    return (0, import_types.Err)(
       new Error(
         `Failed to run mechanical gate: ${error instanceof Error ? error.message : String(error)}`
       )
@@ -3985,8 +3963,183 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
   };
 }
 
+// src/ci/check-orchestrator.ts
+var path2 = __toESM(require("path"));
+var ALL_CHECKS = ["validate", "deps", "docs", "entropy", "phase-gate"];
+async function runSingleCheck(name, projectRoot, config) {
+  const start = Date.now();
+  const issues = [];
+  try {
+    switch (name) {
+      case "validate": {
+        const agentsPath = path2.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;
+      }
+      case "deps": {
+        const layers = config.layers;
+        if (layers && layers.length > 0) {
+          const parser = new TypeScriptParser();
+          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;
+      }
+      case "docs": {
+        const docsDir = path2.join(projectRoot, config.docsDir ?? "docs");
+        const result = await checkDocCoverage("project", { docsDir });
+        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 }
+        });
+        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 "phase-gate": {
+        const phaseGates = config.phaseGates;
+        if (!phaseGates?.enabled) {
+          break;
+        }
+        issues.push({
+          severity: "warning",
+          message: "Phase gate is enabled but requires CLI context. Run `harness check-phase-gate` separately for full validation."
+        });
+        break;
+      }
+    }
+  } catch (error) {
+    issues.push({
+      severity: "error",
+      message: `Check '${name}' threw: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  const hasWarnings = issues.some((i) => i.severity === "warning");
+  const status = hasErrors ? "fail" : hasWarnings ? "warn" : "pass";
+  return {
+    name,
+    status,
+    issues,
+    durationMs: Date.now() - start
+  };
+}
+function buildSummary(checks) {
+  return {
+    total: checks.length,
+    passed: checks.filter((c) => c.status === "pass").length,
+    failed: checks.filter((c) => c.status === "fail").length,
+    warnings: checks.filter((c) => c.status === "warn").length,
+    skipped: checks.filter((c) => c.status === "skip").length
+  };
+}
+function determineExitCode(summary, failOn = "error") {
+  if (summary.failed > 0) return 1;
+  if (failOn === "warning" && summary.warnings > 0) return 1;
+  return 0;
+}
+async function runCIChecks(input) {
+  const { projectRoot, config, skip = [], failOn = "error" } = input;
+  try {
+    const checks = [];
+    for (const name of ALL_CHECKS) {
+      if (skip.includes(name)) {
+        checks.push({ name, status: "skip", issues: [], durationMs: 0 });
+      } else {
+        const result = await runSingleCheck(name, projectRoot, config);
+        checks.push(result);
+      }
+    }
+    const summary = buildSummary(checks);
+    const exitCode = determineExitCode(summary, failOn);
+    const report = {
+      version: 1,
+      project: config.name ?? "unknown",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checks,
+      summary,
+      exitCode
+    };
+    return (0, import_types.Ok)(report);
+  } catch (error) {
+    return (0, import_types.Err)(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
 // src/index.ts
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentActionEmitter,
@@ -3995,7 +4148,6 @@ var VERSION = "0.5.0";
   DEFAULT_STATE,
   EntropyAnalyzer,
   EntropyConfigSchema,
-  Err,
   FailureEntrySchema,
   FileSink,
   GateConfigSchema,
@@ -4005,7 +4157,6 @@ var VERSION = "0.5.0";
   NoOpExecutor,
   NoOpSink,
   NoOpTelemetryAdapter,
-  Ok,
   PatternConfigSchema,
   REQUIRED_SECTIONS,
   TypeScriptParser,
@@ -4016,9 +4167,7 @@ var VERSION = "0.5.0";
   applyFixes,
   archiveFailures,
   buildDependencyGraph,
-  buildReachabilityMap,
   buildSnapshot,
-  checkConfigPattern,
   checkDocCoverage,
   configureFeedback,
   contextBudget,
@@ -4037,28 +4186,23 @@ var VERSION = "0.5.0";
   executeWorkflow,
   extractMarkdownLinks,
   extractSections,
-  findPossibleMatches,
   generateAgentsMap,
   generateSuggestions,
   getActionEmitter,
   getFeedbackConfig,
   getPhaseCategories,
-  isErr,
-  isOk,
-  levenshteinDistance,
   loadFailures,
   loadHandoff,
   loadRelevantLearnings,
   loadState,
   logAgentAction,
   parseDiff,
-  parseDocumentationFile,
   previewFix,
   requestMultiplePeerReviews,
   requestPeerReview,
   resetFeedbackConfig,
-  resolveEntryPoints,
   resolveFileToLayer,
+  runCIChecks,
   runMechanicalGate,
   runMultiTurnPipeline,
   runPipeline,