@harness-engineering/graph 0.3.1 → 0.3.3

package/dist/index.js

@@ -34,11 +34,14 @@ __export(index_exports, {
   CIConnector: () => CIConnector,
   CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
   CodeIngestor: () => CodeIngestor,
+  ConflictPredictor: () => ConflictPredictor,
   ConfluenceConnector: () => ConfluenceConnector,
   ContextQL: () => ContextQL,
   DesignConstraintAdapter: () => DesignConstraintAdapter,
   DesignIngestor: () => DesignIngestor,
   EDGE_TYPES: () => EDGE_TYPES,
+  EntityExtractor: () => EntityExtractor,
+  EntityResolver: () => EntityResolver,
   FusionLayer: () => FusionLayer,
   GitIngestor: () => GitIngestor,
   GraphAnomalyAdapter: () => GraphAnomalyAdapter,
@@ -50,15 +53,21 @@ __export(index_exports, {
   GraphFeedbackAdapter: () => GraphFeedbackAdapter,
   GraphNodeSchema: () => GraphNodeSchema,
   GraphStore: () => GraphStore,
+  INTENTS: () => INTENTS,
+  IntentClassifier: () => IntentClassifier,
   JiraConnector: () => JiraConnector,
   KnowledgeIngestor: () => KnowledgeIngestor,
   NODE_TYPES: () => NODE_TYPES,
   OBSERVABILITY_TYPES: () => OBSERVABILITY_TYPES,
+  ResponseFormatter: () => ResponseFormatter,
   SlackConnector: () => SlackConnector,
   SyncManager: () => SyncManager,
+  TaskIndependenceAnalyzer: () => TaskIndependenceAnalyzer,
   TopologicalLinker: () => TopologicalLinker,
   VERSION: () => VERSION,
   VectorStore: () => VectorStore,
+  askGraph: () => askGraph,
+  groupNodesByImpact: () => groupNodesByImpact,
   linkToCode: () => linkToCode,
   loadGraph: () => loadGraph,
   project: () => project,
@@ -425,6 +434,53 @@ var VectorStore = class _VectorStore {
 };
 
 // src/query/ContextQL.ts
+function edgeKey(e) {
+  return `${e.from}|${e.to}|${e.type}`;
+}
+function addEdge(state, edge) {
+  const key = edgeKey(edge);
+  if (!state.edgeSet.has(key)) {
+    state.edgeSet.add(key);
+    state.resultEdges.push(edge);
+  }
+}
+function shouldPruneNode(neighbor, pruneObservability, params) {
+  if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) return true;
+  if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) return true;
+  if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) return true;
+  return false;
+}
+function isEdgeExcluded(edge, params) {
+  return !!(params.includeEdges && !params.includeEdges.includes(edge.type));
+}
+function processNeighbor(store, edge, neighborId, nextDepth, queue, state, pruneObservability, params) {
+  if (isEdgeExcluded(edge, params)) return;
+  if (state.visited.has(neighborId)) {
+    addEdge(state, edge);
+    return;
+  }
+  const neighbor = store.getNode(neighborId);
+  if (!neighbor) return;
+  state.visited.add(neighborId);
+  if (shouldPruneNode(neighbor, pruneObservability, params)) {
+    state.pruned++;
+    return;
+  }
+  state.resultNodeMap.set(neighborId, neighbor);
+  addEdge(state, edge);
+  queue.push({ id: neighborId, depth: nextDepth });
+}
+function addCrossEdges(store, state) {
+  const resultNodeIds = new Set(state.resultNodeMap.keys());
+  for (const nodeId of resultNodeIds) {
+    const outEdges = store.getEdges({ from: nodeId });
+    for (const edge of outEdges) {
+      if (resultNodeIds.has(edge.to)) {
+        addEdge(state, edge);
+      }
+    }
+  }
+}
 var ContextQL = class {
   store;
   constructor(store) {
@@ -434,89 +490,69 @@ var ContextQL = class {
     const maxDepth = params.maxDepth ?? 3;
     const bidirectional = params.bidirectional ?? false;
     const pruneObservability = params.pruneObservability ?? true;
-    const visited = /* @__PURE__ */ new Set();
-    const resultNodeMap = /* @__PURE__ */ new Map();
-    const resultEdges = [];
-    const edgeSet = /* @__PURE__ */ new Set();
-    let pruned = 0;
-    let depthReached = 0;
-    const edgeKey = (e) => `${e.from}|${e.to}|${e.type}`;
-    const addEdge = (edge) => {
-      const key = edgeKey(edge);
-      if (!edgeSet.has(key)) {
-        edgeSet.add(key);
-        resultEdges.push(edge);
-      }
+    const state = {
+      visited: /* @__PURE__ */ new Set(),
+      resultNodeMap: /* @__PURE__ */ new Map(),
+      resultEdges: [],
+      edgeSet: /* @__PURE__ */ new Set(),
+      pruned: 0,
+      depthReached: 0
     };
     const queue = [];
-    for (const rootId of params.rootNodeIds) {
+    this.seedRootNodes(params.rootNodeIds, state, queue);
+    this.runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state);
+    addCrossEdges(this.store, state);
+    return {
+      nodes: Array.from(state.resultNodeMap.values()),
+      edges: state.resultEdges,
+      stats: {
+        totalTraversed: state.visited.size,
+        totalReturned: state.resultNodeMap.size,
+        pruned: state.pruned,
+        depthReached: state.depthReached
+      }
+    };
+  }
+  seedRootNodes(rootNodeIds, state, queue) {
+    for (const rootId of rootNodeIds) {
       const node = this.store.getNode(rootId);
       if (node) {
-        visited.add(rootId);
-        resultNodeMap.set(rootId, node);
+        state.visited.add(rootId);
+        state.resultNodeMap.set(rootId, node);
         queue.push({ id: rootId, depth: 0 });
       }
     }
+  }
+  runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state) {
     let head = 0;
     while (head < queue.length) {
       const entry = queue[head++];
       const { id: currentId, depth } = entry;
       if (depth >= maxDepth) continue;
       const nextDepth = depth + 1;
-      if (nextDepth > depthReached) depthReached = nextDepth;
-      const outEdges = this.store.getEdges({ from: currentId });
-      const inEdges = bidirectional ? this.store.getEdges({ to: currentId }) : [];
-      const allEdges = [
-        ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
-        ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
-      ];
+      if (nextDepth > state.depthReached) state.depthReached = nextDepth;
+      const allEdges = this.gatherEdges(currentId, bidirectional);
       for (const { edge, neighborId } of allEdges) {
-        if (params.includeEdges && !params.includeEdges.includes(edge.type)) {
-          continue;
-        }
-        if (visited.has(neighborId)) {
-          addEdge(edge);
-          continue;
-        }
-        const neighbor = this.store.getNode(neighborId);
-        if (!neighbor) continue;
-        visited.add(neighborId);
-        if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) {
-          pruned++;
-          continue;
-        }
-        resultNodeMap.set(neighborId, neighbor);
-        addEdge(edge);
-        queue.push({ id: neighborId, depth: nextDepth });
-      }
-    }
-    const resultNodeIds = new Set(resultNodeMap.keys());
-    for (const nodeId of resultNodeIds) {
-      const outEdges = this.store.getEdges({ from: nodeId });
-      for (const edge of outEdges) {
-        if (resultNodeIds.has(edge.to)) {
-          addEdge(edge);
-        }
+        processNeighbor(
+          this.store,
+          edge,
+          neighborId,
+          nextDepth,
+          queue,
+          state,
+          pruneObservability,
+          params
+        );
       }
     }
-    return {
-      nodes: Array.from(resultNodeMap.values()),
-      edges: resultEdges,
-      stats: {
-        totalTraversed: visited.size,
-        totalReturned: resultNodeMap.size,
-        pruned,
-        depthReached
-      }
-    };
+  }
+  gatherEdges(nodeId, bidirectional) {
+    const outEdges = this.store.getEdges({ from: nodeId });
+    const inEdges = bidirectional ? this.store.getEdges({ to: nodeId }) : [];
+    return [
+      ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
+      ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
+    ];
   }
 };
 
@@ -534,9 +570,50 @@ function project(nodes, spec) {
   });
 }
 
+// src/query/groupImpact.ts
+var TEST_TYPES = /* @__PURE__ */ new Set(["test_result"]);
+var DOC_TYPES = /* @__PURE__ */ new Set(["adr", "decision", "document", "learning"]);
+var CODE_TYPES = /* @__PURE__ */ new Set([
+  "file",
+  "module",
+  "class",
+  "interface",
+  "function",
+  "method",
+  "variable"
+]);
+function groupNodesByImpact(nodes, excludeId) {
+  const tests = [];
+  const docs = [];
+  const code = [];
+  const other = [];
+  for (const node of nodes) {
+    if (excludeId && node.id === excludeId) continue;
+    if (TEST_TYPES.has(node.type)) {
+      tests.push(node);
+    } else if (DOC_TYPES.has(node.type)) {
+      docs.push(node);
+    } else if (CODE_TYPES.has(node.type)) {
+      code.push(node);
+    } else {
+      other.push(node);
+    }
+  }
+  return { tests, docs, code, other };
+}
+
 // src/ingest/CodeIngestor.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
