@harness-engineering/graph 0.4.1 → 0.4.3

package/dist/index.mjs

@@ -37,7 +37,9 @@ var NODE_TYPES = [
   "aesthetic_intent",
   "design_constraint",
   // Traceability
-  "requirement"
+  "requirement",
+  // Cache
+  "packed_summary"
 ];
 var EDGE_TYPES = [
   // Code relationships
@@ -70,10 +72,21 @@ var EDGE_TYPES = [
   // Traceability relationships
   "requires",
   "verified_by",
-  "tested_by"
+  "tested_by",
+  // Cache relationships
+  "caches"
 ];
 var OBSERVABILITY_TYPES = /* @__PURE__ */ new Set(["span", "metric", "log"]);
 var CURRENT_SCHEMA_VERSION = 1;
+var NODE_STABILITY = {
+  File: "session",
+  Function: "session",
+  Class: "session",
+  Constraint: "session",
+  PackedSummary: "session",
+  SkillDefinition: "static",
+  ToolDefinition: "static"
+};
 var GraphNodeSchema = z.object({
   id: z.string(),
   type: z.enum(NODE_TYPES),
@@ -260,21 +273,26 @@ var GraphStore = class {
     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);
     }
@@ -404,6 +422,94 @@ var VectorStore = class _VectorStore {
   }
 };
 
+// src/store/PackedSummaryCache.ts
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function normalizeIntent(intent) {
+  return intent.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function cacheNodeId(normalizedIntent) {
+  return `packed_summary:${normalizedIntent}`;
+}
+var PackedSummaryCache = class {
+  constructor(store, ttlMs = DEFAULT_TTL_MS) {
+    this.store = store;
+    this.ttlMs = ttlMs;
+  }
+  store;
+  ttlMs;
+  /** Returns cached envelope with `cached: true` if valid, or null if miss/stale. */
+  get(intent) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    const node = this.store.getNode(nodeId);
+    if (!node) return null;
+    const createdMs = this.parseCreatedMs(node.metadata["createdAt"]);
+    if (createdMs === null) return null;
+    if (Date.now() - createdMs > this.ttlMs) return null;
+    if (!this.areSourcesFresh(nodeId, node, createdMs)) return null;
+    return this.parseEnvelope(node.metadata["envelope"]);
+  }
+  /** Parse and validate createdAt. Returns epoch ms or null if missing/malformed (GC-002). */
+  parseCreatedMs(createdAt) {
+    if (!createdAt) return null;
+    const ms = new Date(createdAt).getTime();
+    return Number.isNaN(ms) ? null : ms;
+  }
+  /** GC-001: Checks source nodes exist and are unmodified since cache creation. */
+  areSourcesFresh(nodeId, node, createdMs) {
+    const sourceNodeIds = node.metadata["sourceNodeIds"];
+    const edges = this.store.getEdges({ from: nodeId, type: "caches" });
+    if (sourceNodeIds && edges.length < sourceNodeIds.length) return false;
+    for (const edge of edges) {
+      const sourceNode = this.store.getNode(edge.to);
+      if (!sourceNode) return false;
+      if (sourceNode.lastModified) {
+        const sourceModMs = new Date(sourceNode.lastModified).getTime();
+        if (sourceModMs > createdMs) return false;
+      }
+    }
+    return true;
+  }
+  /** Parse envelope JSON and set cached: true. Returns null on invalid JSON. */
+  parseEnvelope(raw) {
+    try {
+      const envelope = JSON.parse(raw);
+      return { ...envelope, meta: { ...envelope.meta, cached: true } };
+    } catch {
+      return null;
+    }
+  }
+  /** Write a PackedSummary node with caches edges to source nodes. */
+  set(intent, envelope, sourceNodeIds) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    this.store.removeNode(nodeId);
+    this.store.addNode({
+      id: nodeId,
+      type: "packed_summary",
+      name: normalized,
+      metadata: {
+        envelope: JSON.stringify(envelope),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sourceNodeIds
+      }
+    });
+    for (const sourceId of sourceNodeIds) {
+      this.store.addEdge({
+        from: nodeId,
+        to: sourceId,
+        type: "caches"
+      });
+    }
+  }
+  /** Explicitly invalidate a cached packed summary. */
+  invalidate(intent) {
+    const normalized = normalizeIntent(intent);
+    const nodeId = cacheNodeId(normalized);
+    this.store.removeNode(nodeId);
+  }
+};
+
 // src/query/ContextQL.ts
 function edgeKey2(e) {
   return `${e.from}|${e.to}|${e.type}`;
@@ -1021,6 +1127,17 @@ var CodeIngestor = class {
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(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;
@@ -1057,39 +1174,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,
@@ -1099,14 +1226,7 @@ var GitIngestor = class {
         edgesAdded++;
       }
     }
-    return {
-      nodesAdded,
-      nodesUpdated,
-      edgesAdded,
-      edgesUpdated,
-      errors,
-      durationMs: Date.now() - start
-    };
+    return edgesAdded;
   }
   async runGit(rootDir, args) {
     if (this.gitRunner) {
@@ -1121,63 +1241,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();
@@ -1321,50 +1427,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];
@@ -1373,70 +1454,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();
@@ -1490,6 +1530,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
 import * as fs3 from "fs/promises";
@@ -1534,40 +1642,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").replaceAll("\\", "/");
-      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,
@@ -1578,6 +1655,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.
    */
@@ -1589,54 +1708,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.
@@ -1840,15 +1985,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;
 }
@@ -1861,8 +2009,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) {
@@ -1884,38 +2030,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}`;
@@ -2036,6 +2183,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";
@@ -2046,40 +2203,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;
@@ -2124,6 +2275,61 @@ var ConfluenceConnector = class {
 };
 
 // src/ingest/connectors/CIConnector.ts
+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";
@@ -2134,22 +2340,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, {
@@ -2157,71 +2370,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++;
-        }
-      }
-    } 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
-    };
+        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, edgesAdded };
   }
 };
 
@@ -2291,16 +2453,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);
@@ -2311,15 +2486,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));
@@ -2374,37 +2545,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.
@@ -2661,36 +2845,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,
@@ -2706,6 +2866,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") {
@@ -3261,37 +3453,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;
   }
 };
 
@@ -3708,36 +3917,41 @@ var ENTITY_REQUIRED_INTENTS = /* @__PURE__ */ new Set(["impact", "relationships"
 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 {
@@ -3751,67 +3965,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 lowerQuestion = question.toLowerCase();
-      if (lowerQuestion.includes("blast radius") || lowerQuestion.includes("cascade")) {
-        const simulator = new CascadeSimulator(store);
-        return simulator.simulate(rootId);
-      }
-      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;
   }
@@ -3832,12 +4038,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;
@@ -3918,47 +4126,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 };
   }
   /**
@@ -3989,49 +4205,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");
   }
   /**
@@ -4165,10 +4375,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;
@@ -4177,7 +4392,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();
@@ -4471,65 +4685,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
@@ -4546,47 +4748,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");
@@ -4739,27 +4940,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);
-        }
-      }
-      const couplingResult = new GraphCouplingAdapter(this.store).computeCouplingData();
-      for (const fileData of couplingResult.files) {
-        couplingMap.set(fileData.file, fileData.fanIn + fileData.fanOut);
+    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);
       }
-      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,
@@ -4779,9 +5015,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;
@@ -4790,68 +5026,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 };
@@ -4974,7 +5199,7 @@ var ConflictPredictor = class {
 };
 
 // src/index.ts
-var VERSION = "0.4.0";
+var VERSION = "0.4.3";
 export {
   Assembler,
   CIConnector,
@@ -5005,8 +5230,10 @@ export {
   IntentClassifier,
   JiraConnector,
   KnowledgeIngestor,
+  NODE_STABILITY,
   NODE_TYPES,
   OBSERVABILITY_TYPES,
+  PackedSummaryCache,
   RequirementIngestor,
   ResponseFormatter,
   SlackConnector,
@@ -5020,6 +5247,7 @@ export {
   groupNodesByImpact,
   linkToCode,
   loadGraph,
+  normalizeIntent,
   project,
   queryTraceability,
   saveGraph