@harness-engineering/cli 1.23.2 → 1.24.1

package/dist/chunk-CLD4KL7O.js

@@ -1,4945 +0,0 @@
-// ../graph/dist/index.mjs
-import { z } from "zod";
-import { readFile, writeFile, mkdir, access } from "fs/promises";
-import { join } from "path";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import * as path2 from "path";
-import * as fs2 from "fs/promises";
-import * as path3 from "path";
-import * as crypto from "crypto";
-import * as fs3 from "fs/promises";
-import * as path4 from "path";
-import * as fs4 from "fs/promises";
-import * as path5 from "path";
-import { minimatch } from "minimatch";
-import { relative as relative2 } from "path";
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
-var NODE_TYPES = [
-  // Code
-  "repository",
-  "module",
-  "file",
-  "class",
-  "interface",
-  "function",
-  "method",
-  "variable",
-  // Knowledge
-  "adr",
-  "decision",
-  "learning",
-  "failure",
-  "issue",
-  "document",
-  "skill",
-  "conversation",
-  // VCS
-  "commit",
-  "build",
-  "test_result",
-  // Observability (future)
-  "span",
-  "metric",
-  "log",
-  // Structural
-  "layer",
-  "pattern",
-  "constraint",
-  "violation",
-  // Design
-  "design_token",
-  "aesthetic_intent",
-  "design_constraint",
-  // Traceability
-  "requirement"
-];
-var EDGE_TYPES = [
-  // Code relationships
-  "contains",
-  "imports",
-  "calls",
-  "implements",
-  "inherits",
-  "references",
-  // Knowledge relationships
-  "applies_to",
-  "caused_by",
-  "resolved_by",
-  "documents",
-  "violates",
-  "specifies",
-  "decided",
-  // VCS relationships
-  "co_changes_with",
-  "triggered_by",
-  "failed_in",
-  // Execution relationships (future)
-  "executed_by",
-  "measured_by",
-  // Design relationships
-  "uses_token",
-  "declares_intent",
-  "violates_design",
-  "platform_binding",
-  // Traceability relationships
-  "requires",
-  "verified_by",
-  "tested_by"
-];
-var OBSERVABILITY_TYPES = /* @__PURE__ */ new Set(["span", "metric", "log"]);
-var CURRENT_SCHEMA_VERSION = 1;
-var GraphNodeSchema = z.object({
-  id: z.string(),
-  type: z.enum(NODE_TYPES),
-  name: z.string(),
-  path: z.string().optional(),
-  location: z.object({
-    fileId: z.string(),
-    startLine: z.number(),
-    endLine: z.number(),
-    startColumn: z.number().optional(),
-    endColumn: z.number().optional()
-  }).optional(),
-  content: z.string().optional(),
-  hash: z.string().optional(),
-  metadata: z.record(z.unknown()),
-  embedding: z.array(z.number()).optional(),
-  lastModified: z.string().optional()
-});
-var GraphEdgeSchema = z.object({
-  from: z.string(),
-  to: z.string(),
-  type: z.enum(EDGE_TYPES),
-  confidence: z.number().min(0).max(1).optional(),
-  metadata: z.record(z.unknown()).optional()
-});
-async function saveGraph(dirPath, nodes, edges) {
-  await mkdir(dirPath, { recursive: true });
-  const graphData = { nodes, edges };
-  const metadata = {
-    schemaVersion: CURRENT_SCHEMA_VERSION,
-    lastScanTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nodeCount: nodes.length,
-    edgeCount: edges.length
-  };
-  await Promise.all([
-    writeFile(join(dirPath, "graph.json"), JSON.stringify(graphData, null, 2), "utf-8"),
-    writeFile(join(dirPath, "metadata.json"), JSON.stringify(metadata, null, 2), "utf-8")
-  ]);
-}
-async function loadGraph(dirPath) {
-  const metaPath = join(dirPath, "metadata.json");
-  const graphPath = join(dirPath, "graph.json");
-  try {
-    await access(metaPath);
-    await access(graphPath);
-  } catch {
-    return null;
-  }
-  const metaContent = await readFile(metaPath, "utf-8");
-  const metadata = JSON.parse(metaContent);
-  if (metadata.schemaVersion !== CURRENT_SCHEMA_VERSION) {
-    return null;
-  }
-  const graphContent = await readFile(graphPath, "utf-8");
-  return JSON.parse(graphContent);
-}
-var POISONED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function safeMerge(target, source) {
-  for (const key of Object.keys(source)) {
-    if (!POISONED_KEYS.has(key)) {
-      target[key] = source[key];
-    }
-  }
-}
-function edgeKey(from, to, type) {
-  return `${from}\0${to}\0${type}`;
-}
-function addToIndex(index, key, edge) {
-  const list = index.get(key);
-  if (list) {
-    list.push(edge);
-  } else {
-    index.set(key, [edge]);
-  }
-}
-function removeFromIndex(index, key, edge) {
-  const list = index.get(key);
-  if (!list) return;
-  const idx = list.indexOf(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();
-  // keyed by from\0to\0type
-  edgesByFrom = /* @__PURE__ */ new Map();
-  edgesByTo = /* @__PURE__ */ new Map();
-  edgesByType = /* @__PURE__ */ new Map();
-  // --- Node operations ---
-  addNode(node) {
-    const existing = this.nodeMap.get(node.id);
-    if (existing) {
-      safeMerge(existing, node);
-    } else {
-      this.nodeMap.set(node.id, { ...node });
-    }
-  }
-  batchAddNodes(nodes) {
-    for (const node of nodes) {
-      this.addNode(node);
-    }
-  }
-  getNode(id) {
-    const node = this.nodeMap.get(id);
-    if (!node) return null;
-    return { ...node };
-  }
-  findNodes(query) {
-    const results = [];
-    for (const node of this.nodeMap.values()) {
-      if (query.type !== void 0 && node.type !== query.type) continue;
-      if (query.name !== void 0 && node.name !== query.name) continue;
-      if (query.path !== void 0 && node.path !== query.path) continue;
-      results.push({ ...node });
-    }
-    return results;
-  }
-  removeNode(id) {
-    this.nodeMap.delete(id);
-    const fromEdges = this.edgesByFrom.get(id) ?? [];
-    const toEdges = this.edgesByTo.get(id) ?? [];
-    const edgesToRemove = /* @__PURE__ */ new Set([...fromEdges, ...toEdges]);
-    for (const edge of edgesToRemove) {
-      this.removeEdgeInternal(edge);
-    }
-  }
-  // --- Edge operations ---
-  addEdge(edge) {
-    const key = edgeKey(edge.from, edge.to, edge.type);
-    const existing = this.edgeMap.get(key);
-    if (existing) {
-      if (edge.metadata) {
-        safeMerge(existing, edge);
-      }
-      return;
-    }
-    const copy = { ...edge };
-    this.edgeMap.set(key, copy);
-    addToIndex(this.edgesByFrom, edge.from, copy);
-    addToIndex(this.edgesByTo, edge.to, copy);
-    addToIndex(this.edgesByType, edge.type, copy);
-  }
-  batchAddEdges(edges) {
-    for (const edge of edges) {
-      this.addEdge(edge);
-    }
-  }
-  getEdges(query) {
-    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 }] : [];
-    }
-    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) ?? [];
-    }
-    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();
-    if (direction === "outbound" || direction === "both") {
-      const outEdges = this.edgesByFrom.get(nodeId) ?? [];
-      for (const edge of outEdges) {
-        neighborIds.add(edge.to);
-      }
-    }
-    if (direction === "inbound" || direction === "both") {
-      const inEdges = this.edgesByTo.get(nodeId) ?? [];
-      for (const edge of inEdges) {
-        neighborIds.add(edge.from);
-      }
-    }
-    const results = [];
-    for (const nid of neighborIds) {
-      const node = this.getNode(nid);
-      if (node) results.push(node);
-    }
-    return results;
-  }
-  // --- Counts ---
-  get nodeCount() {
-    return this.nodeMap.size;
-  }
-  get edgeCount() {
-    return this.edgeMap.size;
-  }
-  // --- Clear ---
-  clear() {
-    this.nodeMap.clear();
-    this.edgeMap.clear();
-    this.edgesByFrom.clear();
-    this.edgesByTo.clear();
-    this.edgesByType.clear();
-  }
-  // --- Persistence ---
-  async save(dirPath) {
-    const allNodes = Array.from(this.nodeMap.values()).map((n) => ({ ...n }));
-    const allEdges = Array.from(this.edgeMap.values()).map((e) => ({ ...e }));
-    await saveGraph(dirPath, allNodes, allEdges);
-  }
-  async load(dirPath) {
-    const data = await loadGraph(dirPath);
-    if (!data) return false;
-    this.clear();
-    for (const node of data.nodes) {
-      this.nodeMap.set(node.id, { ...node });
-    }
-    for (const edge of data.edges) {
-      const copy = { ...edge };
-      const key = edgeKey(edge.from, edge.to, edge.type);
-      this.edgeMap.set(key, copy);
-      addToIndex(this.edgesByFrom, edge.from, copy);
-      addToIndex(this.edgesByTo, edge.to, copy);
-      addToIndex(this.edgesByType, edge.type, copy);
-    }
-    return true;
-  }
-  // --- Internal ---
-  removeEdgeInternal(edge) {
-    const key = edgeKey(edge.from, edge.to, edge.type);
-    this.edgeMap.delete(key);
-    removeFromIndex(this.edgesByFrom, edge.from, edge);
-    removeFromIndex(this.edgesByTo, edge.to, edge);
-    removeFromIndex(this.edgesByType, edge.type, edge);
-  }
-};
-function cosineSimilarity(a, b) {
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  return denominator === 0 ? 0 : dotProduct / denominator;
-}
-var VectorStore = class _VectorStore {
-  dimensions;
-  vectors = /* @__PURE__ */ new Map();
-  constructor(dimensions) {
-    this.dimensions = dimensions;
-  }
-  /** Number of vectors currently stored. */
-  get size() {
-    return this.vectors.size;
-  }
-  /** Add a vector with the given id. Throws if dimensions do not match. */
-  add(id, vector) {
-    if (vector.length !== this.dimensions) {
-      throw new Error(`Dimension mismatch: expected ${this.dimensions}, got ${vector.length}`);
-    }
-    this.vectors.set(id, vector);
-  }
-  /** Remove a vector by id. Returns true if the vector existed. */
-  remove(id) {
-    return this.vectors.delete(id);
-  }
-  /** Check whether a vector with the given id exists. */
-  has(id) {
-    return this.vectors.has(id);
-  }
-  /** Remove all stored vectors. */
-  clear() {
-    this.vectors.clear();
-  }
-  /**
-   * Return the top-K most similar vectors to the query, sorted by descending
-   * cosine similarity score.  If the store contains fewer than topK vectors,
-   * all available results are returned.
-   */
-  search(query, topK) {
-    if (query.length !== this.dimensions) {
-      throw new Error(`Dimension mismatch: expected ${this.dimensions}, got ${query.length}`);
-    }
-    const results = [];
-    for (const [id, vector] of this.vectors) {
-      results.push({ id, score: cosineSimilarity(query, vector) });
-    }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
-  }
-  /** Serialize the store to a plain object for persistence. */
-  serialize() {
-    const vectors = [];
-    for (const [id, vector] of this.vectors) {
-      vectors.push({ id, vector: [...vector] });
-    }
-    return { dimensions: this.dimensions, vectors };
-  }
-  /** Deserialize a previously-serialized store. */
-  static deserialize(data) {
-    const store = new _VectorStore(data.dimensions);
-    for (const { id, vector } of data.vectors) {
-      store.add(id, vector);
-    }
-    return store;
-  }
-};
-function edgeKey2(e) {
-  return `${e.from}|${e.to}|${e.type}`;
-}
-function addEdge(state, edge) {
-  const key = edgeKey2(edge);
-  if (!state.edgeSet.has(key)) {
-    state.edgeSet.add(key);
-    state.resultEdges.push(edge);
-  }
-}
-function shouldPruneNode(neighbor, pruneObservability, params) {
-  if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) return true;
-  if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) return true;
-  if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) return true;
-  return false;
-}
-function isEdgeExcluded(edge, params) {
-  return !!(params.includeEdges && !params.includeEdges.includes(edge.type));
-}
-function processNeighbor(store, edge, neighborId, nextDepth, queue, state, pruneObservability, params) {
-  if (isEdgeExcluded(edge, params)) return;
-  if (state.visited.has(neighborId)) {
-    addEdge(state, edge);
-    return;
-  }
-  const neighbor = store.getNode(neighborId);
-  if (!neighbor) return;
-  state.visited.add(neighborId);
-  if (shouldPruneNode(neighbor, pruneObservability, params)) {
-    state.pruned++;
-    return;
-  }
-  state.resultNodeMap.set(neighborId, neighbor);
-  addEdge(state, edge);
-  queue.push({ id: neighborId, depth: nextDepth });
-}
-function addCrossEdges(store, state) {
-  const resultNodeIds = new Set(state.resultNodeMap.keys());
-  for (const nodeId of resultNodeIds) {
-    const outEdges = store.getEdges({ from: nodeId });
-    for (const edge of outEdges) {
-      if (resultNodeIds.has(edge.to)) {
-        addEdge(state, edge);
-      }
-    }
-  }
-}
-var ContextQL = class {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  execute(params) {
-    const maxDepth = params.maxDepth ?? 3;
-    const bidirectional = params.bidirectional ?? false;
-    const pruneObservability = params.pruneObservability ?? true;
-    const state = {
-      visited: /* @__PURE__ */ new Set(),
-      resultNodeMap: /* @__PURE__ */ new Map(),
-      resultEdges: [],
-      edgeSet: /* @__PURE__ */ new Set(),
-      pruned: 0,
-      depthReached: 0
-    };
-    const queue = [];
-    this.seedRootNodes(params.rootNodeIds, state, queue);
-    this.runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state);
-    addCrossEdges(this.store, state);
-    return {
-      nodes: Array.from(state.resultNodeMap.values()),
-      edges: state.resultEdges,
-      stats: {
-        totalTraversed: state.visited.size,
-        totalReturned: state.resultNodeMap.size,
-        pruned: state.pruned,
-        depthReached: state.depthReached
-      }
-    };
-  }
-  seedRootNodes(rootNodeIds, state, queue) {
-    for (const rootId of rootNodeIds) {
-      const node = this.store.getNode(rootId);
-      if (node) {
-        state.visited.add(rootId);
-        state.resultNodeMap.set(rootId, node);
-        queue.push({ id: rootId, depth: 0 });
-      }
-    }
-  }
-  runBFS(queue, maxDepth, bidirectional, pruneObservability, params, state) {
-    let head = 0;
-    while (head < queue.length) {
-      const entry = queue[head++];
-      const { id: currentId, depth } = entry;
-      if (depth >= maxDepth) continue;
-      const nextDepth = depth + 1;
-      if (nextDepth > state.depthReached) state.depthReached = nextDepth;
-      const allEdges = this.gatherEdges(currentId, bidirectional);
-      for (const { edge, neighborId } of allEdges) {
-        processNeighbor(
-          this.store,
-          edge,
-          neighborId,
-          nextDepth,
-          queue,
-          state,
-          pruneObservability,
-          params
-        );
-      }
-    }
-  }
-  gatherEdges(nodeId, bidirectional) {
-    const outEdges = this.store.getEdges({ from: nodeId });
-    const inEdges = bidirectional ? this.store.getEdges({ to: nodeId }) : [];
-    return [
-      ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
-      ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
-    ];
-  }
-};
-function project(nodes, spec) {
-  if (!spec) return nodes.map((n) => ({ ...n }));
-  return nodes.map((node) => {
-    const projected = {};
-    for (const field of spec.fields) {
-      if (field in node) {
-        projected[field] = node[field];
-      }
-    }
-    return projected;
-  });
-}
-var TEST_TYPES = /* @__PURE__ */ new Set(["test_result"]);
-var DOC_TYPES = /* @__PURE__ */ new Set(["adr", "decision", "document", "learning"]);
-var CODE_TYPES = /* @__PURE__ */ new Set([
-  "file",
-  "module",
-  "class",
-  "interface",
-  "function",
-  "method",
-  "variable"
-]);
-function 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 = [];
-  const code = [];
-  const other = [];
-  for (const node of nodes) {
-    if (excludeId && node.id === excludeId) continue;
-    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 };
-}
-var SKIP_METHOD_NAMES = /* @__PURE__ */ new Set(["constructor", "if", "for", "while", "switch"]);
-function countBraces(line) {
-  let net = 0;
-  for (const ch of line) {
-    if (ch === "{") net++;
-    else if (ch === "}") net--;
-  }
-  return net;
-}
-var CodeIngestor = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  async ingest(rootDir) {
-    const start = Date.now();
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    const files = await this.findSourceFiles(rootDir);
-    const nameToFiles = /* @__PURE__ */ new Map();
-    const fileContents = /* @__PURE__ */ new Map();
-    for (const filePath of files) {
-      try {
-        const result = await this.processFile(filePath, rootDir, nameToFiles, fileContents);
-        nodesAdded += result.nodesAdded;
-        edgesAdded += result.edgesAdded;
-      } catch (err) {
-        errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    const callsEdges = this.extractCallsEdges(nameToFiles, fileContents);
-    for (const edge of callsEdges) {
-      this.store.addEdge(edge);
-      edgesAdded++;
-    }
-    edgesAdded += this.extractReqAnnotations(fileContents, rootDir);
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  async processFile(filePath, rootDir, nameToFiles, fileContents) {
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    const relativePath = path.relative(rootDir, filePath).replace(/\\/g, "/");
-    const content = await fs.readFile(filePath, "utf-8");
-    const stat2 = await fs.stat(filePath);
-    const fileId = `file:${relativePath}`;
-    fileContents.set(relativePath, content);
-    const fileNode = {
-      id: fileId,
-      type: "file",
-      name: path.basename(filePath),
-      path: relativePath,
-      metadata: { language: this.detectLanguage(filePath) },
-      lastModified: stat2.mtime.toISOString()
-    };
-    this.store.addNode(fileNode);
-    nodesAdded++;
-    const symbols = this.extractSymbols(content, fileId, relativePath);
-    for (const { node, edge } of symbols) {
-      this.store.addNode(node);
-      this.store.addEdge(edge);
-      nodesAdded++;
-      edgesAdded++;
-      this.trackCallable(node, relativePath, nameToFiles);
-    }
-    const imports = await this.extractImports(content, fileId, relativePath, rootDir);
-    for (const edge of imports) {
-      this.store.addEdge(edge);
-      edgesAdded++;
-    }
-    return { nodesAdded, edgesAdded };
-  }
-  trackCallable(node, relativePath, nameToFiles) {
-    if (node.type !== "function" && node.type !== "method") return;
-    let files = nameToFiles.get(node.name);
-    if (!files) {
-      files = /* @__PURE__ */ new Set();
-      nameToFiles.set(node.name, files);
-    }
-    files.add(relativePath);
-  }
-  async findSourceFiles(dir) {
-    const results = [];
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
-        results.push(...await this.findSourceFiles(fullPath));
-      } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
-        results.push(fullPath);
-      }
-    }
-    return results;
-  }
-  extractSymbols(content, fileId, relativePath) {
-    const results = [];
-    const lines = content.split("\n");
-    const ctx = { className: null, classId: null, insideClass: false, braceDepth: 0 };
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (this.tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.tryExtractClass(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (this.updateClassContext(line, ctx)) continue;
-      if (this.tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results)) continue;
-      if (ctx.insideClass) continue;
-      this.tryExtractVariable(line, i, fileId, relativePath, results);
-    }
-    return results;
-  }
-  tryExtractFunction(line, lines, i, fileId, relativePath, ctx, results) {
-    const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
-    if (!fnMatch) return false;
-    const name = fnMatch[1];
-    const id = `function:${relativePath}:${name}`;
-    const endLine = this.findClosingBrace(lines, i);
-    results.push({
-      node: {
-        id,
-        type: "function",
-        name,
-        path: relativePath,
-        location: { fileId, startLine: i + 1, endLine },
-        metadata: {
-          exported: line.includes("export"),
-          cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
-          nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
-          lineCount: endLine - i,
-          parameterCount: this.countParameters(line)
-        }
-      },
-      edge: { from: fileId, to: id, type: "contains" }
-    });
-    if (!ctx.insideClass) {
-      ctx.className = null;
-      ctx.classId = null;
-    }
-    return true;
-  }
-  tryExtractClass(line, lines, i, fileId, relativePath, ctx, results) {
-    const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
-    if (!classMatch) return false;
-    const name = classMatch[1];
-    const id = `class:${relativePath}:${name}`;
-    const endLine = this.findClosingBrace(lines, i);
-    results.push({
-      node: {
-        id,
-        type: "class",
-        name,
-        path: relativePath,
-        location: { fileId, startLine: i + 1, endLine },
-        metadata: { exported: line.includes("export") }
-      },
-      edge: { from: fileId, to: id, type: "contains" }
-    });
-    ctx.className = name;
-    ctx.classId = id;
-    ctx.insideClass = true;
-    ctx.braceDepth = countBraces(line);
-    return true;
-  }
-  tryExtractInterface(line, lines, i, fileId, relativePath, ctx, results) {
-    const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
-    if (!ifaceMatch) return false;
-    const name = ifaceMatch[1];
-    const id = `interface:${relativePath}:${name}`;
-    const endLine = this.findClosingBrace(lines, i);
-    results.push({
-      node: {
-        id,
-        type: "interface",
-        name,
-        path: relativePath,
-        location: { fileId, startLine: i + 1, endLine },
-        metadata: { exported: line.includes("export") }
-      },
-      edge: { from: fileId, to: id, type: "contains" }
-    });
-    ctx.className = null;
-    ctx.classId = null;
-    ctx.insideClass = false;
-    return true;
-  }
-  /** Update brace tracking; returns true when line is consumed (class ended or tracked). */
-  updateClassContext(line, ctx) {
-    if (!ctx.insideClass) return false;
-    ctx.braceDepth += countBraces(line);
-    if (ctx.braceDepth <= 0) {
-      ctx.className = null;
-      ctx.classId = null;
-      ctx.insideClass = false;
-      return true;
-    }
-    return false;
-  }
-  tryExtractMethod(line, lines, i, fileId, relativePath, ctx, results) {
-    if (!ctx.insideClass || !ctx.className || !ctx.classId) return false;
-    const methodMatch = line.match(
-      /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
-    );
-    if (!methodMatch) return false;
-    const methodName = methodMatch[1];
-    if (SKIP_METHOD_NAMES.has(methodName)) return false;
-    const id = `method:${relativePath}:${ctx.className}.${methodName}`;
-    const endLine = this.findClosingBrace(lines, i);
-    results.push({
-      node: {
-        id,
-        type: "method",
-        name: methodName,
-        path: relativePath,
-        location: { fileId, startLine: i + 1, endLine },
-        metadata: {
-          className: ctx.className,
-          exported: false,
-          cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
-          nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
-          lineCount: endLine - i,
-          parameterCount: this.countParameters(line)
-        }
-      },
-      edge: { from: ctx.classId, to: id, type: "contains" }
-    });
-    return true;
-  }
-  tryExtractVariable(line, i, fileId, relativePath, results) {
-    const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
-    if (!varMatch) return;
-    const name = varMatch[1];
-    const id = `variable:${relativePath}:${name}`;
-    results.push({
-      node: {
-        id,
-        type: "variable",
-        name,
-        path: relativePath,
-        location: { fileId, startLine: i + 1, endLine: i + 1 },
-        metadata: { exported: line.includes("export") }
-      },
-      edge: { from: fileId, to: id, type: "contains" }
-    });
-  }
-  /**
-   * Find the closing brace for a construct starting at the given line.
-   * Uses a simple brace-counting heuristic. Returns 1-indexed line number.
-   */
-  findClosingBrace(lines, startIndex) {
-    let depth = 0;
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      for (const ch of line) {
-        if (ch === "{") depth++;
-        if (ch === "}") depth--;
-      }
-      if (depth <= 0 && i > startIndex) {
-        return i + 1;
-      }
-      if (depth === 0 && i === startIndex) {
-        if (line.includes("{")) {
-          return i + 1;
-        }
-      }
-    }
-    return startIndex + 1;
-  }
-  /**
-   * Second pass: scan each file for identifiers matching known callable names,
-   * then create file-to-file "calls" edges. Uses regex heuristic (not AST).
-   */
-  extractCallsEdges(nameToFiles, fileContents) {
-    const edges = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const [filePath, content] of fileContents) {
-      const callerFileId = `file:${filePath}`;
-      const callPattern = /\b([a-zA-Z_$][\w$]*)\s*\(/g;
-      let match;
-      while ((match = callPattern.exec(content)) !== null) {
-        const name = match[1];
-        const targetFiles = nameToFiles.get(name);
-        if (!targetFiles) continue;
-        for (const targetFile of targetFiles) {
-          if (targetFile === filePath) continue;
-          const targetFileId = `file:${targetFile}`;
-          const key = `${callerFileId}|${targetFileId}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-          edges.push({
-            from: callerFileId,
-            to: targetFileId,
-            type: "calls",
-            metadata: { confidence: "regex" }
-          });
-        }
-      }
-    }
-    return edges;
-  }
-  async extractImports(content, fileId, relativePath, rootDir) {
-    const edges = [];
-    const importRegex = /import\s+(?:type\s+)?(?:\{[^}]*\}|[\w*]+)\s+from\s+['"]([^'"]+)['"]/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (!importPath.startsWith(".")) continue;
-      const resolvedPath = await this.resolveImportPath(relativePath, importPath, rootDir);
-      if (resolvedPath) {
-        const targetId = `file:${resolvedPath}`;
-        const isTypeOnly = match[0].includes("import type");
-        edges.push({
-          from: fileId,
-          to: targetId,
-          type: "imports",
-          metadata: { importType: isTypeOnly ? "type-only" : "static" }
-        });
-      }
-    }
-    return edges;
-  }
-  async resolveImportPath(fromFile, importPath, rootDir) {
-    const fromDir = path.dirname(fromFile);
-    const resolved = path.normalize(path.join(fromDir, importPath)).replace(/\\/g, "/");
-    const extensions = [".ts", ".tsx", ".js", ".jsx"];
-    for (const ext of extensions) {
-      const candidate = resolved.replace(/\.js$/, "") + ext;
-      const fullPath = path.join(rootDir, candidate);
-      try {
-        await fs.access(fullPath);
-        return candidate;
-      } catch {
-      }
-    }
-    for (const ext of extensions) {
-      const candidate = path.join(resolved, `index${ext}`).replace(/\\/g, "/");
-      const fullPath = path.join(rootDir, candidate);
-      try {
-        await fs.access(fullPath);
-        return candidate;
-      } catch {
-      }
-    }
-    return null;
-  }
-  computeCyclomaticComplexity(lines) {
-    let complexity = 1;
-    const decisionPattern = /\b(if|else\s+if|while|for|case)\b|\?\s*[^:?]|&&|\|\||catch\b/g;
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
-      const matches = trimmed.match(decisionPattern);
-      if (matches) complexity += matches.length;
-    }
-    return complexity;
-  }
-  computeMaxNesting(lines) {
-    let maxDepth = 0;
-    let currentDepth = 0;
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
-      for (const ch of trimmed) {
-        if (ch === "{") {
-          currentDepth++;
-          if (currentDepth > maxDepth) maxDepth = currentDepth;
-        } else if (ch === "}") {
-          currentDepth--;
-        }
-      }
-    }
-    return Math.max(0, maxDepth - 1);
-  }
-  countParameters(declarationLine) {
-    const parenMatch = declarationLine.match(/\(([^)]*)\)/);
-    if (!parenMatch || !parenMatch[1].trim()) return 0;
-    let depth = 0;
-    let count = 1;
-    for (const ch of parenMatch[1]) {
-      if (ch === "<" || ch === "(") depth++;
-      else if (ch === ">" || ch === ")") depth--;
-      else if (ch === "," && depth === 0) count++;
-    }
-    return count;
-  }
-  detectLanguage(filePath) {
-    if (/\.tsx?$/.test(filePath)) return "typescript";
-    if (/\.jsx?$/.test(filePath)) return "javascript";
-    return "unknown";
-  }
-  /**
-   * Scan file contents for @req annotations and create verified_by edges
-   * linking requirement nodes to the annotated files.
-   * Format: // @req <feature-name>#<index>
-   */
-  extractReqAnnotations(fileContents, rootDir) {
-    const REQ_TAG = /\/\/\s*@req\s+([\w-]+)#(\d+)/g;
-    const reqNodes = this.store.findNodes({ type: "requirement" });
-    let edgesAdded = 0;
-    for (const [filePath, content] of fileContents) {
-      let match;
-      REQ_TAG.lastIndex = 0;
-      while ((match = REQ_TAG.exec(content)) !== null) {
-        const featureName = match[1];
-        const reqIndex = parseInt(match[2], 10);
-        const reqNode = reqNodes.find(
-          (n) => n.metadata.featureName === featureName && n.metadata.index === reqIndex
-        );
-        if (!reqNode) {
-          console.warn(
-            `@req annotation references non-existent requirement: ${featureName}#${reqIndex} in ${filePath}`
-          );
-          continue;
-        }
-        const relPath = path.relative(rootDir, filePath).replace(/\\/g, "/");
-        const fileNodeId = `file:${relPath}`;
-        this.store.addEdge({
-          from: reqNode.id,
-          to: fileNodeId,
-          type: "verified_by",
-          confidence: 1,
-          metadata: {
-            method: "annotation",
-            tag: `@req ${featureName}#${reqIndex}`,
-            confidence: 1
-          }
-        });
-        edgesAdded++;
-      }
-    }
-    return edgesAdded;
-  }
-};
-var execFileAsync = promisify(execFile);
-var GitIngestor = class {
-  constructor(store, gitRunner) {
-    this.store = store;
-    this.gitRunner = gitRunner;
-  }
-  store;
-  gitRunner;
-  async ingest(rootDir) {
-    const start = Date.now();
-    const errors = [];
-    let nodesAdded = 0;
-    let nodesUpdated = 0;
-    let edgesAdded = 0;
-    let edgesUpdated = 0;
-    let output;
-    try {
-      output = await this.runGit(rootDir, [
-        "log",
-        "--format=%H|%an|%ae|%aI|%s",
-        "--name-only",
-        "-n",
-        "100"
-      ]);
-    } catch (err) {
-      errors.push(`git log failed: ${err instanceof Error ? err.message : String(err)}`);
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors,
-        durationMs: Date.now() - start
-      };
-    }
-    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 coChanges = this.computeCoChanges(commits);
-    for (const { fileA, fileB, count } of coChanges) {
-      const fileAId = `file:${fileA}`;
-      const fileBId = `file:${fileB}`;
-      const nodeA = this.store.getNode(fileAId);
-      const nodeB = this.store.getNode(fileBId);
-      if (nodeA && nodeB) {
-        this.store.addEdge({
-          from: fileAId,
-          to: fileBId,
-          type: "co_changes_with",
-          metadata: { count }
-        });
-        edgesAdded++;
-      }
-    }
-    return {
-      nodesAdded,
-      nodesUpdated,
-      edgesAdded,
-      edgesUpdated,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  async runGit(rootDir, args) {
-    if (this.gitRunner) {
-      return this.gitRunner(rootDir, args);
-    }
-    const { stdout } = await execFileAsync("git", args, { cwd: rootDir });
-    return stdout;
-  }
-  parseGitLog(output) {
-    if (!output.trim()) return [];
-    const commits = [];
-    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;
-      }
-      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;
-      }
-    }
-    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
-      });
-    }
-    return commits;
-  }
-  computeCoChanges(commits) {
-    const pairCounts = /* @__PURE__ */ new Map();
-    for (const commit of commits) {
-      const files = [...commit.files].sort();
-      for (let i = 0; i < files.length; i++) {
-        for (let j = i + 1; j < files.length; j++) {
-          const key = `${files[i]}||${files[j]}`;
-          pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
-        }
-      }
-    }
-    const results = [];
-    for (const [key, count] of pairCounts) {
-      if (count >= 2) {
-        const [fileA, fileB] = key.split("||");
-        results.push({ fileA, fileB, count });
-      }
-    }
-    return results;
-  }
-};
-var TopologicalLinker = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  link() {
-    let edgesAdded = 0;
-    const files = this.store.findNodes({ type: "file" });
-    const directories = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      if (!file.path) continue;
-      const dir = path2.dirname(file.path);
-      if (!directories.has(dir)) {
-        directories.set(dir, []);
-      }
-      directories.get(dir).push(file.id);
-    }
-    for (const [dir, fileIds] of directories) {
-      if (fileIds.length < 1) continue;
-      const moduleId = `module:${dir}`;
-      const moduleName = dir === "." ? "root" : path2.basename(dir);
-      this.store.addNode({
-        id: moduleId,
-        type: "module",
-        name: moduleName,
-        path: dir,
-        metadata: { fileCount: fileIds.length }
-      });
-      for (const fileId of fileIds) {
-        this.store.addEdge({
-          from: moduleId,
-          to: fileId,
-          type: "contains"
-        });
-        edgesAdded++;
-      }
-    }
-    const cycles = this.detectCycles(files.map((f) => f.id));
-    return { edgesAdded, cycles };
-  }
-  detectCycles(fileIds) {
-    const cycles = [];
-    const visited = /* @__PURE__ */ new Set();
-    const inStack = /* @__PURE__ */ new Set();
-    const stack = [];
-    const dfs = (nodeId) => {
-      if (inStack.has(nodeId)) {
-        const cycleStart = stack.indexOf(nodeId);
-        if (cycleStart !== -1) {
-          cycles.push(stack.slice(cycleStart).concat(nodeId));
-        }
-        return;
-      }
-      if (visited.has(nodeId)) return;
-      visited.add(nodeId);
-      inStack.add(nodeId);
-      stack.push(nodeId);
-      const importEdges = this.store.getEdges({ from: nodeId, type: "imports" });
-      for (const edge of importEdges) {
-        dfs(edge.to);
-      }
-      stack.pop();
-      inStack.delete(nodeId);
-    };
-    for (const fileId of fileIds) {
-      if (!visited.has(fileId)) {
-        dfs(fileId);
-      }
-    }
-    return cycles;
-  }
-};
-function hash(text) {
-  return crypto.createHash("sha256").update(text).digest("hex").slice(0, 8);
-}
-function mergeResults(...results) {
-  return {
-    nodesAdded: results.reduce((s, r) => s + r.nodesAdded, 0),
-    nodesUpdated: results.reduce((s, r) => s + r.nodesUpdated, 0),
-    edgesAdded: results.reduce((s, r) => s + r.edgesAdded, 0),
-    edgesUpdated: results.reduce((s, r) => s + r.edgesUpdated, 0),
-    errors: results.flatMap((r) => r.errors),
-    durationMs: results.reduce((s, r) => s + r.durationMs, 0)
-  };
-}
-function emptyResult(durationMs = 0) {
-  return { nodesAdded: 0, nodesUpdated: 0, edgesAdded: 0, edgesUpdated: 0, errors: [], durationMs };
-}
-var CODE_NODE_TYPES = ["file", "function", "class", "method", "interface", "variable"];
-var KnowledgeIngestor = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  async ingestADRs(adrDir) {
-    const start = Date.now();
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    let files;
-    try {
-      files = await this.findMarkdownFiles(adrDir);
-    } catch {
-      return emptyResult(Date.now() - start);
-    }
-    for (const filePath of files) {
-      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 }
-        });
-        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
-    };
-  }
-  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 = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    const lines = content.split("\n");
-    let currentDate;
-    for (const line of lines) {
-      const headingMatch = line.match(/^##\s+(\S+)/);
-      if (headingMatch) {
-        currentDate = headingMatch[1];
-        continue;
-      }
-      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 }
-      });
-      nodesAdded++;
-      edgesAdded += this.linkToCode(text, nodeId, "applies_to");
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - 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 = [];
-    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 }
-      });
-      nodesAdded++;
-      edgesAdded += this.linkToCode(description, nodeId, "caused_by");
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  async ingestAll(projectPath, opts) {
-    const start = Date.now();
-    const adrDir = opts?.adrDir ?? path3.join(projectPath, "docs", "adr");
-    const [adrResult, learningsResult, failuresResult] = await Promise.all([
-      this.ingestADRs(adrDir),
-      this.ingestLearnings(projectPath),
-      this.ingestFailures(projectPath)
-    ]);
-    const merged = mergeResults(adrResult, learningsResult, failuresResult);
-    return { ...merged, durationMs: Date.now() - start };
-  }
-  linkToCode(content, sourceNodeId, edgeType) {
-    let count = 0;
-    for (const nodeType of CODE_NODE_TYPES) {
-      const codeNodes = this.store.findNodes({ type: nodeType });
-      for (const node of codeNodes) {
-        let nameMatches = false;
-        if (node.name.length >= 3) {
-          const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-          const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
-          nameMatches = namePattern.test(content);
-        }
-        let pathMatches = false;
-        if (node.path && node.path.includes(path3.sep)) {
-          pathMatches = content.includes(node.path);
-        }
-        if (nameMatches || pathMatches) {
-          this.store.addEdge({
-            from: sourceNodeId,
-            to: node.id,
-            type: edgeType
-          });
-          count++;
-        }
-      }
-    }
-    return count;
-  }
-  async findMarkdownFiles(dir) {
-    const results = [];
-    const entries = await fs2.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...await this.findMarkdownFiles(fullPath));
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        results.push(fullPath);
-      }
-    }
-    return results;
-  }
-};
-var REQUIREMENT_SECTIONS = [
-  "Observable Truths",
-  "Success Criteria",
-  "Acceptance Criteria"
-];
-var SECTION_HEADING_RE = /^#{2,3}\s+(.+)$/;
-var NUMBERED_ITEM_RE = /^\s*(\d+)\.\s+(.+)$/;
-function detectEarsPattern(text) {
-  const lower = text.toLowerCase();
-  if (/^if\b.+\bthen\b.+\bshall not\b/.test(lower)) return "unwanted";
-  if (/^when\b/.test(lower)) return "event-driven";
-  if (/^while\b/.test(lower)) return "state-driven";
-  if (/^where\b/.test(lower)) return "optional";
-  if (/^the\s+\w+\s+shall\b/.test(lower)) return "ubiquitous";
-  return void 0;
-}
-var CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
-var RequirementIngestor = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  /**
-   * Scan a specs directory for `<feature>/proposal.md` files,
-   * extract numbered requirements from recognized sections,
-   * and create requirement nodes with convention-based edges.
-   */
-  async ingestSpecs(specsDir) {
-    const start = Date.now();
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    let featureDirs;
-    try {
-      const entries = await fs3.readdir(specsDir, { withFileTypes: true });
-      featureDirs = entries.filter((e) => e.isDirectory()).map((e) => path4.join(specsDir, e.name));
-    } catch {
-      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)}`);
-      }
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  /**
-   * Parse markdown content and extract numbered items from recognized sections.
-   */
-  extractRequirements(content, specPath, specHash, featureName) {
-    const lines = content.split("\n");
-    const results = [];
-    let currentSection;
-    let inRequirementSection = false;
-    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;
-        }
-        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
-          }
-        }
-      });
-    }
-    return results;
-  }
-  /**
-   * Convention-based linking: match requirement to code/test files
-   * by feature name in their path.
-   */
-  linkByPathPattern(reqId, featureName) {
-    let count = 0;
-    const fileNodes = this.store.findNodes({ type: "file" });
-    for (const node of fileNodes) {
-      if (!node.path) continue;
-      const normalizedPath = node.path.replace(/\\/g, "/");
-      const isCodeMatch = normalizedPath.includes("packages/") && path4.basename(normalizedPath).includes(featureName);
-      const isTestMatch = normalizedPath.includes("/tests/") && // platform-safe
-      path4.basename(normalizedPath).includes(featureName);
-      if (isCodeMatch && !isTestMatch) {
-        this.store.addEdge({
-          from: reqId,
-          to: node.id,
-          type: "requires",
-          confidence: 0.5,
-          metadata: { method: "convention", matchReason: "path-pattern" }
-        });
-        count++;
-      } else if (isTestMatch) {
-        this.store.addEdge({
-          from: reqId,
-          to: node.id,
-          type: "verified_by",
-          confidence: 0.5,
-          metadata: { method: "convention", matchReason: "path-pattern" }
-        });
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Convention-based linking: match requirement text to code nodes
-   * by keyword overlap (function/class names appearing in requirement text).
-   */
-  linkByKeywordOverlap(reqId, reqText) {
-    let count = 0;
-    for (const nodeType of CODE_NODE_TYPES2) {
-      const codeNodes = this.store.findNodes({ type: nodeType });
-      for (const node of codeNodes) {
-        if (node.name.length < 3) continue;
-        const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const namePattern = new RegExp(`\\b${escaped}\\b`, "i");
-        if (namePattern.test(reqText)) {
-          const edgeType = node.path?.replace(/\\/g, "/").includes("/tests/") ? "verified_by" : "requires";
-          this.store.addEdge({
-            from: reqId,
-            to: node.id,
-            type: edgeType,
-            confidence: 0.6,
-            metadata: { method: "convention", matchReason: "keyword-overlap" }
-          });
-          count++;
-        }
-      }
-    }
-    return count;
-  }
-};
-var CODE_NODE_TYPES3 = ["file", "function", "class", "method", "interface", "variable"];
-var SANITIZE_RULES = [
-  // Strip XML/HTML-like instruction tags that could be interpreted as system prompts
-  {
-    pattern: /<\/?(?:system|instruction|prompt|role|context|tool_call|function_call|assistant|human|user)[^>]*>/gi,
-    replacement: ""
-  },
-  // Strip markdown-style system prompt markers (including trailing space)
-  {
-    pattern: /^#{1,3}\s*(?:system|instruction|prompt)\s*[:：]\s*/gim,
-    replacement: ""
-  },
-  // Strip common injection prefixes
-  {
-    pattern: /(?:ignore|disregard|forget)\s+(?:all\s+)?(?:previous|prior|above)\s+(?:instructions?|prompts?|context)/gi,
-    replacement: "[filtered]"
-  },
-  // Strip "you are now" re-roling attempts (only when followed by AI/agent role words)
-  {
-    pattern: /you\s+are\s+now\s+(?:a\s+)?(?:helpful\s+)?(?:an?\s+)?(?:assistant|system|ai|bot|agent|tool)\b/gi,
-    replacement: "[filtered]"
-  }
-];
-function sanitizeExternalText(text, maxLength = 2e3) {
-  let sanitized = text;
-  for (const rule of SANITIZE_RULES) {
-    sanitized = sanitized.replace(rule.pattern, rule.replacement);
-  }
-  if (sanitized.length > maxLength) {
-    sanitized = sanitized.slice(0, maxLength) + "\u2026";
-  }
-  return sanitized;
-}
-function linkToCode(store, content, sourceNodeId, edgeType, options) {
-  let edgesCreated = 0;
-  for (const type of CODE_NODE_TYPES3) {
-    const nodes = store.findNodes({ type });
-    for (const node of nodes) {
-      if (node.name.length < 3) continue;
-      const escaped = node.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const pattern = new RegExp(`\\b${escaped}\\b`, "i");
-      let matched = pattern.test(content);
-      if (!matched && options?.checkPaths && node.path) {
-        matched = content.includes(node.path);
-      }
-      if (matched) {
-        store.addEdge({ from: sourceNodeId, to: node.id, type: edgeType });
-        edgesCreated++;
-      }
-    }
-  }
-  return edgesCreated;
-}
-var SyncManager = class {
-  constructor(store, graphDir) {
-    this.store = store;
-    this.metadataPath = path5.join(graphDir, "sync-metadata.json");
-  }
-  store;
-  registrations = /* @__PURE__ */ new Map();
-  metadataPath;
-  registerConnector(connector, config) {
-    this.registrations.set(connector.name, { connector, config });
-  }
-  async sync(connectorName) {
-    const registration = this.registrations.get(connectorName);
-    if (!registration) {
-      return {
-        nodesAdded: 0,
-        nodesUpdated: 0,
-        edgesAdded: 0,
-        edgesUpdated: 0,
-        errors: [`Connector "${connectorName}" not registered`],
-        durationMs: 0
-      };
-    }
-    const { connector, config } = registration;
-    const result = await connector.ingest(this.store, config);
-    const metadata = await this.loadMetadata();
-    metadata.connectors[connectorName] = {
-      lastSyncTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      lastResult: result
-    };
-    await this.saveMetadata(metadata);
-    return result;
-  }
-  async syncAll() {
-    const combined = {
-      nodesAdded: 0,
-      nodesUpdated: 0,
-      edgesAdded: 0,
-      edgesUpdated: 0,
-      errors: [],
-      durationMs: 0
-    };
-    for (const [name] of this.registrations) {
-      const result = await this.sync(name);
-      combined.nodesAdded += result.nodesAdded;
-      combined.nodesUpdated += result.nodesUpdated;
-      combined.edgesAdded += result.edgesAdded;
-      combined.edgesUpdated += result.edgesUpdated;
-      combined.errors.push(...result.errors);
-      combined.durationMs += result.durationMs;
-    }
-    return combined;
-  }
-  async getMetadata() {
-    return this.loadMetadata();
-  }
-  async loadMetadata() {
-    try {
-      const raw = await fs4.readFile(this.metadataPath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return { connectors: {} };
-    }
-  }
-  async saveMetadata(metadata) {
-    await fs4.mkdir(path5.dirname(this.metadataPath), { recursive: true });
-    await fs4.writeFile(this.metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
-  }
-};
-function buildIngestResult(nodesAdded, edgesAdded, errors, start) {
-  return {
-    nodesAdded,
-    nodesUpdated: 0,
-    edgesAdded,
-    edgesUpdated: 0,
-    errors,
-    durationMs: Date.now() - start
-  };
-}
-function buildJql(config) {
-  const project2 = config.project;
-  let jql = project2 ? `project=${project2}` : "";
-  const filters = config.filters;
-  if (filters?.status?.length) {
-    jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
-  }
-  if (filters?.labels?.length) {
-    jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
-  }
-  return jql;
-}
-var JiraConnector = class {
-  name = "jira";
-  source = "jira";
-  httpClient;
-  constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
-  }
-  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) {
-      return buildIngestResult(
-        0,
-        0,
-        [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
-        start
-      );
-    }
-    const baseUrlEnv = config.baseUrlEnv ?? "JIRA_BASE_URL";
-    const baseUrl = process.env[baseUrlEnv];
-    if (!baseUrl) {
-      return buildIngestResult(
-        0,
-        0,
-        [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
-        start
-      );
-    }
-    const jql = buildJql(config);
-    const headers = {
-      Authorization: `Basic ${apiKey}`,
-      "Content-Type": "application/json"
-    };
-    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;
-      }
-    } catch (err) {
-      return buildIngestResult(
-        nodesAdded,
-        edgesAdded,
-        [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
-        start
-      );
-    }
-    return buildIngestResult(nodesAdded, edgesAdded, [], start);
-  }
-  processIssue(store, issue) {
-    const nodeId = `issue:jira:${issue.key}`;
-    store.addNode({
-      id: nodeId,
-      type: "issue",
-      name: sanitizeExternalText(issue.fields.summary, 500),
-      metadata: {
-        key: issue.key,
-        status: issue.fields.status?.name,
-        priority: issue.fields.priority?.name,
-        assignee: issue.fields.assignee?.displayName,
-        labels: issue.fields.labels ?? []
-      }
-    });
-    const searchText = sanitizeExternalText(
-      [issue.fields.summary, issue.fields.description ?? ""].join(" ")
-    );
-    const edgesAdded = linkToCode(store, searchText, nodeId, "applies_to");
-    return { nodesAdded: 1, edgesAdded };
-  }
-};
-var SlackConnector = class {
-  name = "slack";
-  source = "slack";
-  httpClient;
-  constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
-  }
-  async ingest(store, config) {
-    const start = Date.now();
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    const apiKeyEnv = config.apiKeyEnv ?? "SLACK_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
-      };
-    }
-    const channels = config.channels ?? [];
-    const oldest = config.lookbackDays ? String(Math.floor((Date.now() - Number(config.lookbackDays) * 864e5) / 1e3)) : void 0;
-    for (const channel of channels) {
-      try {
-        const result = await this.processChannel(store, channel, apiKey, oldest);
-        nodesAdded += result.nodesAdded;
-        edgesAdded += result.edgesAdded;
-        errors.push(...result.errors);
-      } catch (err) {
-        errors.push(
-          `Slack API error for channel ${channel}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  async processChannel(store, channel, apiKey, oldest) {
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
-    if (oldest) {
-      url += `&oldest=${oldest}`;
-    }
-    const response = await this.httpClient(url, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      return {
-        nodesAdded: 0,
-        edgesAdded: 0,
-        errors: [`Slack API request failed for channel ${channel}`]
-      };
-    }
-    const data = await response.json();
-    if (!data.ok) {
-      return { nodesAdded: 0, edgesAdded: 0, errors: [`Slack API error for channel ${channel}`] };
-    }
-    for (const message of data.messages) {
-      const nodeId = `conversation:slack:${channel}:${message.ts}`;
-      const sanitizedText = sanitizeExternalText(message.text);
-      const snippet = sanitizedText.length > 100 ? sanitizedText.slice(0, 100) : sanitizedText;
-      store.addNode({
-        id: nodeId,
-        type: "conversation",
-        name: snippet,
-        metadata: {
-          author: message.user,
-          channel,
-          timestamp: message.ts
-        }
-      });
-      nodesAdded++;
-      edgesAdded += linkToCode(store, sanitizedText, nodeId, "references", {
-        checkPaths: true
-      });
-    }
-    return { nodesAdded, edgesAdded, errors };
-  }
-};
-var ConfluenceConnector = class {
-  name = "confluence";
-  source = "confluence";
-  httpClient;
-  constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
-  }
-  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
-      };
-    }
-    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)}`);
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded,
-      edgesUpdated: 0,
-      errors,
-      durationMs: Date.now() - start
-    };
-  }
-  async fetchAllPages(store, baseUrl, apiKey, spaceKey) {
-    const errors = [];
-    let nodesAdded = 0;
-    let edgesAdded = 0;
-    let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
-    while (nextUrl) {
-      const response = await this.httpClient(nextUrl, {
-        headers: { Authorization: `Bearer ${apiKey}` }
-      });
-      if (!response.ok) {
-        errors.push(`Confluence API error: status ${response.status}`);
-        break;
-      }
-      const data = await response.json();
-      for (const page of data.results) {
-        const counts = this.processPage(store, page, spaceKey);
-        nodesAdded += counts.nodesAdded;
-        edgesAdded += counts.edgesAdded;
-      }
-      nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
-    }
-    return { nodesAdded, edgesAdded, errors };
-  }
-  processPage(store, page, spaceKey) {
-    const nodeId = `confluence:${page.id}`;
-    store.addNode({
-      id: nodeId,
-      type: "document",
-      name: sanitizeExternalText(page.title, 500),
-      metadata: {
-        source: "confluence",
-        spaceKey,
-        pageId: page.id,
-        status: page.status,
-        url: page._links?.webui ?? ""
-      }
-    });
-    const text = sanitizeExternalText(`${page.title} ${page.body?.storage?.value ?? ""}`);
-    const edgesAdded = linkToCode(store, text, nodeId, "documents");
-    return { nodesAdded: 1, edgesAdded };
-  }
-};
-var CIConnector = class {
-  name = "ci";
-  source = "github-actions";
-  httpClient;
-  constructor(httpClient) {
-    this.httpClient = httpClient ?? ((url, options) => fetch(url, options));
-  }
-  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
-      };
-    }
-    const repo = config.repo ?? "";
-    const maxRuns = config.maxRuns ?? 10;
-    try {
-      const url = `https://api.github.com/repos/${repo}/actions/runs?per_page=${maxRuns}`;
-      const response = await this.httpClient(url, {
-        headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/vnd.github.v3+json" }
-      });
-      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
-        };
-      }
-      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
-    };
-  }
-};
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should",
-  "may",
-  "might",
-  "shall",
-  "can",
-  "to",
-  "of",
-  "in",
-  "for",
-  "on",
-  "with",
-  "at",
-  "by",
-  "from",
-  "as",
-  "into",
-  "about",
-  "this",
-  "that",
-  "it",
-  "not",
-  "but",
-  "and",
-  "or",
-  "if",
-  "then",
-  "so"
-]);
-var FusionLayer = class {
-  store;
-  vectorStore;
-  keywordWeight;
-  semanticWeight;
-  constructor(store, vectorStore, keywordWeight = 0.6, semanticWeight = 0.4) {
-    this.store = store;
-    this.vectorStore = vectorStore;
-    this.keywordWeight = keywordWeight;
-    this.semanticWeight = semanticWeight;
-  }
-  search(query, topK = 10, queryEmbedding) {
-    const keywords = this.extractKeywords(query);
-    if (keywords.length === 0) {
-      return [];
-    }
-    const allNodes = this.store.findNodes({});
-    const semanticScores = /* @__PURE__ */ new Map();
-    if (queryEmbedding && this.vectorStore) {
-      const vectorResults = this.vectorStore.search(queryEmbedding, allNodes.length);
-      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;
-    const results = [];
-    for (const node of allNodes) {
-      const kwScore = this.keywordScore(keywords, node);
-      const semScore = semanticScores.get(node.id) ?? 0;
-      const fusedScore = kwWeight * kwScore + semWeight * semScore;
-      if (fusedScore > 0) {
-        results.push({
-          nodeId: node.id,
-          node,
-          score: fusedScore,
-          signals: {
-            keyword: kwScore,
-            semantic: semScore
-          }
-        });
-      }
-    }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
-  }
-  extractKeywords(query) {
-    const tokens = query.toLowerCase().split(/[\s\-_.,:;!?()[\]{}"'`/\\|@#$%^&*+=<>~]+/).filter((t) => t.length >= 2).filter((t) => !STOP_WORDS.has(t));
-    return [...new Set(tokens)];
-  }
-  keywordScore(keywords, node) {
-    if (keywords.length === 0) return 0;
-    let totalScore = 0;
-    for (const keyword of keywords) {
-      totalScore += this.singleKeywordScore(keyword, node);
-    }
-    return totalScore / keywords.length;
-  }
-  singleKeywordScore(keyword, node) {
-    const nameLower = node.name.toLowerCase();
-    if (nameLower === keyword) {
-      return 1;
-    }
-    if (nameLower.includes(keyword)) {
-      return 0.7;
-    }
-    if (node.path && node.path.toLowerCase().includes(keyword)) {
-      return 0.5;
-    }
-    for (const value of Object.values(node.metadata)) {
-      if (typeof value === "string" && value.toLowerCase().includes(keyword)) {
-        return 0.3;
-      }
-    }
-    return 0;
-  }
-};
-var CODE_NODE_TYPES4 = ["file", "function", "class", "method", "interface", "variable"];
-var GraphEntropyAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  /**
-   * Find all `documents` edges and classify them as stale or missing-target.
-   *
-   * 1. Find all `documents` edges in the graph
-   * 2. For each edge, check if the target code node still exists in the store
-   * 3. If target doesn't exist -> add to missingTargets
-   * 4. If target exists -> compare lastModified timestamps to determine staleness
-   */
-  computeDriftData() {
-    const documentsEdges = this.store.getEdges({ type: "documents" });
-    const staleEdges = [];
-    const missingTargets = [];
-    let freshEdges = 0;
-    for (const edge of documentsEdges) {
-      const codeNode = this.store.getNode(edge.to);
-      if (!codeNode) {
-        missingTargets.push(edge.to);
-        continue;
-      }
-      const docNode = this.store.getNode(edge.from);
-      const codeLastModified = codeNode.lastModified;
-      const docLastModified = docNode?.lastModified;
-      if (codeLastModified && docLastModified) {
-        if (codeLastModified > docLastModified) {
-          staleEdges.push({
-            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 { staleEdges, missingTargets, freshEdges };
-  }
-  /**
-   * BFS from entry points to find reachable vs unreachable code nodes.
-   *
-   * 1. Entry points: file nodes named `index.ts` or with metadata `entryPoint: true`
-   * 2. BFS following `imports` and `calls` edges (outbound only)
-   * 3. Unreachable = code nodes NOT in visited set
-   */
-  computeDeadCodeData() {
-    const entryPoints = this.findEntryPoints();
-    const visited = this.bfsFromEntryPoints(entryPoints);
-    const unreachableNodes = this.collectUnreachableNodes(visited);
-    return { reachableNodeIds: visited, unreachableNodes, entryPoints };
-  }
-  findEntryPoints() {
-    const entryPoints = [];
-    for (const nodeType of CODE_NODE_TYPES4) {
-      const nodes = this.store.findNodes({ type: nodeType });
-      for (const node of nodes) {
-        const isIndexFile = nodeType === "file" && node.name === "index.ts";
-        if (isIndexFile || node.metadata?.entryPoint === true) {
-          entryPoints.push(node.id);
-        }
-      }
-    }
-    return entryPoints;
-  }
-  bfsFromEntryPoints(entryPoints) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [...entryPoints];
-    let head = 0;
-    while (head < queue.length) {
-      const nodeId = queue[head++];
-      if (visited.has(nodeId)) continue;
-      visited.add(nodeId);
-      this.enqueueOutboundEdges(nodeId, visited, queue);
-    }
-    return visited;
-  }
-  enqueueOutboundEdges(nodeId, visited, queue) {
-    const edgeTypes = ["imports", "calls", "contains"];
-    for (const edgeType of edgeTypes) {
-      const edges = this.store.getEdges({ from: nodeId, type: edgeType });
-      for (const edge of edges) {
-        if (!visited.has(edge.to)) {
-          queue.push(edge.to);
-        }
-      }
-    }
-  }
-  collectUnreachableNodes(visited) {
-    const unreachableNodes = [];
-    for (const nodeType of CODE_NODE_TYPES4) {
-      const nodes = this.store.findNodes({ type: nodeType });
-      for (const node of nodes) {
-        if (!visited.has(node.id)) {
-          unreachableNodes.push({
-            id: node.id,
-            type: node.type,
-            name: node.name,
-            path: node.path
-          });
-        }
-      }
-    }
-    return unreachableNodes;
-  }
-  /**
-   * Count all nodes and edges by type.
-   */
-  computeSnapshotSummary() {
-    const nodesByType = {};
-    const edgesByType = {};
-    const allNodes = this.store.findNodes({});
-    for (const node of allNodes) {
-      nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
-    }
-    const allEdges = this.store.getEdges({});
-    for (const edge of allEdges) {
-      edgesByType[edge.type] = (edgesByType[edge.type] ?? 0) + 1;
-    }
-    return {
-      nodeCount: this.store.nodeCount,
-      edgeCount: this.store.edgeCount,
-      nodesByType,
-      edgesByType
-    };
-  }
-};
-var GraphComplexityAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  /**
-   * Compute complexity hotspots by combining cyclomatic complexity with change frequency.
-   *
-   * 1. Find all function and method nodes
-   * 2. For each, find the containing file and count commit nodes referencing that file
-   * 3. Compute hotspotScore = changeFrequency * cyclomaticComplexity
-   * 4. Sort descending by score
-   * 5. Compute 95th percentile
-   */
-  computeComplexityHotspots() {
-    const functionNodes = [
-      ...this.store.findNodes({ type: "function" }),
-      ...this.store.findNodes({ type: "method" })
-    ];
-    if (functionNodes.length === 0) {
-      return { hotspots: [], percentile95Score: 0 };
-    }
-    const fileChangeFrequency = /* @__PURE__ */ new Map();
-    const hotspots = [];
-    for (const fnNode of functionNodes) {
-      const complexity = fnNode.metadata?.cyclomaticComplexity ?? 1;
-      const fileId = this.findContainingFileId(fnNode.id);
-      if (!fileId) continue;
-      const changeFrequency = this.getChangeFrequency(fileId, fileChangeFrequency);
-      const hotspotScore = changeFrequency * complexity;
-      const filePath = fnNode.path ?? fileId.replace(/^file:/, "");
-      hotspots.push({
-        file: filePath,
-        function: fnNode.name,
-        changeFrequency,
-        complexity,
-        hotspotScore
-      });
-    }
-    hotspots.sort((a, b) => b.hotspotScore - a.hotspotScore);
-    const percentile95Score = this.computePercentile(
-      hotspots.map((h) => h.hotspotScore),
-      95
-    );
-    return { hotspots, percentile95Score };
-  }
-  /**
-   * Walk the 'contains' edges to find the file node that contains a given function/method.
-   * For methods, walks through the intermediate class node.
-   */
-  findContainingFileId(nodeId) {
-    const containsEdges = this.store.getEdges({ to: nodeId, type: "contains" });
-    for (const edge of containsEdges) {
-      const sourceNode = this.store.getNode(edge.from);
-      if (sourceNode?.type === "file") return sourceNode.id;
-      if (sourceNode?.type === "class") {
-        const fileId = this.findParentFileOfClass(sourceNode.id);
-        if (fileId) return fileId;
-      }
-    }
-    return void 0;
-  }
-  findParentFileOfClass(classNodeId) {
-    const classContainsEdges = this.store.getEdges({ to: classNodeId, type: "contains" });
-    for (const classEdge of classContainsEdges) {
-      const parentNode = this.store.getNode(classEdge.from);
-      if (parentNode?.type === "file") return parentNode.id;
-    }
-    return void 0;
-  }
-  getChangeFrequency(fileId, cache) {
-    let freq = cache.get(fileId);
-    if (freq === void 0) {
-      const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
-      freq = referencesEdges.length;
-      cache.set(fileId, freq);
-    }
-    return freq;
-  }
-  computePercentile(descendingScores, percentile) {
-    if (descendingScores.length === 0) return 0;
-    const ascending = [...descendingScores].sort((a, b) => a - b);
-    const index = Math.ceil(percentile / 100 * ascending.length) - 1;
-    return ascending[Math.min(index, ascending.length - 1)];
-  }
-};
-var GraphCouplingAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  /**
-   * Compute coupling data for all file nodes in the graph.
-   *
-   * For each file:
-   * - fanOut: number of outbound 'imports' edges
-   * - fanIn: number of inbound 'imports' edges from other files
-   * - couplingRatio: fanOut / (fanIn + fanOut), rounded to 2 decimals (0 if both are 0)
-   * - transitiveDepth: longest chain of outbound 'imports' edges via BFS
-   */
-  computeCouplingData() {
-    const fileNodes = this.store.findNodes({ type: "file" });
-    if (fileNodes.length === 0) {
-      return { files: [] };
-    }
-    const files = [];
-    for (const node of fileNodes) {
-      const fileId = node.id;
-      const filePath = node.path ?? node.name;
-      const outEdges = this.store.getEdges({ from: fileId, type: "imports" });
-      const fanOut = outEdges.length;
-      const inEdges = this.store.getEdges({ to: fileId, type: "imports" });
-      const fanIn = inEdges.length;
-      const total = fanIn + fanOut;
-      const couplingRatio = total === 0 ? 0 : Math.round(fanOut / total * 100) / 100;
-      const transitiveDepth = this.computeTransitiveDepth(fileId);
-      files.push({ file: filePath, fanIn, fanOut, couplingRatio, transitiveDepth });
-    }
-    return { files };
-  }
-  /**
-   * BFS from a node following outbound 'imports' edges to find the maximum depth.
-   */
-  computeTransitiveDepth(startId) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [[startId, 0]];
-    visited.add(startId);
-    let maxDepth = 0;
-    let head = 0;
-    while (head < queue.length) {
-      const [nodeId, depth] = queue[head++];
-      if (depth > maxDepth) {
-        maxDepth = depth;
-      }
-      const outEdges = this.store.getEdges({ from: nodeId, type: "imports" });
-      for (const edge of outEdges) {
-        if (!visited.has(edge.to)) {
-          visited.add(edge.to);
-          queue.push([edge.to, depth + 1]);
-        }
-      }
-    }
-    return maxDepth;
-  }
-};
-var DEFAULT_THRESHOLD = 2;
-var DEFAULT_METRICS = [
-  "cyclomaticComplexity",
-  "fanIn",
-  "fanOut",
-  "hotspotScore",
-  "transitiveDepth"
-];
-var RECOGNIZED_METRICS = new Set(DEFAULT_METRICS);
-var GraphAnomalyAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  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 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));
-    return {
-      statisticalOutliers: allOutliers,
-      articulationPoints,
-      overlapping,
-      summary: {
-        totalNodesAnalyzed: analyzedNodeIds.size,
-        outlierCount: allOutliers.length,
-        articulationPointCount: articulationPoints.length,
-        overlapCount: overlapping.length,
-        metricsAnalyzed: metricsToAnalyze,
-        warnings,
-        threshold
-      }
-    };
-  }
-  collectMetricValues(metric, cachedCouplingData, cachedHotspotData) {
-    const entries = [];
-    if (metric === "cyclomaticComplexity") {
-      const functionNodes = [
-        ...this.store.findNodes({ type: "function" }),
-        ...this.store.findNodes({ type: "method" })
-      ];
-      for (const node of functionNodes) {
-        const cc = node.metadata?.cyclomaticComplexity;
-        if (typeof cc === "number") {
-          entries.push({
-            nodeId: node.id,
-            nodeName: node.name,
-            nodePath: node.path,
-            nodeType: node.type,
-            value: cc
-          });
-        }
-      }
-    } else if (metric === "fanIn" || metric === "fanOut" || metric === "transitiveDepth") {
-      const couplingData = cachedCouplingData ?? new GraphCouplingAdapter(this.store).computeCouplingData();
-      const fileNodes = this.store.findNodes({ type: "file" });
-      for (const fileData of couplingData.files) {
-        const fileNode = fileNodes.find((n) => (n.path ?? n.name) === fileData.file);
-        if (!fileNode) continue;
-        entries.push({
-          nodeId: fileNode.id,
-          nodeName: fileNode.name,
-          nodePath: fileNode.path,
-          nodeType: "file",
-          value: fileData[metric]
-        });
-      }
-    } else if (metric === "hotspotScore") {
-      const hotspots = cachedHotspotData ?? new GraphComplexityAdapter(this.store).computeComplexityHotspots();
-      const functionNodes = [
-        ...this.store.findNodes({ type: "function" }),
-        ...this.store.findNodes({ type: "method" })
-      ];
-      for (const h of hotspots.hotspots) {
-        const fnNode = functionNodes.find(
-          (n) => n.name === h.function && (n.path ?? "") === (h.file ?? "")
-        );
-        if (!fnNode) continue;
-        entries.push({
-          nodeId: fnNode.id,
-          nodeName: fnNode.name,
-          nodePath: fnNode.path,
-          nodeType: fnNode.type,
-          value: h.hotspotScore
-        });
-      }
-    }
-    return entries;
-  }
-  computeZScoreOutliers(entries, metric, threshold) {
-    if (entries.length === 0) return [];
-    const values = entries.map((e) => e.value);
-    const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
-    const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
-    const stdDev = Math.sqrt(variance);
-    if (stdDev === 0) return [];
-    const outliers = [];
-    for (const entry of entries) {
-      const zScore = Math.abs(entry.value - mean) / stdDev;
-      if (zScore > threshold) {
-        outliers.push({
-          nodeId: entry.nodeId,
-          nodeName: entry.nodeName,
-          nodePath: entry.nodePath,
-          nodeType: entry.nodeType,
-          metric,
-          value: entry.value,
-          zScore,
-          mean,
-          stdDev
-        });
-      }
-    }
-    return outliers;
-  }
-  findArticulationPoints() {
-    const fileNodes = this.store.findNodes({ type: "file" });
-    if (fileNodes.length === 0) return [];
-    const nodeMap = /* @__PURE__ */ new Map();
-    const adj = /* @__PURE__ */ new Map();
-    for (const node of fileNodes) {
-      nodeMap.set(node.id, { name: node.name, path: node.path });
-      adj.set(node.id, /* @__PURE__ */ new Set());
-    }
-    const importEdges = this.store.getEdges({ type: "imports" });
-    for (const edge of importEdges) {
-      if (adj.has(edge.from) && adj.has(edge.to)) {
-        adj.get(edge.from).add(edge.to);
-        adj.get(edge.to).add(edge.from);
-      }
-    }
-    const disc = /* @__PURE__ */ new Map();
-    const low = /* @__PURE__ */ new Map();
-    const parent = /* @__PURE__ */ new Map();
-    const apSet = /* @__PURE__ */ new Set();
-    let timer = 0;
-    const dfs = (u) => {
-      disc.set(u, timer);
-      low.set(u, timer);
-      timer++;
-      let children = 0;
-      for (const v of adj.get(u)) {
-        if (!disc.has(v)) {
-          children++;
-          parent.set(v, u);
-          dfs(v);
-          low.set(u, Math.min(low.get(u), low.get(v)));
-          if (parent.get(u) === null && children > 1) {
-            apSet.add(u);
-          }
-          if (parent.get(u) !== null && low.get(v) >= disc.get(u)) {
-            apSet.add(u);
-          }
-        } else if (v !== parent.get(u)) {
-          low.set(u, Math.min(low.get(u), disc.get(v)));
-        }
-      }
-    };
-    for (const nodeId of adj.keys()) {
-      if (!disc.has(nodeId)) {
-        parent.set(nodeId, null);
-        dfs(nodeId);
-      }
-    }
-    const results = [];
-    for (const apId of apSet) {
-      const { components, dependentCount } = this.computeRemovalImpact(apId, adj);
-      const info = nodeMap.get(apId);
-      results.push({
-        nodeId: apId,
-        nodeName: info.name,
-        nodePath: info.path,
-        componentsIfRemoved: components,
-        dependentCount
-      });
-    }
-    results.sort((a, b) => b.dependentCount - a.dependentCount);
-    return results;
-  }
-  computeRemovalImpact(removedId, adj) {
-    const visited = /* @__PURE__ */ new Set();
-    visited.add(removedId);
-    const componentSizes = [];
-    for (const nodeId of adj.keys()) {
-      if (visited.has(nodeId)) continue;
-      const queue = [nodeId];
-      visited.add(nodeId);
-      let size = 0;
-      let head = 0;
-      while (head < queue.length) {
-        const current = queue[head++];
-        size++;
-        for (const neighbor of adj.get(current)) {
-          if (!visited.has(neighbor)) {
-            visited.add(neighbor);
-            queue.push(neighbor);
-          }
-        }
-      }
-      componentSizes.push(size);
-    }
-    const components = componentSizes.length;
-    if (componentSizes.length <= 1) {
-      return { components, dependentCount: 0 };
-    }
-    const maxSize = Math.max(...componentSizes);
-    const dependentCount = componentSizes.reduce((sum, s) => sum + s, 0) - maxSize;
-    return { components, dependentCount };
-  }
-};
-var INTENTS = ["impact", "find", "relationships", "explain", "anomaly"];
-var SIGNAL_WEIGHTS = {
-  keyword: 0.35,
-  questionWord: 0.2,
-  verbPattern: 0.45
-};
-var INTENT_SIGNALS = {
-  impact: {
-    keywords: [
-      "break",
-      "affect",
-      "impact",
-      "change",
-      "depend",
-      "blast",
-      "radius",
-      "cascade",
-      "risk",
-      "delete",
-      "remove"
-    ],
-    questionWords: ["what", "if"],
-    verbPatterns: [
-      /what\s+(breaks|happens|is affected)/,
-      /if\s+i\s+(change|modify|remove|delete)/,
-      /blast\s+radius/,
-      /cascad/,
-      /what\s+(depend|relies)/
-    ]
-  },
-  find: {
-    keywords: ["find", "where", "locate", "search", "list", "all", "every"],
-    questionWords: ["where"],
-    verbPatterns: [
-      /where\s+is/,
-      /find\s+(the|all|every)/,
-      /show\s+me/,
-      /show\s+(all|every|the)/,
-      /locate\s+/,
-      /list\s+(all|every|the)/
-    ]
-  },
-  relationships: {
-    keywords: [
-      "connect",
-      "call",
-      "import",
-      "use",
-      "depend",
-      "link",
-      "neighbor",
-      "caller",
-      "callee"
-    ],
-    questionWords: ["what", "who"],
-    verbPatterns: [/connects?\s+to/, /depends?\s+on/, /\bcalls?\b/, /\bimports?\b/]
-  },
-  explain: {
-    keywords: ["describe", "explain", "tell", "about", "overview", "summary", "work"],
-    questionWords: ["what", "how"],
-    verbPatterns: [
-      /what\s+is\s+\w/,
-      /describe\s+/,
-      /tell\s+me\s+about/,
-      /how\s+does/,
-      /overview\s+of/,
-      /give\s+me\s+/
-    ]
-  },
-  anomaly: {
-    keywords: [
-      "wrong",
-      "problem",
-      "anomaly",
-      "smell",
-      "issue",
-      "outlier",
-      "hotspot",
-      "suspicious",
-      "risk"
-    ],
-    questionWords: ["what"],
-    verbPatterns: [
-      /what.*(wrong|problem|smell)/,
-      /find.*(issue|anomal|problem)/,
-      /code\s+smell/,
-      /suspicious/,
-      /hotspot/
-    ]
-  }
-};
-var IntentClassifier = class {
-  /**
-   * Classify a natural language question into an intent.
-   *
-   * @param question - The natural language question to classify
-   * @returns ClassificationResult with intent, confidence, and per-signal scores
-   */
-  classify(question) {
-    const normalized = question.toLowerCase().trim();
-    const scores = [];
-    for (const intent of INTENTS) {
-      const signals = this.scoreIntent(normalized, INTENT_SIGNALS[intent]);
-      const confidence = this.combineSignals(signals);
-      scores.push({ intent, confidence, signals });
-    }
-    scores.sort((a, b) => b.confidence - a.confidence);
-    const best = scores[0];
-    return {
-      intent: best.intent,
-      confidence: best.confidence,
-      signals: best.signals
-    };
-  }
-  /**
-   * Score individual signals for an intent against the normalized query.
-   */
-  scoreIntent(normalized, signalSet) {
-    return {
-      keyword: this.scoreKeywords(normalized, signalSet.keywords),
-      questionWord: this.scoreQuestionWord(normalized, signalSet.questionWords),
-      verbPattern: this.scoreVerbPatterns(normalized, signalSet.verbPatterns)
-    };
-  }
-  /**
-   * Score keyword signal: uses word-stem matching (checks if any word in the
-   * query starts with the keyword). Saturates at 2 matches to avoid penalizing
-   * intents with many keywords when only a few appear in the query.
-   */
-  scoreKeywords(normalized, keywords) {
-    if (keywords.length === 0) return 0;
-    const words = normalized.split(/\s+/);
-    let matched = 0;
-    for (const keyword of keywords) {
-      if (words.some((w) => w.startsWith(keyword))) {
-        matched++;
-      }
-    }
-    return Math.min(matched / 2, 1);
-  }
-  /**
-   * Score question-word signal: 1.0 if the query starts with a matching
-   * question word, 0 otherwise.
-   */
-  scoreQuestionWord(normalized, questionWords) {
-    const firstWord = normalized.split(/\s+/)[0] ?? "";
-    return questionWords.includes(firstWord) ? 1 : 0;
-  }
-  /**
-   * Score verb-pattern signal: any matching pattern yields a strong score.
-   * Multiple matches increase score but saturate quickly.
-   */
-  scoreVerbPatterns(normalized, patterns) {
-    if (patterns.length === 0) return 0;
-    let matched = 0;
-    for (const pattern of patterns) {
-      if (pattern.test(normalized)) {
-        matched++;
-      }
-    }
-    return matched === 0 ? 0 : Math.min(0.6 + matched * 0.2, 1);
-  }
-  /**
-   * Combine individual signal scores into a single confidence score
-   * using additive weighted scoring. Each signal contributes weight * score,
-   * and the total weights sum to 1.0 so the result is naturally bounded [0, 1].
-   */
-  combineSignals(signals) {
-    let total = 0;
-    for (const key of Object.keys(signals)) {
-      const weight = SIGNAL_WEIGHTS[key];
-      total += signals[key] * weight;
-    }
-    return total;
-  }
-};
-var INTENT_KEYWORDS = /* @__PURE__ */ new Set([
-  // impact
-  "break",
-  "breaks",
-  "affect",
-  "affects",
-  "affected",
-  "impact",
-  "change",
-  "depend",
-  "depends",
-  "blast",
-  "radius",
-  "risk",
-  "delete",
-  "remove",
-  "modify",
-  "happens",
-  // find
-  "find",
-  "where",
-  "locate",
-  "search",
-  "list",
-  "all",
-  "every",
-  "show",
-  // relationships
-  "connect",
-  "connects",
-  "call",
-  "calls",
-  "import",
-  "imports",
-  "use",
-  "uses",
-  "link",
-  "neighbor",
-  "caller",
-  "callers",
-  "callee",
-  "callees",
-  // explain
-  "describe",
-  "explain",
-  "tell",
-  "about",
-  "overview",
-  "summary",
-  "work",
-  "works",
-  // anomaly
-  "wrong",
-  "problem",
-  "problems",
-  "anomaly",
-  "anomalies",
-  "smell",
-  "smells",
-  "issue",
-  "issues",
-  "outlier",
-  "hotspot",
-  "hotspots",
-  "suspicious"
-]);
-var STOP_WORDS2 = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "the",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should",
-  "may",
-  "might",
-  "shall",
-  "can",
-  "need",
-  "must",
-  "i",
-  "me",
-  "my",
-  "we",
-  "our",
-  "you",
-  "your",
-  "he",
-  "she",
-  "it",
-  "its",
-  "they",
-  "them",
-  "their",
-  "this",
-  "that",
-  "these",
-  "those",
-  "and",
-  "or",
-  "but",
-  "if",
-  "then",
-  "else",
-  "when",
-  "while",
-  "for",
-  "of",
-  "at",
-  "by",
-  "to",
-  "in",
-  "on",
-  "with",
-  "from",
-  "up",
-  "out",
-  "not",
-  "no",
-  "nor",
-  "so",
-  "too",
-  "very",
-  "just",
-  "also",
-  "what",
-  "who",
-  "how",
-  "which",
-  "where",
-  "why",
-  "there",
-  "here",
-  "any",
-  "some",
-  "each",
-  "than",
-  "like",
-  "get",
-  "give",
-  "go",
-  "make",
-  "see",
-  "know",
-  "take"
-]);
-var PASCAL_OR_CAMEL_RE = /\b([A-Z][a-z]+[A-Za-z]*[a-z][A-Za-z]*|[a-z]+[A-Z][A-Za-z]*)\b/g;
-var FILE_PATH_RE = /(?:\.\/|[a-zA-Z0-9_-]+\/)[a-zA-Z0-9_\-./]+\.[a-zA-Z]{1,10}/g;
-var QUOTED_RE = /["']([^"']+)["']/g;
-function isSkippableWord(cleaned, allConsumed) {
-  if (allConsumed.has(cleaned)) return true;
-  const lower = cleaned.toLowerCase();
-  if (STOP_WORDS2.has(lower)) return true;
-  if (INTENT_KEYWORDS.has(lower)) return true;
-  if (cleaned === cleaned.toUpperCase() && /^[A-Z]+$/.test(cleaned)) return true;
-  return false;
-}
-function buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed) {
-  const quotedWords = /* @__PURE__ */ new Set();
-  for (const q of quotedConsumed) {
-    for (const w of q.split(/\s+/)) {
-      if (w.length > 0) quotedWords.add(w);
-    }
-  }
-  return /* @__PURE__ */ new Set([...quotedConsumed, ...quotedWords, ...casingConsumed, ...pathConsumed]);
-}
-var EntityExtractor = class {
-  /**
-   * Extract candidate entity mentions from a natural language query.
-   *
-   * @param query - The natural language query to extract entities from
-   * @returns Array of raw entity strings in priority order, deduplicated
-   */
-  extract(query) {
-    const trimmed = query.trim();
-    if (trimmed.length === 0) return [];
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    const add = (entity) => {
-      if (!seen.has(entity)) {
-        seen.add(entity);
-        result.push(entity);
-      }
-    };
-    const quotedConsumed = /* @__PURE__ */ new Set();
-    for (const match of trimmed.matchAll(QUOTED_RE)) {
-      const inner = match[1].trim();
-      if (inner.length > 0) {
-        add(inner);
-        quotedConsumed.add(inner);
-      }
-    }
-    const casingConsumed = /* @__PURE__ */ new Set();
-    for (const match of trimmed.matchAll(PASCAL_OR_CAMEL_RE)) {
-      const token = match[0];
-      if (!quotedConsumed.has(token)) {
-        add(token);
-        casingConsumed.add(token);
-      }
-    }
-    const pathConsumed = /* @__PURE__ */ new Set();
-    for (const match of trimmed.matchAll(FILE_PATH_RE)) {
-      const path7 = match[0];
-      add(path7);
-      pathConsumed.add(path7);
-    }
-    const allConsumed = buildConsumedSet(quotedConsumed, casingConsumed, pathConsumed);
-    const words = trimmed.split(/\s+/);
-    for (const raw of words) {
-      const cleaned = raw.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "");
-      if (cleaned.length === 0) continue;
-      if (isSkippableWord(cleaned, allConsumed)) continue;
-      add(cleaned);
-    }
-    return result;
-  }
-};
-var EntityResolver = class {
-  store;
-  fusion;
-  constructor(store, fusion) {
-    this.store = store;
-    this.fusion = fusion;
-  }
-  /**
-   * Resolve an array of raw entity strings to graph nodes.
-   *
-   * @param raws - Raw entity strings from EntityExtractor
-   * @returns Array of ResolvedEntity for each successfully resolved raw string
-   */
-  resolve(raws) {
-    const results = [];
-    for (const raw of raws) {
-      const resolved = this.resolveOne(raw);
-      if (resolved !== void 0) {
-        results.push(resolved);
-      }
-    }
-    return results;
-  }
-  resolveOne(raw) {
-    const exactMatches = this.store.findNodes({ name: raw });
-    if (exactMatches.length > 0) {
-      const node = exactMatches[0];
-      return {
-        raw,
-        nodeId: node.id,
-        node,
-        confidence: 1,
-        method: "exact"
-      };
-    }
-    if (this.fusion) {
-      const fusionResults = this.fusion.search(raw, 5);
-      if (fusionResults.length > 0 && fusionResults[0].score > 0.5) {
-        const top = fusionResults[0];
-        return {
-          raw,
-          nodeId: top.nodeId,
-          node: top.node,
-          confidence: top.score,
-          method: "fusion"
-        };
-      }
-    }
-    if (raw.length < 3) return void 0;
-    const isPathLike = raw.includes("/");
-    const fileNodes = this.store.findNodes({ type: "file" });
-    for (const node of fileNodes) {
-      if (!node.path) continue;
-      if (isPathLike && node.path.includes(raw)) {
-        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
-      }
-      const basename5 = node.path.split("/").pop() ?? "";
-      if (basename5.includes(raw)) {
-        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
-      }
-      if (raw.length >= 4 && node.path.includes(raw)) {
-        return { raw, nodeId: node.id, node, confidence: 0.6, method: "path" };
-      }
-    }
-    return void 0;
-  }
-};
-var ResponseFormatter = class {
-  /**
-   * Format graph operation results into a human-readable summary.
-   *
-   * @param intent - The classified intent
-   * @param entities - Resolved entities from the query
-   * @param data - Raw result data (shape varies per intent)
-   * @param query - Original natural language query (optional)
-   * @returns Human-readable summary string
-   */
-  format(intent, entities, data, query) {
-    if (data === null || data === void 0) {
-      return "No results found.";
-    }
-    const firstEntity = entities[0];
-    const entityName = firstEntity?.raw ?? "the target";
-    switch (intent) {
-      case "impact":
-        return this.formatImpact(entityName, data);
-      case "find":
-        return this.formatFind(data, query);
-      case "relationships":
-        return this.formatRelationships(entityName, entities, data);
-      case "explain":
-        return this.formatExplain(entityName, entities, data);
-      case "anomaly":
-        return this.formatAnomaly(data);
-      default:
-        return `Processed results for "${entityName}".`;
-    }
-  }
-  formatImpact(entityName, data) {
-    const d = data;
-    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);
-    return `Changing **${entityName}** affects ${this.p(code, "code file")}, ${this.p(tests, "test")}, and ${this.p(docs, "doc")}.`;
-  }
-  formatFind(data, query) {
-    const count = Array.isArray(data) ? data.length : 0;
-    if (query) {
-      return `Found ${this.p(count, "match", "matches")} for "${query}".`;
-    }
-    return `Found ${this.p(count, "match", "matches")}.`;
-  }
-  formatRelationships(entityName, entities, data) {
-    const d = data;
-    const edges = Array.isArray(d?.edges) ? d.edges : [];
-    const firstEntity = entities[0];
-    const rootId = firstEntity?.nodeId ?? "";
-    let outbound = 0;
-    let inbound = 0;
-    for (const edge of edges) {
-      if (edge.from === rootId) outbound++;
-      if (edge.to === rootId) inbound++;
-    }
-    return `**${entityName}** has ${outbound} outbound and ${inbound} inbound relationships.`;
-  }
-  formatExplain(entityName, entities, data) {
-    const d = data;
-    const context = Array.isArray(d?.context) ? d.context : [];
-    const firstEntity = entities[0];
-    const nodeType = firstEntity?.node.type ?? "node";
-    const path7 = firstEntity?.node.path ?? "unknown";
-    let neighborCount = 0;
-    const firstContext = context[0];
-    if (firstContext && Array.isArray(firstContext.nodes)) {
-      neighborCount = firstContext.nodes.length;
-    }
-    return `**${entityName}** is a ${nodeType} at \`${path7}\`. Connected to ${neighborCount} nodes.`;
-  }
-  formatAnomaly(data) {
-    const d = data;
-    const outliers = Array.isArray(d?.statisticalOutliers) ? d.statisticalOutliers : [];
-    const artPoints = Array.isArray(d?.articulationPoints) ? d.articulationPoints : [];
-    const count = outliers.length + artPoints.length;
-    if (count === 0) {
-      return "Found 0 anomalies.";
-    }
-    const topItems = [
-      ...outliers.slice(0, 2).map((o) => o.nodeId ?? "unknown outlier"),
-      ...artPoints.slice(0, 1).map((a) => a.nodeId ?? "unknown bottleneck")
-    ].join(", ");
-    return `Found ${this.p(count, "anomaly", "anomalies")}: ${topItems}.`;
-  }
-  safeArrayLength(value) {
-    return Array.isArray(value) ? value.length : 0;
-  }
-  p(count, singular, plural) {
-    const word = count === 1 ? singular : plural ?? singular + "s";
-    return `${count} ${word}`;
-  }
-};
-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
-    );
-  }
-};
-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
-      }
-    };
-  }
-};
-var ENTITY_REQUIRED_INTENTS = /* @__PURE__ */ new Set(["impact", "relationships", "explain"]);
-var classifier = new IntentClassifier();
-var extractor = new EntityExtractor();
-var formatter = new ResponseFormatter();
-async function askGraph(store, question) {
-  const fusion = new FusionLayer(store);
-  const resolver = new EntityResolver(store, fusion);
-  const classification = classifier.classify(question);
-  if (classification.confidence < 0.3) {
-    return {
-      intent: classification.intent,
-      intentConfidence: classification.confidence,
-      entities: [],
-      summary: "I'm not sure what you're asking. Try rephrasing your question.",
-      data: null,
-      suggestions: [
-        'Try "what breaks if I change <name>?" for impact analysis',
-        'Try "where is <name>?" to find entities',
-        'Try "what calls <name>?" for relationships',
-        'Try "what is <name>?" for explanations',
-        'Try "what looks wrong?" for anomaly detection'
-      ]
-    };
-  }
-  const rawEntities = extractor.extract(question);
-  const entities = resolver.resolve(rawEntities);
-  if (ENTITY_REQUIRED_INTENTS.has(classification.intent) && entities.length === 0) {
-    return {
-      intent: classification.intent,
-      intentConfidence: classification.confidence,
-      entities: [],
-      summary: "Could not find any matching nodes in the graph for your query. Try using exact class names, function names, or file paths.",
-      data: null
-    };
-  }
-  let data;
-  try {
-    data = executeOperation(store, classification.intent, entities, question, fusion);
-  } catch (err) {
-    return {
-      intent: classification.intent,
-      intentConfidence: classification.confidence,
-      entities,
-      summary: `An error occurred while querying the graph: ${err instanceof Error ? err.message : String(err)}`,
-      data: null
-    };
-  }
-  const summary = formatter.format(classification.intent, entities, data, question);
-  return {
-    intent: classification.intent,
-    intentConfidence: classification.confidence,
-    entities,
-    summary,
-    data
-  };
-}
-function executeOperation(store, intent, entities, question, fusion) {
-  const cql = new ContextQL(store);
-  switch (intent) {
-    case "impact": {
-      const rootId = entities[0].nodeId;
-      const 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": {
-      return fusion.search(question, 10);
-    }
-    case "relationships": {
-      const rootId = entities[0].nodeId;
-      const result = cql.execute({
-        rootNodeIds: [rootId],
-        bidirectional: true,
-        maxDepth: 1
-      });
-      return { nodes: result.nodes, edges: result.edges };
-    }
-    case "explain": {
-      const searchResults = fusion.search(question, 10);
-      const contextBlocks = [];
-      const rootIds = entities.length > 0 ? [entities[0].nodeId] : searchResults.slice(0, 3).map((r) => r.nodeId);
-      for (const rootId of rootIds) {
-        const expanded = cql.execute({
-          rootNodeIds: [rootId],
-          maxDepth: 2
-        });
-        const matchingResult = searchResults.find((r) => r.nodeId === rootId);
-        contextBlocks.push({
-          rootNode: rootId,
-          score: matchingResult?.score ?? 1,
-          nodes: expanded.nodes,
-          edges: expanded.edges
-        });
-      }
-      return { searchResults, context: contextBlocks };
-    }
-    case "anomaly": {
-      const adapter = new GraphAnomalyAdapter(store);
-      return adapter.detect();
-    }
-    default:
-      return null;
-  }
-}
-var PHASE_NODE_TYPES = {
-  implement: ["file", "function", "class", "method", "interface", "variable"],
-  review: ["adr", "document", "learning", "commit"],
-  debug: ["failure", "learning", "function", "method"],
-  plan: ["adr", "document", "module", "layer"]
-};
-var CODE_NODE_TYPES5 = /* @__PURE__ */ new Set([
-  "file",
-  "function",
-  "class",
-  "interface",
-  "method",
-  "variable"
-]);
-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);
-}
-var Assembler = class {
-  store;
-  vectorStore;
-  fusionLayer;
-  constructor(store, vectorStore) {
-    this.store = store;
-    this.vectorStore = vectorStore;
-  }
-  getFusionLayer() {
-    if (!this.fusionLayer) {
-      this.fusionLayer = new FusionLayer(this.store, this.vectorStore);
-    }
-    return this.fusionLayer;
-  }
-  /**
-   * Assemble context relevant to an intent string within a token budget.
-   */
-  assembleContext(intent, tokenBudget = 4e3) {
-    const fusion = this.getFusionLayer();
-    const topResults = fusion.search(intent, 10);
-    if (topResults.length === 0) {
-      return { nodes: [], edges: [], tokenEstimate: 0, intent, truncated: false };
-    }
-    const { nodeMap, collectedEdges, nodeScores } = this.expandSearchResults(topResults);
-    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
-      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
-    });
-    const { keptNodes, tokenEstimate, truncated } = this.truncateToFit(sortedNodes, tokenBudget);
-    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
-    const keptEdges = collectedEdges.filter(
-      (e) => keptNodeIds.has(e.from) && keptNodeIds.has(e.to)
-    );
-    return { nodes: keptNodes, edges: keptEdges, tokenEstimate, intent, truncated };
-  }
-  expandSearchResults(topResults) {
-    const contextQL = new ContextQL(this.store);
-    const nodeMap = /* @__PURE__ */ new Map();
-    const edgeSet = /* @__PURE__ */ new Set();
-    const collectedEdges = [];
-    const nodeScores = /* @__PURE__ */ new Map();
-    for (const result of topResults) {
-      nodeScores.set(result.nodeId, result.score);
-      const expanded = contextQL.execute({
-        rootNodeIds: [result.nodeId],
-        maxDepth: 2
-      });
-      for (const node of expanded.nodes) {
-        if (!nodeMap.has(node.id)) {
-          nodeMap.set(node.id, node);
-          if (!nodeScores.has(node.id)) {
-            nodeScores.set(node.id, result.score * 0.5);
-          }
-        }
-      }
-      for (const edge of expanded.edges) {
-        const key = `${edge.from}|${edge.to}|${edge.type}`;
-        if (!edgeSet.has(key)) {
-          edgeSet.add(key);
-          collectedEdges.push(edge);
-        }
-      }
-    }
-    return { nodeMap, collectedEdges, nodeScores };
-  }
-  truncateToFit(sortedNodes, tokenBudget) {
-    let tokenEstimate = 0;
-    const keptNodes = [];
-    let truncated = false;
-    for (const node of sortedNodes) {
-      const nodeTokens = estimateNodeTokens(node);
-      if (tokenEstimate + nodeTokens > tokenBudget && keptNodes.length > 0) {
-        truncated = true;
-        break;
-      }
-      tokenEstimate += nodeTokens;
-      keptNodes.push(node);
-    }
-    return { keptNodes, tokenEstimate, truncated };
-  }
-  /**
-   * Compute a token budget allocation across node types.
-   */
-  computeBudget(totalTokens, phase) {
-    const allNodes = this.store.findNodes({});
-    const typeCounts = {};
-    for (const node of allNodes) {
-      typeCounts[node.type] = (typeCounts[node.type] ?? 0) + 1;
-    }
-    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;
-    }
-    const boostTypes = phase ? PHASE_NODE_TYPES[phase] : void 0;
-    const boostFactor = 2;
-    let weightedTotal = 0;
-    const weights = {};
-    for (const [type, count] of Object.entries(typeCounts)) {
-      const isBoosted = boostTypes?.includes(type);
-      const weight = count * (isBoosted ? boostFactor : 1);
-      weights[type] = weight;
-      weightedTotal += weight;
-    }
-    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;
-        }
-      }
-    }
-    return { total: totalTokens, allocations, density };
-  }
-  /**
-   * Filter graph nodes relevant to a development phase.
-   */
-  filterForPhase(phase) {
-    const nodeTypes = PHASE_NODE_TYPES[phase];
-    if (!nodeTypes) {
-      console.warn(
-        `[harness] Unknown phase "${phase}" in filterForPhase. Returning all code nodes.`
-      );
-    }
-    const relevantTypes = nodeTypes ?? PHASE_NODE_TYPES["implement"] ?? [];
-    const nodes = [];
-    const filePathSet = /* @__PURE__ */ new Set();
-    for (const type of relevantTypes) {
-      const found = this.store.findNodes({ type });
-      for (const node of found) {
-        nodes.push(node);
-        if (node.path) {
-          filePathSet.add(node.path);
-        }
-      }
-    }
-    return {
-      phase,
-      nodes,
-      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 };
-    });
-    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)`);
-          }
-        }
-        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 };
-    });
-    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("");
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Check documentation coverage of code nodes.
-   */
-  checkCoverage() {
-    const codeNodes = [];
-    for (const type of CODE_NODE_TYPES5) {
-      codeNodes.push(...this.store.findNodes({ type }));
-    }
-    const documented = [];
-    const undocumented = [];
-    for (const node of codeNodes) {
-      const documentsEdges = this.store.getEdges({ to: node.id, type: "documents" });
-      if (documentsEdges.length > 0) {
-        documented.push(node.id);
-      } else {
-        undocumented.push(node.id);
-      }
-    }
-    const totalCodeNodes = codeNodes.length;
-    const coveragePercentage = totalCodeNodes > 0 ? documented.length / totalCodeNodes * 100 : 0;
-    return {
-      documented,
-      undocumented,
-      coveragePercentage,
-      totalCodeNodes
-    };
-  }
-};
-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) => {
-    if (options?.specPath && node.metadata?.specPath !== options.specPath) return false;
-    if (options?.featureName && node.metadata?.featureName !== options.featureName) return false;
-    return true;
-  });
-  if (filtered.length === 0) return [];
-  const groups = /* @__PURE__ */ new Map();
-  for (const req of filtered) {
-    const meta = req.metadata;
-    const specPath = meta?.specPath ?? "";
-    const featureName = meta?.featureName ?? "";
-    const key = `${specPath}\0${featureName}`;
-    const list = groups.get(key);
-    if (list) {
-      list.push(req);
-    } else {
-      groups.set(key, [req]);
-    }
-  }
-  const results = [];
-  for (const [, reqs] of groups) {
-    const firstReq = reqs[0];
-    const firstMeta = firstReq.metadata;
-    const specPath = firstMeta?.specPath ?? "";
-    const featureName = firstMeta?.featureName ?? "";
-    const requirements = reqs.map((req) => buildRequirementCoverage(store, req));
-    requirements.sort((a, b) => a.index - b.index);
-    results.push({
-      specPath,
-      featureName,
-      requirements,
-      summary: computeSummary(requirements)
-    });
-  }
-  return results;
-}
-var GraphConstraintAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  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 fromNode = this.store.getNode(e.from);
-      const toNode = this.store.getNode(e.to);
-      const fromPath = fromNode?.path ?? e.from;
-      const toPath = toNode?.path ?? e.to;
-      const importType = e.metadata?.importType ?? "static";
-      const line = e.metadata?.line ?? 0;
-      return { from: fromPath, to: toPath, importType, line };
-    });
-    return { nodes, edges };
-  }
-  computeLayerViolations(layers, rootDir) {
-    const { edges } = this.computeDependencyGraph();
-    const violations = [];
-    for (const edge of edges) {
-      const fromRelative = relative2(rootDir, edge.from).replaceAll("\\", "/");
-      const toRelative = relative2(rootDir, edge.to).replaceAll("\\", "/");
-      const fromLayer = this.resolveLayer(fromRelative, layers);
-      const toLayer = this.resolveLayer(toRelative, layers);
-      if (!fromLayer || !toLayer) continue;
-      if (fromLayer.name === toLayer.name) continue;
-      if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
-        violations.push({
-          file: edge.from,
-          imports: edge.to,
-          fromLayer: fromLayer.name,
-          toLayer: toLayer.name,
-          reason: "WRONG_LAYER",
-          line: edge.line
-        });
-      }
-    }
-    return violations;
-  }
-  resolveLayer(filePath, layers) {
-    for (const layer of layers) {
-      for (const pattern of layer.patterns) {
-        if (minimatch(filePath, pattern)) {
-          return layer;
-        }
-      }
-    }
-    return void 0;
-  }
-};
-function isDTCGToken(obj) {
-  return typeof obj === "object" && obj !== null && "$value" in obj && "$type" in obj;
-}
-async function readFileOrNull(filePath) {
-  try {
-    return await fs5.readFile(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function parseJsonOrError(content, filePath) {
-  try {
-    return { data: JSON.parse(content) };
-  } catch (err) {
-    return {
-      error: `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-}
-function walkDTCGTokens(store, obj, groupPath, topGroup, tokensPath) {
-  let count = 0;
-  for (const [key, value] of Object.entries(obj)) {
-    if (key.startsWith("$")) continue;
-    if (isDTCGToken(value)) {
-      const tokenPath = [...groupPath, key].join(".");
-      store.addNode({
-        id: `design_token:${tokenPath}`,
-        type: "design_token",
-        name: tokenPath,
-        path: tokensPath,
-        metadata: {
-          tokenType: value.$type,
-          value: value.$value,
-          group: topGroup || groupPath[0] || key,
-          ...value.$description ? { description: value.$description } : {}
-        }
-      });
-      count++;
-    } else if (typeof value === "object" && value !== null) {
-      count += walkDTCGTokens(
-        store,
-        value,
-        [...groupPath, key],
-        topGroup || key,
-        tokensPath
-      );
-    }
-  }
-  return count;
-}
-function parseAestheticDirection(content) {
-  const extract = (pattern) => {
-    const m = content.match(pattern);
-    return m ? m[1].trim() : void 0;
-  };
-  const result = {};
-  const style = extract(/\*\*Style:\*\*\s*(.+)/);
-  if (style !== void 0) result.style = style;
-  const tone = extract(/\*\*Tone:\*\*\s*(.+)/);
-  if (tone !== void 0) result.tone = tone;
-  const differentiator = extract(/\*\*Differentiator:\*\*\s*(.+)/);
-  if (differentiator !== void 0) result.differentiator = differentiator;
-  const strictness = extract(/^level:\s*(strict|standard|permissive)\s*$/m);
-  if (strictness !== void 0) result.strictness = strictness;
-  return result;
-}
-function parseAntiPatterns(content) {
-  const lines = content.split("\n");
-  const patterns = [];
-  let inSection = false;
-  for (const line of lines) {
-    if (/^##\s+Anti-Patterns/i.test(line)) {
-      inSection = true;
-      continue;
-    }
-    if (inSection && /^##\s+/.test(line)) {
-      break;
-    }
-    if (inSection) {
-      const bulletMatch = line.match(/^-\s+(.+)/);
-      if (bulletMatch) {
-        patterns.push(bulletMatch[1].trim());
-      }
-    }
-  }
-  return patterns;
-}
-var DesignIngestor = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  async ingestTokens(tokensPath) {
-    const start = Date.now();
-    const content = await readFileOrNull(tokensPath);
-    if (content === null) return emptyResult(Date.now() - start);
-    const parsed = parseJsonOrError(content, tokensPath);
-    if ("error" in parsed) {
-      return { ...emptyResult(Date.now() - start), errors: [parsed.error] };
-    }
-    const nodesAdded = walkDTCGTokens(this.store, parsed.data, [], "", tokensPath);
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded: 0,
-      edgesUpdated: 0,
-      errors: [],
-      durationMs: Date.now() - start
-    };
-  }
-  async ingestDesignIntent(designPath) {
-    const start = Date.now();
-    const content = await readFileOrNull(designPath);
-    if (content === null) return emptyResult(Date.now() - start);
-    let nodesAdded = 0;
-    const direction = parseAestheticDirection(content);
-    const metadata = {};
-    if (direction.style) metadata.style = direction.style;
-    if (direction.tone) metadata.tone = direction.tone;
-    if (direction.differentiator) metadata.differentiator = direction.differentiator;
-    if (direction.strictness) metadata.strictness = direction.strictness;
-    this.store.addNode({
-      id: "aesthetic_intent:project",
-      type: "aesthetic_intent",
-      name: "project",
-      path: designPath,
-      metadata
-    });
-    nodesAdded++;
-    for (const text of parseAntiPatterns(content)) {
-      this.store.addNode({
-        id: `design_constraint:${hash(text)}`,
-        type: "design_constraint",
-        name: text,
-        path: designPath,
-        metadata: { rule: text, severity: "warn", scope: "project" }
-      });
-      nodesAdded++;
-    }
-    return {
-      nodesAdded,
-      nodesUpdated: 0,
-      edgesAdded: 0,
-      edgesUpdated: 0,
-      errors: [],
-      durationMs: Date.now() - start
-    };
-  }
-  async ingestAll(designDir) {
-    const start = Date.now();
-    const [tokensResult, intentResult] = await Promise.all([
-      this.ingestTokens(path6.join(designDir, "tokens.json")),
-      this.ingestDesignIntent(path6.join(designDir, "DESIGN.md"))
-    ]);
-    const merged = mergeResults(tokensResult, intentResult);
-    return { ...merged, durationMs: Date.now() - start };
-  }
-};
-var DesignConstraintAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  checkForHardcodedColors(source, file, strictness) {
-    const severity = this.mapSeverity(strictness);
-    const tokenNodes = this.store.findNodes({ type: "design_token" });
-    const colorValues = /* @__PURE__ */ new Set();
-    for (const node of tokenNodes) {
-      if (node.metadata.tokenType === "color" && typeof node.metadata.value === "string") {
-        colorValues.add(node.metadata.value.toLowerCase());
-      }
-    }
-    const hexPattern = /#[0-9a-fA-F]{3,8}\b/g;
-    const violations = [];
-    let match;
-    while ((match = hexPattern.exec(source)) !== null) {
-      const hexValue = match[0];
-      if (!colorValues.has(hexValue.toLowerCase())) {
-        violations.push({
-          code: "DESIGN-001",
-          file,
-          message: `Hardcoded color ${hexValue} is not in the design token set`,
-          severity,
-          value: hexValue
-        });
-      }
-    }
-    return violations;
-  }
-  checkForHardcodedFonts(source, file, strictness) {
-    const severity = this.mapSeverity(strictness);
-    const tokenNodes = this.store.findNodes({ type: "design_token" });
-    const fontFamilies = /* @__PURE__ */ new Set();
-    for (const node of tokenNodes) {
-      if (node.metadata.tokenType === "typography") {
-        const value = node.metadata.value;
-        if (typeof value === "object" && value !== null && "fontFamily" in value) {
-          fontFamilies.add(value.fontFamily.toLowerCase());
-        }
-      }
-    }
-    const fontPatterns = [/fontFamily:\s*['"]([^'"]+)['"]/g, /font-family:\s*['"]([^'"]+)['"]/g];
-    const violations = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const pattern of fontPatterns) {
-      let match;
-      while ((match = pattern.exec(source)) !== null) {
-        const fontName = match[1];
-        if (seen.has(fontName.toLowerCase())) continue;
-        seen.add(fontName.toLowerCase());
-        if (!fontFamilies.has(fontName.toLowerCase())) {
-          violations.push({
-            code: "DESIGN-002",
-            file,
-            message: `Hardcoded font family "${fontName}" is not in the design token set`,
-            severity,
-            value: fontName
-          });
-        }
-      }
-    }
-    return violations;
-  }
-  checkAll(source, file, strictness) {
-    return [
-      ...this.checkForHardcodedColors(source, file, strictness),
-      ...this.checkForHardcodedFonts(source, file, strictness)
-    ];
-  }
-  mapSeverity(strictness = "standard") {
-    switch (strictness) {
-      case "permissive":
-        return "info";
-      case "standard":
-        return "warn";
-      case "strict":
-        return "error";
-    }
-  }
-};
-var GraphFeedbackAdapter = class {
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  computeImpactData(changedFiles) {
-    const affectedTests = [];
-    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
-          });
-        }
-      }
-    }
-    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++;
-      }
-    }
-    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++;
-        }
-      }
-    }
-    return {
-      graphExists: true,
-      nodeCount,
-      edgeCount,
-      constraintViolations,
-      undocumentedFiles,
-      unreachableNodes
-    };
-  }
-};
-var DEFAULT_EDGE_TYPES = ["imports", "calls", "references"];
-var TaskIndependenceAnalyzer = class {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  analyze(params) {
-    const { tasks } = params;
-    const depth = params.depth ?? 1;
-    const edgeTypes = params.edgeTypes ?? DEFAULT_EDGE_TYPES;
-    this.validate(tasks);
-    const useGraph = this.store != null && depth > 0;
-    const analysisLevel = useGraph ? "graph-expanded" : "file-only";
-    const originalFiles = /* @__PURE__ */ new Map();
-    const expandedFiles = /* @__PURE__ */ new Map();
-    for (const task of tasks) {
-      const origSet = new Set(task.files);
-      originalFiles.set(task.id, origSet);
-      if (useGraph) {
-        const expanded = this.expandViaGraph(task.files, depth, edgeTypes);
-        expandedFiles.set(task.id, expanded);
-      } else {
-        expandedFiles.set(task.id, /* @__PURE__ */ new Map());
-      }
-    }
-    const taskIds = tasks.map((t) => t.id);
-    const pairs = [];
-    for (let i = 0; i < taskIds.length; i++) {
-      for (let j = i + 1; j < taskIds.length; j++) {
-        const idA = taskIds[i];
-        const idB = taskIds[j];
-        const pair = this.computePairOverlap(
-          idA,
-          idB,
-          originalFiles.get(idA),
-          originalFiles.get(idB),
-          expandedFiles.get(idA),
-          expandedFiles.get(idB)
-        );
-        pairs.push(pair);
-      }
-    }
-    const groups = this.buildGroups(taskIds, pairs);
-    const verdict = this.generateVerdict(taskIds, groups, analysisLevel);
-    return {
-      tasks: taskIds,
-      analysisLevel,
-      depth,
-      pairs,
-      groups,
-      verdict
-    };
-  }
-  // --- Private methods ---
-  validate(tasks) {
-    if (tasks.length < 2) {
-      throw new Error("At least 2 tasks are required for independence analysis");
-    }
-    const seenIds = /* @__PURE__ */ new Set();
-    for (const task of tasks) {
-      if (seenIds.has(task.id)) {
-        throw new Error(`Duplicate task ID: "${task.id}"`);
-      }
-      seenIds.add(task.id);
-      if (task.files.length === 0) {
-        throw new Error(`Task "${task.id}" has an empty files array`);
-      }
-    }
-  }
-  expandViaGraph(files, depth, edgeTypes) {
-    const result = /* @__PURE__ */ new Map();
-    const store = this.store;
-    const cql = new ContextQL(store);
-    const fileSet = new Set(files);
-    for (const file of files) {
-      const nodeId = `file:${file}`;
-      const node = store.getNode(nodeId);
-      if (!node) continue;
-      const queryResult = cql.execute({
-        rootNodeIds: [nodeId],
-        maxDepth: depth,
-        includeEdges: edgeTypes,
-        includeTypes: ["file"]
-      });
-      for (const n of queryResult.nodes) {
-        const path7 = n.path ?? n.id.replace(/^file:/, "");
-        if (!fileSet.has(path7)) {
-          if (!result.has(path7)) {
-            result.set(path7, file);
-          }
-        }
-      }
-    }
-    return result;
-  }
-  computePairOverlap(idA, idB, origA, origB, expandedA, expandedB) {
-    const overlaps = [];
-    for (const file of origA) {
-      if (origB.has(file)) {
-        overlaps.push({ file, type: "direct" });
-      }
-    }
-    const directFiles = new Set(overlaps.map((o) => o.file));
-    const transitiveFiles = /* @__PURE__ */ new Set();
-    for (const [file, via] of expandedA) {
-      if (origB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
-        transitiveFiles.add(file);
-        overlaps.push({ file, type: "transitive", via });
-      }
-    }
-    for (const [file, via] of expandedB) {
-      if (origA.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
-        transitiveFiles.add(file);
-        overlaps.push({ file, type: "transitive", via });
-      }
-    }
-    for (const [file, viaA] of expandedA) {
-      if (expandedB.has(file) && !directFiles.has(file) && !transitiveFiles.has(file)) {
-        transitiveFiles.add(file);
-        overlaps.push({ file, type: "transitive", via: viaA });
-      }
-    }
-    return {
-      taskA: idA,
-      taskB: idB,
-      independent: overlaps.length === 0,
-      overlaps
-    };
-  }
-  buildGroups(taskIds, pairs) {
-    const parent = /* @__PURE__ */ new Map();
-    const rank = /* @__PURE__ */ new Map();
-    for (const id of taskIds) {
-      parent.set(id, id);
-      rank.set(id, 0);
-    }
-    const find = (x) => {
-      let root = x;
-      while (parent.get(root) !== root) {
-        root = parent.get(root);
-      }
-      let current = x;
-      while (current !== root) {
-        const next = parent.get(current);
-        parent.set(current, root);
-        current = next;
-      }
-      return root;
-    };
-    const union = (a, b) => {
-      const rootA = find(a);
-      const rootB = find(b);
-      if (rootA === rootB) return;
-      const rankA = rank.get(rootA);
-      const rankB = rank.get(rootB);
-      if (rankA < rankB) {
-        parent.set(rootA, rootB);
-      } else if (rankA > rankB) {
-        parent.set(rootB, rootA);
-      } else {
-        parent.set(rootB, rootA);
-        rank.set(rootA, rankA + 1);
-      }
-    };
-    for (const pair of pairs) {
-      if (!pair.independent) {
-        union(pair.taskA, pair.taskB);
-      }
-    }
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const id of taskIds) {
-      const root = find(id);
-      if (!groupMap.has(root)) {
-        groupMap.set(root, []);
-      }
-      groupMap.get(root).push(id);
-    }
-    return Array.from(groupMap.values());
-  }
-  generateVerdict(taskIds, groups, analysisLevel) {
-    const total = taskIds.length;
-    const groupCount = groups.length;
-    let verdict;
-    if (groupCount === 1) {
-      verdict = `All ${total} tasks conflict \u2014 must run serially.`;
-    } else if (groupCount === total) {
-      verdict = `All ${total} tasks are independent \u2014 can all run in parallel.`;
-    } else {
-      verdict = `${total} tasks form ${groupCount} independent groups \u2014 ${groupCount} parallel waves possible.`;
-    }
-    if (analysisLevel === "file-only") {
-      verdict += " Graph unavailable \u2014 transitive dependencies not checked.";
-    }
-    return verdict;
-  }
-};
-var ConflictPredictor = class {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  predict(params) {
-    const analyzer = new TaskIndependenceAnalyzer(this.store);
-    const result = analyzer.analyze(params);
-    const churnMap = /* @__PURE__ */ new Map();
-    const couplingMap = /* @__PURE__ */ new Map();
-    let churnThreshold = Infinity;
-    let couplingThreshold = Infinity;
-    if (this.store != null) {
-      const complexityResult = new GraphComplexityAdapter(this.store).computeComplexityHotspots();
-      for (const hotspot of complexityResult.hotspots) {
-        const existing = churnMap.get(hotspot.file);
-        if (existing === void 0 || hotspot.changeFrequency > existing) {
-          churnMap.set(hotspot.file, hotspot.changeFrequency);
-        }
-      }
-      const couplingResult = new GraphCouplingAdapter(this.store).computeCouplingData();
-      for (const fileData of couplingResult.files) {
-        couplingMap.set(fileData.file, fileData.fanIn + fileData.fanOut);
-      }
-      churnThreshold = this.computePercentile(Array.from(churnMap.values()), 80);
-      couplingThreshold = this.computePercentile(Array.from(couplingMap.values()), 80);
-    }
-    const conflicts = [];
-    for (const pair of result.pairs) {
-      if (pair.independent) continue;
-      const { severity, reason, mitigation } = this.classifyPair(
-        pair.taskA,
-        pair.taskB,
-        pair.overlaps,
-        churnMap,
-        couplingMap,
-        churnThreshold,
-        couplingThreshold
-      );
-      conflicts.push({
-        taskA: pair.taskA,
-        taskB: pair.taskB,
-        severity,
-        reason,
-        mitigation,
-        overlaps: pair.overlaps
-      });
-    }
-    const taskIds = result.tasks;
-    const groups = this.buildHighSeverityGroups(taskIds, conflicts);
-    const regrouped = !this.groupsEqual(result.groups, groups);
-    let highCount = 0;
-    let mediumCount = 0;
-    let lowCount = 0;
-    for (const c of conflicts) {
-      if (c.severity === "high") highCount++;
-      else if (c.severity === "medium") mediumCount++;
-      else lowCount++;
-    }
-    const verdict = this.generateVerdict(
-      taskIds,
-      groups,
-      result.analysisLevel,
-      highCount,
-      mediumCount,
-      lowCount,
-      regrouped
-    );
-    return {
-      tasks: taskIds,
-      analysisLevel: result.analysisLevel,
-      depth: result.depth,
-      conflicts,
-      groups,
-      summary: {
-        high: highCount,
-        medium: mediumCount,
-        low: lowCount,
-        regrouped
-      },
-      verdict
-    };
-  }
-  // --- Private helpers ---
-  classifyPair(taskA, taskB, overlaps, churnMap, couplingMap, churnThreshold, couplingThreshold) {
-    let maxSeverity = "low";
-    let primaryReason = "";
-    let primaryMitigation = "";
-    for (const overlap of overlaps) {
-      let overlapSeverity;
-      let reason;
-      let mitigation;
-      if (overlap.type === "direct") {
-        overlapSeverity = "high";
-        reason = `Both tasks write to ${overlap.file}`;
-        mitigation = `Serialize: run ${taskA} before ${taskB}`;
-      } else {
-        const churn = churnMap.get(overlap.file);
-        const coupling = couplingMap.get(overlap.file);
-        const via = overlap.via ?? "unknown";
-        if (churn !== void 0 && churn >= churnThreshold && churnThreshold !== Infinity) {
-          overlapSeverity = "medium";
-          reason = `Transitive overlap on high-churn file ${overlap.file} (via ${via})`;
-          mitigation = `Review: ${overlap.file} changes frequently \u2014 coordinate edits between ${taskA} and ${taskB}`;
-        } else if (coupling !== void 0 && coupling >= couplingThreshold && couplingThreshold !== Infinity) {
-          overlapSeverity = "medium";
-          reason = `Transitive overlap on highly-coupled file ${overlap.file} (via ${via})`;
-          mitigation = `Review: ${overlap.file} has high coupling \u2014 coordinate edits between ${taskA} and ${taskB}`;
-        } else {
-          overlapSeverity = "low";
-          reason = `Transitive overlap on ${overlap.file} (via ${via}) \u2014 low risk`;
-          mitigation = `Info: transitive overlap unlikely to cause conflicts`;
-        }
-      }
-      if (this.severityRank(overlapSeverity) > this.severityRank(maxSeverity)) {
-        maxSeverity = overlapSeverity;
-        primaryReason = reason;
-        primaryMitigation = mitigation;
-      } else if (primaryReason === "") {
-        primaryReason = reason;
-        primaryMitigation = mitigation;
-      }
-    }
-    return { severity: maxSeverity, reason: primaryReason, mitigation: primaryMitigation };
-  }
-  severityRank(severity) {
-    switch (severity) {
-      case "high":
-        return 3;
-      case "medium":
-        return 2;
-      case "low":
-        return 1;
-    }
-  }
-  computePercentile(values, percentile) {
-    if (values.length === 0) return Infinity;
-    const sorted = [...values].sort((a, b) => a - b);
-    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
-    return sorted[Math.min(index, sorted.length - 1)];
-  }
-  buildHighSeverityGroups(taskIds, conflicts) {
-    const parent = /* @__PURE__ */ new Map();
-    const rank = /* @__PURE__ */ new Map();
-    for (const id of taskIds) {
-      parent.set(id, id);
-      rank.set(id, 0);
-    }
-    const find = (x) => {
-      let root = x;
-      while (parent.get(root) !== root) {
-        root = parent.get(root);
-      }
-      let current = x;
-      while (current !== root) {
-        const next = parent.get(current);
-        parent.set(current, root);
-        current = next;
-      }
-      return root;
-    };
-    const union = (a, b) => {
-      const rootA = find(a);
-      const rootB = find(b);
-      if (rootA === rootB) return;
-      const rankA = rank.get(rootA);
-      const rankB = rank.get(rootB);
-      if (rankA < rankB) {
-        parent.set(rootA, rootB);
-      } else if (rankA > rankB) {
-        parent.set(rootB, rootA);
-      } else {
-        parent.set(rootB, rootA);
-        rank.set(rootA, rankA + 1);
-      }
-    };
-    for (const conflict of conflicts) {
-      if (conflict.severity === "high") {
-        union(conflict.taskA, conflict.taskB);
-      }
-    }
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const id of taskIds) {
-      const root = find(id);
-      let group = groupMap.get(root);
-      if (group === void 0) {
-        group = [];
-        groupMap.set(root, group);
-      }
-      group.push(id);
-    }
-    return Array.from(groupMap.values());
-  }
-  groupsEqual(a, b) {
-    if (a.length !== b.length) return false;
-    const normalize2 = (groups) => groups.map((g) => [...g].sort()).sort((x, y) => {
-      const xFirst = x[0];
-      const yFirst = y[0];
-      return xFirst.localeCompare(yFirst);
-    });
-    const normA = normalize2(a);
-    const normB = normalize2(b);
-    for (let i = 0; i < normA.length; i++) {
-      const groupA = normA[i];
-      const groupB = normB[i];
-      if (groupA.length !== groupB.length) return false;
-      for (let j = 0; j < groupA.length; j++) {
-        if (groupA[j] !== groupB[j]) return false;
-      }
-    }
-    return true;
-  }
-  generateVerdict(taskIds, groups, analysisLevel, highCount, mediumCount, lowCount, regrouped) {
-    const total = taskIds.length;
-    const groupCount = groups.length;
-    const parts = [];
-    const conflictParts = [];
-    if (highCount > 0) conflictParts.push(`${highCount} high`);
-    if (mediumCount > 0) conflictParts.push(`${mediumCount} medium`);
-    if (lowCount > 0) conflictParts.push(`${lowCount} low`);
-    if (conflictParts.length === 0) {
-      parts.push(`${total} tasks have no conflicts \u2014 can all run in parallel.`);
-    } else {
-      parts.push(`${total} tasks have ${conflictParts.join(", ")} severity conflicts.`);
-    }
-    if (groupCount === 1) {
-      parts.push(`All tasks must run serially.`);
-    } else if (groupCount === total) {
-      parts.push(`${groupCount} parallel groups (all independent).`);
-    } else {
-      parts.push(`${groupCount} parallel groups possible.`);
-    }
-    if (regrouped) {
-      parts.push(`Tasks were regrouped due to high-severity conflicts.`);
-    }
-    if (analysisLevel === "file-only") {
-      parts.push(`Graph unavailable \u2014 severity based on file overlaps only.`);
-    }
-    return parts.join(" ");
-  }
-};
-var VERSION = "0.4.0";
-
-export {
-  NODE_TYPES,
-  EDGE_TYPES,
-  OBSERVABILITY_TYPES,
-  CURRENT_SCHEMA_VERSION,
-  GraphNodeSchema,
-  GraphEdgeSchema,
-  saveGraph,
-  loadGraph,
-  GraphStore,
-  VectorStore,
-  ContextQL,
-  project,
-  classifyNodeCategory,
-  groupNodesByImpact,
-  CodeIngestor,
-  GitIngestor,
-  TopologicalLinker,
-  KnowledgeIngestor,
-  RequirementIngestor,
-  linkToCode,
-  SyncManager,
-  JiraConnector,
-  SlackConnector,
-  ConfluenceConnector,
-  CIConnector,
-  FusionLayer,
-  GraphEntropyAdapter,
-  GraphComplexityAdapter,
-  GraphCouplingAdapter,
-  GraphAnomalyAdapter,
-  INTENTS,
-  IntentClassifier,
-  EntityExtractor,
-  EntityResolver,
-  ResponseFormatter,
-  CompositeProbabilityStrategy,
-  CascadeSimulator,
-  askGraph,
-  Assembler,
-  queryTraceability,
-  GraphConstraintAdapter,
-  DesignIngestor,
-  DesignConstraintAdapter,
-  GraphFeedbackAdapter,
-  TaskIndependenceAnalyzer,
-  ConflictPredictor,
-  VERSION
-};