@harness-engineering/cli 1.25.7 → 1.26.1

package/dist/{chunk-NKQEMWGT.js → chunk-2FPUPRCY.js}

@@ -19,12 +19,22 @@ import * as fs3 from "fs/promises";
 import * as path4 from "path";
 import * as fs4 from "fs/promises";
 import * as path5 from "path";
+import * as fs9 from "fs/promises";
+import * as path10 from "path";
 import * as fs5 from "fs/promises";
 import * as path6 from "path";
-import { minimatch } from "minimatch";
-import { relative as relative3 } from "path";
 import * as fs6 from "fs/promises";
 import * as path7 from "path";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
+import * as fs8 from "fs/promises";
+import * as path9 from "path";
+import * as fs10 from "fs/promises";
+import * as path11 from "path";
+import { minimatch } from "minimatch";
+import { relative as relative5 } from "path";
+import * as fs11 from "fs/promises";
+import * as path12 from "path";
 function streamGraphJson(filePath, nodes, edges) {
   return new Promise((resolve, reject) => {
     const stream = createWriteStream(filePath, { encoding: "utf-8" });
@@ -353,6 +363,496 @@ function detectEarsPattern(text) {
   if (/^the\s+\w+\s+shall\b/.test(lower)) return "ubiquitous";
   return void 0;
 }
+function emptyResult2(diagramType = "unknown") {
+  return {
+    entities: [],
+    relationships: [],
+    metadata: { format: "mermaid", diagramType }
+  };
+}
+function detectDiagramType(content) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^(?:graph|flowchart)\b/i.test(trimmed)) return "flowchart";
+    if (/^sequenceDiagram\b/.test(trimmed)) return "sequence";
+    if (/^classDiagram\b/.test(trimmed)) return "class";
+    if (/^erDiagram\b/.test(trimmed)) return "er";
+    break;
+  }
+  return "unknown";
+}
+function isDecisionNode(content, nodeId) {
+  const decisionRegex = new RegExp(`${nodeId}\\s*\\{`);
+  return decisionRegex.test(content);
+}
+function buildFlowchartEntity(content, match) {
+  const id = match[1] ?? "";
+  const label = (match[2] ?? "").trim();
+  if (!id) return null;
+  const decision = isDecisionNode(content, id);
+  const entity = {
+    id,
+    label,
+    ...decision ? { type: "decision" } : {}
+  };
+  return { id, entity };
+}
+function extractFlowchartNodes(content) {
+  const entities = /* @__PURE__ */ new Map();
+  const nodeRegex = /([A-Za-z0-9_]+)\s*[[({]([^\])}]+)[\])}]/g;
+  let match = nodeRegex.exec(content);
+  while (match !== null) {
+    const parsed = buildFlowchartEntity(content, match);
+    if (parsed && !entities.has(parsed.id)) {
+      entities.set(parsed.id, parsed.entity);
+    }
+    match = nodeRegex.exec(content);
+  }
+  return entities;
+}
+function parseLabeledEdgeMatch(match) {
+  const from = match[1] ?? "";
+  const label = (match[2] ?? "").trim();
+  const to = match[3] ?? "";
+  if (!from || !to) return null;
+  return { key: `${from}->${to}:${label}`, rel: { from, to, label } };
+}
+function extractLabeledEdges(stripped, edgeKeys) {
+  const relationships = [];
+  const labeledEdgeRegex = /([A-Za-z0-9_]+)\s*--+>?\|([^|]+)\|\s*([A-Za-z0-9_]+)/g;
+  let match = labeledEdgeRegex.exec(stripped);
+  while (match !== null) {
+    const parsed = parseLabeledEdgeMatch(match);
+    if (parsed && !edgeKeys.has(parsed.key)) {
+      edgeKeys.add(parsed.key);
+      relationships.push(parsed.rel);
+    }
+    match = labeledEdgeRegex.exec(stripped);
+  }
+  return relationships;
+}
+function hasLabeledEdgeBetween(labeledEdges, from, to) {
+  return labeledEdges.some((r) => r.from === from && r.to === to);
+}
+function extractUnlabeledEdges(stripped, edgeKeys, labeledEdges) {
+  const relationships = [];
+  const unlabeledEdgeRegex = /([A-Za-z0-9_]+)\s*--+>?\s+([A-Za-z0-9_]+)/g;
+  let match = unlabeledEdgeRegex.exec(stripped);
+  while (match !== null) {
+    const from = match[1] ?? "";
+    const to = match[2] ?? "";
+    const key = `${from}->${to}`;
+    if (from && to && !hasLabeledEdgeBetween(labeledEdges, from, to) && !edgeKeys.has(key)) {
+      edgeKeys.add(key);
+      relationships.push({ from, to });
+    }
+    match = unlabeledEdgeRegex.exec(stripped);
+  }
+  return relationships;
+}
+function parseFlowchart(content, diagramType) {
+  const entities = extractFlowchartNodes(content);
+  const stripped = content.replace(/[[({][^\])}]*[\])}]/g, "");
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const labeledEdges = extractLabeledEdges(stripped, edgeKeys);
+  const unlabeledEdges = extractUnlabeledEdges(stripped, edgeKeys, labeledEdges);
+  return {
+    entities: Array.from(entities.values()),
+    relationships: [...labeledEdges, ...unlabeledEdges],
+    metadata: { format: "mermaid", diagramType }
+  };
+}
+function extractParticipants(content) {
+  const entities = [];
+  const seenParticipants = /* @__PURE__ */ new Set();
+  const participantRegex = /participant\s+(\w+)(?:\s+as\s+(.+))?/g;
+  let 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);
+  }
+  return entities;
+}
+function relationshipFromMatch(match) {
+  const from = match[1] ?? "";
+  const to = match[2] ?? "";
+  const label = (match[3] ?? "").trim();
+  return from && to ? { from, to, label } : null;
+}
+function collectMessageMatches(content, regex) {
+  const results = [];
+  let match = regex.exec(content);
+  while (match !== null) {
+    const rel = relationshipFromMatch(match);
+    if (rel) results.push(rel);
+    match = regex.exec(content);
+  }
+  return results;
+}
+function extractMessages(content) {
+  const forward = collectMessageMatches(content, /(\w+)\s*->>?\+?\s*(\w+)\s*:\s*(.+)/g);
+  const returns = collectMessageMatches(content, /(\w+)\s*-->>?-?\s*(\w+)\s*:\s*(.+)/g);
+  return [...forward, ...returns];
+}
+function parseSequence(content, diagramType) {
+  return {
+    entities: extractParticipants(content),
+    relationships: extractMessages(content),
+    metadata: { format: "mermaid", diagramType }
+  };
+}
+function emptyResult3() {
+  return {
+    entities: [],
+    relationships: [],
+    metadata: { format: "d2", diagramType: "architecture" }
+  };
+}
+function parseBlockShape(stripped) {
+  const match = stripped.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.+?)\s*\{$/);
+  if (match) {
+    const id = match[1];
+    const label = match[2];
+    if (id && label) return { id, label };
+  }
+  return null;
+}
+function parseConnection(stripped) {
+  const match = stripped.match(/^([a-zA-Z0-9_.-]+)\s*->\s*([a-zA-Z0-9_.-]+)(?:\s*:\s*(.+?))?$/);
+  if (match) {
+    const from = match[1] ?? "";
+    const to = match[2] ?? "";
+    const label = match[3]?.trim();
+    if (from && to) return { from, to, ...label ? { label } : {} };
+  }
+  return null;
+}
+function parseSimpleShape(stripped) {
+  const match = stripped.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.+)$/);
+  if (match) {
+    const id = match[1];
+    const label = (match[2] ?? "").trim();
+    if (id && label) return { id, label };
+  }
+  return null;
+}
+function handleBlockOpen(stripped, state) {
+  if (state.braceDepth === 0) {
+    const shape = parseBlockShape(stripped);
+    if (shape) state.entities.set(shape.id, { id: shape.id, label: shape.label });
+  }
+  state.braceDepth++;
+}
+function processTopLevelLine(stripped, state) {
+  const conn = parseConnection(stripped);
+  if (conn) {
+    state.relationships.push(conn);
+    return;
+  }
+  const shape = parseSimpleShape(stripped);
+  if (shape && !state.entities.has(shape.id)) {
+    state.entities.set(shape.id, { id: shape.id, label: shape.label });
+  }
+}
+function processD2Line(stripped, state) {
+  if (!stripped || stripped.startsWith("#")) return;
+  if (stripped.endsWith("{")) {
+    handleBlockOpen(stripped, state);
+    return;
+  }
+  if (stripped === "}") {
+    state.braceDepth = Math.max(0, state.braceDepth - 1);
+    return;
+  }
+  if (state.braceDepth > 0) return;
+  processTopLevelLine(stripped, state);
+}
+function emptyResult4() {
+  return {
+    entities: [],
+    relationships: [],
+    metadata: { format: "plantuml", diagramType: "unknown" }
+  };
+}
+function detectDiagramType2(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";
+}
+function stripWrappers(content) {
+  return content.replace(/@startuml\b.*\n?/, "").replace(/@enduml\b.*/, "").trim();
+}
+function extractClasses(body, entities) {
+  const classRegex = /class\s+(\w+)/g;
+  let 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);
+  }
+}
+function extractComponents(body, entities) {
+  const componentRegex = /\[([^\]]+)\]/g;
+  let match = componentRegex.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 = componentRegex.exec(body);
+  }
+}
+function parseRelationshipMatch(match) {
+  const from = match[1] ?? "";
+  const to = match[2] ?? "";
+  if (!from || !to) return null;
+  const label = match[3]?.trim();
+  return { from, to, ...label ? { label } : {} };
+}
+function collectRelationshipMatches(body, regex) {
+  const results = [];
+  let match = regex.exec(body);
+  while (match !== null) {
+    const rel = parseRelationshipMatch(match);
+    if (rel) results.push(rel);
+    match = regex.exec(body);
+  }
+  return results;
+}
+function extractRelationships(body) {
+  return collectRelationshipMatches(
+    body,
+    /(\w+)\s*(?:-->|->|<--|<-|\.\.>|--)\s*(\w+)(?:\s*:\s*(.+))?/g
+  );
+}
+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);
+  }
+}
+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];
+}
+function createExtractionRunner() {
+  return new ExtractionRunner(ALL_EXTRACTORS);
+}
+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";
+}
+function buildEntry(node, source) {
+  return {
+    nodeId: node.id,
+    source,
+    name: node.name,
+    content: node.content ?? "",
+    lastModified: node.lastModified
+  };
+}
+function groupByName(nodes) {
+  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);
+  }
+  return byName;
+}
+function tryAddContradiction(acc, a, b, similarity) {
+  const sourceA = a.metadata.source ?? "unknown";
+  const sourceB = b.metadata.source ?? "unknown";
+  if (sourceA === sourceB) return;
+  if ((a.hash ?? a.id) === (b.hash ?? b.id)) return;
+  const pairId = [a.id, b.id].sort().join(":");
+  if (acc.seen.has(pairId)) return;
+  acc.seen.add(pairId);
+  const conflictType = classifyConflict(a, b);
+  const pairKey = [sourceA, sourceB].sort().join("\u2194");
+  acc.sourcePairCounts[pairKey] = (acc.sourcePairCounts[pairKey] ?? 0) + 1;
+  acc.contradictions.push({
+    id: `contradiction:${a.id}:${b.id}`,
+    entityA: buildEntry(a, sourceA),
+    entityB: buildEntry(b, sourceB),
+    similarity,
+    conflictType,
+    severity: SEVERITY_MAP[conflictType],
+    description: `"${a.name}" has conflicting definitions from ${sourceA} and ${sourceB}`
+  });
+}
+function collectExactMatches(byName, acc) {
+  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++) {
+        tryAddContradiction(acc, group[i], group[j], 1);
+      }
+    }
+  }
+}
+function collectFuzzyMatches(byName, acc) {
+  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) {
+          tryAddContradiction(acc, a, b, ratio);
+        }
+      }
+    }
+  }
+}
+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";
+}
+function groupByDomain(nodes, fallback) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const domain = node.metadata.domain ?? fallback(node);
+    const group = map.get(domain) ?? [];
+    group.push(node);
+    map.set(domain, group);
+  }
+  return map;
+}
+function countLinkedEntities(codeEntries, store) {
+  const linkedIds = /* @__PURE__ */ new Set();
+  for (const codeNode of codeEntries) {
+    if (hasKnowledgeEdge(codeNode.id, store)) {
+      linkedIds.add(codeNode.id);
+    }
+  }
+  return linkedIds;
+}
+function hasKnowledgeEdge(nodeId, store) {
+  for (const edgeType of KNOWLEDGE_EDGE_TYPES) {
+    if (store.getEdges({ to: nodeId, type: edgeType }).length > 0) return true;
+  }
+  return false;
+}
+function computeSourceBreakdown(knEntries) {
+  const breakdown = {};
+  for (const kn of knEntries) {
+    const src = kn.metadata.source ?? "unknown";
+    breakdown[src] = (breakdown[src] ?? 0) + 1;
+  }
+  return breakdown;
+}
+function computeDomainScore(knowledgeEntries, codeEntities, linkedEntities, uniqueSources) {
+  const codeCoverageComponent = codeEntities > 0 ? linkedEntities / codeEntities * 60 : 0;
+  const knowledgeDepthComponent = Math.min(knowledgeEntries / 10, 1) * 20;
+  const sourceDiversityComponent = Math.min(uniqueSources / 3, 1) * 20;
+  return Math.round(codeCoverageComponent + knowledgeDepthComponent + sourceDiversityComponent);
+}
+function scoreDomain(domain, knEntries, codeEntries, store) {
+  const linkedIds = countLinkedEntities(codeEntries, store);
+  const sourceBreakdown = computeSourceBreakdown(knEntries);
+  const codeEntities = codeEntries.length;
+  const linkedEntities = linkedIds.size;
+  const knowledgeEntries = knEntries.length;
+  const uniqueSources = Object.keys(sourceBreakdown).length;
+  const score = computeDomainScore(knowledgeEntries, codeEntities, linkedEntities, uniqueSources);
+  return {
+    domain,
+    score,
+    knowledgeEntries,
+    codeEntities,
+    linkedEntities,
+    unlinkedEntities: codeEntities - linkedEntities,
+    sourceBreakdown,
+    grade: toGrade(score)
+  };
+}
+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");
+  };
+}
 function sanitizeExternalText(text, maxLength = 2e3) {
   let sanitized = text;
   for (const rule of SANITIZE_RULES) {
@@ -383,6 +883,44 @@ function linkToCode(store, content, sourceNodeId, edgeType, options) {
   }
   return edgesCreated;
 }
+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
+  };
+}
 function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
   return {
     nodesAdded,
@@ -408,6 +946,28 @@ function buildJql(config) {
   }
   return jql;
 }
