@harness-engineering/core 0.7.0 → 0.8.0

package/dist/index.js

@@ -413,6 +413,9 @@ function resolveLinkPath(linkPath, baseDir) {
   return linkPath.startsWith(".") ? (0, import_path.join)(baseDir, linkPath) : linkPath;
 }
 async function validateAgentsMap(path3 = "./AGENTS.md") {
+  console.warn(
+    "[harness] validateAgentsMap() is deprecated. Use graph-based validation via Assembler.checkCoverage() from @harness-engineering/graph"
+  );
   const contentResult = await readFileContent(path3);
   if (!contentResult.ok) {
     return (0, import_types.Err)(
@@ -488,7 +491,21 @@ function suggestSection(filePath, domain) {
   return `${domain} Reference`;
 }
 async function checkDocCoverage(domain, options = {}) {
-  const { docsDir = "./docs", sourceDir = "./src", excludePatterns = [] } = options;
+  const { docsDir = "./docs", sourceDir = "./src", excludePatterns = [], graphCoverage } = options;
+  if (graphCoverage) {
+    const gaps = graphCoverage.undocumented.map((file) => ({
+      file,
+      suggestedSection: suggestSection(file, domain),
+      importance: determineImportance(file)
+    }));
+    return (0, import_types.Ok)({
+      domain,
+      documented: graphCoverage.documented,
+      undocumented: graphCoverage.undocumented,
+      coveragePercentage: graphCoverage.coveragePercentage,
+      gaps
+    });
+  }
   try {
     const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
     const filteredSourceFiles = sourceFiles.filter((file) => {
@@ -566,6 +583,9 @@ function suggestFix(path3, existingFiles) {
   return `Create the file "${path3}" or remove the link`;
 }
 async function validateKnowledgeMap(rootDir = process.cwd()) {
+  console.warn(
+    "[harness] validateKnowledgeMap() is deprecated. Use graph-based validation via Assembler.checkCoverage() from @harness-engineering/graph"
+  );
   const agentsPath = (0, import_path3.join)(rootDir, "AGENTS.md");
   const agentsResult = await validateAgentsMap(agentsPath);
   if (!agentsResult.ok) {
@@ -639,18 +659,9 @@ function matchesExcludePattern(relativePath, excludePatterns) {
     return regex.test(relativePath);
   });
 }
-async function generateAgentsMap(config) {
+async function generateAgentsMap(config, graphSections) {
   const { rootDir, includePaths, excludePaths, sections = DEFAULT_SECTIONS } = config;
   try {
-    const allFiles = [];
-    for (const pattern of includePaths) {
-      const files = await findFiles(pattern, rootDir);
-      allFiles.push(...files);
-    }
-    const filteredFiles = allFiles.filter((file) => {
-      const relativePath = (0, import_path4.relative)(rootDir, file);
-      return !matchesExcludePattern(relativePath, excludePaths);
-    });
     const lines = [];
     lines.push("# AI Agent Knowledge Map");
     lines.push("");
@@ -660,41 +671,68 @@ async function generateAgentsMap(config) {
     lines.push("");
     lines.push("> Add a brief description of this project, its purpose, and key technologies.");
     lines.push("");
-    lines.push("## Repository Structure");
-    lines.push("");
-    const grouped = groupByDirectory(filteredFiles, rootDir);
-    for (const [dir, files] of grouped) {
-      if (dir !== ".") {
-        lines.push(`### ${dir}/`);
+    if (graphSections) {
+      for (const section of graphSections) {
+        lines.push(`## ${section.name}`);
         lines.push("");
-      }
-      for (const file of files.slice(0, 10)) {
-        lines.push(formatFileLink(file));
-      }
-      if (files.length > 10) {
-        lines.push(`- _... and ${files.length - 10} more files_`);
-      }
-      lines.push("");
-    }
-    for (const section of sections) {
-      lines.push(`## ${section.name}`);
-      lines.push("");
-      if (section.description) {
-        lines.push(section.description);
+        if (section.description) {
+          lines.push(section.description);
+          lines.push("");
+        }
+        for (const file of section.files.slice(0, 20)) {
+          lines.push(formatFileLink(file));
+        }
+        if (section.files.length > 20) {
+          lines.push(`- _... and ${section.files.length - 20} more files_`);
+        }
         lines.push("");
       }
-      const sectionFiles = await findFiles(section.pattern, rootDir);
-      const filteredSectionFiles = sectionFiles.filter((file) => {
+    } else {
+      const allFiles = [];
+      for (const pattern of includePaths) {
+        const files = await findFiles(pattern, rootDir);
+        allFiles.push(...files);
+      }
+      const filteredFiles = allFiles.filter((file) => {
         const relativePath = (0, import_path4.relative)(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("## Repository Structure");
+      lines.push("");
+      const grouped = groupByDirectory(filteredFiles, rootDir);
+      for (const [dir, files] of grouped) {
+        if (dir !== ".") {
+          lines.push(`### ${dir}/`);
+          lines.push("");
+        }
+        for (const file of files.slice(0, 10)) {
+          lines.push(formatFileLink(file));
+        }
+        if (files.length > 10) {
+          lines.push(`- _... and ${files.length - 10} more files_`);
+        }
+        lines.push("");
       }
-      if (filteredSectionFiles.length > 20) {
-        lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
+      for (const section of sections) {
+        lines.push(`## ${section.name}`);
+        lines.push("");
+        if (section.description) {
+          lines.push(section.description);
+          lines.push("");
+        }
+        const sectionFiles = await findFiles(section.pattern, rootDir);
+        const filteredSectionFiles = sectionFiles.filter((file) => {
+          const relativePath = (0, import_path4.relative)(rootDir, file);
+          return !matchesExcludePattern(relativePath, excludePaths);
+        });
+        for (const file of filteredSectionFiles.slice(0, 20)) {
+          lines.push(formatFileLink((0, import_path4.relative)(rootDir, file)));
+        }
+        if (filteredSectionFiles.length > 20) {
+          lines.push(`- _... and ${filteredSectionFiles.length - 20} more files_`);
+        }
+        lines.push("");
       }
-      lines.push("");
     }
     lines.push("## Development Workflow");
     lines.push("");
@@ -724,7 +762,21 @@ var DEFAULT_RATIOS = {
   interfaces: 0.1,
   reserve: 0.1
 };
-function contextBudget(totalTokens, overrides) {
+var NODE_TYPE_TO_CATEGORY = {
+  file: "activeCode",
+  function: "activeCode",
+  class: "activeCode",
+  method: "activeCode",
+  interface: "interfaces",
+  variable: "interfaces",
+  adr: "projectManifest",
+  document: "projectManifest",
+  spec: "taskSpec",
+  task: "taskSpec",
+  prompt: "systemPrompt",
+  system: "systemPrompt"
+};
+function contextBudget(totalTokens, overrides, graphDensity) {
   const ratios = {
     systemPrompt: DEFAULT_RATIOS.systemPrompt,
     projectManifest: DEFAULT_RATIOS.projectManifest,
@@ -733,6 +785,52 @@ function contextBudget(totalTokens, overrides) {
     interfaces: DEFAULT_RATIOS.interfaces,
     reserve: DEFAULT_RATIOS.reserve
   };
+  if (graphDensity) {
+    const categoryWeights = {
+      systemPrompt: 0,
+      projectManifest: 0,
+      taskSpec: 0,
+      activeCode: 0,
+      interfaces: 0,
+      reserve: 0
+    };
+    for (const [nodeType, count] of Object.entries(graphDensity)) {
+      const category = NODE_TYPE_TO_CATEGORY[nodeType];
+      if (category) {
+        categoryWeights[category] += count;
+      }
+    }
+    const totalWeight = Object.values(categoryWeights).reduce((sum, w) => sum + w, 0);
+    if (totalWeight > 0) {
+      const MIN_ALLOCATION = 0.01;
+      for (const key of Object.keys(ratios)) {
+        if (categoryWeights[key] > 0) {
+          ratios[key] = categoryWeights[key] / totalWeight;
+        } else {
+          ratios[key] = MIN_ALLOCATION;
+        }
+      }
+      if (ratios.reserve < DEFAULT_RATIOS.reserve) {
+        ratios.reserve = DEFAULT_RATIOS.reserve;
+      }
+      if (ratios.systemPrompt < DEFAULT_RATIOS.systemPrompt) {
+        ratios.systemPrompt = DEFAULT_RATIOS.systemPrompt;
+      }
+      const ratioSum = Object.values(ratios).reduce((sum, r) => sum + r, 0);
+      for (const key of Object.keys(ratios)) {
+        ratios[key] = ratios[key] / ratioSum;
+      }
+      for (const key of Object.keys(ratios)) {
+        if (ratios[key] < MIN_ALLOCATION) {
+          ratios[key] = MIN_ALLOCATION;
+        }
+      }
+      const finalSum = Object.values(ratios).reduce((sum, r) => sum + r, 0);
+      for (const key of Object.keys(ratios)) {
+        ratios[key] = ratios[key] / finalSum;
+      }
+    }
+  }
   if (overrides) {
     let overrideSum = 0;
     const overrideKeys = [];
@@ -746,12 +844,12 @@ function contextBudget(totalTokens, overrides) {
     }
     if (overrideKeys.length > 0 && overrideKeys.length < 6) {
       const remaining = 1 - overrideSum;
-      const nonOverridden = Object.keys(DEFAULT_RATIOS).filter(
+      const nonOverridden = Object.keys(ratios).filter(
         (k) => !overrideKeys.includes(k)
       );
-      const originalSum = nonOverridden.reduce((sum, k) => sum + DEFAULT_RATIOS[k], 0);
+      const originalSum = nonOverridden.reduce((sum, k) => sum + ratios[k], 0);
       for (const k of nonOverridden) {
-        ratios[k] = remaining * (DEFAULT_RATIOS[k] / originalSum);
+        ratios[k] = remaining * (ratios[k] / originalSum);
       }
     }
   }
@@ -802,7 +900,7 @@ var PHASE_PRIORITIES = {
     { category: "config", patterns: ["harness.config.json", "package.json"], priority: 5 }
   ]
 };
-function contextFilter(phase, maxCategories) {
+function contextFilter(phase, maxCategories, graphFilePaths) {
   const categories = PHASE_PRIORITIES[phase];
   const limit = maxCategories ?? categories.length;
   const included = categories.slice(0, limit);
@@ -811,7 +909,7 @@ function contextFilter(phase, maxCategories) {
     phase,
     includedCategories: included.map((c) => c.category),
     excludedCategories: excluded.map((c) => c.category),
-    filePatterns: included.flatMap((c) => c.patterns)
+    filePatterns: graphFilePaths ?? included.flatMap((c) => c.patterns)
   };
 }
 function getPhaseCategories(phase) {
@@ -855,7 +953,13 @@ function getImportType(imp) {
   if (imp.kind === "type") return "type-only";
   return "static";
 }
-async function buildDependencyGraph(files, parser) {
+async function buildDependencyGraph(files, parser, graphDependencyData) {
+  if (graphDependencyData) {
+    return (0, import_types.Ok)({
+      nodes: graphDependencyData.nodes,
+      edges: graphDependencyData.edges
+    });
+  }
   const nodes = [...files];
   const edges = [];
   for (const file of files) {
@@ -905,7 +1009,19 @@ function checkLayerViolations(graph, layers, rootDir) {
   return violations;
 }
 async function validateDependencies(config) {
-  const { layers, rootDir, parser, fallbackBehavior = "error" } = config;
+  const { layers, rootDir, parser, fallbackBehavior = "error", graphDependencyData } = config;
+  if (graphDependencyData) {
+    const graphResult2 = await buildDependencyGraph([], parser, graphDependencyData);
+    if (!graphResult2.ok) {
+      return (0, import_types.Err)(graphResult2.error);
+    }
+    const violations2 = checkLayerViolations(graphResult2.value, layers, rootDir);
+    return (0, import_types.Ok)({
+      valid: violations2.length === 0,
+      violations: violations2,
+      graph: graphResult2.value
+    });
+  }
   const healthResult = await parser.health();
   if (!healthResult.ok || !healthResult.value.available) {
     if (fallbackBehavior === "skip") {
@@ -1039,8 +1155,8 @@ function detectCircularDeps(graph) {
     largestCycle
   });
 }
-async function detectCircularDepsInFiles(files, parser) {
-  const graphResult = await buildDependencyGraph(files, parser);
+async function detectCircularDepsInFiles(files, parser, graphDependencyData) {
+  const graphResult = await buildDependencyGraph(files, parser, graphDependencyData);
   if (!graphResult.ok) {
     return graphResult;
   }
@@ -1760,7 +1876,45 @@ async function checkStructureDrift(snapshot, _config) {
   }
   return drifts;
 }
-async function detectDocDrift(snapshot, config) {
+async function detectDocDrift(snapshot, config, graphDriftData) {
+  if (graphDriftData) {
+    const drifts2 = [];
+    for (const target of graphDriftData.missingTargets) {
+      drifts2.push({
+        type: "api-signature",
+        docFile: target,
+        line: 0,
+        reference: target,
+        context: "graph-missing-target",
+        issue: "NOT_FOUND",
+        details: `Graph node "${target}" has no matching code target`,
+        confidence: "high"
+      });
+    }
+    for (const edge of graphDriftData.staleEdges) {
+      drifts2.push({
+        type: "api-signature",
+        docFile: edge.docNodeId,
+        line: 0,
+        reference: edge.codeNodeId,
+        context: `graph-stale-edge:${edge.edgeType}`,
+        issue: "NOT_FOUND",
+        details: `Stale edge from doc "${edge.docNodeId}" to code "${edge.codeNodeId}" (${edge.edgeType})`,
+        confidence: "medium"
+      });
+    }
+    const severity2 = drifts2.length === 0 ? "none" : drifts2.length <= 3 ? "low" : drifts2.length <= 10 ? "medium" : "high";
+    return (0, import_types.Ok)({
+      drifts: drifts2,
+      stats: {
+        docsScanned: graphDriftData.staleEdges.length,
+        referencesChecked: graphDriftData.staleEdges.length + graphDriftData.missingTargets.length,
+        driftsFound: drifts2.length,
+        byType: { api: drifts2.length, example: 0, structure: 0 }
+      },
+      severity: severity2
+    });
+  }
   const fullConfig = { ...DEFAULT_DRIFT_CONFIG, ...config };
   const drifts = [];
   if (fullConfig.checkApiSignatures) {
@@ -1998,7 +2152,54 @@ function findDeadInternals(snapshot, _reachability) {
   }
   return deadInternals;
 }
-async function detectDeadCode(snapshot) {
+async function detectDeadCode(snapshot, graphDeadCodeData) {
+  if (graphDeadCodeData) {
+    const deadFiles2 = [];
+    const deadExports2 = [];
+    const fileTypes = /* @__PURE__ */ new Set(["file", "module"]);
+    const exportTypes = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "variable"]);
+    for (const node of graphDeadCodeData.unreachableNodes) {
+      if (fileTypes.has(node.type)) {
+        deadFiles2.push({
+          path: node.path || node.id,
+          reason: "NO_IMPORTERS",
+          exportCount: 0,
+          lineCount: 0
+        });
+      } else if (exportTypes.has(node.type)) {
+        const exportType = node.type === "method" ? "function" : node.type;
+        deadExports2.push({
+          file: node.path || node.id,
+          name: node.name,
+          line: 0,
+          type: exportType,
+          isDefault: false,
+          reason: "NO_IMPORTERS"
+        });
+      }
+    }
+    const reachableCount = graphDeadCodeData.reachableNodeIds instanceof Set ? graphDeadCodeData.reachableNodeIds.size : graphDeadCodeData.reachableNodeIds.length;
+    const fileNodes = graphDeadCodeData.unreachableNodes.filter((n) => fileTypes.has(n.type));
+    const exportNodes = graphDeadCodeData.unreachableNodes.filter((n) => exportTypes.has(n.type));
+    const totalFiles = reachableCount + fileNodes.length;
+    const totalExports2 = exportNodes.length + (reachableCount > 0 ? reachableCount : 0);
+    const report2 = {
+      deadExports: deadExports2,
+      deadFiles: deadFiles2,
+      deadInternals: [],
+      unusedImports: [],
+      stats: {
+        filesAnalyzed: totalFiles,
+        entryPointsUsed: [],
+        totalExports: totalExports2,
+        deadExportCount: deadExports2.length,
+        totalFiles,
+        deadFileCount: deadFiles2.length,
+        estimatedDeadLines: 0
+      }
+    };
+    return (0, import_types.Ok)(report2);
+  }
   const reachability = buildReachabilityMap(snapshot);
   const usageMap = buildExportUsageMap(snapshot);
   const deadExports = findDeadExports(snapshot, usageMap, reachability);
@@ -2324,22 +2525,39 @@ var EntropyAnalyzer = class {
     };
   }
   /**
-   * Run full entropy analysis
+   * Run full entropy analysis.
+   * When graphOptions is provided, passes graph data to drift and dead code detectors
+   * for graph-enhanced analysis instead of snapshot-based analysis.
    */
-  async analyze() {
+  async analyze(graphOptions) {
     const startTime = Date.now();
-    const snapshotResult = await buildSnapshot(this.config);
-    if (!snapshotResult.ok) {
-      return (0, import_types.Err)(snapshotResult.error);
+    const needsSnapshot = !graphOptions || !graphOptions.graphDriftData || !graphOptions.graphDeadCodeData;
+    if (needsSnapshot) {
+      const snapshotResult = await buildSnapshot(this.config);
+      if (!snapshotResult.ok) {
+        return (0, import_types.Err)(snapshotResult.error);
+      }
+      this.snapshot = snapshotResult.value;
+    } else {
+      this.snapshot = {
+        files: [],
+        dependencyGraph: { nodes: [], edges: [] },
+        exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+        docs: [],
+        codeReferences: [],
+        entryPoints: [],
+        rootDir: this.config.rootDir,
+        config: this.config,
+        buildTime: 0
+      };
     }
-    this.snapshot = snapshotResult.value;
     let driftReport;
     let deadCodeReport;
     let patternReport;
     const analysisErrors = [];
     if (this.config.analyze.drift) {
       const driftConfig = typeof this.config.analyze.drift === "object" ? this.config.analyze.drift : {};
-      const result = await detectDocDrift(this.snapshot, driftConfig);
+      const result = await detectDocDrift(this.snapshot, driftConfig, graphOptions?.graphDriftData);
       if (result.ok) {
         driftReport = result.value;
       } else {
@@ -2347,7 +2565,7 @@ var EntropyAnalyzer = class {
       }
     }
     if (this.config.analyze.deadCode) {
-      const result = await detectDeadCode(this.snapshot);
+      const result = await detectDeadCode(this.snapshot, graphOptions?.graphDeadCodeData);
       if (result.ok) {
         deadCodeReport = result.value;
       } else {
@@ -2444,22 +2662,22 @@ var EntropyAnalyzer = class {
   /**
    * Run drift detection only (snapshot must be built first)
    */
-  async detectDrift(config) {
+  async detectDrift(config, graphDriftData) {
     const snapshotResult = await this.ensureSnapshot();
     if (!snapshotResult.ok) {
       return (0, import_types.Err)(snapshotResult.error);
     }
-    return detectDocDrift(snapshotResult.value, config || {});
+    return detectDocDrift(snapshotResult.value, config || {}, graphDriftData);
   }
   /**
    * Run dead code detection only (snapshot must be built first)
    */
-  async detectDeadCode() {
+  async detectDeadCode(graphDeadCodeData) {
     const snapshotResult = await this.ensureSnapshot();
     if (!snapshotResult.ok) {
       return (0, import_types.Err)(snapshotResult.error);
     }
-    return detectDeadCode(snapshotResult.value);
+    return detectDeadCode(snapshotResult.value, graphDeadCodeData);
   }
   /**
    * Run pattern detection only (snapshot must be built first)
@@ -2927,7 +3145,7 @@ function parseDiff(diff) {
     });
   }
 }
-async function analyzeDiff(changes, options) {
+async function analyzeDiff(changes, options, graphImpactData) {
   if (!options?.enabled) {
     return (0, import_types.Ok)([]);
   }
@@ -2978,26 +3196,75 @@ async function analyzeDiff(changes, options) {
     }
   }
   if (options.checkTestCoverage) {
-    const addedSourceFiles = changes.files.filter(
-      (f) => f.status === "added" && f.path.endsWith(".ts") && !f.path.includes(".test.")
-    );
-    const testFiles = changes.files.filter((f) => f.path.includes(".test."));
-    for (const sourceFile of addedSourceFiles) {
-      const expectedTestPath = sourceFile.path.replace(".ts", ".test.ts");
-      const hasTest = testFiles.some(
-        (t) => t.path.includes(expectedTestPath) || t.path.includes(sourceFile.path.replace(".ts", ""))
+    if (graphImpactData) {
+      for (const file of changes.files) {
+        if (file.status === "added" && file.path.endsWith(".ts") && !file.path.includes(".test.")) {
+          const hasGraphTest = graphImpactData.affectedTests.some(
+            (t) => t.coversFile === file.path
+          );
+          if (!hasGraphTest) {
+            items.push({
+              id: `test-coverage-${file.path}`,
+              category: "diff",
+              check: "Test coverage (graph)",
+              passed: false,
+              severity: "warning",
+              details: `New file ${file.path} has no test file linked in the graph`,
+              file: file.path
+            });
+          }
+        }
+      }
+    } else {
+      const addedSourceFiles = changes.files.filter(
+        (f) => f.status === "added" && f.path.endsWith(".ts") && !f.path.includes(".test.")
       );
-      if (!hasTest) {
-        items.push({
-          id: `diff-${++itemId}`,
-          category: "diff",
-          check: `Test coverage: ${sourceFile.path}`,
-          passed: false,
-          severity: "warning",
-          details: "New source file added without corresponding test file",
-          file: sourceFile.path,
-          suggestion: `Add tests in ${expectedTestPath}`
-        });
+      const testFiles = changes.files.filter((f) => f.path.includes(".test."));
+      for (const sourceFile of addedSourceFiles) {
+        const expectedTestPath = sourceFile.path.replace(".ts", ".test.ts");
+        const hasTest = testFiles.some(
+          (t) => t.path.includes(expectedTestPath) || t.path.includes(sourceFile.path.replace(".ts", ""))
+        );
+        if (!hasTest) {
+          items.push({
+            id: `diff-${++itemId}`,
+            category: "diff",
+            check: `Test coverage: ${sourceFile.path}`,
+            passed: false,
+            severity: "warning",
+            details: "New source file added without corresponding test file",
+            file: sourceFile.path,
+            suggestion: `Add tests in ${expectedTestPath}`
+          });
+        }
+      }
+    }
+  }
+  if (graphImpactData && graphImpactData.impactScope > 20) {
+    items.push({
+      id: "impact-scope",
+      category: "diff",
+      check: "Impact scope",
+      passed: false,
+      severity: "warning",
+      details: `Changes affect ${graphImpactData.impactScope} downstream dependents \u2014 consider a thorough review`
+    });
+  }
+  if (graphImpactData) {
+    for (const file of changes.files) {
+      if (file.status === "modified" && file.path.endsWith(".ts") && !file.path.includes(".test.")) {
+        const hasDoc = graphImpactData.affectedDocs.some((d) => d.documentsFile === file.path);
+        if (!hasDoc) {
+          items.push({
+            id: `doc-coverage-${file.path}`,
+            category: "diff",
+            check: "Documentation coverage (graph)",
+            passed: true,
+            severity: "info",
+            details: `Modified file ${file.path} has no documentation linked in the graph`,
+            file: file.path
+          });
+        }
       }
     }
   }
@@ -3008,13 +3275,16 @@ async function analyzeDiff(changes, options) {
 var ChecklistBuilder = class {
   rootDir;
   harnessOptions;
+  graphHarnessData;
   customRules = [];
   diffOptions;
+  graphImpactData;
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
-  withHarnessChecks(options) {
+  withHarnessChecks(options, graphData) {
     this.harnessOptions = options ?? { context: true, constraints: true, entropy: true };
+    this.graphHarnessData = graphData;
     return this;
   }
   addRule(rule) {
@@ -3025,46 +3295,79 @@ var ChecklistBuilder = class {
     this.customRules.push(...rules);
     return this;
   }
-  withDiffAnalysis(options) {
+  withDiffAnalysis(options, graphImpactData) {
     this.diffOptions = options;
+    this.graphImpactData = graphImpactData;
     return this;
   }
   async run(changes) {
     const startTime = Date.now();
     const items = [];
     if (this.harnessOptions) {
-      if (this.harnessOptions.context) {
-        items.push({
-          id: "harness-context",
-          category: "harness",
-          check: "Context Engineering (AGENTS.md, doc coverage)",
-          passed: true,
-          severity: "info",
-          details: "Harness context validation not yet integrated. See Module 2 (context/).",
-          suggestion: "Integrate with validateAgentsMap(), checkDocCoverage() from context module"
-        });
+      if (this.harnessOptions.context !== false) {
+        if (this.graphHarnessData) {
+          items.push({
+            id: "harness-context",
+            category: "harness",
+            check: "Context validation",
+            passed: this.graphHarnessData.graphExists && this.graphHarnessData.nodeCount > 0,
+            severity: "info",
+            details: this.graphHarnessData.graphExists ? `Graph loaded: ${this.graphHarnessData.nodeCount} nodes, ${this.graphHarnessData.edgeCount} edges` : "No graph available \u2014 run harness scan to build the knowledge graph"
+          });
+        } else {
+          items.push({
+            id: "harness-context",
+            category: "harness",
+            check: "Context validation",
+            passed: true,
+            severity: "info",
+            details: "Harness context validation not yet integrated (run with graph for real checks)"
+          });
+        }
       }
-      if (this.harnessOptions.constraints) {
-        items.push({
-          id: "harness-constraints",
-          category: "harness",
-          check: "Architectural Constraints (dependencies, boundaries)",
-          passed: true,
-          severity: "info",
-          details: "Harness constraints validation not yet integrated. See Module 3 (constraints/).",
-          suggestion: "Integrate with validateDependencies(), detectCircularDeps() from constraints module"
-        });
+      if (this.harnessOptions.constraints !== false) {
+        if (this.graphHarnessData) {
+          const violations = this.graphHarnessData.constraintViolations;
+          items.push({
+            id: "harness-constraints",
+            category: "harness",
+            check: "Constraint validation",
+            passed: violations === 0,
+            severity: violations > 0 ? "error" : "info",
+            details: violations === 0 ? "No constraint violations detected" : `${violations} constraint violation(s) detected`
+          });
+        } else {
+          items.push({
+            id: "harness-constraints",
+            category: "harness",
+            check: "Constraint validation",
+            passed: true,
+            severity: "info",
+            details: "Harness constraint validation not yet integrated (run with graph for real checks)"
+          });
+        }
       }
-      if (this.harnessOptions.entropy) {
-        items.push({
-          id: "harness-entropy",
-          category: "harness",
-          check: "Entropy Management (drift, dead code)",
-          passed: true,
-          severity: "info",
-          details: "Harness entropy validation not yet integrated. See Module 4 (entropy/).",
-          suggestion: "Integrate with EntropyAnalyzer from entropy module"
-        });
+      if (this.harnessOptions.entropy !== false) {
+        if (this.graphHarnessData) {
+          const issues = this.graphHarnessData.unreachableNodes + this.graphHarnessData.undocumentedFiles;
+          items.push({
+            id: "harness-entropy",
+            category: "harness",
+            check: "Entropy detection",
+            passed: issues === 0,
+            severity: issues > 0 ? "warning" : "info",
+            details: issues === 0 ? "No entropy issues detected" : `${this.graphHarnessData.unreachableNodes} unreachable node(s), ${this.graphHarnessData.undocumentedFiles} undocumented file(s)`
+          });
+        } else {
+          items.push({
+            id: "harness-entropy",
+            category: "harness",
+            check: "Entropy detection",
+            passed: true,
+            severity: "info",
+            details: "Harness entropy detection not yet integrated (run with graph for real checks)"
+          });
+        }
       }
     }
     for (const rule of this.customRules) {
@@ -3100,7 +3403,7 @@ var ChecklistBuilder = class {
       }
     }
     if (this.diffOptions) {
-      const diffResult = await analyzeDiff(changes, this.diffOptions);
+      const diffResult = await analyzeDiff(changes, this.diffOptions, this.graphImpactData);
       if (diffResult.ok) {
         items.push(...diffResult.value);
       }
@@ -3127,16 +3430,16 @@ var ChecklistBuilder = class {
 };
 
 // src/feedback/review/self-review.ts
-async function createSelfReview(changes, config) {
+async function createSelfReview(changes, config, graphData) {
   const builder = new ChecklistBuilder(config.rootDir);
   if (config.harness) {
-    builder.withHarnessChecks(config.harness);
+    builder.withHarnessChecks(config.harness, graphData?.harness);
   }
   if (config.customRules) {
     builder.addRules(config.customRules);
   }
   if (config.diffAnalysis) {
-    builder.withDiffAnalysis(config.diffAnalysis);
+    builder.withDiffAnalysis(config.diffAnalysis, graphData?.impact);
   }
   return builder.run(changes);
 }
@@ -3996,9 +4299,16 @@ async function runSingleCheck(name, projectRoot, config) {
         break;
       }
       case "deps": {
-        const layers = config.layers;
-        if (layers && layers.length > 0) {
+        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,