+var SKIP_METHOD_NAMES = /* @__PURE__ */ new Set(["constructor", "if", "for", "while", "switch"]);
+function countBraces(line) {
+  let net = 0;
+  for (const ch of line) {
+    if (ch === "{") net++;
+    else if (ch === "}") net--;
+  }
+  return net;
+}
 var CodeIngestor = class {
   constructor(store) {
     this.store = store;
@@ -551,41 +628,9 @@ var CodeIngestor = class {
     const fileContents = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       try {
-        const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
-        const content = await fs.readFile(filePath, "utf-8");
-        const stat2 = await fs.stat(filePath);
-        const fileId = `file:${relativePath}`;
-        fileContents.set(relativePath, content);
-        const fileNode = {
-          id: fileId,
-          type: "file",
-          name: path.basename(filePath),
-          path: relativePath,
-          metadata: { language: this.detectLanguage(filePath) },
-          lastModified: stat2.mtime.toISOString()
-        };
-        this.store.addNode(fileNode);
-        nodesAdded++;
-        const symbols = this.extractSymbols(content, fileId, relativePath);
-        for (const { node, edge } of symbols) {
-          this.store.addNode(node);
-          this.store.addEdge(edge);
-          nodesAdded++;
-          edgesAdded++;
-          if (node.type === "function" || node.type === "method") {
-            let files2 = nameToFiles.get(node.name);
-            if (!files2) {
-              files2 = /* @__PURE__ */ new Set();
-              nameToFiles.set(node.name, files2);
-            }
-            files2.add(relativePath);
-          }
-        }
-        const imports = await this.extractImports(content, fileId, relativePath, rootDir);
-        for (const edge of imports) {
-          this.store.addEdge(edge);
-          edgesAdded++;
-        }
+        const result = await this.processFile(filePath, rootDir, nameToFiles, fileContents);
+        nodesAdded += result.nodesAdded;
+        edgesAdded += result.edgesAdded;
       } catch (err) {
         errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -604,6 +649,48 @@ var CodeIngestor = class {
       durationMs: Date.now() - start
     };
   }
+  async processFile(filePath, rootDir, nameToFiles, fileContents) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
+    const content = await fs.readFile(filePath, "utf-8");
+    const stat2 = await fs.stat(filePath);
+    const fileId = `file:${relativePath}`;
+    fileContents.set(relativePath, content);
+    const fileNode = {
+      id: fileId,
+      type: "file",
+      name: path.basename(filePath),
+      path: relativePath,
+      metadata: { language: this.detectLanguage(filePath) },
+      lastModified: stat2.mtime.toISOString()
+    };
+    this.store.addNode(fileNode);
+    nodesAdded++;
+    const symbols = this.extractSymbols(content, fileId, relativePath);
+    for (const { node, edge } of symbols) {
+      this.store.addNode(node);
+      this.store.addEdge(edge);
+      nodesAdded++;
+      edgesAdded++;
+      this.trackCallable(node, relativePath, nameToFiles);
+    }
+    const imports = await this.extractImports(content, fileId, relativePath, rootDir);
+    for (const edge of imports) {
+      this.store.addEdge(edge);
+      edgesAdded++;
+    }
+    return { nodesAdded, edgesAdded };
+  }
+  trackCallable(node, relativePath, nameToFiles) {
+    if (node.type !== "function" && node.type !== "method") return;
+    let files = nameToFiles.get(node.name);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      nameToFiles.set(node.name, files);
+    }
+    files.add(relativePath);
+  }
   async findSourceFiles(dir) {
     const results = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -620,149 +707,152 @@ var CodeIngestor = class {
   extractSymbols(content, fileId, relativePath) {
     const results = [];
     const lines = content.split("\n");
-    let currentClassName = null;
-    let currentClassId = null;
-    let braceDepth = 0;
-    let insideClass = false;
+    const ctx = { className: null, classId: null, insideClass: false, braceDepth: 0 };
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
-      if (fnMatch) {
-        const name = fnMatch[1];
-        const id = `function:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "function",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            metadata: {
-              exported: line.includes("export"),
-              cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
-              nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
-              lineCount: endLine - i,
-              parameterCount: this.countParameters(line)
-            }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-        if (!insideClass) {
-          currentClassName = null;
-          currentClassId = null;
-        }
-        continue;
-      }
-      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
-      if (classMatch) {
-        const name = classMatch[1];
-        const id = `class:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "class",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-        currentClassName = name;
-        currentClassId = id;
-        insideClass = true;
-        braceDepth = 0;
-        for (const ch of line) {
-          if (ch === "{") braceDepth++;
-          if (ch === "}") braceDepth--;
-        }
-        continue;
-      }
-      const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
-      if (ifaceMatch) {
-        const name = ifaceMatch[1];
-        const id = `interface:${relativePath}:${name}`;
-        const endLine = this.findClosingBrace(lines, i);
-        results.push({
-          node: {
-            id,
-            type: "interface",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-        currentClassName = null;
-        currentClassId = null;
-        insideClass = false;
-        continue;
-      }
-      if (insideClass) {
-        for (const ch of line) {
-          if (ch === "{") braceDepth++;
-          if (ch === "}") braceDepth--;
-        }
-        if (braceDepth <= 0) {
-          currentClassName = null;
-          currentClassId = null;
-          insideClass = false;
-          continue;
-        }
-      }
-      if (insideClass && currentClassName && currentClassId) {
-        const methodMatch = line.match(
-          /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
-        );
-        if (methodMatch) {
-          const methodName = methodMatch[1];
-          if (methodName === "constructor" || methodName === "if" || methodName === "for" || methodName === "while" || methodName === "switch")
-            continue;
-          const id = `method:${relativePath}:${currentClassName}.${methodName}`;
-          const endLine = this.findClosingBrace(lines, i);
-          results.push({
-            node: {
-              id,
-              type: "method",
-              name: methodName,
-              path: relativePath,
-              location: { fileId, startLine: i + 1, endLine },
-              metadata: {
-                className: currentClassName,
-                exported: false,
-                cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
-                nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
-                lineCount: endLine - i,
-                parameterCount: this.countParameters(line)
-              }
-            },
-            edge: { from: currentClassId, to: id, type: "contains" }
-          });
-        }
-        continue;
-      }
-      const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
-      if (varMatch) {
-        const name = varMatch[1];
-        const id = `variable:${relativePath}:${name}`;
-        results.push({
-          node: {
-            id,
-            type: "variable",
-            name,
-            path: relativePath,
-            location: { fileId, startLine: i + 1, endLine: i + 1 },
-            metadata: { exported: line.includes("export") }
-          },
-          edge: { from: fileId, to: id, type: "contains" }
-        });
-      }
+      if (this.tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.tryExtractClass(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (this.updateClassContext(line, ctx)) continue;
+      if (this.tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results)) continue;
+      if (ctx.insideClass) continue;
+      this.tryExtractVariable(line, i, fileId, relativePath, results);
     }
     return results;
   }
+  tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results) {
+    const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (!fnMatch) return false;
+    const name = fnMatch[1];
+    const id = `function:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "function",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: {
+          exported: line.includes("export"),
+          cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+          nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+          lineCount: endLine - i,
+          parameterCount: this.countParameters(line)
+        }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+    if (!ctx.insideClass) {
+      ctx.className = null;
+      ctx.classId = null;
+    }
+    return true;
+  }
+  tryExtractClass(line, lines, i, fileId, relativePath, ctx, results) {
+    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+    if (!classMatch) return false;
+    const name = classMatch[1];
+    const id = `class:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "class",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+    ctx.className = name;
+    ctx.classId = id;
+    ctx.insideClass = true;
+    ctx.braceDepth = countBraces(line);
+    return true;
+  }
+  tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results) {
+    const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+    if (!ifaceMatch) return false;
+    const name = ifaceMatch[1];
+    const id = `interface:${relativePath}:${name}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "interface",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+    ctx.className = null;
+    ctx.classId = null;
+    ctx.insideClass = false;
+    return true;
+  }
+  /** Update brace tracking; returns true when line is consumed (class ended or tracked). */
+  updateClassContext(line, ctx) {
+    if (!ctx.insideClass) return false;
+    ctx.braceDepth += countBraces(line);
+    if (ctx.braceDepth <= 0) {
+      ctx.className = null;
+      ctx.classId = null;
+      ctx.insideClass = false;
+      return true;
+    }
+    return false;
+  }
+  tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results) {
+    if (!ctx.insideClass || !ctx.className || !ctx.classId) return false;
+    const methodMatch = line.match(
+      /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
+    );
+    if (!methodMatch) return false;
+    const methodName = methodMatch[1];
+    if (SKIP_METHOD_NAMES.has(methodName)) return false;
+    const id = `method:${relativePath}:${ctx.className}.${methodName}`;
+    const endLine = this.findClosingBrace(lines, i);
+    results.push({
+      node: {
+        id,
+        type: "method",
+        name: methodName,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine },
+        metadata: {
+          className: ctx.className,
+          exported: false,
+          cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+          nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+          lineCount: endLine - i,
+          parameterCount: this.countParameters(line)
+        }
+      },
+      edge: { from: ctx.classId, to: id, type: "contains" }
+    });
+    return true;
+  }
+  tryExtractVariable(line, i, fileId, relativePath, results) {
+    const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
+    if (!varMatch) return;
+    const name = varMatch[1];
+    const id = `variable:${relativePath}:${name}`;
+    results.push({
+      node: {
+        id,
+        type: "variable",
+        name,
+        path: relativePath,
+        location: { fileId, startLine: i + 1, endLine: i + 1 },
+        metadata: { exported: line.includes("export") }
+      },
+      edge: { from: fileId, to: id, type: "contains" }
+    });
+  }
   /**
    * Find the closing brace for a construct starting at the given line.
    * Uses a simple brace-counting heuristic. Returns 1-indexed line number.
@@ -1382,17 +1472,33 @@ var KnowledgeIngestor = class {
 
 // src/ingest/connectors/ConnectorUtils.ts
 var CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
+var 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]"
+  }
+];
 function sanitizeExternalText(text, maxLength = 2e3) {
-  let sanitized = text.replace(
-    /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
-    ""
-  ).replace(/^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim, "").replace(
-    /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
-    "[filtered]"
-  ).replace(
-    /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
-    "[filtered]"
-  );
+  let sanitized = text;
+  for (const rule of SANITIZE_RULES) {
+    sanitized = sanitized.replace(rule.pattern, rule.replacement);
+  }
   if (sanitized.length > maxLength) {
     sanitized = sanitized.slice(0, maxLength) + "\u2026";
   }
@@ -1492,6 +1598,28 @@ var SyncManager = class {
 };
 
 // src/ingest/connectors/JiraConnector.ts
+function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+function buildJql(config) {
+  const project2 = config.project;
+  let jql = project2 ? `project=${project2}` : "";
+  const filters = config.filters;
+  if (filters?.status?.length) {
+    jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
+  }
+  if (filters?.labels?.length) {
+    jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+  }
+  return jql;
+}
 var JiraConnector = class {
   name = "jira";
   source = "jira";
@@ -1501,105 +1629,81 @@ var JiraConnector = class {
   }
   async ingest(store, config) {
     const start = Date.now();
-    const errors = [];
     let nodesAdded = 0;
     let edgesAdded = 0;
     const apiKeyEnv = config.apiKeyEnv ?? "JIRA_API_KEY";
     const apiKey = process.env[apiKeyEnv];
     if (!apiKey) {
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors: [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
-        durationMs: Date.now() - start
-      };
+      return buildIngestResult(
+        0,
+        0,
+        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        start
+      );
     }
     const baseUrlEnv = config.baseUrlEnv ?? "JIRA_BASE_URL";
     const baseUrl = process.env[baseUrlEnv];
     if (!baseUrl) {
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors: [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
-        durationMs: Date.now() - start
-      };
-    }
-    const project2 = config.project;
-    let jql = project2 ? `project=${project2}` : "";
-    const filters = config.filters;
-    if (filters?.status?.length) {
-      jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
-    }
-    if (filters?.labels?.length) {
-      jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+      return buildIngestResult(
+        0,
+        0,
+        [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
+        start
+      );
     }
+    const jql = buildJql(config);
     const headers = {
       Authorization: `Basic ${apiKey}`,
       "Content-Type": "application/json"
     };
-    let startAt = 0;
-    const maxResults = 50;
-    let total = Infinity;
     try {
+      let startAt = 0;
+      const maxResults = 50;
+      let total = Infinity;
       while (startAt < total) {
         const url = `${baseUrl}/rest/api/2/search?jql=${encodeURIComponent(jql)}&startAt=${startAt}&maxResults=${maxResults}`;
         const response = await this.httpClient(url, { headers });
         if (!response.ok) {
-          return {
-            nodesAdded,
-            nodesUpdated: 0,
-            edgesAdded,
-            edgesUpdated: 0,
-            errors: ["Jira API request failed"],
-            durationMs: Date.now() - start
-          };
+          return buildIngestResult(nodesAdded, edgesAdded, ["Jira API request failed"], start);
         }
         const data = await response.json();
         total = data.total;
         for (const issue of data.issues) {
-          const nodeId = `issue:jira:${issue.key}`;
-          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 ?? []
-            }
-          });
-          nodesAdded++;
-          const searchText = sanitizeExternalText(
-            [issue.fields.summary, issue.fields.description ?? ""].join(" ")
-          );
-          edgesAdded += linkToCode(store, searchText, nodeId, "applies_to");
+          const counts = this.processIssue(store, issue);
+          nodesAdded += counts.nodesAdded;
+          edgesAdded += counts.edgesAdded;
         }
         startAt += maxResults;
       }
     } catch (err) {
-      return {
+      return buildIngestResult(
         nodesAdded,
-        nodesUpdated: 0,
         edgesAdded,
-        edgesUpdated: 0,
-        errors: [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
-        durationMs: Date.now() - start
-      };
+        [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
+        start
+      );
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return buildIngestResult(nodesAdded, edgesAdded, [], start);
+  }
+  processIssue(store, issue) {
+    const nodeId = `issue:jira:${issue.key}`;
+    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 ?? []
+      }
+    });
+    const searchText = sanitizeExternalText(
+      [issue.fields.summary, issue.fields.description ?? ""].join(" ")
+    );
+    const edgesAdded = linkToCode(store, searchText, nodeId, "applies_to");
+    return { nodesAdded: 1, edgesAdded };
   }
 };
 
@@ -1632,44 +1736,10 @@ var SlackConnector = class {
     const oldest = config.lookbackDays ? String(Math.floor((Date.now() - Number(config.lookbackDays) * 864e5) / 1e3)) : void 0;
     for (const channel of channels) {
       try {
-        let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
-        if (oldest) {
-          url += `&oldest=${oldest}`;
-        }
-        const response = await this.httpClient(url, {
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json"
-          }
-        });
-        if (!response.ok) {
-          errors.push(`Slack API request failed for channel ${channel}`);
-          continue;
-        }
-        const data = await response.json();
-        if (!data.ok) {
-          errors.push(`Slack API error for channel ${channel}`);
-          continue;
-        }
-        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;
-          store.addNode({
-            id: nodeId,
-            type: "conversation",
-            name: snippet,
-            metadata: {
-              author: message.user,
-              channel,
-              timestamp: message.ts
-            }
-          });
-          nodesAdded++;
-          edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
-            checkPaths: true
-          });
-        }
+        const result = await this.processChannel(store, channel, apiKey, oldest);
+        nodesAdded += result.nodesAdded;
+        edgesAdded += result.edgesAdded;
+        errors.push(...result.errors);
       } catch (err) {
         errors.push(
           `Slack API error for channel ${channel}: ${err instanceof Error ? err.message : String(err)}`
@@ -1685,6 +1755,52 @@ var SlackConnector = class {
       durationMs: Date.now() - start
     };
   }
+  async processChannel(store, channel, apiKey, oldest) {
+    const errors = [];
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
+    if (oldest) {
+      url += `&oldest=${oldest}`;
+    }
+    const response = await this.httpClient(url, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return {
+        nodesAdded: 0,
+        edgesAdded: 0,
+        errors: [`Slack API request failed for channel ${channel}`]
+      };
+    }
+    const data = await response.json();
+    if (!data.ok) {
+      return { nodesAdded: 0, edgesAdded: 0, errors: [`Slack API error for channel ${channel}`] };
+    }
+    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;
+      store.addNode({
+        id: nodeId,
+        type: "conversation",
+        name: snippet,
+        metadata: {
+          author: message.user,
+          channel,
+          timestamp: message.ts
+        }
+      });
+      nodesAdded++;
+      edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
+        checkPaths: true
+      });
+    }
+    return { nodesAdded, edgesAdded, errors };
+  }
 };
 
 // src/ingest/connectors/ConfluenceConnector.ts
@@ -1716,36 +1832,10 @@ var ConfluenceConnector = class {
     const baseUrl = process.env[baseUrlEnv] ?? "";
     const spaceKey = config.spaceKey ?? "";
     try {
-      let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
-      while (nextUrl) {
-        const response = await this.httpClient(nextUrl, {
-          headers: { Authorization: `Bearer ${apiKey}` }
-        });
-        if (!response.ok) {
-          errors.push(`Confluence API error: status ${response.status}`);
-          break;
-        }
-        const data = await response.json();
-        for (const page of data.results) {
-          const nodeId = `confluence:${page.id}`;
-          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 ?? ""
-            }
-          });
-          nodesAdded++;
-          const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
-          edgesAdded += linkToCode(store, text, nodeId, "documents");
-        }
-        nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
-      }
+      const result = await this.fetchAllPages(store, baseUrl, apiKey, spaceKey);
+      nodesAdded = result.nodesAdded;
+      edgesAdded = result.edgesAdded;
+      errors.push(...result.errors);
     } catch (err) {
       errors.push(`Confluence fetch error: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -1758,6 +1848,47 @@ var ConfluenceConnector = class {
       durationMs: Date.now() - start
     };
   }
+  async fetchAllPages(store, baseUrl, apiKey, spaceKey) {
+    const errors = [];
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
+    while (nextUrl) {
+      const response = await this.httpClient(nextUrl, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!response.ok) {
+        errors.push(`Confluence API error: status ${response.status}`);
+        break;
+      }
+      const data = await response.json();
+      for (const page of data.results) {
+        const counts = this.processPage(store, page, spaceKey);
+        nodesAdded += counts.nodesAdded;
+        edgesAdded += counts.edgesAdded;
+      }
+      nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
+    }
+    return { nodesAdded, edgesAdded, errors };
+  }
+  processPage(store, page, spaceKey) {
+    const nodeId = `confluence:${page.id}`;
+    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 ?? ""
+      }
+    });
+    const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
+    const edgesAdded = linkToCode(store, text, nodeId, "documents");
+    return { nodesAdded: 1, edgesAdded };
+  }
 };
 
 // src/ingest/connectors/CIConnector.ts