+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;
+}
 function missingApiKeyResult(envVar, start) {
   return {
     nodesAdded: 0,
@@ -418,7 +978,7 @@ function missingApiKeyResult(envVar, start) {
     durationMs: Date.now() - start
   };
 }
-function emptyResult2(errors, start) {
+function emptyResult5(errors, start) {
   return {
     nodesAdded: 0,
     nodesUpdated: 0,
@@ -473,6 +1033,99 @@ function ingestRun(store, run) {
   }
   return { nodesAdded, edgesAdded };
 }
+function hasConstraintKeyword(text) {
+  const lower = text.toLowerCase();
+  return CONSTRAINT_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function buildNodeMetadata(condensed, base) {
+  const metadata = { ...base };
+  if (condensed.method !== "passthrough") {
+    metadata.condensed = condensed.method;
+    metadata.originalLength = condensed.originalLength;
+  }
+  return metadata;
+}
+function buildIngestResult2(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+function validateFigmaConfig(config) {
+  const apiKeyEnv = config.apiKeyEnv ?? "FIGMA_API_KEY";
+  const apiKey = process.env[apiKeyEnv];
+  if (!apiKey) return { error: `Missing API key: environment variable "${apiKeyEnv}" is not set` };
+  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 { error: `Invalid ${baseUrlEnv}: must be an HTTPS URL on api.figma.com` };
+    }
+  } catch {
+    return { error: `Invalid ${baseUrlEnv}: not a valid URL` };
+  }
+  const fileIds = config.fileIds;
+  if (!fileIds || fileIds.length === 0) return { error: "No fileIds provided in connector config" };
+  return { apiKey, baseUrl, fileIds };
+}
+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
+  };
+}
+function validateBaseUrl(baseUrl, baseUrlEnv) {
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "https:" || parsed.hostname !== "api.miro.com") {
+      return `Invalid ${baseUrlEnv}: must be an HTTPS URL on api.miro.com`;
+    }
+  } catch {
+    return `Invalid ${baseUrlEnv}: not a valid URL`;
+  }
+  return null;
+}
+function resolveConfig(config, start) {
+  const apiKeyEnv = config.apiKeyEnv ?? "MIRO_API_KEY";
+  const apiKey = process.env[apiKeyEnv];
+  if (!apiKey) {
+    return {
+      ok: false,
+      result: 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";
+  const urlError = validateBaseUrl(baseUrl, baseUrlEnv);
+  if (urlError) {
+    return { ok: false, result: buildIngestResult3(0, 0, [urlError], start) };
+  }
+  const boardIds = config.boardIds;
+  if (!boardIds || boardIds.length === 0) {
+    return {
+      ok: false,
+      result: buildIngestResult3(0, 0, ["No boardIds provided in config"], start)
+    };
+  }
+  return { ok: true, apiKey, baseUrl, boardIds, headers: { Authorization: `Bearer ${apiKey}` } };
+}
 function isSkippableWord(cleaned, allConsumed) {
   if (allConsumed.has(cleaned)) return true;
   const lower = cleaned.toLowerCase();
@@ -700,7 +1353,7 @@ function isDTCGToken(obj) {
 }
 async function readFileOrNull(filePath) {
   try {
-    return await fs6.readFile(filePath, "utf-8");
+    return await fs11.readFile(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -782,7 +1435,7 @@ function parseAntiPatterns(content) {
   }
   return patterns;
 }
-var NODE_TYPES, EDGE_TYPES, OBSERVABILITY_TYPES, CURRENT_SCHEMA_VERSION, NODE_STABILITY, GraphNodeSchema, GraphEdgeSchema, POISONED_KEYS, GraphStore, VectorStore, DEFAULT_TTL_MS, PackedSummaryCache, ContextQL, TEST_TYPES, DOC_TYPES, CODE_TYPES, SKIP_METHOD_NAMES, FUNCTION_PATTERNS, CLASS_PATTERNS, INTERFACE_PATTERNS, METHOD_PATTERNS, GO_METHOD_PATTERN, VARIABLE_PATTERNS, SUPPORTED_EXTENSIONS, SKIP_EXTENSIONS, CodeIngestor, execFileAsync, GitIngestor, TopologicalLinker, CODE_NODE_TYPES, KnowledgeIngestor, BUSINESS_KNOWLEDGE_TYPES, GOVERNS_SOURCE_TYPES, CODE_NODE_TYPES2, MEASURABLE_TYPES, BusinessKnowledgeIngestor, REQUIREMENT_SECTIONS, SECTION_HEADING_RE, NUMBERED_ITEM_RE, CODE_NODE_TYPES3, RequirementIngestor, CODE_NODE_TYPES4, SANITIZE_RULES, SyncManager, JiraConnector, SlackConnector, ConfluenceConnector, CIConnector, STOP_WORDS, FusionLayer, CODE_NODE_TYPES5, GraphEntropyAdapter, GraphComplexityAdapter, GraphCouplingAdapter, DEFAULT_THRESHOLD, DEFAULT_METRICS, RECOGNIZED_METRICS, GraphAnomalyAdapter, INTENTS, SIGNAL_WEIGHTS, INTENT_SIGNALS, IntentClassifier, INTENT_KEYWORDS, STOP_WORDS2, PASCAL_OR_CAMEL_RE, FILE_PATH_RE, QUOTED_RE, EntityExtractor, EntityResolver, ResponseFormatter, CompositeProbabilityStrategy, DEFAULT_PROBABILITY_FLOOR, DEFAULT_MAX_DEPTH, CascadeSimulator, ENTITY_REQUIRED_INTENTS, classifier, extractor, formatter, PHASE_NODE_TYPES, CODE_NODE_TYPES6, Assembler, GraphConstraintAdapter, DesignIngestor, DesignConstraintAdapter, GraphFeedbackAdapter, DEFAULT_EDGE_TYPES, TaskIndependenceAnalyzer, ConflictPredictor, VERSION;
+var NODE_TYPES, EDGE_TYPES, OBSERVABILITY_TYPES, CURRENT_SCHEMA_VERSION, NODE_STABILITY, GraphNodeSchema, GraphEdgeSchema, POISONED_KEYS, GraphStore, VectorStore, DEFAULT_TTL_MS, PackedSummaryCache, ContextQL, TEST_TYPES, DOC_TYPES, CODE_TYPES, SKIP_METHOD_NAMES, FUNCTION_PATTERNS, CLASS_PATTERNS, INTERFACE_PATTERNS, METHOD_PATTERNS, GO_METHOD_PATTERN, VARIABLE_PATTERNS, SUPPORTED_EXTENSIONS, SKIP_EXTENSIONS, CodeIngestor, execFileAsync, GitIngestor, TopologicalLinker, CODE_NODE_TYPES, KnowledgeIngestor, BUSINESS_KNOWLEDGE_TYPES, GOVERNS_SOURCE_TYPES, CODE_NODE_TYPES2, MEASURABLE_TYPES, BusinessKnowledgeIngestor, REQUIREMENT_SECTIONS, SECTION_HEADING_RE, NUMBERED_ITEM_RE, CODE_NODE_TYPES3, RequirementIngestor, MermaidParser, D2Parser, PlantUmlParser, DIAGRAM_EXTENSIONS, SKIP_DIRS, DiagramParser, HEURISTIC_PATTERNS, SCANNABLE_TYPES, KnowledgeLinker, StructuralDriftDetector, KnowledgeStagingAggregator, SKIP_DIRS2, EXT_TO_LANGUAGE, SKIP_EXTENSIONS2, EXTRACTOR_EDGE_TYPE, ExtractionRunner, PATTERNS, TestDescriptionExtractor, EnumConstantExtractor, ValidationRuleExtractor, ApiPathExtractor, ALL_EXTRACTORS, ImageAnalysisExtractor, KNOWLEDGE_NODE_TYPES, SIMILARITY_THRESHOLD, SEVERITY_MAP, ContradictionDetector, KNOWLEDGE_TYPES, CODE_TYPES2, KNOWLEDGE_EDGE_TYPES, CoverageScorer, BUSINESS_NODE_TYPES, SNAPSHOT_NODE_TYPES, KnowledgePipelineRunner, CODE_NODE_TYPES4, RETRYABLE_STATUSES, SANITIZE_RULES, SyncManager, SUMMARIZE_PROMPT, JiraConnector, SlackConnector, ConfluenceConnector, CIConnector, CONSTRAINT_KEYWORDS, FigmaConnector, MIN_CONTENT_LENGTH, CONCEPT_ITEM_TYPES, MiroConnector, STOP_WORDS, FusionLayer, CODE_NODE_TYPES5, GraphEntropyAdapter, GraphComplexityAdapter, GraphCouplingAdapter, DEFAULT_THRESHOLD, DEFAULT_METRICS, RECOGNIZED_METRICS, GraphAnomalyAdapter, INTENTS, SIGNAL_WEIGHTS, INTENT_SIGNALS, IntentClassifier, INTENT_KEYWORDS, STOP_WORDS2, PASCAL_OR_CAMEL_RE, FILE_PATH_RE, QUOTED_RE, EntityExtractor, EntityResolver, ResponseFormatter, CompositeProbabilityStrategy, DEFAULT_PROBABILITY_FLOOR, DEFAULT_MAX_DEPTH, CascadeSimulator, ENTITY_REQUIRED_INTENTS, classifier, extractor, formatter, PHASE_NODE_TYPES, CODE_NODE_TYPES6, Assembler, GraphConstraintAdapter, DesignIngestor, DesignConstraintAdapter, GraphFeedbackAdapter, DEFAULT_EDGE_TYPES, TaskIndependenceAnalyzer, ConflictPredictor, VERSION;
 var init_dist = __esm({
   "../graph/dist/index.mjs"() {
     NODE_TYPES = [
@@ -822,6 +1475,7 @@ var init_dist = __esm({
       "design_token",
       "aesthetic_intent",
       "design_constraint",
+      "image_annotation",
       // Traceability
       "requirement",
       // Business Knowledge
@@ -830,6 +1484,7 @@ var init_dist = __esm({
       "business_concept",
       "business_term",
       "business_metric",
+      "business_fact",
       // Cache
       "packed_summary"
     ];
@@ -869,6 +1524,7 @@ var init_dist = __esm({
       // Business Knowledge relationships
       "governs",
       "measures",
+      "annotates",
       // Cache relationships
       "caches"
     ];
@@ -2671,80 +3327,2328 @@ var init_dist = __esm({
         return count;
       }
     };
-    CODE_NODE_TYPES4 = ["file", "function", "class", "method", "interface", "variable"];
-    SANITIZE_RULES = [
-      // Strip XML/HTML-like instruction tags that could be interpreted as system prompts
-      {
-        pattern: /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
-        replacement: ""
-      },
-      // Strip markdown-style system prompt markers (including trailing space)
-      {
-        pattern: /^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim,
-        replacement: ""
-      },
-      // Strip common injection prefixes
-      {
-        pattern: /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
-        replacement: "[filtered]"
-      },
-      // Strip "you are now" re-roling attempts (only when followed by AI/agent role words)
-      {
-        pattern: /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
-        replacement: "[filtered]"
+    MermaidParser = class {
+      canParse(_content, ext) {
+        return ext === ".mmd" || ext === ".mermaid";
       }
-    ];
-    SyncManager = class {
-      constructor(store, graphDir) {
-        this.store = store;
-        this.metadataPath = path6.join(graphDir, "sync-metadata.json");
+      parse(content, _filePath) {
+        const trimmed = content.trim();
+        if (!trimmed) {
+          return emptyResult2();
+        }
+        const diagramType = detectDiagramType(trimmed);
+        switch (diagramType) {
+          case "flowchart":
+            return parseFlowchart(trimmed, diagramType);
+          case "sequence":
+            return parseSequence(trimmed, diagramType);
+          default:
+            return emptyResult2(diagramType);
+        }
       }
-      store;
-      registrations = /* @__PURE__ */ new Map();
-      metadataPath;
-      registerConnector(connector, config) {
-        this.registrations.set(connector.name, { connector, config });
+    };
+    D2Parser = class {
+      canParse(_content, ext) {
+        return ext === ".d2";
       }
-      async sync(connectorName) {
-        const registration = this.registrations.get(connectorName);
-        if (!registration) {
-          return {
-            nodesAdded: 0,
-            nodesUpdated: 0,
-            edgesAdded: 0,
-            edgesUpdated: 0,
-            errors: [`Connector "${connectorName}" not registered`],
-            durationMs: 0
-          };
+      parse(content, _filePath) {
+        const trimmed = content.trim();
+        if (!trimmed) return emptyResult3();
+        const state = {
+          entities: /* @__PURE__ */ new Map(),
+          relationships: [],
+          braceDepth: 0
+        };
+        for (const line of trimmed.split("\n")) {
+          processD2Line(line.trim(), state);
         }
-        const { connector, config } = registration;
-        const result = await connector.ingest(this.store, config);
-        const metadata = await this.loadMetadata();
-        metadata.connectors[connectorName] = {
-          lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          lastResult: result
+        return {
+          entities: Array.from(state.entities.values()),
+          relationships: state.relationships,
+          metadata: { format: "d2", diagramType: "architecture" }
         };
-        await this.saveMetadata(metadata);
-        return result;
       }
-      async syncAll() {
-        const combined = {
-          nodesAdded: 0,
-          nodesUpdated: 0,
-          edgesAdded: 0,
-          edgesUpdated: 0,
-          errors: [],
-          durationMs: 0
+    };
+    PlantUmlParser = class {
+      canParse(_content, ext) {
+        return ext === ".puml" || ext === ".plantuml";
+      }
+      parse(content, _filePath) {
+        const trimmed = content.trim();
+        if (!trimmed) return emptyResult4();
+        const diagramType = detectDiagramType2(trimmed);
+        const entities = /* @__PURE__ */ new Map();
+        const body = stripWrappers(trimmed);
+        extractClasses(body, entities);
+        extractComponents(body, entities);
+        const relationships = extractRelationships(body);
+        return {
+          entities: Array.from(entities.values()),
+          relationships,
+          metadata: { format: "plantuml", diagramType }
         };
-        for (const [name] of this.registrations) {
-          const result = await this.sync(name);
-          combined.nodesAdded += result.nodesAdded;
-          combined.nodesUpdated += result.nodesUpdated;
-          combined.edgesAdded += result.edgesAdded;
+      }
+    };
+    DIAGRAM_EXTENSIONS = /* @__PURE__ */ new Set([".mmd", ".mermaid", ".d2", ".puml", ".plantuml"]);
+    SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".harness"]);
+    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);
+            nodesAdded += this.addEntityNodes(result, relPath, pathHash);
+            edgesAdded += this.addRelationshipEdges(result, pathHash);
+          } 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
+        };
+      }
+      /** Map diagram entities to business_concept graph nodes. */
+      addEntityNodes(result, relPath, pathHash) {
+        let count = 0;
+        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 } : {}
+            }
+          });
+          count++;
+        }
+        return count;
+      }
+      /** Map diagram relationships to references graph edges. */
+      addRelationshipEdges(result, pathHash) {
+        let count = 0;
+        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 } : {}
+            }
+          });
+          count++;
+        }
+        return count;
+      }
+      async findDiagramFiles(dir) {
+        const files = [];
+        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_DIRS.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;
+      }
+    };
+    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"
+      }
+    ];
+    SCANNABLE_TYPES = ["issue", "conversation", "document"];
+    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;
+      }
+    };
+    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 };
+      }
+    };
+    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");
+      }
+    };
+    SKIP_DIRS2 = /* @__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"
+    ]);
+    EXT_TO_LANGUAGE = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java"
+    };
+    SKIP_EXTENSIONS2 = /* @__PURE__ */ new Set([".d.ts"]);
+    EXTRACTOR_EDGE_TYPE = {
+      "test-descriptions": "governs",
+      "enum-constants": "documents",
+      "validation-rules": "governs",
+      "api-paths": "documents"
+    };
+    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_DIRS2.has(entry.name)) {
+            results.push(...await this.findSourceFiles(fullPath));
+          } else if (entry.isFile() && detectLanguage(fullPath) !== void 0) {
+            results.push(fullPath);
+          }
+        }
+        return results;
+      }
+    };
+    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
+      ]
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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;
+      }
+    };
+    ALL_EXTRACTORS = [
+      new TestDescriptionExtractor(),
+      new EnumConstantExtractor(),
+      new ValidationRuleExtractor(),
+      new ApiPathExtractor()
+    ];
+    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 counts = await this.processImage(store, imagePath);
+            nodesAdded += counts.nodes;
+            edgesAdded += counts.edges;
+          } 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
+        };
+      }
+      /** Analyze a single image and add annotation + concept nodes to the store. */
+      async processImage(store, imagePath) {
+        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 annotationId = `img:${hash(imagePath)}`;
+        let nodes = 0;
+        let edges = 0;
+        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
+          }
+        });
+        nodes++;
+        edges += this.linkToFileNode(store, annotationId, imagePath);
+        for (const pattern of result.designPatterns) {
+          edges += this.addDesignPatternConcept(store, annotationId, imagePath, pattern);
+          nodes++;
+        }
+        return { nodes, edges };
+      }
+      /** Link annotation to its source file node if it exists. Returns 1 if linked, 0 otherwise. */
+      linkToFileNode(store, annotationId, imagePath) {
+        const fileNode = store.findNodes({ type: "file" }).find((n) => n.path === imagePath);
+        if (!fileNode) return 0;
+        store.addEdge({ from: annotationId, to: fileNode.id, type: "annotates" });
+        return 1;
+      }
+      /** Create a business_concept node for a design pattern and link it. Returns edges added. */
+      addDesignPatternConcept(store, annotationId, imagePath, pattern) {
+        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"
+          }
+        });
+        store.addEdge({ from: annotationId, to: conceptId, type: "contains" });
+        return 1;
+      }
+    };
+    KNOWLEDGE_NODE_TYPES = [
+      "business_fact",
+      "business_rule",
+      "business_process",
+      "business_term",
+      "business_concept",
+      "business_metric",
+      "design_token",
+      "design_constraint",
+      "aesthetic_intent",
+      "image_annotation"
+    ];
+    SIMILARITY_THRESHOLD = 0.8;
+    SEVERITY_MAP = {
+      value_mismatch: "critical",
+      definition_conflict: "high",
+      status_divergence: "medium",
+      temporal_conflict: "medium"
+    };
+    ContradictionDetector = class {
+      detect(store) {
+        const nodes = KNOWLEDGE_NODE_TYPES.flatMap((t) => store.findNodes({ type: t }));
+        const byName = groupByName(nodes);
+        const acc = {
+          contradictions: [],
+          sourcePairCounts: {},
+          seen: /* @__PURE__ */ new Set()
+        };
+        collectExactMatches(byName, acc);
+        collectFuzzyMatches(byName, acc);
+        return {
+          contradictions: acc.contradictions,
+          sourcePairCounts: acc.sourcePairCounts,
+          totalChecked: nodes.length
+        };
+      }
+    };
+    KNOWLEDGE_TYPES = KNOWLEDGE_NODE_TYPES;
+    CODE_TYPES2 = [
+      "file",
+      "function",
+      "class",
+      "method",
+      "interface",
+      "variable"
+    ];
+    KNOWLEDGE_EDGE_TYPES = [
+      "governs",
+      "documents",
+      "measures",
+      "applies_to",
+      "references",
+      "uses_token",
+      "declares_intent",
+      "annotates"
+    ];
+    CoverageScorer = class {
+      score(store) {
+        const knowledgeNodes = KNOWLEDGE_TYPES.flatMap((t) => store.findNodes({ type: t }));
+        const domainMap = groupByDomain(knowledgeNodes, () => "unclassified");
+        const codeNodes = CODE_TYPES2.flatMap((t) => store.findNodes({ type: t }));
+        const codeDomains = groupByDomain(codeNodes, (n) => this.domainFromPath(n.path));
+        const allDomains = /* @__PURE__ */ new Set([...domainMap.keys(), ...codeDomains.keys()]);
+        const domains = [];
+        for (const domain of allDomains) {
+          domains.push(
+            scoreDomain(domain, domainMap.get(domain) ?? [], codeDomains.get(domain) ?? [], store)
+          );
+        }
+        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";
+      }
+    };
+    BUSINESS_NODE_TYPES = [
+      "business_concept",
+      "business_rule",
+      "business_process",
+      "business_term",
+      "business_metric",
+      "business_fact"
+    ];
+    SNAPSHOT_NODE_TYPES = [
+      ...BUSINESS_NODE_TYPES,
+      "design_token",
+      "design_constraint",
+      "aesthetic_intent",
+      "image_annotation"
+    ];
+    KnowledgePipelineRunner = class {
+      constructor(store) {
+        this.store = store;
+      }
+      store;
+      async run(options) {
+        const remediations = [];
+        const extraction = await this.extract(options);
+        let driftResult = this.runReconciliation(options);
+        const contradictions = new ContradictionDetector().detect(this.store);
+        let gapReport = await this.detect(options);
+        const coverage = new CoverageScorer().score(this.store);
+        const iterations = options.fix ? await this.runRemediationLoop(options, driftResult, gapReport, remediations) : 1;
+        if (options.fix && iterations > 1) {
+          driftResult = this.runReconciliation(options);
+          gapReport = await this.detect(options);
+        }
+        await this.stageNewFindings(driftResult, options);
+        return this.buildResult(
+          driftResult,
+          iterations,
+          extraction,
+          gapReport,
+          remediations,
+          contradictions,
+          coverage
+        );
+      }
+      /** Run phases 1-2 (extract snapshot, reconcile) and return drift result. */
+      runReconciliation(options) {
+        const preSnapshot = this.buildSnapshot(options.domain);
+        const postSnapshot = this.buildSnapshot(options.domain);
+        return this.reconcile(preSnapshot, postSnapshot);
+      }
+      /** Run the remediation convergence loop; returns total iteration count. */
+      async runRemediationLoop(options, driftResult, _gapReport, remediations) {
+        const maxIterations = options.maxIterations ?? 5;
+        let iterations = 1;
+        let currentDrift = driftResult;
+        let previousFindingCount = currentDrift.findings.length;
+        while (iterations < maxIterations) {
+          if (currentDrift.findings.length === 0) break;
+          this.remediate(currentDrift, remediations, options);
+          await this.extract(options);
+          currentDrift = this.runReconciliation(options);
+          await this.detect(options);
+          iterations++;
+          if (currentDrift.findings.length >= previousFindingCount) break;
+          previousFindingCount = currentDrift.findings.length;
+        }
+        return iterations;
+      }
+      /** Assemble the final pipeline result. */
+      buildResult(driftResult, iterations, extraction, gaps, remediations, contradictions, coverage) {
+        return {
+          verdict: this.computeVerdict(driftResult),
+          driftScore: driftResult.driftScore,
+          iterations,
+          findings: driftResult.summary,
+          extraction,
+          gaps,
+          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
+        };
+      }
+      // ── 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;
+          }
+        }
+      }
+      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";
+      }
+    };
+    CODE_NODE_TYPES4 = ["file", "function", "class", "method", "interface", "variable"];
+    RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+    SANITIZE_RULES = [
+      // Strip XML/HTML-like instruction tags that could be interpreted as system prompts
+      {
+        pattern: /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
+        replacement: ""
+      },
+      // Strip markdown-style system prompt markers (including trailing space)
+      {
+        pattern: /^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim,
+        replacement: ""
+      },
+      // Strip common injection prefixes
+      {
+        pattern: /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
+        replacement: "[filtered]"
+      },
+      // Strip "you are now" re-roling attempts (only when followed by AI/agent role words)
+      {
+        pattern: /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
+        replacement: "[filtered]"
+      }
+    ];
+    SyncManager = class {
+      constructor(store, graphDir) {
+        this.store = store;
+        this.metadataPath = path11.join(graphDir, "sync-metadata.json");
+      }
+      store;
+      registrations = /* @__PURE__ */ new Map();
+      metadataPath;
+      registerConnector(connector, config) {
+        this.registrations.set(connector.name, { connector, config });
+      }
+      async sync(connectorName) {
+        const registration = this.registrations.get(connectorName);
+        if (!registration) {
+          return {
+            nodesAdded: 0,
+            nodesUpdated: 0,
+            edgesAdded: 0,
+            edgesUpdated: 0,
+            errors: [`Connector "${connectorName}" not registered`],
+            durationMs: 0
+          };
+        }
+        const { connector, config } = registration;
+        const result = await connector.ingest(this.store, config);
+        const metadata = await this.loadMetadata();
+        metadata.connectors[connectorName] = {
+          lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          lastResult: result
+        };
+        await this.saveMetadata(metadata);
+        return result;
+      }
+      async syncAll() {
+        const combined = {
+          nodesAdded: 0,
+          nodesUpdated: 0,
+          edgesAdded: 0,
+          edgesUpdated: 0,
+          errors: [],
+          durationMs: 0
+        };
+        for (const [name] of this.registrations) {
+          const result = await this.sync(name);
+          combined.nodesAdded += result.nodesAdded;
+          combined.nodesUpdated += result.nodesUpdated;
+          combined.edgesAdded += result.edgesAdded;
           combined.edgesUpdated += result.edgesUpdated;
           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() {
@@ -2752,23 +5656,29 @@ var init_dist = __esm({
       }
       async loadMetadata() {
         try {
-          const raw = await fs5.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 fs5.mkdir(path6.dirname(this.metadataPath), { recursive: true });
-        await fs5.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");
       }
     };
+    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:
+`;
     JiraConnector = class {
       name = "jira";
       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();
@@ -2795,7 +5705,7 @@ var init_dist = __esm({
         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(
@@ -2806,7 +5716,7 @@ var init_dist = __esm({
           );
         }
       }
-      async fetchAllIssues(store, baseUrl, jql, headers) {
+      async fetchAllIssues(store, baseUrl, jql, headers, config) {
         let nodesAdded = 0;
         let edgesAdded = 0;
         let startAt = 0;
@@ -2819,7 +5729,7 @@ var init_dist = __esm({
           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;
           }
@@ -2827,19 +5737,47 @@ var init_dist = __esm({
         }
         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(" ")
@@ -2847,13 +5785,24 @@ var init_dist = __esm({
         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 [];
+        }
+      }
     };
     SlackConnector = class {
       name = "slack";
       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();
@@ -2876,7 +5825,7 @@ var init_dist = __esm({
         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);
@@ -2895,7 +5844,7 @@ var init_dist = __esm({
           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;
@@ -2920,34 +5869,81 @@ var init_dist = __esm({
         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 [];
+        }
+      }
     };
     ConfluenceConnector = class {
       name = "confluence";
       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();
@@ -2960,7 +5956,14 @@ var init_dist = __esm({
         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,
@@ -2970,9 +5973,9 @@ var init_dist = __esm({
           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) {
@@ -2980,7 +5983,7 @@ var init_dist = __esm({
           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;
@@ -2995,7 +5998,7 @@ var init_dist = __esm({
           }
           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;
           }
@@ -3003,22 +6006,43 @@ var init_dist = __esm({
         }
         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 };
       }
     };
@@ -3027,7 +6051,7 @@ var init_dist = __esm({
       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();
@@ -3035,7 +6059,7 @@ var init_dist = __esm({
         const apiKeyEnv = config.apiKeyEnv ?? "GITHUB_TOKEN";
         const apiKey = process.env[apiKeyEnv];
         if (!apiKey) {
-          return emptyResult2(
+          return emptyResult5(
             [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
             start
           );
@@ -3078,6 +6102,255 @@ var init_dist = __esm({
         return { nodesAdded, edgesAdded };
       }
     };
+    CONSTRAINT_KEYWORDS = [
+      "constraint",
+      "must",
+      "required",
+      "minimum",
+      "maximum",
+      "spacing",
+      "padding",
+      "margin",
+      "breakpoint",
+      "responsive",
+      "accessible",
+      "a11y",
+      "wcag"
+    ];
+    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 validated = validateFigmaConfig(config);
+        if ("error" in validated) return buildIngestResult2(0, 0, [validated.error], start);
+        const { apiKey, baseUrl, fileIds } = validated;
+        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 styleCounts = await this.ingestStyles(store, baseUrl, fileId, headers, maxLen);
+        nodesAdded += styleCounts.nodesAdded;
+        edgesAdded += styleCounts.edgesAdded;
+        const componentCounts = await this.ingestComponents(store, baseUrl, fileId, headers, maxLen);
+        nodesAdded += componentCounts.nodesAdded;
+        edgesAdded += componentCounts.edgesAdded;
+        return { nodesAdded, edgesAdded };
+      }
+      async ingestStyles(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 counts = await this.processStyle(store, style, fileId, maxLen);
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
+        }
+        return { nodesAdded, edgesAdded };
+      }
+      async processStyle(store, style, fileId, maxLen) {
+        const nodeId = `figma:token:${style.key}`;
+        const condensed = await condenseContent(sanitizeExternalText(style.description || "", 2e3), {
+          maxLength: maxLen
+        });
+        const metadata = buildNodeMetadata(condensed, {
+          source: "figma",
+          key: style.key,
+          styleType: style.style_type,
+          fileId
+        });
+        store.addNode({
+          id: nodeId,
+          type: "design_token",
+          name: sanitizeExternalText(style.name, 500),
+          content: condensed.content,
+          metadata
+        });
+        const searchText = sanitizeExternalText([style.name, style.description].join(" "));
+        const edgesAdded = linkToCode(store, searchText, nodeId, "references");
+        return { nodesAdded: 1, edgesAdded };
+      }
+      async ingestComponents(store, baseUrl, fileId, headers, maxLen) {
+        let nodesAdded = 0;
+        let edgesAdded = 0;
+        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 counts = await this.processComponent(store, component, fileId, maxLen);
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
+        }
+        return { nodesAdded, edgesAdded };
+      }
+      async processComponent(store, component, fileId, maxLen) {
+        let nodesAdded = 0;
+        let edgesAdded = 0;
+        const description = component.description || "";
+        if (description) {
+          const counts = await this.addComponentIntent(store, component, description, fileId, maxLen);
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
+        }
+        if (description && hasConstraintKeyword(description)) {
+          const counts = await this.addComponentConstraint(
+            store,
+            component,
+            description,
+            fileId,
+            maxLen
+          );
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
+        }
+        return { nodesAdded, edgesAdded };
+      }
+      async addComponentIntent(store, component, description, fileId, maxLen) {
+        const intentId = `figma:intent:${component.key}`;
+        const condensed = await condenseContent(sanitizeExternalText(description, 2e3), {
+          maxLength: maxLen
+        });
+        const metadata = buildNodeMetadata(condensed, {
+          source: "figma",
+          key: component.key,
+          fileId
+        });
+        store.addNode({
+          id: intentId,
+          type: "aesthetic_intent",
+          name: sanitizeExternalText(component.name, 500),
+          content: condensed.content,
+          metadata
+        });
+        const searchText = sanitizeExternalText([component.name, description].join(" "));
+        const edgesAdded = linkToCode(store, searchText, intentId, "references");
+        return { nodesAdded: 1, edgesAdded };
+      }
+      async addComponentConstraint(store, component, description, fileId, maxLen) {
+        const constraintId = `figma:constraint:${component.key}`;
+        const condensed = await condenseContent(sanitizeExternalText(description, 2e3), {
+          maxLength: maxLen
+        });
+        const metadata = buildNodeMetadata(condensed, {
+          source: "figma",
+          key: component.key,
+          fileId
+        });
+        store.addNode({
+          id: constraintId,
+          type: "design_constraint",
+          name: sanitizeExternalText(component.name, 500),
+          content: condensed.content,
+          metadata
+        });
+        const searchText = sanitizeExternalText([component.name, description].join(" "));
+        const edgesAdded = linkToCode(store, searchText, constraintId, "references");
+        return { nodesAdded: 1, edgesAdded };
+      }
+    };
+    MIN_CONTENT_LENGTH = 10;
+    CONCEPT_ITEM_TYPES = /* @__PURE__ */ new Set(["sticky_note", "text"]);
+    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 resolved = resolveConfig(config, start);
+        if (!resolved.ok) return resolved.result;
+        const { baseUrl, boardIds, headers } = resolved;
+        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 };
+      }
+    };
     STOP_WORDS = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -4146,9 +7419,9 @@ var init_dist = __esm({
       extractPaths(trimmed, add) {
         const consumed = /* @__PURE__ */ new Set();
         for (const match of trimmed.matchAll(FILE_PATH_RE)) {
-          const path8 = match[0];
-          add(path8);
-          consumed.add(path8);
+          const path13 = match[0];
+          add(path13);
+          consumed.add(path13);
         }
         return consumed;
       }
@@ -4218,8 +7491,8 @@ var init_dist = __esm({
           if (isPathLike && node.path.includes(raw)) {
             return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
           }
-          const basename6 = node.path.split("/").pop() ?? "";
-          if (basename6.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)) {
@@ -4296,13 +7569,13 @@ var init_dist = __esm({
         const context = Array.isArray(d?.context) ? d.context : [];
         const firstEntity = entities[0];
         const nodeType = firstEntity?.node.type ?? "node";
-        const path8 = 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 \`${path8}\`. Connected to ${neighborCount} nodes.`;
+        return `**${entityName}** is a ${nodeType} at \`${path13}\`. Connected to ${neighborCount} nodes.`;
       }
       formatAnomaly(data) {
         const d = data;
@@ -4833,8 +8106,8 @@ var init_dist = __esm({
         const { edges } = this.computeDependencyGraph();
         const violations = [];
         for (const edge of edges) {
-          const fromRelative = relative3(rootDir, edge.from).replaceAll("\\", "/");
-          const toRelative = relative3(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;
@@ -4927,8 +8200,8 @@ var init_dist = __esm({
       async ingestAll(designDir) {
         const start = Date.now();
         const [tokensResult, intentResult] = await Promise.all([
-          this.ingestTokens(path7.join(designDir, "tokens.json")),
-          this.ingestDesignIntent(path7.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 };
@@ -5158,10 +8431,10 @@ var init_dist = __esm({
             includeTypes: ["file"]
           });
           for (const n of queryResult.nodes) {
-            const path8 = n.path ?? n.id.replace(/^file:/, "");
-            if (!fileSet.has(path8)) {
-              if (!result.has(path8)) {
-                result.set(path8, file);
+            const path13 = n.path ?? n.id.replace(/^file:/, "");
+            if (!fileSet.has(path13)) {
+              if (!result.has(path13)) {
+                result.set(path13, file);
               }
             }
           }
@@ -5562,12 +8835,32 @@ export {
   KnowledgeIngestor,
   BusinessKnowledgeIngestor,
   RequirementIngestor,
+  MermaidParser,
+  D2Parser,
+  PlantUmlParser,
+  DiagramParser,
+  StructuralDriftDetector,
+  KnowledgeStagingAggregator,
+  detectLanguage,
+  ExtractionRunner,
+  TestDescriptionExtractor,
+  EnumConstantExtractor,
+  ValidationRuleExtractor,
+  ApiPathExtractor,
+  ALL_EXTRACTORS,
+  createExtractionRunner,
+  ImageAnalysisExtractor,
+  ContradictionDetector,
+  CoverageScorer,
+  KnowledgePipelineRunner,
   linkToCode,
   SyncManager,
   JiraConnector,
   SlackConnector,
   ConfluenceConnector,
   CIConnector,
+  FigmaConnector,
+  MiroConnector,
   FusionLayer,
   GraphEntropyAdapter,
   GraphComplexityAdapter,