@harness-engineering/graph 0.4.2 → 0.5.0

package/dist/index.mjs

@@ -23,6 +23,7 @@ var NODE_TYPES = [
   "commit",
   "build",
   "test_result",
+  "execution_outcome",
   // Observability (future)
   "span",
   "metric",
@@ -36,8 +37,18 @@ var NODE_TYPES = [
   "design_token",
   "aesthetic_intent",
   "design_constraint",
+  "image_annotation",
   // Traceability
-  "requirement"
+  "requirement",
+  // Business Knowledge
+  "business_rule",
+  "business_process",
+  "business_concept",
+  "business_term",
+  "business_metric",
+  "business_fact",
+  // Cache
+  "packed_summary"
 ];
 var EDGE_TYPES = [
   // Code relationships
@@ -59,6 +70,7 @@ var EDGE_TYPES = [
   "co_changes_with",
   "triggered_by",
   "failed_in",
+  "outcome_of",
   // Execution relationships (future)
   "executed_by",
   "measured_by",
@@ -70,10 +82,25 @@ var EDGE_TYPES = [
   // Traceability relationships
   "requires",
   "verified_by",
-  "tested_by"
+  "tested_by",
+  // Business Knowledge relationships
+  "governs",
+  "measures",
+  "annotates",
+  // Cache relationships
+  "caches"
 ];
 var OBSERVABILITY_TYPES = /* @__PURE__ */ new Set(["span", "metric", "log"]);
 var CURRENT_SCHEMA_VERSION = 1;
+var NODE_STABILITY = {
+  File: "session",
+  Function: "session",
+  Class: "session",
+  Constraint: "session",
+  PackedSummary: "session",
+  SkillDefinition: "static",
+  ToolDefinition: "static"
+};
 var GraphNodeSchema = z.object({
   id: z.string(),
   type: z.enum(NODE_TYPES),
@@ -102,10 +129,28 @@ var GraphEdgeSchema = z.object({
 
 // src/store/Serializer.ts
 import { readFile, writeFile, mkdir, access } from "fs/promises";
+import { createWriteStream } from "fs";
 import { join } from "path";
+function streamGraphJson(filePath, nodes, edges) {
+  return new Promise((resolve, reject) => {
+    const stream = createWriteStream(filePath, { encoding: "utf-8" });
+    stream.on("error", reject);
+    stream.write('{"nodes":[');
+    for (let i = 0; i < nodes.length; i++) {
+      if (i > 0) stream.write(",");
+      stream.write(JSON.stringify(nodes[i]));
+    }
+    stream.write('],"edges":[');
+    for (let i = 0; i < edges.length; i++) {
+      if (i > 0) stream.write(",");
+      stream.write(JSON.stringify(edges[i]));
+    }
+    stream.write("]}");
+    stream.end(resolve);
+  });
+}
 async function saveGraph(dirPath, nodes, edges) {
   await mkdir(dirPath, { recursive: true });
-  const graphData = { nodes, edges };
   const metadata = {
     schemaVersion: CURRENT_SCHEMA_VERSION,
     lastScanTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -113,7 +158,7 @@ async function saveGraph(dirPath, nodes, edges) {
     edgeCount: edges.length
   };
   await Promise.all([
-    writeFile(join(dirPath, "graph.json"), JSON.stringify(graphData, null, 2), "utf-8"),
+    streamGraphJson(join(dirPath, "graph.json"), nodes, edges),
     writeFile(join(dirPath, "metadata.json"), JSON.stringify(metadata, null, 2), "utf-8")
   ]);
 }
@@ -302,8 +347,8 @@ var GraphStore = class {
   }
   // --- Persistence ---
   async save(dirPath) {
-    const allNodes = Array.from(this.nodeMap.values()).map((n) => ({ ...n }));
-    const allEdges = Array.from(this.edgeMap.values()).map((e) => ({ ...e }));
+    const allNodes = Array.from(this.nodeMap.values());
+    const allEdges = Array.from(this.edgeMap.values());
     await saveGraph(dirPath, allNodes, allEdges);
   }
   async load(dirPath) {
@@ -409,6 +454,94 @@ var VectorStore = class _VectorStore {
   }
 };
 
+// src/store/PackedSummaryCache.ts
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function normalizeIntent(intent) {
+  return intent.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function cacheNodeId(normalizedIntent) {
+  return `packed_summary:${normalizedIntent}`;
+}
+var PackedSummaryCache = class {
+  constructor(store, ttlMs = DEFAULT_TTL_MS) {
+    this.store = store;
+    this.ttlMs = ttlMs;
+  }
+  store;
+  ttlMs;
+  /** Returns cached envelope with `cached: true` if valid, or null if miss/stale. */
+  get(intent) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    const node = this.store.getNode(nodeId);
+    if (!node) return null;
+    const createdMs = this.parseCreatedMs(node.metadata["createdAt"]);
+    if (createdMs === null) return null;
+    if (Date.now() - createdMs > this.ttlMs) return null;
+    if (!this.areSourcesFresh(nodeId, node, createdMs)) return null;
+    return this.parseEnvelope(node.metadata["envelope"]);
+  }
+  /** Parse and validate createdAt. Returns epoch ms or null if missing/malformed (GC-002). */
+  parseCreatedMs(createdAt) {
+    if (!createdAt) return null;
+    const ms = new Date(createdAt).getTime();
+    return Number.isNaN(ms) ? null : ms;
+  }
+  /** GC-001: Checks source nodes exist and are unmodified since cache creation. */
+  areSourcesFresh(nodeId, node, createdMs) {
+    const sourceNodeIds = node.metadata["sourceNodeIds"];
+    const edges = this.store.getEdges({ from: nodeId, type: "caches" });
+    if (sourceNodeIds && edges.length < sourceNodeIds.length) return false;
+    for (const edge of edges) {
+      const sourceNode = this.store.getNode(edge.to);
+      if (!sourceNode) return false;
+      if (sourceNode.lastModified) {
+        const sourceModMs = new Date(sourceNode.lastModified).getTime();
+        if (sourceModMs > createdMs) return false;
+      }
+    }
+    return true;
+  }
+  /** Parse envelope JSON and set cached: true. Returns null on invalid JSON. */
+  parseEnvelope(raw) {
+    try {
+      const envelope = JSON.parse(raw);
+      return { ...envelope, meta: { ...envelope.meta, cached: true } };
+    } catch {
+      return null;
+    }
+  }
+  /** Write a PackedSummary node with caches edges to source nodes. */
+  set(intent, envelope, sourceNodeIds) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    this.store.removeNode(nodeId);
+    this.store.addNode({
+      id: nodeId,
+      type: "packed_summary",
+      name: normalized,
+      metadata: {
+        envelope: JSON.stringify(envelope),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceNodeIds
+      }
+    });
+    for (const sourceId of sourceNodeIds) {
+      this.store.addEdge({
+        from: nodeId,
+        to: sourceId,
+        type: "caches"
+      });
+    }
+  }
+  /** Explicitly invalidate a cached packed summary. */
+  invalidate(intent) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    this.store.removeNode(nodeId);
+  }
+};
+
 // src/query/ContextQL.ts
 function edgeKey2(e) {
   return `${e.from}|${e.to}|${e.type}`;
@@ -584,6 +717,49 @@ function groupNodesByImpact(nodes, excludeId) {
 import * as fs from "fs/promises";
 import * as path from "path";
 var SKIP_METHOD_NAMES = /* @__PURE__ */ new Set(["constructor", "if", "for", "while", "switch"]);
+var FUNCTION_PATTERNS = {
+  python: /^def\s+(\w+)\s*\(/,
+  go: /^func\s+(\w+)\s*[[(]/,
+  rust: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+  typescript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
+  javascript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)/
+};
+var CLASS_PATTERNS = {
+  python: /^class\s+(\w+)/,
+  go: /^type\s+(\w+)\s+struct\b/,
+  rust: /^(?:pub\s+)?struct\s+(\w+)/,
+  java: /(?:public|private|protected)?\s*(?:abstract\s+|final\s+)?class\s+(\w+)/,
+  typescript: /(?:export\s+)?class\s+(\w+)/,
+  javascript: /(?:export\s+)?class\s+(\w+)/
+};
+var INTERFACE_PATTERNS = {
+  go: /^type\s+(\w+)\s+interface\b/,
+  rust: /^(?:pub\s+)?trait\s+(\w+)/,
+  java: /(?:public\s+)?interface\s+(\w+)/,
+  typescript: /(?:export\s+)?interface\s+(\w+)/,
+  javascript: /(?:export\s+)?interface\s+(\w+)/
+};
+var METHOD_PATTERNS = {
+  python: /^\s+def\s+(\w+)\s*\(/,
+  rust: /^\s+(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
+  java: /^\s+(?:(?:public|private|protected|static|final|abstract|synchronized)\s+)*(?:\w+(?:<[^>]*>)?)\s+(\w+)\s*\(/,
+  typescript: /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/,
+  javascript: /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
+};
+var GO_METHOD_PATTERN = /^func\s+\(\w+\s+\*?(\w+)\)\s+(\w+)\s*\(/;
+var VARIABLE_PATTERNS = {
+  python: /^([A-Z]\w*)\s*=/,
+  go: /^(?:var|const)\s+(\w+)/,
+  rust: /^(?:pub\s+)?(?:const|static)\s+(\w+)/,
+  typescript: /(?:export\s+)?(?:const|let|var)\s+(\w+)/,
+  javascript: /(?:export\s+)?(?:const|let|var)\s+(\w+)/
+};
+function isExported(lang, line, name) {
+  if (lang === "go") return /^[A-Z]/.test(name);
+  if (lang === "rust") return /^\s*pub\b/.test(line);
+  if (lang === "java") return /\bpublic\b/.test(line);
+  return line.includes("export");
+}
 function countBraces(line) {
   let net = 0;
   for (const ch of line) {
@@ -592,6 +768,23 @@ function countBraces(line) {
   }
   return net;
 }
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".groovy"
+]);
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([".d.ts"]);
+function isSupportedSourceFile(name) {
+  if (SKIP_EXTENSIONS.has(name.slice(name.lastIndexOf(".")))) return false;
+  const ext = name.slice(name.lastIndexOf("."));
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
 var CodeIngestor = class {
   constructor(store) {
     this.store = store;
@@ -604,22 +797,34 @@ var CodeIngestor = class {
     let edgesAdded = 0;
     const files = await this.findSourceFiles(rootDir);
     const nameToFiles = /* @__PURE__ */ new Map();
-    const fileContents = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       try {
-        const result = await this.processFile(filePath, rootDir, nameToFiles, fileContents);
+        const result = await this.processFile(filePath, rootDir, nameToFiles);
         nodesAdded += result.nodesAdded;
         edgesAdded += result.edgesAdded;
       } catch (err) {
         errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    const callsEdges = this.extractCallsEdges(nameToFiles, fileContents);
-    for (const edge of callsEdges) {
-      this.store.addEdge(edge);
-      edgesAdded++;
+    for (const filePath of files) {
+      try {
+        const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
+        const content = await fs.readFile(filePath, "utf-8");
+        const callsEdges = this.extractCallsEdgesForFile(relativePath, content, nameToFiles);
+        for (const edge of callsEdges) {
+          this.store.addEdge(edge);
+          edgesAdded++;
+        }
+      } catch {
+      }
+    }
+    for (const filePath of files) {
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+        edgesAdded += this.extractReqAnnotationsForFile(filePath, content, rootDir);
+      } catch {
+      }
     }
-    edgesAdded += this.extractReqAnnotations(fileContents, rootDir);
     return {
       nodesAdded,
       nodesUpdated: 0,
@@ -629,14 +834,13 @@ var CodeIngestor = class {
       durationMs: Date.now() - start
     };
   }
-  async processFile(filePath, rootDir, nameToFiles, fileContents) {
+  async processFile(filePath, rootDir, nameToFiles) {
     let nodesAdded = 0;
     let edgesAdded = 0;
     const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
     const content = await fs.readFile(filePath, "utf-8");
     const stat2 = await fs.stat(filePath);
     const fileId = `file:${relativePath}`;
-    fileContents.set(relativePath, content);
     const fileNode = {
       id: fileId,
       type: "file",
@@ -676,9 +880,9 @@ var CodeIngestor = class {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "target" && entry.name !== "build" && entry.name !== ".git" && entry.name !== "__pycache__" && entry.name !== ".venv" && entry.name !== ".turbo" && entry.name !== ".harness" && entry.name !== ".next" && entry.name !== ".vscode" && entry.name !== ".idea" && entry.name !== "vendor" && entry.name !== "out" && entry.name !== ".gradle" && entry.name !== ".gradle-home" && entry.name !== "bin" && entry.name !== "obj" && entry.name !== "venv" && entry.name !== "_build" && entry.name !== "deps" && entry.name !== "coverage" && entry.name !== ".nyc_output") {
         results.push(...await this.findSourceFiles(fullPath));
-      } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+      } else if (entry.isFile() && isSupportedSourceFile(entry.name)) {
         results.push(fullPath);
       }
     }
@@ -687,25 +891,40 @@ var CodeIngestor = class {
   extractSymbols(content, fileId, relativePath) {
     const results = [];
     const lines = content.split("\n");
+    const lang = this.detectLanguage(relativePath);
     const ctx = { className: null, classId: null, insideClass: false, braceDepth: 0 };
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      if (this.tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.tryExtractClass(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.updateClassContext(line, ctx)) continue;
-      if (this.tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (ctx.insideClass) continue;
-      this.tryExtractVariable(line, i, fileId, relativePath, results);
+      this.processSymbolLine(line, lines, i, fileId, relativePath, ctx, results, lang);
     }
     return results;
   }
-  tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results) {
-    const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+  processSymbolLine(line, lines, i, fileId, relativePath, ctx, results, lang) {
+    if (lang === "python") {
+      this.updatePythonClassContext(lines, i, ctx);
+    }
+    if (this.tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results, lang)) return;
+    if (this.tryExtractClass(line, lines, i, fileId, relativePath, ctx, results, lang)) return;
+    if (this.tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results, lang)) return;
+    if (this.tryEnterImplBlock(line, lang, relativePath, ctx)) return;
+    if (lang !== "python" && this.updateClassContext(line, ctx)) return;
+    if (this.tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results, lang)) return;
+    if (ctx.insideClass) return;
+    this.tryExtractVariable(line, i, fileId, relativePath, results, lang);
+  }
+  matchFunction(line, lang) {
+    if (lang === "java") return null;
+    const pattern = FUNCTION_PATTERNS[lang];
+    return pattern ? line.match(pattern) : null;
+  }
+  tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results, lang) {
+    if (ctx.insideClass) return false;
+    const fnMatch = this.matchFunction(line, lang);
     if (!fnMatch) return false;
     const name = fnMatch[1];
     const id = `function:${relativePath}:${name}`;
-    const endLine = this.findClosingBrace(lines, i);
+    const endLine = lang === "python" ? this.findEndOfIndentBlock(lines, i) : this.findClosingBrace(lines, i);
+    const exported = isExported(lang, line, name);
     results.push({
       node: {
         id,
@@ -714,7 +933,7 @@ var CodeIngestor = class {
         path: relativePath,
         location: { fileId, startLine: i + 1, endLine },
         metadata: {
-          exported: line.includes("export"),
+          exported,
           cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
           nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
           lineCount: endLine - i,
@@ -729,12 +948,17 @@ var CodeIngestor = class {
     }
     return true;
   }
-  tryExtractClass(line, lines, i, fileId, relativePath, ctx, results) {
-    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+  matchClass(line, lang) {
+    const pattern = CLASS_PATTERNS[lang];
+    return pattern ? line.match(pattern) : null;
+  }
+  tryExtractClass(line, lines, i, fileId, relativePath, ctx, results, lang) {
+    const classMatch = this.matchClass(line, lang);
     if (!classMatch) return false;
     const name = classMatch[1];
     const id = `class:${relativePath}:${name}`;
-    const endLine = this.findClosingBrace(lines, i);
+    const endLine = lang === "python" ? this.findEndOfIndentBlock(lines, i) : this.findClosingBrace(lines, i);
+    const exported = isExported(lang, line, name);
     results.push({
       node: {
         id,
@@ -742,22 +966,27 @@ var CodeIngestor = class {
         name,
         path: relativePath,
         location: { fileId, startLine: i + 1, endLine },
-        metadata: { exported: line.includes("export") }
+        metadata: { exported }
       },
       edge: { from: fileId, to: id, type: "contains" }
     });
     ctx.className = name;
     ctx.classId = id;
     ctx.insideClass = true;
-    ctx.braceDepth = countBraces(line);
+    ctx.braceDepth = lang === "python" ? 1 : countBraces(line);
     return true;
   }
-  tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results) {
-    const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+  matchInterface(line, lang) {
+    const pattern = INTERFACE_PATTERNS[lang];
+    return pattern ? line.match(pattern) : null;
+  }
+  tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results, lang) {
+    const ifaceMatch = this.matchInterface(line, lang);
     if (!ifaceMatch) return false;
     const name = ifaceMatch[1];
     const id = `interface:${relativePath}:${name}`;
     const endLine = this.findClosingBrace(lines, i);
+    const exported = isExported(lang, line, name);
     results.push({
       node: {
         id,
@@ -765,7 +994,7 @@ var CodeIngestor = class {
         name,
         path: relativePath,
         location: { fileId, startLine: i + 1, endLine },
-        metadata: { exported: line.includes("export") }
+        metadata: { exported }
       },
       edge: { from: fileId, to: id, type: "contains" }
     });
@@ -774,6 +1003,23 @@ var CodeIngestor = class {
     ctx.insideClass = false;
     return true;
   }
+  /**
+   * Enter an impl block (Rust) or Java class body — sets class context without creating a node.
+   */
+  tryEnterImplBlock(line, lang, relativePath, ctx) {
+    if (lang === "rust") {
+      const implMatch = line.match(/^impl(?:<[^>]*>)?\s+(\w+)/);
+      if (implMatch) {
+        const name = implMatch[1];
+        ctx.className = name;
+        ctx.classId = `class:${relativePath}:${name}`;
+        ctx.insideClass = true;
+        ctx.braceDepth = countBraces(line);
+        return true;
+      }
+    }
+    return false;
+  }
   /** Update brace tracking; returns true when line is consumed (class ended or tracked). */
   updateClassContext(line, ctx) {
     if (!ctx.insideClass) return false;
@@ -786,16 +1032,32 @@ var CodeIngestor = class {
     }
     return false;
   }
-  tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results) {
-    if (!ctx.insideClass || !ctx.className || !ctx.classId) return false;
-    const methodMatch = line.match(
-      /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
-    );
+  matchMethod(line, lang, insideClass) {
+    if (lang === "go") return line.match(GO_METHOD_PATTERN);
+    if (!insideClass) return null;
+    const pattern = METHOD_PATTERNS[lang];
+    return pattern ? line.match(pattern) : null;
+  }
+  tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results, lang) {
+    const methodMatch = this.matchMethod(line, lang, ctx.insideClass);
     if (!methodMatch) return false;
-    const methodName = methodMatch[1];
+    let methodName;
+    let className;
+    let classId;
+    if (lang === "go") {
+      const receiverType = methodMatch[1];
+      methodName = methodMatch[2];
+      className = receiverType;
+      classId = `class:${relativePath}:${receiverType}`;
+    } else {
+      if (!ctx.insideClass || !ctx.className || !ctx.classId) return false;
+      methodName = methodMatch[1];
+      className = ctx.className;
+      classId = ctx.classId;
+    }
     if (SKIP_METHOD_NAMES.has(methodName)) return false;
-    const id = `method:${relativePath}:${ctx.className}.${methodName}`;
-    const endLine = this.findClosingBrace(lines, i);
+    const id = `method:${relativePath}:${className}.${methodName}`;
+    const endLine = lang === "python" ? this.findEndOfIndentBlock(lines, i) : this.findClosingBrace(lines, i);
     results.push({
       node: {
         id,
@@ -804,23 +1066,28 @@ var CodeIngestor = class {
         path: relativePath,
         location: { fileId, startLine: i + 1, endLine },
         metadata: {
-          className: ctx.className,
-          exported: false,
+          className,
+          exported: isExported(lang, line, methodName),
           cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
           nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
           lineCount: endLine - i,
           parameterCount: this.countParameters(line)
         }
       },
-      edge: { from: ctx.classId, to: id, type: "contains" }
+      edge: { from: classId, to: id, type: "contains" }
     });
     return true;
   }
-  tryExtractVariable(line, i, fileId, relativePath, results) {
-    const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
+  matchVariable(line, lang) {
+    const pattern = VARIABLE_PATTERNS[lang];
+    return pattern ? line.match(pattern) : null;
+  }
+  tryExtractVariable(line, i, fileId, relativePath, results, lang) {
+    const varMatch = this.matchVariable(line, lang);
     if (!varMatch) return;
     const name = varMatch[1];
     const id = `variable:${relativePath}:${name}`;
+    const exported = isExported(lang, line, name);
     results.push({
       node: {
         id,
@@ -828,7 +1095,7 @@ var CodeIngestor = class {
         name,
         path: relativePath,
         location: { fileId, startLine: i + 1, endLine: i + 1 },
-        metadata: { exported: line.includes("export") }
+        metadata: { exported }
       },
       edge: { from: fileId, to: id, type: "contains" }
     });
@@ -857,48 +1124,79 @@ var CodeIngestor = class {
     return startIndex + 1;
   }
   /**
-   * Second pass: scan each file for identifiers matching known callable names,
+   * Find the end of an indentation-based block (Python).
+   * The block ends when a subsequent non-empty line has indentation <= the starting line.
+   */
+  findEndOfIndentBlock(lines, startIndex) {
+    const startLine = lines[startIndex] ?? "";
+    const baseIndent = startLine.search(/\S/);
+    let lastNonEmpty = startIndex;
+    for (let i = startIndex + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "") continue;
+      const indent = line.search(/\S/);
+      if (indent <= baseIndent) {
+        return lastNonEmpty + 1;
+      }
+      lastNonEmpty = i;
+    }
+    return lastNonEmpty + 1;
+  }
+  /**
+   * Update class context for Python using indentation tracking.
+   */
+  updatePythonClassContext(lines, i, ctx) {
+    if (!ctx.insideClass) return false;
+    const line = lines[i];
+    if (line.trim() === "") return false;
+    const indent = line.search(/\S/);
+    if (indent <= 0) {
+      ctx.className = null;
+      ctx.classId = null;
+      ctx.insideClass = false;
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Scan a file for identifiers matching known callable names,
    * then create file-to-file "calls" edges. Uses regex heuristic (not AST).
    */
-  extractCallsEdges(nameToFiles, fileContents) {
+  extractCallsEdgesForFile(relativePath, content, nameToFiles) {
     const edges = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const [filePath, content] of fileContents) {
-      const callerFileId = `file:${filePath}`;
-      const callPattern = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
-      let match;
-      while ((match = callPattern.exec(content)) !== null) {
-        const name = match[1];
-        const targetFiles = nameToFiles.get(name);
-        if (!targetFiles) continue;
-        for (const targetFile of targetFiles) {
-          if (targetFile === filePath) continue;
-          const targetFileId = `file:${targetFile}`;
-          const key = `${callerFileId}|${targetFileId}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          edges.push({
-            from: callerFileId,
-            to: targetFileId,
-            type: "calls",
-            metadata: { confidence: "regex" }
-          });
-        }
+    const callerFileId = `file:${relativePath}`;
+    const callPattern = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
+    let match;
+    while ((match = callPattern.exec(content)) !== null) {
+      const name = match[1];
+      const targetFiles = nameToFiles.get(name);
+      if (!targetFiles) continue;
+      for (const targetFile of targetFiles) {
+        if (targetFile === relativePath) continue;
+        const targetFileId = `file:${targetFile}`;
+        const key = `${callerFileId}|${targetFileId}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        edges.push({
+          from: callerFileId,
+          to: targetFileId,
+          type: "calls",
+          metadata: { confidence: "regex" }
+        });
       }
     }
     return edges;
   }
   async extractImports(content, fileId, relativePath, rootDir) {
+    const lang = this.detectLanguage(relativePath);
     const edges = [];
-    const importRegex = /import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+)\s+from\s+['"]([^'"]+)['"]/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (!importPath.startsWith(".")) continue;
+    const importPaths = this.extractImportPaths(content, lang);
+    for (const { importPath, isTypeOnly } of importPaths) {
+      if ((lang === "typescript" || lang === "javascript") && !importPath.startsWith(".")) continue;
       const resolvedPath = await this.resolveImportPath(relativePath, importPath, rootDir);
       if (resolvedPath) {
         const targetId = `file:${resolvedPath}`;
-        const isTypeOnly = match[0].includes("import type");
         edges.push({
           from: fileId,
           to: targetId,
@@ -909,10 +1207,53 @@ var CodeIngestor = class {
     }
     return edges;
   }
+  extractImportPaths(content, lang) {
+    const results = [];
+    if (lang === "typescript" || lang === "javascript") {
+      const importRegex = /import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+)\s+from\s+['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        results.push({
+          importPath: match[1],
+          isTypeOnly: match[0].includes("import type")
+        });
+      }
+    } else if (lang === "python") {
+      const fromImport = /(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/g;
+      let match;
+      while ((match = fromImport.exec(content)) !== null) {
+        const importPath = match[1] ?? match[2];
+        if (importPath.startsWith(".")) {
+          results.push({ importPath, isTypeOnly: false });
+        } else {
+          results.push({ importPath: importPath.replace(/\./g, "/"), isTypeOnly: false });
+        }
+      }
+    } else if (lang === "go") {
+      const goImport = /"([^"]+)"/g;
+      let match;
+      while ((match = goImport.exec(content)) !== null) {
+        results.push({ importPath: match[1], isTypeOnly: false });
+      }
+    } else if (lang === "rust") {
+      const useDecl = /use\s+((?:crate|super|self)(?:::\w+)+)/g;
+      let match;
+      while ((match = useDecl.exec(content)) !== null) {
+        results.push({ importPath: match[1], isTypeOnly: false });
+      }
+    } else if (lang === "java") {
+      const javaImport = /import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;/g;
+      let match;
+      while ((match = javaImport.exec(content)) !== null) {
+        results.push({ importPath: match[1], isTypeOnly: false });
+      }
+    }
+    return results;
+  }
   async resolveImportPath(fromFile, importPath, rootDir) {
     const fromDir = path.dirname(fromFile);
     const resolved = path.normalize(path.join(fromDir, importPath)).replace(/\\/g, "/");
-    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
     for (const ext of extensions) {
       const candidate = resolved.replace(/\.js$/, "") + ext;
       const fullPath = path.join(rootDir, candidate);
@@ -922,7 +1263,8 @@ var CodeIngestor = class {
       } catch {
       }
     }
-    for (const ext of extensions) {
+    const indexExtensions = [".ts", ".tsx", ".js", ".jsx"];
+    for (const ext of indexExtensions) {
       const candidate = path.join(resolved, `index${ext}`).replace(/\\/g, "/");
       const fullPath = path.join(rootDir, candidate);
       try {
@@ -931,6 +1273,12 @@ var CodeIngestor = class {
       } catch {
       }
     }
+    const pyInit = path.join(resolved, "__init__.py").replace(/\\/g, "/");
+    try {
+      await fs.access(path.join(rootDir, pyInit));
+      return pyInit;
+    } catch {
+    }
     return null;
   }
   computeCyclomaticComplexity(lines) {
@@ -976,6 +1324,11 @@ var CodeIngestor = class {
   detectLanguage(filePath) {
     if (/\.tsx?$/.test(filePath)) return "typescript";
     if (/\.jsx?$/.test(filePath)) return "javascript";
+    if (/\.py$/.test(filePath)) return "python";
+    if (/\.go$/.test(filePath)) return "go";
+    if (/\.rs$/.test(filePath)) return "rust";
+    if (/\.java$/.test(filePath)) return "java";
+    if (/\.groovy$/.test(filePath)) return "java";
     return "unknown";
   }
   /**
@@ -983,40 +1336,38 @@ var CodeIngestor = class {
    * linking requirement nodes to the annotated files.
    * Format: // @req <feature-name>#<index>
    */
-  extractReqAnnotations(fileContents, rootDir) {
-    const REQ_TAG = /\/\/\s*@req\s+([\w-]+)#(\d+)/g;
+  extractReqAnnotationsForFile(filePath, content, rootDir) {
+    const REQ_TAG = /(?:\/\/|#|\/\*)\s*@req\s+([\w-]+)#(\d+)/g;
     const reqNodes = this.store.findNodes({ type: "requirement" });
     let edgesAdded = 0;
-    for (const [filePath, content] of fileContents) {
-      let match;
-      REQ_TAG.lastIndex = 0;
-      while ((match = REQ_TAG.exec(content)) !== null) {
-        const featureName = match[1];
-        const reqIndex = parseInt(match[2], 10);
-        const reqNode = reqNodes.find(
-          (n) => n.metadata.featureName === featureName && n.metadata.index === reqIndex
+    let match;
+    REQ_TAG.lastIndex = 0;
+    while ((match = REQ_TAG.exec(content)) !== null) {
+      const featureName = match[1];
+      const reqIndex = parseInt(match[2], 10);
+      const reqNode = reqNodes.find(
+        (n) => n.metadata.featureName === featureName && n.metadata.index === reqIndex
+      );
+      if (!reqNode) {
+        console.warn(
+          `@req annotation references non-existent requirement: ${featureName}#${reqIndex} in ${filePath}`
         );
-        if (!reqNode) {
-          console.warn(
-            `@req annotation references non-existent requirement: ${featureName}#${reqIndex} in ${filePath}`
-          );
-          continue;
-        }
-        const relPath = path.relative(rootDir, filePath).replace(/\\/g, "/");
-        const fileNodeId = `file:${relPath}`;
-        this.store.addEdge({
-          from: reqNode.id,
-          to: fileNodeId,
-          type: "verified_by",
-          confidence: 1,
-          metadata: {
-            method: "annotation",
-            tag: `@req ${featureName}#${reqIndex}`,
-            confidence: 1
-          }
-        });
-        edgesAdded++;
+        continue;
       }
+      const relPath = path.relative(rootDir, filePath).replace(/\\/g, "/");
+      const fileNodeId = `file:${relPath}`;
+      this.store.addEdge({
+        from: reqNode.id,
+        to: fileNodeId,
+        type: "verified_by",
+        confidence: 1,
+        metadata: {
+          method: "annotation",
+          tag: `@req ${featureName}#${reqIndex}`,
+          confidence: 1
+        }
+      });
+      edgesAdded++;
     }
     return edgesAdded;
   }
@@ -1420,7 +1771,7 @@ var KnowledgeIngestor = class {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory()) {
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "target" && entry.name !== "build" && entry.name !== ".git" && entry.name !== ".gradle" && entry.name !== ".harness" && entry.name !== "vendor" && entry.name !== "bin" && entry.name !== "obj" && entry.name !== "venv" && entry.name !== "_build" && entry.name !== "deps" && entry.name !== "coverage") {
         results.push(...await this.findMarkdownFiles(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         results.push(fullPath);
@@ -1498,9 +1849,176 @@ function parseFailureSection(section) {
   };
 }
 
-// src/ingest/RequirementIngestor.ts
+// src/ingest/BusinessKnowledgeIngestor.ts
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
+var BUSINESS_KNOWLEDGE_TYPES = /* @__PURE__ */ new Set([
+  "business_rule",
+  "business_process",
+  "business_concept",
+  "business_term",
+  "business_metric"
+]);
+var GOVERNS_SOURCE_TYPES = /* @__PURE__ */ new Set(["business_rule", "business_process"]);
+var CODE_NODE_TYPES2 = [
+  "file",
+  "function",
+  "class",
+  "method",
+  "interface",
+  "variable"
+];
+var MEASURABLE_TYPES = /* @__PURE__ */ new Set(["business_process", "business_concept"]);
+var BusinessKnowledgeIngestor = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async ingest(knowledgeDir) {
+    const start = Date.now();
+    const errors = [];
+    let files;
+    try {
+      files = await this.findMarkdownFiles(knowledgeDir);
+    } catch {
+      return emptyResult(Date.now() - start);
+    }
+    const nodeEntries = await this.createNodes(files, knowledgeDir, errors);
+    const edgesAdded = this.createEdges(nodeEntries);
+    return {
+      nodesAdded: nodeEntries.length,
+      nodesUpdated: 0,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  async createNodes(files, knowledgeDir, errors) {
+    const entries = [];
+    for (const filePath of files) {
+      try {
+        const entry = await this.parseAndAddNode(filePath, knowledgeDir);
+        if (entry) entries.push(entry);
+      } catch (err) {
+        errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return entries;
+  }
+  async parseAndAddNode(filePath, knowledgeDir) {
+    const raw = await fs3.readFile(filePath, "utf-8");
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) return null;
+    const { frontmatter, body } = parsed;
+    if (!BUSINESS_KNOWLEDGE_TYPES.has(frontmatter.type)) return null;
+    const relPath = path4.relative(knowledgeDir, filePath).replaceAll("\\", "/");
+    const domain = frontmatter.domain ?? relPath.split("/")[0] ?? "unknown";
+    const filename = path4.basename(filePath, ".md");
+    const nodeId = `bk:${domain}:${filename}`;
+    const titleMatch = body.match(/^#\s+(.+)$/m);
+    const name = titleMatch ? titleMatch[1].trim() : filename;
+    const node = {
+      id: nodeId,
+      type: frontmatter.type,
+      name,
+      path: relPath,
+      content: body.trim(),
+      metadata: {
+        domain,
+        ...frontmatter.tags && { tags: frontmatter.tags },
+        ...frontmatter.related && { related: frontmatter.related }
+      }
+    };
+    this.store.addNode(node);
+    return { nodeId, node, content: body };
+  }
+  createEdges(nodeEntries) {
+    let edgesAdded = 0;
+    for (const { nodeId, node, content } of nodeEntries) {
+      if (GOVERNS_SOURCE_TYPES.has(node.type)) {
+        edgesAdded += this.linkToNodes(content, nodeId, "governs", CODE_NODE_TYPES2);
+      } else {
+        edgesAdded += this.linkToNodes(content, nodeId, "documents", CODE_NODE_TYPES2);
+      }
+      if (node.type === "business_metric") {
+        edgesAdded += this.linkToBusinessNodes(content, nodeId, "measures", MEASURABLE_TYPES);
+      }
+    }
+    return edgesAdded;
+  }
+  linkToNodes(content, sourceNodeId, edgeType, targetTypes) {
+    let count = 0;
+    for (const nodeType of targetTypes) {
+      const nodes = this.store.findNodes({ type: nodeType });
+      for (const node of nodes) {
+        if (node.name.length < 3) continue;
+        const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
+        if (namePattern.test(content)) {
+          this.store.addEdge({ from: sourceNodeId, to: node.id, type: edgeType });
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  linkToBusinessNodes(content, sourceNodeId, edgeType, targetTypes) {
+    let count = 0;
+    for (const node of this.store.findNodes({})) {
+      if (!targetTypes.has(node.type)) continue;
+      if (node.name.length < 3) continue;
+      const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
+      if (namePattern.test(content)) {
+        this.store.addEdge({ from: sourceNodeId, to: node.id, type: edgeType });
+        count++;
+      }
+    }
+    return count;
+  }
+  async findMarkdownFiles(dir) {
+    const results = [];
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "target" && entry.name !== "build" && entry.name !== ".git" && entry.name !== ".gradle" && entry.name !== ".harness" && entry.name !== "vendor" && entry.name !== "bin" && entry.name !== "obj" && entry.name !== "venv" && entry.name !== "_build" && entry.name !== "deps" && entry.name !== "coverage") {
+        results.push(...await this.findMarkdownFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+};
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return null;
+  const yamlBlock = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  for (const line of yamlBlock.split("\n")) {
+    const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+    if (!kvMatch) continue;
+    const key = kvMatch[1];
+    const value = kvMatch[2].trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      frontmatter[key] = value.slice(1, -1).split(",").map((s) => s.trim());
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+  if (!frontmatter.type || typeof frontmatter.type !== "string") return null;
+  if (!frontmatter.domain || typeof frontmatter.domain !== "string") return null;
+  return {
+    frontmatter,
+    body
+  };
+}
+
+// src/ingest/RequirementIngestor.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
 var REQUIREMENT_SECTIONS = [
   "Observable Truths",
   "Success Criteria",
@@ -1517,7 +2035,7 @@ function detectEarsPattern(text) {
   if (/^the\s+\w+\s+shall\b/.test(lower)) return "ubiquitous";
   return void 0;
 }
-var CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
+var CODE_NODE_TYPES3 = ["file", "function", "class", "method", "interface", "variable"];
 var RequirementIngestor = class {
   constructor(store) {
     this.store = store;
@@ -1535,8 +2053,8 @@ var RequirementIngestor = class {
     let edgesAdded = 0;
     let featureDirs;
     try {
-      const entries = await fs3.readdir(specsDir, { withFileTypes: true });
-      featureDirs = entries.filter((e) => e.isDirectory()).map((e) => path4.join(specsDir, e.name));
+      const entries = await fs4.readdir(specsDir, { withFileTypes: true });
+      featureDirs = entries.filter((e) => e.isDirectory()).map((e) => path5.join(specsDir, e.name));
     } catch {
       return emptyResult(Date.now() - start);
     }
@@ -1555,11 +2073,11 @@ var RequirementIngestor = class {
     };
   }
   async ingestFeatureDir(featureDir, errors) {
-    const featureName = path4.basename(featureDir);
-    const specPath = path4.join(featureDir, "proposal.md").replaceAll("\\", "/");
+    const featureName = path5.basename(featureDir);
+    const specPath = path5.join(featureDir, "proposal.md").replaceAll("\\", "/");
     let content;
     try {
-      content = await fs3.readFile(specPath, "utf-8");
+      content = await fs4.readFile(specPath, "utf-8");
     } catch {
       return { nodesAdded: 0, edgesAdded: 0 };
     }
@@ -1576,7 +2094,7 @@ var RequirementIngestor = class {
     this.store.addNode({
       id: specNodeId,
       type: "document",
-      name: path4.basename(specPath),
+      name: path5.basename(specPath),
       path: specPath,
       metadata: { featureName }
     });
@@ -1691,9 +2209,9 @@ var RequirementIngestor = class {
     for (const node of fileNodes) {
       if (!node.path) continue;
       const normalizedPath = node.path.replace(/\\/g, "/");
-      const isCodeMatch = normalizedPath.includes("packages/") && path4.basename(normalizedPath).includes(featureName);
+      const isCodeMatch = normalizedPath.includes("packages/") && path5.basename(normalizedPath).includes(featureName);
       const isTestMatch = normalizedPath.includes("/tests/") && // platform-safe
-      path4.basename(normalizedPath).includes(featureName);
+      path5.basename(normalizedPath).includes(featureName);
       if (isCodeMatch && !isTestMatch) {
         this.store.addEdge({
           from: reqId,
@@ -1714,39 +2232,2676 @@ var RequirementIngestor = class {
         count++;
       }
     }
-    return count;
+    return count;
+  }
+  /**
+   * Convention-based linking: match requirement text to code nodes
+   * by keyword overlap (function/class names appearing in requirement text).
+   */
+  linkByKeywordOverlap(reqId, reqText) {
+    let count = 0;
+    for (const nodeType of CODE_NODE_TYPES3) {
+      const codeNodes = this.store.findNodes({ type: nodeType });
+      for (const node of codeNodes) {
+        if (node.name.length < 3) continue;
+        const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
+        if (namePattern.test(reqText)) {
+          const edgeType = node.path?.replace(/\\/g, "/").includes("/tests/") ? "verified_by" : "requires";
+          this.store.addEdge({
+            from: reqId,
+            to: node.id,
+            type: edgeType,
+            confidence: 0.6,
+            metadata: { method: "convention", matchReason: "keyword-overlap" }
+          });
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+};
+
+// src/ingest/KnowledgePipelineRunner.ts
+import * as fs9 from "fs/promises";
+import * as path10 from "path";
+
+// src/ingest/DiagramParser.ts
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
+function emptyMermaidResult(diagramType = "unknown") {
+  return {
+    entities: [],
+    relationships: [],
+    metadata: { format: "mermaid", diagramType }
+  };
+}
+var MermaidParser = class {
+  canParse(_content, ext) {
+    return ext === ".mmd" || ext === ".mermaid";
+  }
+  parse(content, _filePath) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return emptyMermaidResult();
+    }
+    const diagramType = this.detectDiagramType(trimmed);
+    switch (diagramType) {
+      case "flowchart":
+        return this.parseFlowchart(trimmed, diagramType);
+      case "sequence":
+        return this.parseSequence(trimmed, diagramType);
+      default:
+        return emptyMermaidResult(diagramType);
+    }
+  }
+  detectDiagramType(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) continue;
+      if (/^(?:graph|flowchart)\b/i.test(trimmedLine)) return "flowchart";
+      if (/^sequenceDiagram\b/.test(trimmedLine)) return "sequence";
+      if (/^classDiagram\b/.test(trimmedLine)) return "class";
+      if (/^erDiagram\b/.test(trimmedLine)) return "er";
+      break;
+    }
+    return "unknown";
+  }
+  parseFlowchart(content, diagramType) {
+    const entities = /* @__PURE__ */ new Map();
+    const relationships = [];
+    const nodeRegex = /([A-Za-z0-9_]+)\s*[[({]([^\])}]+)[\])}]/g;
+    let match;
+    match = nodeRegex.exec(content);
+    while (match !== null) {
+      const id = match[1] ?? "";
+      const label = (match[2] ?? "").trim();
+      if (id && !entities.has(id)) {
+        const isDecision = this.isDecisionNode(content, id);
+        entities.set(id, {
+          id,
+          label,
+          ...isDecision ? { type: "decision" } : {}
+        });
+      }
+      match = nodeRegex.exec(content);
+    }
+    const stripped = content.replace(/[[({][^\])}]*[\])}]/g, "");
+    const labeledEdgeRegex = /([A-Za-z0-9_]+)\s*--+>?\|([^|]+)\|\s*([A-Za-z0-9_]+)/g;
+    const unlabeledEdgeRegex = /([A-Za-z0-9_]+)\s*--+>?\s+([A-Za-z0-9_]+)/g;
+    const edgeKeys = /* @__PURE__ */ new Set();
+    match = labeledEdgeRegex.exec(stripped);
+    while (match !== null) {
+      const from = match[1] ?? "";
+      const label = (match[2] ?? "").trim();
+      const to = match[3] ?? "";
+      if (from && to) {
+        const key = `${from}->${to}:${label}`;
+        if (!edgeKeys.has(key)) {
+          edgeKeys.add(key);
+          relationships.push({ from, to, label });
+        }
+      }
+      match = labeledEdgeRegex.exec(stripped);
+    }
+    match = unlabeledEdgeRegex.exec(stripped);
+    while (match !== null) {
+      const from = match[1] ?? "";
+      const to = match[2] ?? "";
+      if (from && to) {
+        const hasLabeled = relationships.some((r) => r.from === from && r.to === to);
+        if (!hasLabeled) {
+          const key = `${from}->${to}`;
+          if (!edgeKeys.has(key)) {
+            edgeKeys.add(key);
+            relationships.push({ from, to });
+          }
+        }
+      }
+      match = unlabeledEdgeRegex.exec(stripped);
+    }
+    return {
+      entities: Array.from(entities.values()),
+      relationships,
+      metadata: { format: "mermaid", diagramType }
+    };
+  }
+  isDecisionNode(content, nodeId) {
+    const decisionRegex = new RegExp(`${nodeId}\\s*\\{`);
+    return decisionRegex.test(content);
+  }
+  parseSequence(content, diagramType) {
+    const entities = [];
+    const relationships = [];
+    const seenParticipants = /* @__PURE__ */ new Set();
+    const participantRegex = /participant\s+(\w+)(?:\s+as\s+(.+))?/g;
+    let match;
+    match = participantRegex.exec(content);
+    while (match !== null) {
+      const id = match[1] ?? "";
+      const label = match[2]?.trim() || id;
+      if (id && !seenParticipants.has(id)) {
+        seenParticipants.add(id);
+        entities.push({ id, label });
+      }
+      match = participantRegex.exec(content);
+    }
+    const forwardMsgRegex = /(\w+)\s*->>?\+?\s*(\w+)\s*:\s*(.+)/g;
+    match = forwardMsgRegex.exec(content);
+    while (match !== null) {
+      const from = match[1] ?? "";
+      const to = match[2] ?? "";
+      const label = (match[3] ?? "").trim();
+      if (from && to) {
+        relationships.push({ from, to, label });
+      }
+      match = forwardMsgRegex.exec(content);
+    }
+    const returnMsgRegex = /(\w+)\s*-->>?-?\s*(\w+)\s*:\s*(.+)/g;
+    match = returnMsgRegex.exec(content);
+    while (match !== null) {
+      const from = match[1] ?? "";
+      const to = match[2] ?? "";
+      const label = (match[3] ?? "").trim();
+      if (from && to) {
+        relationships.push({ from, to, label });
+      }
+      match = returnMsgRegex.exec(content);
+    }
+    return {
+      entities,
+      relationships,
+      metadata: { format: "mermaid", diagramType }
+    };
+  }
+};
+var D2Parser = class {
+  canParse(_content, ext) {
+    return ext === ".d2";
+  }
+  parse(content, _filePath) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return {
+        entities: [],
+        relationships: [],
+        metadata: { format: "d2", diagramType: "architecture" }
+      };
+    }
+    const entities = /* @__PURE__ */ new Map();
+    const relationships = [];
+    let braceDepth = 0;
+    for (const line of trimmed.split("\n")) {
+      const stripped = line.trim();
+      if (!stripped || stripped.startsWith("#")) continue;
+      if (stripped.endsWith("{")) {
+        if (braceDepth === 0) {
+          const shapeMatch = stripped.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.+?)\s*\{$/);
+          if (shapeMatch) {
+            const id = shapeMatch[1];
+            const label = shapeMatch[2];
+            if (id && label) {
+              entities.set(id, { id, label });
+            }
+          }
+        }
+        braceDepth++;
+        continue;
+      }
+      if (stripped === "}") {
+        braceDepth = Math.max(0, braceDepth - 1);
+        continue;
+      }
+      if (braceDepth > 0) continue;
+      const connMatch = stripped.match(
+        /^([a-zA-Z0-9_.-]+)\s*->\s*([a-zA-Z0-9_.-]+)(?:\s*:\s*(.+?))?$/
+      );
+      if (connMatch) {
+        const from = connMatch[1] ?? "";
+        const to = connMatch[2] ?? "";
+        const label = connMatch[3]?.trim();
+        if (from && to) {
+          relationships.push({ from, to, ...label ? { label } : {} });
+        }
+        continue;
+      }
+      const simpleMatch = stripped.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.+)$/);
+      if (simpleMatch) {
+        const id = simpleMatch[1];
+        const label = (simpleMatch[2] ?? "").trim();
+        if (id && label && !entities.has(id)) {
+          entities.set(id, { id, label });
+        }
+      }
+    }
+    return {
+      entities: Array.from(entities.values()),
+      relationships,
+      metadata: { format: "d2", diagramType: "architecture" }
+    };
+  }
+};
+var PlantUmlParser = class {
+  canParse(_content, ext) {
+    return ext === ".puml" || ext === ".plantuml";
+  }
+  parse(content, _filePath) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+      return {
+        entities: [],
+        relationships: [],
+        metadata: { format: "plantuml", diagramType: "unknown" }
+      };
+    }
+    const diagramType = this.detectDiagramType(trimmed);
+    const entities = /* @__PURE__ */ new Map();
+    const relationships = [];
+    const body = trimmed.replace(/@startuml\b.*\n?/, "").replace(/@enduml\b.*/, "").trim();
+    const classRegex = /class\s+(\w+)/g;
+    let match;
+    match = classRegex.exec(body);
+    while (match !== null) {
+      const id = match[1] ?? "";
+      if (id && !entities.has(id)) {
+        entities.set(id, { id, label: id });
+      }
+      match = classRegex.exec(body);
+    }
+    const componentRegex1 = /\[([^\]]+)\]/g;
+    match = componentRegex1.exec(body);
+    while (match !== null) {
+      const label = (match[1] ?? "").trim();
+      if (label) {
+        const id = label.replace(/\s+/g, "_");
+        if (!entities.has(id)) {
+          entities.set(id, { id, label });
+        }
+      }
+      match = componentRegex1.exec(body);
+    }
+    const relRegex = /(\w+)\s*(?:-->|->|<--|<-|\.\.>|--)\s*(\w+)(?:\s*:\s*(.+))?/g;
+    match = relRegex.exec(body);
+    while (match !== null) {
+      const from = match[1] ?? "";
+      const to = match[2] ?? "";
+      const label = match[3]?.trim();
+      if (from && to) {
+        relationships.push({ from, to, ...label ? { label } : {} });
+      }
+      match = relRegex.exec(body);
+    }
+    return {
+      entities: Array.from(entities.values()),
+      relationships,
+      metadata: { format: "plantuml", diagramType }
+    };
+  }
+  detectDiagramType(content) {
+    if (/class\s+\w+/.test(content)) return "class";
+    if (/\[.+\]/.test(content) || /component\s+/.test(content)) return "component";
+    if (/participant\s+/.test(content) || /actor\s+/.test(content)) return "sequence";
+    return "unknown";
+  }
+};
+var DIAGRAM_EXTENSIONS = /* @__PURE__ */ new Set([".mmd", ".mermaid", ".d2", ".puml", ".plantuml"]);
+var DiagramParser = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  parsers = [
+    new MermaidParser(),
+    new D2Parser(),
+    new PlantUmlParser()
+  ];
+  parse(content, filePath) {
+    const ext = path6.extname(filePath).toLowerCase();
+    for (const parser of this.parsers) {
+      if (parser.canParse(content, ext)) {
+        return parser.parse(content, filePath);
+      }
+    }
+    return {
+      entities: [],
+      relationships: [],
+      metadata: { format: "mermaid", diagramType: "unknown" }
+    };
+  }
+  async ingest(projectDir) {
+    const start = Date.now();
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const errors = [];
+    const diagramFiles = await this.findDiagramFiles(projectDir);
+    for (const filePath of diagramFiles) {
+      try {
+        const content = await fs5.readFile(filePath, "utf-8");
+        const relPath = path6.relative(projectDir, filePath).replaceAll("\\", "/");
+        const result = this.parse(content, filePath);
+        if (result.entities.length === 0) continue;
+        const pathHash = hash(relPath);
+        for (const entity of result.entities) {
+          const nodeId = `diagram:${pathHash}:${entity.id}`;
+          this.store.addNode({
+            id: nodeId,
+            type: "business_concept",
+            name: entity.label,
+            path: relPath,
+            metadata: {
+              source: "diagram",
+              format: result.metadata.format,
+              diagramType: result.metadata.diagramType,
+              confidence: 0.85,
+              ...entity.type ? { entityType: entity.type } : {}
+            }
+          });
+          nodesAdded++;
+        }
+        for (const rel of result.relationships) {
+          const fromId = `diagram:${pathHash}:${rel.from}`;
+          const toId = `diagram:${pathHash}:${rel.to}`;
+          this.store.addEdge({
+            from: fromId,
+            to: toId,
+            type: "references",
+            metadata: {
+              ...rel.label ? { label: rel.label } : {}
+            }
+          });
+          edgesAdded++;
+        }
+      } catch (err) {
+        errors.push(
+          `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  async findDiagramFiles(dir) {
+    const files = [];
+    const SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".harness"]);
+    const walk = async (currentDir) => {
+      let entries;
+      try {
+        entries = await fs5.readdir(currentDir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS2.has(entry.name)) {
+            await walk(path6.join(currentDir, entry.name));
+          }
+        } else if (entry.isFile()) {
+          const ext = path6.extname(entry.name).toLowerCase();
+          if (DIAGRAM_EXTENSIONS.has(ext)) {
+            files.push(path6.join(currentDir, entry.name));
+          }
+        }
+      }
+    };
+    await walk(dir);
+    return files;
+  }
+};
+
+// src/ingest/KnowledgeLinker.ts
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
+var HEURISTIC_PATTERNS = [
+  {
+    name: "business-rule-imperative",
+    pattern: /\b(?:must|shall|required)\b.*\b(?:system|service|api|user|data|app|application|client|server|process|handler|module)\b/i,
+    signal: "Business rule",
+    confidence: 0.7,
+    nodeType: "business_fact"
+  },
+  {
+    name: "sla-slo-pattern",
+    pattern: /(?:\b\d+(?:\.\d+)?%\s*(?:availability|uptime|success\s*rate)|\bunder\s+\d+\s*(?:ms|seconds?|minutes?|hours?)\b|\b(?:SLA|SLO)\b|\b99(?:\.\d+)?%\b)/i,
+    signal: "Business constraint (SLA/SLO)",
+    confidence: 0.8,
+    nodeType: "business_fact"
+  },
+  {
+    name: "monetary-amount",
+    pattern: /\$[\d,]+(?:\.\d{2})?\s*(?:\b(?:cost|revenue|budget|price|fee|license|subscription|annual|monthly)\b)?/i,
+    signal: "Business fact (monetary)",
+    confidence: 0.6,
+    nodeType: "business_fact"
+  },
+  {
+    name: "acceptance-criteria",
+    pattern: /\b(?:Given\b.*\bWhen\b.*\bThen\b|\[[ x]\])/i,
+    signal: "Business rule (acceptance criteria)",
+    confidence: 0.8,
+    nodeType: "business_fact"
+  },
+  {
+    name: "regulatory-reference",
+    pattern: /\b(?:GDPR|SOC\s*2|PCI(?:\s*-?\s*DSS)?|HIPAA|CCPA|FERPA|SOX)\b/i,
+    signal: "Business rule (regulatory)",
+    confidence: 0.9,
+    nodeType: "business_fact"
+  }
+];
+var SCANNABLE_TYPES = ["issue", "conversation", "document"];
+function applyReactionBoost(candidate, nodeType, metadata) {
+  if (nodeType !== "conversation" || !metadata.reactions) return;
+  const reactions = metadata.reactions;
+  const totalReactions = Object.values(reactions).reduce((sum, count) => sum + count, 0);
+  if (totalReactions > 0) {
+    candidate.confidence = Math.min(1, Math.round((candidate.confidence + 0.1) * 100) / 100);
+  }
+}
+var KnowledgeLinker = class {
+  constructor(store, outputDir) {
+    this.store = store;
+    this.outputDir = outputDir;
+  }
+  store;
+  outputDir;
+  async link() {
+    const errors = [];
+    const candidates = this.scanAllNodes(errors);
+    await this.writeJsonl(candidates);
+    const conceptsClustered = this.clusterBySource(candidates);
+    const promoted = this.promoteAndDeduplicate(candidates);
+    await this.writeStagedJsonl(promoted.staged);
+    return {
+      factsCreated: promoted.factsCreated,
+      conceptsClustered,
+      duplicatesMerged: promoted.duplicatesMerged,
+      stagedForReview: promoted.staged.length,
+      errors
+    };
+  }
+  /** Stage 1: Scan all scannable node types for heuristic pattern matches. */
+  scanAllNodes(errors) {
+    const candidates = [];
+    for (const type of SCANNABLE_TYPES) {
+      const nodes = this.store.findNodes({ type });
+      for (const node of nodes) {
+        if (!node.content) continue;
+        try {
+          const matches = this.scanPatterns(node.content, node.id, type);
+          for (const match of matches) {
+            applyReactionBoost(match, type, node.metadata);
+            candidates.push(match);
+          }
+        } catch (err) {
+          errors.push(
+            `Scan failed for ${node.id}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+    return candidates;
+  }
+  /** Stage 2: Group candidates by source node and create business_concept for 3+. */
+  clusterBySource(candidates) {
+    const sourceGroups = /* @__PURE__ */ new Map();
+    for (const candidate of candidates) {
+      const group = sourceGroups.get(candidate.sourceNodeId) ?? [];
+      group.push(candidate);
+      sourceGroups.set(candidate.sourceNodeId, group);
+    }
+    let clustered = 0;
+    for (const [sourceNodeId, group] of sourceGroups) {
+      if (group.length >= 3) {
+        this.store.addNode({
+          id: `concept:linker:${hash(sourceNodeId)}`,
+          type: "business_concept",
+          name: `Business concept cluster from ${sourceNodeId}`,
+          metadata: {
+            source: "knowledge-linker",
+            sources: [sourceNodeId],
+            factCount: group.length
+          }
+        });
+        clustered++;
+      }
+    }
+    return clustered;
+  }
+  /** Stage 3: Promote high-confidence candidates, stage medium, discard low. */
+  promoteAndDeduplicate(candidates) {
+    let factsCreated = 0;
+    let duplicatesMerged = 0;
+    const staged = [];
+    for (const candidate of candidates) {
+      if (candidate.confidence >= 0.8) {
+        const merged = this.tryMergeDuplicate(candidate);
+        if (merged) {
+          duplicatesMerged++;
+          continue;
+        }
+        this.createFactNode(candidate);
+        factsCreated++;
+      } else if (candidate.confidence >= 0.5) {
+        staged.push(candidate);
+      }
+    }
+    return { factsCreated, duplicatesMerged, staged };
+  }
+  /** Check for existing duplicate fact and merge sources if found. Returns true if merged. */
+  tryMergeDuplicate(candidate) {
+    if (this.store.getNode(candidate.id)) return true;
+    const existingFacts = this.store.findNodes({ type: "business_fact" });
+    const duplicate = existingFacts.find(
+      (f) => f.content === candidate.content && f.id !== candidate.id
+    );
+    if (!duplicate) return false;
+    const existingSources = duplicate.metadata.sources ?? [];
+    if (!existingSources.includes(candidate.sourceNodeId)) {
+      existingSources.push(candidate.sourceNodeId);
+      duplicate.metadata.sources = existingSources;
+    }
+    return true;
+  }
+  /** Create a business_fact node and governs edge for a promoted candidate. */
+  createFactNode(candidate) {
+    this.store.addNode({
+      id: candidate.id,
+      type: candidate.nodeType,
+      name: candidate.name,
+      content: candidate.content,
+      metadata: {
+        source: "knowledge-linker",
+        pattern: candidate.pattern,
+        signal: candidate.signal,
+        confidence: candidate.confidence,
+        sourceNodeId: candidate.sourceNodeId,
+        sourceNodeType: candidate.sourceNodeType,
+        sources: [candidate.sourceNodeId]
+      }
+    });
+    this.store.addEdge({
+      from: candidate.id,
+      to: candidate.sourceNodeId,
+      type: "governs",
+      confidence: candidate.confidence,
+      metadata: { source: "knowledge-linker" }
+    });
+  }
+  /**
+   * Write candidates to JSONL file for audit trail.
+   */
+  async writeJsonl(candidates) {
+    if (!this.outputDir) return;
+    await fs6.mkdir(this.outputDir, { recursive: true });
+    const filePath = path7.join(this.outputDir, "linker.jsonl");
+    const lines = candidates.map(
+      (c) => JSON.stringify({
+        id: c.id,
+        sourceNodeId: c.sourceNodeId,
+        sourceNodeType: c.sourceNodeType,
+        name: c.name,
+        confidence: c.confidence,
+        pattern: c.pattern,
+        signal: c.signal,
+        nodeType: c.nodeType
+      })
+    );
+    await fs6.writeFile(filePath, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+  }
+  /**
+   * Write medium-confidence candidates to staged JSONL for human review.
+   */
+  async writeStagedJsonl(candidates) {
+    if (!this.outputDir || candidates.length === 0) return;
+    const stagedDir = path7.join(this.outputDir, "staged");
+    await fs6.mkdir(stagedDir, { recursive: true });
+    const filePath = path7.join(stagedDir, "linker-staged.jsonl");
+    const lines = candidates.map(
+      (c) => JSON.stringify({
+        id: c.id,
+        sourceNodeId: c.sourceNodeId,
+        sourceNodeType: c.sourceNodeType,
+        name: c.name,
+        confidence: c.confidence,
+        pattern: c.pattern,
+        signal: c.signal,
+        nodeType: c.nodeType
+      })
+    );
+    await fs6.writeFile(filePath, lines.join("\n") + "\n");
+  }
+  /**
+   * Apply heuristic patterns to content and return candidate extractions.
+   */
+  scanPatterns(content, nodeId, nodeType) {
+    const candidates = [];
+    for (const heuristic of HEURISTIC_PATTERNS) {
+      if (heuristic.pattern.test(content)) {
+        const candidateId = `extracted:linker:${hash(nodeId + ":" + heuristic.name)}`;
+        candidates.push({
+          id: candidateId,
+          sourceNodeId: nodeId,
+          sourceNodeType: nodeType,
+          name: `${heuristic.signal} from ${nodeId}`,
+          content,
+          confidence: heuristic.confidence,
+          pattern: heuristic.name,
+          signal: heuristic.signal,
+          nodeType: heuristic.nodeType
+        });
+      }
+    }
+    return candidates;
+  }
+};
+
+// src/ingest/StructuralDriftDetector.ts
+var StructuralDriftDetector = class {
+  detect(current, fresh) {
+    const findings = [];
+    const currentById = new Map(current.entries.map((e) => [e.id, e]));
+    const freshById = new Map(fresh.entries.map((e) => [e.id, e]));
+    for (const [id, entry] of freshById) {
+      if (!currentById.has(id)) {
+        findings.push({
+          entryId: id,
+          classification: "new",
+          fresh: entry,
+          severity: "low"
+        });
+      }
+    }
+    for (const [id, entry] of currentById) {
+      if (!freshById.has(id)) {
+        findings.push({
+          entryId: id,
+          classification: "stale",
+          current: entry,
+          severity: "high"
+        });
+      }
+    }
+    for (const [id, freshEntry] of freshById) {
+      const currentEntry = currentById.get(id);
+      if (currentEntry && currentEntry.contentHash !== freshEntry.contentHash) {
+        findings.push({
+          entryId: id,
+          classification: "drifted",
+          current: currentEntry,
+          fresh: freshEntry,
+          severity: "medium"
+        });
+      }
+    }
+    const byName = /* @__PURE__ */ new Map();
+    for (const entry of fresh.entries) {
+      const group = byName.get(entry.name) ?? [];
+      group.push(entry);
+      byName.set(entry.name, group);
+    }
+    for (const [, group] of byName) {
+      if (group.length > 1) {
+        const sources = new Set(group.map((e) => e.source));
+        const hashes = new Set(group.map((e) => e.contentHash));
+        if (sources.size > 1 && hashes.size > 1) {
+          const alreadyContradicting = new Set(
+            findings.filter((f) => f.classification === "contradicting").map((f) => f.entryId)
+          );
+          for (const entry of group) {
+            if (!alreadyContradicting.has(entry.id)) {
+              findings.push({
+                entryId: entry.id,
+                classification: "contradicting",
+                fresh: entry,
+                severity: "critical"
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+    const totalEntries = (/* @__PURE__ */ new Set([...currentById.keys(), ...freshById.keys()])).size;
+    const driftScore = totalEntries > 0 ? findings.length / totalEntries : 0;
+    const summary = {
+      new: findings.filter((f) => f.classification === "new").length,
+      drifted: findings.filter((f) => f.classification === "drifted").length,
+      stale: findings.filter((f) => f.classification === "stale").length,
+      contradicting: findings.filter((f) => f.classification === "contradicting").length
+    };
+    return { findings, driftScore, summary };
+  }
+};
+
+// src/ingest/KnowledgeStagingAggregator.ts
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
+var KnowledgeStagingAggregator = class {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+  }
+  projectDir;
+  async aggregate(extractorResults, linkerResults, diagramResults) {
+    const all = [...extractorResults, ...linkerResults, ...diagramResults];
+    const byHash = /* @__PURE__ */ new Map();
+    for (const entry of all) {
+      const existing = byHash.get(entry.contentHash);
+      if (!existing || entry.confidence > existing.confidence) {
+        byHash.set(entry.contentHash, entry);
+      }
+    }
+    const deduplicated = Array.from(byHash.values());
+    if (deduplicated.length === 0) {
+      return { staged: 0 };
+    }
+    const stagedDir = path8.join(this.projectDir, ".harness", "knowledge", "staged");
+    await fs7.mkdir(stagedDir, { recursive: true });
+    const jsonl = deduplicated.map((entry) => JSON.stringify(entry)).join("\n") + "\n";
+    await fs7.writeFile(path8.join(stagedDir, "pipeline-staged.jsonl"), jsonl, "utf-8");
+    return { staged: deduplicated.length };
+  }
+  async generateGapReport(knowledgeDir) {
+    const domains = [];
+    let totalEntries = 0;
+    try {
+      const entries = await fs7.readdir(knowledgeDir, { withFileTypes: true });
+      const domainDirs = entries.filter((e) => e.isDirectory());
+      for (const dir of domainDirs) {
+        const domainPath = path8.join(knowledgeDir, dir.name);
+        const files = await fs7.readdir(domainPath);
+        const mdFiles = files.filter((f) => f.endsWith(".md"));
+        const entryCount = mdFiles.length;
+        totalEntries += entryCount;
+        domains.push({ domain: dir.name, entryCount });
+      }
+    } catch {
+    }
+    return {
+      domains,
+      totalEntries,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async writeGapReport(report) {
+    const gapsDir = path8.join(this.projectDir, ".harness", "knowledge");
+    await fs7.mkdir(gapsDir, { recursive: true });
+    const lines = [
+      "# Knowledge Gaps Report",
+      "",
+      `Generated: ${report.generatedAt}`,
+      "",
+      "## Coverage by Domain",
+      "",
+      "| Domain | Entries |",
+      "| ------ | ------- |"
+    ];
+    for (const domain of report.domains) {
+      lines.push(`| ${domain.domain} | ${domain.entryCount} |`);
+    }
+    lines.push("", `## Total Entries: ${report.totalEntries}`, "");
+    await fs7.writeFile(path8.join(gapsDir, "gaps.md"), lines.join("\n"), "utf-8");
+  }
+};
+
+// src/ingest/extractors/ExtractionRunner.ts
+import * as fs8 from "fs/promises";
+import * as path9 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "target",
+  "build",
+  ".git",
+  "__pycache__",
+  ".venv",
+  ".turbo",
+  ".harness",
+  ".next",
+  ".vscode",
+  ".idea",
+  "vendor",
+  "out",
+  ".gradle",
+  ".gradle-home",
+  "bin",
+  "obj",
+  "venv",
+  "_build",
+  "deps",
+  "coverage",
+  ".nyc_output"
+]);
+var EXT_TO_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java"
+};
+var SKIP_EXTENSIONS2 = /* @__PURE__ */ new Set([".d.ts"]);
+function detectLanguage(filePath) {
+  const name = path9.basename(filePath);
+  for (const skip of SKIP_EXTENSIONS2) {
+    if (name.endsWith(skip)) return void 0;
+  }
+  const ext = path9.extname(filePath);
+  return EXT_TO_LANGUAGE[ext];
+}
+var EXTRACTOR_EDGE_TYPE = {
+  "test-descriptions": "governs",
+  "enum-constants": "documents",
+  "validation-rules": "governs",
+  "api-paths": "documents"
+};
+var ExtractionRunner = class {
+  constructor(extractors) {
+    this.extractors = extractors;
+  }
+  extractors;
+  /**
+   * Run all extractors against a project directory.
+   * @param projectDir - Project root directory
+   * @param store - GraphStore for node/edge persistence
+   * @param outputDir - Directory for JSONL output (e.g. .harness/knowledge/extracted/)
+   */
+  async run(projectDir, store, outputDir) {
+    const start = Date.now();
+    const errors = [];
+    let nodesAdded = 0;
+    let nodesUpdated = 0;
+    let edgesAdded = 0;
+    await fs8.mkdir(outputDir, { recursive: true });
+    const files = await this.findSourceFiles(projectDir);
+    const recordsByExtractor = /* @__PURE__ */ new Map();
+    for (const ext of this.extractors) {
+      recordsByExtractor.set(ext.name, []);
+    }
+    for (const filePath of files) {
+      const language = detectLanguage(filePath);
+      if (!language) continue;
+      const ext = path9.extname(filePath);
+      let content;
+      try {
+        content = await fs8.readFile(filePath, "utf-8");
+      } catch (err) {
+        errors.push(
+          `Failed to read ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        continue;
+      }
+      const relativePath = path9.relative(projectDir, filePath).replaceAll("\\", "/");
+      for (const extractor2 of this.extractors) {
+        if (!extractor2.supportedExtensions.includes(ext)) continue;
+        try {
+          const records = extractor2.extract(content, relativePath, language);
+          recordsByExtractor.get(extractor2.name).push(...records);
+        } catch (err) {
+          errors.push(
+            `Extractor ${extractor2.name} failed on ${relativePath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+    const allCurrentIds = /* @__PURE__ */ new Set();
+    for (const [extractorName, records] of recordsByExtractor) {
+      await this.writeJsonl(records, outputDir, extractorName);
+      for (const record of records) {
+        allCurrentIds.add(record.id);
+        const result = this.persistRecord(record, store);
+        nodesAdded += result.nodesAdded;
+        nodesUpdated += result.nodesUpdated;
+        edgesAdded += result.edgesAdded;
+      }
+    }
+    const staleCount = this.markStale(store, allCurrentIds);
+    nodesUpdated += staleCount;
+    return {
+      nodesAdded,
+      nodesUpdated,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  /** Write extraction records to JSONL file. */
+  async writeJsonl(records, outputDir, extractorName) {
+    const filePath = path9.join(outputDir, `${extractorName}.jsonl`);
+    const lines = records.map((r) => JSON.stringify(r));
+    await fs8.writeFile(filePath, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+  }
+  /** Create or update a graph node from an extraction record. */
+  persistRecord(record, store) {
+    const existing = store.getNode(record.id);
+    const node = {
+      id: record.id,
+      type: record.nodeType,
+      name: record.name,
+      path: record.filePath,
+      location: {
+        fileId: `file:${hash(record.filePath)}`,
+        startLine: record.line,
+        endLine: record.line
+      },
+      content: record.content,
+      metadata: {
+        ...record.metadata,
+        source: "code-extractor",
+        extractor: record.extractor,
+        confidence: record.confidence,
+        language: record.language,
+        stale: false
+      }
+    };
+    store.addNode(node);
+    const fileNodeId = `file:${hash(record.filePath)}`;
+    const edgeType = EXTRACTOR_EDGE_TYPE[record.extractor] ?? "documents";
+    const edge = {
+      from: record.id,
+      to: fileNodeId,
+      type: edgeType,
+      confidence: record.confidence,
+      metadata: { source: "code-extractor" }
+    };
+    store.addEdge(edge);
+    return {
+      nodesAdded: existing ? 0 : 1,
+      nodesUpdated: existing ? 1 : 0,
+      edgesAdded: existing ? 0 : 1
+    };
+  }
+  /**
+   * Mark nodes from previous extractions that are no longer present as stale.
+   * Returns the number of nodes marked stale.
+   */
+  markStale(store, currentIds) {
+    let count = 0;
+    const businessTypes = ["business_rule", "business_process", "business_term"];
+    for (const type of businessTypes) {
+      const nodes = store.findNodes({ type });
+      for (const node of nodes) {
+        if (node.metadata.source === "code-extractor" && !node.metadata.stale && !currentIds.has(node.id)) {
+          store.addNode({
+            ...node,
+            metadata: {
+              ...node.metadata,
+              stale: true,
+              staleAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  /** Recursively find source files, skipping common non-source directories. */
+  async findSourceFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+      entries = await fs8.readdir(dir, { withFileTypes: true });
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const fullPath = path9.join(dir, entry.name);
+      if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+        results.push(...await this.findSourceFiles(fullPath));
+      } else if (entry.isFile() && detectLanguage(fullPath) !== void 0) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+};
+
+// src/ingest/extractors/TestDescriptionExtractor.ts
+var PATTERNS = {
+  typescript: [/(?:describe|it|test)\s*\(\s*(['"`])((?:(?!\1).)*)\1/g],
+  javascript: [/(?:describe|it|test)\s*\(\s*(['"`])((?:(?!\1).)*)\1/g],
+  python: [/def\s+(test_\w+)\s*\(/g, /"""((?:(?!""").)*?)"""/gs, /class\s+(Test\w+)/g],
+  go: [/func\s+(Test\w+)\s*\(/g, /t\.Run\(\s*"([^"]+)"/g],
+  rust: [/#\[test\]\s*\n\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/g, /\/\/\/\s*(.+)/g],
+  java: [
+    /@DisplayName\s*\(\s*"([^"]+)"\s*\)/g,
+    /@Test\s*\n\s*(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:void|[\w<>]+)\s+(\w+)\s*\(/g
+  ]
+};
+var TestDescriptionExtractor = class {
+  name = "test-descriptions";
+  supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
+  extract(content, filePath, language) {
+    const records = [];
+    const patterns = PATTERNS[language];
+    if (!patterns) return records;
+    const lines = content.split("\n");
+    if (language === "typescript" || language === "javascript") {
+      return this.extractJsTs(content, filePath, language, lines);
+    }
+    if (language === "python") {
+      return this.extractPython(content, filePath, language, lines);
+    }
+    if (language === "go") {
+      return this.extractGo(content, filePath, language, lines);
+    }
+    if (language === "rust") {
+      return this.extractRust(content, filePath, language, lines);
+    }
+    if (language === "java") {
+      return this.extractJava(content, filePath, language, lines);
+    }
+    return records;
+  }
+  extractJsTs(_content, filePath, language, lines) {
+    const records = [];
+    const describeStack = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const describeMatch = line.match(/describe\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
+      if (describeMatch) {
+        describeStack.push(describeMatch[2]);
+      }
+      const itMatch = line.match(/(?:it|test)\s*\(\s*(['"`])((?:(?!\1).)*)\1/);
+      if (itMatch) {
+        const testName = itMatch[2];
+        const fullPath = [...describeStack, testName].join(" > ");
+        const patternKey = fullPath;
+        records.push({
+          id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+          extractor: "test-descriptions",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: testName,
+          content: fullPath,
+          confidence: 0.7,
+          metadata: {
+            suite: describeStack.length > 0 ? describeStack[describeStack.length - 1] : void 0,
+            framework: "vitest"
+          }
+        });
+      }
+      if (line.match(/^\s*\}\s*\)\s*;?\s*$/) && describeStack.length > 0) {
+        describeStack.pop();
+      }
+    }
+    return records;
+  }
+  extractPython(_content, filePath, language, lines) {
+    const records = [];
+    let currentClass;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const classMatch = line.match(/^class\s+(Test\w+)/);
+      if (classMatch) {
+        currentClass = classMatch[1];
+      }
+      const funcMatch = line.match(/^\s*def\s+(test_\w+)\s*\(/);
+      if (funcMatch) {
+        const testName = funcMatch[1];
+        const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
+        let docstring;
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1].trim();
+          const docMatch = nextLine.match(/^"""(.+?)"""/);
+          if (docMatch) {
+            docstring = docMatch[1];
+          }
+        }
+        const patternKey = currentClass ? `${currentClass}.${testName}` : testName;
+        records.push({
+          id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+          extractor: "test-descriptions",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: docstring ?? humanName,
+          content: patternKey,
+          confidence: docstring ? 0.7 : 0.5,
+          metadata: {
+            suite: currentClass,
+            framework: "pytest",
+            functionName: testName
+          }
+        });
+      }
+      if (currentClass && /^\S/.test(line) && !line.startsWith("class ") && !line.startsWith("#") && line.trim() !== "") {
+        currentClass = void 0;
+      }
+    }
+    return records;
+  }
+  extractGo(_content, filePath, language, lines) {
+    const records = [];
+    let currentTest;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const funcMatch = line.match(/^func\s+(Test\w+)\s*\(/);
+      if (funcMatch) {
+        currentTest = funcMatch[1];
+        const humanName = currentTest.replace(/^Test/, "").replace(/([A-Z])/g, " $1").trim();
+        records.push({
+          id: `extracted:test-descriptions:${hash(filePath + ":" + currentTest)}`,
+          extractor: "test-descriptions",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: humanName,
+          content: currentTest,
+          confidence: 0.5,
+          metadata: { framework: "testing" }
+        });
+      }
+      const runMatch = line.match(/t\.Run\(\s*"([^"]+)"/);
+      if (runMatch && currentTest) {
+        const subtestName = runMatch[1];
+        const patternKey = `${currentTest} > ${subtestName}`;
+        records.push({
+          id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+          extractor: "test-descriptions",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: subtestName,
+          content: patternKey,
+          confidence: 0.7,
+          metadata: {
+            suite: currentTest,
+            framework: "testing"
+          }
+        });
+      }
+    }
+    return records;
+  }
+  extractRust(_content, filePath, language, lines) {
+    const records = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "#[test]") {
+        for (let j = i + 1; j < lines.length && j <= i + 3; j++) {
+          const fnLine = lines[j];
+          const fnMatch = fnLine.match(/(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+          if (fnMatch) {
+            const testName = fnMatch[1];
+            const humanName = testName.replace(/^test_/, "").replace(/_/g, " ");
+            let docComment;
+            if (i > 0) {
+              const prevLine = lines[i - 1].trim();
+              const docMatch = prevLine.match(/^\/\/\/\s*(.+)/);
+              if (docMatch) {
+                docComment = docMatch[1];
+              }
+            }
+            records.push({
+              id: `extracted:test-descriptions:${hash(filePath + ":" + testName)}`,
+              extractor: "test-descriptions",
+              language,
+              filePath,
+              line: j + 1,
+              nodeType: "business_rule",
+              name: docComment ?? humanName,
+              content: testName,
+              confidence: docComment ? 0.7 : 0.5,
+              metadata: { framework: "rust-test" }
+            });
+            break;
+          }
+        }
+      }
+    }
+    return records;
+  }
+  extractJava(_content, filePath, language, lines) {
+    const records = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const testMatch = line.match(/@Test\s*$/);
+      if (testMatch) {
+        let displayName;
+        for (let k = Math.max(0, i - 3); k < i; k++) {
+          const prevLine = lines[k];
+          const dm = prevLine.match(/@DisplayName\s*\(\s*"([^"]+)"\s*\)/);
+          if (dm) displayName = dm[1];
+        }
+        for (let j = i + 1; j < lines.length && j <= i + 5; j++) {
+          const scanLine = lines[j];
+          const adjacentDisplay = scanLine.match(/@DisplayName\s*\(\s*"([^"]+)"\s*\)/);
+          if (adjacentDisplay) {
+            displayName = adjacentDisplay[1];
+            continue;
+          }
+          const methodMatch = scanLine.match(
+            /^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:void|[\w<>[\]]+)\s+(\w+)\s*\(/
+          );
+          if (methodMatch) {
+            const methodName = methodMatch[1];
+            const name = displayName ?? methodName;
+            const patternKey = displayName ?? methodName;
+            records.push({
+              id: `extracted:test-descriptions:${hash(filePath + ":" + patternKey)}`,
+              extractor: "test-descriptions",
+              language,
+              filePath,
+              line: j + 1,
+              nodeType: "business_rule",
+              name,
+              content: patternKey,
+              confidence: displayName ? 0.7 : 0.5,
+              metadata: { framework: "junit5" }
+            });
+            break;
+          }
+        }
+      }
+    }
+    return records;
+  }
+};
+
+// src/ingest/extractors/EnumConstantExtractor.ts
+var EnumConstantExtractor = class {
+  name = "enum-constants";
+  supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
+  extract(content, filePath, language) {
+    switch (language) {
+      case "typescript":
+        return this.extractTypeScript(content, filePath, language);
+      case "javascript":
+        return this.extractJavaScript(content, filePath, language);
+      case "python":
+        return this.extractPython(content, filePath, language);
+      case "go":
+        return this.extractGo(content, filePath, language);
+      case "rust":
+        return this.extractRust(content, filePath, language);
+      case "java":
+        return this.extractJava(content, filePath, language);
+    }
+  }
+  extractTypeScript(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const enumMatch = line.match(/(?:export\s+)?enum\s+(\w+)/);
+      if (enumMatch) {
+        const enumName = enumMatch[1];
+        const members = this.collectEnumMembers(lines, i + 1);
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: enumName,
+          content: `enum ${enumName} { ${members.join(", ")} }`,
+          confidence: 0.8,
+          metadata: { kind: "enum", members }
+        });
+      }
+      const constMatch = line.match(/(?:export\s+)?const\s+(\w+)\s*=\s*\{/);
+      if (constMatch && content.includes("as const")) {
+        const blockEnd = this.findClosingBrace(lines, i);
+        const block = lines.slice(i, blockEnd + 1).join("\n");
+        if (block.includes("as const")) {
+          const constName = constMatch[1];
+          const members = this.collectObjectKeys(lines, i + 1);
+          records.push({
+            id: `extracted:enum-constants:${hash(filePath + ":" + constName)}`,
+            extractor: "enum-constants",
+            language,
+            filePath,
+            line: i + 1,
+            nodeType: "business_term",
+            name: constName,
+            content: `const ${constName} = { ${members.join(", ")} } as const`,
+            confidence: 0.8,
+            metadata: { kind: "as-const", members }
+          });
+        }
+      }
+      const unionMatch = line.match(
+        /(?:export\s+)?type\s+(\w+)\s*=\s*(['"`][\w]+['"`](?:\s*\|\s*['"`][\w]+['"`])+)/
+      );
+      if (unionMatch) {
+        const typeName = unionMatch[1];
+        const values = unionMatch[2].split("|").map((v) => v.trim().replace(/['"`]/g, ""));
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: typeName,
+          content: `type ${typeName} = ${values.map((v) => `'${v}'`).join(" | ")}`,
+          confidence: 0.7,
+          metadata: { kind: "union-type", members: values }
+        });
+      }
+    }
+    return records;
+  }
+  extractJavaScript(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const freezeMatch = line.match(/(?:export\s+)?const\s+(\w+)\s*=\s*Object\.freeze\s*\(\s*\{/);
+      if (freezeMatch) {
+        const name = freezeMatch[1];
+        const members = this.collectObjectKeys(lines, i + 1);
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name,
+          content: `const ${name} = Object.freeze({ ${members.join(", ")} })`,
+          confidence: 0.8,
+          metadata: { kind: "frozen-object", members }
+        });
+      }
+      const constMatch = line.match(/(?:export\s+)?const\s+([A-Z][A-Z_\d]*)\s*=\s*\{/);
+      if (constMatch && !freezeMatch) {
+        const name = constMatch[1];
+        const members = this.collectObjectKeys(lines, i + 1);
+        if (members.length > 0 && members.every((m) => /^[A-Z][A-Z_\d]*$/.test(m))) {
+          records.push({
+            id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+            extractor: "enum-constants",
+            language,
+            filePath,
+            line: i + 1,
+            nodeType: "business_term",
+            name,
+            content: `const ${name} = { ${members.join(", ")} }`,
+            confidence: 0.6,
+            metadata: { kind: "const-object", members }
+          });
+        }
+      }
+    }
+    return records;
+  }
+  extractPython(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const enumMatch = line.match(
+        /^class\s+(\w+)\s*\(\s*(?:str\s*,\s*)?(?:Enum|StrEnum|IntEnum|Flag|IntFlag)\s*\)/
+      );
+      if (enumMatch) {
+        const enumName = enumMatch[1];
+        const members = this.collectPythonEnumMembers(lines, i + 1);
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: enumName,
+          content: `class ${enumName}(Enum) { ${members.join(", ")} }`,
+          confidence: 0.8,
+          metadata: { kind: "enum", members }
+        });
+      }
+      const literalMatch = line.match(/(\w+)\s*=\s*Literal\s*\[([^\]]+)\]/);
+      if (literalMatch) {
+        const typeName = literalMatch[1];
+        const values = literalMatch[2].split(",").map((v) => v.trim().replace(/["']/g, ""));
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + typeName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: typeName,
+          content: `${typeName} = Literal[${values.map((v) => `"${v}"`).join(", ")}]`,
+          confidence: 0.7,
+          metadata: { kind: "literal-type", members: values }
+        });
+      }
+    }
+    return records;
+  }
+  extractGo(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const typeMatch = line.match(/^type\s+(\w+)\s+(?:int|string|uint|int32|int64|uint32|uint64)/);
+      if (typeMatch) {
+      }
+      const constBlockMatch = line.match(/^const\s*\(/);
+      if (constBlockMatch) {
+        const consts = [];
+        let typeName;
+        for (let j = i + 1; j < lines.length; j++) {
+          const constLine = lines[j].trim();
+          if (constLine === ")") break;
+          if (constLine === "" || constLine.startsWith("//")) continue;
+          const iotaMatch = constLine.match(/^(\w+)\s+(\w+)\s*=\s*iota/);
+          if (iotaMatch) {
+            typeName = iotaMatch[2];
+            consts.push(iotaMatch[1]);
+            continue;
+          }
+          const typedMatch = constLine.match(/^(\w+)\s+(\w+)\s*=\s*"[^"]*"/);
+          if (typedMatch) {
+            typeName = typeName ?? typedMatch[2];
+            consts.push(typedMatch[1]);
+            continue;
+          }
+          const bareMatch = constLine.match(/^(\w+)\s*$/);
+          if (bareMatch) {
+            consts.push(bareMatch[1]);
+          }
+        }
+        if (consts.length > 0) {
+          const name = typeName ?? consts[0];
+          records.push({
+            id: `extracted:enum-constants:${hash(filePath + ":" + name)}`,
+            extractor: "enum-constants",
+            language,
+            filePath,
+            line: i + 1,
+            nodeType: "business_term",
+            name,
+            content: `const ( ${consts.join(", ")} )`,
+            confidence: typeName ? 0.8 : 0.6,
+            metadata: { kind: typeName ? "typed-const" : "const-block", members: consts }
+          });
+        }
+      }
+    }
+    return records;
+  }
+  extractRust(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const enumMatch = line.match(/^(?:pub\s+)?enum\s+(\w+)/);
+      if (enumMatch) {
+        const enumName = enumMatch[1];
+        const members = this.collectRustEnumVariants(lines, i + 1);
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: enumName,
+          content: `enum ${enumName} { ${members.join(", ")} }`,
+          confidence: 0.8,
+          metadata: { kind: "enum", members }
+        });
+      }
+    }
+    return records;
+  }
+  extractJava(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const enumMatch = line.match(/(?:public\s+|private\s+|protected\s+)?enum\s+(\w+)/);
+      if (enumMatch) {
+        const enumName = enumMatch[1];
+        const members = this.collectJavaEnumConstants(lines, i + 1);
+        records.push({
+          id: `extracted:enum-constants:${hash(filePath + ":" + enumName)}`,
+          extractor: "enum-constants",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_term",
+          name: enumName,
+          content: `enum ${enumName} { ${members.join(", ")} }`,
+          confidence: 0.8,
+          metadata: { kind: "enum", members }
+        });
+      }
+    }
+    return records;
+  }
+  // --- Helper methods ---
+  collectEnumMembers(lines, startLine) {
+    const members = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === "}") break;
+      if (line === "" || line.startsWith("//")) continue;
+      const match = line.match(/^(\w+)/);
+      if (match) members.push(match[1]);
+    }
+    return members;
+  }
+  collectObjectKeys(lines, startLine) {
+    const keys = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("}")) break;
+      if (line === "" || line.startsWith("//")) continue;
+      const match = line.match(/^(\w+)\s*:/);
+      if (match) keys.push(match[1]);
+    }
+    return keys;
+  }
+  findClosingBrace(lines, startLine) {
+    let depth = 0;
+    for (let i = startLine; i < lines.length; i++) {
+      for (const ch of lines[i]) {
+        if (ch === "{") depth++;
+        if (ch === "}") {
+          depth--;
+          if (depth === 0) return i;
+        }
+      }
+    }
+    return lines.length - 1;
+  }
+  collectPythonEnumMembers(lines, startLine) {
+    const members = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\S/.test(line) && line.trim() !== "") break;
+      const match = line.match(/^\s+(\w+)\s*=/);
+      if (match) members.push(match[1]);
+    }
+    return members;
+  }
+  collectRustEnumVariants(lines, startLine) {
+    const variants = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === "}") break;
+      if (line === "" || line.startsWith("//")) continue;
+      const match = line.match(/^(\w+)/);
+      if (match) variants.push(match[1]);
+    }
+    return variants;
+  }
+  collectJavaEnumConstants(lines, startLine) {
+    const constants = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === "}") break;
+      if (line === "" || line.startsWith("//") || line.startsWith("/*")) continue;
+      if (line.match(/^\s*(?:private|public|protected|static)/)) break;
+      const match = line.match(/^(\w+)[\s(,;]/);
+      if (match) constants.push(match[1]);
+      const singleMatch = line.match(/^(\w+)$/);
+      if (singleMatch) constants.push(singleMatch[1]);
+    }
+    return constants;
+  }
+};
+
+// src/ingest/extractors/ValidationRuleExtractor.ts
+var ValidationRuleExtractor = class {
+  name = "validation-rules";
+  supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
+  extract(content, filePath, language) {
+    switch (language) {
+      case "typescript":
+      case "javascript":
+        return this.extractZod(content, filePath, language);
+      case "python":
+        return this.extractPydantic(content, filePath, language);
+      case "go":
+        return this.extractGoValidate(content, filePath, language);
+      case "rust":
+        return this.extractRustValidate(content, filePath, language);
+      case "java":
+        return this.extractBeanValidation(content, filePath, language);
+    }
+  }
+  extractZod(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const schemaMatch = line.match(/(?:export\s+)?const\s+(\w+)\s*=\s*z\.object\s*\(\s*\{/);
+      if (schemaMatch) {
+        const schemaName = schemaMatch[1];
+        const constraints = this.collectZodConstraints(lines, i + 1);
+        records.push({
+          id: `extracted:validation-rules:${hash(filePath + ":" + schemaName)}`,
+          extractor: "validation-rules",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: schemaName,
+          content: `${schemaName}: ${constraints.join("; ")}`,
+          confidence: 0.8,
+          metadata: { kind: "zod-schema", constraints, framework: "zod" }
+        });
+      }
+    }
+    return records;
+  }
+  collectZodConstraints(lines, startLine) {
+    const constraints = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("}") || line.startsWith(")")) break;
+      if (line === "" || line.startsWith("//")) continue;
+      const fieldMatch = line.match(/(\w+)\s*:\s*z\.(.+?)(?:,?\s*$)/);
+      if (fieldMatch) {
+        const fieldName = fieldMatch[1];
+        const chain = fieldMatch[2];
+        constraints.push(`${fieldName}: ${chain}`);
+      }
+    }
+    return constraints;
+  }
+  extractPydantic(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const modelMatch = line.match(/^class\s+(\w+)\s*\(\s*BaseModel\s*\)/);
+      if (modelMatch) {
+        const modelName = modelMatch[1];
+        const constraints = this.collectPydanticConstraints(lines, i + 1);
+        records.push({
+          id: `extracted:validation-rules:${hash(filePath + ":" + modelName)}`,
+          extractor: "validation-rules",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_rule",
+          name: modelName,
+          content: `${modelName}: ${constraints.join("; ")}`,
+          confidence: 0.8,
+          metadata: { kind: "pydantic-model", constraints, framework: "pydantic" }
+        });
+      }
+    }
+    return records;
+  }
+  collectPydanticConstraints(lines, startLine) {
+    const constraints = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\S/.test(line) && line.trim() !== "") break;
+      if (line.trim() === "" || line.trim().startsWith("#")) continue;
+      const fieldMatch = line.match(/^\s+(\w+)\s*:\s*(.+?)(?:\s*$)/);
+      if (fieldMatch) {
+        constraints.push(`${fieldMatch[1]}: ${fieldMatch[2]}`);
+      }
+    }
+    return constraints;
+  }
+  extractGoValidate(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const structMatch = line.match(/^type\s+(\w+)\s+struct\s*\{/);
+      if (structMatch) {
+        const structName = structMatch[1];
+        const constraints = this.collectGoValidateTags(lines, i + 1);
+        if (constraints.length > 0) {
+          records.push({
+            id: `extracted:validation-rules:${hash(filePath + ":" + structName)}`,
+            extractor: "validation-rules",
+            language,
+            filePath,
+            line: i + 1,
+            nodeType: "business_rule",
+            name: structName,
+            content: `${structName}: ${constraints.join("; ")}`,
+            confidence: 0.8,
+            metadata: { kind: "struct-tags", constraints, framework: "go-playground/validator" }
+          });
+        }
+      }
+    }
+    return records;
+  }
+  collectGoValidateTags(lines, startLine) {
+    const constraints = [];
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === "}") break;
+      if (line === "" || line.startsWith("//")) continue;
+      const tagMatch = line.match(/(\w+)\s+\S+\s+`[^`]*validate:"([^"]+)"[^`]*`/);
+      if (tagMatch) {
+        constraints.push(`${tagMatch[1]}: ${tagMatch[2]}`);
+      }
+    }
+    return constraints;
+  }
+  extractRustValidate(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const deriveMatch = line.match(/#\[derive\([^)]*Validate[^)]*\)\]/);
+      if (deriveMatch) {
+        for (let j = i + 1; j < lines.length && j <= i + 3; j++) {
+          const structLine = lines[j];
+          const structMatch = structLine.match(/^(?:pub\s+)?struct\s+(\w+)/);
+          if (structMatch) {
+            const structName = structMatch[1];
+            const constraints = this.collectRustValidateAttrs(lines, j + 1);
+            if (constraints.length > 0) {
+              records.push({
+                id: `extracted:validation-rules:${hash(filePath + ":" + structName)}`,
+                extractor: "validation-rules",
+                language,
+                filePath,
+                line: j + 1,
+                nodeType: "business_rule",
+                name: structName,
+                content: `${structName}: ${constraints.join("; ")}`,
+                confidence: 0.8,
+                metadata: { kind: "validate-derive", constraints, framework: "validator" }
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+    return records;
+  }
+  collectRustValidateAttrs(lines, startLine) {
+    const constraints = [];
+    let pendingValidate;
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line === "}") break;
+      const attrMatch = line.match(/#\[validate\((.+?)\)\]/);
+      if (attrMatch) {
+        pendingValidate = attrMatch[1];
+        continue;
+      }
+      if (pendingValidate) {
+        const fieldMatch = line.match(/(?:pub\s+)?(\w+)\s*:/);
+        if (fieldMatch) {
+          constraints.push(`${fieldMatch[1]}: ${pendingValidate}`);
+          pendingValidate = void 0;
+        }
+      }
+    }
+    return constraints;
+  }
+  extractBeanValidation(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const classRanges = this.findJavaClasses(lines);
+    for (const { name: className, startLine, endLine } of classRanges) {
+      const constraints = this.collectBeanConstraints(lines, startLine, endLine);
+      if (constraints.length > 0) {
+        records.push({
+          id: `extracted:validation-rules:${hash(filePath + ":" + className)}`,
+          extractor: "validation-rules",
+          language,
+          filePath,
+          line: startLine + 1,
+          nodeType: "business_rule",
+          name: className,
+          content: `${className}: ${constraints.join("; ")}`,
+          confidence: 0.8,
+          metadata: { kind: "bean-validation", constraints, framework: "javax.validation" }
+        });
+      }
+    }
+    return records;
+  }
+  findJavaClasses(lines) {
+    const classes = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(/(?:public\s+|private\s+|protected\s+)?class\s+(\w+)/);
+      if (match) {
+        const endLine = this.findClosingBrace(lines, i);
+        classes.push({ name: match[1], startLine: i, endLine });
+      }
+    }
+    return classes;
+  }
+  findClosingBrace(lines, startLine) {
+    let depth = 0;
+    for (let i = startLine; i < lines.length; i++) {
+      for (const ch of lines[i]) {
+        if (ch === "{") depth++;
+        if (ch === "}") {
+          depth--;
+          if (depth === 0) return i;
+        }
+      }
+    }
+    return lines.length - 1;
+  }
+  collectBeanConstraints(lines, startLine, endLine) {
+    const constraints = [];
+    const validationAnnotations = [
+      "@NotNull",
+      "@NotBlank",
+      "@NotEmpty",
+      "@Size",
+      "@Min",
+      "@Max",
+      "@DecimalMin",
+      "@DecimalMax",
+      "@Email",
+      "@Pattern",
+      "@Positive",
+      "@Negative",
+      "@Past",
+      "@Future"
+    ];
+    let pendingAnnotations = [];
+    for (let i = startLine + 1; i < endLine; i++) {
+      const line = lines[i].trim();
+      for (const anno of validationAnnotations) {
+        if (line.startsWith(anno)) {
+          pendingAnnotations.push(line.replace(/;?\s*$/, ""));
+        }
+      }
+      if (pendingAnnotations.length > 0) {
+        const fieldMatch = line.match(
+          /(?:private|public|protected)\s+(?:[\w<>[\]]+)\s+(\w+)\s*[;=]/
+        );
+        if (fieldMatch) {
+          constraints.push(`${fieldMatch[1]}: ${pendingAnnotations.join(", ")}`);
+          pendingAnnotations = [];
+        }
+      }
+    }
+    return constraints;
+  }
+};
+
+// src/ingest/extractors/ApiPathExtractor.ts
+var ApiPathExtractor = class {
+  name = "api-paths";
+  supportedExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java"];
+  extract(content, filePath, language) {
+    switch (language) {
+      case "typescript":
+      case "javascript":
+        return this.extractJsTs(content, filePath, language);
+      case "python":
+        return this.extractPython(content, filePath, language);
+      case "go":
+        return this.extractGo(content, filePath, language);
+      case "rust":
+        return this.extractRust(content, filePath, language);
+      case "java":
+        return this.extractJava(content, filePath, language);
+    }
+  }
+  extractJsTs(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const routePattern = /(?:app|router|server|fastify)\.(get|post|put|patch|delete|head|options)\s*\(\s*(['"`])([^'"`]+)\2/i;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(routePattern);
+      if (match) {
+        const method = match[1].toUpperCase();
+        const routePath = match[3];
+        const patternKey = `${method} ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `${method} ${routePath}`,
+          confidence: 0.9,
+          metadata: { method, path: routePath, framework: "express" }
+        });
+      }
+    }
+    return records;
+  }
+  extractPython(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const decoratorPattern = /@(?:app|router)\.(get|post|put|patch|delete|head|options)\s*\(\s*["']([^"']+)["']/i;
+    const flaskPattern = /@(?:app|blueprint)\.route\s*\(\s*["']([^"']+)["'](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?/i;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const fastApiMatch = line.match(decoratorPattern);
+      if (fastApiMatch) {
+        const method = fastApiMatch[1].toUpperCase();
+        const routePath = fastApiMatch[2];
+        const patternKey = `${method} ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `${method} ${routePath}`,
+          confidence: 0.9,
+          metadata: { method, path: routePath, framework: "fastapi" }
+        });
+        continue;
+      }
+      const flaskMatch = line.match(flaskPattern);
+      if (flaskMatch) {
+        const routePath = flaskMatch[1];
+        const methods = flaskMatch[2] ? flaskMatch[2].split(",").map((m) => m.trim().replace(/["']/g, "")) : ["GET"];
+        for (const method of methods) {
+          const patternKey = `${method} ${routePath}`;
+          records.push({
+            id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+            extractor: "api-paths",
+            language,
+            filePath,
+            line: i + 1,
+            nodeType: "business_process",
+            name: patternKey,
+            content: `${method} ${routePath}`,
+            confidence: 0.9,
+            metadata: { method, path: routePath, framework: "flask" }
+          });
+        }
+      }
+    }
+    return records;
+  }
+  extractGo(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const ginPattern = /(?:\w+)\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*"([^"]+)"/i;
+    const httpPattern = /http\.HandleFunc\s*\(\s*"([^"]+)"/;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const ginMatch = line.match(ginPattern);
+      if (ginMatch) {
+        const method = ginMatch[1].toUpperCase();
+        const routePath = ginMatch[2];
+        const patternKey = `${method} ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `${method} ${routePath}`,
+          confidence: 0.9,
+          metadata: { method, path: routePath, framework: "gin" }
+        });
+        continue;
+      }
+      const httpMatch = line.match(httpPattern);
+      if (httpMatch) {
+        const routePath = httpMatch[1];
+        const patternKey = `ANY ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `ANY ${routePath}`,
+          confidence: 0.6,
+          metadata: { method: "ANY", path: routePath, framework: "net/http" }
+        });
+      }
+    }
+    return records;
+  }
+  extractRust(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const actixPattern = /#\[(get|post|put|patch|delete|head|options)\s*\(\s*"([^"]+)"\s*\)\s*\]/i;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(actixPattern);
+      if (match) {
+        const method = match[1].toUpperCase();
+        const routePath = match[2];
+        const patternKey = `${method} ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `${method} ${routePath}`,
+          confidence: 0.9,
+          metadata: { method, path: routePath, framework: "actix" }
+        });
+      }
+    }
+    return records;
+  }
+  extractJava(content, filePath, language) {
+    const records = [];
+    const lines = content.split("\n");
+    const springPattern = /@(GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping|RequestMapping)\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/;
+    let basePath = "";
+    for (const line of lines) {
+      const baseMatch = line.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']\s*\)/);
+      if (baseMatch && line.match(/class\s/) === null) {
+        basePath = baseMatch[1];
+      }
+    }
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(springPattern);
+      if (match) {
+        const annotation = match[1];
+        const routePath = basePath + match[2];
+        const methodMap = {
+          GetMapping: "GET",
+          PostMapping: "POST",
+          PutMapping: "PUT",
+          PatchMapping: "PATCH",
+          DeleteMapping: "DELETE",
+          RequestMapping: "ANY"
+        };
+        const method = methodMap[annotation] ?? "ANY";
+        const patternKey = `${method} ${routePath}`;
+        records.push({
+          id: `extracted:api-paths:${hash(filePath + ":" + patternKey)}`,
+          extractor: "api-paths",
+          language,
+          filePath,
+          line: i + 1,
+          nodeType: "business_process",
+          name: patternKey,
+          content: `${method} ${routePath}`,
+          confidence: 0.9,
+          metadata: { method, path: routePath, framework: "spring" }
+        });
+      }
+    }
+    return records;
+  }
+};
+
+// src/ingest/extractors/index.ts
+var ALL_EXTRACTORS = [
+  new TestDescriptionExtractor(),
+  new EnumConstantExtractor(),
+  new ValidationRuleExtractor(),
+  new ApiPathExtractor()
+];
+function createExtractionRunner() {
+  return new ExtractionRunner(ALL_EXTRACTORS);
+}
+
+// src/ingest/ImageAnalysisExtractor.ts
+var ImageAnalysisExtractor = class {
+  provider;
+  /** Maximum file size in bytes. Reserved for future file-size filtering. */
+  maxFileSizeBytes;
+  constructor(options) {
+    this.provider = options.analysisProvider;
+    this.maxFileSizeBytes = (options.maxFileSizeMB ?? 10) * 1024 * 1024;
+  }
+  async analyze(store, imagePaths) {
+    const start = Date.now();
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const errors = [];
+    for (const imagePath of imagePaths) {
+      try {
+        const response = await this.provider.analyze({
+          prompt: "Analyze this image and provide a structured description of its visual contents.",
+          systemPrompt: "You are an image analysis assistant. Describe the image contents, detect UI elements, extract visible text, identify design patterns, and note accessibility concerns.",
+          responseSchema: {},
+          // Schema handled by provider
+          maxTokens: 1e3
+        });
+        const result = response.result;
+        const pathHash = hash(imagePath);
+        const annotationId = `img:${pathHash}`;
+        store.addNode({
+          id: annotationId,
+          type: "image_annotation",
+          name: result.description.slice(0, 200),
+          path: imagePath,
+          content: result.description,
+          hash: hash(result.description),
+          metadata: {
+            source: "image-analysis",
+            detectedElements: result.detectedElements,
+            extractedText: result.extractedText,
+            designPatterns: result.designPatterns,
+            accessibilityNotes: result.accessibilityNotes,
+            model: response.model
+          }
+        });
+        nodesAdded++;
+        const fileNodes = store.findNodes({ type: "file" });
+        const fileNode = fileNodes.find((n) => n.path === imagePath);
+        if (fileNode) {
+          store.addEdge({ from: annotationId, to: fileNode.id, type: "annotates" });
+          edgesAdded++;
+        }
+        for (const pattern of result.designPatterns) {
+          const conceptId = `img:concept:${hash(pattern + imagePath)}`;
+          store.addNode({
+            id: conceptId,
+            type: "business_concept",
+            name: pattern,
+            content: `Design pattern detected in ${imagePath}: ${pattern}`,
+            hash: hash(pattern),
+            metadata: {
+              source: "image-analysis",
+              sourceImage: imagePath,
+              domain: "design"
+            }
+          });
+          nodesAdded++;
+          store.addEdge({ from: annotationId, to: conceptId, type: "contains" });
+          edgesAdded++;
+        }
+      } catch (err) {
+        errors.push(
+          `Image analysis failed for ${imagePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+};
+
+// src/ingest/knowledgeTypes.ts
+var KNOWLEDGE_NODE_TYPES = [
+  "business_fact",
+  "business_rule",
+  "business_process",
+  "business_term",
+  "business_concept",
+  "business_metric",
+  "design_token",
+  "design_constraint",
+  "aesthetic_intent",
+  "image_annotation"
+];
+
+// src/ingest/ContradictionDetector.ts
+var SIMILARITY_THRESHOLD = 0.8;
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+function levenshteinRatio(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshteinDistance(a, b) / maxLen;
+}
+function classifyConflict(a, b) {
+  const factTypes = /* @__PURE__ */ new Set([
+    "business_fact",
+    "business_metric",
+    "design_token"
+  ]);
+  const termTypes = /* @__PURE__ */ new Set(["business_term", "business_concept"]);
+  if (factTypes.has(a.type) || factTypes.has(b.type)) return "value_mismatch";
+  if (termTypes.has(a.type) || termTypes.has(b.type)) return "definition_conflict";
+  if (a.lastModified && b.lastModified && a.lastModified !== b.lastModified)
+    return "temporal_conflict";
+  return "status_divergence";
+}
+var ContradictionDetector = class {
+  detect(store) {
+    const nodes = KNOWLEDGE_NODE_TYPES.flatMap((t) => store.findNodes({ type: t }));
+    const byName = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const key = node.name.toLowerCase().trim();
+      const group = byName.get(key) ?? [];
+      group.push(node);
+      byName.set(key, group);
+    }
+    const contradictions = [];
+    const sourcePairCounts = {};
+    const seen = /* @__PURE__ */ new Set();
+    const addContradiction = (a, b, similarity) => {
+      const sourceA = a.metadata.source ?? "unknown";
+      const sourceB = b.metadata.source ?? "unknown";
+      if (sourceA === sourceB) return;
+      const hashA = a.hash ?? a.id;
+      const hashB = b.hash ?? b.id;
+      if (hashA === hashB) return;
+      const pairId = [a.id, b.id].sort().join(":");
+      if (seen.has(pairId)) return;
+      seen.add(pairId);
+      const conflictType = classifyConflict(a, b);
+      const severity = conflictType === "value_mismatch" ? "critical" : conflictType === "definition_conflict" ? "high" : "medium";
+      const pairKey = [sourceA, sourceB].sort().join("\u2194");
+      sourcePairCounts[pairKey] = (sourcePairCounts[pairKey] ?? 0) + 1;
+      contradictions.push({
+        id: `contradiction:${a.id}:${b.id}`,
+        entityA: {
+          nodeId: a.id,
+          source: sourceA,
+          name: a.name,
+          content: a.content ?? "",
+          lastModified: a.lastModified
+        },
+        entityB: {
+          nodeId: b.id,
+          source: sourceB,
+          name: b.name,
+          content: b.content ?? "",
+          lastModified: b.lastModified
+        },
+        similarity,
+        conflictType,
+        severity,
+        description: `"${a.name}" has conflicting definitions from ${sourceA} and ${sourceB}`
+      });
+    };
+    for (const [, group] of byName) {
+      if (group.length < 2) continue;
+      for (let i = 0; i < group.length; i++) {
+        for (let j = i + 1; j < group.length; j++) {
+          addContradiction(group[i], group[j], 1);
+        }
+      }
+    }
+    const keys = [...byName.keys()];
+    for (let i = 0; i < keys.length; i++) {
+      for (let j = i + 1; j < keys.length; j++) {
+        const keyA = keys[i];
+        const keyB = keys[j];
+        const maxLen = Math.max(keyA.length, keyB.length);
+        const minLen = Math.min(keyA.length, keyB.length);
+        if (minLen / maxLen < SIMILARITY_THRESHOLD) continue;
+        const ratio = levenshteinRatio(keyA, keyB);
+        if (ratio < SIMILARITY_THRESHOLD) continue;
+        const groupA = byName.get(keyA);
+        const groupB = byName.get(keyB);
+        for (const a of groupA) {
+          for (const b of groupB) {
+            addContradiction(a, b, ratio);
+          }
+        }
+      }
+    }
+    return { contradictions, sourcePairCounts, totalChecked: nodes.length };
+  }
+};
+
+// src/ingest/CoverageScorer.ts
+var KNOWLEDGE_TYPES = KNOWLEDGE_NODE_TYPES;
+var CODE_TYPES2 = [
+  "file",
+  "function",
+  "class",
+  "method",
+  "interface",
+  "variable"
+];
+var KNOWLEDGE_EDGE_TYPES = [
+  "governs",
+  "documents",
+  "measures",
+  "applies_to",
+  "references",
+  "uses_token",
+  "declares_intent",
+  "annotates"
+];
+function toGrade(score) {
+  if (score >= 80) return "A";
+  if (score >= 60) return "B";
+  if (score >= 40) return "C";
+  if (score >= 20) return "D";
+  return "F";
+}
+var CoverageScorer = class {
+  score(store) {
+    const knowledgeNodes = KNOWLEDGE_TYPES.flatMap((t) => store.findNodes({ type: t }));
+    const domainMap = /* @__PURE__ */ new Map();
+    for (const node of knowledgeNodes) {
+      const domain = node.metadata.domain ?? "unclassified";
+      const group = domainMap.get(domain) ?? [];
+      group.push(node);
+      domainMap.set(domain, group);
+    }
+    const codeNodes = CODE_TYPES2.flatMap((t) => store.findNodes({ type: t }));
+    const codeDomains = /* @__PURE__ */ new Map();
+    for (const node of codeNodes) {
+      const domain = node.metadata.domain ?? this.domainFromPath(node.path);
+      const group = codeDomains.get(domain) ?? [];
+      group.push(node);
+      codeDomains.set(domain, group);
+    }
+    const allDomains = /* @__PURE__ */ new Set([...domainMap.keys(), ...codeDomains.keys()]);
+    const domains = [];
+    for (const domain of allDomains) {
+      const knEntries = domainMap.get(domain) ?? [];
+      const codeEntries = codeDomains.get(domain) ?? [];
+      const linkedIds = /* @__PURE__ */ new Set();
+      for (const codeNode of codeEntries) {
+        for (const edgeType of KNOWLEDGE_EDGE_TYPES) {
+          const edges = store.getEdges({ to: codeNode.id, type: edgeType });
+          if (edges.length > 0) {
+            linkedIds.add(codeNode.id);
+            break;
+          }
+        }
+      }
+      const sourceBreakdown = {};
+      for (const kn of knEntries) {
+        const src = kn.metadata.source ?? "unknown";
+        sourceBreakdown[src] = (sourceBreakdown[src] ?? 0) + 1;
+      }
+      const codeEntities = codeEntries.length;
+      const linkedEntities = linkedIds.size;
+      const knowledgeEntries = knEntries.length;
+      const uniqueSources = Object.keys(sourceBreakdown).length;
+      const codeCoverageComponent = codeEntities > 0 ? linkedEntities / codeEntities * 60 : 0;
+      const knowledgeDepthComponent = Math.min(knowledgeEntries / 10, 1) * 20;
+      const sourceDiversityComponent = Math.min(uniqueSources / 3, 1) * 20;
+      const score = Math.round(
+        codeCoverageComponent + knowledgeDepthComponent + sourceDiversityComponent
+      );
+      domains.push({
+        domain,
+        score,
+        knowledgeEntries,
+        codeEntities,
+        linkedEntities,
+        unlinkedEntities: codeEntities - linkedEntities,
+        sourceBreakdown,
+        grade: toGrade(score)
+      });
+    }
+    const overallScore = domains.length > 0 ? Math.round(domains.reduce((sum, d) => sum + d.score, 0) / domains.length) : 0;
+    return {
+      domains,
+      overallScore,
+      overallGrade: toGrade(overallScore),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  domainFromPath(filePath) {
+    if (!filePath) return "unclassified";
+    const parts = filePath.split("/");
+    const pkgIdx = parts.indexOf("packages");
+    if (pkgIdx >= 0 && parts[pkgIdx + 1]) return parts[pkgIdx + 1];
+    const srcIdx = parts.indexOf("src");
+    if (srcIdx >= 0 && parts[srcIdx + 1]) return parts[srcIdx + 1];
+    return parts[0] ?? "unclassified";
+  }
+};
+
+// src/ingest/KnowledgePipelineRunner.ts
+var BUSINESS_NODE_TYPES = [
+  "business_concept",
+  "business_rule",
+  "business_process",
+  "business_term",
+  "business_metric",
+  "business_fact"
+];
+var SNAPSHOT_NODE_TYPES = [
+  ...BUSINESS_NODE_TYPES,
+  "design_token",
+  "design_constraint",
+  "aesthetic_intent",
+  "image_annotation"
+];
+var KnowledgePipelineRunner = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async run(options) {
+    const maxIterations = options.maxIterations ?? 5;
+    const remediations = [];
+    const preSnapshot = this.buildSnapshot(options.domain);
+    const extraction = await this.extract(options);
+    const postSnapshot = this.buildSnapshot(options.domain);
+    let driftResult = this.reconcile(preSnapshot, postSnapshot);
+    const contradictionDetector = new ContradictionDetector();
+    const contradictions = contradictionDetector.detect(this.store);
+    let gapReport = await this.detect(options);
+    const coverageScorer = new CoverageScorer();
+    const coverage = coverageScorer.score(this.store);
+    let iterations = 1;
+    if (options.fix) {
+      let previousFindingCount = driftResult.findings.length;
+      while (iterations < maxIterations) {
+        if (driftResult.findings.length === 0) break;
+        this.remediate(driftResult, remediations, options);
+        const rePreSnapshot = this.buildSnapshot(options.domain);
+        await this.extract(options);
+        const rePostSnapshot = this.buildSnapshot(options.domain);
+        driftResult = this.reconcile(rePreSnapshot, rePostSnapshot);
+        gapReport = await this.detect(options);
+        iterations++;
+        const newFindingCount = driftResult.findings.length;
+        if (newFindingCount >= previousFindingCount) break;
+        previousFindingCount = newFindingCount;
+      }
+    }
+    await this.stageNewFindings(driftResult, options);
+    return {
+      verdict: this.computeVerdict(driftResult),
+      driftScore: driftResult.driftScore,
+      iterations,
+      findings: driftResult.summary,
+      extraction,
+      gaps: gapReport,
+      remediations,
+      contradictions,
+      coverage
+    };
+  }
+  // ── Phase 1: EXTRACT ──────────────────────────────────────────────────────
+  async extract(options) {
+    const extractedDir = path10.join(options.projectDir, ".harness", "knowledge", "extracted");
+    await fs9.mkdir(extractedDir, { recursive: true });
+    const runner = createExtractionRunner();
+    const extractionResult = await runner.run(options.projectDir, this.store, extractedDir);
+    const diagramParser = new DiagramParser(this.store);
+    const diagramResult = await diagramParser.ingest(options.projectDir);
+    let imageCount = 0;
+    const imagePaths = options.imagePaths ?? [];
+    if (options.analyzeImages && options.analysisProvider && imagePaths.length > 0) {
+      const imageExtractor = new ImageAnalysisExtractor({
+        analysisProvider: options.analysisProvider
+      });
+      const imageResult = await imageExtractor.analyze(this.store, imagePaths);
+      imageCount = imageResult.nodesAdded;
+    }
+    const knowledgeDir = path10.join(options.projectDir, "docs", "knowledge");
+    const bkIngestor = new BusinessKnowledgeIngestor(this.store);
+    let bkResult;
+    try {
+      bkResult = await bkIngestor.ingest(knowledgeDir);
+    } catch {
+      bkResult = {
+        nodesAdded: 0,
+        nodesUpdated: 0,
+        edgesAdded: 0,
+        edgesUpdated: 0,
+        errors: [],
+        durationMs: 0
+      };
+    }
+    const linker = new KnowledgeLinker(this.store, extractedDir);
+    const linkResult = await linker.link();
+    return {
+      codeSignals: extractionResult.nodesAdded,
+      diagrams: diagramResult.nodesAdded,
+      linkerFacts: linkResult.factsCreated,
+      businessKnowledge: bkResult.nodesAdded,
+      images: imageCount
+    };
   }
-  /**
-   * Convention-based linking: match requirement text to code nodes
-   * by keyword overlap (function/class names appearing in requirement text).
-   */
-  linkByKeywordOverlap(reqId, reqText) {
-    let count = 0;
-    for (const nodeType of CODE_NODE_TYPES2) {
-      const codeNodes = this.store.findNodes({ type: nodeType });
-      for (const node of codeNodes) {
-        if (node.name.length < 3) continue;
-        const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
-        if (namePattern.test(reqText)) {
-          const edgeType = node.path?.replace(/\\/g, "/").includes("/tests/") ? "verified_by" : "requires";
-          this.store.addEdge({
-            from: reqId,
-            to: node.id,
-            type: edgeType,
-            confidence: 0.6,
-            metadata: { method: "convention", matchReason: "keyword-overlap" }
-          });
-          count++;
-        }
+  // ── Phase 2: RECONCILE ────────────────────────────────────────────────────
+  buildSnapshot(domain) {
+    let nodes = SNAPSHOT_NODE_TYPES.flatMap((type) => this.store.findNodes({ type }));
+    if (domain) {
+      nodes = nodes.filter((n) => n.metadata?.domain === domain);
+    }
+    return {
+      entries: nodes.map((n) => ({
+        id: n.id,
+        type: n.type,
+        contentHash: n.hash ?? n.id,
+        source: n.metadata?.source ?? "unknown",
+        name: n.name
+      })),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  reconcile(current, fresh) {
+    const detector = new StructuralDriftDetector();
+    return detector.detect(current, fresh);
+  }
+  // ── Phase 3: DETECT ───────────────────────────────────────────────────────
+  async detect(options) {
+    const knowledgeDir = path10.join(options.projectDir, "docs", "knowledge");
+    const aggregator = new KnowledgeStagingAggregator(options.projectDir);
+    const gapReport = await aggregator.generateGapReport(knowledgeDir);
+    await aggregator.writeGapReport(gapReport);
+    return gapReport;
+  }
+  // ── Phase 4: REMEDIATE ────────────────────────────────────────────────────
+  remediate(driftResult, remediations, options) {
+    for (const finding of driftResult.findings) {
+      switch (finding.classification) {
+        case "stale":
+          this.store.removeNode(finding.entryId);
+          remediations.push(`removed stale: ${finding.entryId}`);
+          break;
+        case "new":
+          break;
+        case "drifted":
+          if (!options.ci) {
+            remediations.push(`flagged drifted: ${finding.entryId}`);
+          }
+          break;
+        case "contradicting":
+          break;
       }
     }
-    return count;
+  }
+  async stageNewFindings(driftResult, options) {
+    const newFindings = driftResult.findings.filter((f) => f.classification === "new");
+    if (newFindings.length === 0) return;
+    const stagedEntries = newFindings.filter((f) => f.fresh != null).map((f) => ({
+      id: f.fresh.id,
+      source: this.classifySource(f.fresh.source),
+      nodeType: f.fresh.type,
+      name: f.fresh.name,
+      confidence: 0.7,
+      contentHash: f.fresh.contentHash,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    if (stagedEntries.length > 0) {
+      const aggregator = new KnowledgeStagingAggregator(options.projectDir);
+      await aggregator.aggregate(stagedEntries, [], []);
+    }
+  }
+  classifySource(source) {
+    if (source === "linker" || source === "knowledge-linker") return "linker";
+    if (source === "diagram") return "diagram";
+    return "extractor";
+  }
+  // ── Verdict ───────────────────────────────────────────────────────────────
+  computeVerdict(driftResult) {
+    const { summary } = driftResult;
+    const unresolved = summary.drifted + summary.stale + summary.contradicting;
+    if (unresolved === 0 && summary.new === 0) return "pass";
+    if (unresolved === 0) return "warn";
+    return "fail";
   }
 };
 
 // src/ingest/connectors/ConnectorUtils.ts
-var CODE_NODE_TYPES3 = ["file", "function", "class", "method", "interface", "variable"];
+var CODE_NODE_TYPES4 = ["file", "function", "class", "method", "interface", "variable"];
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function withRetry(client, options) {
+  const maxRetries = options?.maxRetries ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 1e3;
+  const maxDelayMs = options?.maxDelayMs ?? 3e4;
+  return async (url, requestOptions) => {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await client(url, requestOptions);
+        if (response.ok || !RETRYABLE_STATUSES.has(response.status ?? 0)) {
+          return response;
+        }
+        if (attempt === maxRetries) {
+          return response;
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt === maxRetries) {
+          throw lastError;
+        }
+      }
+      const exponentialDelay = baseDelayMs * 2 ** attempt;
+      const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+      const jitteredDelay = cappedDelay * (0.5 + Math.random() * 0.5);
+      await new Promise((resolve) => setTimeout(resolve, jitteredDelay));
+    }
+    throw lastError ?? new Error("Request failed after retries");
+  };
+}
 var SANITIZE_RULES = [
   // Strip XML/HTML-like instruction tags that could be interpreted as system prompts
   {
@@ -1781,7 +4936,7 @@ function sanitizeExternalText(text, maxLength = 2e3) {
 }
 function linkToCode(store, content, sourceNodeId, edgeType, options) {
   let edgesCreated = 0;
-  for (const type of CODE_NODE_TYPES3) {
+  for (const type of CODE_NODE_TYPES4) {
     const nodes = store.findNodes({ type });
     for (const node of nodes) {
       if (node.name.length < 3) continue;
@@ -1801,12 +4956,12 @@ function linkToCode(store, content, sourceNodeId, edgeType, options) {
 }
 
 // src/ingest/connectors/SyncManager.ts
-import * as fs4 from "fs/promises";
-import * as path5 from "path";
+import * as fs10 from "fs/promises";
+import * as path11 from "path";
 var SyncManager = class {
   constructor(store, graphDir) {
     this.store = store;
-    this.metadataPath = path5.join(graphDir, "sync-metadata.json");
+    this.metadataPath = path11.join(graphDir, "sync-metadata.json");
   }
   store;
   registrations = /* @__PURE__ */ new Map();
@@ -1854,6 +5009,16 @@ var SyncManager = class {
       combined.errors.push(...result.errors);
       combined.durationMs += result.durationMs;
     }
+    try {
+      const linker = new KnowledgeLinker(this.store);
+      const linkResult = await linker.link();
+      combined.nodesAdded += linkResult.factsCreated + linkResult.conceptsClustered;
+      combined.errors.push(...linkResult.errors);
+    } catch (err) {
+      combined.errors.push(
+        `KnowledgeLinker error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     return combined;
   }
   async getMetadata() {
@@ -1861,18 +5026,64 @@ var SyncManager = class {
   }
   async loadMetadata() {
     try {
-      const raw = await fs4.readFile(this.metadataPath, "utf-8");
+      const raw = await fs10.readFile(this.metadataPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return { connectors: {} };
     }
   }
   async saveMetadata(metadata) {
-    await fs4.mkdir(path5.dirname(this.metadataPath), { recursive: true });
-    await fs4.writeFile(this.metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    await fs10.mkdir(path11.dirname(this.metadataPath), { recursive: true });
+    await fs10.writeFile(this.metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   }
 };
 
+// src/ingest/connectors/ContentCondenser.ts
+var SUMMARIZE_PROMPT = `Summarize the following content to fit within the specified length.
+Preserve all business rules, SLAs, requirements, decisions, and regulatory references.
+Remove redundant details and boilerplate while keeping all actionable information.
+
+Content to summarize:
+`;
+async function condenseContent(raw, options, summarizeFn) {
+  const originalLength = raw.length;
+  const { maxLength } = options;
+  const summarizationThreshold = options.summarizationThreshold ?? maxLength * 2;
+  if (raw.length <= maxLength) {
+    return { content: raw, method: "passthrough", originalLength };
+  }
+  if (raw.length < summarizationThreshold) {
+    return {
+      content: sanitizeExternalText(raw, maxLength),
+      method: "truncated",
+      originalLength
+    };
+  }
+  if (options.modelEndpoint && summarizeFn) {
+    try {
+      const summarized = await summarizeFn(SUMMARIZE_PROMPT + raw, {
+        endpoint: options.modelEndpoint,
+        model: options.modelName ?? "default",
+        maxTokens: Math.ceil(maxLength / 4)
+        // rough token estimate
+      });
+      const finalContent = summarized.length > maxLength ? sanitizeExternalText(summarized, maxLength) : summarized;
+      return { content: finalContent, method: "summarized", originalLength };
+    } catch {
+      return {
+        content: sanitizeExternalText(raw, maxLength),
+        method: "truncated",
+        originalLength
+      };
+    }
+  }
+  return {
+    content: sanitizeExternalText(raw, maxLength),
+    method: "truncated",
+    originalLength
+  };
+}
+
 // src/ingest/connectors/JiraConnector.ts
 function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
   return {
@@ -1904,7 +5115,7 @@ var JiraConnector = class {
   source = "jira";
   httpClient;
   constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
   }
   async ingest(store, config) {
     const start = Date.now();
@@ -1931,7 +5142,7 @@ var JiraConnector = class {
     const jql = buildJql(config);
     const headers = { Authorization: `Basic ${apiKey}`, "Content-Type": "application/json" };
     try {
-      const counts = await this.fetchAllIssues(store, baseUrl, jql, headers);
+      const counts = await this.fetchAllIssues(store, baseUrl, jql, headers, config);
       return buildIngestResult(counts.nodesAdded, counts.edgesAdded, [], start);
     } catch (err) {
       return buildIngestResult(
@@ -1942,7 +5153,7 @@ var JiraConnector = class {
       );
     }
   }
-  async fetchAllIssues(store, baseUrl, jql, headers) {
+  async fetchAllIssues(store, baseUrl, jql, headers, config) {
     let nodesAdded = 0;
     let edgesAdded = 0;
     let startAt = 0;
@@ -1955,7 +5166,7 @@ var JiraConnector = class {
       const data = await response.json();
       total = data.total;
       for (const issue of data.issues) {
-        const counts = this.processIssue(store, issue);
+        const counts = await this.processIssue(store, issue, baseUrl, headers, config);
         nodesAdded += counts.nodesAdded;
         edgesAdded += counts.edgesAdded;
       }
@@ -1963,19 +5174,47 @@ var JiraConnector = class {
     }
     return { nodesAdded, edgesAdded };
   }
-  processIssue(store, issue) {
+  async processIssue(store, issue, baseUrl, headers, config) {
     const nodeId = `issue:jira:${issue.key}`;
+    const comments = await this.fetchComments(baseUrl, issue.key, headers);
+    const parts = [issue.fields.summary];
+    if (issue.fields.description) {
+      parts.push(issue.fields.description);
+    }
+    if (comments.length > 0) {
+      for (const comment of comments) {
+        parts.push(`${comment.author.displayName} (${comment.created}): ${comment.body}`);
+      }
+    }
+    const rawContent = parts.join("\n");
+    const acceptanceCriteria = parseAcceptanceCriteria(issue.fields.description ?? "");
+    const customFields = extractCustomFields(issue.fields);
+    const maxLen = config.maxContentLength ?? 4e3;
+    const condensed = await condenseContent(rawContent, { maxLength: maxLen });
+    const metadata = {
+      key: issue.key,
+      status: issue.fields.status?.name,
+      priority: issue.fields.priority?.name,
+      assignee: issue.fields.assignee?.displayName,
+      labels: issue.fields.labels ?? [],
+      commentCount: comments.length
+    };
+    if (acceptanceCriteria.length > 0) {
+      metadata.acceptanceCriteria = acceptanceCriteria;
+    }
+    if (Object.keys(customFields).length > 0) {
+      metadata.customFields = customFields;
+    }
+    if (condensed.method !== "passthrough") {
+      metadata.condensed = condensed.method;
+      metadata.originalLength = condensed.originalLength;
+    }
     store.addNode({
       id: nodeId,
       type: "issue",
       name: sanitizeExternalText(issue.fields.summary, 500),
-      metadata: {
-        key: issue.key,
-        status: issue.fields.status?.name,
-        priority: issue.fields.priority?.name,
-        assignee: issue.fields.assignee?.displayName,
-        labels: issue.fields.labels ?? []
-      }
+      content: condensed.content,
+      metadata
     });
     const searchText = sanitizeExternalText(
       [issue.fields.summary, issue.fields.description ?? ""].join(" ")
@@ -1983,7 +5222,40 @@ var JiraConnector = class {
     const edgesAdded = linkToCode(store, searchText, nodeId, "applies_to");
     return { nodesAdded: 1, edgesAdded };
   }
+  async fetchComments(baseUrl, issueKey, headers) {
+    try {
+      const url = `${baseUrl}/rest/api/2/issue/${issueKey}/comment`;
+      const response = await this.httpClient(url, { headers });
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.comments ?? [];
+    } catch {
+      return [];
+    }
+  }
 };
+function parseAcceptanceCriteria(description) {
+  const criteria = [];
+  const checkboxRegex = /[-*]\s*\[[ x]\]\s*(.+)/gi;
+  let match;
+  while ((match = checkboxRegex.exec(description)) !== null) {
+    criteria.push(match[1].trim());
+  }
+  const gwtRegex = /Given\b.+?When\b.+?Then\b.+/gi;
+  while ((match = gwtRegex.exec(description)) !== null) {
+    criteria.push(match[0].trim());
+  }
+  return criteria;
+}
+function extractCustomFields(fields) {
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (key.startsWith("customfield_") && value != null && typeof value === "string") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 
 // src/ingest/connectors/SlackConnector.ts
 var SlackConnector = class {
@@ -1991,7 +5263,7 @@ var SlackConnector = class {
   source = "slack";
   httpClient;
   constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
   }
   async ingest(store, config) {
     const start = Date.now();
@@ -2014,7 +5286,7 @@ var SlackConnector = class {
     const oldest = config.lookbackDays ? String(Math.floor((Date.now() - Number(config.lookbackDays) * 864e5) / 1e3)) : void 0;
     for (const channel of channels) {
       try {
-        const result = await this.processChannel(store, channel, apiKey, oldest);
+        const result = await this.processChannel(store, channel, apiKey, oldest, config);
         nodesAdded += result.nodesAdded;
         edgesAdded += result.edgesAdded;
         errors.push(...result.errors);
@@ -2033,7 +5305,7 @@ var SlackConnector = class {
       durationMs: Date.now() - start
     };
   }
-  async processChannel(store, channel, apiKey, oldest) {
+  async processChannel(store, channel, apiKey, oldest, config) {
     const errors = [];
     let nodesAdded = 0;
     let edgesAdded = 0;
@@ -2058,27 +5330,74 @@ var SlackConnector = class {
     if (!data.ok) {
       return { nodesAdded: 0, edgesAdded: 0, errors: [`Slack API error for channel ${channel}`] };
     }
+    const maxLen = config.maxContentLength ?? 2e3;
     for (const message of data.messages) {
       const nodeId = `conversation:slack:${channel}:${message.ts}`;
-      const sanitizedText = sanitizeExternalText(message.text);
-      const snippet = sanitizedText.length > 100 ? sanitizedText.slice(0, 100) : sanitizedText;
+      let assembledText = message.text;
+      let threadReplyCount;
+      if (message.reply_count && message.reply_count > 0 && message.thread_ts) {
+        const replies = await this.fetchThreadReplies(channel, message.thread_ts, apiKey);
+        if (replies.length > 0) {
+          const threadReplies = replies.slice(1);
+          threadReplyCount = threadReplies.length;
+          if (threadReplies.length > 0) {
+            const replyLines = threadReplies.map((r) => `${r.user} (${r.ts}): ${r.text}`);
+            assembledText = `${message.text}
+${replyLines.join("\n")}`;
+          }
+        }
+      }
+      const condensed = await condenseContent(assembledText, { maxLength: maxLen });
+      const snippet = condensed.content.length > 100 ? condensed.content.slice(0, 100) : condensed.content;
+      const reactions = message.reactions ? message.reactions.reduce(
+        (acc, r) => ({ ...acc, [r.name]: r.count }),
+        {}
+      ) : void 0;
+      const metadata = {
+        author: message.user,
+        channel,
+        timestamp: message.ts
+      };
+      if (threadReplyCount !== void 0) {
+        metadata.threadReplyCount = threadReplyCount;
+      }
+      if (reactions) {
+        metadata.reactions = reactions;
+      }
+      if (condensed.method !== "passthrough") {
+        metadata.condensed = condensed.method;
+        metadata.originalLength = condensed.originalLength;
+      }
       store.addNode({
         id: nodeId,
         type: "conversation",
         name: snippet,
-        metadata: {
-          author: message.user,
-          channel,
-          timestamp: message.ts
-        }
+        content: condensed.content,
+        metadata
       });
       nodesAdded++;
-      edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
+      edgesAdded += linkToCode(store, condensed.content, nodeId, "references", {
         checkPaths: true
       });
     }
     return { nodesAdded, edgesAdded, errors };
   }
+  async fetchThreadReplies(channel, threadTs, apiKey) {
+    try {
+      const url = `https://slack.com/api/conversations.replies?channel=${encodeURIComponent(channel)}&ts=${threadTs}`;
+      const response = await this.httpClient(url, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.ok ? data.messages : [];
+    } catch {
+      return [];
+    }
+  }
 };
 
 // src/ingest/connectors/ConfluenceConnector.ts
@@ -2097,7 +5416,7 @@ var ConfluenceConnector = class {
   source = "confluence";
   httpClient;
   constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
   }
   async ingest(store, config) {
     const start = Date.now();
@@ -2110,7 +5429,14 @@ var ConfluenceConnector = class {
     const baseUrlEnv = config.baseUrlEnv ?? "CONFLUENCE_BASE_URL";
     const baseUrl = process.env[baseUrlEnv] ?? "";
     const spaceKey = config.spaceKey ?? "";
-    const counts = await this.fetchAllPagesHandled(store, baseUrl, apiKey, spaceKey, errors);
+    const counts = await this.fetchAllPagesHandled(
+      store,
+      baseUrl,
+      apiKey,
+      spaceKey,
+      errors,
+      config
+    );
     return {
       nodesAdded: counts.nodesAdded,
       nodesUpdated: 0,
@@ -2120,9 +5446,9 @@ var ConfluenceConnector = class {
       durationMs: Date.now() - start
     };
   }
-  async fetchAllPagesHandled(store, baseUrl, apiKey, spaceKey, errors) {
+  async fetchAllPagesHandled(store, baseUrl, apiKey, spaceKey, errors, config) {
     try {
-      const result = await this.fetchAllPages(store, baseUrl, apiKey, spaceKey);
+      const result = await this.fetchAllPages(store, baseUrl, apiKey, spaceKey, config);
       errors.push(...result.errors);
       return { nodesAdded: result.nodesAdded, edgesAdded: result.edgesAdded };
     } catch (err) {
@@ -2130,7 +5456,7 @@ var ConfluenceConnector = class {
       return { nodesAdded: 0, edgesAdded: 0 };
     }
   }
-  async fetchAllPages(store, baseUrl, apiKey, spaceKey) {
+  async fetchAllPages(store, baseUrl, apiKey, spaceKey, config) {
     const errors = [];
     let nodesAdded = 0;
     let edgesAdded = 0;
@@ -2145,7 +5471,7 @@ var ConfluenceConnector = class {
       }
       const data = await response.json();
       for (const page of data.results) {
-        const counts = this.processPage(store, page, spaceKey);
+        const counts = await this.processPage(store, page, spaceKey, config);
         nodesAdded += counts.nodesAdded;
         edgesAdded += counts.edgesAdded;
       }
@@ -2153,22 +5479,43 @@ var ConfluenceConnector = class {
     }
     return { nodesAdded, edgesAdded, errors };
   }
-  processPage(store, page, spaceKey) {
+  async processPage(store, page, spaceKey, config) {
     const nodeId = `confluence:${page.id}`;
+    let edgesAdded = 0;
+    const labels = page.metadata?.labels?.results?.map((l) => l.name) ?? [];
+    const parentPageId = page.ancestors && page.ancestors.length > 0 ? page.ancestors[page.ancestors.length - 1].id : void 0;
+    const rawContent = `${page.title} ${page.body?.storage?.value ?? ""}`;
+    const maxLen = config.maxContentLength ?? 8e3;
+    const condensed = await condenseContent(rawContent, { maxLength: maxLen });
+    const metadata = {
+      source: "confluence",
+      spaceKey,
+      pageId: page.id,
+      status: page.status,
+      url: page._links?.webui ?? "",
+      labels
+    };
+    if (parentPageId) {
+      metadata.parentPageId = parentPageId;
+    }
+    if (condensed.method !== "passthrough") {
+      metadata.condensed = condensed.method;
+      metadata.originalLength = condensed.originalLength;
+    }
     store.addNode({
       id: nodeId,
       type: "document",
       name: sanitizeExternalText(page.title, 500),
-      metadata: {
-        source: "confluence",
-        spaceKey,
-        pageId: page.id,
-        status: page.status,
-        url: page._links?.webui ?? ""
-      }
+      content: condensed.content,
+      metadata
     });
+    if (parentPageId) {
+      const parentNodeId = `confluence:${parentPageId}`;
+      store.addEdge({ from: parentNodeId, to: nodeId, type: "contains" });
+      edgesAdded++;
+    }
     const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
-    const edgesAdded = linkToCode(store, text, nodeId, "documents");
+    edgesAdded += linkToCode(store, text, nodeId, "documents");
     return { nodesAdded: 1, edgesAdded };
   }
 };
@@ -2234,7 +5581,7 @@ var CIConnector = class {
   source = "github-actions";
   httpClient;
   constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
   }
   async ingest(store, config) {
     const start = Date.now();
@@ -2286,6 +5633,306 @@ var CIConnector = class {
   }
 };
 
+// src/ingest/connectors/FigmaConnector.ts
+var CONSTRAINT_KEYWORDS = [
+  "constraint",
+  "must",
+  "required",
+  "minimum",
+  "maximum",
+  "spacing",
+  "padding",
+  "margin",
+  "breakpoint",
+  "responsive",
+  "accessible",
+  "a11y",
+  "wcag"
+];
+function hasConstraintKeyword(text) {
+  const lower = text.toLowerCase();
+  return CONSTRAINT_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function buildIngestResult2(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+var FigmaConnector = class {
+  name = "figma";
+  source = "figma";
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
+  }
+  async ingest(store, config) {
+    const start = Date.now();
+    const apiKeyEnv = config.apiKeyEnv ?? "FIGMA_API_KEY";
+    const apiKey = process.env[apiKeyEnv];
+    if (!apiKey) {
+      return buildIngestResult2(
+        0,
+        0,
+        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        start
+      );
+    }
+    const baseUrlEnv = config.baseUrlEnv ?? "FIGMA_BASE_URL";
+    const baseUrl = process.env[baseUrlEnv] ?? "https://api.figma.com";
+    try {
+      const parsed = new URL(baseUrl);
+      if (parsed.protocol !== "https:" || !parsed.hostname.endsWith("api.figma.com")) {
+        return buildIngestResult2(
+          0,
+          0,
+          [`Invalid ${baseUrlEnv}: must be an HTTPS URL on api.figma.com`],
+          start
+        );
+      }
+    } catch {
+      return buildIngestResult2(0, 0, [`Invalid ${baseUrlEnv}: not a valid URL`], start);
+    }
+    const fileIds = config.fileIds;
+    if (!fileIds || fileIds.length === 0) {
+      return buildIngestResult2(0, 0, ["No fileIds provided in connector config"], start);
+    }
+    const headers = { "X-FIGMA-TOKEN": apiKey };
+    const maxLen = config.maxContentLength ?? 4e3;
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const errors = [];
+    for (const fileId of fileIds) {
+      try {
+        const counts = await this.processFile(store, baseUrl, fileId, headers, maxLen);
+        nodesAdded += counts.nodesAdded;
+        edgesAdded += counts.edgesAdded;
+      } catch (err) {
+        errors.push(
+          `Figma API error for file ${fileId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return buildIngestResult2(nodesAdded, edgesAdded, errors, start);
+  }
+  async processFile(store, baseUrl, fileId, headers, maxLen) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const stylesUrl = `${baseUrl}/v1/files/${fileId}/styles`;
+    const stylesResponse = await this.httpClient(stylesUrl, { headers });
+    if (!stylesResponse.ok) throw new Error(`Styles request failed for file ${fileId}`);
+    const stylesData = await stylesResponse.json();
+    for (const style of stylesData.meta.styles) {
+      const nodeId = `figma:token:${style.key}`;
+      const condensed = await condenseContent(sanitizeExternalText(style.description || "", 2e3), {
+        maxLength: maxLen
+      });
+      const metadata = {
+        source: "figma",
+        key: style.key,
+        styleType: style.style_type,
+        fileId
+      };
+      if (condensed.method !== "passthrough") {
+        metadata.condensed = condensed.method;
+        metadata.originalLength = condensed.originalLength;
+      }
+      store.addNode({
+        id: nodeId,
+        type: "design_token",
+        name: sanitizeExternalText(style.name, 500),
+        content: condensed.content,
+        metadata
+      });
+      nodesAdded++;
+      const searchText = sanitizeExternalText([style.name, style.description].join(" "));
+      edgesAdded += linkToCode(store, searchText, nodeId, "references");
+    }
+    const componentsUrl = `${baseUrl}/v1/files/${fileId}/components`;
+    const componentsResponse = await this.httpClient(componentsUrl, { headers });
+    if (!componentsResponse.ok) throw new Error(`Components request failed for file ${fileId}`);
+    const componentsData = await componentsResponse.json();
+    for (const component of componentsData.meta.components) {
+      const description = component.description || "";
+      if (description) {
+        const intentId = `figma:intent:${component.key}`;
+        const condensed = await condenseContent(sanitizeExternalText(description, 2e3), {
+          maxLength: maxLen
+        });
+        const metadata = {
+          source: "figma",
+          key: component.key,
+          fileId
+        };
+        if (condensed.method !== "passthrough") {
+          metadata.condensed = condensed.method;
+          metadata.originalLength = condensed.originalLength;
+        }
+        store.addNode({
+          id: intentId,
+          type: "aesthetic_intent",
+          name: sanitizeExternalText(component.name, 500),
+          content: condensed.content,
+          metadata
+        });
+        nodesAdded++;
+        const searchText = sanitizeExternalText([component.name, description].join(" "));
+        edgesAdded += linkToCode(store, searchText, intentId, "references");
+      }
+      if (description && hasConstraintKeyword(description)) {
+        const constraintId = `figma:constraint:${component.key}`;
+        const condensed = await condenseContent(sanitizeExternalText(description, 2e3), {
+          maxLength: maxLen
+        });
+        const metadata = {
+          source: "figma",
+          key: component.key,
+          fileId
+        };
+        if (condensed.method !== "passthrough") {
+          metadata.condensed = condensed.method;
+          metadata.originalLength = condensed.originalLength;
+        }
+        store.addNode({
+          id: constraintId,
+          type: "design_constraint",
+          name: sanitizeExternalText(component.name, 500),
+          content: condensed.content,
+          metadata
+        });
+        nodesAdded++;
+        const searchText = sanitizeExternalText([component.name, description].join(" "));
+        edgesAdded += linkToCode(store, searchText, constraintId, "references");
+      }
+    }
+    return { nodesAdded, edgesAdded };
+  }
+};
+
+// src/ingest/connectors/MiroConnector.ts
+var MIN_CONTENT_LENGTH = 10;
+var CONCEPT_ITEM_TYPES = /* @__PURE__ */ new Set(["sticky_note", "text"]);
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "");
+}
+function buildIngestResult3(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+var MiroConnector = class {
+  name = "miro";
+  source = "miro";
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient ?? withRetry((url, options) => fetch(url, options));
+  }
+  async ingest(store, config) {
+    const start = Date.now();
+    const apiKeyEnv = config.apiKeyEnv ?? "MIRO_API_KEY";
+    const apiKey = process.env[apiKeyEnv];
+    if (!apiKey) {
+      return buildIngestResult3(
+        0,
+        0,
+        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        start
+      );
+    }
+    const baseUrlEnv = config.baseUrlEnv ?? "MIRO_BASE_URL";
+    const baseUrl = process.env[baseUrlEnv] ?? "https://api.miro.com";
+    try {
+      const parsed = new URL(baseUrl);
+      if (parsed.protocol !== "https:" || parsed.hostname !== "api.miro.com") {
+        return buildIngestResult3(
+          0,
+          0,
+          [`Invalid ${baseUrlEnv}: must be an HTTPS URL on api.miro.com`],
+          start
+        );
+      }
+    } catch {
+      return buildIngestResult3(0, 0, [`Invalid ${baseUrlEnv}: not a valid URL`], start);
+    }
+    const boardIds = config.boardIds;
+    if (!boardIds || boardIds.length === 0) {
+      return buildIngestResult3(0, 0, ["No boardIds provided in config"], start);
+    }
+    const headers = { Authorization: `Bearer ${apiKey}` };
+    let totalNodesAdded = 0;
+    let totalEdgesAdded = 0;
+    const errors = [];
+    for (const boardId of boardIds) {
+      try {
+        const counts = await this.processBoard(store, baseUrl, boardId, headers);
+        totalNodesAdded += counts.nodesAdded;
+        totalEdgesAdded += counts.edgesAdded;
+      } catch (err) {
+        errors.push(
+          `Miro API error for board ${boardId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    return buildIngestResult3(totalNodesAdded, totalEdgesAdded, errors, start);
+  }
+  async processBoard(store, baseUrl, boardId, headers) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const boardResponse = await this.httpClient(`${baseUrl}/v2/boards/${boardId}`, { headers });
+    if (!boardResponse.ok) throw new Error(`Failed to fetch board ${boardId}`);
+    const board = await boardResponse.json();
+    const boardNodeId = `miro:board:${boardId}`;
+    store.addNode({
+      id: boardNodeId,
+      type: "document",
+      name: sanitizeExternalText(board.name, 500),
+      content: sanitizeExternalText(board.description ?? "", 2e3),
+      metadata: {
+        source: "miro",
+        boardId: board.id
+      }
+    });
+    nodesAdded++;
+    const itemsResponse = await this.httpClient(`${baseUrl}/v2/boards/${boardId}/items`, {
+      headers
+    });
+    if (!itemsResponse.ok) throw new Error(`Failed to fetch items for board ${boardId}`);
+    const itemsData = await itemsResponse.json();
+    for (const item of itemsData.data) {
+      const rawContent = item.data?.content ?? "";
+      const plainContent = stripHtml(rawContent);
+      if (plainContent.length < MIN_CONTENT_LENGTH) continue;
+      if (!CONCEPT_ITEM_TYPES.has(item.type)) continue;
+      const itemNodeId = `miro:item:${item.id}`;
+      store.addNode({
+        id: itemNodeId,
+        type: "business_concept",
+        name: sanitizeExternalText(plainContent, 500),
+        content: sanitizeExternalText(plainContent, 2e3),
+        metadata: {
+          source: "miro",
+          boardId: board.id,
+          itemType: item.type
+        }
+      });
+      nodesAdded++;
+      store.addEdge({ from: boardNodeId, to: itemNodeId, type: "contains" });
+      edgesAdded++;
+      edgesAdded += linkToCode(store, plainContent, itemNodeId, "documents");
+    }
+    return { nodesAdded, edgesAdded };
+  }
+};
+
 // src/search/FusionLayer.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
@@ -2424,7 +6071,7 @@ var FusionLayer = class {
 };
 
 // src/entropy/GraphEntropyAdapter.ts
-var CODE_NODE_TYPES4 = ["file", "function", "class", "method", "interface", "variable"];
+var CODE_NODE_TYPES5 = ["file", "function", "class", "method", "interface", "variable"];
 var GraphEntropyAdapter = class {
   constructor(store) {
     this.store = store;
@@ -2504,7 +6151,7 @@ var GraphEntropyAdapter = class {
   }
   findEntryPoints() {
     const entryPoints = [];
-    for (const nodeType of CODE_NODE_TYPES4) {
+    for (const nodeType of CODE_NODE_TYPES5) {
       const nodes = this.store.findNodes({ type: nodeType });
       for (const node of nodes) {
         const isIndexFile = nodeType === "file" && node.name === "index.ts";
@@ -2540,7 +6187,7 @@ var GraphEntropyAdapter = class {
   }
   collectUnreachableNodes(visited) {
     const unreachableNodes = [];
-    for (const nodeType of CODE_NODE_TYPES4) {
+    for (const nodeType of CODE_NODE_TYPES5) {
       const nodes = this.store.findNodes({ type: nodeType });
       for (const node of nodes) {
         if (!visited.has(node.id)) {
@@ -3386,9 +7033,9 @@ var EntityExtractor = class {
   extractPaths(trimmed, add) {
     const consumed = /* @__PURE__ */ new Set();
     for (const match of trimmed.matchAll(FILE_PATH_RE)) {
-      const path7 = match[0];
-      add(path7);
-      consumed.add(path7);
+      const path13 = match[0];
+      add(path13);
+      consumed.add(path13);
     }
     return consumed;
   }
@@ -3460,8 +7107,8 @@ var EntityResolver = class {
       if (isPathLike && node.path.includes(raw)) {
         return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
       }
-      const basename5 = node.path.split("/").pop() ?? "";
-      if (basename5.includes(raw)) {
+      const basename7 = node.path.split("/").pop() ?? "";
+      if (basename7.includes(raw)) {
         return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
       }
       if (raw.length >= 4 && node.path.includes(raw)) {
@@ -3540,13 +7187,13 @@ var ResponseFormatter = class {
     const context = Array.isArray(d?.context) ? d.context : [];
     const firstEntity = entities[0];
     const nodeType = firstEntity?.node.type ?? "node";
-    const path7 = firstEntity?.node.path ?? "unknown";
+    const path13 = firstEntity?.node.path ?? "unknown";
     let neighborCount = 0;
     const firstContext = context[0];
     if (firstContext && Array.isArray(firstContext.nodes)) {
       neighborCount = firstContext.nodes.length;
     }
-    return `**${entityName}** is a ${nodeType} at \`${path7}\`. Connected to ${neighborCount} nodes.`;
+    return `**${entityName}** is a ${nodeType} at \`${path13}\`. Connected to ${neighborCount} nodes.`;
   }
   formatAnomaly(data) {
     const d = data;
@@ -3929,7 +7576,7 @@ var PHASE_NODE_TYPES = {
   debug: ["failure", "learning", "function", "method"],
   plan: ["adr", "document", "module", "layer"]
 };
-var CODE_NODE_TYPES5 = /* @__PURE__ */ new Set([
+var CODE_NODE_TYPES6 = /* @__PURE__ */ new Set([
   "file",
   "function",
   "class",
@@ -4148,7 +7795,7 @@ var Assembler = class {
    */
   checkCoverage() {
     const codeNodes = [];
-    for (const type of CODE_NODE_TYPES5) {
+    for (const type of CODE_NODE_TYPES6) {
       codeNodes.push(...this.store.findNodes({ type }));
     }
     const documented = [];
@@ -4267,7 +7914,7 @@ function queryTraceability(store, options) {
 
 // src/constraints/GraphConstraintAdapter.ts
 import { minimatch } from "minimatch";
-import { relative as relative2 } from "path";
+import { relative as relative5 } from "path";
 var GraphConstraintAdapter = class {
   constructor(store) {
     this.store = store;
@@ -4296,8 +7943,8 @@ var GraphConstraintAdapter = class {
     const { edges } = this.computeDependencyGraph();
     const violations = [];
     for (const edge of edges) {
-      const fromRelative = relative2(rootDir, edge.from).replaceAll("\\", "/");
-      const toRelative = relative2(rootDir, edge.to).replaceAll("\\", "/");
+      const fromRelative = relative5(rootDir, edge.from).replaceAll("\\", "/");
+      const toRelative = relative5(rootDir, edge.to).replaceAll("\\", "/");
       const fromLayer = this.resolveLayer(fromRelative, layers);
       const toLayer = this.resolveLayer(toRelative, layers);
       if (!fromLayer || !toLayer) continue;
@@ -4328,14 +7975,14 @@ var GraphConstraintAdapter = class {
 };
 
 // src/ingest/DesignIngestor.ts
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as fs11 from "fs/promises";
+import * as path12 from "path";
 function isDTCGToken(obj) {
   return typeof obj === "object" && obj !== null && "$value" in obj && "$type" in obj;
 }
 async function readFileOrNull(filePath) {
   try {
-    return await fs5.readFile(filePath, "utf-8");
+    return await fs11.readFile(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -4481,8 +8128,8 @@ var DesignIngestor = class {
   async ingestAll(designDir) {
     const start = Date.now();
     const [tokensResult, intentResult] = await Promise.all([
-      this.ingestTokens(path6.join(designDir, "tokens.json")),
-      this.ingestDesignIntent(path6.join(designDir, "DESIGN.md"))
+      this.ingestTokens(path12.join(designDir, "tokens.json")),
+      this.ingestDesignIntent(path12.join(designDir, "DESIGN.md"))
     ]);
     const merged = mergeResults(tokensResult, intentResult);
     return { ...merged, durationMs: Date.now() - start };
@@ -4718,10 +8365,10 @@ var TaskIndependenceAnalyzer = class {
         includeTypes: ["file"]
       });
       for (const n of queryResult.nodes) {
-        const path7 = n.path ?? n.id.replace(/^file:/, "");
-        if (!fileSet.has(path7)) {
-          if (!result.has(path7)) {
-            result.set(path7, file);
+        const path13 = n.path ?? n.id.replace(/^file:/, "");
+        if (!fileSet.has(path13)) {
+          if (!result.has(path13)) {
+            result.set(path13, file);
           }
         }
       }
@@ -5098,9 +8745,12 @@ var ConflictPredictor = class {
 };
 
 // src/index.ts
-var VERSION = "0.4.1";
+var VERSION = "0.4.3";
 export {
+  ALL_EXTRACTORS,
+  ApiPathExtractor,
   Assembler,
+  BusinessKnowledgeIngestor,
   CIConnector,
   CURRENT_SCHEMA_VERSION,
   CascadeSimulator,
@@ -5109,11 +8759,18 @@ export {
   ConflictPredictor,
   ConfluenceConnector,
   ContextQL,
+  ContradictionDetector,
+  CoverageScorer,
+  D2Parser,
   DesignConstraintAdapter,
   DesignIngestor,
+  DiagramParser,
   EDGE_TYPES,
   EntityExtractor,
   EntityResolver,
+  EnumConstantExtractor,
+  ExtractionRunner,
+  FigmaConnector,
   FusionLayer,
   GitIngestor,
   GraphAnomalyAdapter,
@@ -5126,24 +8783,38 @@ export {
   GraphNodeSchema,
   GraphStore,
   INTENTS,
+  ImageAnalysisExtractor,
   IntentClassifier,
   JiraConnector,
   KnowledgeIngestor,
+  KnowledgePipelineRunner,
+  KnowledgeStagingAggregator,
+  MermaidParser,
+  MiroConnector,
+  NODE_STABILITY,
   NODE_TYPES,
   OBSERVABILITY_TYPES,
+  PackedSummaryCache,
+  PlantUmlParser,
   RequirementIngestor,
   ResponseFormatter,
   SlackConnector,
+  StructuralDriftDetector,
   SyncManager,
   TaskIndependenceAnalyzer,
+  TestDescriptionExtractor,
   TopologicalLinker,
   VERSION,
+  ValidationRuleExtractor,
   VectorStore,
   askGraph,
   classifyNodeCategory,
+  createExtractionRunner,
+  detectLanguage,
   groupNodesByImpact,
   linkToCode,
   loadGraph,
+  normalizeIntent,
   project,
   queryTraceability,
   saveGraph