@harness-engineering/core 0.5.0

package/dist/index.js

@@ -0,0 +1,4077 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentActionEmitter: () => AgentActionEmitter,
+  ChecklistBuilder: () => ChecklistBuilder,
+  ConsoleSink: () => ConsoleSink,
+  DEFAULT_STATE: () => DEFAULT_STATE,
+  EntropyAnalyzer: () => EntropyAnalyzer,
+  EntropyConfigSchema: () => EntropyConfigSchema,
+  Err: () => Err,
+  FailureEntrySchema: () => FailureEntrySchema,
+  FileSink: () => FileSink,
+  GateConfigSchema: () => GateConfigSchema,
+  GateResultSchema: () => GateResultSchema,
+  HandoffSchema: () => HandoffSchema,
+  HarnessStateSchema: () => HarnessStateSchema,
+  NoOpExecutor: () => NoOpExecutor,
+  NoOpSink: () => NoOpSink,
+  NoOpTelemetryAdapter: () => NoOpTelemetryAdapter,
+  Ok: () => Ok,
+  PatternConfigSchema: () => PatternConfigSchema,
+  REQUIRED_SECTIONS: () => REQUIRED_SECTIONS,
+  TypeScriptParser: () => TypeScriptParser,
+  VERSION: () => VERSION,
+  analyzeDiff: () => analyzeDiff,
+  appendFailure: () => appendFailure,
+  appendLearning: () => appendLearning,
+  applyFixes: () => applyFixes,
+  archiveFailures: () => archiveFailures,
+  buildDependencyGraph: () => buildDependencyGraph,
+  buildReachabilityMap: () => buildReachabilityMap,
+  buildSnapshot: () => buildSnapshot,
+  checkConfigPattern: () => checkConfigPattern,
+  checkDocCoverage: () => checkDocCoverage,
+  configureFeedback: () => configureFeedback,
+  contextBudget: () => contextBudget,
+  contextFilter: () => contextFilter,
+  createBoundaryValidator: () => createBoundaryValidator,
+  createError: () => createError,
+  createFixes: () => createFixes,
+  createParseError: () => createParseError,
+  createSelfReview: () => createSelfReview,
+  defineLayer: () => defineLayer,
+  detectCircularDeps: () => detectCircularDeps,
+  detectCircularDepsInFiles: () => detectCircularDepsInFiles,
+  detectDeadCode: () => detectDeadCode,
+  detectDocDrift: () => detectDocDrift,
+  detectPatternViolations: () => detectPatternViolations,
+  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,
+  runMechanicalGate: () => runMechanicalGate,
+  runMultiTurnPipeline: () => runMultiTurnPipeline,
+  runPipeline: () => runPipeline,
+  saveHandoff: () => saveHandoff,
+  saveState: () => saveState,
+  trackAction: () => trackAction,
+  validateAgentsMap: () => validateAgentsMap,
+  validateBoundaries: () => validateBoundaries,
+  validateCommitMessage: () => validateCommitMessage,
+  validateConfig: () => validateConfig,
+  validateDependencies: () => validateDependencies,
+  validateFileStructure: () => validateFileStructure,
+  validateKnowledgeMap: () => validateKnowledgeMap,
+  validatePatternConfig: () => validatePatternConfig
+});
+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 };
+}
+function createEntropyError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+
+// 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) {
+  try {
+    await accessAsync(path2, import_fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileContent(path2) {
+  try {
+    const content = await readFileAsync(path2, "utf-8");
+    return Ok(content);
+  } catch (error) {
+    return Err(error);
+  }
+}
+async function findFiles(pattern, cwd = process.cwd()) {
+  return (0, import_glob.glob)(pattern, { cwd, absolute: true });
+}
+
+// src/validation/file-structure.ts
+async function validateFileStructure(projectPath, conventions) {
+  const missing = [];
+  const unexpected = [];
+  let foundRequired = 0;
+  const totalRequired = conventions.filter((c) => c.required).length;
+  for (const convention of conventions) {
+    const files = await findFiles(convention.pattern, projectPath);
+    if (convention.required) {
+      if (files.length === 0) {
+        missing.push(convention.pattern);
+      } else {
+        foundRequired++;
+      }
+    }
+  }
+  const conformance = totalRequired === 0 ? 100 : foundRequired / totalRequired * 100;
+  const validation = {
+    valid: missing.length === 0,
+    missing,
+    unexpected,
+    conformance
+  };
+  return Ok(validation);
+}
+
+// src/validation/config.ts
+function validateConfig(data, schema) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return Ok(result.data);
+  }
+  const zodErrors = result.error;
+  const firstError = zodErrors.errors[0];
+  let code = "VALIDATION_FAILED";
+  let message = "Configuration validation failed";
+  const suggestions = [];
+  if (firstError) {
+    const path2 = firstError.path.join(".");
+    const pathDisplay = path2 ? ` at "${path2}"` : "";
+    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}"`);
+      } else {
+        code = "INVALID_TYPE";
+        message = `Invalid type${pathDisplay}: ${firstError.message}`;
+        suggestions.push(`Expected ${expected} but got ${received}`);
+      }
+    } else {
+      code = "VALIDATION_FAILED";
+      message = `${firstError.message}${pathDisplay}`;
+    }
+  }
+  const error = createError(
+    code,
+    message,
+    {
+      zodError: zodErrors,
+      path: firstError?.path
+    },
+    suggestions
+  );
+  return Err(error);
+}
+
+// src/validation/commit-message.ts
+var VALID_TYPES = [
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "revert"
+];
+var CONVENTIONAL_PATTERN = /^(\w+)(\(([^)]+)\))?(!)?: (.+)$/;
+function validateCommitMessage(message, format = "conventional") {
+  if (!message || typeof message !== "string") {
+    const error = createError(
+      "VALIDATION_FAILED",
+      "Commit message must be a non-empty string",
+      { message },
+      ["Provide a valid commit message"]
+    );
+    return Err(error);
+  }
+  if (format === "conventional" || format === "angular") {
+    return validateConventionalCommit(message);
+  }
+  return Ok({
+    valid: true,
+    breaking: false,
+    issues: []
+  });
+}
+function validateConventionalCommit(message) {
+  const lines = message.split("\n");
+  const headerLine = lines[0];
+  if (!headerLine) {
+    const error = createError(
+      "VALIDATION_FAILED",
+      "Commit message header cannot be empty",
+      { message },
+      ["Provide a commit message with at least a header line"]
+    );
+    return Err(error);
+  }
+  const match = headerLine.match(CONVENTIONAL_PATTERN);
+  if (!match) {
+    const error = createError(
+      "VALIDATION_FAILED",
+      "Commit message does not follow conventional format",
+      { message, header: headerLine },
+      [
+        "Use format: type(scope)?: description",
+        "Valid types: " + VALID_TYPES.join(", "),
+        "Example: feat(core): add new feature"
+      ]
+    );
+    return Err(error);
+  }
+  const type = match[1];
+  const scope = match[3];
+  const breaking = match[4] === "!";
+  const description = match[5];
+  const issues = [];
+  if (!VALID_TYPES.includes(type)) {
+    issues.push(`Invalid commit type "${type}". Valid types: ${VALID_TYPES.join(", ")}`);
+  }
+  if (!description || description.trim() === "") {
+    issues.push("Commit description cannot be empty");
+  }
+  let hasBreakingChange = breaking;
+  if (lines.length > 1) {
+    const body = lines.slice(1).join("\n");
+    if (body.includes("BREAKING CHANGE:")) {
+      hasBreakingChange = true;
+    }
+  }
+  if (issues.length > 0) {
+    let errorMessage = `Commit message validation failed: ${issues.join("; ")}`;
+    if (issues.some((issue) => issue.includes("description cannot be empty"))) {
+      errorMessage = `Commit message validation failed: ${issues.join("; ")}`;
+    }
+    const error = createError(
+      "VALIDATION_FAILED",
+      errorMessage,
+      { message, issues, type, scope },
+      ["Review and fix the validation issues above"]
+    );
+    return Err(error);
+  }
+  const result = {
+    valid: true,
+    type,
+    ...scope && { scope },
+    breaking: hasBreakingChange,
+    issues: []
+  };
+  return Ok(result);
+}
+
+// src/context/types.ts
+var REQUIRED_SECTIONS = [
+  "Project Overview",
+  "Repository Structure",
+  "Development Workflow"
+];
+
+// src/context/agents-map.ts
+var import_path = require("path");
+function extractMarkdownLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  const linkPattern = /\[([^\]]+)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    let match;
+    linkPattern.lastIndex = 0;
+    while ((match = linkPattern.exec(line)) !== null) {
+      if (match[1] && match[2]) {
+        links.push({
+          text: match[1],
+          path: match[2],
+          line: i + 1
+          // 1-indexed
+        });
+      }
+    }
+  }
+  return links;
+}
+function extractSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  const headingPattern = /^(#{1,6})\s+(.+)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const match = line.match(headingPattern);
+    if (match && match[1] && match[2]) {
+      sections.push({
+        title: match[2].trim(),
+        level: match[1].length,
+        line: i + 1,
+        // 1-indexed
+        startIndex: i
+      });
+    }
+  }
+  for (let i = 0; i < sections.length; i++) {
+    const currentSection = sections[i];
+    const nextSection = sections[i + 1];
+    if (currentSection) {
+      currentSection.endIndex = nextSection ? nextSection.startIndex : lines.length;
+    }
+  }
+  return sections.map((section) => {
+    const endIndex = section.endIndex ?? lines.length;
+    const sectionLines = lines.slice(section.startIndex + 1, endIndex);
+    const sectionContent = sectionLines.join("\n");
+    const links = extractMarkdownLinks(sectionContent).map((link) => ({
+      ...link,
+      line: link.line + section.startIndex + 1,
+      // Adjust line number
+      exists: false
+      // Will be set later by validateAgentsMap
+    }));
+    const descriptionLines = [];
+    for (const line of sectionLines) {
+      const trimmed = line.trim();
+      if (trimmed === "") {
+        if (descriptionLines.length > 0) break;
+        continue;
+      }
+      if (trimmed.startsWith("#")) break;
+      if (trimmed.startsWith("-") || trimmed.startsWith("*")) break;
+      if (trimmed.startsWith("```")) break;
+      descriptionLines.push(trimmed);
+    }
+    const result = {
+      title: section.title,
+      level: section.level,
+      line: section.line,
+      links
+    };
+    if (descriptionLines.length > 0) {
+      result.description = descriptionLines.join(" ");
+    }
+    return result;
+  });
+}
+function isExternalLink(path2) {
+  return path2.startsWith("http://") || path2.startsWith("https://") || path2.startsWith("#") || path2.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);
+  if (!contentResult.ok) {
+    return Err(
+      createError(
+        "PARSE_ERROR",
+        `Failed to read AGENTS.md: ${contentResult.error.message}`,
+        { path: path2 },
+        ["Ensure the file exists", "Check file permissions"]
+      )
+    );
+  }
+  const content = contentResult.value;
+  const sections = extractSections(content);
+  const baseDir = (0, import_path.dirname)(path2);
+  const sectionTitles = sections.map((s) => s.title);
+  const missingSections = REQUIRED_SECTIONS.filter(
+    (required) => !sectionTitles.some((title) => title.toLowerCase().includes(required.toLowerCase()))
+  );
+  const allLinks = [];
+  const brokenLinks = [];
+  for (const section of sections) {
+    for (const link of section.links) {
+      if (isExternalLink(link.path)) {
+        const externalLink = { ...link, exists: true };
+        allLinks.push(externalLink);
+        continue;
+      }
+      const absolutePath = resolveLinkPath(link.path, baseDir);
+      const exists = await fileExists(absolutePath);
+      const fullLink = { ...link, exists };
+      allLinks.push(fullLink);
+      if (!exists) {
+        brokenLinks.push(fullLink);
+      }
+    }
+    section.links = section.links.map(
+      (link) => allLinks.find((l) => l.path === link.path && l.line === link.line) || {
+        ...link,
+        exists: false
+      }
+    );
+  }
+  const valid = missingSections.length === 0 && brokenLinks.length === 0;
+  return Ok({
+    valid,
+    sections,
+    totalLinks: allLinks.length,
+    brokenLinks,
+    missingSections: [...missingSections]
+  });
+}
+
+// src/context/doc-coverage.ts
+var import_path2 = require("path");
+function determineImportance(filePath) {
+  const name = (0, import_path2.basename)(filePath).toLowerCase();
+  if (name === "index.ts" || name === "index.js" || name === "main.ts") {
+    return "high";
+  }
+  if (name.includes("types") || name.endsWith(".d.ts")) {
+    return "high";
+  }
+  if (name.includes(".test.") || name.includes(".spec.") || name.includes("config")) {
+    return "low";
+  }
+  return "medium";
+}
+function suggestSection(filePath, domain) {
+  const name = (0, import_path2.basename)(filePath).toLowerCase();
+  if (name.includes("types")) return "API Types";
+  if (name === "index.ts" || name === "index.js") return "Module Exports";
+  if (name.includes("util")) return "Utilities";
+  return `${domain} Reference`;
+}
+async function checkDocCoverage(domain, options = {}) {
+  const { docsDir = "./docs", sourceDir = "./src", excludePatterns = [] } = options;
+  try {
+    const sourceFiles = await findFiles("**/*.{ts,js,tsx,jsx}", sourceDir);
+    const filteredSourceFiles = sourceFiles.filter((file) => {
+      const relativePath = (0, import_path2.relative)(sourceDir, file);
+      return !excludePatterns.some((pattern) => {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+        const regex = new RegExp("^" + escaped + "$");
+        return regex.test(relativePath) || regex.test(file);
+      });
+    });
+    const docFiles = await findFiles("**/*.md", docsDir);
+    const documentedPaths = /* @__PURE__ */ new Set();
+    for (const docFile of docFiles) {
+      const contentResult = await readFileContent(docFile);
+      if (contentResult.ok) {
+        const links = extractMarkdownLinks(contentResult.value);
+        for (const link of links) {
+          const normalizedPath = link.path.replace(/^\.\.\//, "").replace(/^\.\//, "");
+          documentedPaths.add(normalizedPath);
+          const linkBasename = (0, import_path2.basename)(link.path);
+          documentedPaths.add(linkBasename);
+        }
+      }
+    }
+    const documented = [];
+    const undocumented = [];
+    const gaps = [];
+    for (const sourceFile of filteredSourceFiles) {
+      const relativePath = (0, import_path2.relative)(sourceDir, sourceFile);
+      const fileName = (0, import_path2.basename)(sourceFile);
+      const isDocumented = documentedPaths.has(relativePath) || documentedPaths.has(fileName) || documentedPaths.has(`src/${relativePath}`);
+      if (isDocumented) {
+        documented.push(relativePath);
+      } else {
+        undocumented.push(relativePath);
+        gaps.push({
+          file: relativePath,
+          suggestedSection: suggestSection(sourceFile, domain),
+          importance: determineImportance(sourceFile)
+        });
+      }
+    }
+    const total = documented.length + undocumented.length;
+    const coveragePercentage = total > 0 ? Math.round(documented.length / total * 100) : 100;
+    return Ok({
+      domain,
+      documented,
+      undocumented,
+      coveragePercentage,
+      gaps
+    });
+  } catch (error) {
+    return Err(
+      createError(
+        "PARSE_ERROR",
+        `Failed to analyze documentation coverage: ${error.message}`,
+        { domain, docsDir, sourceDir },
+        ["Ensure directories exist", "Check file permissions"]
+      )
+    );
+  }
+}
+
+// src/context/knowledge-map.ts
+var import_path3 = require("path");
+function suggestFix(path2, existingFiles) {
+  const targetName = (0, import_path3.basename)(path2).toLowerCase();
+  const similar = existingFiles.find((file) => {
+    const fileName = (0, import_path3.basename)(file).toLowerCase();
+    return fileName.includes(targetName) || targetName.includes(fileName);
+  });
+  if (similar) {
+    return `Did you mean "${similar}"?`;
+  }
+  return `Create the file "${path2}" 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);
+  }
+  const {
+    sections,
+    brokenLinks: agentsBrokenLinks,
+    totalLinks: agentsTotalLinks
+  } = agentsResult.value;
+  const existingFiles = await findFiles("**/*", rootDir);
+  const relativeExistingFiles = existingFiles.map((f) => (0, import_path3.relative)(rootDir, f));
+  const brokenLinks = agentsBrokenLinks.map((link) => {
+    const section = sections.find(
+      (s) => s.links.some((l) => l.path === link.path && l.line === link.line)
+    );
+    return {
+      text: link.text,
+      path: link.path,
+      line: link.line,
+      section: section?.title || "Unknown",
+      reason: "NOT_FOUND",
+      suggestion: suggestFix(link.path, relativeExistingFiles)
+    };
+  });
+  const validLinks = agentsTotalLinks - brokenLinks.length;
+  const integrity = agentsTotalLinks > 0 ? Math.round(validLinks / agentsTotalLinks * 100) : 100;
+  return Ok({
+    totalLinks: agentsTotalLinks,
+    brokenLinks,
+    validLinks,
+    integrity
+  });
+}
+
+// src/context/generate.ts
+var import_path4 = require("path");
+var DEFAULT_SECTIONS = [
+  {
+    name: "Documentation",
+    pattern: "docs/**/*.md",
+    description: "Project documentation"
+  },
+  {
+    name: "Source Code",
+    pattern: "src/**/*.ts",
+    description: "Source code modules"
+  }
+];
+function groupByDirectory(files, rootDir) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const relativePath = (0, import_path4.relative)(rootDir, file);
+    const dir = (0, import_path4.dirname)(relativePath);
+    if (!groups.has(dir)) {
+      groups.set(dir, []);
+    }
+    groups.get(dir).push(relativePath);
+  }
+  return groups;
+}
+function formatFileLink(filePath) {
+  const ext = filePath.match(/\.[^.]+$/)?.[0] || "";
+  const name = (0, import_path4.basename)(filePath, ext).replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  return `- [${name}](./${filePath})`;
+}
+function matchesExcludePattern(relativePath, excludePatterns) {
+  return excludePatterns.some((pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    const regex = new RegExp("^" + escaped + "$");
+    return regex.test(relativePath);
+  });
+}
+async function generateAgentsMap(config) {
+  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("");
+    lines.push("This is the single source of truth for AI agents working on this project.");
+    lines.push("");
+    lines.push("## Project Overview");
+    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}/`);
+        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);
+        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("## Development Workflow");
+    lines.push("");
+    lines.push(
+      "> Document your development workflow: branching strategy, testing commands, deployment process."
+    );
+    lines.push("");
+    return Ok(lines.join("\n"));
+  } catch (error) {
+    return Err(
+      createError(
+        "PARSE_ERROR",
+        `Failed to generate AGENTS.md: ${error.message}`,
+        { rootDir },
+        ["Check directory permissions", "Ensure glob patterns are valid"]
+      )
+    );
+  }
+}
+
+// src/context/budget.ts
+var DEFAULT_RATIOS = {
+  systemPrompt: 0.15,
+  projectManifest: 0.05,
+  taskSpec: 0.2,
+  activeCode: 0.4,
+  interfaces: 0.1,
+  reserve: 0.1
+};
+function contextBudget(totalTokens, overrides) {
+  const ratios = {
+    systemPrompt: DEFAULT_RATIOS.systemPrompt,
+    projectManifest: DEFAULT_RATIOS.projectManifest,
+    taskSpec: DEFAULT_RATIOS.taskSpec,
+    activeCode: DEFAULT_RATIOS.activeCode,
+    interfaces: DEFAULT_RATIOS.interfaces,
+    reserve: DEFAULT_RATIOS.reserve
+  };
+  if (overrides) {
+    let overrideSum = 0;
+    const overrideKeys = [];
+    for (const [key, value] of Object.entries(overrides)) {
+      if (value !== void 0 && key in ratios) {
+        const k = key;
+        ratios[k] = value;
+        overrideSum += value;
+        overrideKeys.push(k);
+      }
+    }
+    if (overrideKeys.length > 0 && overrideKeys.length < 6) {
+      const remaining = 1 - overrideSum;
+      const nonOverridden = Object.keys(DEFAULT_RATIOS).filter(
+        (k) => !overrideKeys.includes(k)
+      );
+      const originalSum = nonOverridden.reduce((sum, k) => sum + DEFAULT_RATIOS[k], 0);
+      for (const k of nonOverridden) {
+        ratios[k] = remaining * (DEFAULT_RATIOS[k] / originalSum);
+      }
+    }
+  }
+  return {
+    total: totalTokens,
+    systemPrompt: Math.floor(totalTokens * ratios.systemPrompt),
+    projectManifest: Math.floor(totalTokens * ratios.projectManifest),
+    taskSpec: Math.floor(totalTokens * ratios.taskSpec),
+    activeCode: Math.floor(totalTokens * ratios.activeCode),
+    interfaces: Math.floor(totalTokens * ratios.interfaces),
+    reserve: Math.floor(totalTokens * ratios.reserve)
+  };
+}
+
+// src/context/filter.ts
+var PHASE_PRIORITIES = {
+  implement: [
+    { category: "source", patterns: ["src/**/*.ts", "src/**/*.tsx"], priority: 1 },
+    {
+      category: "types",
+      patterns: ["src/**/types.ts", "src/**/interfaces.ts", "**/*.d.ts"],
+      priority: 2
+    },
+    { category: "tests", patterns: ["tests/**/*.test.ts", "**/*.spec.ts"], priority: 3 },
+    { category: "specs", patterns: ["docs/specs/**/*.md"], priority: 4 },
+    { category: "config", patterns: ["package.json", "tsconfig.json"], priority: 5 }
+  ],
+  review: [
+    { category: "diff", patterns: [], priority: 1 },
+    // Diff is provided, not globbed
+    { category: "specs", patterns: ["docs/specs/**/*.md", "docs/plans/**/*.md"], priority: 2 },
+    { category: "learnings", patterns: [".harness/review-learnings.md"], priority: 3 },
+    { category: "types", patterns: ["src/**/types.ts", "src/**/interfaces.ts"], priority: 4 },
+    { category: "tests", patterns: ["tests/**/*.test.ts"], priority: 5 }
+  ],
+  debug: [
+    { category: "source", patterns: ["src/**/*.ts"], priority: 1 },
+    { category: "tests", patterns: ["tests/**/*.test.ts"], priority: 2 },
+    { category: "antipatterns", patterns: [".harness/anti-patterns.md"], priority: 3 },
+    { category: "config", patterns: ["package.json", "tsconfig.json", ".env*"], priority: 4 },
+    { category: "types", patterns: ["src/**/types.ts"], priority: 5 }
+  ],
+  plan: [
+    { category: "specs", patterns: ["docs/specs/**/*.md", "docs/plans/**/*.md"], priority: 1 },
+    { category: "architecture", patterns: ["AGENTS.md", "docs/standard/**/*.md"], priority: 2 },
+    { category: "handoffs", patterns: [".harness/handoff.md"], priority: 3 },
+    { category: "types", patterns: ["src/**/types.ts", "src/**/interfaces.ts"], priority: 4 },
+    { category: "config", patterns: ["harness.config.json", "package.json"], priority: 5 }
+  ]
+};
+function contextFilter(phase, maxCategories) {
+  const categories = PHASE_PRIORITIES[phase];
+  const limit = maxCategories ?? categories.length;
+  const included = categories.slice(0, limit);
+  const excluded = categories.slice(limit);
+  return {
+    phase,
+    includedCategories: included.map((c) => c.category),
+    excludedCategories: excluded.map((c) => c.category),
+    filePatterns: included.flatMap((c) => c.patterns)
+  };
+}
+function getPhaseCategories(phase) {
+  return [...PHASE_PRIORITIES[phase]];
+}
+
+// src/constraints/layers.ts
+var import_minimatch = require("minimatch");
+function defineLayer(name, patterns, allowedDependencies) {
+  return {
+    name,
+    patterns,
+    allowedDependencies
+  };
+}
+function resolveFileToLayer(file, layers) {
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      if ((0, import_minimatch.minimatch)(file, pattern)) {
+        return layer;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/constraints/dependencies.ts
+var import_path5 = require("path");
+function resolveImportPath(importSource, fromFile, _rootDir) {
+  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
+    return null;
+  }
+  const fromDir = (0, import_path5.dirname)(fromFile);
+  let resolved = (0, import_path5.resolve)(fromDir, importSource);
+  if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+    resolved = resolved + ".ts";
+  }
+  return resolved;
+}
+function getImportType(imp) {
+  if (imp.kind === "type") return "type-only";
+  return "static";
+}
+async function buildDependencyGraph(files, parser) {
+  const nodes = [...files];
+  const edges = [];
+  for (const file of files) {
+    const parseResult = await parser.parseFile(file);
+    if (!parseResult.ok) {
+      continue;
+    }
+    const importsResult = parser.extractImports(parseResult.value);
+    if (!importsResult.ok) {
+      continue;
+    }
+    for (const imp of importsResult.value) {
+      const resolvedPath = resolveImportPath(imp.source, file, "");
+      if (resolvedPath) {
+        edges.push({
+          from: file,
+          to: resolvedPath,
+          importType: getImportType(imp),
+          line: imp.location.line
+        });
+      }
+    }
+  }
+  return Ok({ nodes, edges });
+}
+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 fromLayer = resolveFileToLayer(fromRelative, layers);
+    const toLayer = resolveFileToLayer(toRelative, layers);
+    if (!fromLayer || !toLayer) continue;
+    if (fromLayer.name === toLayer.name) continue;
+    if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
+      violations.push({
+        file: edge.from,
+        imports: edge.to,
+        fromLayer: fromLayer.name,
+        toLayer: toLayer.name,
+        reason: "WRONG_LAYER",
+        line: edge.line,
+        suggestion: `Move the dependency to an allowed layer (${fromLayer.allowedDependencies.join(", ") || "none"}) or update layer rules`
+      });
+    }
+  }
+  return violations;
+}
+async function validateDependencies(config) {
+  const { layers, rootDir, parser, fallbackBehavior = "error" } = config;
+  const healthResult = await parser.health();
+  if (!healthResult.ok || !healthResult.value.available) {
+    if (fallbackBehavior === "skip") {
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    if (fallbackBehavior === "warn") {
+      console.warn(`Parser ${parser.name} unavailable, skipping validation`);
+      return Ok({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    return Err(
+      createError(
+        "PARSER_UNAVAILABLE",
+        `Parser ${parser.name} is not available`,
+        { parser: parser.name },
+        ["Install required runtime", "Use different parser", 'Set fallbackBehavior: "skip"']
+      )
+    );
+  }
+  const allFiles = [];
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      const files = await findFiles(pattern, rootDir);
+      allFiles.push(...files);
+    }
+  }
+  const uniqueFiles = [...new Set(allFiles)];
+  const graphResult = await buildDependencyGraph(uniqueFiles, parser);
+  if (!graphResult.ok) {
+    return Err(graphResult.error);
+  }
+  const violations = checkLayerViolations(graphResult.value, layers, rootDir);
+  return Ok({
+    valid: violations.length === 0,
+    violations,
+    graph: graphResult.value
+  });
+}
+
+// src/constraints/circular-deps.ts
+function tarjanSCC(graph) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const stack = [];
+  const sccs = [];
+  let index = 0;
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    adjacency.set(node, []);
+  }
+  for (const edge of graph.edges) {
+    const neighbors = adjacency.get(edge.from);
+    if (neighbors && graph.nodes.includes(edge.to)) {
+      neighbors.push(edge.to);
+    }
+  }
+  function strongConnect(node) {
+    nodeMap.set(node, {
+      index,
+      lowlink: index,
+      onStack: true
+    });
+    index++;
+    stack.push(node);
+    const neighbors = adjacency.get(node) ?? [];
+    for (const neighbor of neighbors) {
+      const neighborData = nodeMap.get(neighbor);
+      if (!neighborData) {
+        strongConnect(neighbor);
+        const nodeData2 = nodeMap.get(node);
+        const updatedNeighborData = nodeMap.get(neighbor);
+        nodeData2.lowlink = Math.min(nodeData2.lowlink, updatedNeighborData.lowlink);
+      } else if (neighborData.onStack) {
+        const nodeData2 = nodeMap.get(node);
+        nodeData2.lowlink = Math.min(nodeData2.lowlink, neighborData.index);
+      }
+    }
+    const nodeData = nodeMap.get(node);
+    if (nodeData.lowlink === nodeData.index) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        nodeMap.get(w).onStack = false;
+        scc.push(w);
+      } while (w !== node);
+      if (scc.length > 1) {
+        sccs.push(scc);
+      } else if (scc.length === 1) {
+        const selfNode = scc[0];
+        const selfNeighbors = adjacency.get(selfNode) ?? [];
+        if (selfNeighbors.includes(selfNode)) {
+          sccs.push(scc);
+        }
+      }
+    }
+  }
+  for (const node of graph.nodes) {
+    if (!nodeMap.has(node)) {
+      strongConnect(node);
+    }
+  }
+  return sccs;
+}
+function detectCircularDeps(graph) {
+  const sccs = tarjanSCC(graph);
+  const cycles = sccs.map((scc) => {
+    const reversed = scc.reverse();
+    const firstNode = reversed[reversed.length - 1];
+    const cycle = [...reversed, firstNode];
+    return {
+      cycle,
+      severity: "error",
+      size: scc.length
+    };
+  });
+  const largestCycle = cycles.reduce((max, c) => Math.max(max, c.size), 0);
+  return Ok({
+    hasCycles: cycles.length > 0,
+    cycles,
+    largestCycle
+  });
+}
+async function detectCircularDepsInFiles(files, parser) {
+  const graphResult = await buildDependencyGraph(files, parser);
+  if (!graphResult.ok) {
+    return graphResult;
+  }
+  return detectCircularDeps(graphResult.value);
+}
+
+// src/constraints/boundary.ts
+function createBoundaryValidator(schema, name) {
+  return {
+    name,
+    schema,
+    parse(input) {
+      const result = schema.safeParse(input);
+      if (result.success) {
+        return Ok(result.data);
+      }
+      const suggestions = result.error.issues.map((issue) => {
+        const path2 = issue.path.join(".");
+        return path2 ? `${path2}: ${issue.message}` : issue.message;
+      });
+      return Err(
+        createError(
+          "BOUNDARY_ERROR",
+          `Boundary validation failed for ${name}`,
+          {
+            boundary: name,
+            zodError: result.error,
+            input
+          },
+          suggestions
+        )
+      );
+    },
+    validate(input) {
+      const result = schema.safeParse(input);
+      return Ok(result.success);
+    }
+  };
+}
+function validateBoundaries(boundaries, data) {
+  const violations = [];
+  for (const boundary of boundaries) {
+    const input = data.get(boundary.name);
+    if (input === void 0) {
+      continue;
+    }
+    const result = boundary.schema.safeParse(input);
+    if (!result.success) {
+      violations.push({
+        boundary: boundary.name,
+        direction: boundary.direction,
+        error: result.error,
+        data: input
+      });
+    }
+  }
+  return Ok({
+    valid: violations.length === 0,
+    violations
+  });
+}
+
+// src/shared/parsers/typescript.ts
+var import_typescript_estree = require("@typescript-eslint/typescript-estree");
+
+// src/shared/parsers/base.ts
+function createParseError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+
+// src/shared/parsers/typescript.ts
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  if ("type" in node) {
+    visitor(node);
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      value.forEach((v) => walk(v, visitor));
+    } else {
+      walk(value, visitor);
+    }
+  }
+}
+var TypeScriptParser = class {
+  name = "typescript";
+  extensions = [".ts", ".tsx", ".mts", ".cts"];
+  async parseFile(path2) {
+    const contentResult = await readFileContent(path2);
+    if (!contentResult.ok) {
+      return Err(
+        createParseError("NOT_FOUND", `File not found: ${path2}`, { path: path2 }, [
+          "Check that the file exists",
+          "Verify the path is correct"
+        ])
+      );
+    }
+    try {
+      const ast = (0, import_typescript_estree.parse)(contentResult.value, {
+        loc: true,
+        range: true,
+        jsx: path2.endsWith(".tsx"),
+        errorOnUnknownASTType: false
+      });
+      return 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 }, [
+          "Check for syntax errors in the file",
+          "Ensure valid TypeScript syntax"
+        ])
+      );
+    }
+  }
+  extractImports(ast) {
+    const imports = [];
+    const program = ast.body;
+    walk(program, (node) => {
+      if (node.type === "ImportDeclaration") {
+        const importDecl = node;
+        const imp = {
+          source: importDecl.source.value,
+          specifiers: [],
+          location: {
+            file: "",
+            line: importDecl.loc?.start.line ?? 0,
+            column: importDecl.loc?.start.column ?? 0
+          },
+          kind: importDecl.importKind === "type" ? "type" : "value"
+        };
+        for (const spec of importDecl.specifiers) {
+          if (spec.type === "ImportDefaultSpecifier") {
+            imp.default = spec.local.name;
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            imp.namespace = spec.local.name;
+          } else if (spec.type === "ImportSpecifier") {
+            imp.specifiers.push(spec.local.name);
+            if (spec.importKind === "type") {
+              imp.kind = "type";
+            }
+          }
+        }
+        imports.push(imp);
+      }
+      if (node.type === "ImportExpression") {
+        const importExpr = node;
+        if (importExpr.source.type === "Literal" && typeof importExpr.source.value === "string") {
+          imports.push({
+            source: importExpr.source.value,
+            specifiers: [],
+            location: {
+              file: "",
+              line: importExpr.loc?.start.line ?? 0,
+              column: importExpr.loc?.start.column ?? 0
+            },
+            kind: "value"
+          });
+        }
+      }
+    });
+    return Ok(imports);
+  }
+  extractExports(ast) {
+    const exports2 = [];
+    const program = ast.body;
+    walk(program, (node) => {
+      if (node.type === "ExportNamedDeclaration") {
+        const exportDecl = node;
+        if (exportDecl.source) {
+          for (const spec of exportDecl.specifiers) {
+            if (spec.type === "ExportSpecifier") {
+              const exported = spec.exported;
+              const name = exported.type === "Identifier" ? exported.name : String(exported.value);
+              exports2.push({
+                name,
+                type: "named",
+                location: {
+                  file: "",
+                  line: exportDecl.loc?.start.line ?? 0,
+                  column: exportDecl.loc?.start.column ?? 0
+                },
+                isReExport: true,
+                source: exportDecl.source.value
+              });
+            }
+          }
+          return;
+        }
+        if (exportDecl.declaration) {
+          const decl = exportDecl.declaration;
+          if (decl.type === "VariableDeclaration") {
+            for (const declarator of decl.declarations) {
+              if (declarator.id.type === "Identifier") {
+                exports2.push({
+                  name: declarator.id.name,
+                  type: "named",
+                  location: {
+                    file: "",
+                    line: decl.loc?.start.line ?? 0,
+                    column: decl.loc?.start.column ?? 0
+                  },
+                  isReExport: false
+                });
+              }
+            }
+          } else if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+            if (decl.id) {
+              exports2.push({
+                name: decl.id.name,
+                type: "named",
+                location: {
+                  file: "",
+                  line: decl.loc?.start.line ?? 0,
+                  column: decl.loc?.start.column ?? 0
+                },
+                isReExport: false
+              });
+            }
+          }
+        }
+        for (const spec of exportDecl.specifiers) {
+          if (spec.type === "ExportSpecifier") {
+            const exported = spec.exported;
+            const name = exported.type === "Identifier" ? exported.name : String(exported.value);
+            exports2.push({
+              name,
+              type: "named",
+              location: {
+                file: "",
+                line: exportDecl.loc?.start.line ?? 0,
+                column: exportDecl.loc?.start.column ?? 0
+              },
+              isReExport: false
+            });
+          }
+        }
+      }
+      if (node.type === "ExportDefaultDeclaration") {
+        const exportDecl = node;
+        exports2.push({
+          name: "default",
+          type: "default",
+          location: {
+            file: "",
+            line: exportDecl.loc?.start.line ?? 0,
+            column: exportDecl.loc?.start.column ?? 0
+          },
+          isReExport: false
+        });
+      }
+      if (node.type === "ExportAllDeclaration") {
+        const exportDecl = node;
+        exports2.push({
+          name: exportDecl.exported?.name ?? "*",
+          type: "namespace",
+          location: {
+            file: "",
+            line: exportDecl.loc?.start.line ?? 0,
+            column: exportDecl.loc?.start.column ?? 0
+          },
+          isReExport: true,
+          source: exportDecl.source.value
+        });
+      }
+    });
+    return Ok(exports2);
+  }
+  async health() {
+    return Ok({ available: true, version: "7.0.0" });
+  }
+};
+
+// src/entropy/snapshot.ts
+var import_path6 = require("path");
+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);
+  }
+  const pkgPath = (0, import_path6.join)(rootDir, "package.json");
+  if (await fileExists(pkgPath)) {
+    const pkgContent = await readFileContent(pkgPath);
+    if (pkgContent.ok) {
+      try {
+        const pkg = JSON.parse(pkgContent.value);
+        const entries = [];
+        if (pkg["exports"]) {
+          const exports2 = pkg["exports"];
+          if (typeof exports2 === "string") {
+            entries.push((0, import_path6.resolve)(rootDir, exports2));
+          } else if (typeof exports2 === "object" && exports2 !== null) {
+            for (const value of Object.values(exports2)) {
+              if (typeof value === "string") {
+                entries.push((0, import_path6.resolve)(rootDir, value));
+              }
+            }
+          }
+        }
+        const main = pkg["main"];
+        if (typeof main === "string" && entries.length === 0) {
+          entries.push((0, import_path6.resolve)(rootDir, main));
+        }
+        const bin = pkg["bin"];
+        if (bin) {
+          if (typeof bin === "string") {
+            entries.push((0, import_path6.resolve)(rootDir, bin));
+          } else if (typeof bin === "object") {
+            for (const value of Object.values(bin)) {
+              if (typeof value === "string") {
+                entries.push((0, import_path6.resolve)(rootDir, value));
+              }
+            }
+          }
+        }
+        if (entries.length > 0) {
+          return Ok(entries);
+        }
+      } catch {
+      }
+    }
+  }
+  const conventions = ["src/index.ts", "src/main.ts", "index.ts", "main.ts"];
+  for (const conv of conventions) {
+    const convPath = (0, import_path6.join)(rootDir, conv);
+    if (await fileExists(convPath)) {
+      return Ok([convPath]);
+    }
+  }
+  return Err(
+    createEntropyError(
+      "ENTRY_POINT_NOT_FOUND",
+      "Could not resolve entry points",
+      { reason: "No package.json exports/main and no conventional entry files found" },
+      [
+        'Add "exports" or "main" to package.json',
+        "Create src/index.ts",
+        "Specify entryPoints in config"
+      ]
+    )
+  );
+}
+function extractCodeBlocks(content) {
+  const blocks = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.startsWith("```")) {
+      const langMatch = line.match(/```(\w*)/);
+      const language = langMatch?.[1] || "text";
+      let codeContent = "";
+      let j = i + 1;
+      let currentLine = lines[j];
+      while (j < lines.length && currentLine !== void 0 && !currentLine.startsWith("```")) {
+        codeContent += currentLine + "\n";
+        j++;
+        currentLine = lines[j];
+      }
+      blocks.push({
+        language,
+        content: codeContent.trim(),
+        line: i + 1
+      });
+      i = j;
+    }
+  }
+  return blocks;
+}
+function extractInlineRefs(content) {
+  const refs = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const regex = /`([^`]+)`/g;
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const reference = match[1];
+      if (reference === void 0) continue;
+      if (reference.match(/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*(\(.*\))?$/)) {
+        refs.push({
+          reference: reference.replace(/\(.*\)$/, ""),
+          // Remove function parens
+          line: i + 1,
+          column: match.index
+        });
+      }
+    }
+  }
+  return refs;
+}
+async function parseDocumentationFile(path2) {
+  const contentResult = await readFileContent(path2);
+  if (!contentResult.ok) {
+    return Err(
+      createEntropyError(
+        "PARSE_ERROR",
+        `Failed to read documentation file: ${path2}`,
+        { file: path2 },
+        ["Check that the file exists"]
+      )
+    );
+  }
+  const content = contentResult.value;
+  const type = path2.endsWith(".md") ? "markdown" : "text";
+  return Ok({
+    path: path2,
+    type,
+    content,
+    codeBlocks: extractCodeBlocks(content),
+    inlineRefs: extractInlineRefs(content)
+  });
+}
+function extractInternalSymbols(ast) {
+  const symbols = [];
+  const body = ast.body;
+  if (!body?.body) return symbols;
+  for (const node of body.body) {
+    if (node.type === "FunctionDeclaration" && node.id?.name) {
+      symbols.push({
+        name: node.id.name,
+        type: "function",
+        line: node.loc?.start?.line || 0,
+        references: 0,
+        calledBy: []
+      });
+    }
+    if (node.type === "VariableDeclaration") {
+      for (const decl of node.declarations || []) {
+        if (decl.id?.name) {
+          symbols.push({
+            name: decl.id.name,
+            type: "variable",
+            line: node.loc?.start?.line || 0,
+            references: 0,
+            calledBy: []
+          });
+        }
+      }
+    }
+    if (node.type === "ClassDeclaration" && node.id?.name) {
+      symbols.push({
+        name: node.id.name,
+        type: "class",
+        line: node.loc?.start?.line || 0,
+        references: 0,
+        calledBy: []
+      });
+    }
+  }
+  return symbols;
+}
+function extractJSDocComments(ast) {
+  const comments = [];
+  const body = ast.body;
+  if (body?.comments) {
+    for (const comment of body.comments) {
+      if (comment.type === "Block" && comment.value?.startsWith("*")) {
+        const jsDocComment = {
+          content: comment.value,
+          line: comment.loc?.start?.line || 0
+        };
+        comments.push(jsDocComment);
+      }
+    }
+  }
+  return comments;
+}
+function buildExportMap(files) {
+  const byFile = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byFile.set(file.path, file.exports);
+    for (const exp of file.exports) {
+      const existing = byName.get(exp.name) || [];
+      existing.push({ file: file.path, export: exp });
+      byName.set(exp.name, existing);
+    }
+  }
+  return { byFile, byName };
+}
+function extractAllCodeReferences(docs) {
+  const refs = [];
+  for (const doc of docs) {
+    for (const inlineRef of doc.inlineRefs) {
+      refs.push({
+        docFile: doc.path,
+        line: inlineRef.line,
+        column: inlineRef.column,
+        reference: inlineRef.reference,
+        context: "inline"
+      });
+    }
+    for (const block of doc.codeBlocks) {
+      if (block.language === "typescript" || block.language === "ts" || block.language === "javascript" || block.language === "js") {
+        const importRegex = /import\s+\{([^}]+)\}\s+from/g;
+        let match;
+        while ((match = importRegex.exec(block.content)) !== null) {
+          const matchedGroup = match[1];
+          if (matchedGroup === void 0) continue;
+          const names = matchedGroup.split(",").map((n) => n.trim());
+          for (const name of names) {
+            refs.push({
+              docFile: doc.path,
+              line: block.line,
+              column: 0,
+              reference: name,
+              context: "code-block"
+            });
+          }
+        }
+      }
+    }
+  }
+  return refs;
+}
+async function buildSnapshot(config) {
+  const startTime = Date.now();
+  const parser = config.parser || new TypeScriptParser();
+  const rootDir = (0, import_path6.resolve)(config.rootDir);
+  const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
+  if (!entryPointsResult.ok) {
+    return Err(entryPointsResult.error);
+  }
+  const includePatterns = config.include || ["**/*.ts", "**/*.tsx"];
+  const excludePatterns = config.exclude || [
+    "node_modules/**",
+    "dist/**",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ];
+  let sourceFilePaths = [];
+  for (const pattern of includePatterns) {
+    const files2 = await findFiles(pattern, rootDir);
+    sourceFilePaths.push(...files2);
+  }
+  sourceFilePaths = sourceFilePaths.filter((f) => {
+    const rel = (0, import_path6.relative)(rootDir, f);
+    return !excludePatterns.some((p) => (0, import_minimatch2.minimatch)(rel, p));
+  });
+  const files = [];
+  for (const filePath of sourceFilePaths) {
+    const parseResult = await parser.parseFile(filePath);
+    if (!parseResult.ok) continue;
+    const importsResult = parser.extractImports(parseResult.value);
+    const exportsResult = parser.extractExports(parseResult.value);
+    const internalSymbols = extractInternalSymbols(parseResult.value);
+    const jsDocComments = extractJSDocComments(parseResult.value);
+    files.push({
+      path: filePath,
+      ast: parseResult.value,
+      imports: importsResult.ok ? importsResult.value : [],
+      exports: exportsResult.ok ? exportsResult.value : [],
+      internalSymbols,
+      jsDocComments
+    });
+  }
+  const graphResult = await buildDependencyGraph(sourceFilePaths, parser);
+  const dependencyGraph = graphResult.ok ? graphResult.value : { nodes: [], edges: [] };
+  const docPatterns = config.docPaths || ["docs/**/*.md", "README.md", "**/README.md"];
+  let docFilePaths = [];
+  for (const pattern of docPatterns) {
+    const docFiles = await findFiles(pattern, rootDir);
+    docFilePaths.push(...docFiles);
+  }
+  docFilePaths = [...new Set(docFilePaths)];
+  const docs = [];
+  for (const docPath of docFilePaths) {
+    const docResult = await parseDocumentationFile(docPath);
+    if (docResult.ok) {
+      docs.push(docResult.value);
+    }
+  }
+  const exportMap = buildExportMap(files);
+  const codeReferences = extractAllCodeReferences(docs);
+  const buildTime = Date.now() - startTime;
+  return Ok({
+    files,
+    dependencyGraph,
+    exportMap,
+    docs,
+    codeReferences,
+    entryPoints: entryPointsResult.value,
+    rootDir,
+    config,
+    buildTime
+  });
+}
+
+// src/entropy/detectors/drift.ts
+var import_path7 = require("path");
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    const row = matrix[0];
+    if (row) {
+      row[j] = j;
+    }
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const row = matrix[i];
+      const prevRow = matrix[i - 1];
+      if (!row || !prevRow) continue;
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        row[j] = prevRow[j - 1] ?? 0;
+      } else {
+        row[j] = Math.min((prevRow[j - 1] ?? 0) + 1, (row[j - 1] ?? 0) + 1, (prevRow[j] ?? 0) + 1);
+      }
+    }
+  }
+  const lastRow = matrix[b.length];
+  return lastRow?.[a.length] ?? 0;
+}
+function findPossibleMatches(reference, exportNames, maxDistance = 5) {
+  const matches = [];
+  const refLower = reference.toLowerCase();
+  for (const name of exportNames) {
+    const nameLower = name.toLowerCase();
+    if (nameLower === refLower) {
+      matches.push({ name, score: 0 });
+      continue;
+    }
+    if (nameLower.includes(refLower) || refLower.includes(nameLower)) {
+      matches.push({ name, score: 1 });
+      continue;
+    }
+    const distance = levenshteinDistance(refLower, nameLower);
+    if (distance <= maxDistance) {
+      matches.push({ name, score: distance });
+    }
+  }
+  return matches.sort((a, b) => a.score - b.score).slice(0, 3).map((m) => m.name);
+}
+var DEFAULT_DRIFT_CONFIG = {
+  docPaths: [],
+  checkApiSignatures: true,
+  checkExamples: true,
+  checkStructure: true,
+  ignorePatterns: []
+};
+function checkApiSignatureDrift(snapshot, config) {
+  const drifts = [];
+  const exportNames = Array.from(snapshot.exportMap.byName.keys());
+  for (const ref of snapshot.codeReferences) {
+    if (config.ignorePatterns.some((p) => ref.reference.match(new RegExp(p)))) {
+      continue;
+    }
+    if (!snapshot.exportMap.byName.has(ref.reference)) {
+      const possibleMatches = findPossibleMatches(ref.reference, exportNames);
+      const confidence = possibleMatches.length > 0 ? "high" : "medium";
+      const drift = {
+        type: "api-signature",
+        docFile: ref.docFile,
+        line: ref.line,
+        reference: ref.reference,
+        context: ref.context,
+        issue: possibleMatches.length > 0 ? "RENAMED" : "NOT_FOUND",
+        details: possibleMatches.length > 0 ? `Symbol "${ref.reference}" not found. Similar: ${possibleMatches.join(", ")}` : `Symbol "${ref.reference}" not found in codebase`,
+        suggestion: possibleMatches.length > 0 ? `Did you mean "${possibleMatches[0]}"?` : "Remove reference or add the missing export",
+        confidence
+      };
+      if (possibleMatches.length > 0) {
+        drift.possibleMatches = possibleMatches;
+      }
+      drifts.push(drift);
+    }
+  }
+  return drifts;
+}
+function extractFileLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const linkRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = linkRegex.exec(line)) !== null) {
+      const linkPath = match[2];
+      if (linkPath && !linkPath.startsWith("http") && !linkPath.startsWith("#") && (linkPath.includes(".") || linkPath.startsWith(".."))) {
+        links.push({ link: linkPath, line: i + 1 });
+      }
+    }
+  }
+  return links;
+}
+async function checkStructureDrift(snapshot, _config) {
+  const drifts = [];
+  for (const doc of snapshot.docs) {
+    const fileLinks = extractFileLinks(doc.content);
+    for (const { link, line } of fileLinks) {
+      const resolvedPath = (0, import_path7.resolve)((0, import_path7.dirname)(doc.path), link);
+      const exists = await fileExists(resolvedPath);
+      if (!exists) {
+        drifts.push({
+          type: "structure",
+          docFile: doc.path,
+          line,
+          reference: link,
+          context: "link",
+          issue: "NOT_FOUND",
+          details: `File "${link}" referenced in documentation does not exist`,
+          suggestion: "Update the link or remove the reference",
+          confidence: "high"
+        });
+      }
+    }
+  }
+  return drifts;
+}
+async function detectDocDrift(snapshot, config) {
+  const fullConfig = { ...DEFAULT_DRIFT_CONFIG, ...config };
+  const drifts = [];
+  if (fullConfig.checkApiSignatures) {
+    drifts.push(...checkApiSignatureDrift(snapshot, fullConfig));
+  }
+  if (fullConfig.checkStructure) {
+    drifts.push(...await checkStructureDrift(snapshot, fullConfig));
+  }
+  const apiDrifts = drifts.filter((d) => d.type === "api-signature").length;
+  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({
+    drifts,
+    stats: {
+      docsScanned: snapshot.docs.length,
+      referencesChecked: snapshot.codeReferences.length,
+      driftsFound: drifts.length,
+      byType: { api: apiDrifts, example: exampleDrifts, structure: structureDrifts }
+    },
+    severity
+  });
+}
+
+// src/entropy/detectors/dead-code.ts
+var import_path8 = require("path");
+function resolveImportToFile(importSource, fromFile, snapshot) {
+  if (!importSource.startsWith(".")) {
+    return null;
+  }
+  const fromDir = (0, import_path8.dirname)(fromFile);
+  let resolved = (0, import_path8.resolve)(fromDir, importSource);
+  if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+    const withTs = resolved + ".ts";
+    if (snapshot.files.some((f) => f.path === withTs)) {
+      return withTs;
+    }
+    const withIndex = (0, import_path8.resolve)(resolved, "index.ts");
+    if (snapshot.files.some((f) => f.path === withIndex)) {
+      return withIndex;
+    }
+  }
+  if (snapshot.files.some((f) => f.path === resolved)) {
+    return resolved;
+  }
+  return null;
+}
+function buildReachabilityMap(snapshot) {
+  const reachability = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    reachability.set(file.path, false);
+  }
+  const queue = [...snapshot.entryPoints];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    reachability.set(current, true);
+    const sourceFile = snapshot.files.find((f) => f.path === current);
+    if (!sourceFile) continue;
+    for (const imp of sourceFile.imports) {
+      const resolved = resolveImportToFile(imp.source, current, snapshot);
+      if (resolved && !visited.has(resolved)) {
+        queue.push(resolved);
+      }
+    }
+    for (const exp of sourceFile.exports) {
+      if (exp.isReExport && exp.source) {
+        const resolved = resolveImportToFile(exp.source, current, snapshot);
+        if (resolved && !visited.has(resolved)) {
+          queue.push(resolved);
+        }
+      }
+    }
+  }
+  return reachability;
+}
+function buildExportUsageMap(snapshot) {
+  const usageMap = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    for (const exp of file.exports) {
+      const key = `${file.path}:${exp.name}`;
+      usageMap.set(key, { importers: [], isReExported: exp.isReExport });
+    }
+  }
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const resolvedFile = resolveImportToFile(imp.source, file.path, snapshot);
+      if (!resolvedFile) continue;
+      const sourceFile = snapshot.files.find((f) => f.path === resolvedFile);
+      if (!sourceFile) continue;
+      for (const specifier of imp.specifiers) {
+        const matchingExport = sourceFile.exports.find(
+          (e) => e.name === specifier || specifier === "default" && e.type === "default"
+        );
+        if (matchingExport) {
+          const key = `${resolvedFile}:${matchingExport.name}`;
+          const usage = usageMap.get(key);
+          if (usage) {
+            usage.importers.push(file.path);
+          }
+        }
+      }
+    }
+  }
+  return usageMap;
+}
+function findDeadExports(snapshot, usageMap, reachability) {
+  const deadExports = [];
+  for (const file of snapshot.files) {
+    if (snapshot.entryPoints.includes(file.path)) continue;
+    for (const exp of file.exports) {
+      if (exp.isReExport) continue;
+      const key = `${file.path}:${exp.name}`;
+      const usage = usageMap.get(key);
+      if (!usage || usage.importers.length === 0) {
+        deadExports.push({
+          file: file.path,
+          name: exp.name,
+          line: exp.location.line,
+          type: "variable",
+          // Default type since Export doesn't track declaration kind
+          isDefault: exp.type === "default",
+          reason: "NO_IMPORTERS"
+        });
+      } else {
+        const allImportersDead = usage.importers.every((importer) => !reachability.get(importer));
+        if (allImportersDead) {
+          deadExports.push({
+            file: file.path,
+            name: exp.name,
+            line: exp.location.line,
+            type: "variable",
+            // Default type since Export doesn't track declaration kind
+            isDefault: exp.type === "default",
+            reason: "IMPORTERS_ALSO_DEAD"
+          });
+        }
+      }
+    }
+  }
+  return deadExports;
+}
+function countLinesFromAST(ast) {
+  if (ast.body && Array.isArray(ast.body)) {
+    let maxLine = 0;
+    const traverse = (node) => {
+      if (node && typeof node === "object") {
+        const n = node;
+        if (n.loc?.end?.line && n.loc.end.line > maxLine) {
+          maxLine = n.loc.end.line;
+        }
+        for (const key of Object.keys(node)) {
+          const value = node[key];
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              traverse(item);
+            }
+          } else if (value && typeof value === "object") {
+            traverse(value);
+          }
+        }
+      }
+    };
+    traverse(ast);
+    if (maxLine > 0) return maxLine;
+    return Math.max(ast.body.length * 3, 1);
+  }
+  return 1;
+}
+function findDeadFiles(snapshot, reachability) {
+  const deadFiles = [];
+  for (const file of snapshot.files) {
+    const isReachable = reachability.get(file.path) ?? false;
+    if (!isReachable) {
+      deadFiles.push({
+        path: file.path,
+        reason: "NO_IMPORTERS",
+        exportCount: file.exports.filter((e) => !e.isReExport).length,
+        lineCount: countLinesFromAST(file.ast)
+      });
+    }
+  }
+  return deadFiles;
+}
+function isIdentifierUsedInAST(ast, identifier, skipImportDeclaration = true) {
+  const astString = JSON.stringify(ast);
+  const identifierPattern = new RegExp(`"name"\\s*:\\s*"${identifier}"`, "g");
+  const matches = astString.match(identifierPattern);
+  if (!matches) return false;
+  if (skipImportDeclaration) {
+    return matches.length > 2;
+  }
+  return matches.length > 0;
+}
+function findUnusedImports(snapshot) {
+  const unusedImports = [];
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const unusedSpecifiers = [];
+      for (const specifier of imp.specifiers) {
+        if (!isIdentifierUsedInAST(file.ast, specifier, true)) {
+          unusedSpecifiers.push(specifier);
+        }
+      }
+      if (unusedSpecifiers.length > 0) {
+        unusedImports.push({
+          file: file.path,
+          line: imp.location.line,
+          source: imp.source,
+          specifiers: unusedSpecifiers,
+          isFullyUnused: unusedSpecifiers.length === imp.specifiers.length
+        });
+      }
+    }
+  }
+  return unusedImports;
+}
+function findDeadInternals(snapshot, _reachability) {
+  const deadInternals = [];
+  for (const file of snapshot.files) {
+    for (const symbol of file.internalSymbols) {
+      if (symbol.type === "type") continue;
+      if (symbol.references === 0 && symbol.calledBy.length === 0) {
+        deadInternals.push({
+          file: file.path,
+          name: symbol.name,
+          line: symbol.line,
+          type: symbol.type,
+          reason: "NEVER_CALLED"
+        });
+      }
+    }
+  }
+  return deadInternals;
+}
+async function detectDeadCode(snapshot) {
+  const reachability = buildReachabilityMap(snapshot);
+  const usageMap = buildExportUsageMap(snapshot);
+  const deadExports = findDeadExports(snapshot, usageMap, reachability);
+  const deadFiles = findDeadFiles(snapshot, reachability);
+  const unusedImports = findUnusedImports(snapshot);
+  const deadInternals = findDeadInternals(snapshot, reachability);
+  const totalExports = snapshot.files.reduce(
+    (acc, file) => acc + file.exports.filter((e) => !e.isReExport).length,
+    0
+  );
+  const estimatedDeadLines = deadFiles.reduce((acc, file) => acc + file.lineCount, 0);
+  const report = {
+    deadExports,
+    deadFiles,
+    deadInternals,
+    unusedImports,
+    stats: {
+      filesAnalyzed: snapshot.files.length,
+      entryPointsUsed: snapshot.entryPoints,
+      totalExports,
+      deadExportCount: deadExports.length,
+      totalFiles: snapshot.files.length,
+      deadFileCount: deadFiles.length,
+      estimatedDeadLines
+    }
+  };
+  return Ok(report);
+}
+
+// src/entropy/detectors/patterns.ts
+var import_minimatch3 = require("minimatch");
+var import_path9 = require("path");
+function fileMatchesPattern(filePath, pattern, rootDir) {
+  const relativePath = (0, import_path9.relative)(rootDir, filePath);
+  return (0, import_minimatch3.minimatch)(relativePath, pattern);
+}
+function checkConfigPattern(pattern, file, rootDir) {
+  const matches = [];
+  const fileMatches = pattern.files.some((glob2) => fileMatchesPattern(file.path, glob2, rootDir));
+  if (!fileMatches) {
+    return matches;
+  }
+  const rule = pattern.rule;
+  switch (rule.type) {
+    case "must-export": {
+      for (const name of rule.names) {
+        const hasExport = file.exports.some((e) => e.name === name);
+        if (!hasExport) {
+          matches.push({
+            line: 1,
+            message: pattern.message || `Missing required export: "${name}"`,
+            suggestion: `Add export for "${name}"`
+          });
+        }
+      }
+      break;
+    }
+    case "must-export-default": {
+      const hasDefault = file.exports.some((e) => e.type === "default");
+      if (!hasDefault) {
+        matches.push({
+          line: 1,
+          message: pattern.message || "File must have a default export",
+          suggestion: "Add a default export"
+        });
+      }
+      break;
+    }
+    case "no-export": {
+      for (const name of rule.names) {
+        const exp = file.exports.find((e) => e.name === name);
+        if (exp) {
+          matches.push({
+            line: exp.location.line,
+            message: pattern.message || `Forbidden export: "${name}"`,
+            suggestion: `Remove export "${name}"`
+          });
+        }
+      }
+      break;
+    }
+    case "must-import": {
+      const hasImport = file.imports.some(
+        (i) => i.source === rule.from || i.source.endsWith(rule.from)
+      );
+      if (!hasImport) {
+        matches.push({
+          line: 1,
+          message: pattern.message || `Missing required import from "${rule.from}"`,
+          suggestion: `Add import from "${rule.from}"`
+        });
+      }
+      break;
+    }
+    case "no-import": {
+      const forbiddenImport = file.imports.find(
+        (i) => i.source === rule.from || i.source.endsWith(rule.from)
+      );
+      if (forbiddenImport) {
+        matches.push({
+          line: forbiddenImport.location.line,
+          message: pattern.message || `Forbidden import from "${rule.from}"`,
+          suggestion: `Remove import from "${rule.from}"`
+        });
+      }
+      break;
+    }
+    case "naming": {
+      const regex = new RegExp(rule.match);
+      for (const exp of file.exports) {
+        if (!regex.test(exp.name)) {
+          let expected = "";
+          switch (rule.convention) {
+            case "camelCase":
+              expected = "camelCase (e.g., myFunction)";
+              break;
+            case "PascalCase":
+              expected = "PascalCase (e.g., MyClass)";
+              break;
+            case "UPPER_SNAKE":
+              expected = "UPPER_SNAKE_CASE (e.g., MY_CONSTANT)";
+              break;
+            case "kebab-case":
+              expected = "kebab-case (e.g., my-component)";
+              break;
+          }
+          matches.push({
+            line: exp.location.line,
+            message: pattern.message || `"${exp.name}" does not follow ${rule.convention} convention`,
+            suggestion: `Rename to follow ${expected}`
+          });
+        }
+      }
+      break;
+    }
+    case "max-exports": {
+      if (file.exports.length > rule.count) {
+        matches.push({
+          line: 1,
+          message: pattern.message || `File has ${file.exports.length} exports, max is ${rule.count}`,
+          suggestion: `Split into multiple files or reduce exports to ${rule.count}`
+        });
+      }
+      break;
+    }
+    case "max-lines": {
+      break;
+    }
+    case "require-jsdoc": {
+      if (file.jsDocComments.length === 0 && file.exports.length > 0) {
+        matches.push({
+          line: 1,
+          message: pattern.message || "Exported symbols require JSDoc documentation",
+          suggestion: "Add JSDoc comments to exports"
+        });
+      }
+      break;
+    }
+  }
+  return matches;
+}
+async function detectPatternViolations(snapshot, config) {
+  const violations = [];
+  const patterns = config?.patterns || [];
+  for (const file of snapshot.files) {
+    for (const pattern of patterns) {
+      const matches = checkConfigPattern(pattern, file, snapshot.rootDir);
+      for (const match of matches) {
+        violations.push({
+          pattern: pattern.name,
+          file: file.path,
+          line: match.line,
+          message: match.message,
+          suggestion: match.suggestion || "Review and fix this pattern violation",
+          severity: pattern.severity
+        });
+      }
+    }
+  }
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  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({
+    violations,
+    stats: {
+      filesChecked: snapshot.files.length,
+      patternsApplied: patterns.length,
+      violationCount: violations.length,
+      errorCount,
+      warningCount
+    },
+    passRate
+  });
+}
+
+// src/entropy/fixers/suggestions.ts
+function generateDeadCodeSuggestions(report) {
+  const suggestions = [];
+  for (const file of report.deadFiles) {
+    suggestions.push({
+      type: "delete",
+      priority: "high",
+      source: "dead-code",
+      relatedIssues: [`dead-file:${file.path}`],
+      title: `Remove dead file: ${file.path.split("/").pop()}`,
+      description: `This file is not imported by any other file and can be safely removed.`,
+      files: [file.path],
+      steps: [`Delete ${file.path}`, "Run tests to verify no regressions"],
+      whyManual: "File deletion requires verification that no dynamic imports exist"
+    });
+  }
+  for (const exp of report.deadExports) {
+    suggestions.push({
+      type: "refactor",
+      priority: "medium",
+      source: "dead-code",
+      relatedIssues: [`dead-export:${exp.file}:${exp.name}`],
+      title: `Remove unused export: ${exp.name}`,
+      description: `The export "${exp.name}" is not used anywhere. Consider removing it.`,
+      files: [exp.file],
+      steps: [`Remove export "${exp.name}" from ${exp.file}`, "Run tests to verify no regressions"],
+      whyManual: "Export removal may affect external consumers not in scope"
+    });
+  }
+  for (const imp of report.unusedImports) {
+    suggestions.push({
+      type: "delete",
+      priority: "medium",
+      source: "dead-code",
+      relatedIssues: [`unused-import:${imp.file}:${imp.specifiers.join(",")}`],
+      title: `Remove unused import${imp.specifiers.length > 1 ? "s" : ""}: ${imp.specifiers.join(", ")}`,
+      description: `The import${imp.specifiers.length > 1 ? "s" : ""} from "${imp.source}" ${imp.specifiers.length > 1 ? "are" : "is"} not used.`,
+      files: [imp.file],
+      steps: imp.isFullyUnused ? [`Remove entire import line from ${imp.file}`] : [`Remove unused specifiers (${imp.specifiers.join(", ")}) from import statement`],
+      whyManual: "Import removal can be auto-fixed"
+    });
+  }
+  return suggestions;
+}
+function generateDriftSuggestions(report) {
+  const suggestions = [];
+  for (const drift of report.drifts) {
+    const priority = drift.confidence === "high" ? "high" : "medium";
+    suggestions.push({
+      type: "update-docs",
+      priority,
+      source: "drift",
+      relatedIssues: [`drift:${drift.docFile}:${drift.reference}`],
+      title: `Fix documentation drift: ${drift.reference}`,
+      description: drift.details,
+      files: [drift.docFile],
+      steps: [
+        drift.suggestion || "Review and update documentation",
+        "Review documentation for accuracy"
+      ],
+      whyManual: "Documentation updates require human judgment for accuracy"
+    });
+  }
+  return suggestions;
+}
+function generatePatternSuggestions(report) {
+  const suggestions = [];
+  for (const violation of report.violations) {
+    suggestions.push({
+      type: "refactor",
+      priority: violation.severity === "error" ? "high" : "low",
+      source: "pattern",
+      relatedIssues: [`pattern:${violation.pattern}:${violation.file}`],
+      title: `Fix pattern violation: ${violation.pattern}`,
+      description: violation.message,
+      files: [violation.file],
+      steps: [violation.suggestion || "Follow pattern guidelines"],
+      whyManual: "Pattern violations often require architectural decisions"
+    });
+  }
+  return suggestions;
+}
+function generateSuggestions(deadCode, drift, patterns) {
+  const suggestions = [];
+  if (deadCode) {
+    suggestions.push(...generateDeadCodeSuggestions(deadCode));
+  }
+  if (drift) {
+    suggestions.push(...generateDriftSuggestions(drift));
+  }
+  if (patterns) {
+    suggestions.push(...generatePatternSuggestions(patterns));
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  suggestions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  const byPriority = {
+    high: suggestions.filter((s) => s.priority === "high"),
+    medium: suggestions.filter((s) => s.priority === "medium"),
+    low: suggestions.filter((s) => s.priority === "low")
+  };
+  let estimatedEffort;
+  if (suggestions.length === 0) {
+    estimatedEffort = "trivial";
+  } else if (suggestions.length <= 5) {
+    estimatedEffort = "small";
+  } else if (suggestions.length <= 20) {
+    estimatedEffort = "medium";
+  } else {
+    estimatedEffort = "large";
+  }
+  return {
+    suggestions,
+    byPriority,
+    estimatedEffort
+  };
+}
+
+// src/entropy/analyzer.ts
+var EntropyAnalyzer = class {
+  config;
+  snapshot;
+  report;
+  constructor(config) {
+    this.config = {
+      ...config,
+      parser: config.parser || new TypeScriptParser()
+    };
+  }
+  /**
+   * Run full entropy analysis
+   */
+  async analyze() {
+    const startTime = Date.now();
+    const snapshotResult = await buildSnapshot(this.config);
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    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);
+      if (result.ok) {
+        driftReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "drift", error: result.error });
+      }
+    }
+    if (this.config.analyze.deadCode) {
+      const result = await detectDeadCode(this.snapshot);
+      if (result.ok) {
+        deadCodeReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "deadCode", error: result.error });
+      }
+    }
+    if (this.config.analyze.patterns) {
+      const patternConfig = typeof this.config.analyze.patterns === "object" ? this.config.analyze.patterns : { patterns: [] };
+      const result = await detectPatternViolations(this.snapshot, patternConfig);
+      if (result.ok) {
+        patternReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "patterns", error: result.error });
+      }
+    }
+    const driftIssues = driftReport?.drifts.length || 0;
+    const deadCodeIssues = (deadCodeReport?.deadExports.length || 0) + (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+    const patternIssues = patternReport?.violations.length || 0;
+    const patternErrors = patternReport?.stats.errorCount || 0;
+    const patternWarnings = patternReport?.stats.warningCount || 0;
+    const totalIssues = driftIssues + deadCodeIssues + patternIssues;
+    const fixableCount = (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+    const suggestions = generateSuggestions(deadCodeReport, driftReport, patternReport);
+    const duration = Date.now() - startTime;
+    const report = {
+      snapshot: this.snapshot,
+      analysisErrors,
+      summary: {
+        totalIssues,
+        errors: patternErrors,
+        warnings: patternWarnings + driftIssues,
+        fixableCount,
+        suggestionCount: suggestions.suggestions.length
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration
+    };
+    if (driftReport) {
+      report.drift = driftReport;
+    }
+    if (deadCodeReport) {
+      report.deadCode = deadCodeReport;
+    }
+    if (patternReport) {
+      report.patterns = patternReport;
+    }
+    this.report = report;
+    return Ok(report);
+  }
+  /**
+   * Get the built snapshot (must call analyze first)
+   */
+  getSnapshot() {
+    return this.snapshot;
+  }
+  /**
+   * Get the last report (must call analyze first)
+   */
+  getReport() {
+    return this.report;
+  }
+  /**
+   * Generate suggestions from the last analysis
+   */
+  getSuggestions() {
+    if (!this.report) {
+      return {
+        suggestions: [],
+        byPriority: { high: [], medium: [], low: [] },
+        estimatedEffort: "trivial"
+      };
+    }
+    return generateSuggestions(this.report.deadCode, this.report.drift, this.report.patterns);
+  }
+  /**
+   * Build snapshot without running analysis
+   */
+  async buildSnapshot() {
+    const result = await buildSnapshot(this.config);
+    if (result.ok) {
+      this.snapshot = result.value;
+    }
+    return result;
+  }
+  /**
+   * Ensure snapshot is built, returning the snapshot or an error
+   */
+  async ensureSnapshot() {
+    if (this.snapshot) {
+      return Ok(this.snapshot);
+    }
+    return this.buildSnapshot();
+  }
+  /**
+   * Run drift detection only (snapshot must be built first)
+   */
+  async detectDrift(config) {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectDocDrift(snapshotResult.value, config || {});
+  }
+  /**
+   * Run dead code detection only (snapshot must be built first)
+   */
+  async detectDeadCode() {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectDeadCode(snapshotResult.value);
+  }
+  /**
+   * Run pattern detection only (snapshot must be built first)
+   */
+  async detectPatterns(config) {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectPatternViolations(snapshotResult.value, config);
+  }
+};
+
+// src/entropy/fixers/safe-fixes.ts
+var fs = __toESM(require("fs"));
+var import_util2 = require("util");
+var import_path10 = require("path");
+var readFile3 = (0, import_util2.promisify)(fs.readFile);
+var writeFile2 = (0, import_util2.promisify)(fs.writeFile);
+var unlink2 = (0, import_util2.promisify)(fs.unlink);
+var mkdir2 = (0, import_util2.promisify)(fs.mkdir);
+var copyFile2 = (0, import_util2.promisify)(fs.copyFile);
+var DEFAULT_FIX_CONFIG = {
+  dryRun: false,
+  fixTypes: ["unused-imports", "dead-files"],
+  createBackup: true,
+  backupDir: ".entropy-backups"
+};
+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)}`,
+    action: "delete-file",
+    safe: true,
+    reversible: true
+  }));
+}
+function createUnusedImportFixes(deadCodeReport) {
+  return deadCodeReport.unusedImports.map((imp) => ({
+    type: "unused-imports",
+    file: imp.file,
+    description: `Remove unused import: ${imp.specifiers.join(", ")} from ${imp.source}`,
+    action: "delete-lines",
+    line: imp.line,
+    safe: true,
+    reversible: true
+  }));
+}
+function createFixes(deadCodeReport, config) {
+  const fullConfig = { ...DEFAULT_FIX_CONFIG, ...config };
+  const fixes = [];
+  if (fullConfig.fixTypes.includes("dead-files")) {
+    fixes.push(...createDeadFileFixes(deadCodeReport));
+  }
+  if (fullConfig.fixTypes.includes("unused-imports")) {
+    fixes.push(...createUnusedImportFixes(deadCodeReport));
+  }
+  return fixes;
+}
+function previewFix(fix) {
+  switch (fix.action) {
+    case "delete-file":
+      return `Would delete file: ${fix.file}`;
+    case "delete-lines":
+      return `Would delete line ${fix.line} in ${fix.file}: ${fix.description}`;
+    case "replace":
+      return `Would replace in ${fix.file}:
+  - ${fix.oldContent}
+  + ${fix.newContent}`;
+    case "insert":
+      return `Would insert at line ${fix.line} in ${fix.file}:
+  + ${fix.newContent}`;
+    default:
+      return `Would apply fix: ${fix.description}`;
+  }
+}
+async function createBackup(filePath, backupDir) {
+  const backupPath = (0, import_path10.join)(backupDir, `${Date.now()}-${(0, import_path10.basename)(filePath)}`);
+  try {
+    await mkdir2((0, import_path10.dirname)(backupPath), { recursive: true });
+    await copyFile2(filePath, backupPath);
+    return Ok(backupPath);
+  } catch (e) {
+    return Err(
+      createEntropyError(
+        "BACKUP_FAILED",
+        `Failed to create backup: ${filePath}`,
+        { file: filePath, originalError: e },
+        ["Check file permissions", "Ensure backup directory is writable"]
+      )
+    );
+  }
+}
+async function applySingleFix(fix, config) {
+  if (config.dryRun) {
+    return Ok(fix);
+  }
+  try {
+    switch (fix.action) {
+      case "delete-file":
+        if (config.createBackup && config.backupDir) {
+          const backupResult = await createBackup(fix.file, config.backupDir);
+          if (!backupResult.ok) {
+            return Err({ fix, error: backupResult.error.message });
+          }
+        }
+        await unlink2(fix.file);
+        break;
+      case "delete-lines":
+        if (fix.line !== void 0) {
+          const content = await readFile3(fix.file, "utf-8");
+          const lines = content.split("\n");
+          lines.splice(fix.line - 1, 1);
+          await writeFile2(fix.file, lines.join("\n"));
+        }
+        break;
+      case "replace":
+        if (fix.oldContent && fix.newContent !== void 0) {
+          const content = await readFile3(fix.file, "utf-8");
+          const newContent = content.replace(fix.oldContent, fix.newContent);
+          await writeFile2(fix.file, newContent);
+        }
+        break;
+      case "insert":
+        if (fix.line !== void 0 && fix.newContent) {
+          const content = await readFile3(fix.file, "utf-8");
+          const lines = content.split("\n");
+          lines.splice(fix.line - 1, 0, fix.newContent);
+          await writeFile2(fix.file, lines.join("\n"));
+        }
+        break;
+    }
+    return Ok(fix);
+  } catch (e) {
+    return Err({ fix, error: e.message });
+  }
+}
+async function applyFixes(fixes, config) {
+  const fullConfig = { ...DEFAULT_FIX_CONFIG, ...config };
+  const applied = [];
+  const skipped = [];
+  const errors = [];
+  let filesModified = 0;
+  let filesDeleted = 0;
+  let linesRemoved = 0;
+  for (const fix of fixes) {
+    if (!fullConfig.fixTypes.includes(fix.type)) {
+      skipped.push(fix);
+      continue;
+    }
+    const result = await applySingleFix(fix, fullConfig);
+    if (result.ok) {
+      applied.push(result.value);
+      if (fix.action === "delete-file") {
+        filesDeleted++;
+      } else {
+        filesModified++;
+      }
+      if (fix.action === "delete-lines") {
+        linesRemoved++;
+      }
+    } else {
+      errors.push(result.error);
+    }
+  }
+  return Ok({
+    applied,
+    skipped,
+    errors,
+    stats: {
+      filesModified,
+      filesDeleted,
+      linesRemoved
+    }
+  });
+}
+
+// src/entropy/config/schema.ts
+var import_zod = require("zod");
+var MustExportRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("must-export"),
+  names: import_zod.z.array(import_zod.z.string())
+});
+var MustExportDefaultRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("must-export-default"),
+  kind: import_zod.z.enum(["class", "function", "object"]).optional()
+});
+var NoExportRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("no-export"),
+  names: import_zod.z.array(import_zod.z.string())
+});
+var MustImportRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("must-import"),
+  from: import_zod.z.string(),
+  names: import_zod.z.array(import_zod.z.string()).optional()
+});
+var NoImportRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("no-import"),
+  from: import_zod.z.string()
+});
+var NamingRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("naming"),
+  match: import_zod.z.string(),
+  convention: import_zod.z.enum(["camelCase", "PascalCase", "UPPER_SNAKE", "kebab-case"])
+});
+var MaxExportsRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("max-exports"),
+  count: import_zod.z.number().positive()
+});
+var MaxLinesRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("max-lines"),
+  count: import_zod.z.number().positive()
+});
+var RequireJSDocRuleSchema = import_zod.z.object({
+  type: import_zod.z.literal("require-jsdoc"),
+  for: import_zod.z.array(import_zod.z.enum(["function", "class", "export"]))
+});
+var RuleSchema = import_zod.z.discriminatedUnion("type", [
+  MustExportRuleSchema,
+  MustExportDefaultRuleSchema,
+  NoExportRuleSchema,
+  MustImportRuleSchema,
+  NoImportRuleSchema,
+  NamingRuleSchema,
+  MaxExportsRuleSchema,
+  MaxLinesRuleSchema,
+  RequireJSDocRuleSchema
+]);
+var ConfigPatternSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1),
+  description: import_zod.z.string(),
+  severity: import_zod.z.enum(["error", "warning"]),
+  files: import_zod.z.array(import_zod.z.string()),
+  rule: RuleSchema,
+  message: import_zod.z.string().optional()
+});
+var PatternConfigSchema = import_zod.z.object({
+  patterns: import_zod.z.array(ConfigPatternSchema),
+  customPatterns: import_zod.z.array(import_zod.z.any()).optional(),
+  // Code patterns are functions, can't validate
+  ignoreFiles: import_zod.z.array(import_zod.z.string()).optional()
+});
+var DriftConfigSchema = import_zod.z.object({
+  docPaths: import_zod.z.array(import_zod.z.string()).optional(),
+  checkApiSignatures: import_zod.z.boolean().optional(),
+  checkExamples: import_zod.z.boolean().optional(),
+  checkStructure: import_zod.z.boolean().optional(),
+  ignorePatterns: import_zod.z.array(import_zod.z.string()).optional()
+});
+var DeadCodeConfigSchema = import_zod.z.object({
+  entryPoints: import_zod.z.array(import_zod.z.string()).optional(),
+  includeTypes: import_zod.z.boolean().optional(),
+  includeInternals: import_zod.z.boolean().optional(),
+  ignorePatterns: import_zod.z.array(import_zod.z.string()).optional(),
+  treatDynamicImportsAs: import_zod.z.enum(["used", "unknown"]).optional()
+});
+var EntropyConfigSchema = import_zod.z.object({
+  rootDir: import_zod.z.string(),
+  parser: import_zod.z.any().optional(),
+  // LanguageParser instance, can't validate
+  entryPoints: import_zod.z.array(import_zod.z.string()).optional(),
+  analyze: import_zod.z.object({
+    drift: import_zod.z.union([import_zod.z.boolean(), DriftConfigSchema]).optional(),
+    deadCode: import_zod.z.union([import_zod.z.boolean(), DeadCodeConfigSchema]).optional(),
+    patterns: import_zod.z.union([import_zod.z.boolean(), PatternConfigSchema]).optional()
+  }),
+  include: import_zod.z.array(import_zod.z.string()).optional(),
+  exclude: import_zod.z.array(import_zod.z.string()).optional(),
+  docPaths: import_zod.z.array(import_zod.z.string()).optional()
+});
+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(
+      createEntropyError(
+        "CONFIG_VALIDATION_ERROR",
+        `Invalid pattern config: ${issues}`,
+        { issues: result.error.issues },
+        ["Check the pattern config matches the schema"]
+      )
+    );
+  }
+  return 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" });
+  }
+  async getMetrics() {
+    return Ok([]);
+  }
+  async getTraces() {
+    return Ok([]);
+  }
+  async getLogs() {
+    return Ok([]);
+  }
+};
+
+// src/shared/uuid.ts
+function generateId() {
+  if (typeof globalThis !== "undefined" && "crypto" in globalThis && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/feedback/executor/noop.ts
+var NoOpExecutor = class {
+  name = "noop";
+  processes = /* @__PURE__ */ new Map();
+  async health() {
+    return Ok({ available: true, message: "NoOp executor - no real agent spawning" });
+  }
+  async spawn(config) {
+    const id = generateId();
+    const process2 = {
+      id,
+      status: "completed",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      config
+    };
+    this.processes.set(id, process2);
+    return Ok(process2);
+  }
+  async status(processId) {
+    const process2 = this.processes.get(processId);
+    if (!process2) {
+      return Err({
+        code: "AGENT_SPAWN_ERROR",
+        message: "Process not found",
+        details: { agentId: processId },
+        suggestions: ["Check if the process ID is correct"]
+      });
+    }
+    return Ok(process2);
+  }
+  async wait(processId) {
+    const process2 = this.processes.get(processId);
+    if (!process2) {
+      return Err({
+        code: "AGENT_SPAWN_ERROR",
+        message: "Process not found",
+        details: { agentId: processId },
+        suggestions: ["Check if the process ID is correct"]
+      });
+    }
+    return Ok({
+      agentId: processId,
+      agentType: process2.config.type,
+      approved: true,
+      comments: [],
+      suggestions: [],
+      duration: 0,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async kill(processId) {
+    this.processes.delete(processId);
+    return Ok(void 0);
+  }
+};
+
+// src/feedback/logging/console-sink.ts
+var ConsoleSink = class {
+  name = "console";
+  options;
+  constructor(options = {}) {
+    this.options = {
+      level: options.level ?? "info",
+      format: options.format ?? "pretty",
+      verbose: options.verbose ?? false
+    };
+  }
+  async write(action) {
+    const output = this.options.format === "json" ? JSON.stringify(action) : this.formatPretty(action);
+    console.log(output);
+    return Ok(void 0);
+  }
+  formatPretty(action) {
+    const status = action.status === "completed" ? "\u2713" : action.status === "failed" ? "\u2717" : "\u2192";
+    const duration = action.duration ? ` (${action.duration}ms)` : "";
+    return `[${status}] ${action.type}${duration}: ${action.result?.summary ?? action.status}`;
+  }
+};
+
+// src/feedback/config.ts
+function getDefaults() {
+  return {
+    telemetry: new NoOpTelemetryAdapter(),
+    executor: new NoOpExecutor(),
+    sinks: [new ConsoleSink()],
+    emitEvents: true,
+    defaultTimeout: 3e5,
+    rootDir: process.cwd()
+  };
+}
+var feedbackConfig = null;
+function ensureConfig() {
+  if (!feedbackConfig) {
+    feedbackConfig = getDefaults();
+  }
+  return feedbackConfig;
+}
+function configureFeedback(config) {
+  feedbackConfig = { ...ensureConfig(), ...config };
+}
+function getFeedbackConfig() {
+  return Object.freeze({ ...ensureConfig() });
+}
+function resetFeedbackConfig() {
+  feedbackConfig = null;
+}
+
+// src/feedback/review/diff-analyzer.ts
+function parseDiff(diff) {
+  try {
+    if (!diff.trim()) {
+      return Ok({ diff, files: [] });
+    }
+    const files = [];
+    const newFileRegex = /new file mode/;
+    const deletedFileRegex = /deleted file mode/;
+    const additionRegex = /^\+(?!\+\+)/gm;
+    const deletionRegex = /^-(?!--)/gm;
+    const diffParts = diff.split(/(?=diff --git)/);
+    for (const part of diffParts) {
+      if (!part.trim()) continue;
+      const headerMatch = /diff --git a\/(.+?) b\/(.+?)(?:\n|$)/.exec(part);
+      if (!headerMatch || !headerMatch[2]) continue;
+      const filePath = headerMatch[2];
+      let status = "modified";
+      if (newFileRegex.test(part)) {
+        status = "added";
+      } else if (deletedFileRegex.test(part)) {
+        status = "deleted";
+      } else if (part.includes("rename from")) {
+        status = "renamed";
+      }
+      const additions = (part.match(additionRegex) || []).length;
+      const deletions = (part.match(deletionRegex) || []).length;
+      files.push({
+        path: filePath,
+        status,
+        additions,
+        deletions
+      });
+    }
+    return Ok({ diff, files });
+  } catch (error) {
+    return Err({
+      code: "DIFF_PARSE_ERROR",
+      message: "Failed to parse git diff",
+      details: { reason: String(error) },
+      suggestions: ["Ensure diff is in valid git diff format"]
+    });
+  }
+}
+async function analyzeDiff(changes, options) {
+  if (!options?.enabled) {
+    return Ok([]);
+  }
+  const items = [];
+  let itemId = 0;
+  if (options.forbiddenPatterns) {
+    for (const forbidden of options.forbiddenPatterns) {
+      const pattern = typeof forbidden.pattern === "string" ? new RegExp(forbidden.pattern, "g") : forbidden.pattern;
+      if (pattern.test(changes.diff)) {
+        items.push({
+          id: `diff-${++itemId}`,
+          category: "diff",
+          check: `Forbidden pattern: ${forbidden.pattern}`,
+          passed: false,
+          severity: forbidden.severity,
+          details: forbidden.message,
+          suggestion: `Remove occurrences of ${forbidden.pattern}`
+        });
+      }
+    }
+  }
+  if (options.maxChangedFiles && changes.files.length > options.maxChangedFiles) {
+    items.push({
+      id: `diff-${++itemId}`,
+      category: "diff",
+      check: `PR size: ${changes.files.length} files changed`,
+      passed: false,
+      severity: "warning",
+      details: `This PR changes ${changes.files.length} files, which exceeds the recommended maximum of ${options.maxChangedFiles}`,
+      suggestion: "Consider breaking this into smaller PRs"
+    });
+  }
+  if (options.maxFileSize) {
+    for (const file of changes.files) {
+      const totalLines = file.additions + file.deletions;
+      if (totalLines > options.maxFileSize) {
+        items.push({
+          id: `diff-${++itemId}`,
+          category: "diff",
+          check: `File size: ${file.path}`,
+          passed: false,
+          severity: "warning",
+          details: `File has ${totalLines} lines changed, exceeding limit of ${options.maxFileSize}`,
+          file: file.path,
+          suggestion: "Consider splitting this file into smaller modules"
+        });
+      }
+    }
+  }
+  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 (!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}`
+        });
+      }
+    }
+  }
+  return Ok(items);
+}
+
+// src/feedback/review/checklist.ts
+var ChecklistBuilder = class {
+  rootDir;
+  harnessOptions;
+  customRules = [];
+  diffOptions;
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  withHarnessChecks(options) {
+    this.harnessOptions = options ?? { context: true, constraints: true, entropy: true };
+    return this;
+  }
+  addRule(rule) {
+    this.customRules.push(rule);
+    return this;
+  }
+  addRules(rules) {
+    this.customRules.push(...rules);
+    return this;
+  }
+  withDiffAnalysis(options) {
+    this.diffOptions = options;
+    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.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.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"
+        });
+      }
+    }
+    for (const rule of this.customRules) {
+      try {
+        const result = await rule.check(changes, this.rootDir);
+        const item = {
+          id: rule.id,
+          category: "custom",
+          check: rule.name,
+          passed: result.passed,
+          severity: rule.severity,
+          details: result.details
+        };
+        if (result.suggestion !== void 0) {
+          item.suggestion = result.suggestion;
+        }
+        if (result.file !== void 0) {
+          item.file = result.file;
+        }
+        if (result.line !== void 0) {
+          item.line = result.line;
+        }
+        items.push(item);
+      } catch (error) {
+        items.push({
+          id: rule.id,
+          category: "custom",
+          check: rule.name,
+          passed: false,
+          severity: "error",
+          details: `Rule execution failed: ${String(error)}`
+        });
+      }
+    }
+    if (this.diffOptions) {
+      const diffResult = await analyzeDiff(changes, this.diffOptions);
+      if (diffResult.ok) {
+        items.push(...diffResult.value);
+      }
+    }
+    const passed = items.filter((i) => i.passed).length;
+    const failed = items.filter((i) => !i.passed).length;
+    const errors = items.filter((i) => !i.passed && i.severity === "error").length;
+    const warnings = items.filter((i) => !i.passed && i.severity === "warning").length;
+    const checklist = {
+      items,
+      passed: failed === 0,
+      // Pass if no failed items
+      summary: {
+        total: items.length,
+        passed,
+        failed,
+        errors,
+        warnings
+      },
+      duration: Date.now() - startTime
+    };
+    return Ok(checklist);
+  }
+};
+
+// src/feedback/review/self-review.ts
+async function createSelfReview(changes, config) {
+  const builder = new ChecklistBuilder(config.rootDir);
+  if (config.harness) {
+    builder.withHarnessChecks(config.harness);
+  }
+  if (config.customRules) {
+    builder.addRules(config.customRules);
+  }
+  if (config.diffAnalysis) {
+    builder.withDiffAnalysis(config.diffAnalysis);
+  }
+  return builder.run(changes);
+}
+
+// src/feedback/logging/emitter.ts
+var AgentActionEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(eventType, handler) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(handler);
+    return () => this.off(eventType, handler);
+  }
+  once(eventType, handler) {
+    const wrappedHandler = (event) => {
+      this.off(eventType, wrappedHandler);
+      return handler(event);
+    };
+    return this.on(eventType, wrappedHandler);
+  }
+  off(eventType, handler) {
+    this.listeners.get(eventType)?.delete(handler);
+  }
+  emit(event) {
+    this.listeners.get(event.type)?.forEach((handler) => {
+      try {
+        handler(event);
+      } catch (e) {
+        console.error("Error in action event handler:", e);
+      }
+    });
+    if (event.type !== "action:*") {
+      this.listeners.get("action:*")?.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (e) {
+          console.error("Error in wildcard action event handler:", e);
+        }
+      });
+    }
+  }
+  listenerCount(eventType) {
+    return this.listeners.get(eventType)?.size ?? 0;
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+var globalEmitter = null;
+function getActionEmitter() {
+  if (!globalEmitter) {
+    globalEmitter = new AgentActionEmitter();
+  }
+  return globalEmitter;
+}
+async function logAgentAction(action) {
+  const fullAction = {
+    ...action,
+    id: generateId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const config = getFeedbackConfig();
+  if (config.emitEvents) {
+    const eventType = action.status === "completed" ? "action:completed" : action.status === "failed" ? "action:failed" : "action:started";
+    getActionEmitter().emit({
+      type: eventType,
+      action: fullAction,
+      timestamp: fullAction.timestamp
+    });
+  }
+  if (config.sinks) {
+    for (const sink of config.sinks) {
+      await sink.write(fullAction);
+    }
+  }
+  return Ok(fullAction);
+}
+function trackAction(type, context) {
+  const startTime = Date.now();
+  const action = {
+    id: generateId(),
+    type,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "started",
+    context
+  };
+  const config = getFeedbackConfig();
+  if (config.emitEvents) {
+    getActionEmitter().emit({
+      type: "action:started",
+      action,
+      timestamp: action.timestamp
+    });
+  }
+  return {
+    get action() {
+      return action;
+    },
+    async complete(result) {
+      action.status = "completed";
+      action.duration = Date.now() - startTime;
+      action.result = result;
+      return logAgentAction(action);
+    },
+    async fail(error) {
+      action.status = "failed";
+      action.duration = Date.now() - startTime;
+      action.error = error;
+      return logAgentAction(action);
+    }
+  };
+}
+
+// src/feedback/review/peer-review.ts
+async function requestPeerReview(agentType, context, options) {
+  const config = getFeedbackConfig();
+  const executor = config.executor;
+  if (!executor) {
+    return Err({
+      code: "AGENT_SPAWN_ERROR",
+      message: "No agent executor configured",
+      details: {},
+      suggestions: ["Configure an AgentExecutor via configureFeedback()"]
+    });
+  }
+  const tracker = trackAction("peer-review", {
+    trigger: "agent",
+    files: context.files
+  });
+  try {
+    const spawnConfig = {
+      type: agentType,
+      context
+    };
+    if (options?.customAgentType) {
+      spawnConfig.customType = options.customAgentType;
+    }
+    if (options?.skills) {
+      spawnConfig.skills = options.skills;
+    }
+    if (options?.timeout !== void 0) {
+      spawnConfig.timeout = options.timeout;
+    } else if (config.defaultTimeout !== void 0) {
+      spawnConfig.timeout = config.defaultTimeout;
+    }
+    const spawnResult = await executor.spawn(spawnConfig);
+    if (!spawnResult.ok) {
+      await tracker.fail({ code: spawnResult.error.code, message: spawnResult.error.message });
+      return spawnResult;
+    }
+    if (options?.wait !== false) {
+      const waitResult = await executor.wait(
+        spawnResult.value.id,
+        options?.timeout ?? config.defaultTimeout
+      );
+      if (!waitResult.ok) {
+        await tracker.fail({ code: waitResult.error.code, message: waitResult.error.message });
+        return waitResult;
+      }
+      await tracker.complete({
+        outcome: waitResult.value.approved ? "success" : "failure",
+        summary: waitResult.value.approved ? "Review approved" : `Review rejected: ${waitResult.value.comments.length} comments`,
+        data: waitResult.value
+      });
+      return waitResult;
+    }
+    await tracker.complete({
+      outcome: "success",
+      summary: `Agent spawned: ${spawnResult.value.id}`,
+      data: { processId: spawnResult.value.id }
+    });
+    return Ok({
+      agentId: spawnResult.value.id,
+      agentType,
+      approved: false,
+      // Unknown until wait
+      comments: [],
+      suggestions: [],
+      duration: 0,
+      completedAt: ""
+    });
+  } catch (error) {
+    await tracker.fail({
+      code: "AGENT_SPAWN_ERROR",
+      message: String(error)
+    });
+    return Err({
+      code: "AGENT_SPAWN_ERROR",
+      message: "Failed to request peer review",
+      details: { reason: String(error) },
+      suggestions: ["Check executor configuration", "Verify agent availability"]
+    });
+  }
+}
+async function requestMultiplePeerReviews(requests) {
+  if (requests.length === 0) {
+    return Ok([]);
+  }
+  const results = await Promise.all(
+    requests.map(
+      ({ agentType, context, options }) => requestPeerReview(agentType, context, options)
+    )
+  );
+  const firstError = results.find((r) => !r.ok);
+  if (firstError && !firstError.ok) {
+    return Err(firstError.error);
+  }
+  return Ok(results.map((r) => r.value));
+}
+
+// src/feedback/logging/file-sink.ts
+var import_fs2 = require("fs");
+var import_path11 = require("path");
+var FileSink = class {
+  name = "file";
+  filePath;
+  options;
+  buffer = [];
+  flushTimer;
+  initialized = false;
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.options = {
+      mode: options.mode ?? "append",
+      bufferSize: options.bufferSize ?? 1
+    };
+    if (options.flushInterval !== void 0) {
+      this.options.flushInterval = options.flushInterval;
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.options.flushInterval);
+    }
+  }
+  ensureDirectory() {
+    if (!this.initialized) {
+      const dir = (0, import_path11.dirname)(this.filePath);
+      if (!(0, import_fs2.existsSync)(dir)) {
+        (0, import_fs2.mkdirSync)(dir, { recursive: true });
+      }
+      this.initialized = true;
+    }
+  }
+  async write(action) {
+    try {
+      const line = JSON.stringify(action) + "\n";
+      this.buffer.push(line);
+      if (this.buffer.length >= (this.options.bufferSize ?? 1)) {
+        return this.flush();
+      }
+      return Ok(void 0);
+    } catch (error) {
+      return Err({
+        code: "SINK_ERROR",
+        message: "Failed to write action to file",
+        details: { reason: String(error) },
+        suggestions: ["Check file permissions", "Verify disk space"]
+      });
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) {
+      return Ok(void 0);
+    }
+    try {
+      this.ensureDirectory();
+      const content = this.buffer.join("");
+      this.buffer = [];
+      if (this.options.mode === "overwrite" && !(0, import_fs2.existsSync)(this.filePath)) {
+        (0, import_fs2.writeFileSync)(this.filePath, content);
+      } else {
+        (0, import_fs2.appendFileSync)(this.filePath, content);
+      }
+      return Ok(void 0);
+    } catch (error) {
+      return Err({
+        code: "SINK_ERROR",
+        message: "Failed to flush actions to file",
+        details: { reason: String(error) },
+        suggestions: ["Check file permissions", "Verify disk space"]
+      });
+    }
+  }
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    await this.flush();
+  }
+};
+
+// src/feedback/logging/sink.ts
+var NoOpSink = class {
+  name = "noop";
+  async write() {
+    return Ok(void 0);
+  }
+};
+
+// src/state/types.ts
+var import_zod2 = require("zod");
+var FailureEntrySchema = import_zod2.z.object({
+  date: import_zod2.z.string(),
+  skill: import_zod2.z.string(),
+  type: import_zod2.z.string(),
+  description: import_zod2.z.string()
+});
+var HandoffSchema = import_zod2.z.object({
+  timestamp: import_zod2.z.string(),
+  fromSkill: import_zod2.z.string(),
+  phase: import_zod2.z.string(),
+  summary: import_zod2.z.string(),
+  completed: import_zod2.z.array(import_zod2.z.string()).default([]),
+  pending: import_zod2.z.array(import_zod2.z.string()).default([]),
+  concerns: import_zod2.z.array(import_zod2.z.string()).default([]),
+  decisions: import_zod2.z.array(
+    import_zod2.z.object({
+      what: import_zod2.z.string(),
+      why: import_zod2.z.string()
+    })
+  ).default([]),
+  blockers: import_zod2.z.array(import_zod2.z.string()).default([]),
+  contextKeywords: import_zod2.z.array(import_zod2.z.string()).default([])
+});
+var GateCheckSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  passed: import_zod2.z.boolean(),
+  command: import_zod2.z.string(),
+  output: import_zod2.z.string().optional(),
+  duration: import_zod2.z.number().optional()
+});
+var GateResultSchema = import_zod2.z.object({
+  passed: import_zod2.z.boolean(),
+  checks: import_zod2.z.array(GateCheckSchema)
+});
+var GateConfigSchema = import_zod2.z.object({
+  checks: import_zod2.z.array(
+    import_zod2.z.object({
+      name: import_zod2.z.string(),
+      command: import_zod2.z.string()
+    })
+  ).optional(),
+  trace: import_zod2.z.boolean().optional()
+});
+var HarnessStateSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(1),
+  position: import_zod2.z.object({
+    phase: import_zod2.z.string().optional(),
+    task: import_zod2.z.string().optional()
+  }).default({}),
+  decisions: import_zod2.z.array(
+    import_zod2.z.object({
+      date: import_zod2.z.string(),
+      decision: import_zod2.z.string(),
+      context: import_zod2.z.string()
+    })
+  ).default([]),
+  blockers: import_zod2.z.array(
+    import_zod2.z.object({
+      id: import_zod2.z.string(),
+      description: import_zod2.z.string(),
+      status: import_zod2.z.enum(["open", "resolved"])
+    })
+  ).default([]),
+  progress: import_zod2.z.record(import_zod2.z.enum(["pending", "in_progress", "complete"])).default({}),
+  lastSession: import_zod2.z.object({
+    date: import_zod2.z.string(),
+    summary: import_zod2.z.string(),
+    lastSkill: import_zod2.z.string().optional(),
+    pendingTasks: import_zod2.z.array(import_zod2.z.string()).optional()
+  }).optional()
+});
+var DEFAULT_STATE = {
+  schemaVersion: 1,
+  position: {},
+  decisions: [],
+  blockers: [],
+  progress: {}
+};
+
+// src/state/state-manager.ts
+var fs2 = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var HARNESS_DIR = ".harness";
+var STATE_FILE = "state.json";
+var LEARNINGS_FILE = "learnings.md";
+var FAILURES_FILE = "failures.md";
+var HANDOFF_FILE = "handoff.json";
+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 });
+  }
+  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 Ok(result.data);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to load state from ${statePath}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function saveState(projectPath, state) {
+  const harnessDir = path.join(projectPath, HARNESS_DIR);
+  const statePath = path.join(harnessDir, STATE_FILE);
+  try {
+    fs2.mkdirSync(harnessDir, { recursive: true });
+    fs2.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(`Failed to save state: ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}
+async function appendLearning(projectPath, learning, skillName, outcome) {
+  const harnessDir = path.join(projectPath, HARNESS_DIR);
+  const learningsPath = path.join(harnessDir, LEARNINGS_FILE);
+  try {
+    fs2.mkdirSync(harnessDir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    let entry;
+    if (skillName && outcome) {
+      entry = `
+- **${timestamp} [skill:${skillName}] [outcome:${outcome}]:** ${learning}
+`;
+    } else if (skillName) {
+      entry = `
+- **${timestamp} [skill:${skillName}]:** ${learning}
+`;
+    } else {
+      entry = `
+- **${timestamp}:** ${learning}
+`;
+    }
+    if (!fs2.existsSync(learningsPath)) {
+      fs2.writeFileSync(learningsPath, `# Learnings
+${entry}`);
+    } else {
+      fs2.appendFileSync(learningsPath, entry);
+    }
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to append learning: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function loadRelevantLearnings(projectPath, skillName) {
+  const learningsPath = path.join(projectPath, HARNESS_DIR, LEARNINGS_FILE);
+  if (!fs2.existsSync(learningsPath)) {
+    return Ok([]);
+  }
+  try {
+    const content = fs2.readFileSync(learningsPath, "utf-8");
+    const lines = content.split("\n");
+    const entries = [];
+    let currentBlock = [];
+    for (const line of lines) {
+      if (line.startsWith("# ")) continue;
+      const isDatedBullet = /^- \*\*\d{4}-\d{2}-\d{2}/.test(line);
+      const isHeading = /^## \d{4}-\d{2}-\d{2}/.test(line);
+      if (isDatedBullet || isHeading) {
+        if (currentBlock.length > 0) {
+          entries.push(currentBlock.join("\n"));
+        }
+        currentBlock = [line];
+      } else if (line.trim() !== "" && currentBlock.length > 0) {
+        currentBlock.push(line);
+      }
+    }
+    if (currentBlock.length > 0) {
+      entries.push(currentBlock.join("\n"));
+    }
+    if (!skillName) {
+      return Ok(entries);
+    }
+    const filtered = entries.filter((entry) => entry.includes(`[skill:${skillName}]`));
+    return Ok(filtered);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to load learnings: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+var FAILURE_LINE_REGEX = /^- \*\*(\d{4}-\d{2}-\d{2}) \[skill:([^\]]+)\] \[type:([^\]]+)\]:\*\* (.+)$/;
+async function appendFailure(projectPath, description, skillName, type) {
+  const harnessDir = path.join(projectPath, HARNESS_DIR);
+  const failuresPath = path.join(harnessDir, FAILURES_FILE);
+  try {
+    fs2.mkdirSync(harnessDir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const entry = `
+- **${timestamp} [skill:${skillName}] [type:${type}]:** ${description}
+`;
+    if (!fs2.existsSync(failuresPath)) {
+      fs2.writeFileSync(failuresPath, `# Failures
+${entry}`);
+    } else {
+      fs2.appendFileSync(failuresPath, entry);
+    }
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to append failure: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function loadFailures(projectPath) {
+  const failuresPath = path.join(projectPath, HARNESS_DIR, FAILURES_FILE);
+  if (!fs2.existsSync(failuresPath)) {
+    return Ok([]);
+  }
+  try {
+    const content = fs2.readFileSync(failuresPath, "utf-8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(FAILURE_LINE_REGEX);
+      if (match) {
+        entries.push({
+          date: match[1] ?? "",
+          skill: match[2] ?? "",
+          type: match[3] ?? "",
+          description: match[4] ?? ""
+        });
+      }
+    }
+    return Ok(entries);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to load failures: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+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);
+  }
+  try {
+    const archiveDir = path.join(harnessDir, "archive");
+    fs2.mkdirSync(archiveDir, { recursive: true });
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    let archiveName = `failures-${date}.md`;
+    let counter = 2;
+    while (fs2.existsSync(path.join(archiveDir, archiveName))) {
+      archiveName = `failures-${date}-${counter}.md`;
+      counter++;
+    }
+    fs2.renameSync(failuresPath, path.join(archiveDir, archiveName));
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to archive failures: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+async function saveHandoff(projectPath, handoff) {
+  const harnessDir = path.join(projectPath, HARNESS_DIR);
+  const handoffPath = path.join(harnessDir, HANDOFF_FILE);
+  try {
+    fs2.mkdirSync(harnessDir, { recursive: true });
+    fs2.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+    return Ok(void 0);
+  } catch (error) {
+    return Err(
+      new Error(`Failed to save handoff: ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}
+async function loadHandoff(projectPath) {
+  const handoffPath = path.join(projectPath, HARNESS_DIR, HANDOFF_FILE);
+  if (!fs2.existsSync(handoffPath)) {
+    return 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 Ok(result.data);
+  } catch (error) {
+    return Err(
+      new Error(`Failed to load handoff: ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}
+async function runMechanicalGate(projectPath) {
+  const harnessDir = path.join(projectPath, HARNESS_DIR);
+  const gateConfigPath = path.join(harnessDir, GATE_CONFIG_FILE);
+  try {
+    let checks = [];
+    if (fs2.existsSync(gateConfigPath)) {
+      const raw = JSON.parse(fs2.readFileSync(gateConfigPath, "utf-8"));
+      const config = GateConfigSchema.safeParse(raw);
+      if (config.success && config.data.checks) {
+        checks = config.data.checks;
+      }
+    }
+    if (checks.length === 0) {
+      const packageJsonPath = path.join(projectPath, "package.json");
+      if (fs2.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+        const scripts = pkg.scripts || {};
+        if (scripts.test) checks.push({ name: "test", command: "npm test" });
+        if (scripts.lint) checks.push({ name: "lint", command: "npm run lint" });
+        if (scripts.typecheck) checks.push({ name: "typecheck", command: "npm run typecheck" });
+        if (scripts.build) checks.push({ name: "build", command: "npm run build" });
+      }
+      if (fs2.existsSync(path.join(projectPath, "go.mod"))) {
+        checks.push({ name: "test", command: "go test ./..." });
+        checks.push({ name: "build", command: "go build ./..." });
+      }
+      if (fs2.existsSync(path.join(projectPath, "pyproject.toml")) || fs2.existsSync(path.join(projectPath, "setup.py"))) {
+        checks.push({ name: "test", command: "python -m pytest" });
+      }
+    }
+    const results = [];
+    for (const check of checks) {
+      const start = Date.now();
+      try {
+        (0, import_child_process.execSync)(check.command, {
+          cwd: projectPath,
+          stdio: "pipe",
+          timeout: 12e4
+        });
+        results.push({
+          name: check.name,
+          passed: true,
+          command: check.command,
+          duration: Date.now() - start
+        });
+      } catch (error) {
+        const output = error instanceof Error ? error.stderr?.toString() || error.message : String(error);
+        results.push({
+          name: check.name,
+          passed: false,
+          command: check.command,
+          output: output.slice(0, 2e3),
+          duration: Date.now() - start
+        });
+      }
+    }
+    return Ok({
+      passed: results.length === 0 || results.every((r) => r.passed),
+      checks: results
+    });
+  } catch (error) {
+    return Err(
+      new Error(
+        `Failed to run mechanical gate: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+// src/workflow/runner.ts
+async function executeWorkflow(workflow, executor) {
+  const stepResults = [];
+  const startTime = Date.now();
+  let previousArtifact;
+  let stopped = false;
+  for (const step of workflow.steps) {
+    if (stopped) {
+      stepResults.push({
+        step,
+        outcome: "skipped",
+        durationMs: 0
+      });
+      continue;
+    }
+    const stepResult = await executor(step, previousArtifact);
+    stepResults.push(stepResult);
+    if (stepResult.outcome === "pass") {
+      previousArtifact = stepResult.artifact;
+    } else {
+      const gate = step.gate ?? "pass-required";
+      if (gate === "pass-required") {
+        stopped = true;
+      }
+    }
+  }
+  const hasFailure = stepResults.some((r) => r.outcome === "fail");
+  return {
+    workflow,
+    stepResults,
+    pass: !hasFailure,
+    totalDurationMs: Date.now() - startTime
+  };
+}
+
+// src/pipeline/skill-pipeline.ts
+async function runPipeline(initialContext, executor, options) {
+  const startTime = Date.now();
+  const hooks = options?.hooks;
+  let context = { ...initialContext };
+  if (hooks?.preExecution) {
+    const updated = hooks.preExecution(context);
+    if (updated === null) {
+      return {
+        success: false,
+        context,
+        error: "Pre-execution hook rejected the context",
+        turnsExecuted: 0,
+        durationMs: Date.now() - startTime
+      };
+    }
+    context = updated;
+  }
+  let result;
+  try {
+    result = await executor(context);
+  } catch (e) {
+    return {
+      success: false,
+      context,
+      error: e instanceof Error ? e.message : String(e),
+      turnsExecuted: 1,
+      durationMs: Date.now() - startTime
+    };
+  }
+  if (hooks?.postExecution) {
+    try {
+      hooks.postExecution(context, result);
+    } catch {
+    }
+  }
+  return {
+    success: result.success,
+    context,
+    result,
+    turnsExecuted: 1,
+    durationMs: Date.now() - startTime
+  };
+}
+async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
+  const startTime = Date.now();
+  const hooks = options?.hooks;
+  const maxTurns = options?.maxTurns ?? 10;
+  let context = { ...initialContext };
+  if (hooks?.preExecution) {
+    const updated = hooks.preExecution(context);
+    if (updated === null) {
+      return {
+        success: false,
+        context,
+        error: "Pre-execution hook rejected the context",
+        turnsExecuted: 0,
+        durationMs: Date.now() - startTime
+      };
+    }
+    context = updated;
+  }
+  const previousResults = [];
+  let turnsExecuted = 0;
+  let lastError;
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const turnContext = {
+      ...context,
+      turnNumber: turn + 1,
+      previousResults: [...previousResults]
+    };
+    let filteredTurnContext = turnContext;
+    if (hooks?.perTurn) {
+      const updated = hooks.perTurn(turnContext);
+      if (updated === null) {
+        break;
+      }
+      filteredTurnContext = updated;
+    }
+    try {
+      const turnResult = await turnExecutor(filteredTurnContext);
+      previousResults.push(turnResult.result);
+      turnsExecuted++;
+      if (turnResult.done) {
+        break;
+      }
+    } catch (e) {
+      lastError = e instanceof Error ? e.message : String(e);
+      turnsExecuted++;
+      break;
+    }
+  }
+  const skillResult = {
+    success: !lastError,
+    artifacts: [],
+    summary: lastError ?? `Completed in ${turnsExecuted} turns`
+  };
+  if (hooks?.postExecution) {
+    try {
+      hooks.postExecution(context, skillResult);
+    } catch {
+    }
+  }
+  return {
+    success: !lastError,
+    context,
+    result: skillResult,
+    ...lastError !== void 0 && { error: lastError },
+    turnsExecuted,
+    durationMs: Date.now() - startTime
+  };
+}
+
+// src/index.ts
+var VERSION = "0.5.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentActionEmitter,
+  ChecklistBuilder,
+  ConsoleSink,
+  DEFAULT_STATE,
+  EntropyAnalyzer,
+  EntropyConfigSchema,
+  Err,
+  FailureEntrySchema,
+  FileSink,
+  GateConfigSchema,
+  GateResultSchema,
+  HandoffSchema,
+  HarnessStateSchema,
+  NoOpExecutor,
+  NoOpSink,
+  NoOpTelemetryAdapter,
+  Ok,
+  PatternConfigSchema,
+  REQUIRED_SECTIONS,
+  TypeScriptParser,
+  VERSION,
+  analyzeDiff,
+  appendFailure,
+  appendLearning,
+  applyFixes,
+  archiveFailures,
+  buildDependencyGraph,
+  buildReachabilityMap,
+  buildSnapshot,
+  checkConfigPattern,
+  checkDocCoverage,
+  configureFeedback,
+  contextBudget,
+  contextFilter,
+  createBoundaryValidator,
+  createError,
+  createFixes,
+  createParseError,
+  createSelfReview,
+  defineLayer,
+  detectCircularDeps,
+  detectCircularDepsInFiles,
+  detectDeadCode,
+  detectDocDrift,
+  detectPatternViolations,
+  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,
+  runMechanicalGate,
+  runMultiTurnPipeline,
+  runPipeline,
+  saveHandoff,
+  saveState,
+  trackAction,
+  validateAgentsMap,
+  validateBoundaries,
+  validateCommitMessage,
+  validateConfig,
+  validateDependencies,
+  validateFileStructure,
+  validateKnowledgeMap,
+  validatePatternConfig,
+  ...require("@harness-engineering/types")
+});