@harness-engineering/cli 2.0.0 → 2.1.1

package/dist/{chunk-S2WB4LE7.js → chunk-BMM3GXV6.js}

@@ -5,10 +5,12 @@ import {
 // ../graph/dist/index.mjs
 import { z } from "zod";
 import { readFile, writeFile, mkdir, access } from "fs/promises";
-import { createWriteStream } from "fs";
+import { createReadStream, createWriteStream } from "fs";
+import { createInterface } from "readline";
 import { join } from "path";
 import * as fs from "fs/promises";
 import * as path from "path";
+import { minimatch } from "minimatch";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import * as path2 from "path";
@@ -17,6 +19,7 @@ import * as path3 from "path";
 import * as crypto from "crypto";
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
+import { z as z2 } from "zod";
 import * as fs4 from "fs/promises";
 import * as path5 from "path";
 import * as fs5 from "fs/promises";
@@ -35,41 +38,101 @@ import * as fs10 from "fs/promises";
 import * as path11 from "path";
 import * as fs12 from "fs/promises";
 import * as path13 from "path";
-import { minimatch } from "minimatch";
+import { minimatch as minimatch2 } from "minimatch";
 import { relative as relative5 } from "path";
 import * as fs13 from "fs/promises";
 import * as path14 from "path";
-function streamGraphJson(filePath, nodes, edges) {
+function streamGraphNdjson(filePath, nodes, edges) {
   return new Promise((resolve, reject) => {
     const stream = createWriteStream(filePath, { encoding: "utf-8" });
     stream.on("error", reject);
-    stream.write('{"nodes":[');
-    for (let i = 0; i < nodes.length; i++) {
-      if (i > 0) stream.write(",");
-      stream.write(JSON.stringify(nodes[i]));
+    for (const node of nodes) {
+      stream.write(JSON.stringify({ kind: "node", ...node }));
+      stream.write("\n");
     }
-    stream.write('],"edges":[');
-    for (let i = 0; i < edges.length; i++) {
-      if (i > 0) stream.write(",");
-      stream.write(JSON.stringify(edges[i]));
+    for (const edge of edges) {
+      stream.write(JSON.stringify({ kind: "edge", ...edge }));
+      stream.write("\n");
     }
-    stream.write("]}");
     stream.end(() => resolve());
   });
 }
+function countNodesByType(nodes) {
+  const counts = {};
+  for (const node of nodes) {
+    counts[node.type] = (counts[node.type] ?? 0) + 1;
+  }
+  return counts;
+}
 async function saveGraph(dirPath, nodes, edges) {
   await mkdir(dirPath, { recursive: true });
   const metadata = {
     schemaVersion: CURRENT_SCHEMA_VERSION,
     lastScanTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     nodeCount: nodes.length,
-    edgeCount: edges.length
+    edgeCount: edges.length,
+    nodesByType: countNodesByType(nodes)
   };
   await Promise.all([
-    streamGraphJson(join(dirPath, "graph.json"), nodes, edges),
+    streamGraphNdjson(join(dirPath, "graph.json"), nodes, edges),
     writeFile(join(dirPath, "metadata.json"), JSON.stringify(metadata, null, 2), "utf-8")
   ]);
 }
+async function loadGraphMetadata(dirPath) {
+  const metaPath = join(dirPath, "metadata.json");
+  try {
+    await access(metaPath);
+  } catch {
+    return { status: "not_found" };
+  }
+  let metadata;
+  try {
+    const content = await readFile(metaPath, "utf-8");
+    metadata = JSON.parse(content);
+  } catch {
+    return { status: "not_found" };
+  }
+  if (metadata.schemaVersion !== CURRENT_SCHEMA_VERSION) {
+    return {
+      status: "schema_mismatch",
+      found: metadata.schemaVersion,
+      expected: CURRENT_SCHEMA_VERSION
+    };
+  }
+  return { status: "loaded", metadata };
+}
+async function streamReadGraph(filePath) {
+  const stream = createReadStream(filePath, { encoding: "utf-8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  const nodes = [];
+  const edges = [];
+  try {
+    for await (const rawLine of rl) {
+      const line = rawLine.trim();
+      if (line === "") continue;
+      const record = JSON.parse(line);
+      if (record.kind === "node") {
+        const { kind: _kind, ...rest } = record;
+        nodes.push(rest);
+      } else if (record.kind === "edge") {
+        const { kind: _kind, ...rest } = record;
+        edges.push(rest);
+      }
+    }
+  } catch (err) {
+    if (err instanceof RangeError && /invalid string length/i.test(err.message)) {
+      throw new Error(
+        `Graph contains a record larger than V8 can hold in a single string (~512 MB). This usually means a node or edge has a multi-hundred-MB content/embedding field. Inspect ${filePath} for the offending record.`,
+        { cause: err }
+      );
+    }
+    throw err;
+  } finally {
+    rl.close();
+    stream.close();
+  }
+  return { nodes, edges };
+}
 async function loadGraph(dirPath) {
   const metaPath = join(dirPath, "metadata.json");
   const graphPath = join(dirPath, "graph.json");
@@ -88,8 +151,8 @@ async function loadGraph(dirPath) {
       expected: CURRENT_SCHEMA_VERSION
     };
   }
-  const graphContent = await readFile(graphPath, "utf-8");
-  return { status: "loaded", graph: JSON.parse(graphContent) };
+  const graph = await streamReadGraph(graphPath);
+  return { status: "loaded", graph };
 }
 function safeMerge(target, source) {
   for (const key of Object.keys(source)) {
@@ -224,6 +287,13 @@ function groupNodesByImpact(nodes, excludeId) {
   }
   return { tests, docs, code, other };
 }
+function resolveSkipDirs(options) {
+  const base = options?.skipDirs ? new Set(options.skipDirs) : new Set(DEFAULT_SKIP_DIRS);
+  if (options?.additionalSkipDirs) {
+    for (const name of options.additionalSkipDirs) base.add(name);
+  }
+  return base;
+}
 function isExported(lang, line, name) {
   if (lang === "go") return /^[A-Z]/.test(name);
   if (lang === "rust") return /^\s*pub\b/.test(line);
@@ -243,6 +313,44 @@ function isSupportedSourceFile(name) {
   const ext = name.slice(name.lastIndexOf("."));
   return SUPPORTED_EXTENSIONS.has(ext);
 }
+function isExcluded(relPath, patterns) {
+  if (patterns.length === 0) return false;
+  for (const pattern of patterns) {
+    if (minimatch(relPath, pattern, { dot: true, matchBase: false })) return true;
+    if (!pattern.includes("/") && minimatch(relPath, pattern, { dot: true, matchBase: true })) {
+      return true;
+    }
+  }
+  return false;
+}
+async function readGitignorePatterns(rootDir) {
+  let content;
+  try {
+    content = await fs.readFile(path.join(rootDir, ".gitignore"), "utf-8");
+  } catch {
+    return [];
+  }
+  const patterns = [];
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    if (line.startsWith("!")) continue;
+    const rooted = line.startsWith("/");
+    const stripped = rooted ? line.slice(1) : line;
+    const isDirOnly = stripped.endsWith("/");
+    const core = isDirOnly ? stripped.slice(0, -1) : stripped;
+    if (core === "") continue;
+    if (rooted) {
+      patterns.push(isDirOnly ? `${core}/**` : core);
+      if (isDirOnly) patterns.push(`${core}/`);
+    } else {
+      patterns.push(`**/${core}`);
+      patterns.push(`**/${core}/**`);
+      if (isDirOnly) patterns.push(`**/${core}/`);
+    }
+  }
+  return patterns;
+}
 function finalizeCommit(current) {
   return {
     hash: current.hash,
@@ -362,6 +470,25 @@ function parseFrontmatter(raw) {
     body
   };
 }
+function parseSolutionFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return null;
+  const yamlBlock = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  for (const line of yamlBlock.split(/\r?\n/)) {
+    const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+    if (!kvMatch) continue;
+    const key = kvMatch[1];
+    const value = kvMatch[2].trim();
+    if (value.startsWith("[") && value.endsWith("]")) {
+      frontmatter[key] = value.slice(1, -1).split(",").map((s) => s.trim());
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
 function detectEarsPattern(text) {
   const lower = text.toLowerCase();
   if (/^if\b.+\bthen\b.+\bshall not\b/.test(lower)) return "unwanted";
@@ -1502,7 +1629,7 @@ function parseAntiPatterns(content) {
   }
   return patterns;
 }
-var NODE_TYPES, EDGE_TYPES, OBSERVABILITY_TYPES, CURRENT_SCHEMA_VERSION, NODE_STABILITY, GraphNodeSchema, GraphEdgeSchema, POISONED_KEYS, GraphStore, VectorStore, DEFAULT_TTL_MS, PackedSummaryCache, ContextQL, TEST_TYPES, DOC_TYPES, CODE_TYPES, SKIP_METHOD_NAMES, FUNCTION_PATTERNS, CLASS_PATTERNS, INTERFACE_PATTERNS, METHOD_PATTERNS, GO_METHOD_PATTERN, VARIABLE_PATTERNS, SUPPORTED_EXTENSIONS, SKIP_EXTENSIONS, CodeIngestor, execFileAsync, GitIngestor, TopologicalLinker, CODE_NODE_TYPES, KnowledgeIngestor, BUSINESS_KNOWLEDGE_TYPES, GOVERNS_SOURCE_TYPES, CODE_NODE_TYPES2, MEASURABLE_TYPES, BusinessKnowledgeIngestor, CODE_NODE_TYPES3, DecisionIngestor, REQUIREMENT_SECTIONS, SECTION_HEADING_RE, NUMBERED_ITEM_RE, CODE_NODE_TYPES4, RequirementIngestor, DEFAULT_PATTERNS, DEFAULT_BLOCKLIST, CODE_EXTENSIONS, MermaidParser, D2Parser, PlantUmlParser, DIAGRAM_EXTENSIONS, SKIP_DIRS, DiagramParser, HEURISTIC_PATTERNS, SCANNABLE_TYPES, KnowledgeLinker, StructuralDriftDetector, BUSINESS_NODE_TYPES, KnowledgeStagingAggregator, SKIP_DIRS2, EXT_TO_LANGUAGE, SKIP_EXTENSIONS2, EXTRACTOR_EDGE_TYPE, ExtractionRunner, PATTERNS, TestDescriptionExtractor, EnumConstantExtractor, ValidationRuleExtractor, ApiPathExtractor, ALL_EXTRACTORS, ImageAnalysisExtractor, KNOWLEDGE_NODE_TYPES, SIMILARITY_THRESHOLD, SEVERITY_MAP, ContradictionDetector, KNOWLEDGE_TYPES, CODE_TYPES2, KNOWLEDGE_EDGE_TYPES, CoverageScorer, VALID_BUSINESS_TYPES, DEFAULT_MAX_DOCS, MAX_COLLISION_SUFFIX, KnowledgeDocMaterializer, BUSINESS_NODE_TYPES2, SNAPSHOT_NODE_TYPES, KnowledgePipelineRunner, CODE_NODE_TYPES5, RETRYABLE_STATUSES, SANITIZE_RULES, SyncManager, SUMMARIZE_PROMPT, JiraConnector, SlackConnector, ConfluenceConnector, CIConnector, CONSTRAINT_KEYWORDS, FigmaConnector, MIN_CONTENT_LENGTH, CONCEPT_ITEM_TYPES, MiroConnector, STOP_WORDS, FusionLayer, CODE_NODE_TYPES6, GraphEntropyAdapter, GraphComplexityAdapter, GraphCouplingAdapter, DEFAULT_THRESHOLD, DEFAULT_METRICS, RECOGNIZED_METRICS, GraphAnomalyAdapter, INTENTS, SIGNAL_WEIGHTS, INTENT_SIGNALS, IntentClassifier, INTENT_KEYWORDS, STOP_WORDS2, PASCAL_OR_CAMEL_RE, FILE_PATH_RE, QUOTED_RE, EntityExtractor, EntityResolver, ResponseFormatter, CompositeProbabilityStrategy, DEFAULT_PROBABILITY_FLOOR, DEFAULT_MAX_DEPTH, CascadeSimulator, ENTITY_REQUIRED_INTENTS, classifier, extractor, formatter, PHASE_NODE_TYPES, CODE_NODE_TYPES7, Assembler, GraphConstraintAdapter, DesignIngestor, DesignConstraintAdapter, GraphFeedbackAdapter, DEFAULT_EDGE_TYPES, TaskIndependenceAnalyzer, ConflictPredictor, VERSION;
+var NODE_TYPES, EDGE_TYPES, OBSERVABILITY_TYPES, CURRENT_SCHEMA_VERSION, NODE_STABILITY, GraphNodeSchema, GraphEdgeSchema, POISONED_KEYS, GraphStore, VectorStore, DEFAULT_TTL_MS, PackedSummaryCache, ContextQL, TEST_TYPES, DOC_TYPES, CODE_TYPES, DEFAULT_SKIP_DIRS, SKIP_METHOD_NAMES, FUNCTION_PATTERNS, CLASS_PATTERNS, INTERFACE_PATTERNS, METHOD_PATTERNS, GO_METHOD_PATTERN, VARIABLE_PATTERNS, SUPPORTED_EXTENSIONS, SKIP_EXTENSIONS, CodeIngestor, execFileAsync, GitIngestor, TopologicalLinker, CODE_NODE_TYPES, KnowledgeIngestor, BUG_TRACK_CATEGORIES, KNOWLEDGE_TRACK_CATEGORIES, ISO_DATE, SolutionBaseSchema, SolutionDocFrontmatterSchema, BUSINESS_KNOWLEDGE_TYPES, GOVERNS_SOURCE_TYPES, CODE_NODE_TYPES2, MEASURABLE_TYPES, BusinessKnowledgeIngestor, CODE_NODE_TYPES3, DecisionIngestor, REQUIREMENT_SECTIONS, SECTION_HEADING_RE, NUMBERED_ITEM_RE, CODE_NODE_TYPES4, RequirementIngestor, DEFAULT_PATTERNS, DEFAULT_BLOCKLIST, CODE_EXTENSIONS, MermaidParser, D2Parser, PlantUmlParser, DIAGRAM_EXTENSIONS, SKIP_DIRS, DiagramParser, HEURISTIC_PATTERNS, SCANNABLE_TYPES, KnowledgeLinker, StructuralDriftDetector, BUSINESS_NODE_TYPES, KnowledgeStagingAggregator, SKIP_DIRS2, EXT_TO_LANGUAGE, SKIP_EXTENSIONS2, EXTRACTOR_EDGE_TYPE, ExtractionRunner, PATTERNS, TestDescriptionExtractor, EnumConstantExtractor, ValidationRuleExtractor, ApiPathExtractor, ALL_EXTRACTORS, ImageAnalysisExtractor, KNOWLEDGE_NODE_TYPES, SIMILARITY_THRESHOLD, SEVERITY_MAP, ContradictionDetector, KNOWLEDGE_TYPES, CODE_TYPES2, KNOWLEDGE_EDGE_TYPES, CoverageScorer, VALID_BUSINESS_TYPES, DEFAULT_MAX_DOCS, MAX_COLLISION_SUFFIX, KnowledgeDocMaterializer, BUSINESS_NODE_TYPES2, SNAPSHOT_NODE_TYPES, KnowledgePipelineRunner, CODE_NODE_TYPES5, RETRYABLE_STATUSES, SANITIZE_RULES, SyncManager, SUMMARIZE_PROMPT, JiraConnector, SlackConnector, ConfluenceConnector, CIConnector, CONSTRAINT_KEYWORDS, FigmaConnector, MIN_CONTENT_LENGTH, CONCEPT_ITEM_TYPES, MiroConnector, STOP_WORDS, FusionLayer, CODE_NODE_TYPES6, GraphEntropyAdapter, GraphComplexityAdapter, GraphCouplingAdapter, DEFAULT_THRESHOLD, DEFAULT_METRICS, RECOGNIZED_METRICS, GraphAnomalyAdapter, INTENTS, SIGNAL_WEIGHTS, INTENT_SIGNALS, IntentClassifier, INTENT_KEYWORDS, STOP_WORDS2, PASCAL_OR_CAMEL_RE, FILE_PATH_RE, QUOTED_RE, EntityExtractor, EntityResolver, ResponseFormatter, CompositeProbabilityStrategy, DEFAULT_PROBABILITY_FLOOR, DEFAULT_MAX_DEPTH, CascadeSimulator, ENTITY_REQUIRED_INTENTS, classifier, extractor, formatter, PHASE_NODE_TYPES, CODE_NODE_TYPES7, Assembler, GraphConstraintAdapter, DesignIngestor, DesignConstraintAdapter, GraphFeedbackAdapter, DEFAULT_EDGE_TYPES, TaskIndependenceAnalyzer, ConflictPredictor, VERSION;
 var init_dist = __esm({
   "../graph/dist/index.mjs"() {
     NODE_TYPES = [
@@ -1596,7 +1723,7 @@ var init_dist = __esm({
       "caches"
     ];
     OBSERVABILITY_TYPES = /* @__PURE__ */ new Set(["span", "metric", "log"]);
-    CURRENT_SCHEMA_VERSION = 1;
+    CURRENT_SCHEMA_VERSION = 2;
     NODE_STABILITY = {
       File: "session",
       Function: "session",
@@ -2026,6 +2153,72 @@ var init_dist = __esm({
       "method",
       "variable"
     ]);
+    DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
+      // VCS
+      ".git",
+      ".hg",
+      ".svn",
+      // Package managers
+      "node_modules",
+      ".pnpm-store",
+      ".yarn",
+      "vendor",
+      // JS/TS build outputs
+      "dist",
+      "build",
+      "out",
+      "_build",
+      "bin",
+      "obj",
+      "target",
+      "deps",
+      // JS/TS framework / tooling caches
+      ".next",
+      ".nuxt",
+      ".svelte-kit",
+      ".turbo",
+      ".vite",
+      ".cache",
+      ".parcel-cache",
+      ".docusaurus",
+      ".wrangler",
+      ".astro",
+      ".remix",
+      "storybook-static",
+      // Test / coverage / reporter outputs
+      "coverage",
+      ".nyc_output",
+      ".pytest_cache",
+      "playwright-report",
+      "test-results",
+      ".e2e",
+      // Python
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".tox",
+      ".mypy_cache",
+      ".ruff_cache",
+      // JVM
+      ".gradle",
+      ".gradle-home",
+      // IDE / editor
+      ".idea",
+      ".vscode",
+      ".vs",
+      // Harness self
+      ".harness",
+      // AI agent sandboxes (these often contain full repo clones — skipping them
+      // prevents the walker from re-ingesting nested copies of the project)
+      ".claude",
+      ".cursor",
+      ".codex",
+      ".gemini",
+      ".aider",
+      ".agents",
+      ".agentastic",
+      ".playwright-mcp"
+    ]);
     SKIP_METHOD_NAMES = /* @__PURE__ */ new Set(["constructor", "if", "for", "while", "switch"]);
     FUNCTION_PATTERNS = {
       python: /^def\s+(\w+)\s*\(/,
@@ -2077,10 +2270,16 @@ var init_dist = __esm({
     ]);
     SKIP_EXTENSIONS = /* @__PURE__ */ new Set([".d.ts"]);
     CodeIngestor = class {
-      constructor(store) {
+      constructor(store, options = {}) {
         this.store = store;
+        this.skipDirs = resolveSkipDirs(options);
+        this.excludePatterns = options.excludePatterns ?? [];
+        this.respectGitignore = options.respectGitignore ?? true;
       }
       store;
+      skipDirs;
+      excludePatterns;
+      respectGitignore;
       async ingest(rootDir) {
         const start = Date.now();
         const errors = [];
@@ -2170,19 +2369,55 @@ var init_dist = __esm({
         }
         files.add(relativePath);
       }
-      async findSourceFiles(dir) {
+      /**
+       * Walk `rootDir` iteratively (BFS via an explicit queue) and return absolute paths
+       * of every supported source file that is not excluded by the configured filters.
+       *
+       * Iterative on purpose: a recursive walker burns one stack frame per nested
+       * directory and crashes with `Maximum call stack size exceeded` on deeply nested
+       * monorepos (issue #274). The queue-based form keeps memory bounded by the
+       * frontier size rather than the deepest path.
+       */
+      async findSourceFiles(rootDir) {
         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" && entry.name !== "target" && entry.name !== "build" && entry.name !== ".git" && entry.name !== "__pycache__" && entry.name !== ".venv" && entry.name !== ".turbo" && entry.name !== ".harness" && entry.name !== ".next" && entry.name !== ".vscode" && entry.name !== ".idea" && entry.name !== "vendor" && entry.name !== "out" && entry.name !== ".gradle" && entry.name !== ".gradle-home" && entry.name !== "bin" && entry.name !== "obj" && entry.name !== "venv" && entry.name !== "_build" && entry.name !== "deps" && entry.name !== "coverage" && entry.name !== ".nyc_output") {
-            results.push(...await this.findSourceFiles(fullPath));
-          } else if (entry.isFile() && isSupportedSourceFile(entry.name)) {
-            results.push(fullPath);
+        const matchers = await this.buildExcludeMatchers(rootDir);
+        const queue = [rootDir];
+        while (queue.length > 0) {
+          const dir = queue.pop();
+          let entries;
+          try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+          } catch {
+            continue;
+          }
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = path.relative(rootDir, fullPath).replaceAll("\\", "/");
+            if (entry.isDirectory()) {
+              if (this.skipDirs.has(entry.name)) continue;
+              if (isExcluded(`${relPath}/`, matchers)) continue;
+              queue.push(fullPath);
+            } else if (entry.isFile()) {
+              if (!isSupportedSourceFile(entry.name)) continue;
+              if (isExcluded(relPath, matchers)) continue;
+              results.push(fullPath);
+            }
           }
         }
         return results;
       }
+      /**
+       * Compose the exclude matchers from `excludePatterns` and (optionally) `.gitignore`.
+       * Returns a list of minimatch-compatible patterns; an empty list means "no excludes".
+       */
+      async buildExcludeMatchers(rootDir) {
+        const patterns = [...this.excludePatterns];
+        if (this.respectGitignore) {
+          const gitignorePatterns = await readGitignorePatterns(rootDir);
+          patterns.push(...gitignorePatterns);
+        }
+        return patterns;
+      }
       extractSymbols(content, fileId, relativePath) {
         const results = [];
         const lines = content.split("\n");
@@ -3032,6 +3267,46 @@ var init_dist = __esm({
         return results;
       }
     };
+    BUG_TRACK_CATEGORIES = [
+      "build-errors",
+      "test-failures",
+      "runtime-errors",
+      "performance-issues",
+      "database-issues",
+      "security-issues",
+      "ui-bugs",
+      "integration-issues",
+      "logic-errors"
+    ];
+    KNOWLEDGE_TRACK_CATEGORIES = [
+      "architecture-patterns",
+      "design-patterns",
+      "tooling-decisions",
+      "conventions",
+      "dx",
+      "best-practices"
+    ];
+    ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+    SolutionBaseSchema = z2.object({
+      module: z2.string().min(1),
+      tags: z2.array(z2.string()),
+      problem_type: z2.string().min(1),
+      last_updated: z2.string().regex(ISO_DATE, "last_updated must be ISO date YYYY-MM-DD")
+    });
+    SolutionDocFrontmatterSchema = z2.discriminatedUnion("track", [
+      SolutionBaseSchema.merge(
+        z2.object({
+          track: z2.literal("bug-track"),
+          category: z2.enum(BUG_TRACK_CATEGORIES)
+        })
+      ),
+      SolutionBaseSchema.merge(
+        z2.object({
+          track: z2.literal("knowledge-track"),
+          category: z2.enum(KNOWLEDGE_TRACK_CATEGORIES)
+        })
+      )
+    ]);
     BUSINESS_KNOWLEDGE_TYPES = /* @__PURE__ */ new Set([
       "business_rule",
       "business_process",
@@ -3074,6 +3349,65 @@ var init_dist = __esm({
           durationMs: Date.now() - start
         };
       }
+      async ingestSolutions(solutionsDir) {
+        const start = Date.now();
+        const errors = [];
+        let files;
+        try {
+          files = await this.findMarkdownFiles(solutionsDir);
+        } catch {
+          return emptyResult(Date.now() - start);
+        }
+        let nodesAdded = 0;
+        for (const filePath of files) {
+          try {
+            const raw = await fs3.readFile(filePath, "utf-8");
+            const parsed = parseSolutionFrontmatter(raw);
+            if (!parsed) {
+              errors.push(`${filePath}: no frontmatter found`);
+              continue;
+            }
+            const validation = SolutionDocFrontmatterSchema.safeParse(parsed.frontmatter);
+            if (!validation.success) {
+              errors.push(`${filePath}: ${validation.error.message}`);
+              continue;
+            }
+            if (validation.data.track !== "knowledge-track") continue;
+            const relPath = path4.relative(solutionsDir, filePath).replaceAll("\\", "/");
+            const filename = path4.basename(filePath, ".md");
+            const nodeId = `bk:solutions:${validation.data.module}:${filename}`;
+            const titleMatch = parsed.body.match(/^#\s+(.+)$/m);
+            const name = titleMatch ? titleMatch[1].trim() : filename;
+            const node = {
+              id: nodeId,
+              type: "business_concept",
+              name,
+              path: relPath,
+              content: parsed.body.trim(),
+              metadata: {
+                domain: validation.data.module,
+                tags: validation.data.tags,
+                problem_type: validation.data.problem_type,
+                last_updated: validation.data.last_updated,
+                source: "solutions",
+                category: validation.data.category
+              }
+            };
+            this.store.addNode(node);
+            nodesAdded++;
+          } catch (err) {
+            errors.push(`${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        return {
+          nodesAdded,
+          nodesUpdated: 0,
+          edgesAdded: 0,
+          edgesUpdated: 0,
+          errors,
+          durationMs: Date.now() - start
+        };
+      }
       async createNodes(files, knowledgeDir, errors) {
         const entries = [];
         for (const filePath of files) {
@@ -5965,6 +6299,25 @@ var init_dist = __esm({
             durationMs: 0
           };
         }
+        const solutionsDir = path12.join(options.projectDir, "docs", "solutions");
+        let solutionsResult;
+        try {
+          solutionsResult = await bkIngestor.ingestSolutions(solutionsDir);
+        } catch {
+          solutionsResult = {
+            nodesAdded: 0,
+            nodesUpdated: 0,
+            edgesAdded: 0,
+            edgesUpdated: 0,
+            errors: [],
+            durationMs: 0
+          };
+        }
+        bkResult = {
+          ...bkResult,
+          nodesAdded: bkResult.nodesAdded + solutionsResult.nodesAdded,
+          errors: [...bkResult.errors, ...solutionsResult.errors]
+        };
         const decisionsDir = path12.join(options.projectDir, "docs", "knowledge", "decisions");
         const decisionIngestor = new DecisionIngestor(this.store);
         let decisionResult;
@@ -8667,7 +9020,7 @@ ${replyLines.join("\n")}`;
       resolveLayer(filePath, layers) {
         for (const layer of layers) {
           for (const pattern of layer.patterns) {
-            if (minimatch(filePath, pattern)) {
+            if (minimatch2(filePath, pattern)) {
               return layer;
             }
           }
@@ -9359,6 +9712,7 @@ export {
   GraphNodeSchema,
   GraphEdgeSchema,
   saveGraph,
+  loadGraphMetadata,
   loadGraph,
   GraphStore,
   VectorStore,
@@ -9368,6 +9722,8 @@ export {
   project,
   classifyNodeCategory,
   groupNodesByImpact,
+  DEFAULT_SKIP_DIRS,
+  resolveSkipDirs,
   CodeIngestor,
   GitIngestor,
   TopologicalLinker,

package/dist/{chunk-BYS3TQOO.js → chunk-CPYL6LJR.js}

@@ -1,6 +1,6 @@
 import {
   init_dist
-} from "./chunk-RFYF7TJS.js";
+} from "./chunk-K4WRQTEF.js";
 import {
   Err,
   Ok

package/dist/{chunk-QDRBWVVY.js → chunk-E7W3YOXL.js}

@@ -1,9 +1,9 @@
 import {
   resolveConfig
-} from "./chunk-KJD4J54I.js";
+} from "./chunk-LO7ZLV7S.js";
 import {
   init_dist
-} from "./chunk-RFYF7TJS.js";
+} from "./chunk-K4WRQTEF.js";
 import {
   Ok
 } from "./chunk-RL4VMEXL.js";