@@ -2050,22 +2181,25 @@ var GraphEntropyAdapter = class {
    * 3. Unreachable = code nodes NOT in visited set
    */
   computeDeadCodeData() {
-    const allFileNodes = this.store.findNodes({ type: "file" });
+    const entryPoints = this.findEntryPoints();
+    const visited = this.bfsFromEntryPoints(entryPoints);
+    const unreachableNodes = this.collectUnreachableNodes(visited);
+    return { reachableNodeIds: visited, unreachableNodes, entryPoints };
+  }
+  findEntryPoints() {
     const entryPoints = [];
-    for (const node of allFileNodes) {
-      if (node.name === "index.ts" || node.metadata?.entryPoint === true) {
-        entryPoints.push(node.id);
-      }
-    }
     for (const nodeType of CODE_NODE_TYPES3) {
-      if (nodeType === "file") continue;
       const nodes = this.store.findNodes({ type: nodeType });
       for (const node of nodes) {
-        if (node.metadata?.entryPoint === true) {
+        const isIndexFile = nodeType === "file" && node.name === "index.ts";
+        if (isIndexFile || node.metadata?.entryPoint === true) {
           entryPoints.push(node.id);
         }
       }
     }
+    return entryPoints;
+  }
+  bfsFromEntryPoints(entryPoints) {
     const visited = /* @__PURE__ */ new Set();
     const queue = [...entryPoints];
     let head = 0;
@@ -2073,25 +2207,22 @@ var GraphEntropyAdapter = class {
       const nodeId = queue[head++];
       if (visited.has(nodeId)) continue;
       visited.add(nodeId);
-      const importEdges = this.store.getEdges({ from: nodeId, type: "imports" });
-      for (const edge of importEdges) {
-        if (!visited.has(edge.to)) {
-          queue.push(edge.to);
-        }
-      }
-      const callEdges = this.store.getEdges({ from: nodeId, type: "calls" });
-      for (const edge of callEdges) {
-        if (!visited.has(edge.to)) {
-          queue.push(edge.to);
-        }
-      }
-      const containsEdges = this.store.getEdges({ from: nodeId, type: "contains" });
-      for (const edge of containsEdges) {
+      this.enqueueOutboundEdges(nodeId, visited, queue);
+    }
+    return visited;
+  }
+  enqueueOutboundEdges(nodeId, visited, queue) {
+    const edgeTypes = ["imports", "calls", "contains"];
+    for (const edgeType of edgeTypes) {
+      const edges = this.store.getEdges({ from: nodeId, type: edgeType });
+      for (const edge of edges) {
         if (!visited.has(edge.to)) {
           queue.push(edge.to);
         }
       }
     }
+  }
+  collectUnreachableNodes(visited) {
     const unreachableNodes = [];
     for (const nodeType of CODE_NODE_TYPES3) {
       const nodes = this.store.findNodes({ type: nodeType });
@@ -2106,11 +2237,7 @@ var GraphEntropyAdapter = class {
         }
       }
     }
-    return {
-      reachableNodeIds: visited,
-      unreachableNodes,
-      entryPoints
-    };
+    return unreachableNodes;
   }
   /**
    * Count all nodes and edges by type.
@@ -2161,33 +2288,9 @@ var GraphComplexityAdapter = class {
     const hotspots = [];
     for (const fnNode of functionNodes) {
       const complexity = fnNode.metadata?.cyclomaticComplexity ?? 1;
-      const containsEdges = this.store.getEdges({ to: fnNode.id, type: "contains" });
-      let fileId;
-      for (const edge of containsEdges) {
-        const sourceNode = this.store.getNode(edge.from);
-        if (sourceNode?.type === "file") {
-          fileId = sourceNode.id;
-          break;
-        }
-        if (sourceNode?.type === "class") {
-          const classContainsEdges = this.store.getEdges({ to: sourceNode.id, type: "contains" });
-          for (const classEdge of classContainsEdges) {
-            const parentNode = this.store.getNode(classEdge.from);
-            if (parentNode?.type === "file") {
-              fileId = parentNode.id;
-              break;
-            }
-          }
-          if (fileId) break;
-        }
-      }
+      const fileId = this.findContainingFileId(fnNode.id);
       if (!fileId) continue;
-      let changeFrequency = fileChangeFrequency.get(fileId);
-      if (changeFrequency === void 0) {
-        const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
-        changeFrequency = referencesEdges.length;
-        fileChangeFrequency.set(fileId, changeFrequency);
-      }
+      const changeFrequency = this.getChangeFrequency(fileId, fileChangeFrequency);
       const hotspotScore = changeFrequency * complexity;
       const filePath = fnNode.path ?? fileId.replace(/^file:/, "");
       hotspots.push({
@@ -2205,6 +2308,39 @@ var GraphComplexityAdapter = class {
     );
     return { hotspots, percentile95Score };
   }
+  /**
+   * Walk the 'contains' edges to find the file node that contains a given function/method.
+   * For methods, walks through the intermediate class node.
+   */
+  findContainingFileId(nodeId) {
+    const containsEdges = this.store.getEdges({ to: nodeId, type: "contains" });
+    for (const edge of containsEdges) {
+      const sourceNode = this.store.getNode(edge.from);
+      if (sourceNode?.type === "file") return sourceNode.id;
+      if (sourceNode?.type === "class") {
+        const fileId = this.findParentFileOfClass(sourceNode.id);
+        if (fileId) return fileId;
+      }
+    }
+    return void 0;
+  }
+  findParentFileOfClass(classNodeId) {
+    const classContainsEdges = this.store.getEdges({ to: classNodeId, type: "contains" });
+    for (const classEdge of classContainsEdges) {
+      const parentNode = this.store.getNode(classEdge.from);
+      if (parentNode?.type === "file") return parentNode.id;
+    }
+    return void 0;
+  }
+  getChangeFrequency(fileId, cache) {
+    let freq = cache.get(fileId);
+    if (freq === void 0) {
+      const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
+      freq = referencesEdges.length;
+      cache.set(fileId, freq);
+    }
+    return freq;
+  }
   computePercentile(descendingScores, percentile) {
     if (descendingScores.length === 0) return 0;
     const ascending = [...descendingScores].sort((a, b) => a - b);
@@ -2511,6 +2647,689 @@ var GraphAnomalyAdapter = class {
   }
 };
 
+// src/nlq/types.ts
+var INTENTS = ["impact", "find", "relationships", "explain", "anomaly"];
+
+// src/nlq/IntentClassifier.ts
+var SIGNAL_WEIGHTS = {
+  keyword: 0.35,
+  questionWord: 0.2,
+  verbPattern: 0.45
+};
+var INTENT_SIGNALS = {
+  impact: {
+    keywords: [
+      "break",
+      "affect",
+      "impact",
+      "change",
+      "depend",
+      "blast",
+      "radius",
+      "risk",
+      "delete",
+      "remove"
+    ],
+    questionWords: ["what", "if"],
+    verbPatterns: [
+      /what\s+(breaks|happens|is affected)/,
+      /if\s+i\s+(change|modify|remove|delete)/,
+      /blast\s+radius/,
+      /what\s+(depend|relies)/
+    ]
+  },
+  find: {
+    keywords: ["find", "where", "locate", "search", "list", "all", "every"],
+    questionWords: ["where"],
+    verbPatterns: [
+      /where\s+is/,
+      /find\s+(the|all|every)/,
+      /show\s+me/,
+      /show\s+(all|every|the)/,
+      /locate\s+/,
+      /list\s+(all|every|the)/
+    ]
+  },
+  relationships: {
+    keywords: [
+      "connect",
+      "call",
+      "import",
+      "use",
+      "depend",
+      "link",
+      "neighbor",
+      "caller",
+      "callee"
+    ],
+    questionWords: ["what", "who"],
+    verbPatterns: [/connects?\s+to/, /depends?\s+on/, /\bcalls?\b/, /\bimports?\b/]
+  },
+  explain: {
+    keywords: ["describe", "explain", "tell", "about", "overview", "summary", "work"],
+    questionWords: ["what", "how"],
+    verbPatterns: [
+      /what\s+is\s+\w/,
+      /describe\s+/,
+      /tell\s+me\s+about/,
+      /how\s+does/,
+      /overview\s+of/,
+      /give\s+me\s+/
+    ]
+  },
+  anomaly: {
+    keywords: [
+      "wrong",
+      "problem",
+      "anomaly",
+      "smell",
+      "issue",
+      "outlier",
+      "hotspot",
+      "suspicious",
+      "risk"
+    ],
+    questionWords: ["what"],
+    verbPatterns: [
+      /what.*(wrong|problem|smell)/,
+      /find.*(issue|anomal|problem)/,
+      /code\s+smell/,
+      /suspicious/,
+      /hotspot/
+    ]
+  }
+};
+var IntentClassifier = class {
+  /**
+   * Classify a natural language question into an intent.
+   *
+   * @param question - The natural language question to classify
+   * @returns ClassificationResult with intent, confidence, and per-signal scores
+   */
+  classify(question) {
+    const normalized = question.toLowerCase().trim();
+    const scores = [];
+    for (const intent of INTENTS) {
+      const signals = this.scoreIntent(normalized, INTENT_SIGNALS[intent]);
+      const confidence = this.combineSignals(signals);
+      scores.push({ intent, confidence, signals });
+    }
+    scores.sort((a, b) => b.confidence - a.confidence);
+    const best = scores[0];
+    return {
+      intent: best.intent,
+      confidence: best.confidence,
+      signals: best.signals
+    };
+  }
+  /**
+   * Score individual signals for an intent against the normalized query.
+   */
+  scoreIntent(normalized, signalSet) {
+    return {
+      keyword: this.scoreKeywords(normalized, signalSet.keywords),
+      questionWord: this.scoreQuestionWord(normalized, signalSet.questionWords),
+      verbPattern: this.scoreVerbPatterns(normalized, signalSet.verbPatterns)
+    };
+  }
+  /**
+   * Score keyword signal: uses word-stem matching (checks if any word in the
+   * query starts with the keyword). Saturates at 2 matches to avoid penalizing
+   * intents with many keywords when only a few appear in the query.
+   */
+  scoreKeywords(normalized, keywords) {
+    if (keywords.length === 0) return 0;
+    const words = normalized.split(/\s+/);
+    let matched = 0;
+    for (const keyword of keywords) {
+      if (words.some((w) => w.startsWith(keyword))) {
+        matched++;
+      }
+    }
+    return Math.min(matched / 2, 1);
+  }
+  /**
+   * Score question-word signal: 1.0 if the query starts with a matching
+   * question word, 0 otherwise.
+   */
+  scoreQuestionWord(normalized, questionWords) {
+    const firstWord = normalized.split(/\s+/)[0] ?? "";
+    return questionWords.includes(firstWord) ? 1 : 0;
+  }
+  /**
+   * Score verb-pattern signal: any matching pattern yields a strong score.
+   * Multiple matches increase score but saturate quickly.
+   */
+  scoreVerbPatterns(normalized, patterns) {
+    if (patterns.length === 0) return 0;
+    let matched = 0;
+    for (const pattern of patterns) {
+      if (pattern.test(normalized)) {
+        matched++;
+      }
+    }
+    return matched === 0 ? 0 : Math.min(0.6 + matched * 0.2, 1);
+  }
+  /**
+   * Combine individual signal scores into a single confidence score
+   * using additive weighted scoring. Each signal contributes weight * score,
+   * and the total weights sum to 1.0 so the result is naturally bounded [0, 1].
+   */
+  combineSignals(signals) {
+    let total = 0;
+    for (const key of Object.keys(signals)) {
+      const weight = SIGNAL_WEIGHTS[key];
+      total += signals[key] * weight;
+    }
+    return total;
+  }
+};
+
+// src/nlq/EntityExtractor.ts
+var INTENT_KEYWORDS = /* @__PURE__ */ new Set([
+  // impact
+  "break",
+  "breaks",
+  "affect",
+  "affects",
+  "affected",
+  "impact",
+  "change",
+  "depend",
+  "depends",
+  "blast",
+  "radius",
+  "risk",
+  "delete",
+  "remove",
+  "modify",
+  "happens",
+  // find
+  "find",
+  "where",
+  "locate",
+  "search",
+  "list",
+  "all",
+  "every",
+  "show",
+  // relationships
+  "connect",
+  "connects",
+  "call",
+  "calls",
+  "import",
+  "imports",
+  "use",
+  "uses",
+  "link",
+  "neighbor",
+  "caller",
+  "callers",
+  "callee",
+  "callees",
+  // explain
+  "describe",
+  "explain",
+  "tell",
+  "about",
+  "overview",
+  "summary",
+  "work",
+  "works",
+  // anomaly
+  "wrong",
+  "problem",
+  "problems",
+  "anomaly",
+  "anomalies",
+  "smell",
+  "smells",
+  "issue",
+  "issues",
+  "outlier",
+  "hotspot",
+  "hotspots",
+  "suspicious"
+]);
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "must",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "he",
+  "she",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their",
+  "this",
+  "that",
+  "these",
+  "those",
+  "and",
+  "or",
+  "but",
+  "if",
+  "then",
+  "else",
+  "when",
+  "while",
+  "for",
+  "of",
+  "at",
+  "by",
+  "to",
+  "in",
+  "on",
+  "with",
+  "from",
+  "up",
+  "out",
+  "not",
+  "no",
+  "nor",
+  "so",
+  "too",
+  "very",
+  "just",
+  "also",
+  "what",
+  "who",
+  "how",
+  "which",
+  "where",
+  "why",
+  "there",
+  "here",
+  "any",
+  "some",
+  "each",
+  "than",
+  "like",
+  "get",
+  "give",
+  "go",
+  "make",
+  "see",
+  "know",
+  "take"
+]);
+var PASCAL_OR_CAMEL_RE = /\b([A-Z][a-z]+[A-Za-z]*[a-z][A-Za-z]*|[a-z]+[A-Z][A-Za-z]*)\b/g;
+var FILE_PATH_RE = /(?:\.\/|[a-zA-Z0-9_-]+\/)[a-zA-Z0-9_\-./]+\.[a-zA-Z]{1,10}/g;
+var QUOTED_RE = /["']([^"']+)["']/g;
+function isSkippableWord(cleaned, allConsumed) {
+  if (allConsumed.has(cleaned)) return true;
+  const lower = cleaned.toLowerCase();
+  if (STOP_WORDS2.has(lower)) return true;
+  if (INTENT_KEYWORDS.has(lower)) return true;
+  if (cleaned === cleaned.toUpperCase() && /^[A-Z]+$/.test(cleaned)) return true;
+  return false;
+}
+function buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed) {
+  const quotedWords = /* @__PURE__ */ new Set();
+  for (const q of quotedConsumed) {
+    for (const w of q.split(/\s+/)) {
+      if (w.length > 0) quotedWords.add(w);
+    }
+  }
+  return /* @__PURE__ */ new Set([...quotedConsumed, ...quotedWords, ...casingConsumed, ...pathConsumed]);
+}
+var EntityExtractor = class {
+  /**
+   * Extract candidate entity mentions from a natural language query.
+   *
+   * @param query - The natural language query to extract entities from
+   * @returns Array of raw entity strings in priority order, deduplicated
+   */
+  extract(query) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    const add = (entity) => {
+      if (!seen.has(entity)) {
+        seen.add(entity);
+        result.push(entity);
+      }
+    };
+    const quotedConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(QUOTED_RE)) {
+      const inner = match[1].trim();
+      if (inner.length > 0) {
+        add(inner);
+        quotedConsumed.add(inner);
+      }
+    }
+    const casingConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(PASCAL_OR_CAMEL_RE)) {
+      const token = match[0];
+      if (!quotedConsumed.has(token)) {
+        add(token);
+        casingConsumed.add(token);
+      }
+    }
+    const pathConsumed = /* @__PURE__ */ new Set();
+    for (const match of trimmed.matchAll(FILE_PATH_RE)) {
+      const path6 = match[0];
+      add(path6);
+      pathConsumed.add(path6);
+    }
+    const allConsumed = buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed);
+    const words = trimmed.split(/\s+/);
+    for (const raw of words) {
+      const cleaned = raw.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "");
+      if (cleaned.length === 0) continue;
+      if (isSkippableWord(cleaned, allConsumed)) continue;
+      add(cleaned);
+    }
+    return result;
+  }
+};
+
+// src/nlq/EntityResolver.ts
+var EntityResolver = class {
+  store;
+  fusion;
+  constructor(store, fusion) {
+    this.store = store;
+    this.fusion = fusion;
+  }
+  /**
+   * Resolve an array of raw entity strings to graph nodes.
+   *
+   * @param raws - Raw entity strings from EntityExtractor
+   * @returns Array of ResolvedEntity for each successfully resolved raw string
+   */
+  resolve(raws) {
+    const results = [];
+    for (const raw of raws) {
+      const resolved = this.resolveOne(raw);
+      if (resolved !== void 0) {
+        results.push(resolved);
+      }
+    }
+    return results;
+  }
+  resolveOne(raw) {
+    const exactMatches = this.store.findNodes({ name: raw });
+    if (exactMatches.length > 0) {
+      const node = exactMatches[0];
+      return {
+        raw,
+        nodeId: node.id,
+        node,
+        confidence: 1,
+        method: "exact"
+      };
+    }
+    if (this.fusion) {
+      const fusionResults = this.fusion.search(raw, 5);
+      if (fusionResults.length > 0 && fusionResults[0].score > 0.5) {
+        const top = fusionResults[0];
+        return {
+          raw,
+          nodeId: top.nodeId,
+          node: top.node,
+          confidence: top.score,
+          method: "fusion"
+        };
+      }
+    }
+    if (raw.length < 3) return void 0;
+    const isPathLike = raw.includes("/");
+    const fileNodes = this.store.findNodes({ type: "file" });
+    for (const node of fileNodes) {
+      if (!node.path) continue;
+      if (isPathLike && node.path.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+      const basename4 = node.path.split("/").pop() ?? "";
+      if (basename4.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+      if (raw.length >= 4 && node.path.includes(raw)) {
+        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/nlq/ResponseFormatter.ts
+var ResponseFormatter = class {
+  /**
+   * Format graph operation results into a human-readable summary.
+   *
+   * @param intent - The classified intent
+   * @param entities - Resolved entities from the query
+   * @param data - Raw result data (shape varies per intent)
+   * @param query - Original natural language query (optional)
+   * @returns Human-readable summary string
+   */
+  format(intent, entities, data, query) {
+    if (data === null || data === void 0) {
+      return "No results found.";
+    }
+    const firstEntity = entities[0];
+    const entityName = firstEntity?.raw ?? "the target";
+    switch (intent) {
+      case "impact":
+        return this.formatImpact(entityName, data);
+      case "find":
+        return this.formatFind(data, query);
+      case "relationships":
+        return this.formatRelationships(entityName, entities, data);
+      case "explain":
+        return this.formatExplain(entityName, entities, data);
+      case "anomaly":
+        return this.formatAnomaly(data);
+      default:
+        return `Processed results for "${entityName}".`;
+    }
+  }
+  formatImpact(entityName, data) {
+    const d = data;
+    const code = this.safeArrayLength(d?.code);
+    const tests = this.safeArrayLength(d?.tests);
+    const docs = this.safeArrayLength(d?.docs);
+    return `Changing **${entityName}** affects ${this.p(code, "code file")}, ${this.p(tests, "test")}, and ${this.p(docs, "doc")}.`;
+  }
+  formatFind(data, query) {
+    const count = Array.isArray(data) ? data.length : 0;
+    if (query) {
+      return `Found ${this.p(count, "match", "matches")} for "${query}".`;
+    }
+    return `Found ${this.p(count, "match", "matches")}.`;
+  }
+  formatRelationships(entityName, entities, data) {
+    const d = data;
+    const edges = Array.isArray(d?.edges) ? d.edges : [];
+    const firstEntity = entities[0];
+    const rootId = firstEntity?.nodeId ?? "";
+    let outbound = 0;
+    let inbound = 0;
+    for (const edge of edges) {
+      if (edge.from === rootId) outbound++;
+      if (edge.to === rootId) inbound++;
+    }
+    return `**${entityName}** has ${outbound} outbound and ${inbound} inbound relationships.`;
+  }
+  formatExplain(entityName, entities, data) {
+    const d = data;
+    const context = Array.isArray(d?.context) ? d.context : [];
+    const firstEntity = entities[0];
+    const nodeType = firstEntity?.node.type ?? "node";
+    const path6 = 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 \`${path6}\`. Connected to ${neighborCount} nodes.`;
+  }
+  formatAnomaly(data) {
+    const d = data;
+    const outliers = Array.isArray(d?.statisticalOutliers) ? d.statisticalOutliers : [];
+    const artPoints = Array.isArray(d?.articulationPoints) ? d.articulationPoints : [];
+    const count = outliers.length + artPoints.length;
+    if (count === 0) {
+      return "Found 0 anomalies.";
+    }
+    const topItems = [
+      ...outliers.slice(0, 2).map((o) => o.nodeId ?? "unknown outlier"),
+      ...artPoints.slice(0, 1).map((a) => a.nodeId ?? "unknown bottleneck")
+    ].join(", ");
+    return `Found ${this.p(count, "anomaly", "anomalies")}: ${topItems}.`;
+  }
+  safeArrayLength(value) {
+    return Array.isArray(value) ? value.length : 0;
+  }
+  p(count, singular, plural) {
+    const word = count === 1 ? singular : plural ?? singular + "s";
+    return `${count} ${word}`;
+  }
+};
+
+// src/nlq/index.ts
+var ENTITY_REQUIRED_INTENTS = /* @__PURE__ */ new Set(["impact", "relationships", "explain"]);
+var classifier = new IntentClassifier();
+var extractor = new EntityExtractor();
+var formatter = new ResponseFormatter();
+async function askGraph(store, question) {
+  const fusion = new FusionLayer(store);
+  const resolver = new EntityResolver(store, fusion);
+  const classification = classifier.classify(question);
+  if (classification.confidence < 0.3) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities: [],
+      summary: "I'm not sure what you're asking. Try rephrasing your question.",
+      data: null,
+      suggestions: [
+        'Try "what breaks if I change <name>?" for impact analysis',
+        'Try "where is <name>?" to find entities',
+        'Try "what calls <name>?" for relationships',
+        'Try "what is <name>?" for explanations',
+        'Try "what looks wrong?" for anomaly detection'
+      ]
+    };
+  }
+  const rawEntities = extractor.extract(question);
+  const entities = resolver.resolve(rawEntities);
+  if (ENTITY_REQUIRED_INTENTS.has(classification.intent) && entities.length === 0) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities: [],
+      summary: "Could not find any matching nodes in the graph for your query. Try using exact class names, function names, or file paths.",
+      data: null
+    };
+  }
+  let data;
+  try {
+    data = executeOperation(store, classification.intent, entities, question, fusion);
+  } catch (err) {
+    return {
+      intent: classification.intent,
+      intentConfidence: classification.confidence,
+      entities,
+      summary: `An error occurred while querying the graph: ${err instanceof Error ? err.message : String(err)}`,
+      data: null
+    };
+  }
+  const summary = formatter.format(classification.intent, entities, data, question);
+  return {
+    intent: classification.intent,
+    intentConfidence: classification.confidence,
+    entities,
+    summary,
+    data
+  };
+}
+function executeOperation(store, intent, entities, question, fusion) {
+  const cql = new ContextQL(store);
+  switch (intent) {
+    case "impact": {
+      const rootId = entities[0].nodeId;
+      const result = cql.execute({
+        rootNodeIds: [rootId],
+        bidirectional: true,
+        maxDepth: 3
+      });
+      return groupNodesByImpact(result.nodes, rootId);
+    }
+    case "find": {
+      return fusion.search(question, 10);
+    }
+    case "relationships": {
+      const rootId = entities[0].nodeId;
+      const result = cql.execute({
+        rootNodeIds: [rootId],
+        bidirectional: true,
+        maxDepth: 1
+      });
+      return { nodes: result.nodes, edges: result.edges };
+    }
+    case "explain": {
+      const searchResults = fusion.search(question, 10);
+      const contextBlocks = [];
+      const rootIds = entities.length > 0 ? [entities[0].nodeId] : searchResults.slice(0, 3).map((r) => r.nodeId);
+      for (const rootId of rootIds) {
+        const expanded = cql.execute({
+          rootNodeIds: [rootId],
+          maxDepth: 2
+        });
+        const matchingResult = searchResults.find((r) => r.nodeId === rootId);
+        contextBlocks.push({
+          rootNode: rootId,
+          score: matchingResult?.score ?? 1,
+          nodes: expanded.nodes,
+          edges: expanded.edges
+        });
+      }
+      return { searchResults, context: contextBlocks };
+    }
+    case "anomaly": {
+      const adapter = new GraphAnomalyAdapter(store);
+      return adapter.detect();
+    }
+    default:
+      return null;
+  }
+}
+
 // src/context/Assembler.ts
 var PHASE_NODE_TYPES = {
   implement: ["file", "function", "class", "method", "interface", "variable"],
@@ -2554,14 +3373,20 @@ var Assembler = class {
     const fusion = this.getFusionLayer();
     const topResults = fusion.search(intent, 10);
     if (topResults.length === 0) {
-      return {
-        nodes: [],
-        edges: [],
-        tokenEstimate: 0,
-        intent,
-        truncated: false
-      };
+      return { nodes: [], edges: [], tokenEstimate: 0, intent, truncated: false };
     }
+    const { nodeMap, collectedEdges, nodeScores } = this.expandSearchResults(topResults);
+    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
+      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
+    });
+    const { keptNodes, tokenEstimate, truncated } = this.truncateToFit(sortedNodes, tokenBudget);
+    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
+    const keptEdges = collectedEdges.filter(
+      (e) => keptNodeIds.has(e.from) && keptNodeIds.has(e.to)
+    );
+    return { nodes: keptNodes, edges: keptEdges, tokenEstimate, intent, truncated };
+  }
+  expandSearchResults(topResults) {
     const contextQL = new ContextQL(this.store);
     const nodeMap = /* @__PURE__ */ new Map();
     const edgeSet = /* @__PURE__ */ new Set();
@@ -2589,9 +3414,9 @@ var Assembler = class {
         }
       }
     }
