@harness-engineering/graph 0.4.0 → 0.4.2

package/dist/index.js

@@ -33,7 +33,9 @@ __export(index_exports, {
   Assembler: () => Assembler,
   CIConnector: () => CIConnector,
   CURRENT_SCHEMA_VERSION: () => CURRENT_SCHEMA_VERSION,
+  CascadeSimulator: () => CascadeSimulator,
   CodeIngestor: () => CodeIngestor,
+  CompositeProbabilityStrategy: () => CompositeProbabilityStrategy,
   ConflictPredictor: () => ConflictPredictor,
   ConfluenceConnector: () => ConfluenceConnector,
   ContextQL: () => ContextQL,
@@ -68,6 +70,7 @@ __export(index_exports, {
   VERSION: () => VERSION,
   VectorStore: () => VectorStore,
   askGraph: () => askGraph,
+  classifyNodeCategory: () => classifyNodeCategory,
   groupNodesByImpact: () => groupNodesByImpact,
   linkToCode: () => linkToCode,
   loadGraph: () => loadGraph,
@@ -241,6 +244,16 @@ function removeFromIndex(index, key, edge) {
   if (idx !== -1) list.splice(idx, 1);
   if (list.length === 0) index.delete(key);
 }
+function filterEdges(candidates, query) {
+  const results = [];
+  for (const edge of candidates) {
+    if (query.from !== void 0 && edge.from !== query.from) continue;
+    if (query.to !== void 0 && edge.to !== query.to) continue;
+    if (query.type !== void 0 && edge.type !== query.type) continue;
+    results.push({ ...edge });
+  }
+  return results;
+}
 var GraphStore = class {
   nodeMap = /* @__PURE__ */ new Map();
   edgeMap = /* @__PURE__ */ new Map();
@@ -308,44 +321,47 @@ var GraphStore = class {
     }
   }
   getEdges(query) {
-    let candidates;
     if (query.from !== void 0 && query.to !== void 0 && query.type !== void 0) {
       const edge = this.edgeMap.get(edgeKey(query.from, query.to, query.type));
       return edge ? [{ ...edge }] : [];
-    } else if (query.from !== void 0) {
-      candidates = this.edgesByFrom.get(query.from) ?? [];
-    } else if (query.to !== void 0) {
-      candidates = this.edgesByTo.get(query.to) ?? [];
-    } else if (query.type !== void 0) {
-      candidates = this.edgesByType.get(query.type) ?? [];
-    } else {
-      candidates = this.edgeMap.values();
     }
-    const results = [];
-    for (const edge of candidates) {
-      if (query.from !== void 0 && edge.from !== query.from) continue;
-      if (query.to !== void 0 && edge.to !== query.to) continue;
-      if (query.type !== void 0 && edge.type !== query.type) continue;
-      results.push({ ...edge });
+    const candidates = this.selectCandidates(query);
+    return filterEdges(candidates, query);
+  }
+  /** Pick the most selective index to start from. */
+  selectCandidates(query) {
+    if (query.from !== void 0) {
+      return this.edgesByFrom.get(query.from) ?? [];
     }
-    return results;
+    if (query.to !== void 0) {
+      return this.edgesByTo.get(query.to) ?? [];
+    }
+    if (query.type !== void 0) {
+      return this.edgesByType.get(query.type) ?? [];
+    }
+    return this.edgeMap.values();
   }
   getNeighbors(nodeId, direction = "both") {
-    const neighborIds = /* @__PURE__ */ new Set();
+    const neighborIds = this.collectNeighborIds(nodeId, direction);
+    return this.resolveNodes(neighborIds);
+  }
+  collectNeighborIds(nodeId, direction) {
+    const ids = /* @__PURE__ */ new Set();
     if (direction === "outbound" || direction === "both") {
-      const outEdges = this.edgesByFrom.get(nodeId) ?? [];
-      for (const edge of outEdges) {
-        neighborIds.add(edge.to);
+      for (const edge of this.edgesByFrom.get(nodeId) ?? []) {
+        ids.add(edge.to);
       }
     }
     if (direction === "inbound" || direction === "both") {
-      const inEdges = this.edgesByTo.get(nodeId) ?? [];
-      for (const edge of inEdges) {
-        neighborIds.add(edge.from);
+      for (const edge of this.edgesByTo.get(nodeId) ?? []) {
+        ids.add(edge.from);
       }
     }
+    return ids;
+  }
+  resolveNodes(ids) {
     const results = [];
-    for (const nid of neighborIds) {
+    for (const nid of ids) {
       const node = this.getNode(nid);
       if (node) results.push(node);
     }
@@ -624,6 +640,12 @@ var CODE_TYPES = /* @__PURE__ */ new Set([
   "method",
   "variable"
 ]);
+function classifyNodeCategory(node) {
+  if (TEST_TYPES.has(node.type)) return "tests";
+  if (DOC_TYPES.has(node.type)) return "docs";
+  if (CODE_TYPES.has(node.type)) return "code";
+  return "other";
+}
 function groupNodesByImpact(nodes, excludeId) {
   const tests = [];
   const docs = [];
@@ -631,15 +653,11 @@ function groupNodesByImpact(nodes, excludeId) {
   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);
-    }
+    const category = classifyNodeCategory(node);
+    if (category === "tests") tests.push(node);
+    else if (category === "docs") docs.push(node);
+    else if (category === "code") code.push(node);
+    else other.push(node);
   }
   return { tests, docs, code, other };
 }
@@ -1090,6 +1108,17 @@ var CodeIngestor = class {
 var import_node_child_process = require("child_process");
 var import_node_util = require("util");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+function finalizeCommit(current) {
+  return {
+    hash: current.hash,
+    shortHash: current.shortHash,
+    author: current.author,
+    email: current.email,
+    date: current.date,
+    message: current.message,
+    files: current.files
+  };
+}
 var GitIngestor = class {
   constructor(store, gitRunner) {
     this.store = store;
@@ -1126,39 +1155,49 @@ var GitIngestor = class {
     }
     const commits = this.parseGitLog(output);
     for (const commit of commits) {
-      const nodeId = `commit:${commit.shortHash}`;
-      this.store.addNode({
-        id: nodeId,
-        type: "commit",
-        name: commit.message,
-        metadata: {
-          author: commit.author,
-          email: commit.email,
-          date: commit.date,
-          hash: commit.hash
-        }
-      });
-      nodesAdded++;
-      for (const file of commit.files) {
-        const fileNodeId = `file:${file}`;
-        const existingNode = this.store.getNode(fileNodeId);
-        if (existingNode) {
-          this.store.addEdge({
-            from: fileNodeId,
-            to: nodeId,
-            type: "triggered_by"
-          });
-          edgesAdded++;
-        }
+      const counts = this.ingestCommit(commit);
+      nodesAdded += counts.nodesAdded;
+      edgesAdded += counts.edgesAdded;
+    }
+    edgesAdded += this.ingestCoChanges(commits);
+    return {
+      nodesAdded,
+      nodesUpdated,
+      edgesAdded,
+      edgesUpdated,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  ingestCommit(commit) {
+    const nodeId = `commit:${commit.shortHash}`;
+    this.store.addNode({
+      id: nodeId,
+      type: "commit",
+      name: commit.message,
+      metadata: {
+        author: commit.author,
+        email: commit.email,
+        date: commit.date,
+        hash: commit.hash
+      }
+    });
+    let edgesAdded = 0;
+    for (const file of commit.files) {
+      const fileNodeId = `file:${file}`;
+      if (this.store.getNode(fileNodeId)) {
+        this.store.addEdge({ from: fileNodeId, to: nodeId, type: "triggered_by" });
+        edgesAdded++;
       }
     }
-    const coChanges = this.computeCoChanges(commits);
-    for (const { fileA, fileB, count } of coChanges) {
+    return { nodesAdded: 1, edgesAdded };
+  }
+  ingestCoChanges(commits) {
+    let edgesAdded = 0;
+    for (const { fileA, fileB, count } of this.computeCoChanges(commits)) {
       const fileAId = `file:${fileA}`;
       const fileBId = `file:${fileB}`;
-      const nodeA = this.store.getNode(fileAId);
-      const nodeB = this.store.getNode(fileBId);
-      if (nodeA && nodeB) {
+      if (this.store.getNode(fileAId) && this.store.getNode(fileBId)) {
         this.store.addEdge({
           from: fileAId,
           to: fileBId,
@@ -1168,14 +1207,7 @@ var GitIngestor = class {
         edgesAdded++;
       }
     }
-    return {
-      nodesAdded,
-      nodesUpdated,
-      edgesAdded,
-      edgesUpdated,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return edgesAdded;
   }
   async runGit(rootDir, args) {
     if (this.gitRunner) {
@@ -1190,63 +1222,49 @@ var GitIngestor = class {
     const lines = output.split("\n");
     let current = null;
     for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        if (current && current.hasFiles) {
-          commits.push({
-            hash: current.hash,
-            shortHash: current.shortHash,
-            author: current.author,
-            email: current.email,
-            date: current.date,
-            message: current.message,
-            files: current.files
-          });
-          current = null;
-        }
-        continue;
+      current = this.processLogLine(line, current, commits);
+    }
+    if (current) {
+      commits.push(finalizeCommit(current));
+    }
+    return commits;
+  }
+  /**
+   * Process one line from git log output, updating the in-progress commit builder
+   * and flushing completed commits into the accumulator.
+   * Returns the updated current builder (null if flushed and not replaced).
+   */
+  processLogLine(line, current, commits) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (current?.hasFiles) {
+        commits.push(finalizeCommit(current));
+        return null;
       }
-      const parts = trimmed.split("|");
-      if (parts.length >= 5 && /^[0-9a-f]{7,40}$/.test(parts[0])) {
-        if (current) {
-          commits.push({
-            hash: current.hash,
-            shortHash: current.shortHash,
-            author: current.author,
-            email: current.email,
-            date: current.date,
-            message: current.message,
-            files: current.files
-          });
-        }
-        current = {
-          hash: parts[0],
-          shortHash: parts[0].substring(0, 7),
-          author: parts[1],
-          email: parts[2],
-          date: parts[3],
-          message: parts.slice(4).join("|"),
-          // message may contain |
-          files: [],
-          hasFiles: false
-        };
-      } else if (current) {
-        current.files.push(trimmed);
-        current.hasFiles = true;
+      return current;
+    }
+    const parts = trimmed.split("|");
+    if (parts.length >= 5 && /^[0-9a-f]{7,40}$/.test(parts[0])) {
+      if (current) {
+        commits.push(finalizeCommit(current));
       }
+      return {
+        hash: parts[0],
+        shortHash: parts[0].substring(0, 7),
+        author: parts[1],
+        email: parts[2],
+        date: parts[3],
+        message: parts.slice(4).join("|"),
+        // message may contain |
+        files: [],
+        hasFiles: false
+      };
     }
     if (current) {
-      commits.push({
-        hash: current.hash,
-        shortHash: current.shortHash,
-        author: current.author,
-        email: current.email,
-        date: current.date,
-        message: current.message,
-        files: current.files
-      });
+      current.files.push(trimmed);
+      current.hasFiles = true;
     }
-    return commits;
+    return current;
   }
   computeCoChanges(commits) {
     const pairCounts = /* @__PURE__ */ new Map();
@@ -1390,50 +1408,25 @@ var KnowledgeIngestor = class {
       try {
         const content = await fs2.readFile(filePath, "utf-8");
         const filename = path3.basename(filePath, ".md");
-        const titleMatch = content.match(/^#\s+(.+)$/m);
-        const title = titleMatch ? titleMatch[1].trim() : filename;
-        const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
-        const statusMatch = content.match(/\*\*Status:\*\*\s*(.+)/);
-        const date = dateMatch ? dateMatch[1].trim() : void 0;
-        const status = statusMatch ? statusMatch[1].trim() : void 0;
         const nodeId = `adr:${filename}`;
-        this.store.addNode({
-          id: nodeId,
-          type: "adr",
-          name: title,
-          path: filePath,
-          metadata: { date, status }
-        });
+        this.store.addNode(parseADRNode(nodeId, filePath, filename, content));
         nodesAdded++;
         edgesAdded += this.linkToCode(content, nodeId, "documents");
       } catch (err) {
         errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return buildResult(nodesAdded, edgesAdded, errors, start);
   }
   async ingestLearnings(projectPath) {
     const start = Date.now();
     const filePath = path3.join(projectPath, ".harness", "learnings.md");
-    let content;
-    try {
-      content = await fs2.readFile(filePath, "utf-8");
-    } catch {
-      return emptyResult(Date.now() - start);
-    }
-    const errors = [];
+    const content = await readFileOrEmpty(filePath);
+    if (content === null) return emptyResult(Date.now() - start);
     let nodesAdded = 0;
     let edgesAdded = 0;
-    const lines = content.split("\n");
     let currentDate;
-    for (const line of lines) {
+    for (const line of content.split("\n")) {
       const headingMatch = line.match(/^##\s+(\S+)/);
       if (headingMatch) {
         currentDate = headingMatch[1];
@@ -1442,70 +1435,29 @@ var KnowledgeIngestor = class {
       const bulletMatch = line.match(/^-\s+(.+)/);
       if (!bulletMatch) continue;
       const text = bulletMatch[1];
-      const skillMatch = text.match(/\[skill:([^\]]+)\]/);
-      const outcomeMatch = text.match(/\[outcome:([^\]]+)\]/);
-      const skill = skillMatch ? skillMatch[1] : void 0;
-      const outcome = outcomeMatch ? outcomeMatch[1] : void 0;
       const nodeId = `learning:${hash(text)}`;
-      this.store.addNode({
-        id: nodeId,
-        type: "learning",
-        name: text,
-        metadata: { skill, outcome, date: currentDate }
-      });
+      this.store.addNode(parseLearningNode(nodeId, text, currentDate));
       nodesAdded++;
       edgesAdded += this.linkToCode(text, nodeId, "applies_to");
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return buildResult(nodesAdded, edgesAdded, [], start);
   }
   async ingestFailures(projectPath) {
     const start = Date.now();
     const filePath = path3.join(projectPath, ".harness", "failures.md");
-    let content;
-    try {
-      content = await fs2.readFile(filePath, "utf-8");
-    } catch {
-      return emptyResult(Date.now() - start);
-    }
-    const errors = [];
+    const content = await readFileOrEmpty(filePath);
+    if (content === null) return emptyResult(Date.now() - start);
     let nodesAdded = 0;
     let edgesAdded = 0;
-    const sections = content.split(/^##\s+/m).filter((s) => s.trim());
-    for (const section of sections) {
-      const dateMatch = section.match(/\*\*Date:\*\*\s*(.+)/);
-      const skillMatch = section.match(/\*\*Skill:\*\*\s*(.+)/);
-      const typeMatch = section.match(/\*\*Type:\*\*\s*(.+)/);
-      const descMatch = section.match(/\*\*Description:\*\*\s*(.+)/);
-      const date = dateMatch ? dateMatch[1].trim() : void 0;
-      const skill = skillMatch ? skillMatch[1].trim() : void 0;
-      const failureType = typeMatch ? typeMatch[1].trim() : void 0;
-      const description = descMatch ? descMatch[1].trim() : void 0;
-      if (!description) continue;
-      const nodeId = `failure:${hash(description)}`;
-      this.store.addNode({
-        id: nodeId,
-        type: "failure",
-        name: description,
-        metadata: { date, skill, type: failureType }
-      });
+    for (const section of content.split(/^##\s+/m).filter((s) => s.trim())) {
+      const parsed = parseFailureSection(section);
+      if (!parsed) continue;
+      const { description, node } = parsed;
+      this.store.addNode(node);
       nodesAdded++;
-      edgesAdded += this.linkToCode(description, nodeId, "caused_by");
+      edgesAdded += this.linkToCode(description, node.id, "caused_by");
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return buildResult(nodesAdded, edgesAdded, [], start);
   }
   async ingestAll(projectPath, opts) {
     const start = Date.now();
@@ -1559,6 +1511,74 @@ var KnowledgeIngestor = class {
     return results;
   }
 };
+async function readFileOrEmpty(filePath) {
+  try {
+    return await fs2.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function buildResult(nodesAdded, edgesAdded, errors, start) {
+  return {
+    nodesAdded,
+    nodesUpdated: 0,
+    edgesAdded,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+function parseADRNode(nodeId, filePath, filename, content) {
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : filename;
+  const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
+  const statusMatch = content.match(/\*\*Status:\*\*\s*(.+)/);
+  return {
+    id: nodeId,
+    type: "adr",
+    name: title,
+    path: filePath,
+    metadata: {
+      date: dateMatch ? dateMatch[1].trim() : void 0,
+      status: statusMatch ? statusMatch[1].trim() : void 0
+    }
+  };
+}
+function parseLearningNode(nodeId, text, currentDate) {
+  const skillMatch = text.match(/\[skill:([^\]]+)\]/);
+  const outcomeMatch = text.match(/\[outcome:([^\]]+)\]/);
+  return {
+    id: nodeId,
+    type: "learning",
+    name: text,
+    metadata: {
+      skill: skillMatch ? skillMatch[1] : void 0,
+      outcome: outcomeMatch ? outcomeMatch[1] : void 0,
+      date: currentDate
+    }
+  };
+}
+function parseFailureSection(section) {
+  const descMatch = section.match(/\*\*Description:\*\*\s*(.+)/);
+  const description = descMatch ? descMatch[1].trim() : void 0;
+  if (!description) return null;
+  const dateMatch = section.match(/\*\*Date:\*\*\s*(.+)/);
+  const skillMatch = section.match(/\*\*Skill:\*\*\s*(.+)/);
+  const typeMatch = section.match(/\*\*Type:\*\*\s*(.+)/);
+  return {
+    description,
+    node: {
+      id: `failure:${hash(description)}`,
+      type: "failure",
+      name: description,
+      metadata: {
+        date: dateMatch ? dateMatch[1].trim() : void 0,
+        skill: skillMatch ? skillMatch[1].trim() : void 0,
+        type: typeMatch ? typeMatch[1].trim() : void 0
+      }
+    }
+  };
+}
 
 // src/ingest/RequirementIngestor.ts
 var fs3 = __toESM(require("fs/promises"));
@@ -1603,40 +1623,9 @@ var RequirementIngestor = class {
       return emptyResult(Date.now() - start);
     }
     for (const featureDir of featureDirs) {
-      const featureName = path4.basename(featureDir);
-      const specPath = path4.join(featureDir, "proposal.md");
-      let content;
-      try {
-        content = await fs3.readFile(specPath, "utf-8");
-      } catch {
-        continue;
-      }
-      try {
-        const specHash = hash(specPath);
-        const specNodeId = `file:${specPath}`;
-        this.store.addNode({
-          id: specNodeId,
-          type: "document",
-          name: path4.basename(specPath),
-          path: specPath,
-          metadata: { featureName }
-        });
-        const requirements = this.extractRequirements(content, specPath, specHash, featureName);
-        for (const req of requirements) {
-          this.store.addNode(req.node);
-          nodesAdded++;
-          this.store.addEdge({
-            from: req.node.id,
-            to: specNodeId,
-            type: "specifies"
-          });
-          edgesAdded++;
-          edgesAdded += this.linkByPathPattern(req.node.id, featureName);
-          edgesAdded += this.linkByKeywordOverlap(req.node.id, req.node.name);
-        }
-      } catch (err) {
-        errors.push(`${specPath}: ${err instanceof Error ? err.message : String(err)}`);
-      }
+      const counts = await this.ingestFeatureDir(featureDir, errors);
+      nodesAdded += counts.nodesAdded;
+      edgesAdded += counts.edgesAdded;
     }
     return {
       nodesAdded,
@@ -1647,6 +1636,48 @@ var RequirementIngestor = class {
       durationMs: Date.now() - start
     };
   }
+  async ingestFeatureDir(featureDir, errors) {
+    const featureName = path4.basename(featureDir);
+    const specPath = path4.join(featureDir, "proposal.md").replaceAll("\\", "/");
+    let content;
+    try {
+      content = await fs3.readFile(specPath, "utf-8");
+    } catch {
+      return { nodesAdded: 0, edgesAdded: 0 };
+    }
+    try {
+      return this.ingestSpec(specPath, content, featureName);
+    } catch (err) {
+      errors.push(`${specPath}: ${err instanceof Error ? err.message : String(err)}`);
+      return { nodesAdded: 0, edgesAdded: 0 };
+    }
+  }
+  ingestSpec(specPath, content, featureName) {
+    const specHash = hash(specPath);
+    const specNodeId = `file:${specPath}`;
+    this.store.addNode({
+      id: specNodeId,
+      type: "document",
+      name: path4.basename(specPath),
+      path: specPath,
+      metadata: { featureName }
+    });
+    const requirements = this.extractRequirements(content, specPath, specHash, featureName);
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    for (const req of requirements) {
+      const counts = this.ingestRequirement(req.node, specNodeId, featureName);
+      nodesAdded += counts.nodesAdded;
+      edgesAdded += counts.edgesAdded;
+    }
+    return { nodesAdded, edgesAdded };
+  }
+  ingestRequirement(node, specNodeId, featureName) {
+    this.store.addNode(node);
+    this.store.addEdge({ from: node.id, to: specNodeId, type: "specifies" });
+    const edgesAdded = 1 + this.linkByPathPattern(node.id, featureName) + this.linkByKeywordOverlap(node.id, node.name);
+    return { nodesAdded: 1, edgesAdded };
+  }
   /**
    * Parse markdown content and extract numbered items from recognized sections.
    */
@@ -1658,54 +1689,80 @@ var RequirementIngestor = class {
     let globalIndex = 0;
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
-      const headingMatch = line.match(SECTION_HEADING_RE);
-      if (headingMatch) {
-        const heading = headingMatch[1].trim();
-        const isReqSection = REQUIREMENT_SECTIONS.some(
-          (s) => heading.toLowerCase() === s.toLowerCase()
-        );
-        if (isReqSection) {
-          currentSection = heading;
-          inRequirementSection = true;
-        } else {
-          inRequirementSection = false;
+      const sectionResult = this.processHeadingLine(line, inRequirementSection);
+      if (sectionResult !== null) {
+        inRequirementSection = sectionResult.inRequirementSection;
+        if (sectionResult.currentSection !== void 0) {
+          currentSection = sectionResult.currentSection;
         }
         continue;
       }
       if (!inRequirementSection) continue;
       const itemMatch = line.match(NUMBERED_ITEM_RE);
       if (!itemMatch) continue;
-      const index = parseInt(itemMatch[1], 10);
-      const text = itemMatch[2].trim();
-      const rawText = line.trim();
-      const lineNumber = i + 1;
       globalIndex++;
-      const nodeId = `req:${specHash}:${globalIndex}`;
-      const earsPattern = detectEarsPattern(text);
-      results.push({
-        node: {
-          id: nodeId,
-          type: "requirement",
-          name: text,
-          path: specPath,
-          location: {
-            fileId: `file:${specPath}`,
-            startLine: lineNumber,
-            endLine: lineNumber
-          },
-          metadata: {
-            specPath,
-            index,
-            section: currentSection,
-            rawText,
-            earsPattern,
-            featureName
-          }
-        }
-      });
+      results.push(
+        this.buildRequirementNode(
+          line,
+          itemMatch,
+          i + 1,
+          specPath,
+          specHash,
+          globalIndex,
+          featureName,
+          currentSection
+        )
+      );
     }
     return results;
   }
+  /**
+   * Check if a line is a section heading and return updated section state,
+   * or return null if the line is not a heading.
+   */
+  processHeadingLine(line, _inRequirementSection) {
+    const headingMatch = line.match(SECTION_HEADING_RE);
+    if (!headingMatch) return null;
+    const heading = headingMatch[1].trim();
+    const isReqSection = REQUIREMENT_SECTIONS.some(
+      (s) => heading.toLowerCase() === s.toLowerCase()
+    );
+    if (isReqSection) {
+      return { inRequirementSection: true, currentSection: heading };
+    }
+    return { inRequirementSection: false };
+  }
+  /**
+   * Build a requirement GraphNode from a matched numbered-item line.
+   */
+  buildRequirementNode(line, itemMatch, lineNumber, specPath, specHash, globalIndex, featureName, currentSection) {
+    const index = parseInt(itemMatch[1], 10);
+    const text = itemMatch[2].trim();
+    const rawText = line.trim();
+    const nodeId = `req:${specHash}:${globalIndex}`;
+    const earsPattern = detectEarsPattern(text);
+    return {
+      node: {
+        id: nodeId,
+        type: "requirement",
+        name: text,
+        path: specPath,
+        location: {
+          fileId: `file:${specPath}`,
+          startLine: lineNumber,
+          endLine: lineNumber
+        },
+        metadata: {
+          specPath,
+          index,
+          section: currentSection,
+          rawText,
+          earsPattern,
+          featureName
+        }
+      }
+    };
+  }
   /**
    * Convention-based linking: match requirement to code/test files
    * by feature name in their path.
@@ -1754,7 +1811,7 @@ var RequirementIngestor = class {
         const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
         if (namePattern.test(reqText)) {
-          const edgeType = node.path && node.path.replace(/\\/g, "/").includes("/tests/") ? "verified_by" : "requires";
+          const edgeType = node.path?.replace(/\\/g, "/").includes("/tests/") ? "verified_by" : "requires";
           this.store.addEdge({
             from: reqId,
             to: node.id,
@@ -1909,15 +1966,18 @@ function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
     durationMs: Date.now() - start
   };
 }
+function appendJqlClause(jql, clause) {
+  return jql ? `${jql} AND ${clause}` : clause;
+}
 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(",")})`;
+    jql = appendJqlClause(jql, `status IN (${filters.status.map((s) => `"${s}"`).join(",")})`);
   }
   if (filters?.labels?.length) {
-    jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+    jql = appendJqlClause(jql, `labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`);
   }
   return jql;
 }
@@ -1930,8 +1990,6 @@ var JiraConnector = class {
   }
   async ingest(store, config) {
     const start = Date.now();
-    let nodesAdded = 0;
-    let edgesAdded = 0;
     const apiKeyEnv = config.apiKeyEnv ?? "JIRA_API_KEY";
     const apiKey = process.env[apiKeyEnv];
     if (!apiKey) {
@@ -1953,38 +2011,39 @@ var JiraConnector = class {
       );
     }
     const jql = buildJql(config);
-    const headers = {
-      Authorization: `Basic ${apiKey}`,
-      "Content-Type": "application/json"
-    };
+    const headers = { Authorization: `Basic ${apiKey}`, "Content-Type": "application/json" };
     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 buildIngestResult(nodesAdded, edgesAdded, ["Jira API request failed"], start);
-        }
-        const data = await response.json();
-        total = data.total;
-        for (const issue of data.issues) {
-          const counts = this.processIssue(store, issue);
-          nodesAdded += counts.nodesAdded;
-          edgesAdded += counts.edgesAdded;
-        }
-        startAt += maxResults;
-      }
+      const counts = await this.fetchAllIssues(store, baseUrl, jql, headers);
+      return buildIngestResult(counts.nodesAdded, counts.edgesAdded, [], start);
     } catch (err) {
       return buildIngestResult(
-        nodesAdded,
-        edgesAdded,
+        0,
+        0,
         [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
         start
       );
     }
-    return buildIngestResult(nodesAdded, edgesAdded, [], start);
+  }
+  async fetchAllIssues(store, baseUrl, jql, headers) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    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) throw new Error("Jira API request failed");
+      const data = await response.json();
+      total = data.total;
+      for (const issue of data.issues) {
+        const counts = this.processIssue(store, issue);
+        nodesAdded += counts.nodesAdded;
+        edgesAdded += counts.edgesAdded;
+      }
+      startAt += maxResults;
+    }
+    return { nodesAdded, edgesAdded };
   }
   processIssue(store, issue) {
     const nodeId = `issue:jira:${issue.key}`;
@@ -2105,6 +2164,16 @@ var SlackConnector = class {
 };
 
 // src/ingest/connectors/ConfluenceConnector.ts
+function missingApiKeyResult(envVar, start) {
+  return {
+    nodesAdded: 0,
+    nodesUpdated: 0,
+    edgesAdded: 0,
+    edgesUpdated: 0,
+    errors: [`Missing API key: environment variable "${envVar}" is not set`],
+    durationMs: Date.now() - start
+  };
+}
 var ConfluenceConnector = class {
   name = "confluence";
   source = "confluence";
@@ -2115,40 +2184,34 @@ var ConfluenceConnector = class {
   async ingest(store, config) {
     const start = Date.now();
     const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
     const apiKeyEnv = config.apiKeyEnv ?? "CONFLUENCE_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 missingApiKeyResult(apiKeyEnv, start);
     }
     const baseUrlEnv = config.baseUrlEnv ?? "CONFLUENCE_BASE_URL";
     const baseUrl = process.env[baseUrlEnv] ?? "";
     const spaceKey = config.spaceKey ?? "";
-    try {
-      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)}`);
-    }
+    const counts = await this.fetchAllPagesHandled(store, baseUrl, apiKey, spaceKey, errors);
     return {
-      nodesAdded,
+      nodesAdded: counts.nodesAdded,
       nodesUpdated: 0,
-      edgesAdded,
+      edgesAdded: counts.edgesAdded,
       edgesUpdated: 0,
       errors,
       durationMs: Date.now() - start
     };
   }
+  async fetchAllPagesHandled(store, baseUrl, apiKey, spaceKey, errors) {
+    try {
+      const result = await this.fetchAllPages(store, baseUrl, apiKey, spaceKey);
+      errors.push(...result.errors);
+      return { nodesAdded: result.nodesAdded, edgesAdded: result.edgesAdded };
+    } catch (err) {
+      errors.push(`Confluence fetch error: ${err instanceof Error ? err.message : String(err)}`);
+      return { nodesAdded: 0, edgesAdded: 0 };
+    }
+  }
   async fetchAllPages(store, baseUrl, apiKey, spaceKey) {
     const errors = [];
     let nodesAdded = 0;
@@ -2193,7 +2256,62 @@ var ConfluenceConnector = class {
 };
 
 // src/ingest/connectors/CIConnector.ts
-var CIConnector = class {
+function emptyResult2(errors, start) {
+  return {
+    nodesAdded: 0,
+    nodesUpdated: 0,
+    edgesAdded: 0,
+    edgesUpdated: 0,
+    errors,
+    durationMs: Date.now() - start
+  };
+}
+function ingestRun(store, run) {
+  const buildId = `build:${run.id}`;
+  const safeName = sanitizeExternalText(run.name, 200);
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  store.addNode({
+    id: buildId,
+    type: "build",
+    name: `${safeName} #${run.id}`,
+    metadata: {
+      source: "github-actions",
+      status: run.status,
+      conclusion: run.conclusion,
+      branch: run.head_branch,
+      sha: run.head_sha,
+      url: run.html_url,
+      createdAt: run.created_at
+    }
+  });
+  nodesAdded++;
+  const commitNode = store.getNode(`commit:${run.head_sha}`);
+  if (commitNode) {
+    store.addEdge({ from: buildId, to: commitNode.id, type: "triggered_by" });
+    edgesAdded++;
+  }
+  if (run.conclusion === "failure") {
+    const testResultId = `test_result:${run.id}`;
+    store.addNode({
+      id: testResultId,
+      type: "test_result",
+      name: `Failed: ${safeName} #${run.id}`,
+      metadata: {
+        source: "github-actions",
+        buildId: String(run.id),
+        conclusion: "failure",
+        branch: run.head_branch,
+        sha: run.head_sha
+      }
+    });
+    nodesAdded++;
+    store.addEdge({ from: testResultId, to: buildId, type: "failed_in" });
+    edgesAdded++;
+  }
+  return { nodesAdded, edgesAdded };
+}
+var CIConnector = class {
   name = "ci";
   source = "github-actions";
   httpClient;
@@ -2203,22 +2321,29 @@ var CIConnector = class {
   async ingest(store, config) {
     const start = Date.now();
     const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
     const apiKeyEnv = config.apiKeyEnv ?? "GITHUB_TOKEN";
     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 emptyResult2(
+        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        start
+      );
     }
     const repo = config.repo ?? "";
     const maxRuns = config.maxRuns ?? 10;
+    const counts = await this.fetchAndIngestRuns(store, repo, maxRuns, apiKey, errors);
+    return {
+      nodesAdded: counts.nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded: counts.edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  async fetchAndIngestRuns(store, repo, maxRuns, apiKey, errors) {
+    let nodesAdded = 0;
+    let edgesAdded = 0;
     try {
       const url = `https://api.github.com/repos/${repo}/actions/runs?per_page=${maxRuns}`;
       const response = await this.httpClient(url, {
@@ -2226,71 +2351,20 @@ var CIConnector = class {
       });
       if (!response.ok) {
         errors.push(`GitHub Actions API error: status ${response.status}`);
-        return {
-          nodesAdded: 0,
-          nodesUpdated: 0,
-          edgesAdded: 0,
-          edgesUpdated: 0,
-          errors,
-          durationMs: Date.now() - start
-        };
+        return { nodesAdded, edgesAdded };
       }
       const data = await response.json();
       for (const run of data.workflow_runs) {
-        const buildId = `build:${run.id}`;
-        const safeName = sanitizeExternalText(run.name, 200);
-        store.addNode({
-          id: buildId,
-          type: "build",
-          name: `${safeName} #${run.id}`,
-          metadata: {
-            source: "github-actions",
-            status: run.status,
-            conclusion: run.conclusion,
-            branch: run.head_branch,
-            sha: run.head_sha,
-            url: run.html_url,
-            createdAt: run.created_at
-          }
-        });
-        nodesAdded++;
-        const commitNode = store.getNode(`commit:${run.head_sha}`);
-        if (commitNode) {
-          store.addEdge({ from: buildId, to: commitNode.id, type: "triggered_by" });
-          edgesAdded++;
-        }
-        if (run.conclusion === "failure") {
-          const testResultId = `test_result:${run.id}`;
-          store.addNode({
-            id: testResultId,
-            type: "test_result",
-            name: `Failed: ${safeName} #${run.id}`,
-            metadata: {
-              source: "github-actions",
-              buildId: String(run.id),
-              conclusion: "failure",
-              branch: run.head_branch,
-              sha: run.head_sha
-            }
-          });
-          nodesAdded++;
-          store.addEdge({ from: testResultId, to: buildId, type: "failed_in" });
-          edgesAdded++;
-        }
+        const counts = ingestRun(store, run);
+        nodesAdded += counts.nodesAdded;
+        edgesAdded += counts.edgesAdded;
       }
     } catch (err) {
       errors.push(
         `GitHub Actions fetch error: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return { nodesAdded, edgesAdded };
   }
 };
 
@@ -2360,16 +2434,29 @@ var FusionLayer = class {
       return [];
     }
     const allNodes = this.store.findNodes({});
+    const semanticScores = this.buildSemanticScores(queryEmbedding, allNodes.length);
+    const { kwWeight, semWeight } = this.resolveWeights(semanticScores.size > 0);
+    const results = this.scoreNodes(allNodes, keywords, semanticScores, kwWeight, semWeight);
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  buildSemanticScores(queryEmbedding, nodeCount) {
     const semanticScores = /* @__PURE__ */ new Map();
     if (queryEmbedding && this.vectorStore) {
-      const vectorResults = this.vectorStore.search(queryEmbedding, allNodes.length);
+      const vectorResults = this.vectorStore.search(queryEmbedding, nodeCount);
       for (const vr of vectorResults) {
         semanticScores.set(vr.id, vr.score);
       }
     }
-    const hasSemanticScores = semanticScores.size > 0;
-    const kwWeight = hasSemanticScores ? this.keywordWeight : 1;
-    const semWeight = hasSemanticScores ? this.semanticWeight : 0;
+    return semanticScores;
+  }
+  resolveWeights(hasSemanticScores) {
+    return {
+      kwWeight: hasSemanticScores ? this.keywordWeight : 1,
+      semWeight: hasSemanticScores ? this.semanticWeight : 0
+    };
+  }
+  scoreNodes(allNodes, keywords, semanticScores, kwWeight, semWeight) {
     const results = [];
     for (const node of allNodes) {
       const kwScore = this.keywordScore(keywords, node);
@@ -2380,15 +2467,11 @@ var FusionLayer = class {
           nodeId: node.id,
           node,
           score: fusedScore,
-          signals: {
-            keyword: kwScore,
-            semantic: semScore
-          }
+          signals: { keyword: kwScore, semantic: semScore }
         });
       }
     }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
+    return results;
   }
   extractKeywords(query) {
     const tokens = query.toLowerCase().split(/[\s\-_.,:;!?()[\]{}"'`/\\|@#$%^&*+=<>~]+/).filter((t) => t.length >= 2).filter((t) => !STOP_WORDS.has(t));
@@ -2443,37 +2526,50 @@ var GraphEntropyAdapter = class {
     const missingTargets = [];
     let freshEdges = 0;
     for (const edge of documentsEdges) {
-      const codeNode = this.store.getNode(edge.to);
-      if (!codeNode) {
+      const result = this.classifyDocEdge(edge);
+      if (result.kind === "missing") {
         missingTargets.push(edge.to);
-        continue;
+      } else if (result.kind === "fresh") {
+        freshEdges++;
+      } else {
+        staleEdges.push(result.entry);
       }
-      const docNode = this.store.getNode(edge.from);
-      const codeLastModified = codeNode.lastModified;
-      const docLastModified = docNode?.lastModified;
-      if (codeLastModified && docLastModified) {
-        if (codeLastModified > docLastModified) {
-          staleEdges.push({
+    }
+    return { staleEdges, missingTargets, freshEdges };
+  }
+  classifyDocEdge(edge) {
+    const codeNode = this.store.getNode(edge.to);
+    if (!codeNode) {
+      return { kind: "missing" };
+    }
+    const docNode = this.store.getNode(edge.from);
+    const codeLastModified = codeNode.lastModified;
+    const docLastModified = docNode?.lastModified;
+    if (codeLastModified && docLastModified) {
+      if (codeLastModified > docLastModified) {
+        return {
+          kind: "stale",
+          entry: {
             docNodeId: edge.from,
             codeNodeId: edge.to,
             edgeType: edge.type,
             codeLastModified,
             docLastModified
-          });
-        } else {
-          freshEdges++;
-        }
-      } else {
-        staleEdges.push({
-          docNodeId: edge.from,
-          codeNodeId: edge.to,
-          edgeType: edge.type,
-          codeLastModified,
-          docLastModified
-        });
+          }
+        };
       }
+      return { kind: "fresh" };
     }
-    return { staleEdges, missingTargets, freshEdges };
+    return {
+      kind: "stale",
+      entry: {
+        docNodeId: edge.from,
+        codeNodeId: edge.to,
+        edgeType: edge.type,
+        codeLastModified,
+        docLastModified
+      }
+    };
   }
   /**
    * BFS from entry points to find reachable vs unreachable code nodes.
@@ -2730,36 +2826,12 @@ var GraphAnomalyAdapter = class {
   store;
   detect(options) {
     const threshold = options?.threshold != null && options.threshold > 0 ? options.threshold : DEFAULT_THRESHOLD;
-    const requestedMetrics = options?.metrics ?? [...DEFAULT_METRICS];
-    const warnings = [];
-    const metricsToAnalyze = [];
-    for (const m of requestedMetrics) {
-      if (RECOGNIZED_METRICS.has(m)) {
-        metricsToAnalyze.push(m);
-      } else {
-        warnings.push(m);
-      }
-    }
-    const allOutliers = [];
-    const analyzedNodeIds = /* @__PURE__ */ new Set();
-    const couplingMetrics = ["fanIn", "fanOut", "transitiveDepth"];
-    const needsCoupling = metricsToAnalyze.some((m) => couplingMetrics.includes(m));
-    const needsComplexity = metricsToAnalyze.includes("hotspotScore");
-    const cachedCouplingData = needsCoupling ? new GraphCouplingAdapter(this.store).computeCouplingData() : void 0;
-    const cachedHotspotData = needsComplexity ? new GraphComplexityAdapter(this.store).computeComplexityHotspots() : void 0;
-    for (const metric of metricsToAnalyze) {
-      const entries = this.collectMetricValues(metric, cachedCouplingData, cachedHotspotData);
-      for (const e of entries) {
-        analyzedNodeIds.add(e.nodeId);
-      }
-      const outliers = this.computeZScoreOutliers(entries, metric, threshold);
-      allOutliers.push(...outliers);
-    }
-    allOutliers.sort((a, b) => b.zScore - a.zScore);
+    const { metricsToAnalyze, warnings } = this.filterMetrics(
+      options?.metrics ?? [...DEFAULT_METRICS]
+    );
+    const { allOutliers, analyzedNodeIds } = this.computeAllOutliers(metricsToAnalyze, threshold);
     const articulationPoints = this.findArticulationPoints();
-    const outlierNodeIds = new Set(allOutliers.map((o) => o.nodeId));
-    const apNodeIds = new Set(articulationPoints.map((ap) => ap.nodeId));
-    const overlapping = [...outlierNodeIds].filter((id) => apNodeIds.has(id));
+    const overlapping = this.computeOverlap(allOutliers, articulationPoints);
     return {
       statisticalOutliers: allOutliers,
       articulationPoints,
@@ -2775,6 +2847,38 @@ var GraphAnomalyAdapter = class {
       }
     };
   }
+  filterMetrics(requested) {
+    const metricsToAnalyze = [];
+    const warnings = [];
+    for (const m of requested) {
+      if (RECOGNIZED_METRICS.has(m)) {
+        metricsToAnalyze.push(m);
+      } else {
+        warnings.push(m);
+      }
+    }
+    return { metricsToAnalyze, warnings };
+  }
+  computeAllOutliers(metricsToAnalyze, threshold) {
+    const couplingMetrics = ["fanIn", "fanOut", "transitiveDepth"];
+    const needsCoupling = metricsToAnalyze.some((m) => couplingMetrics.includes(m));
+    const cachedCouplingData = needsCoupling ? new GraphCouplingAdapter(this.store).computeCouplingData() : void 0;
+    const cachedHotspotData = metricsToAnalyze.includes("hotspotScore") ? new GraphComplexityAdapter(this.store).computeComplexityHotspots() : void 0;
+    const allOutliers = [];
+    const analyzedNodeIds = /* @__PURE__ */ new Set();
+    for (const metric of metricsToAnalyze) {
+      const entries = this.collectMetricValues(metric, cachedCouplingData, cachedHotspotData);
+      for (const e of entries) analyzedNodeIds.add(e.nodeId);
+      allOutliers.push(...this.computeZScoreOutliers(entries, metric, threshold));
+    }
+    allOutliers.sort((a, b) => b.zScore - a.zScore);
+    return { allOutliers, analyzedNodeIds };
+  }
+  computeOverlap(outliers, articulationPoints) {
+    const outlierNodeIds = new Set(outliers.map((o) => o.nodeId));
+    const apNodeIds = new Set(articulationPoints.map((ap) => ap.nodeId));
+    return [...outlierNodeIds].filter((id) => apNodeIds.has(id));
+  }
   collectMetricValues(metric, cachedCouplingData, cachedHotspotData) {
     const entries = [];
     if (metric === "cyclomaticComplexity") {
@@ -2971,6 +3075,7 @@ var INTENT_SIGNALS = {
       "depend",
       "blast",
       "radius",
+      "cascade",
       "risk",
       "delete",
       "remove"
@@ -2980,6 +3085,7 @@ var INTENT_SIGNALS = {
       /what\s+(breaks|happens|is affected)/,
       /if\s+i\s+(change|modify|remove|delete)/,
       /blast\s+radius/,
+      /cascad/,
       /what\s+(depend|relies)/
     ]
   },
@@ -3328,37 +3434,54 @@ var EntityExtractor = class {
         result.push(entity);
       }
     };
-    const quotedConsumed = /* @__PURE__ */ new Set();
+    const quotedConsumed = this.extractQuoted(trimmed, add);
+    const casingConsumed = this.extractCasing(trimmed, quotedConsumed, add);
+    const pathConsumed = this.extractPaths(trimmed, add);
+    this.extractNouns(trimmed, buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed), add);
+    return result;
+  }
+  /** Strategy 1: Quoted strings. Returns the set of consumed tokens. */
+  extractQuoted(trimmed, add) {
+    const consumed = /* @__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);
+        consumed.add(inner);
       }
     }
-    const casingConsumed = /* @__PURE__ */ new Set();
+    return consumed;
+  }
+  /** Strategy 2: PascalCase/camelCase tokens. Returns the set of consumed tokens. */
+  extractCasing(trimmed, quotedConsumed, add) {
+    const consumed = /* @__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);
+        consumed.add(token);
       }
     }
-    const pathConsumed = /* @__PURE__ */ new Set();
+    return consumed;
+  }
+  /** Strategy 3: File paths. Returns the set of consumed tokens. */
+  extractPaths(trimmed, add) {
+    const consumed = /* @__PURE__ */ new Set();
     for (const match of trimmed.matchAll(FILE_PATH_RE)) {
       const path7 = match[0];
       add(path7);
-      pathConsumed.add(path7);
+      consumed.add(path7);
     }
-    const allConsumed = buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed);
-    const words = trimmed.split(/\s+/);
-    for (const raw of words) {
+    return consumed;
+  }
+  /** Strategy 4: Remaining significant nouns after stop-word and intent-keyword removal. */
+  extractNouns(trimmed, allConsumed, add) {
+    for (const raw of trimmed.split(/\s+/)) {
       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;
   }
 };
 
@@ -3465,6 +3588,10 @@ var ResponseFormatter = class {
   }
   formatImpact(entityName, data) {
     const d = data;
+    if ("sourceNodeId" in d && "summary" in d) {
+      const summary = d.summary;
+      return `Blast radius of **${entityName}**: ${summary.totalAffected} affected nodes (${summary.highRisk} high risk, ${summary.mediumRisk} medium, ${summary.lowRisk} low).`;
+    }
     const code = this.safeArrayLength(d?.code);
     const tests = this.safeArrayLength(d?.tests);
     const docs = this.safeArrayLength(d?.docs);
@@ -3526,41 +3653,286 @@ var ResponseFormatter = class {
   }
 };
 
+// src/blast-radius/CompositeProbabilityStrategy.ts
+var CompositeProbabilityStrategy = class _CompositeProbabilityStrategy {
+  constructor(changeFreqMap, couplingMap) {
+    this.changeFreqMap = changeFreqMap;
+    this.couplingMap = couplingMap;
+  }
+  changeFreqMap;
+  couplingMap;
+  static BASE_WEIGHTS = {
+    imports: 0.7,
+    calls: 0.5,
+    implements: 0.6,
+    inherits: 0.6,
+    co_changes_with: 0.4,
+    references: 0.2,
+    contains: 0.3
+  };
+  static FALLBACK_WEIGHT = 0.1;
+  static EDGE_TYPE_BLEND = 0.5;
+  static CHANGE_FREQ_BLEND = 0.3;
+  static COUPLING_BLEND = 0.2;
+  getEdgeProbability(edge, _fromNode, toNode) {
+    const base = _CompositeProbabilityStrategy.BASE_WEIGHTS[edge.type] ?? _CompositeProbabilityStrategy.FALLBACK_WEIGHT;
+    const changeFreq = this.changeFreqMap.get(toNode.id) ?? 0;
+    const coupling = this.couplingMap.get(toNode.id) ?? 0;
+    return Math.min(
+      1,
+      base * _CompositeProbabilityStrategy.EDGE_TYPE_BLEND + changeFreq * _CompositeProbabilityStrategy.CHANGE_FREQ_BLEND + coupling * _CompositeProbabilityStrategy.COUPLING_BLEND
+    );
+  }
+};
+
+// src/blast-radius/CascadeSimulator.ts
+var DEFAULT_PROBABILITY_FLOOR = 0.05;
+var DEFAULT_MAX_DEPTH = 10;
+var CascadeSimulator = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  simulate(sourceNodeId, options = {}) {
+    const sourceNode = this.store.getNode(sourceNodeId);
+    if (!sourceNode) {
+      throw new Error(`Node not found: ${sourceNodeId}. Ensure the file has been ingested.`);
+    }
+    const probabilityFloor = options.probabilityFloor ?? DEFAULT_PROBABILITY_FLOOR;
+    const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const edgeTypeFilter = options.edgeTypes ? new Set(options.edgeTypes) : null;
+    const strategy = options.strategy ?? this.buildDefaultStrategy();
+    const visited = /* @__PURE__ */ new Map();
+    const queue = [];
+    const fanOutCount = /* @__PURE__ */ new Map();
+    this.seedQueue(
+      sourceNodeId,
+      sourceNode,
+      strategy,
+      edgeTypeFilter,
+      probabilityFloor,
+      queue,
+      fanOutCount
+    );
+    const truncated = this.runBfs(
+      queue,
+      visited,
+      fanOutCount,
+      sourceNodeId,
+      strategy,
+      edgeTypeFilter,
+      probabilityFloor,
+      maxDepth
+    );
+    return this.buildResult(sourceNodeId, sourceNode.name, visited, fanOutCount, truncated);
+  }
+  seedQueue(sourceNodeId, sourceNode, strategy, edgeTypeFilter, probabilityFloor, queue, fanOutCount) {
+    const sourceEdges = this.store.getEdges({ from: sourceNodeId });
+    for (const edge of sourceEdges) {
+      if (edge.to === sourceNodeId) continue;
+      if (edgeTypeFilter && !edgeTypeFilter.has(edge.type)) continue;
+      const targetNode = this.store.getNode(edge.to);
+      if (!targetNode) continue;
+      const cumProb = strategy.getEdgeProbability(edge, sourceNode, targetNode);
+      if (cumProb < probabilityFloor) continue;
+      queue.push({
+        nodeId: edge.to,
+        cumProb,
+        depth: 1,
+        parentId: sourceNodeId,
+        incomingEdge: edge.type
+      });
+    }
+    fanOutCount.set(
+      sourceNodeId,
+      sourceEdges.filter(
+        (e) => e.to !== sourceNodeId && (!edgeTypeFilter || edgeTypeFilter.has(e.type))
+      ).length
+    );
+  }
+  runBfs(queue, visited, fanOutCount, sourceNodeId, strategy, edgeTypeFilter, probabilityFloor, maxDepth) {
+    const MAX_QUEUE_SIZE = 1e4;
+    let head = 0;
+    while (head < queue.length) {
+      if (queue.length > MAX_QUEUE_SIZE) return true;
+      const entry = queue[head++];
+      const existing = visited.get(entry.nodeId);
+      if (existing && existing.cumulativeProbability >= entry.cumProb) continue;
+      const targetNode = this.store.getNode(entry.nodeId);
+      if (!targetNode) continue;
+      visited.set(entry.nodeId, {
+        nodeId: entry.nodeId,
+        name: targetNode.name,
+        ...targetNode.path !== void 0 && { path: targetNode.path },
+        type: targetNode.type,
+        cumulativeProbability: entry.cumProb,
+        depth: entry.depth,
+        incomingEdge: entry.incomingEdge,
+        parentId: entry.parentId
+      });
+      if (entry.depth < maxDepth) {
+        const childCount = this.expandNode(
+          entry,
+          targetNode,
+          sourceNodeId,
+          strategy,
+          edgeTypeFilter,
+          probabilityFloor,
+          queue
+        );
+        fanOutCount.set(entry.nodeId, (fanOutCount.get(entry.nodeId) ?? 0) + childCount);
+      }
+    }
+    return false;
+  }
+  expandNode(entry, fromNode, sourceNodeId, strategy, edgeTypeFilter, probabilityFloor, queue) {
+    const outEdges = this.store.getEdges({ from: entry.nodeId });
+    let childCount = 0;
+    for (const edge of outEdges) {
+      if (edgeTypeFilter && !edgeTypeFilter.has(edge.type)) continue;
+      if (edge.to === sourceNodeId) continue;
+      const childNode = this.store.getNode(edge.to);
+      if (!childNode) continue;
+      const newCumProb = entry.cumProb * strategy.getEdgeProbability(edge, fromNode, childNode);
+      if (newCumProb < probabilityFloor) continue;
+      childCount++;
+      queue.push({
+        nodeId: edge.to,
+        cumProb: newCumProb,
+        depth: entry.depth + 1,
+        parentId: entry.nodeId,
+        incomingEdge: edge.type
+      });
+    }
+    return childCount;
+  }
+  buildDefaultStrategy() {
+    return new CompositeProbabilityStrategy(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+  }
+  buildResult(sourceNodeId, sourceName, visited, fanOutCount, truncated = false) {
+    if (visited.size === 0) {
+      return {
+        sourceNodeId,
+        sourceName,
+        layers: [],
+        flatSummary: [],
+        summary: {
+          totalAffected: 0,
+          maxDepthReached: 0,
+          highRisk: 0,
+          mediumRisk: 0,
+          lowRisk: 0,
+          categoryBreakdown: { code: 0, tests: 0, docs: 0, other: 0 },
+          amplificationPoints: [],
+          truncated
+        }
+      };
+    }
+    const allNodes = Array.from(visited.values());
+    const flatSummary = [...allNodes].sort(
+      (a, b) => b.cumulativeProbability - a.cumulativeProbability
+    );
+    const depthMap = /* @__PURE__ */ new Map();
+    for (const node of allNodes) {
+      let list = depthMap.get(node.depth);
+      if (!list) {
+        list = [];
+        depthMap.set(node.depth, list);
+      }
+      list.push(node);
+    }
+    const layers = [];
+    const depths = Array.from(depthMap.keys()).sort((a, b) => a - b);
+    for (const depth of depths) {
+      const nodes = depthMap.get(depth);
+      const breakdown = { code: 0, tests: 0, docs: 0, other: 0 };
+      for (const n of nodes) {
+        const graphNode = this.store.getNode(n.nodeId);
+        if (graphNode) {
+          breakdown[classifyNodeCategory(graphNode)]++;
+        }
+      }
+      layers.push({ depth, nodes, categoryBreakdown: breakdown });
+    }
+    let highRisk = 0;
+    let mediumRisk = 0;
+    let lowRisk = 0;
+    const catBreakdown = { code: 0, tests: 0, docs: 0, other: 0 };
+    for (const node of allNodes) {
+      if (node.cumulativeProbability >= 0.5) highRisk++;
+      else if (node.cumulativeProbability >= 0.2) mediumRisk++;
+      else lowRisk++;
+      const graphNode = this.store.getNode(node.nodeId);
+      if (graphNode) {
+        catBreakdown[classifyNodeCategory(graphNode)]++;
+      }
+    }
+    const amplificationPoints = [];
+    for (const [nodeId, count] of fanOutCount) {
+      if (count > 3) {
+        amplificationPoints.push(nodeId);
+      }
+    }
+    const maxDepthReached = allNodes.reduce((max, n) => Math.max(max, n.depth), 0);
+    return {
+      sourceNodeId,
+      sourceName,
+      layers,
+      flatSummary,
+      summary: {
+        totalAffected: allNodes.length,
+        maxDepthReached,
+        highRisk,
+        mediumRisk,
+        lowRisk,
+        categoryBreakdown: catBreakdown,
+        amplificationPoints,
+        truncated
+      }
+    };
+  }
+};
+
 // 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();
+function lowConfidenceResult(intent, confidence) {
+  return {
+    intent,
+    intentConfidence: 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'
+    ]
+  };
+}
+function noEntityResult(intent, confidence) {
+  return {
+    intent,
+    intentConfidence: 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
+  };
+}
 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'
-      ]
-    };
+    return lowConfidenceResult(classification.intent, classification.confidence);
   }
-  const rawEntities = extractor.extract(question);
-  const entities = resolver.resolve(rawEntities);
+  const entities = resolver.resolve(extractor.extract(question));
   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
-    };
+    return noEntityResult(classification.intent, classification.confidence);
   }
   let data;
   try {
@@ -3574,62 +3946,59 @@ async function askGraph(store, question) {
       data: null
     };
   }
-  const summary = formatter.format(classification.intent, entities, data, question);
   return {
     intent: classification.intent,
     intentConfidence: classification.confidence,
     entities,
-    summary,
+    summary: formatter.format(classification.intent, entities, data, question),
     data
   };
 }
+function buildContextBlocks(cql, rootIds, searchResults) {
+  return rootIds.map((rootId) => {
+    const expanded = cql.execute({ rootNodeIds: [rootId], maxDepth: 2 });
+    const match = searchResults.find((r) => r.nodeId === rootId);
+    return {
+      rootNode: rootId,
+      score: match?.score ?? 1,
+      nodes: expanded.nodes,
+      edges: expanded.edges
+    };
+  });
+}
+function executeImpact(store, cql, entities, question) {
+  const rootId = entities[0].nodeId;
+  const lower = question.toLowerCase();
+  if (lower.includes("blast radius") || lower.includes("cascade")) {
+    return new CascadeSimulator(store).simulate(rootId);
+  }
+  const result = cql.execute({ rootNodeIds: [rootId], bidirectional: true, maxDepth: 3 });
+  return groupNodesByImpact(result.nodes, rootId);
+}
+function executeExplain(cql, entities, question, fusion) {
+  const searchResults = fusion.search(question, 10);
+  const rootIds = entities.length > 0 ? [entities[0].nodeId] : searchResults.slice(0, 3).map((r) => r.nodeId);
+  return { searchResults, context: buildContextBlocks(cql, rootIds, searchResults) };
+}
 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": {
+    case "impact":
+      return executeImpact(store, cql, entities, question);
+    case "find":
       return fusion.search(question, 10);
-    }
     case "relationships": {
-      const rootId = entities[0].nodeId;
       const result = cql.execute({
-        rootNodeIds: [rootId],
+        rootNodeIds: [entities[0].nodeId],
         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();
-    }
+    case "explain":
+      return executeExplain(cql, entities, question, fusion);
+    case "anomaly":
+      return new GraphAnomalyAdapter(store).detect();
     default:
       return null;
   }
@@ -3650,12 +4019,14 @@ var CODE_NODE_TYPES5 = /* @__PURE__ */ new Set([
   "method",
   "variable"
 ]);
+function countMetadataChars(node) {
+  return node.metadata ? JSON.stringify(node.metadata).length : 0;
+}
+function countBaseChars(node) {
+  return (node.name?.length ?? 0) + (node.path?.length ?? 0) + (node.type?.length ?? 0);
+}
 function estimateNodeTokens(node) {
-  let chars = (node.name?.length ?? 0) + (node.path?.length ?? 0) + (node.type?.length ?? 0);
-  if (node.metadata) {
-    chars += JSON.stringify(node.metadata).length;
-  }
-  return Math.ceil(chars / 4);
+  return Math.ceil((countBaseChars(node) + countMetadataChars(node)) / 4);
 }
 var Assembler = class {
   store;
@@ -3736,47 +4107,55 @@ var Assembler = class {
     }
     return { keptNodes, tokenEstimate, truncated };
   }
-  /**
-   * Compute a token budget allocation across node types.
-   */
-  computeBudget(totalTokens, phase) {
-    const allNodes = this.store.findNodes({});
+  countNodesByType() {
     const typeCounts = {};
-    for (const node of allNodes) {
+    for (const node of this.store.findNodes({})) {
       typeCounts[node.type] = (typeCounts[node.type] ?? 0) + 1;
     }
+    return typeCounts;
+  }
+  computeModuleDensity() {
     const density = {};
-    const moduleNodes = this.store.findNodes({ type: "module" });
-    for (const mod of moduleNodes) {
-      const outEdges = this.store.getEdges({ from: mod.id });
-      const inEdges = this.store.getEdges({ to: mod.id });
-      density[mod.name] = outEdges.length + inEdges.length;
+    for (const mod of this.store.findNodes({ type: "module" })) {
+      const out = this.store.getEdges({ from: mod.id }).length;
+      const inn = this.store.getEdges({ to: mod.id }).length;
+      density[mod.name] = out + inn;
     }
-    const boostTypes = phase ? PHASE_NODE_TYPES[phase] : void 0;
-    const boostFactor = 2;
-    let weightedTotal = 0;
+    return density;
+  }
+  computeTypeWeights(typeCounts, boostTypes) {
     const weights = {};
+    let weightedTotal = 0;
     for (const [type, count] of Object.entries(typeCounts)) {
-      const isBoosted = boostTypes?.includes(type);
-      const weight = count * (isBoosted ? boostFactor : 1);
+      const weight = count * (boostTypes?.includes(type) ? 2 : 1);
       weights[type] = weight;
       weightedTotal += weight;
     }
+    return { weights, weightedTotal };
+  }
+  allocateProportionally(weights, weightedTotal, totalTokens) {
     const allocations = {};
-    if (weightedTotal > 0) {
-      let allocated = 0;
-      const types = Object.keys(weights);
-      for (let i = 0; i < types.length; i++) {
-        const type = types[i];
-        if (i === types.length - 1) {
-          allocations[type] = totalTokens - allocated;
-        } else {
-          const share = Math.round(weights[type] / weightedTotal * totalTokens);
-          allocations[type] = share;
-          allocated += share;
-        }
+    if (weightedTotal === 0) return allocations;
+    let allocated = 0;
+    const types = Object.keys(weights);
+    for (let i = 0; i < types.length; i++) {
+      const type = types[i];
+      if (i === types.length - 1) {
+        allocations[type] = totalTokens - allocated;
+      } else {
+        const share = Math.round(weights[type] / weightedTotal * totalTokens);
+        allocations[type] = share;
+        allocated += share;
       }
     }
+    return allocations;
+  }
+  computeBudget(totalTokens, phase) {
+    const typeCounts = this.countNodesByType();
+    const density = this.computeModuleDensity();
+    const boostTypes = phase ? PHASE_NODE_TYPES[phase] : void 0;
+    const { weights, weightedTotal } = this.computeTypeWeights(typeCounts, boostTypes);
+    const allocations = this.allocateProportionally(weights, weightedTotal, totalTokens);
     return { total: totalTokens, allocations, density };
   }
   /**
@@ -3807,49 +4186,43 @@ var Assembler = class {
       filePaths: Array.from(filePathSet)
     };
   }
-  /**
-   * Generate a markdown repository map from graph structure.
-   */
-  generateMap() {
-    const moduleNodes = this.store.findNodes({ type: "module" });
-    const modulesWithEdgeCount = moduleNodes.map((mod) => {
-      const outEdges = this.store.getEdges({ from: mod.id });
-      const inEdges = this.store.getEdges({ to: mod.id });
-      return { module: mod, edgeCount: outEdges.length + inEdges.length };
+  buildModuleLines() {
+    const modulesWithEdgeCount = this.store.findNodes({ type: "module" }).map((mod) => {
+      const edgeCount = this.store.getEdges({ from: mod.id }).length + this.store.getEdges({ to: mod.id }).length;
+      return { module: mod, edgeCount };
     });
     modulesWithEdgeCount.sort((a, b) => b.edgeCount - a.edgeCount);
-    const lines = ["# Repository Structure", ""];
-    if (modulesWithEdgeCount.length > 0) {
-      lines.push("## Modules", "");
-      for (const { module: mod, edgeCount } of modulesWithEdgeCount) {
-        lines.push(`### ${mod.name} (${edgeCount} connections)`);
-        lines.push("");
-        const containsEdges = this.store.getEdges({ from: mod.id, type: "contains" });
-        for (const edge of containsEdges) {
-          const fileNode = this.store.getNode(edge.to);
-          if (fileNode && fileNode.type === "file") {
-            const symbolEdges = this.store.getEdges({ from: fileNode.id, type: "contains" });
-            lines.push(`- ${fileNode.path ?? fileNode.name} (${symbolEdges.length} symbols)`);
-          }
+    if (modulesWithEdgeCount.length === 0) return [];
+    const lines = ["## Modules", ""];
+    for (const { module: mod, edgeCount } of modulesWithEdgeCount) {
+      lines.push(`### ${mod.name} (${edgeCount} connections)`, "");
+      for (const edge of this.store.getEdges({ from: mod.id, type: "contains" })) {
+        const fileNode = this.store.getNode(edge.to);
+        if (fileNode?.type === "file") {
+          const symbols = this.store.getEdges({ from: fileNode.id, type: "contains" }).length;
+          lines.push(`- ${fileNode.path ?? fileNode.name} (${symbols} symbols)`);
         }
-        lines.push("");
       }
+      lines.push("");
     }
-    const fileNodes = this.store.findNodes({ type: "file" });
-    const nonBarrelFiles = fileNodes.filter((n) => !n.name.startsWith("index."));
-    const filesWithOutDegree = nonBarrelFiles.map((f) => {
-      const outEdges = this.store.getEdges({ from: f.id });
-      return { file: f, outDegree: outEdges.length };
-    });
+    return lines;
+  }
+  buildEntryPointLines() {
+    const filesWithOutDegree = this.store.findNodes({ type: "file" }).filter((n) => !n.name.startsWith("index.")).map((f) => ({ file: f, outDegree: this.store.getEdges({ from: f.id }).length }));
     filesWithOutDegree.sort((a, b) => b.outDegree - a.outDegree);
     const entryPoints = filesWithOutDegree.filter((f) => f.outDegree > 0).slice(0, 5);
-    if (entryPoints.length > 0) {
-      lines.push("## Entry Points", "");
-      for (const { file, outDegree } of entryPoints) {
-        lines.push(`- ${file.path ?? file.name} (${outDegree} outbound edges)`);
-      }
-      lines.push("");
+    if (entryPoints.length === 0) return [];
+    const lines = ["## Entry Points", ""];
+    for (const { file, outDegree } of entryPoints) {
+      lines.push(`- ${file.path ?? file.name} (${outDegree} outbound edges)`);
     }
+    lines.push("");
+    return lines;
+  }
+  generateMap() {
+    const lines = ["# Repository Structure", ""];
+    lines.push(...this.buildModuleLines());
+    lines.push(...this.buildEntryPointLines());
     return lines.join("\n");
   }
   /**
@@ -3882,6 +4255,59 @@ var Assembler = class {
 };
 
 // src/query/Traceability.ts
+function extractConfidence(edge) {
+  return edge.confidence ?? edge.metadata?.confidence ?? 0;
+}
+function extractMethod(edge) {
+  return edge.metadata?.method ?? "convention";
+}
+function edgesToTracedFiles(store, edges) {
+  return edges.map((edge) => ({
+    path: store.getNode(edge.to)?.path ?? edge.to,
+    confidence: extractConfidence(edge),
+    method: extractMethod(edge)
+  }));
+}
+function determineCoverageStatus(hasCode, hasTests) {
+  if (hasCode && hasTests) return "full";
+  if (hasCode) return "code-only";
+  if (hasTests) return "test-only";
+  return "none";
+}
+function computeMaxConfidence(codeFiles, testFiles) {
+  const allConfidences = [
+    ...codeFiles.map((f) => f.confidence),
+    ...testFiles.map((f) => f.confidence)
+  ];
+  return allConfidences.length > 0 ? Math.max(...allConfidences) : 0;
+}
+function buildRequirementCoverage(store, req) {
+  const codeFiles = edgesToTracedFiles(store, store.getEdges({ from: req.id, type: "requires" }));
+  const testFiles = edgesToTracedFiles(
+    store,
+    store.getEdges({ from: req.id, type: "verified_by" })
+  );
+  const hasCode = codeFiles.length > 0;
+  const hasTests = testFiles.length > 0;
+  return {
+    requirementId: req.id,
+    requirementName: req.name,
+    index: req.metadata?.index ?? 0,
+    codeFiles,
+    testFiles,
+    status: determineCoverageStatus(hasCode, hasTests),
+    maxConfidence: computeMaxConfidence(codeFiles, testFiles)
+  };
+}
+function computeSummary(requirements) {
+  const total = requirements.length;
+  const withCode = requirements.filter((r) => r.codeFiles.length > 0).length;
+  const withTests = requirements.filter((r) => r.testFiles.length > 0).length;
+  const fullyTraced = requirements.filter((r) => r.status === "full").length;
+  const untraceable = requirements.filter((r) => r.status === "none").length;
+  const coveragePercent = total > 0 ? Math.round(fullyTraced / total * 100) : 0;
+  return { total, withCode, withTests, fullyTraced, untraceable, coveragePercent };
+}
 function queryTraceability(store, options) {
   const allRequirements = store.findNodes({ type: "requirement" });
   const filtered = allRequirements.filter((node) => {
@@ -3909,56 +4335,13 @@ function queryTraceability(store, options) {
     const firstMeta = firstReq.metadata;
     const specPath = firstMeta?.specPath ?? "";
     const featureName = firstMeta?.featureName ?? "";
-    const requirements = [];
-    for (const req of reqs) {
-      const requiresEdges = store.getEdges({ from: req.id, type: "requires" });
-      const codeFiles = requiresEdges.map((edge) => {
-        const targetNode = store.getNode(edge.to);
-        return {
-          path: targetNode?.path ?? edge.to,
-          confidence: edge.confidence ?? edge.metadata?.confidence ?? 0,
-          method: edge.metadata?.method ?? "convention"
-        };
-      });
-      const verifiedByEdges = store.getEdges({ from: req.id, type: "verified_by" });
-      const testFiles = verifiedByEdges.map((edge) => {
-        const targetNode = store.getNode(edge.to);
-        return {
-          path: targetNode?.path ?? edge.to,
-          confidence: edge.confidence ?? edge.metadata?.confidence ?? 0,
-          method: edge.metadata?.method ?? "convention"
-        };
-      });
-      const hasCode = codeFiles.length > 0;
-      const hasTests = testFiles.length > 0;
-      const status = hasCode && hasTests ? "full" : hasCode ? "code-only" : hasTests ? "test-only" : "none";
-      const allConfidences = [
-        ...codeFiles.map((f) => f.confidence),
-        ...testFiles.map((f) => f.confidence)
-      ];
-      const maxConfidence = allConfidences.length > 0 ? Math.max(...allConfidences) : 0;
-      requirements.push({
-        requirementId: req.id,
-        requirementName: req.name,
-        index: req.metadata?.index ?? 0,
-        codeFiles,
-        testFiles,
-        status,
-        maxConfidence
-      });
-    }
+    const requirements = reqs.map((req) => buildRequirementCoverage(store, req));
     requirements.sort((a, b) => a.index - b.index);
-    const total = requirements.length;
-    const withCode = requirements.filter((r) => r.codeFiles.length > 0).length;
-    const withTests = requirements.filter((r) => r.testFiles.length > 0).length;
-    const fullyTraced = requirements.filter((r) => r.status === "full").length;
-    const untraceable = requirements.filter((r) => r.status === "none").length;
-    const coveragePercent = total > 0 ? Math.round(fullyTraced / total * 100) : 0;
     results.push({
       specPath,
       featureName,
       requirements,
-      summary: { total, withCode, withTests, fullyTraced, untraceable, coveragePercent }
+      summary: computeSummary(requirements)
     });
   }
   return results;
@@ -3973,10 +4356,15 @@ var GraphConstraintAdapter = class {
   }
   store;
   computeDependencyGraph() {
-    const fileNodes = this.store.findNodes({ type: "file" });
-    const nodes = fileNodes.map((n) => n.path ?? n.id);
-    const importsEdges = this.store.getEdges({ type: "imports" });
-    const edges = importsEdges.map((e) => {
+    const nodes = this.collectFileNodePaths();
+    const edges = this.collectImportEdges();
+    return { nodes, edges };
+  }
+  collectFileNodePaths() {
+    return this.store.findNodes({ type: "file" }).map((n) => n.path ?? n.id);
+  }
+  collectImportEdges() {
+    return this.store.getEdges({ type: "imports" }).map((e) => {
       const fromNode = this.store.getNode(e.from);
       const toNode = this.store.getNode(e.to);
       const fromPath = fromNode?.path ?? e.from;
@@ -3985,7 +4373,6 @@ var GraphConstraintAdapter = class {
       const line = e.metadata?.line ?? 0;
       return { from: fromPath, to: toPath, importType, line };
     });
-    return { nodes, edges };
   }
   computeLayerViolations(layers, rootDir) {
     const { edges } = this.computeDependencyGraph();
@@ -4279,65 +4666,53 @@ var GraphFeedbackAdapter = class {
     const affectedDocs = [];
     let impactScope = 0;
     for (const filePath of changedFiles) {
-      const fileNodes = this.store.findNodes({ path: filePath });
-      if (fileNodes.length === 0) continue;
-      const fileNode = fileNodes[0];
-      const inboundImports = this.store.getEdges({ to: fileNode.id, type: "imports" });
-      for (const edge of inboundImports) {
-        const importerNode = this.store.getNode(edge.from);
-        if (importerNode?.path && /test/i.test(importerNode.path)) {
-          affectedTests.push({
-            testFile: importerNode.path,
-            coversFile: filePath
-          });
-        }
-        impactScope++;
-      }
-      const docsEdges = this.store.getEdges({ to: fileNode.id, type: "documents" });
-      for (const edge of docsEdges) {
-        const docNode = this.store.getNode(edge.from);
-        if (docNode) {
-          affectedDocs.push({
-            docFile: docNode.path ?? docNode.name,
-            documentsFile: filePath
-          });
-        }
-      }
+      const fileNode = this.store.findNodes({ path: filePath })[0];
+      if (!fileNode) continue;
+      const counts = this.collectFileImpact(fileNode.id, filePath, affectedTests, affectedDocs);
+      impactScope += counts.impactScope;
     }
     return { affectedTests, affectedDocs, impactScope };
   }
-  computeHarnessCheckData() {
-    const nodeCount = this.store.nodeCount;
-    const edgeCount = this.store.edgeCount;
-    const violatesEdges = this.store.getEdges({ type: "violates" });
-    const constraintViolations = violatesEdges.length;
-    const fileNodes = this.store.findNodes({ type: "file" });
-    let undocumentedFiles = 0;
-    for (const node of fileNodes) {
-      const docsEdges = this.store.getEdges({ to: node.id, type: "documents" });
-      if (docsEdges.length === 0) {
-        undocumentedFiles++;
+  collectFileImpact(fileNodeId, filePath, affectedTests, affectedDocs) {
+    const inboundImports = this.store.getEdges({ to: fileNodeId, type: "imports" });
+    for (const edge of inboundImports) {
+      const importerNode = this.store.getNode(edge.from);
+      if (importerNode?.path && /test/i.test(importerNode.path)) {
+        affectedTests.push({ testFile: importerNode.path, coversFile: filePath });
       }
     }
-    let unreachableNodes = 0;
-    for (const node of fileNodes) {
-      const inboundImports = this.store.getEdges({ to: node.id, type: "imports" });
-      if (inboundImports.length === 0) {
-        const isEntryPoint = node.name === "index.ts" || node.path !== void 0 && node.path.endsWith("/index.ts") || node.metadata?.entryPoint === true;
-        if (!isEntryPoint) {
-          unreachableNodes++;
-        }
+    const docsEdges = this.store.getEdges({ to: fileNodeId, type: "documents" });
+    for (const edge of docsEdges) {
+      const docNode = this.store.getNode(edge.from);
+      if (docNode) {
+        affectedDocs.push({ docFile: docNode.path ?? docNode.name, documentsFile: filePath });
       }
     }
+    return { impactScope: inboundImports.length };
+  }
+  computeHarnessCheckData() {
+    const fileNodes = this.store.findNodes({ type: "file" });
     return {
       graphExists: true,
-      nodeCount,
-      edgeCount,
-      constraintViolations,
-      undocumentedFiles,
-      unreachableNodes
+      nodeCount: this.store.nodeCount,
+      edgeCount: this.store.edgeCount,
+      constraintViolations: this.store.getEdges({ type: "violates" }).length,
+      undocumentedFiles: this.countUndocumentedFiles(fileNodes),
+      unreachableNodes: this.countUnreachableNodes(fileNodes)
     };
   }
+  countUndocumentedFiles(fileNodes) {
+    return fileNodes.filter(
+      (node) => this.store.getEdges({ to: node.id, type: "documents" }).length === 0
+    ).length;
+  }
+  countUnreachableNodes(fileNodes) {
+    return fileNodes.filter((node) => {
+      if (this.store.getEdges({ to: node.id, type: "imports" }).length > 0) return false;
+      const isEntryPoint = node.name === "index.ts" || node.path !== void 0 && node.path.endsWith("/index.ts") || node.metadata?.entryPoint === true;
+      return !isEntryPoint;
+    }).length;
+  }
 };
 
 // src/independence/TaskIndependenceAnalyzer.ts
@@ -4354,47 +4729,46 @@ var TaskIndependenceAnalyzer = class {
     this.validate(tasks);
     const useGraph = this.store != null && depth > 0;
     const analysisLevel = useGraph ? "graph-expanded" : "file-only";
+    const { originalFiles, expandedFiles } = this.buildFileSets(tasks, useGraph, depth, edgeTypes);
+    const taskIds = tasks.map((t) => t.id);
+    const pairs = this.computeAllPairs(taskIds, originalFiles, expandedFiles);
+    const groups = this.buildGroups(taskIds, pairs);
+    const verdict = this.generateVerdict(taskIds, groups, analysisLevel);
+    return { tasks: taskIds, analysisLevel, depth, pairs, groups, verdict };
+  }
+  // --- Private methods ---
+  buildFileSets(tasks, useGraph, depth, edgeTypes) {
     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());
-      }
+      originalFiles.set(task.id, new Set(task.files));
+      expandedFiles.set(
+        task.id,
+        useGraph ? this.expandViaGraph(task.files, depth, edgeTypes) : /* @__PURE__ */ new Map()
+      );
     }
-    const taskIds = tasks.map((t) => t.id);
+    return { originalFiles, expandedFiles };
+  }
+  computeAllPairs(taskIds, originalFiles, expandedFiles) {
     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(
+          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
-    };
+    return pairs;
   }
-  // --- Private methods ---
   validate(tasks) {
     if (tasks.length < 2) {
       throw new Error("At least 2 tasks are required for independence analysis");
@@ -4547,27 +4921,62 @@ var ConflictPredictor = class {
   predict(params) {
     const analyzer = new TaskIndependenceAnalyzer(this.store);
     const result = analyzer.analyze(params);
+    const { churnMap, couplingMap, churnThreshold, couplingThreshold } = this.buildMetricMaps();
+    const conflicts = this.classifyConflicts(
+      result.pairs,
+      churnMap,
+      couplingMap,
+      churnThreshold,
+      couplingThreshold
+    );
+    const taskIds = result.tasks;
+    const groups = this.buildHighSeverityGroups(taskIds, conflicts);
+    const regrouped = !this.groupsEqual(result.groups, groups);
+    const { highCount, mediumCount, lowCount } = this.countBySeverity(conflicts);
+    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 ---
+  buildMetricMaps() {
     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);
-        }
+    if (this.store == null) {
+      return { churnMap, couplingMap, churnThreshold: Infinity, couplingThreshold: Infinity };
+    }
+    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 couplingResult = new GraphCouplingAdapter(this.store).computeCouplingData();
+    for (const fileData of couplingResult.files) {
+      couplingMap.set(fileData.file, fileData.fanIn + fileData.fanOut);
+    }
+    const churnThreshold = this.computePercentile(Array.from(churnMap.values()), 80);
+    const couplingThreshold = this.computePercentile(Array.from(couplingMap.values()), 80);
+    return { churnMap, couplingMap, churnThreshold, couplingThreshold };
+  }
+  classifyConflicts(pairs, churnMap, couplingMap, churnThreshold, couplingThreshold) {
     const conflicts = [];
-    for (const pair of result.pairs) {
+    for (const pair of pairs) {
       if (pair.independent) continue;
       const { severity, reason, mitigation } = this.classifyPair(
         pair.taskA,
@@ -4587,9 +4996,9 @@ var ConflictPredictor = class {
         overlaps: pair.overlaps
       });
     }
-    const taskIds = result.tasks;
-    const groups = this.buildHighSeverityGroups(taskIds, conflicts);
-    const regrouped = !this.groupsEqual(result.groups, groups);
+    return conflicts;
+  }
+  countBySeverity(conflicts) {
     let highCount = 0;
     let mediumCount = 0;
     let lowCount = 0;
@@ -4598,68 +5007,57 @@ var ConflictPredictor = class {
       else if (c.severity === "medium") mediumCount++;
       else lowCount++;
     }
-    const verdict = this.generateVerdict(
-      taskIds,
-      groups,
-      result.analysisLevel,
-      highCount,
-      mediumCount,
-      lowCount,
-      regrouped
-    );
+    return { highCount, mediumCount, lowCount };
+  }
+  classifyTransitiveOverlap(taskA, taskB, overlap, churnMap, couplingMap, churnThreshold, couplingThreshold) {
+    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) {
+      return {
+        severity: "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}`
+      };
+    }
+    if (coupling !== void 0 && coupling >= couplingThreshold && couplingThreshold !== Infinity) {
+      return {
+        severity: "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}`
+      };
+    }
     return {
-      tasks: taskIds,
-      analysisLevel: result.analysisLevel,
-      depth: result.depth,
-      conflicts,
-      groups,
-      summary: {
-        high: highCount,
-        medium: mediumCount,
-        low: lowCount,
-        regrouped
-      },
-      verdict
+      severity: "low",
+      reason: `Transitive overlap on ${overlap.file} (via ${via}) \u2014 low risk`,
+      mitigation: `Info: transitive overlap unlikely to cause conflicts`
     };
   }
-  // --- 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;
+      const classified = overlap.type === "direct" ? {
+        severity: "high",
+        reason: `Both tasks write to ${overlap.file}`,
+        mitigation: `Serialize: run ${taskA} before ${taskB}`
+      } : this.classifyTransitiveOverlap(
+        taskA,
+        taskB,
+        overlap,
+        churnMap,
+        couplingMap,
+        churnThreshold,
+        couplingThreshold
+      );
+      if (this.severityRank(classified.severity) > this.severityRank(maxSeverity)) {
+        maxSeverity = classified.severity;
+        primaryReason = classified.reason;
+        primaryMitigation = classified.mitigation;
       } else if (primaryReason === "") {
-        primaryReason = reason;
-        primaryMitigation = mitigation;
+        primaryReason = classified.reason;
+        primaryMitigation = classified.mitigation;
       }
     }
     return { severity: maxSeverity, reason: primaryReason, mitigation: primaryMitigation };
@@ -4782,13 +5180,15 @@ var ConflictPredictor = class {
 };
 
 // src/index.ts
-var VERSION = "0.2.0";
+var VERSION = "0.4.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Assembler,
   CIConnector,
   CURRENT_SCHEMA_VERSION,
+  CascadeSimulator,
   CodeIngestor,
+  CompositeProbabilityStrategy,
   ConflictPredictor,
   ConfluenceConnector,
   ContextQL,
@@ -4823,6 +5223,7 @@ var VERSION = "0.2.0";
   VERSION,
   VectorStore,
   askGraph,
+  classifyNodeCategory,
   groupNodesByImpact,
   linkToCode,
   loadGraph,