@harness-engineering/cli 1.6.0 → 1.6.2

package/dist/dist-4MYPT3OE.js

@@ -0,0 +1,2528 @@
+// ../graph/dist/index.mjs
+import { z } from "zod";
+import loki from "lokijs";
+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 { minimatch } from "minimatch";
+import { relative as relative2 } 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"
+];
+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"
+];
+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 GraphStore = class {
+  db;
+  nodes;
+  edges;
+  constructor() {
+    this.db = new loki("graph.db");
+    this.nodes = this.db.addCollection("nodes", {
+      unique: ["id"],
+      indices: ["type", "name"]
+    });
+    this.edges = this.db.addCollection("edges", {
+      indices: ["from", "to", "type"]
+    });
+  }
+  // --- Node operations ---
+  addNode(node) {
+    const existing = this.nodes.by("id", node.id);
+    if (existing) {
+      Object.assign(existing, node);
+      this.nodes.update(existing);
+    } else {
+      this.nodes.insert({ ...node });
+    }
+  }
+  batchAddNodes(nodes) {
+    for (const node of nodes) {
+      this.addNode(node);
+    }
+  }
+  getNode(id) {
+    const doc = this.nodes.by("id", id);
+    if (!doc) return null;
+    return this.stripLokiMeta(doc);
+  }
+  findNodes(query) {
+    const lokiQuery = {};
+    if (query.type !== void 0) lokiQuery["type"] = query.type;
+    if (query.name !== void 0) lokiQuery["name"] = query.name;
+    if (query.path !== void 0) lokiQuery["path"] = query.path;
+    return this.nodes.find(lokiQuery).map((doc) => this.stripLokiMeta(doc));
+  }
+  removeNode(id) {
+    const doc = this.nodes.by("id", id);
+    if (doc) {
+      this.nodes.remove(doc);
+    }
+    const edgesToRemove = this.edges.find({
+      $or: [{ from: id }, { to: id }]
+    });
+    for (const edge of edgesToRemove) {
+      this.edges.remove(edge);
+    }
+  }
+  // --- Edge operations ---
+  addEdge(edge) {
+    const existing = this.edges.findOne({
+      from: edge.from,
+      to: edge.to,
+      type: edge.type
+    });
+    if (existing) {
+      if (edge.metadata) {
+        Object.assign(existing, edge);
+        this.edges.update(existing);
+      }
+      return;
+    }
+    this.edges.insert({ ...edge });
+  }
+  batchAddEdges(edges) {
+    for (const edge of edges) {
+      this.addEdge(edge);
+    }
+  }
+  getEdges(query) {
+    const lokiQuery = {};
+    if (query.from !== void 0) lokiQuery["from"] = query.from;
+    if (query.to !== void 0) lokiQuery["to"] = query.to;
+    if (query.type !== void 0) lokiQuery["type"] = query.type;
+    return this.edges.find(lokiQuery).map((doc) => this.stripLokiMeta(doc));
+  }
+  getNeighbors(nodeId, direction = "both") {
+    const neighborIds = /* @__PURE__ */ new Set();
+    if (direction === "outbound" || direction === "both") {
+      const outEdges = this.edges.find({ from: nodeId });
+      for (const edge of outEdges) {
+        neighborIds.add(edge.to);
+      }
+    }
+    if (direction === "inbound" || direction === "both") {
+      const inEdges = this.edges.find({ to: 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.nodes.count();
+  }
+  get edgeCount() {
+    return this.edges.count();
+  }
+  // --- Clear ---
+  clear() {
+    this.nodes.clear();
+    this.edges.clear();
+  }
+  // --- Persistence ---
+  async save(dirPath) {
+    const allNodes = this.nodes.find().map((doc) => this.stripLokiMeta(doc));
+    const allEdges = this.edges.find().map((doc) => this.stripLokiMeta(doc));
+    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.nodes.insert({ ...node });
+    }
+    for (const edge of data.edges) {
+      this.edges.insert({ ...edge });
+    }
+    return true;
+  }
+  // --- Internal ---
+  stripLokiMeta(doc) {
+    const { $loki: _, meta: _meta, ...rest } = doc;
+    return rest;
+  }
+};
+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;
+  }
+};
+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 visited = /* @__PURE__ */ new Set();
+    const resultNodeMap = /* @__PURE__ */ new Map();
+    const resultEdges = [];
+    const edgeSet = /* @__PURE__ */ new Set();
+    let pruned = 0;
+    let depthReached = 0;
+    const edgeKey = (e) => `${e.from}|${e.to}|${e.type}`;
+    const addEdge = (edge) => {
+      const key = edgeKey(edge);
+      if (!edgeSet.has(key)) {
+        edgeSet.add(key);
+        resultEdges.push(edge);
+      }
+    };
+    const queue = [];
+    for (const rootId of params.rootNodeIds) {
+      const node = this.store.getNode(rootId);
+      if (node) {
+        visited.add(rootId);
+        resultNodeMap.set(rootId, node);
+        queue.push({ id: rootId, depth: 0 });
+      }
+    }
+    let head = 0;
+    while (head < queue.length) {
+      const entry = queue[head++];
+      const { id: currentId, depth } = entry;
+      if (depth >= maxDepth) continue;
+      const nextDepth = depth + 1;
+      if (nextDepth > depthReached) depthReached = nextDepth;
+      const outEdges = this.store.getEdges({ from: currentId });
+      const inEdges = bidirectional ? this.store.getEdges({ to: currentId }) : [];
+      const allEdges = [
+        ...outEdges.map((e) => ({ edge: e, neighborId: e.to })),
+        ...inEdges.map((e) => ({ edge: e, neighborId: e.from }))
+      ];
+      for (const { edge, neighborId } of allEdges) {
+        if (params.includeEdges && !params.includeEdges.includes(edge.type)) {
+          continue;
+        }
+        if (visited.has(neighborId)) {
+          addEdge(edge);
+          continue;
+        }
+        const neighbor = this.store.getNode(neighborId);
+        if (!neighbor) continue;
+        visited.add(neighborId);
+        if (pruneObservability && OBSERVABILITY_TYPES.has(neighbor.type)) {
+          pruned++;
+          continue;
+        }
+        if (params.includeTypes && !params.includeTypes.includes(neighbor.type)) {
+          pruned++;
+          continue;
+        }
+        if (params.excludeTypes && params.excludeTypes.includes(neighbor.type)) {
+          pruned++;
+          continue;
+        }
+        resultNodeMap.set(neighborId, neighbor);
+        addEdge(edge);
+        queue.push({ id: neighborId, depth: nextDepth });
+      }
+    }
+    const resultNodeIds = new Set(resultNodeMap.keys());
+    for (const nodeId of resultNodeIds) {
+      const outEdges = this.store.getEdges({ from: nodeId });
+      for (const edge of outEdges) {
+        if (resultNodeIds.has(edge.to)) {
+          addEdge(edge);
+        }
+      }
+    }
+    return {
+      nodes: Array.from(resultNodeMap.values()),
+      edges: resultEdges,
+      stats: {
+        totalTraversed: visited.size,
+        totalReturned: resultNodeMap.size,
+        pruned,
+        depthReached
+      }
+    };
+  }
+};
+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 CodeIngestor = class {
+  constructor(store) {
+    this.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 relativePath = path.relative(rootDir, filePath);
+        const content = await fs.readFile(filePath, "utf-8");
+        const stat2 = await fs.stat(filePath);
+        const fileId = `file:${relativePath}`;
+        fileContents.set(relativePath, content);
+        const fileNode = {
+          id: fileId,
+          type: "file",
+          name: path.basename(filePath),
+          path: relativePath,
+          metadata: { language: this.detectLanguage(filePath) },
+          lastModified: stat2.mtime.toISOString()
+        };
+        this.store.addNode(fileNode);
+        nodesAdded++;
+        const symbols = this.extractSymbols(content, fileId, relativePath);
+        for (const { node, edge } of symbols) {
+          this.store.addNode(node);
+          this.store.addEdge(edge);
+          nodesAdded++;
+          edgesAdded++;
+          if (node.type === "function" || node.type === "method") {
+            let files2 = nameToFiles.get(node.name);
+            if (!files2) {
+              files2 = /* @__PURE__ */ new Set();
+              nameToFiles.set(node.name, files2);
+            }
+            files2.add(relativePath);
+          }
+        }
+        const imports = await this.extractImports(content, fileId, relativePath, rootDir);
+        for (const edge of imports) {
+          this.store.addEdge(edge);
+          edgesAdded++;
+        }
+      } 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++;
+    }
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  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");
+    let currentClassName = null;
+    let currentClassId = null;
+    let braceDepth = 0;
+    let insideClass = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fnMatch) {
+        const name = fnMatch[1];
+        const id = `function:${relativePath}:${name}`;
+        const endLine = this.findClosingBrace(lines, i);
+        results.push({
+          node: {
+            id,
+            type: "function",
+            name,
+            path: relativePath,
+            location: { fileId, startLine: i + 1, endLine },
+            metadata: {
+              exported: line.includes("export"),
+              cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+              nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+              lineCount: endLine - i,
+              parameterCount: this.countParameters(line)
+            }
+          },
+          edge: { from: fileId, to: id, type: "contains" }
+        });
+        if (!insideClass) {
+          currentClassName = null;
+          currentClassId = null;
+        }
+        continue;
+      }
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) {
+        const name = classMatch[1];
+        const id = `class:${relativePath}:${name}`;
+        const endLine = this.findClosingBrace(lines, i);
+        results.push({
+          node: {
+            id,
+            type: "class",
+            name,
+            path: relativePath,
+            location: { fileId, startLine: i + 1, endLine },
+            metadata: { exported: line.includes("export") }
+          },
+          edge: { from: fileId, to: id, type: "contains" }
+        });
+        currentClassName = name;
+        currentClassId = id;
+        insideClass = true;
+        braceDepth = 0;
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        continue;
+      }
+      const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+      if (ifaceMatch) {
+        const name = ifaceMatch[1];
+        const id = `interface:${relativePath}:${name}`;
+        const endLine = this.findClosingBrace(lines, i);
+        results.push({
+          node: {
+            id,
+            type: "interface",
+            name,
+            path: relativePath,
+            location: { fileId, startLine: i + 1, endLine },
+            metadata: { exported: line.includes("export") }
+          },
+          edge: { from: fileId, to: id, type: "contains" }
+        });
+        currentClassName = null;
+        currentClassId = null;
+        insideClass = false;
+        continue;
+      }
+      if (insideClass) {
+        for (const ch of line) {
+          if (ch === "{") braceDepth++;
+          if (ch === "}") braceDepth--;
+        }
+        if (braceDepth <= 0) {
+          currentClassName = null;
+          currentClassId = null;
+          insideClass = false;
+          continue;
+        }
+      }
+      if (insideClass && currentClassName && currentClassId) {
+        const methodMatch = line.match(
+          /^\s+(?:(?:public|private|protected|readonly|static|abstract)\s+)*(?:async\s+)?(\w+)\s*\(/
+        );
+        if (methodMatch) {
+          const methodName = methodMatch[1];
+          if (methodName === "constructor" || methodName === "if" || methodName === "for" || methodName === "while" || methodName === "switch")
+            continue;
+          const id = `method:${relativePath}:${currentClassName}.${methodName}`;
+          const endLine = this.findClosingBrace(lines, i);
+          results.push({
+            node: {
+              id,
+              type: "method",
+              name: methodName,
+              path: relativePath,
+              location: { fileId, startLine: i + 1, endLine },
+              metadata: {
+                className: currentClassName,
+                exported: false,
+                cyclomaticComplexity: this.computeCyclomaticComplexity(lines.slice(i, endLine)),
+                nestingDepth: this.computeMaxNesting(lines.slice(i, endLine)),
+                lineCount: endLine - i,
+                parameterCount: this.countParameters(line)
+              }
+            },
+            edge: { from: currentClassId, to: id, type: "contains" }
+          });
+        }
+        continue;
+      }
+      const varMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)/);
+      if (varMatch) {
+        const name = varMatch[1];
+        const id = `variable:${relativePath}:${name}`;
+        results.push({
+          node: {
+            id,
+            type: "variable",
+            name,
+            path: relativePath,
+            location: { fileId, startLine: i + 1, endLine: i + 1 },
+            metadata: { exported: line.includes("export") }
+          },
+          edge: { from: fileId, to: id, type: "contains" }
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * 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));
+    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}`);
+      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";
+  }
+};
+var execFileAsync = promisify(execFile);
+var GitIngestor = class {
+  constructor(store, gitRunner) {
+    this.store = store;
+    this.gitRunner = 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;
+  }
+  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;
+  }
+};
+var CODE_NODE_TYPES = ["file", "function", "class", "method", "interface", "variable"];
+function hash(text) {
+  return crypto.createHash("md5").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 KnowledgeIngestor = class {
+  constructor(store) {
+    this.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 CODE_NODE_TYPES2 = ["file", "function", "class", "method", "interface", "variable"];
+function linkToCode(store, content, sourceNodeId, edgeType, options) {
+  let edgesCreated = 0;
+  for (const type of CODE_NODE_TYPES2) {
+    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 = path4.join(graphDir, "sync-metadata.json");
+  }
+  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 fs3.readFile(this.metadataPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { connectors: {} };
+    }
+  }
+  async saveMetadata(metadata) {
+    await fs3.mkdir(path4.dirname(this.metadataPath), { recursive: true });
+    await fs3.writeFile(this.metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+  }
+};
+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();
+    const errors = [];
+    let nodesAdded = 0;
+    let edgesAdded = 0;
+    const apiKeyEnv = config.apiKeyEnv ?? "JIRA_API_KEY";
+    const apiKey = process.env[apiKeyEnv];
+    if (!apiKey) {
+      return {
+        nodesAdded: 0,
+        nodesUpdated: 0,
+        edgesAdded: 0,
+        edgesUpdated: 0,
+        errors: [`Missing API key: environment variable "${apiKeyEnv}" is not set`],
+        durationMs: Date.now() - start
+      };
+    }
+    const baseUrlEnv = config.baseUrlEnv ?? "JIRA_BASE_URL";
+    const baseUrl = process.env[baseUrlEnv];
+    if (!baseUrl) {
+      return {
+        nodesAdded: 0,
+        nodesUpdated: 0,
+        edgesAdded: 0,
+        edgesUpdated: 0,
+        errors: [`Missing base URL: environment variable "${baseUrlEnv}" is not set`],
+        durationMs: Date.now() - start
+      };
+    }
+    const project2 = config.project;
+    let jql = project2 ? `project=${project2}` : "";
+    const filters = config.filters;
+    if (filters?.status?.length) {
+      jql += `${jql ? " AND " : ""}status IN (${filters.status.map((s) => `"${s}"`).join(",")})`;
+    }
+    if (filters?.labels?.length) {
+      jql += `${jql ? " AND " : ""}labels IN (${filters.labels.map((l) => `"${l}"`).join(",")})`;
+    }
+    const headers = {
+      Authorization: `Basic ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+    let startAt = 0;
+    const maxResults = 50;
+    let total = Infinity;
+    try {
+      while (startAt < total) {
+        const url = `${baseUrl}/rest/api/2/search?jql=${encodeURIComponent(jql)}&startAt=${startAt}&maxResults=${maxResults}`;
+        const response = await this.httpClient(url, { headers });
+        if (!response.ok) {
+          return {
+            nodesAdded,
+            nodesUpdated: 0,
+            edgesAdded,
+            edgesUpdated: 0,
+            errors: ["Jira API request failed"],
+            durationMs: Date.now() - start
+          };
+        }
+        const data = await response.json();
+        total = data.total;
+        for (const issue of data.issues) {
+          const nodeId = `issue:jira:${issue.key}`;
+          store.addNode({
+            id: nodeId,
+            type: "issue",
+            name: issue.fields.summary,
+            metadata: {
+              key: issue.key,
+              status: issue.fields.status?.name,
+              priority: issue.fields.priority?.name,
+              assignee: issue.fields.assignee?.displayName,
+              labels: issue.fields.labels ?? []
+            }
+          });
+          nodesAdded++;
+          const searchText = [issue.fields.summary, issue.fields.description ?? ""].join(" ");
+          edgesAdded += linkToCode(store, searchText, nodeId, "applies_to");
+        }
+        startAt += maxResults;
+      }
+    } catch (err) {
+      return {
+        nodesAdded,
+        nodesUpdated: 0,
+        edgesAdded,
+        edgesUpdated: 0,
+        errors: [`Jira API error: ${err instanceof Error ? err.message : String(err)}`],
+        durationMs: Date.now() - start
+      };
+    }
+    return {
+      nodesAdded,
+      nodesUpdated: 0,
+      edgesAdded,
+      edgesUpdated: 0,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+};
+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 {
+        let url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}`;
+        if (oldest) {
+          url += `&oldest=${oldest}`;
+        }
+        const response = await this.httpClient(url, {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          errors.push(`Slack API request failed for channel ${channel}`);
+          continue;
+        }
+        const data = await response.json();
+        if (!data.ok) {
+          errors.push(`Slack API error for channel ${channel}`);
+          continue;
+        }
+        for (const message of data.messages) {
+          const nodeId = `conversation:slack:${channel}:${message.ts}`;
+          const snippet = message.text.length > 100 ? message.text.slice(0, 100) : message.text;
+          store.addNode({
+            id: nodeId,
+            type: "conversation",
+            name: snippet,
+            metadata: {
+              author: message.user,
+              channel,
+              timestamp: message.ts
+            }
+          });
+          nodesAdded++;
+          edgesAdded += linkToCode(store, message.text, nodeId, "references", { checkPaths: true });
+        }
+      } 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
+    };
+  }
+};
+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 {
+      let nextUrl = `${baseUrl}/wiki/api/v2/pages?spaceKey=${encodeURIComponent(spaceKey)}&limit=25&body-format=storage`;
+      while (nextUrl) {
+        const response = await this.httpClient(nextUrl, {
+          headers: { Authorization: `Bearer ${apiKey}` }
+        });
+        if (!response.ok) {
+          errors.push(`Confluence API error: status ${response.status}`);
+          break;
+        }
+        const data = await response.json();
+        for (const page of data.results) {
+          const nodeId = `confluence:${page.id}`;
+          store.addNode({
+            id: nodeId,
+            type: "document",
+            name: page.title,
+            metadata: {
+              source: "confluence",
+              spaceKey,
+              pageId: page.id,
+              status: page.status,
+              url: page._links?.webui ?? ""
+            }
+          });
+          nodesAdded++;
+          const text = `${page.title} ${page.body?.storage?.value ?? ""}`;
+          edgesAdded += linkToCode(store, text, nodeId, "documents");
+        }
+        nextUrl = data._links?.next ? `${baseUrl}${data._links.next}` : null;
+      }
+    } 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
+    };
+  }
+};
+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}`;
+        store.addNode({
+          id: buildId,
+          type: "build",
+          name: `${run.name} #${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: ${run.name} #${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_TYPES3 = ["file", "function", "class", "method", "interface", "variable"];
+var GraphEntropyAdapter = class {
+  constructor(store) {
+    this.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 allFileNodes = this.store.findNodes({ type: "file" });
+    const entryPoints = [];
+    for (const node of allFileNodes) {
+      if (node.name === "index.ts" || node.metadata?.entryPoint === true) {
+        entryPoints.push(node.id);
+      }
+    }
+    for (const nodeType of CODE_NODE_TYPES3) {
+      if (nodeType === "file") continue;
+      const nodes = this.store.findNodes({ type: nodeType });
+      for (const node of nodes) {
+        if (node.metadata?.entryPoint === true) {
+          entryPoints.push(node.id);
+        }
+      }
+    }
+    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);
+      const importEdges = this.store.getEdges({ from: nodeId, type: "imports" });
+      for (const edge of importEdges) {
+        if (!visited.has(edge.to)) {
+          queue.push(edge.to);
+        }
+      }
+      const callEdges = this.store.getEdges({ from: nodeId, type: "calls" });
+      for (const edge of callEdges) {
+        if (!visited.has(edge.to)) {
+          queue.push(edge.to);
+        }
+      }
+      const containsEdges = this.store.getEdges({ from: nodeId, type: "contains" });
+      for (const edge of containsEdges) {
+        if (!visited.has(edge.to)) {
+          queue.push(edge.to);
+        }
+      }
+    }
+    const unreachableNodes = [];
+    for (const nodeType of CODE_NODE_TYPES3) {
+      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 {
+      reachableNodeIds: visited,
+      unreachableNodes,
+      entryPoints
+    };
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 containsEdges = this.store.getEdges({ to: fnNode.id, type: "contains" });
+      let fileId;
+      for (const edge of containsEdges) {
+        const sourceNode = this.store.getNode(edge.from);
+        if (sourceNode?.type === "file") {
+          fileId = sourceNode.id;
+          break;
+        }
+        if (sourceNode?.type === "class") {
+          const classContainsEdges = this.store.getEdges({ to: sourceNode.id, type: "contains" });
+          for (const classEdge of classContainsEdges) {
+            const parentNode = this.store.getNode(classEdge.from);
+            if (parentNode?.type === "file") {
+              fileId = parentNode.id;
+              break;
+            }
+          }
+          if (fileId) break;
+        }
+      }
+      if (!fileId) continue;
+      let changeFrequency = fileChangeFrequency.get(fileId);
+      if (changeFrequency === void 0) {
+        const referencesEdges = this.store.getEdges({ to: fileId, type: "references" });
+        changeFrequency = referencesEdges.length;
+        fileChangeFrequency.set(fileId, changeFrequency);
+      }
+      const 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 };
+  }
+  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;
+  }
+  /**
+   * 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 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_TYPES4 = /* @__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 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);
+        }
+      }
+    }
+    const sortedNodes = Array.from(nodeMap.values()).sort((a, b) => {
+      return (nodeScores.get(b.id) ?? 0) - (nodeScores.get(a.id) ?? 0);
+    });
+    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);
+    }
+    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
+    };
+  }
+  /**
+   * 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_TYPES4) {
+      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
+    };
+  }
+};
+var GraphConstraintAdapter = class {
+  constructor(store) {
+    this.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);
+      const toRelative = relative2(rootDir, edge.to);
+      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;
+  }
+};
+var GraphFeedbackAdapter = class {
+  constructor(store) {
+    this.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 VERSION = "0.2.0";
+export {
+  Assembler,
+  CIConnector,
+  CURRENT_SCHEMA_VERSION,
+  CodeIngestor,
+  ConfluenceConnector,
+  ContextQL,
+  EDGE_TYPES,
+  FusionLayer,
+  GitIngestor,
+  GraphComplexityAdapter,
+  GraphConstraintAdapter,
+  GraphCouplingAdapter,
+  GraphEdgeSchema,
+  GraphEntropyAdapter,
+  GraphFeedbackAdapter,
+  GraphNodeSchema,
+  GraphStore,
+  JiraConnector,
+  KnowledgeIngestor,
+  NODE_TYPES,
+  OBSERVABILITY_TYPES,
+  SlackConnector,
+  SyncManager,
+  TopologicalLinker,
+  VERSION,
+  VectorStore,
+  linkToCode,
+  loadGraph,
+  project,
+  saveGraph
+};