-    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
-      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
-    });
+    return { nodeMap, collectedEdges, nodeScores };
+  }
+  truncateToFit(sortedNodes, tokenBudget) {
     let tokenEstimate = 0;
     const keptNodes = [];
     let truncated = false;
@@ -2604,17 +3429,7 @@ var Assembler = class {
       tokenEstimate += nodeTokens;
       keptNodes.push(node);
     }
-    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
-    const keptEdges = collectedEdges.filter(
-      (e) => keptNodeIds.has(e.from) && keptNodeIds.has(e.to)
-    );
-    return {
-      nodes: keptNodes,
-      edges: keptEdges,
-      tokenEstimate,
-      intent,
-      truncated
-    };
+    return { keptNodes, tokenEstimate, truncated };
   }
   /**
    * Compute a token budget allocation across node types.
@@ -2787,8 +3602,8 @@ var GraphConstraintAdapter = class {
     const { edges } = this.computeDependencyGraph();
     const violations = [];
     for (const edge of edges) {
-      const fromRelative = (0, import_node_path2.relative)(rootDir, edge.from);
-      const toRelative = (0, import_node_path2.relative)(rootDir, edge.to);
+      const fromRelative = (0, import_node_path2.relative)(rootDir, edge.from).replaceAll("\\", "/");
+      const toRelative = (0, import_node_path2.relative)(rootDir, edge.to).replaceAll("\\", "/");
       const fromLayer = this.resolveLayer(fromRelative, layers);
       const toLayer = this.resolveLayer(toRelative, layers);
       if (!fromLayer || !toLayer) continue;
@@ -3133,6 +3948,447 @@ var GraphFeedbackAdapter = class {
   }
 };
 
+// src/independence/TaskIndependenceAnalyzer.ts
+var DEFAULT_EDGE_TYPES = ["imports", "calls", "references"];
+var TaskIndependenceAnalyzer = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  analyze(params) {
+    const { tasks } = params;
+    const depth = params.depth ?? 1;
+    const edgeTypes = params.edgeTypes ?? DEFAULT_EDGE_TYPES;
+    this.validate(tasks);
+    const useGraph = this.store != null && depth > 0;
+    const analysisLevel = useGraph ? "graph-expanded" : "file-only";
+    const originalFiles = /* @__PURE__ */ new Map();
+    const expandedFiles = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      const origSet = new Set(task.files);
+      originalFiles.set(task.id, origSet);
+      if (useGraph) {
+        const expanded = this.expandViaGraph(task.files, depth, edgeTypes);
+        expandedFiles.set(task.id, expanded);
+      } else {
+        expandedFiles.set(task.id, /* @__PURE__ */ new Map());
+      }
+    }
+    const taskIds = tasks.map((t) => t.id);
+    const pairs = [];
+    for (let i = 0; i < taskIds.length; i++) {
+      for (let j = i + 1; j < taskIds.length; j++) {
+        const idA = taskIds[i];
+        const idB = taskIds[j];
+        const pair = this.computePairOverlap(
+          idA,
+          idB,
+          originalFiles.get(idA),
+          originalFiles.get(idB),
+          expandedFiles.get(idA),
+          expandedFiles.get(idB)
+        );
+        pairs.push(pair);
+      }
+    }
+    const groups = this.buildGroups(taskIds, pairs);
+    const verdict = this.generateVerdict(taskIds, groups, analysisLevel);
+    return {
+      tasks: taskIds,
+      analysisLevel,
+      depth,
+      pairs,
+      groups,
+      verdict
+    };
+  }
+  // --- Private methods ---
+  validate(tasks) {
+    if (tasks.length < 2) {
+      throw new Error("At least 2 tasks are required for independence analysis");
+    }
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (seenIds.has(task.id)) {
+        throw new Error(`Duplicate task ID: "${task.id}"`);
+      }
+      seenIds.add(task.id);
+      if (task.files.length === 0) {
+        throw new Error(`Task "${task.id}" has an empty files array`);
+      }
+    }
+  }
+  expandViaGraph(files, depth, edgeTypes) {
+    const result = /* @__PURE__ */ new Map();
+    const store = this.store;
+    const cql = new ContextQL(store);
+    const fileSet = new Set(files);
+    for (const file of files) {
+      const nodeId = `file:${file}`;
+      const node = store.getNode(nodeId);
+      if (!node) continue;
+      const queryResult = cql.execute({
+        rootNodeIds: [nodeId],
+        maxDepth: depth,
+        includeEdges: edgeTypes,
+        includeTypes: ["file"]
+      });
+      for (const n of queryResult.nodes) {
+        const path6 = n.path ?? n.id.replace(/^file:/, "");
+        if (!fileSet.has(path6)) {
+          if (!result.has(path6)) {
+            result.set(path6, file);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  computePairOverlap(idA, idB, origA, origB, expandedA, expandedB) {
+    const overlaps = [];
+    for (const file of origA) {
+      if (origB.has(file)) {
+        overlaps.push({ file, type: "direct" });
+      }
+    }
+    const directFiles = new Set(overlaps.map((o) => o.file));
+    const transitiveFiles = /* @__PURE__ */ new Set();
+    for (const [file, via] of expandedA) {
+      if (origB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via });
+      }
+    }
+    for (const [file, via] of expandedB) {
+      if (origA.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via });
+      }
+    }
+    for (const [file, viaA] of expandedA) {
+      if (expandedB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
+        transitiveFiles.add(file);
+        overlaps.push({ file, type: "transitive", via: viaA });
+      }
+    }
+    return {
+      taskA: idA,
+      taskB: idB,
+      independent: overlaps.length === 0,
+      overlaps
+    };
+  }
+  buildGroups(taskIds, pairs) {
+    const parent = /* @__PURE__ */ new Map();
+    const rank = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      parent.set(id, id);
+      rank.set(id, 0);
+    }
+    const find = (x) => {
+      let root = x;
+      while (parent.get(root) !== root) {
+        root = parent.get(root);
+      }
+      let current = x;
+      while (current !== root) {
+        const next = parent.get(current);
+        parent.set(current, root);
+        current = next;
+      }
+      return root;
+    };
+    const union = (a, b) => {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA === rootB) return;
+      const rankA = rank.get(rootA);
+      const rankB = rank.get(rootB);
+      if (rankA < rankB) {
+        parent.set(rootA, rootB);
+      } else if (rankA > rankB) {
+        parent.set(rootB, rootA);
+      } else {
+        parent.set(rootB, rootA);
+        rank.set(rootA, rankA + 1);
+      }
+    };
+    for (const pair of pairs) {
+      if (!pair.independent) {
+        union(pair.taskA, pair.taskB);
+      }
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      const root = find(id);
+      if (!groupMap.has(root)) {
+        groupMap.set(root, []);
+      }
+      groupMap.get(root).push(id);
+    }
+    return Array.from(groupMap.values());
+  }
+  generateVerdict(taskIds, groups, analysisLevel) {
+    const total = taskIds.length;
+    const groupCount = groups.length;
+    let verdict;
+    if (groupCount === 1) {
+      verdict = `All ${total} tasks conflict \u2014 must run serially.`;
+    } else if (groupCount === total) {
+      verdict = `All ${total} tasks are independent \u2014 can all run in parallel.`;
+    } else {
+      verdict = `${total} tasks form ${groupCount} independent groups \u2014 ${groupCount} parallel waves possible.`;
+    }
+    if (analysisLevel === "file-only") {
+      verdict += " Graph unavailable \u2014 transitive dependencies not checked.";
+    }
+    return verdict;
+  }
+};
+
+// src/independence/ConflictPredictor.ts
+var ConflictPredictor = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  predict(params) {
+    const analyzer = new TaskIndependenceAnalyzer(this.store);
+    const result = analyzer.analyze(params);
+    const churnMap = /* @__PURE__ */ new Map();
+    const couplingMap = /* @__PURE__ */ new Map();
+    let churnThreshold = Infinity;
+    let couplingThreshold = Infinity;
+    if (this.store != null) {
+      const complexityResult = new GraphComplexityAdapter(this.store).computeComplexityHotspots();
+      for (const hotspot of complexityResult.hotspots) {
+        const existing = churnMap.get(hotspot.file);
+        if (existing === void 0 || hotspot.changeFrequency > existing) {
+          churnMap.set(hotspot.file, hotspot.changeFrequency);
+        }
+      }
+      const couplingResult = new GraphCouplingAdapter(this.store).computeCouplingData();
+      for (const fileData of couplingResult.files) {
+        couplingMap.set(fileData.file, fileData.fanIn + fileData.fanOut);
+      }
+      churnThreshold = this.computePercentile(Array.from(churnMap.values()), 80);
+      couplingThreshold = this.computePercentile(Array.from(couplingMap.values()), 80);
+    }
+    const conflicts = [];
+    for (const pair of result.pairs) {
+      if (pair.independent) continue;
+      const { severity, reason, mitigation } = this.classifyPair(
+        pair.taskA,
+        pair.taskB,
+        pair.overlaps,
+        churnMap,
+        couplingMap,
+        churnThreshold,
+        couplingThreshold
+      );
+      conflicts.push({
+        taskA: pair.taskA,
+        taskB: pair.taskB,
+        severity,
+        reason,
+        mitigation,
+        overlaps: pair.overlaps
+      });
+    }
+    const taskIds = result.tasks;
+    const groups = this.buildHighSeverityGroups(taskIds, conflicts);
+    const regrouped = !this.groupsEqual(result.groups, groups);
+    let highCount = 0;
+    let mediumCount = 0;
+    let lowCount = 0;
+    for (const c of conflicts) {
+      if (c.severity === "high") highCount++;
+      else if (c.severity === "medium") mediumCount++;
+      else lowCount++;
+    }
+    const verdict = this.generateVerdict(
+      taskIds,
+      groups,
+      result.analysisLevel,
+      highCount,
+      mediumCount,
+      lowCount,
+      regrouped
+    );
+    return {
+      tasks: taskIds,
+      analysisLevel: result.analysisLevel,
+      depth: result.depth,
+      conflicts,
+      groups,
+      summary: {
+        high: highCount,
+        medium: mediumCount,
+        low: lowCount,
+        regrouped
+      },
+      verdict
+    };
+  }
+  // --- Private helpers ---
+  classifyPair(taskA, taskB, overlaps, churnMap, couplingMap, churnThreshold, couplingThreshold) {
+    let maxSeverity = "low";
+    let primaryReason = "";
+    let primaryMitigation = "";
+    for (const overlap of overlaps) {
+      let overlapSeverity;
+      let reason;
+      let mitigation;
+      if (overlap.type === "direct") {
+        overlapSeverity = "high";
+        reason = `Both tasks write to ${overlap.file}`;
+        mitigation = `Serialize: run ${taskA} before ${taskB}`;
+      } else {
+        const churn = churnMap.get(overlap.file);
+        const coupling = couplingMap.get(overlap.file);
+        const via = overlap.via ?? "unknown";
+        if (churn !== void 0 && churn >= churnThreshold && churnThreshold !== Infinity) {
+          overlapSeverity = "medium";
+          reason = `Transitive overlap on high-churn file ${overlap.file} (via ${via})`;
+          mitigation = `Review: ${overlap.file} changes frequently \u2014 coordinate edits between ${taskA} and ${taskB}`;
+        } else if (coupling !== void 0 && coupling >= couplingThreshold && couplingThreshold !== Infinity) {
+          overlapSeverity = "medium";
+          reason = `Transitive overlap on highly-coupled file ${overlap.file} (via ${via})`;
+          mitigation = `Review: ${overlap.file} has high coupling \u2014 coordinate edits between ${taskA} and ${taskB}`;
+        } else {
+          overlapSeverity = "low";
+          reason = `Transitive overlap on ${overlap.file} (via ${via}) \u2014 low risk`;
+          mitigation = `Info: transitive overlap unlikely to cause conflicts`;
+        }
+      }
+      if (this.severityRank(overlapSeverity) > this.severityRank(maxSeverity)) {
+        maxSeverity = overlapSeverity;
+        primaryReason = reason;
+        primaryMitigation = mitigation;
+      } else if (primaryReason === "") {
+        primaryReason = reason;
+        primaryMitigation = mitigation;
+      }
+    }
+    return { severity: maxSeverity, reason: primaryReason, mitigation: primaryMitigation };
+  }
+  severityRank(severity) {
+    switch (severity) {
+      case "high":
+        return 3;
+      case "medium":
+        return 2;
+      case "low":
+        return 1;
+    }
+  }
+  computePercentile(values, percentile) {
+    if (values.length === 0) return Infinity;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[Math.min(index, sorted.length - 1)];
+  }
+  buildHighSeverityGroups(taskIds, conflicts) {
+    const parent = /* @__PURE__ */ new Map();
+    const rank = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      parent.set(id, id);
+      rank.set(id, 0);
+    }
+    const find = (x) => {
+      let root = x;
+      while (parent.get(root) !== root) {
+        root = parent.get(root);
+      }
+      let current = x;
+      while (current !== root) {
+        const next = parent.get(current);
+        parent.set(current, root);
+        current = next;
+      }
+      return root;
+    };
+    const union = (a, b) => {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA === rootB) return;
+      const rankA = rank.get(rootA);
+      const rankB = rank.get(rootB);
+      if (rankA < rankB) {
+        parent.set(rootA, rootB);
+      } else if (rankA > rankB) {
+        parent.set(rootB, rootA);
+      } else {
+        parent.set(rootB, rootA);
+        rank.set(rootA, rankA + 1);
+      }
+    };
+    for (const conflict of conflicts) {
+      if (conflict.severity === "high") {
+        union(conflict.taskA, conflict.taskB);
+      }
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      const root = find(id);
+      let group = groupMap.get(root);
+      if (group === void 0) {
+        group = [];
+        groupMap.set(root, group);
+      }
+      group.push(id);
+    }
+    return Array.from(groupMap.values());
+  }
+  groupsEqual(a, b) {
+    if (a.length !== b.length) return false;
+    const normalize2 = (groups) => groups.map((g) => [...g].sort()).sort((x, y) => {
+      const xFirst = x[0];
+      const yFirst = y[0];
+      return xFirst.localeCompare(yFirst);
+    });
+    const normA = normalize2(a);
+    const normB = normalize2(b);
+    for (let i = 0; i < normA.length; i++) {
+      const groupA = normA[i];
+      const groupB = normB[i];
+      if (groupA.length !== groupB.length) return false;
+      for (let j = 0; j < groupA.length; j++) {
+        if (groupA[j] !== groupB[j]) return false;
+      }
+    }
+    return true;
+  }
+  generateVerdict(taskIds, groups, analysisLevel, highCount, mediumCount, lowCount, regrouped) {
+    const total = taskIds.length;
+    const groupCount = groups.length;
+    const parts = [];
+    const conflictParts = [];
+    if (highCount > 0) conflictParts.push(`${highCount} high`);
+    if (mediumCount > 0) conflictParts.push(`${mediumCount} medium`);
+    if (lowCount > 0) conflictParts.push(`${lowCount} low`);
+    if (conflictParts.length === 0) {
+      parts.push(`${total} tasks have no conflicts \u2014 can all run in parallel.`);
+    } else {
+      parts.push(`${total} tasks have ${conflictParts.join(", ")} severity conflicts.`);
+    }
+    if (groupCount === 1) {
+      parts.push(`All tasks must run serially.`);
+    } else if (groupCount === total) {
+      parts.push(`${groupCount} parallel groups (all independent).`);
+    } else {
+      parts.push(`${groupCount} parallel groups possible.`);
+    }
+    if (regrouped) {
+      parts.push(`Tasks were regrouped due to high-severity conflicts.`);
+    }
+    if (analysisLevel === "file-only") {
+      parts.push(`Graph unavailable \u2014 severity based on file overlaps only.`);
+    }
+    return parts.join(" ");
+  }
+};
+
 // src/index.ts
 var VERSION = "0.2.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -3141,11 +4397,14 @@ var VERSION = "0.2.0";
   CIConnector,
   CURRENT_SCHEMA_VERSION,
   CodeIngestor,
+  ConflictPredictor,
   ConfluenceConnector,
   ContextQL,
   DesignConstraintAdapter,
   DesignIngestor,
   EDGE_TYPES,
+  EntityExtractor,
+  EntityResolver,
   FusionLayer,
   GitIngestor,
   GraphAnomalyAdapter,
@@ -3157,15 +4416,21 @@ var VERSION = "0.2.0";
   GraphFeedbackAdapter,
   GraphNodeSchema,
   GraphStore,
+  INTENTS,
+  IntentClassifier,
   JiraConnector,
   KnowledgeIngestor,
   NODE_TYPES,
   OBSERVABILITY_TYPES,
+  ResponseFormatter,
   SlackConnector,
   SyncManager,
+  TaskIndependenceAnalyzer,
   TopologicalLinker,
   VERSION,
   VectorStore,
+  askGraph,
+  groupNodesByImpact,
   linkToCode,
   loadGraph,
   project,