@zabaca/lattice 0.3.3 → 1.0.0

package/dist/main.js

@@ -23,86 +23,890 @@ import { CommandFactory } from "nest-commander";
 import { Module as Module5 } from "@nestjs/common";
 import { ConfigModule as ConfigModule2 } from "@nestjs/config";
 
-// src/graph/graph.module.ts
-import { Module } from "@nestjs/common";
+// src/commands/init.command.ts
+import * as fs from "fs/promises";
+import { homedir } from "os";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { Injectable } from "@nestjs/common";
+import { Command, CommandRunner, Option } from "nest-commander";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var COMMANDS = ["research.md", "graph-sync.md", "entity-extract.md"];
+
+class InitCommand extends CommandRunner {
+  async run(_inputs, options) {
+    try {
+      const targetDir = options.global ? path.join(homedir(), ".claude", "commands") : path.join(process.cwd(), ".claude", "commands");
+      let commandsSourceDir = path.resolve(__dirname2, "..", "commands");
+      try {
+        await fs.access(commandsSourceDir);
+      } catch {
+        commandsSourceDir = path.resolve(__dirname2, "..", "..", "commands");
+      }
+      try {
+        await fs.access(commandsSourceDir);
+      } catch {
+        console.error("Error: Commands source directory not found at", commandsSourceDir);
+        console.error("This may indicate a corrupted installation. Try reinstalling @zabaca/lattice.");
+        process.exit(1);
+      }
+      await fs.mkdir(targetDir, { recursive: true });
+      let copied = 0;
+      let skipped = 0;
+      const installed = [];
+      for (const file of COMMANDS) {
+        const sourcePath = path.join(commandsSourceDir, file);
+        const targetPath = path.join(targetDir, file);
+        try {
+          await fs.access(sourcePath);
+          try {
+            await fs.access(targetPath);
+            const sourceContent = await fs.readFile(sourcePath, "utf-8");
+            const targetContent = await fs.readFile(targetPath, "utf-8");
+            if (sourceContent === targetContent) {
+              skipped++;
+              continue;
+            }
+          } catch {}
+          await fs.copyFile(sourcePath, targetPath);
+          installed.push(file);
+          copied++;
+        } catch (err) {
+          console.error(`Warning: Could not copy ${file}:`, err instanceof Error ? err.message : String(err));
+        }
+      }
+      console.log();
+      console.log(`\u2705 Lattice commands installed to ${targetDir}`);
+      console.log();
+      if (copied > 0) {
+        console.log(`Installed ${copied} command(s):`);
+        installed.forEach((f) => {
+          const name = f.replace(".md", "");
+          console.log(`  - /${name}`);
+        });
+      }
+      if (skipped > 0) {
+        console.log(`Skipped ${skipped} unchanged command(s)`);
+      }
+      console.log();
+      console.log("Available commands in Claude Code:");
+      console.log("  /research <topic>    - AI-assisted research workflow");
+      console.log("  /graph-sync          - Extract entities and sync to graph");
+      console.log("  /entity-extract      - Extract entities from a single document");
+      console.log();
+      if (!options.global) {
+        console.log("\uD83D\uDCA1 Tip: Use 'lattice init --global' to install for all projects");
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  parseGlobal() {
+    return true;
+  }
+}
+__legacyDecorateClassTS([
+  Option({
+    flags: "-g, --global",
+    description: "Install to ~/.claude/commands/ (available in all projects)"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], InitCommand.prototype, "parseGlobal", null);
+InitCommand = __legacyDecorateClassTS([
+  Injectable(),
+  Command({
+    name: "init",
+    description: "Install Claude Code slash commands for Lattice"
+  })
+], InitCommand);
+// src/commands/ontology.command.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+import { Command as Command2, CommandRunner as CommandRunner2 } from "nest-commander";
+
+// src/sync/ontology.service.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+
+// src/sync/document-parser.service.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { Injectable as Injectable2, Logger } from "@nestjs/common";
+import { glob } from "glob";
+
+// src/schemas/config.schemas.ts
+import { z } from "zod";
+var DuckDBConfigSchema = z.object({
+  dbPath: z.string().optional(),
+  embeddingDimensions: z.coerce.number().int().positive().default(512)
+});
+var EmbeddingConfigSchema = z.object({
+  provider: z.enum(["openai", "voyage", "nomic", "mock"]).default("voyage"),
+  apiKey: z.string().optional(),
+  model: z.string().min(1).default("voyage-3.5-lite"),
+  dimensions: z.coerce.number().int().positive().default(512)
+});
+var DocsConfigSchema = z.object({
+  projectRoot: z.string().default(process.cwd()),
+  docsPath: z.string().default("docs")
+});
+
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+import { z as z2 } from "zod";
+var EntityTypeSchema = z2.enum([
+  "Topic",
+  "Technology",
+  "Concept",
+  "Tool",
+  "Process",
+  "Person",
+  "Organization",
+  "Document"
+]);
+var RelationTypeSchema = z2.enum(["REFERENCES"]);
+var EntitySchema = z2.object({
+  name: z2.string().min(1),
+  type: EntityTypeSchema,
+  description: z2.string().optional()
+});
+var RelationshipSchema = z2.object({
+  source: z2.string().min(1),
+  relation: RelationTypeSchema,
+  target: z2.string().min(1)
+});
+var GraphMetadataSchema = z2.object({
+  importance: z2.enum(["high", "medium", "low"]).optional(),
+  domain: z2.string().optional()
+});
+var validateDateFormat = (dateStr) => {
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match)
+    return false;
+  const [, yearStr, monthStr, dayStr] = match;
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10);
+  const day = parseInt(dayStr, 10);
+  if (month < 1 || month > 12)
+    return false;
+  if (day < 1 || day > 31)
+    return false;
+  const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
+    daysInMonth[1] = 29;
+  }
+  return day <= daysInMonth[month - 1];
+};
+var FrontmatterSchema = z2.object({
+  created: z2.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  updated: z2.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  status: z2.enum(["draft", "ongoing", "complete"]).optional(),
+  topic: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  summary: z2.string().optional(),
+  entities: z2.array(EntitySchema).optional(),
+  relationships: z2.array(RelationshipSchema).optional(),
+  graph: GraphMetadataSchema.optional()
+}).passthrough();
+function parseFrontmatter(content) {
+  try {
+    const { data, content: markdown } = matter(content);
+    if (Object.keys(data).length === 0) {
+      return {
+        frontmatter: null,
+        content: markdown.trim(),
+        raw: content
+      };
+    }
+    const normalizedData = normalizeData(data);
+    const validated = FrontmatterSchema.safeParse(normalizedData);
+    return {
+      frontmatter: validated.success ? validated.data : normalizedData,
+      content: markdown.trim(),
+      raw: content
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`YAML parsing error: ${errorMessage}`);
+  }
+}
+function normalizeData(data) {
+  if (data instanceof Date) {
+    return data.toISOString().split("T")[0];
+  }
+  if (Array.isArray(data)) {
+    return data.map(normalizeData);
+  }
+  if (data !== null && typeof data === "object") {
+    const normalized = {};
+    for (const [key, value] of Object.entries(data)) {
+      normalized[key] = normalizeData(value);
+    }
+    return normalized;
+  }
+  return data;
+}
+
+// src/sync/document-parser.service.ts
+class DocumentParserService {
+  logger = new Logger(DocumentParserService.name);
+  docsPath;
+  constructor() {
+    const config = DocsConfigSchema.parse({
+      projectRoot: process.env.PROJECT_ROOT,
+      docsPath: process.env.DOCS_PATH
+    });
+    if (config.docsPath.startsWith("/")) {
+      this.docsPath = config.docsPath;
+    } else {
+      this.docsPath = resolve2(config.projectRoot, config.docsPath);
+    }
+  }
+  getDocsPath() {
+    return this.docsPath;
+  }
+  async discoverDocuments() {
+    const pattern = `${this.docsPath}/**/*.md`;
+    const files = await glob(pattern, {
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    return files.sort();
+  }
+  async parseDocument(filePath) {
+    const content = await readFile2(filePath, "utf-8");
+    const parsed = parseFrontmatter(content);
+    const title = this.extractTitle(content, filePath);
+    const contentHash = this.computeHash(content);
+    const frontmatterHash = this.computeHash(JSON.stringify(parsed.frontmatter || {}));
+    const entities = this.extractEntities(parsed.frontmatter, filePath);
+    const relationships = this.extractRelationships(parsed.frontmatter, filePath);
+    const graphMetadata = this.extractGraphMetadata(parsed.frontmatter);
+    return {
+      path: filePath,
+      title,
+      content: parsed.content,
+      contentHash,
+      frontmatterHash,
+      summary: parsed.frontmatter?.summary,
+      topic: parsed.frontmatter?.topic,
+      entities,
+      relationships,
+      graphMetadata,
+      tags: parsed.frontmatter?.tags || [],
+      created: parsed.frontmatter?.created,
+      updated: parsed.frontmatter?.updated,
+      status: parsed.frontmatter?.status
+    };
+  }
+  async parseAllDocuments() {
+    const { docs } = await this.parseAllDocumentsWithErrors();
+    return docs;
+  }
+  async parseAllDocumentsWithErrors() {
+    const files = await this.discoverDocuments();
+    const docs = [];
+    const errors = [];
+    for (const file of files) {
+      try {
+        const parsed = await this.parseDocument(file);
+        docs.push(parsed);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        errors.push({ path: file, error: errorMsg });
+        this.logger.warn(`Failed to parse ${file}: ${error}`);
+      }
+    }
+    return { docs, errors };
+  }
+  extractTitle(content, filePath) {
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+      return h1Match[1];
+    }
+    const parts = filePath.split("/");
+    return parts[parts.length - 1].replace(".md", "");
+  }
+  extractEntities(frontmatter, docPath) {
+    const fm = frontmatter;
+    if (!fm?.entities || !Array.isArray(fm.entities)) {
+      return [];
+    }
+    const validEntities = [];
+    const errors = [];
+    for (let i = 0;i < fm.entities.length; i++) {
+      const e = fm.entities[i];
+      const result = EntitySchema.safeParse(e);
+      if (result.success) {
+        validEntities.push(result.data);
+      } else {
+        const entityPreview = typeof e === "string" ? `"${e}"` : JSON.stringify(e);
+        errors.push(`Entity[${i}]: ${entityPreview} - Expected object with {name, type}, got ${typeof e}`);
+      }
+    }
+    if (errors.length > 0) {
+      const errorMsg = `Invalid entity schema in ${docPath}:
+  ${errors.join(`
+  `)}`;
+      throw new Error(errorMsg);
+    }
+    return validEntities;
+  }
+  extractRelationships(frontmatter, docPath) {
+    const fm = frontmatter;
+    if (!fm?.relationships || !Array.isArray(fm.relationships)) {
+      return [];
+    }
+    const validRelationships = [];
+    const errors = [];
+    const validRelationTypes = RelationTypeSchema.options;
+    for (let i = 0;i < fm.relationships.length; i++) {
+      const r = fm.relationships[i];
+      const result = RelationshipSchema.safeParse(r);
+      if (result.success) {
+        const rel = result.data;
+        if (rel.source === "this") {
+          rel.source = docPath;
+        }
+        if (rel.target === "this") {
+          rel.target = docPath;
+        }
+        validRelationships.push(rel);
+      } else {
+        if (typeof r === "string") {
+          errors.push(`Relationship[${i}]: "${r}" - Expected object with {source, relation, target}, got string`);
+        } else if (typeof r === "object" && r !== null) {
+          const issues = [];
+          if (!r.source)
+            issues.push("missing source");
+          if (!r.target)
+            issues.push("missing target");
+          if (!r.relation) {
+            issues.push("missing relation");
+          } else if (!validRelationTypes.includes(r.relation)) {
+            issues.push(`invalid relation "${r.relation}" (allowed: ${validRelationTypes.join(", ")})`);
+          }
+          errors.push(`Relationship[${i}]: ${issues.join(", ")}`);
+        } else {
+          errors.push(`Relationship[${i}]: Expected object, got ${typeof r}`);
+        }
+      }
+    }
+    if (errors.length > 0) {
+      const errorMsg = `Invalid relationship schema in ${docPath}:
+  ${errors.join(`
+  `)}`;
+      throw new Error(errorMsg);
+    }
+    return validRelationships;
+  }
+  extractGraphMetadata(frontmatter) {
+    const fm = frontmatter;
+    if (!fm?.graph) {
+      return;
+    }
+    const result = GraphMetadataSchema.safeParse(fm.graph);
+    return result.success ? result.data : undefined;
+  }
+  computeHash(content) {
+    return createHash("sha256").update(content).digest("hex");
+  }
+}
+DocumentParserService = __legacyDecorateClassTS([
+  Injectable2(),
+  __legacyMetadataTS("design:paramtypes", [])
+], DocumentParserService);
+
+// src/sync/ontology.service.ts
+class OntologyService {
+  parser;
+  constructor(parser) {
+    this.parser = parser;
+  }
+  async deriveOntology() {
+    const docs = await this.parser.parseAllDocuments();
+    return this.deriveFromDocuments(docs);
+  }
+  deriveFromDocuments(docs) {
+    const entityTypeSet = new Set;
+    const relationshipTypeSet = new Set;
+    const entityCounts = {};
+    const relationshipCounts = {};
+    const entityExamples = {};
+    let documentsWithEntities = 0;
+    let documentsWithoutEntities = 0;
+    let totalRelationships = 0;
+    for (const doc of docs) {
+      if (doc.entities.length > 0) {
+        documentsWithEntities++;
+      } else {
+        documentsWithoutEntities++;
+      }
+      for (const entity of doc.entities) {
+        entityTypeSet.add(entity.type);
+        entityCounts[entity.type] = (entityCounts[entity.type] || 0) + 1;
+        if (!entityExamples[entity.name]) {
+          entityExamples[entity.name] = { type: entity.type, documents: [] };
+        }
+        if (!entityExamples[entity.name].documents.includes(doc.path)) {
+          entityExamples[entity.name].documents.push(doc.path);
+        }
+      }
+      for (const rel of doc.relationships) {
+        relationshipTypeSet.add(rel.relation);
+        relationshipCounts[rel.relation] = (relationshipCounts[rel.relation] || 0) + 1;
+        totalRelationships++;
+      }
+    }
+    return {
+      entityTypes: Array.from(entityTypeSet).sort(),
+      relationshipTypes: Array.from(relationshipTypeSet).sort(),
+      entityCounts,
+      relationshipCounts,
+      totalEntities: Object.keys(entityExamples).length,
+      totalRelationships,
+      documentsWithEntities,
+      documentsWithoutEntities,
+      entityExamples
+    };
+  }
+  printSummary(ontology) {
+    console.log(`
+Derived Ontology Summary
+`);
+    console.log(`Documents: ${ontology.documentsWithEntities} with entities, ${ontology.documentsWithoutEntities} without`);
+    console.log(`Unique Entities: ${ontology.totalEntities}`);
+    console.log(`Total Relationships: ${ontology.totalRelationships}`);
+    console.log(`
+Entity Types:`);
+    for (const type of ontology.entityTypes) {
+      console.log(`  ${type}: ${ontology.entityCounts[type]} instances`);
+    }
+    console.log(`
+Relationship Types:`);
+    for (const type of ontology.relationshipTypes) {
+      console.log(`  ${type}: ${ontology.relationshipCounts[type]} instances`);
+    }
+    console.log(`
+Top Entities (by document count):`);
+    const sorted = Object.entries(ontology.entityExamples).sort((a, b) => b[1].documents.length - a[1].documents.length).slice(0, 10);
+    for (const [name, info] of sorted) {
+      console.log(`  ${name} (${info.type}): ${info.documents.length} docs`);
+    }
+  }
+}
+OntologyService = __legacyDecorateClassTS([
+  Injectable3(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
+  ])
+], OntologyService);
+
+// src/commands/ontology.command.ts
+class OntologyCommand extends CommandRunner2 {
+  ontologyService;
+  constructor(ontologyService) {
+    super();
+    this.ontologyService = ontologyService;
+  }
+  async run() {
+    try {
+      const ontology = await this.ontologyService.deriveOntology();
+      this.ontologyService.printSummary(ontology);
+      process.exit(0);
+    } catch (error) {
+      console.error(`
+\u274C Ontology derivation failed:`, error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+}
+OntologyCommand = __legacyDecorateClassTS([
+  Injectable4(),
+  Command2({
+    name: "ontology",
+    description: "Derive and display ontology from all documents"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof OntologyService === "undefined" ? Object : OntologyService
+  ])
+], OntologyCommand);
+// src/commands/query.command.ts
+import { Injectable as Injectable7 } from "@nestjs/common";
+import { Command as Command3, CommandRunner as CommandRunner3, Option as Option2 } from "nest-commander";
+
+// src/embedding/embedding.service.ts
+import { Injectable as Injectable5, Logger as Logger2 } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+
+// src/embedding/embedding.types.ts
+var DEFAULT_EMBEDDING_CONFIG = {
+  provider: "voyage",
+  model: "voyage-3.5-lite",
+  dimensions: 512
+};
+
+// src/embedding/providers/mock.provider.ts
+class MockEmbeddingProvider {
+  name = "mock";
+  dimensions;
+  constructor(dimensions = 1536) {
+    this.dimensions = dimensions;
+  }
+  async generateEmbedding(text) {
+    return this.generateDeterministicEmbedding(text);
+  }
+  async generateEmbeddings(texts) {
+    return Promise.all(texts.map((text) => this.generateEmbedding(text)));
+  }
+  generateDeterministicEmbedding(text) {
+    const embedding = new Array(this.dimensions);
+    let hash = 0;
+    for (let i = 0;i < text.length; i++) {
+      hash = (hash << 5) - hash + text.charCodeAt(i);
+      hash = hash & hash;
+    }
+    for (let i = 0;i < this.dimensions; i++) {
+      const seed = hash * (i + 1) ^ i * 31;
+      embedding[i] = (seed % 2000 - 1000) / 1000;
+    }
+    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+    return embedding.map((val) => val / magnitude);
+  }
+}
+
+// src/embedding/providers/openai.provider.ts
+class OpenAIEmbeddingProvider {
+  name = "openai";
+  dimensions;
+  model;
+  apiKey;
+  baseUrl = "https://api.openai.com/v1";
+  constructor(config) {
+    const apiKey = config?.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.apiKey = apiKey;
+    this.model = config?.model || "text-embedding-3-small";
+    this.dimensions = config?.dimensions || 1536;
+  }
+  async generateEmbedding(text) {
+    const embeddings = await this.generateEmbeddings([text]);
+    return embeddings[0];
+  }
+  async generateEmbeddings(texts) {
+    if (!texts || texts.length === 0) {
+      return [];
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          input: texts,
+          dimensions: this.dimensions
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(`OpenAI API error: ${response.status} ${JSON.stringify(error)}`);
+      }
+      const data = await response.json();
+      const sortedData = data.data.sort((a, b) => a.index - b.index);
+      return sortedData.map((item) => item.embedding);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to generate embeddings: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+}
+
+// src/schemas/embedding.schemas.ts
+import { z as z3 } from "zod";
+var VoyageEmbeddingResponseSchema = z3.object({
+  object: z3.string(),
+  data: z3.array(z3.object({
+    object: z3.string(),
+    embedding: z3.array(z3.number()),
+    index: z3.number().int().nonnegative()
+  })),
+  model: z3.string(),
+  usage: z3.object({
+    total_tokens: z3.number().int().positive()
+  })
+});
+
+// src/embedding/providers/voyage.provider.ts
+class VoyageEmbeddingProvider {
+  name = "voyage";
+  dimensions;
+  model;
+  apiKey;
+  inputType;
+  baseUrl = "https://api.voyageai.com/v1";
+  constructor(config) {
+    const apiKey = config?.apiKey || process.env.VOYAGE_API_KEY;
+    if (!apiKey) {
+      throw new Error("Voyage API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config.");
+    }
+    this.apiKey = apiKey;
+    this.model = config?.model || "voyage-3.5-lite";
+    this.dimensions = config?.dimensions || 512;
+    this.inputType = config?.inputType || "document";
+  }
+  async generateEmbedding(text) {
+    const embeddings = await this.generateEmbeddings([text]);
+    return embeddings[0];
+  }
+  async generateEmbeddings(texts) {
+    if (!texts || texts.length === 0) {
+      return [];
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          input: texts,
+          output_dimension: this.dimensions,
+          input_type: this.inputType
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(`Voyage API error: ${response.status} ${JSON.stringify(error)}`);
+      }
+      const data = VoyageEmbeddingResponseSchema.parse(await response.json());
+      const sortedData = data.data.sort((a, b) => a.index - b.index);
+      return sortedData.map((item) => item.embedding);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to generate embeddings: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+}
+
+// src/embedding/embedding.service.ts
+class EmbeddingService {
+  configService;
+  logger = new Logger2(EmbeddingService.name);
+  provider;
+  config;
+  constructor(configService) {
+    this.configService = configService;
+    this.config = this.loadConfig();
+    this.provider = this.createProvider();
+    this.logger.log(`Initialized embedding service with provider: ${this.provider.name}`);
+  }
+  loadConfig() {
+    const providerEnv = this.configService.get("EMBEDDING_PROVIDER");
+    const provider = providerEnv ?? DEFAULT_EMBEDDING_CONFIG.provider;
+    let apiKey;
+    if (provider === "voyage") {
+      apiKey = this.configService.get("VOYAGE_API_KEY");
+    } else if (provider === "openai") {
+      apiKey = this.configService.get("OPENAI_API_KEY");
+    }
+    return EmbeddingConfigSchema.parse({
+      provider: providerEnv,
+      apiKey,
+      model: this.configService.get("EMBEDDING_MODEL"),
+      dimensions: this.configService.get("EMBEDDING_DIMENSIONS")
+    });
+  }
+  createProvider() {
+    switch (this.config.provider) {
+      case "openai":
+        if (!this.config.apiKey) {
+          throw new Error("OPENAI_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
+        }
+        return new OpenAIEmbeddingProvider({
+          apiKey: this.config.apiKey,
+          model: this.config.model,
+          dimensions: this.config.dimensions
+        });
+      case "mock":
+        return new MockEmbeddingProvider(this.config.dimensions);
+      case "voyage":
+        if (!this.config.apiKey) {
+          throw new Error("VOYAGE_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
+        }
+        return new VoyageEmbeddingProvider({
+          apiKey: this.config.apiKey,
+          model: this.config.model,
+          dimensions: this.config.dimensions
+        });
+      case "nomic":
+        throw new Error(`Provider ${this.config.provider} not yet implemented. Use 'voyage', 'openai', or 'mock'.`);
+      default:
+        throw new Error(`Unknown embedding provider: ${this.config.provider}. Use 'voyage', 'openai', or 'mock'.`);
+    }
+  }
+  getProviderName() {
+    return this.provider.name;
+  }
+  getDimensions() {
+    return this.provider.dimensions;
+  }
+  async generateEmbedding(text) {
+    if (!text || text.trim().length === 0) {
+      throw new Error("Cannot generate embedding for empty text");
+    }
+    return this.provider.generateEmbedding(text);
+  }
+  async generateEmbeddings(texts) {
+    const validTexts = texts.filter((t) => t && t.trim().length > 0);
+    if (validTexts.length === 0) {
+      return [];
+    }
+    return this.provider.generateEmbeddings(validTexts);
+  }
+  isRealProvider() {
+    return this.provider.name !== "mock";
+  }
+}
+EmbeddingService = __legacyDecorateClassTS([
+  Injectable5(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ConfigService === "undefined" ? Object : ConfigService
+  ])
+], EmbeddingService);
 
 // src/graph/graph.service.ts
-import { Injectable, Logger } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import Redis from "ioredis";
+import { DuckDBInstance } from "@duckdb/node-api";
+import { Injectable as Injectable6, Logger as Logger3 } from "@nestjs/common";
+import { ConfigService as ConfigService2 } from "@nestjs/config";
 class GraphService {
   configService;
-  logger = new Logger(GraphService.name);
-  redis = null;
-  config;
+  logger = new Logger3(GraphService.name);
+  instance = null;
+  connection = null;
+  dbPath;
   connecting = null;
+  vectorIndexes = new Set;
+  embeddingDimensions;
   constructor(configService) {
     this.configService = configService;
-    this.config = {
-      host: this.configService.get("FALKORDB_HOST", "localhost"),
-      port: this.configService.get("FALKORDB_PORT", 6379),
-      graphName: this.configService.get("GRAPH_NAME", "research_knowledge")
-    };
+    this.dbPath = this.configService.get("DUCKDB_PATH") || "./.lattice.duckdb";
+    this.embeddingDimensions = this.configService.get("EMBEDDING_DIMENSIONS") || 512;
   }
   async onModuleDestroy() {
     await this.disconnect();
   }
   async ensureConnected() {
-    if (this.redis) {
-      return this.redis;
+    if (this.connection) {
+      return this.connection;
     }
     if (this.connecting) {
       await this.connecting;
-      return this.redis;
+      if (!this.connection) {
+        throw new Error("Connection failed to establish");
+      }
+      return this.connection;
     }
     this.connecting = this.connect();
     await this.connecting;
     this.connecting = null;
-    return this.redis;
+    if (!this.connection) {
+      throw new Error("Connection failed to establish");
+    }
+    return this.connection;
   }
   async connect() {
     try {
-      this.redis = new Redis({
-        host: this.config.host,
-        port: this.config.port,
-        maxRetriesPerRequest: 3,
-        retryStrategy: (times) => {
-          if (times > 3) {
-            return null;
-          }
-          const delay = Math.min(times * 50, 2000);
-          return delay;
-        },
-        lazyConnect: true
-      });
-      this.redis.on("error", (err) => {
-        this.logger.debug(`Redis connection error: ${err.message}`);
+      this.instance = await DuckDBInstance.create(this.dbPath, {
+        allow_unsigned_extensions: "true"
       });
-      await this.redis.ping();
-      this.logger.log(`Connected to FalkorDB at ${this.config.host}:${this.config.port}`);
+      this.connection = await this.instance.connect();
+      await this.connection.run("INSTALL vss; LOAD vss;");
+      await this.connection.run("SET hnsw_enable_experimental_persistence = true;");
+      try {
+        await this.connection.run("SET custom_extension_repository = 'http://duckpgq.s3.eu-north-1.amazonaws.com';");
+        await this.connection.run("FORCE INSTALL 'duckpgq';");
+        await this.connection.run("LOAD 'duckpgq';");
+        this.logger.log("DuckPGQ extension loaded successfully");
+      } catch (e) {
+        this.logger.warn(`DuckPGQ extension not available: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      await this.initializeSchema();
+      this.logger.log(`Connected to DuckDB at ${this.dbPath}`);
     } catch (error) {
-      this.redis = null;
-      this.logger.error(`Failed to connect to FalkorDB: ${error instanceof Error ? error.message : String(error)}`);
+      this.connection = null;
+      this.instance = null;
+      this.logger.error(`Failed to connect to DuckDB: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
   async disconnect() {
-    if (this.redis) {
-      await this.redis.quit();
-      this.logger.log("Disconnected from FalkorDB");
-    }
-  }
-  async query(cypher, _params) {
+    if (this.connection) {
+      this.connection.closeSync();
+      this.connection = null;
+      this.logger.log("Disconnected from DuckDB");
+    }
+    if (this.instance) {
+      this.instance = null;
+    }
+  }
+  async initializeSchema() {
+    if (!this.connection) {
+      throw new Error("Cannot initialize schema: not connected");
+    }
+    const conn = this.connection;
+    await conn.run(`
+			CREATE TABLE IF NOT EXISTS nodes (
+				label VARCHAR NOT NULL,
+				name VARCHAR NOT NULL,
+				properties JSON,
+				embedding FLOAT[${this.embeddingDimensions}],
+				created_at TIMESTAMP DEFAULT NOW(),
+				updated_at TIMESTAMP DEFAULT NOW(),
+				PRIMARY KEY(label, name)
+			)
+		`);
+    await conn.run(`
+			CREATE TABLE IF NOT EXISTS relationships (
+				source_label VARCHAR NOT NULL,
+				source_name VARCHAR NOT NULL,
+				relation_type VARCHAR NOT NULL,
+				target_label VARCHAR NOT NULL,
+				target_name VARCHAR NOT NULL,
+				properties JSON,
+				created_at TIMESTAMP DEFAULT NOW(),
+				PRIMARY KEY(source_label, source_name, relation_type, target_label, target_name)
+			)
+		`);
+    await conn.run("CREATE INDEX IF NOT EXISTS idx_nodes_label ON nodes(label)");
+    await conn.run("CREATE INDEX IF NOT EXISTS idx_nodes_label_name ON nodes(label, name)");
+    await conn.run("CREATE INDEX IF NOT EXISTS idx_rels_source ON relationships(source_label, source_name)");
+    await conn.run("CREATE INDEX IF NOT EXISTS idx_rels_target ON relationships(target_label, target_name)");
+  }
+  async query(sql, _params) {
     try {
-      const redis = await this.ensureConnected();
-      const result = await redis.call("GRAPH.QUERY", this.config.graphName, cypher);
-      const resultArray = Array.isArray(result) ? result : [];
+      const conn = await this.ensureConnected();
+      const reader = await conn.runAndReadAll(sql);
+      const rows = reader.getRows();
       return {
-        resultSet: Array.isArray(resultArray[1]) ? resultArray[1] : [],
-        stats: this.parseStats(result)
+        resultSet: rows,
+        stats: undefined
       };
     } catch (error) {
-      this.logger.error(`Cypher query failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.logger.error(`Query failed: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
@@ -112,18 +916,15 @@ class GraphService {
       if (!name) {
         throw new Error("Node must have a 'name' property");
       }
-      const escapedName = this.escapeCypher(String(name));
-      const escapedLabel = this.escapeCypher(label);
-      const propAssignments = Object.entries({
-        name,
-        ...otherProps
-      }).map(([key, value]) => {
-        const escapedKey = this.escapeCypher(key);
-        const escapedValue = this.escapeCypherValue(value);
-        return `n.\`${escapedKey}\` = ${escapedValue}`;
-      }).join(", ");
-      const cypher = `MERGE (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `SET ${propAssignments}`;
-      await this.query(cypher);
+      const conn = await this.ensureConnected();
+      const propsJson = JSON.stringify(otherProps);
+      await conn.run(`
+				INSERT INTO nodes (label, name, properties)
+				VALUES ('${this.escape(String(label))}', '${this.escape(String(name))}', '${this.escape(propsJson)}')
+				ON CONFLICT (label, name) DO UPDATE SET
+					properties = EXCLUDED.properties,
+					updated_at = NOW()
+			`);
     } catch (error) {
       this.logger.error(`Failed to upsert node: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -131,21 +932,31 @@ class GraphService {
   }
   async upsertRelationship(sourceLabel, sourceName, relation, targetLabel, targetName, properties) {
     try {
-      const escapedSourceLabel = this.escapeCypher(sourceLabel);
-      const escapedSourceName = this.escapeCypher(sourceName);
-      const escapedRelation = this.escapeCypher(relation);
-      const escapedTargetLabel = this.escapeCypher(targetLabel);
-      const escapedTargetName = this.escapeCypher(targetName);
-      let relPropAssignments = "";
-      if (properties && Object.keys(properties).length > 0) {
-        relPropAssignments = ` SET ` + Object.entries(properties).map(([key, value]) => {
-          const escapedKey = this.escapeCypher(key);
-          const escapedValue = this.escapeCypherValue(value);
-          return `r.\`${escapedKey}\` = ${escapedValue}`;
-        }).join(", ");
-      }
-      const cypher = `MERGE (source:\`${escapedSourceLabel}\` { name: '${escapedSourceName}' }) ` + `MERGE (target:\`${escapedTargetLabel}\` { name: '${escapedTargetName}' }) ` + `MERGE (source)-[r:\`${escapedRelation}\`]->(target)` + relPropAssignments;
-      await this.query(cypher);
+      const conn = await this.ensureConnected();
+      await conn.run(`
+				INSERT INTO nodes (label, name, properties)
+				VALUES ('${this.escape(sourceLabel)}', '${this.escape(sourceName)}', '{}')
+				ON CONFLICT (label, name) DO NOTHING
+			`);
+      await conn.run(`
+				INSERT INTO nodes (label, name, properties)
+				VALUES ('${this.escape(targetLabel)}', '${this.escape(targetName)}', '{}')
+				ON CONFLICT (label, name) DO NOTHING
+			`);
+      const propsJson = properties ? JSON.stringify(properties) : "{}";
+      await conn.run(`
+				INSERT INTO relationships (source_label, source_name, relation_type, target_label, target_name, properties)
+				VALUES (
+					'${this.escape(sourceLabel)}',
+					'${this.escape(sourceName)}',
+					'${this.escape(relation)}',
+					'${this.escape(targetLabel)}',
+					'${this.escape(targetName)}',
+					'${this.escape(propsJson)}'
+				)
+				ON CONFLICT (source_label, source_name, relation_type, target_label, target_name) DO UPDATE SET
+					properties = EXCLUDED.properties
+			`);
     } catch (error) {
       this.logger.error(`Failed to upsert relationship: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -153,10 +964,16 @@ class GraphService {
   }
   async deleteNode(label, name) {
     try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedName = this.escapeCypher(name);
-      const cypher = `MATCH (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `DETACH DELETE n`;
-      await this.query(cypher);
+      const conn = await this.ensureConnected();
+      await conn.run(`
+				DELETE FROM relationships
+				WHERE (source_label = '${this.escape(label)}' AND source_name = '${this.escape(name)}')
+				   OR (target_label = '${this.escape(label)}' AND target_name = '${this.escape(name)}')
+			`);
+      await conn.run(`
+				DELETE FROM nodes
+				WHERE label = '${this.escape(label)}' AND name = '${this.escape(name)}'
+			`);
     } catch (error) {
       this.logger.error(`Failed to delete node: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -164,9 +981,11 @@ class GraphService {
   }
   async deleteDocumentRelationships(documentPath) {
     try {
-      const escapedPath = this.escapeCypher(documentPath);
-      const cypher = `MATCH ()-[r { documentPath: '${escapedPath}' }]-() ` + `DELETE r`;
-      await this.query(cypher);
+      const conn = await this.ensureConnected();
+      await conn.run(`
+				DELETE FROM relationships
+				WHERE properties->>'documentPath' = '${this.escape(documentPath)}'
+			`);
     } catch (error) {
       this.logger.error(`Failed to delete document relationships: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -174,11 +993,18 @@ class GraphService {
   }
   async findNodesByLabel(label, limit) {
     try {
-      const escapedLabel = this.escapeCypher(label);
+      const conn = await this.ensureConnected();
       const limitClause = limit ? ` LIMIT ${limit}` : "";
-      const cypher = `MATCH (n:\`${escapedLabel}\`) RETURN n${limitClause}`;
-      const result = await this.query(cypher);
-      return (result.resultSet || []).map((row) => row[0]);
+      const reader = await conn.runAndReadAll(`
+				SELECT name, properties
+				FROM nodes
+				WHERE label = '${this.escape(label)}'${limitClause}
+			`);
+      return reader.getRows().map((row) => {
+        const [name, properties] = row;
+        const props = properties ? JSON.parse(properties) : {};
+        return { name, ...props };
+      });
     } catch (error) {
       this.logger.error(`Failed to find nodes by label: ${error instanceof Error ? error.message : String(error)}`);
       return [];
@@ -186,10 +1012,17 @@ class GraphService {
   }
   async findRelationships(nodeName) {
     try {
-      const escapedName = this.escapeCypher(nodeName);
-      const cypher = `MATCH (n { name: '${escapedName}' })-[r]-(m) ` + `RETURN type(r), m.name`;
-      const result = await this.query(cypher);
-      return result.resultSet || [];
+      const conn = await this.ensureConnected();
+      const reader = await conn.runAndReadAll(`
+				SELECT relation_type, target_name, source_name
+				FROM relationships
+				WHERE source_name = '${this.escape(nodeName)}'
+				   OR target_name = '${this.escape(nodeName)}'
+			`);
+      return reader.getRows().map((row) => {
+        const [relType, targetName, sourceName] = row;
+        return [relType, sourceName === nodeName ? targetName : sourceName];
+      });
     } catch (error) {
       this.logger.error(`Failed to find relationships: ${error instanceof Error ? error.message : String(error)}`);
       return [];
@@ -197,27 +1030,39 @@ class GraphService {
   }
   async createVectorIndex(label, property, dimensions) {
     try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedProperty = this.escapeCypher(property);
-      const cypher = `CREATE VECTOR INDEX FOR (n:\`${escapedLabel}\`) ON (n.\`${escapedProperty}\`) OPTIONS { dimension: ${dimensions}, similarityFunction: 'cosine' }`;
-      await this.query(cypher);
+      const indexKey = `${label}_${property}`;
+      if (this.vectorIndexes.has(indexKey)) {
+        return;
+      }
+      const conn = await this.ensureConnected();
+      try {
+        await conn.run(`
+					CREATE INDEX idx_embedding_${this.escape(label)}
+					ON nodes USING HNSW (embedding)
+					WITH (metric = 'cosine')
+				`);
+      } catch {
+        this.logger.debug(`Vector index on ${label}.${property} already exists`);
+      }
+      this.vectorIndexes.add(indexKey);
       this.logger.log(`Created vector index on ${label}.${property} with ${dimensions} dimensions`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      if (!errorMessage.includes("already indexed")) {
+      if (!errorMessage.includes("already exists")) {
         this.logger.error(`Failed to create vector index: ${errorMessage}`);
         throw error;
       }
-      this.logger.debug(`Vector index on ${label}.${property} already exists`);
     }
   }
   async updateNodeEmbedding(label, name, embedding) {
     try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedName = this.escapeCypher(name);
+      const conn = await this.ensureConnected();
       const vectorStr = `[${embedding.join(", ")}]`;
-      const cypher = `MATCH (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `SET n.embedding = vecf32(${vectorStr})`;
-      await this.query(cypher);
+      await conn.run(`
+				UPDATE nodes
+				SET embedding = ${vectorStr}::FLOAT[${this.embeddingDimensions}]
+				WHERE label = '${this.escape(label)}' AND name = '${this.escape(name)}'
+			`);
     } catch (error) {
       this.logger.error(`Failed to update node embedding: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -225,133 +1070,286 @@ class GraphService {
   }
   async vectorSearch(label, queryVector, k = 10) {
     try {
-      const escapedLabel = this.escapeCypher(label);
+      const conn = await this.ensureConnected();
       const vectorStr = `[${queryVector.join(", ")}]`;
-      const cypher = `CALL db.idx.vector.queryNodes('${escapedLabel}', 'embedding', ${k}, vecf32(${vectorStr})) ` + `YIELD node, score ` + `RETURN node.name AS name, node.title AS title, (2 - score) / 2 AS similarity ` + `ORDER BY similarity DESC`;
-      const result = await this.query(cypher);
-      return (result.resultSet || []).map((row) => ({
-        name: row[0],
-        title: row[1],
-        score: row[2]
-      }));
+      const reader = await conn.runAndReadAll(`
+				SELECT
+					name,
+					properties->>'title' as title,
+					array_cosine_similarity(embedding, ${vectorStr}::FLOAT[${this.embeddingDimensions}]) as similarity
+				FROM nodes
+				WHERE label = '${this.escape(label)}'
+				  AND embedding IS NOT NULL
+				ORDER BY similarity DESC
+				LIMIT ${k}
+			`);
+      return reader.getRows().map((row) => {
+        const [name, title, similarity] = row;
+        return {
+          name,
+          title: title || undefined,
+          score: similarity
+        };
+      });
     } catch (error) {
       this.logger.error(`Vector search failed: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
   async vectorSearchAll(queryVector, k = 10) {
-    const allLabels = ["Document", "Concept", "Process", "Tool", "Technology", "Organization", "Topic", "Person"];
     const allResults = [];
-    for (const label of allLabels) {
-      try {
-        const escapedLabel = this.escapeCypher(label);
-        const vectorStr = `[${queryVector.join(", ")}]`;
-        const cypher = `CALL db.idx.vector.queryNodes('${escapedLabel}', 'embedding', ${k}, vecf32(${vectorStr})) ` + `YIELD node, score ` + `RETURN node.name AS name, node.title AS title, node.description AS description, (2 - score) / 2 AS similarity ` + `ORDER BY similarity DESC`;
-        const result = await this.query(cypher);
-        const labelResults = (result.resultSet || []).map((row) => ({
-          name: row[0],
+    const conn = await this.ensureConnected();
+    const vectorStr = `[${queryVector.join(", ")}]`;
+    try {
+      const reader = await conn.runAndReadAll(`
+				SELECT
+					name,
+					label,
+					properties->>'title' as title,
+					properties->>'description' as description,
+					array_cosine_similarity(embedding, ${vectorStr}::FLOAT[${this.embeddingDimensions}]) as similarity
+				FROM nodes
+				WHERE embedding IS NOT NULL
+				ORDER BY similarity DESC
+				LIMIT ${k}
+			`);
+      for (const row of reader.getRows()) {
+        const [name, label, title, description, similarity] = row;
+        allResults.push({
+          name,
           label,
-          title: row[1],
-          description: row[2],
-          score: row[3]
-        }));
-        allResults.push(...labelResults);
-      } catch (error) {
-        this.logger.debug(`Vector search for ${label} skipped: ${error instanceof Error ? error.message : String(error)}`);
+          title: title || undefined,
+          description: description || undefined,
+          score: similarity
+        });
       }
+    } catch (error) {
+      this.logger.debug(`Vector search failed: ${error instanceof Error ? error.message : String(error)}`);
     }
     return allResults.sort((a, b) => b.score - a.score).slice(0, k);
   }
-  escapeCypher(value) {
-    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"");
+  escape(value) {
+    return value.replace(/'/g, "''");
   }
-  escapeCypherValue(value) {
-    if (value === null || value === undefined) {
-      return "null";
-    }
-    if (typeof value === "string") {
-      const escaped = this.escapeCypher(value);
-      return `'${escaped}'`;
-    }
-    if (typeof value === "number" || typeof value === "boolean") {
-      return String(value);
-    }
-    if (Array.isArray(value)) {
-      return `[${value.map((v) => this.escapeCypherValue(v)).join(", ")}]`;
-    }
-    if (typeof value === "object") {
-      const pairs = Object.entries(value).map(([k, v]) => `${k}: ${this.escapeCypherValue(v)}`).join(", ");
-      return `{${pairs}}`;
-    }
-    return String(value);
+}
+GraphService = __legacyDecorateClassTS([
+  Injectable6(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ConfigService2 === "undefined" ? Object : ConfigService2
+  ])
+], GraphService);
+
+// src/commands/query.command.ts
+class SearchCommand extends CommandRunner3 {
+  graphService;
+  embeddingService;
+  constructor(graphService, embeddingService) {
+    super();
+    this.graphService = graphService;
+    this.embeddingService = embeddingService;
   }
-  parseStats(result) {
-    if (!Array.isArray(result) || result.length < 3) {
-      return;
-    }
-    const statsStr = result[2];
-    if (!statsStr || typeof statsStr !== "string") {
-      return;
-    }
-    const stats = {
-      nodesCreated: 0,
-      nodesDeleted: 0,
-      relationshipsCreated: 0,
-      relationshipsDeleted: 0,
-      propertiesSet: 0
-    };
-    const nodeCreatedMatch = statsStr.match(/Nodes created: (\d+)/);
-    if (nodeCreatedMatch) {
-      stats.nodesCreated = parseInt(nodeCreatedMatch[1], 10);
-    }
-    const nodeDeletedMatch = statsStr.match(/Nodes deleted: (\d+)/);
-    if (nodeDeletedMatch) {
-      stats.nodesDeleted = parseInt(nodeDeletedMatch[1], 10);
-    }
-    const relCreatedMatch = statsStr.match(/Relationships created: (\d+)/);
-    if (relCreatedMatch) {
-      stats.relationshipsCreated = parseInt(relCreatedMatch[1], 10);
-    }
-    const relDeletedMatch = statsStr.match(/Relationships deleted: (\d+)/);
-    if (relDeletedMatch) {
-      stats.relationshipsDeleted = parseInt(relDeletedMatch[1], 10);
+  async run(inputs, options) {
+    const query = inputs[0];
+    const limit = Math.min(parseInt(options.limit || "20", 10), 100);
+    try {
+      const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+      let results;
+      if (options.label) {
+        const labelResults = await this.graphService.vectorSearch(options.label, queryEmbedding, limit);
+        results = labelResults.map((r) => ({
+          name: r.name,
+          label: options.label,
+          title: r.title,
+          score: r.score
+        }));
+      } else {
+        results = await this.graphService.vectorSearchAll(queryEmbedding, limit);
+      }
+      const labelSuffix = options.label ? ` (${options.label})` : "";
+      console.log(`
+=== Semantic Search Results for "${query}"${labelSuffix} ===
+`);
+      if (results.length === 0) {
+        console.log(`No results found.
+`);
+        if (options.label) {
+          console.log(`Tip: Try without --label to search all entity types.
+`);
+        }
+        process.exit(0);
+      }
+      results.forEach((result, idx) => {
+        console.log(`${idx + 1}. [${result.label}] ${result.name}`);
+        if (result.title) {
+          console.log(`   Title: ${result.title}`);
+        }
+        if (result.description && result.label !== "Document") {
+          const desc = result.description.length > 80 ? `${result.description.slice(0, 80)}...` : result.description;
+          console.log(`   ${desc}`);
+        }
+        console.log(`   Similarity: ${(result.score * 100).toFixed(2)}%`);
+      });
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error("Error:", errorMsg);
+      if (errorMsg.includes("no embeddings") || errorMsg.includes("vector")) {
+        console.log(`
+Note: Semantic search requires embeddings to be generated first.`);
+        console.log(`Run 'lattice sync' to generate embeddings for documents.
+`);
+      }
+      process.exit(1);
     }
-    const propSetMatch = statsStr.match(/Properties set: (\d+)/);
-    if (propSetMatch) {
-      stats.propertiesSet = parseInt(propSetMatch[1], 10);
+  }
+  parseLabel(value) {
+    return value;
+  }
+  parseLimit(value) {
+    return value;
+  }
+}
+__legacyDecorateClassTS([
+  Option2({
+    flags: "-l, --label <label>",
+    description: "Filter by entity label (e.g., Technology, Concept, Document)"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    String
+  ]),
+  __legacyMetadataTS("design:returntype", String)
+], SearchCommand.prototype, "parseLabel", null);
+__legacyDecorateClassTS([
+  Option2({
+    flags: "--limit <n>",
+    description: "Limit results",
+    defaultValue: "20"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    String
+  ]),
+  __legacyMetadataTS("design:returntype", String)
+], SearchCommand.prototype, "parseLimit", null);
+SearchCommand = __legacyDecorateClassTS([
+  Injectable7(),
+  Command3({
+    name: "search",
+    arguments: "<query>",
+    description: "Semantic search across the knowledge graph"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService,
+    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
+  ])
+], SearchCommand);
+
+class RelsCommand extends CommandRunner3 {
+  graphService;
+  constructor(graphService) {
+    super();
+    this.graphService = graphService;
+  }
+  async run(inputs) {
+    const name = inputs[0];
+    try {
+      const relationships = await this.graphService.findRelationships(name);
+      console.log(`
+=== Relationships for "${name}" ===
+`);
+      if (relationships.length === 0) {
+        console.log(`No relationships found.
+`);
+        process.exit(0);
+      }
+      console.log("Relationships:");
+      for (const rel of relationships) {
+        const [relType, targetName] = rel;
+        console.log(`  -[${relType}]-> ${targetName}`);
+      }
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
     }
-    return stats;
   }
 }
-GraphService = __legacyDecorateClassTS([
-  Injectable(),
+RelsCommand = __legacyDecorateClassTS([
+  Injectable7(),
+  Command3({
+    name: "rels",
+    arguments: "<name>",
+    description: "Show relationships for a node"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService
+  ])
+], RelsCommand);
+
+class SqlCommand extends CommandRunner3 {
+  graphService;
+  constructor(graphService) {
+    super();
+    this.graphService = graphService;
+  }
+  async run(inputs) {
+    const query = inputs[0];
+    try {
+      const result = await this.graphService.query(query);
+      console.log(`
+=== SQL Query Results ===
+`);
+      const replacer = (_key, value) => typeof value === "bigint" ? Number(value) : value;
+      console.log(JSON.stringify(result, replacer, 2));
+      console.log();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+}
+SqlCommand = __legacyDecorateClassTS([
+  Injectable7(),
+  Command3({
+    name: "sql",
+    arguments: "<query>",
+    description: "Execute raw SQL query against DuckDB"
+  }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof ConfigService === "undefined" ? Object : ConfigService
+    typeof GraphService === "undefined" ? Object : GraphService
   ])
-], GraphService);
-
-// src/graph/graph.module.ts
-class GraphModule {
-}
-GraphModule = __legacyDecorateClassTS([
-  Module({
-    providers: [GraphService],
-    exports: [GraphService]
-  })
-], GraphModule);
+], SqlCommand);
+// src/commands/status.command.ts
+import { Injectable as Injectable12 } from "@nestjs/common";
+import { Command as Command4, CommandRunner as CommandRunner4, Option as Option3 } from "nest-commander";
 
-// src/sync/sync.module.ts
-import { Module as Module3 } from "@nestjs/common";
+// src/sync/manifest.service.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync } from "fs";
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { Injectable as Injectable8 } from "@nestjs/common";
 
-// src/sync/sync.service.ts
-import { Injectable as Injectable7, Logger as Logger6 } from "@nestjs/common";
+// src/schemas/manifest.schemas.ts
+import { z as z4 } from "zod";
+var ManifestEntrySchema = z4.object({
+  contentHash: z4.string(),
+  frontmatterHash: z4.string(),
+  lastSynced: z4.string(),
+  entityCount: z4.number().int().nonnegative(),
+  relationshipCount: z4.number().int().nonnegative()
+});
+var SyncManifestSchema = z4.object({
+  version: z4.string(),
+  lastSync: z4.string(),
+  documents: z4.record(z4.string(), ManifestEntrySchema)
+});
 
 // src/sync/manifest.service.ts
-import { Injectable as Injectable2 } from "@nestjs/common";
-import { createHash } from "crypto";
-import { readFile, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { resolve } from "path";
 function getProjectRoot() {
   if (process.env.PROJECT_ROOT) {
     return process.env.PROJECT_ROOT;
@@ -364,17 +1362,17 @@ class ManifestService {
   manifest = null;
   constructor() {
     const docsPath = process.env.DOCS_PATH || "docs";
-    this.manifestPath = resolve(getProjectRoot(), docsPath, ".sync-manifest.json");
+    this.manifestPath = resolve3(getProjectRoot(), docsPath, ".sync-manifest.json");
   }
   async load() {
     try {
       if (existsSync(this.manifestPath)) {
-        const content = await readFile(this.manifestPath, "utf-8");
-        this.manifest = JSON.parse(content);
+        const content = await readFile3(this.manifestPath, "utf-8");
+        this.manifest = SyncManifestSchema.parse(JSON.parse(content));
       } else {
         this.manifest = this.createEmptyManifest();
       }
-    } catch (error) {
+    } catch (_error) {
       this.manifest = this.createEmptyManifest();
     }
     return this.manifest;
@@ -388,13 +1386,13 @@ class ManifestService {
     await writeFile(this.manifestPath, content, "utf-8");
   }
   getContentHash(content) {
-    return createHash("sha256").update(content).digest("hex");
+    return createHash2("sha256").update(content).digest("hex");
   }
-  detectChange(path, contentHash, frontmatterHash) {
+  detectChange(path2, contentHash, frontmatterHash) {
     if (!this.manifest) {
       throw new Error("Manifest not loaded. Call load() first.");
     }
-    const existing = this.manifest.documents[path];
+    const existing = this.manifest.documents[path2];
     if (!existing) {
       return "new";
     }
@@ -403,11 +1401,11 @@ class ManifestService {
     }
     return "updated";
   }
-  updateEntry(path, contentHash, frontmatterHash, entityCount, relationshipCount) {
+  updateEntry(path2, contentHash, frontmatterHash, entityCount, relationshipCount) {
     if (!this.manifest) {
       throw new Error("Manifest not loaded. Call load() first.");
     }
-    this.manifest.documents[path] = {
+    this.manifest.documents[path2] = {
       contentHash,
       frontmatterHash,
       lastSynced: new Date().toISOString(),
@@ -415,11 +1413,11 @@ class ManifestService {
       relationshipCount
     };
   }
-  removeEntry(path) {
+  removeEntry(path2) {
     if (!this.manifest) {
       throw new Error("Manifest not loaded. Call load() first.");
     }
-    delete this.manifest.documents[path];
+    delete this.manifest.documents[path2];
   }
   getTrackedPaths() {
     if (!this.manifest) {
@@ -436,291 +1434,119 @@ class ManifestService {
   }
 }
 ManifestService = __legacyDecorateClassTS([
-  Injectable2(),
+  Injectable8(),
   __legacyMetadataTS("design:paramtypes", [])
 ], ManifestService);
 
-// src/sync/document-parser.service.ts
-import { Injectable as Injectable3, Logger as Logger2 } from "@nestjs/common";
-import { glob } from "glob";
-import { readFile as readFile2 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
-import { resolve as resolve2 } from "path";
+// src/sync/sync.service.ts
+import { Injectable as Injectable11, Logger as Logger5 } from "@nestjs/common";
 
-// src/utils/frontmatter.ts
-import { z } from "zod";
-import matter from "gray-matter";
-var EntityTypeSchema = z.enum([
-  "Topic",
-  "Technology",
-  "Concept",
-  "Tool",
-  "Process",
-  "Person",
-  "Organization",
-  "Document"
-]);
-var RelationTypeSchema = z.enum([
-  "REFERENCES"
-]);
-var EntitySchema = z.object({
-  name: z.string().min(1),
-  type: EntityTypeSchema,
-  description: z.string().optional()
-});
-var RelationshipSchema = z.object({
-  source: z.string().min(1),
-  relation: RelationTypeSchema,
-  target: z.string().min(1)
-});
-var GraphMetadataSchema = z.object({
-  importance: z.enum(["high", "medium", "low"]).optional(),
-  domain: z.string().optional()
-});
-var validateDateFormat = (dateStr) => {
-  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (!match)
-    return false;
-  const [, yearStr, monthStr, dayStr] = match;
-  const year = parseInt(yearStr, 10);
-  const month = parseInt(monthStr, 10);
-  const day = parseInt(dayStr, 10);
-  if (month < 1 || month > 12)
-    return false;
-  if (day < 1 || day > 31)
-    return false;
-  const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-  if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
-    daysInMonth[1] = 29;
+// src/pure/embedding-text.ts
+function composeDocumentEmbeddingText(doc) {
+  const parts = [];
+  if (doc.title) {
+    parts.push(`Title: ${doc.title}`);
   }
-  return day <= daysInMonth[month - 1];
-};
-var FrontmatterSchema = z.object({
-  created: z.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  updated: z.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  status: z.enum(["draft", "ongoing", "complete"]).optional(),
-  topic: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  summary: z.string().optional(),
-  entities: z.array(EntitySchema).optional(),
-  relationships: z.array(RelationshipSchema).optional(),
-  graph: GraphMetadataSchema.optional()
-}).passthrough();
-function parseFrontmatter(content) {
-  try {
-    const { data, content: markdown } = matter(content);
-    if (Object.keys(data).length === 0) {
-      return {
-        frontmatter: null,
-        content: markdown.trim(),
-        raw: content
-      };
-    }
-    const normalizedData = normalizeData(data);
-    const validated = FrontmatterSchema.safeParse(normalizedData);
-    return {
-      frontmatter: validated.success ? validated.data : normalizedData,
-      content: markdown.trim(),
-      raw: content
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`YAML parsing error: ${errorMessage}`);
+  if (doc.topic) {
+    parts.push(`Topic: ${doc.topic}`);
   }
-}
-function normalizeData(data) {
-  if (data instanceof Date) {
-    return data.toISOString().split("T")[0];
+  if (doc.tags && doc.tags.length > 0) {
+    parts.push(`Tags: ${doc.tags.join(", ")}`);
   }
-  if (Array.isArray(data)) {
-    return data.map(normalizeData);
+  if (doc.entities && doc.entities.length > 0) {
+    const entityNames = doc.entities.map((e) => e.name).join(", ");
+    parts.push(`Entities: ${entityNames}`);
   }
-  if (data !== null && typeof data === "object") {
-    const normalized = {};
-    for (const [key, value] of Object.entries(data)) {
-      normalized[key] = normalizeData(value);
-    }
-    return normalized;
+  if (doc.summary) {
+    parts.push(doc.summary);
+  } else {
+    parts.push(doc.content.slice(0, 500));
   }
-  return data;
+  return parts.join(" | ");
 }
-
-// src/sync/document-parser.service.ts
-function getProjectRoot2() {
-  if (process.env.PROJECT_ROOT) {
-    return process.env.PROJECT_ROOT;
+function composeEntityEmbeddingText(entity) {
+  const parts = [`${entity.type}: ${entity.name}`];
+  if (entity.description) {
+    parts.push(entity.description);
   }
-  return process.cwd();
+  return parts.join(". ");
 }
-
-class DocumentParserService {
-  logger = new Logger2(DocumentParserService.name);
-  docsPath;
-  constructor() {
-    const docsPathEnv = process.env.DOCS_PATH || "docs";
-    if (docsPathEnv.startsWith("/")) {
-      this.docsPath = docsPathEnv;
-    } else {
-      this.docsPath = resolve2(getProjectRoot2(), docsPathEnv);
-    }
-  }
-  getDocsPath() {
-    return this.docsPath;
-  }
-  async discoverDocuments() {
-    const pattern = `${this.docsPath}/**/*.md`;
-    const files = await glob(pattern, {
-      ignore: ["**/node_modules/**", "**/.git/**"]
-    });
-    return files.sort();
-  }
-  async parseDocument(filePath) {
-    const content = await readFile2(filePath, "utf-8");
-    const parsed = parseFrontmatter(content);
-    const title = this.extractTitle(content, filePath);
-    const contentHash = this.computeHash(content);
-    const frontmatterHash = this.computeHash(JSON.stringify(parsed.frontmatter || {}));
-    const entities = this.extractEntities(parsed.frontmatter, filePath);
-    const relationships = this.extractRelationships(parsed.frontmatter, filePath);
-    const graphMetadata = this.extractGraphMetadata(parsed.frontmatter);
-    return {
-      path: filePath,
-      title,
-      content: parsed.content,
-      contentHash,
-      frontmatterHash,
-      summary: parsed.frontmatter?.summary,
-      topic: parsed.frontmatter?.topic,
-      entities,
-      relationships,
-      graphMetadata,
-      tags: parsed.frontmatter?.tags || [],
-      created: parsed.frontmatter?.created,
-      updated: parsed.frontmatter?.updated,
-      status: parsed.frontmatter?.status
-    };
-  }
-  async parseAllDocuments() {
-    const { docs } = await this.parseAllDocumentsWithErrors();
-    return docs;
-  }
-  async parseAllDocumentsWithErrors() {
-    const files = await this.discoverDocuments();
-    const docs = [];
-    const errors = [];
-    for (const file of files) {
-      try {
-        const parsed = await this.parseDocument(file);
-        docs.push(parsed);
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        errors.push({ path: file, error: errorMsg });
-        this.logger.warn(`Failed to parse ${file}: ${error}`);
-      }
-    }
-    return { docs, errors };
-  }
-  extractTitle(content, filePath) {
-    const h1Match = content.match(/^#\s+(.+)$/m);
-    if (h1Match) {
-      return h1Match[1];
-    }
-    const parts = filePath.split("/");
-    return parts[parts.length - 1].replace(".md", "");
-  }
-  extractEntities(frontmatter, docPath) {
-    if (!frontmatter?.entities || !Array.isArray(frontmatter.entities)) {
-      return [];
-    }
-    const validEntities = [];
-    const errors = [];
-    for (let i = 0;i < frontmatter.entities.length; i++) {
-      const e = frontmatter.entities[i];
-      const result = EntitySchema.safeParse(e);
-      if (result.success) {
-        validEntities.push(result.data);
+function collectUniqueEntities(docs) {
+  const entities = new Map;
+  for (const doc of docs) {
+    for (const entity of doc.entities) {
+      const key = `${entity.type}:${entity.name}`;
+      const existing = entities.get(key);
+      if (!existing) {
+        entities.set(key, {
+          type: entity.type,
+          name: entity.name,
+          description: entity.description,
+          documentPaths: [doc.path]
+        });
       } else {
-        const entityPreview = typeof e === "string" ? `"${e}"` : JSON.stringify(e);
-        errors.push(`Entity[${i}]: ${entityPreview} - Expected object with {name, type}, got ${typeof e}`);
+        existing.documentPaths.push(doc.path);
+        if (entity.description && (!existing.description || entity.description.length > existing.description.length)) {
+          existing.description = entity.description;
+        }
       }
     }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid entity schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
-    }
-    return validEntities;
   }
-  extractRelationships(frontmatter, docPath) {
-    if (!frontmatter?.relationships || !Array.isArray(frontmatter.relationships)) {
-      return [];
-    }
-    const validRelationships = [];
-    const errors = [];
-    const validRelationTypes = RelationTypeSchema.options;
-    for (let i = 0;i < frontmatter.relationships.length; i++) {
-      const r = frontmatter.relationships[i];
-      const result = RelationshipSchema.safeParse(r);
-      if (result.success) {
-        const rel = result.data;
-        if (rel.source === "this") {
-          rel.source = docPath;
-        }
-        if (rel.target === "this") {
-          rel.target = docPath;
-        }
-        validRelationships.push(rel);
-      } else {
-        if (typeof r === "string") {
-          errors.push(`Relationship[${i}]: "${r}" - Expected object with {source, relation, target}, got string`);
-        } else if (typeof r === "object" && r !== null) {
-          const issues = [];
-          if (!r.source)
-            issues.push("missing source");
-          if (!r.target)
-            issues.push("missing target");
-          if (!r.relation) {
-            issues.push("missing relation");
-          } else if (!validRelationTypes.includes(r.relation)) {
-            issues.push(`invalid relation "${r.relation}" (allowed: ${validRelationTypes.join(", ")})`);
-          }
-          errors.push(`Relationship[${i}]: ${issues.join(", ")}`);
-        } else {
-          errors.push(`Relationship[${i}]: Expected object, got ${typeof r}`);
-        }
+  return entities;
+}
+// src/pure/validation.ts
+function validateDocuments(docs) {
+  const errors = [];
+  const entityIndex = new Map;
+  for (const doc of docs) {
+    for (const entity of doc.entities) {
+      let docSet = entityIndex.get(entity.name);
+      if (!docSet) {
+        docSet = new Set;
+        entityIndex.set(entity.name, docSet);
       }
+      docSet.add(doc.path);
     }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid relationship schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
-    }
-    return validRelationships;
   }
-  extractGraphMetadata(frontmatter) {
-    if (!frontmatter?.graph) {
-      return;
+  for (const doc of docs) {
+    for (const rel of doc.relationships) {
+      if (rel.source !== doc.path && !entityIndex.has(rel.source)) {
+        errors.push({
+          path: doc.path,
+          error: `Relationship source "${rel.source}" not found in any document`
+        });
+      }
+      const isDocPath = rel.target.endsWith(".md");
+      const isKnownEntity = entityIndex.has(rel.target);
+      const isSelfReference = rel.target === doc.path;
+      if (!isDocPath && !isKnownEntity && !isSelfReference) {
+        errors.push({
+          path: doc.path,
+          error: `Relationship target "${rel.target}" not found as entity`
+        });
+      }
     }
-    const result = GraphMetadataSchema.safeParse(frontmatter.graph);
-    return result.success ? result.data : undefined;
   }
-  computeHash(content) {
-    return createHash2("sha256").update(content).digest("hex");
+  return errors;
+}
+function getChangeReason(changeType) {
+  switch (changeType) {
+    case "new":
+      return "New document";
+    case "updated":
+      return "Content or frontmatter changed";
+    case "deleted":
+      return "File no longer exists";
+    case "unchanged":
+      return "No changes detected";
   }
 }
-DocumentParserService = __legacyDecorateClassTS([
-  Injectable3(),
-  __legacyMetadataTS("design:paramtypes", [])
-], DocumentParserService);
-
 // src/sync/cascade.service.ts
-import { Injectable as Injectable4, Logger as Logger3 } from "@nestjs/common";
+import { Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
 class CascadeService {
   graph;
   _parser;
-  logger = new Logger3(CascadeService.name);
+  logger = new Logger4(CascadeService.name);
   constructor(graph, _parser) {
     this.graph = graph;
     this._parser = _parser;
@@ -828,10 +1654,13 @@ class CascadeService {
   }
   async findAffectedByRename(entityName, _newName) {
     try {
-      const escapedName = this.escapeForCypher(entityName);
+      const escapedName = this.escapeForSql(entityName);
       const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
+				SELECT DISTINCT n.name, n.properties->>'title' as title
+				FROM nodes n
+				INNER JOIN relationships r ON r.target_label = n.label AND r.target_name = n.name
+				WHERE r.source_name = '${escapedName}'
+				  AND n.label = 'Document'
 			`.trim();
       const result = await this.graph.query(query);
       return (result.resultSet || []).map((row) => ({
@@ -848,10 +1677,13 @@ class CascadeService {
   }
   async findAffectedByDeletion(entityName) {
     try {
-      const escapedName = this.escapeForCypher(entityName);
+      const escapedName = this.escapeForSql(entityName);
       const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
+				SELECT DISTINCT n.name, n.properties->>'title' as title
+				FROM nodes n
+				INNER JOIN relationships r ON r.target_label = n.label AND r.target_name = n.name
+				WHERE r.source_name = '${escapedName}'
+				  AND n.label = 'Document'
 			`.trim();
       const result = await this.graph.query(query);
       return (result.resultSet || []).map((row) => ({
@@ -868,10 +1700,13 @@ class CascadeService {
   }
   async findAffectedByTypeChange(entityName, oldType, newType) {
     try {
-      const escapedName = this.escapeForCypher(entityName);
+      const escapedName = this.escapeForSql(entityName);
       const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
+				SELECT DISTINCT n.name, n.properties->>'title' as title
+				FROM nodes n
+				INNER JOIN relationships r ON r.target_label = n.label AND r.target_name = n.name
+				WHERE r.source_name = '${escapedName}'
+				  AND n.label = 'Document'
 			`.trim();
       const result = await this.graph.query(query);
       return (result.resultSet || []).map((row) => ({
@@ -888,10 +1723,13 @@ class CascadeService {
   }
   async findAffectedByRelationshipChange(entityName) {
     try {
-      const escapedName = this.escapeForCypher(entityName);
+      const escapedName = this.escapeForSql(entityName);
       const query = `
-				MATCH (e {name: '${escapedName}'})-[r]->(d:Document)
-				RETURN d.name, d.title, type(r) as relType
+				SELECT DISTINCT n.name, n.properties->>'title' as title, r.relation_type
+				FROM nodes n
+				INNER JOIN relationships r ON r.target_label = n.label AND r.target_name = n.name
+				WHERE r.source_name = '${escapedName}'
+				  AND n.label = 'Document'
 			`.trim();
       const result = await this.graph.query(query);
       return (result.resultSet || []).map((row) => ({
@@ -908,10 +1746,13 @@ class CascadeService {
   }
   async findAffectedByDocumentDeletion(documentPath) {
     try {
-      const escapedPath = this.escapeForCypher(documentPath);
+      const escapedPath = this.escapeForSql(documentPath);
       const query = `
-				MATCH (d:Document)-[r]->(deleted:Document {name: '${escapedPath}'})
-				RETURN d.name, type(r) as relType
+				SELECT DISTINCT n.name, r.relation_type
+				FROM nodes n
+				INNER JOIN relationships r ON r.source_label = n.label AND r.source_name = n.name
+				WHERE r.target_name = '${escapedPath}'
+				  AND n.label = 'Document'
 			`.trim();
       const result = await this.graph.query(query);
       return (result.resultSet || []).map((row) => ({
@@ -998,12 +1839,12 @@ class CascadeService {
         return action;
     }
   }
-  escapeForCypher(value) {
-    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"");
+  escapeForSql(value) {
+    return value.replace(/'/g, "''");
   }
 }
 CascadeService = __legacyDecorateClassTS([
-  Injectable4(),
+  Injectable9(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService,
     typeof DocumentParserService === "undefined" ? Object : DocumentParserService
@@ -1011,12 +1852,11 @@ CascadeService = __legacyDecorateClassTS([
 ], CascadeService);
 
 // src/sync/path-resolver.service.ts
-import { Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
-import { resolve as resolve3, isAbsolute } from "path";
 import { existsSync as existsSync2 } from "fs";
+import { isAbsolute, resolve as resolve4 } from "path";
+import { Injectable as Injectable10 } from "@nestjs/common";
 class PathResolverService {
   parser;
-  logger = new Logger4(PathResolverService.name);
   constructor(parser) {
     this.parser = parser;
   }
@@ -1029,10 +1869,10 @@ class PathResolverService {
     if (isAbsolute(userPath)) {
       resolvedPath = userPath;
     } else {
-      const fromCwd = resolve3(process.cwd(), userPath);
-      const fromDocs = resolve3(this.getDocsPath(), userPath);
+      const fromCwd = resolve4(process.cwd(), userPath);
+      const fromDocs = resolve4(this.getDocsPath(), userPath);
       const docsPrefix = "docs/";
-      const strippedFromDocs = userPath.startsWith(docsPrefix) ? resolve3(this.getDocsPath(), userPath.slice(docsPrefix.length)) : null;
+      const strippedFromDocs = userPath.startsWith(docsPrefix) ? resolve4(this.getDocsPath(), userPath.slice(docsPrefix.length)) : null;
       if (this.isUnderDocs(fromCwd) && existsSync2(fromCwd)) {
         resolvedPath = fromCwd;
       } else if (strippedFromDocs && existsSync2(strippedFromDocs)) {
@@ -1053,268 +1893,31 @@ class PathResolverService {
     if (requireExists && !existsSync2(resolvedPath)) {
       throw new Error(`Path "${userPath}" does not exist (resolved to: ${resolvedPath})`);
     }
-    return resolvedPath;
-  }
-  resolveDocPaths(userPaths, options = {}) {
-    return userPaths.map((p) => this.resolveDocPath(p, options));
-  }
-  isUnderDocs(absolutePath) {
-    const docsPath = this.getDocsPath();
-    const normalizedPath = absolutePath.replace(/\/$/, "");
-    const normalizedDocs = docsPath.replace(/\/$/, "");
-    return normalizedPath.startsWith(normalizedDocs + "/") || normalizedPath === normalizedDocs;
-  }
-  getRelativePath(absolutePath) {
-    const docsPath = this.getDocsPath();
-    if (absolutePath.startsWith(docsPath)) {
-      return absolutePath.slice(docsPath.length + 1);
-    }
-    return absolutePath;
-  }
-}
-PathResolverService = __legacyDecorateClassTS([
-  Injectable5(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], PathResolverService);
-
-// src/embedding/embedding.service.ts
-import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
-import { ConfigService as ConfigService2 } from "@nestjs/config";
-
-// src/embedding/embedding.types.ts
-var DEFAULT_EMBEDDING_CONFIG = {
-  provider: "voyage",
-  model: "voyage-3.5-lite",
-  dimensions: 512
-};
-
-// src/embedding/providers/openai.provider.ts
-class OpenAIEmbeddingProvider {
-  name = "openai";
-  dimensions;
-  model;
-  apiKey;
-  baseUrl = "https://api.openai.com/v1";
-  constructor(config) {
-    const apiKey = config?.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
-    }
-    this.apiKey = apiKey;
-    this.model = config?.model || "text-embedding-3-small";
-    this.dimensions = config?.dimensions || 1536;
-  }
-  async generateEmbedding(text) {
-    const embeddings = await this.generateEmbeddings([text]);
-    return embeddings[0];
-  }
-  async generateEmbeddings(texts) {
-    if (!texts || texts.length === 0) {
-      return [];
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}/embeddings`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.model,
-          input: texts,
-          dimensions: this.dimensions
-        })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`OpenAI API error: ${response.status} ${JSON.stringify(error)}`);
-      }
-      const data = await response.json();
-      const sortedData = data.data.sort((a, b) => a.index - b.index);
-      return sortedData.map((item) => item.embedding);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to generate embeddings: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-}
-
-// src/embedding/providers/voyage.provider.ts
-class VoyageEmbeddingProvider {
-  name = "voyage";
-  dimensions;
-  model;
-  apiKey;
-  inputType;
-  baseUrl = "https://api.voyageai.com/v1";
-  constructor(config) {
-    const apiKey = config?.apiKey || process.env.VOYAGE_API_KEY;
-    if (!apiKey) {
-      throw new Error("Voyage API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config.");
-    }
-    this.apiKey = apiKey;
-    this.model = config?.model || "voyage-3.5-lite";
-    this.dimensions = config?.dimensions || 512;
-    this.inputType = config?.inputType || "document";
-  }
-  async generateEmbedding(text) {
-    const embeddings = await this.generateEmbeddings([text]);
-    return embeddings[0];
-  }
-  async generateEmbeddings(texts) {
-    if (!texts || texts.length === 0) {
-      return [];
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}/embeddings`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.model,
-          input: texts,
-          output_dimension: this.dimensions,
-          input_type: this.inputType
-        })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`Voyage API error: ${response.status} ${JSON.stringify(error)}`);
-      }
-      const data = await response.json();
-      const sortedData = data.data.sort((a, b) => a.index - b.index);
-      return sortedData.map((item) => item.embedding);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to generate embeddings: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-}
-
-// src/embedding/providers/mock.provider.ts
-class MockEmbeddingProvider {
-  name = "mock";
-  dimensions;
-  constructor(dimensions = 1536) {
-    this.dimensions = dimensions;
-  }
-  async generateEmbedding(text) {
-    return this.generateDeterministicEmbedding(text);
-  }
-  async generateEmbeddings(texts) {
-    return Promise.all(texts.map((text) => this.generateEmbedding(text)));
-  }
-  generateDeterministicEmbedding(text) {
-    const embedding = new Array(this.dimensions);
-    let hash = 0;
-    for (let i = 0;i < text.length; i++) {
-      hash = (hash << 5) - hash + text.charCodeAt(i);
-      hash = hash & hash;
-    }
-    for (let i = 0;i < this.dimensions; i++) {
-      const seed = hash * (i + 1) ^ i * 31;
-      embedding[i] = (seed % 2000 - 1000) / 1000;
-    }
-    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-    return embedding.map((val) => val / magnitude);
-  }
-}
-
-// src/embedding/embedding.service.ts
-class EmbeddingService {
-  configService;
-  logger = new Logger5(EmbeddingService.name);
-  provider;
-  config;
-  constructor(configService) {
-    this.configService = configService;
-    this.config = this.loadConfig();
-    this.provider = this.createProvider();
-    this.logger.log(`Initialized embedding service with provider: ${this.provider.name}`);
-  }
-  loadConfig() {
-    const providerEnv = this.configService.get("EMBEDDING_PROVIDER");
-    const modelEnv = this.configService.get("EMBEDDING_MODEL");
-    const dimensionsEnv = this.configService.get("EMBEDDING_DIMENSIONS");
-    const provider = providerEnv ?? DEFAULT_EMBEDDING_CONFIG.provider;
-    let apiKey;
-    if (provider === "voyage") {
-      apiKey = this.configService.get("VOYAGE_API_KEY");
-    } else if (provider === "openai") {
-      apiKey = this.configService.get("OPENAI_API_KEY");
-    }
-    return {
-      provider,
-      apiKey,
-      model: modelEnv ?? DEFAULT_EMBEDDING_CONFIG.model,
-      dimensions: dimensionsEnv ? Number(dimensionsEnv) : DEFAULT_EMBEDDING_CONFIG.dimensions
-    };
-  }
-  createProvider() {
-    switch (this.config.provider) {
-      case "openai":
-        if (!this.config.apiKey) {
-          throw new Error("OPENAI_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
-        }
-        return new OpenAIEmbeddingProvider({
-          apiKey: this.config.apiKey,
-          model: this.config.model,
-          dimensions: this.config.dimensions
-        });
-      case "mock":
-        return new MockEmbeddingProvider(this.config.dimensions);
-      case "voyage":
-        if (!this.config.apiKey) {
-          throw new Error("VOYAGE_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
-        }
-        return new VoyageEmbeddingProvider({
-          apiKey: this.config.apiKey,
-          model: this.config.model,
-          dimensions: this.config.dimensions
-        });
-      case "nomic":
-        throw new Error(`Provider ${this.config.provider} not yet implemented. Use 'voyage', 'openai', or 'mock'.`);
-      default:
-        throw new Error(`Unknown embedding provider: ${this.config.provider}. Use 'voyage', 'openai', or 'mock'.`);
-    }
-  }
-  getProviderName() {
-    return this.provider.name;
+    return resolvedPath;
   }
-  getDimensions() {
-    return this.provider.dimensions;
+  resolveDocPaths(userPaths, options = {}) {
+    return userPaths.map((p) => this.resolveDocPath(p, options));
   }
-  async generateEmbedding(text) {
-    if (!text || text.trim().length === 0) {
-      throw new Error("Cannot generate embedding for empty text");
-    }
-    return this.provider.generateEmbedding(text);
+  isUnderDocs(absolutePath) {
+    const docsPath = this.getDocsPath();
+    const normalizedPath = absolutePath.replace(/\/$/, "");
+    const normalizedDocs = docsPath.replace(/\/$/, "");
+    return normalizedPath.startsWith(`${normalizedDocs}/`) || normalizedPath === normalizedDocs;
   }
-  async generateEmbeddings(texts) {
-    const validTexts = texts.filter((t) => t && t.trim().length > 0);
-    if (validTexts.length === 0) {
-      return [];
+  getRelativePath(absolutePath) {
+    const docsPath = this.getDocsPath();
+    if (absolutePath.startsWith(docsPath)) {
+      return absolutePath.slice(docsPath.length + 1);
     }
-    return this.provider.generateEmbeddings(validTexts);
-  }
-  isRealProvider() {
-    return this.provider.name !== "mock";
+    return absolutePath;
   }
 }
-EmbeddingService = __legacyDecorateClassTS([
-  Injectable6(),
+PathResolverService = __legacyDecorateClassTS([
+  Injectable10(),
   __legacyMetadataTS("design:paramtypes", [
-    typeof ConfigService2 === "undefined" ? Object : ConfigService2
+    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
   ])
-], EmbeddingService);
+], PathResolverService);
 
 // src/sync/sync.service.ts
 var ENTITY_TYPES = [
@@ -1326,37 +1929,8 @@ var ENTITY_TYPES = [
   "Person",
   "Organization"
 ];
-function validateDocuments(docs) {
-  const errors = [];
-  const entityIndex = new Map;
-  for (const doc of docs) {
-    for (const entity of doc.entities) {
-      if (!entityIndex.has(entity.name)) {
-        entityIndex.set(entity.name, new Set);
-      }
-      entityIndex.get(entity.name).add(doc.path);
-    }
-  }
-  for (const doc of docs) {
-    for (const rel of doc.relationships) {
-      if (rel.source !== doc.path && !entityIndex.has(rel.source)) {
-        errors.push({
-          path: doc.path,
-          error: `Relationship source "${rel.source}" not found in any document`
-        });
-      }
-      const isDocPath = rel.target.endsWith(".md");
-      const isKnownEntity = entityIndex.has(rel.target);
-      const isSelfReference = rel.target === doc.path;
-      if (!isDocPath && !isKnownEntity && !isSelfReference) {
-        errors.push({
-          path: doc.path,
-          error: `Relationship target "${rel.target}" not found as entity`
-        });
-      }
-    }
-  }
-  return errors;
+function validateDocuments2(docs) {
+  return validateDocuments(docs);
 }
 
 class SyncService {
@@ -1366,7 +1940,7 @@ class SyncService {
   cascade;
   pathResolver;
   embeddingService;
-  logger = new Logger6(SyncService.name);
+  logger = new Logger5(SyncService.name);
   constructor(manifest, parser, graph, cascade, pathResolver, embeddingService) {
     this.manifest = manifest;
     this.parser = parser;
@@ -1421,7 +1995,7 @@ class SyncService {
           }
         }
       }
-      const validationErrors = validateDocuments(docsToSync);
+      const validationErrors = validateDocuments2(docsToSync);
       if (validationErrors.length > 0) {
         for (const err of validationErrors) {
           result.errors.push(err);
@@ -1431,7 +2005,7 @@ class SyncService {
         result.duration = Date.now() - startTime;
         return result;
       }
-      const uniqueEntities = this.collectUniqueEntities(docsToSync);
+      const uniqueEntities = collectUniqueEntities(docsToSync);
       if (options.verbose) {
         this.logger.log(`Collected ${uniqueEntities.size} unique entities from ${docsToSync.length} documents`);
       }
@@ -1508,7 +2082,7 @@ class SyncService {
         changes.push({
           path: docPath,
           changeType,
-          reason: this.getChangeReason(changeType)
+          reason: getChangeReason(changeType)
         });
         trackedPaths.delete(docPath);
       } catch (error) {
@@ -1537,9 +2111,9 @@ class SyncService {
     await this.graph.deleteDocumentRelationships(doc.path);
     const documentProps = {
       name: doc.path,
-      title: doc.title,
+      title: doc.title ?? "",
       contentHash: doc.contentHash,
-      tags: doc.tags
+      tags: doc.tags ?? []
     };
     if (doc.summary)
       documentProps.summary = doc.summary;
@@ -1561,7 +2135,7 @@ class SyncService {
     let embeddingGenerated = false;
     if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
       try {
-        const textForEmbedding = this.composeEmbeddingText(doc);
+        const textForEmbedding = composeDocumentEmbeddingText(doc);
         if (textForEmbedding.trim()) {
           const embedding = await this.embeddingService.generateEmbedding(textForEmbedding);
           await this.graph.updateNodeEmbedding("Document", doc.path, embedding);
@@ -1623,9 +2197,9 @@ class SyncService {
     }
     return embeddingGenerated;
   }
-  async removeDocument(path) {
-    await this.graph.deleteDocumentRelationships(path);
-    await this.graph.deleteNode("Document", path);
+  async removeDocument(path2) {
+    await this.graph.deleteDocumentRelationships(path2);
+    await this.graph.deleteNode("Document", path2);
   }
   async processChange(change, options, preloadedDoc) {
     const cascadeWarnings = [];
@@ -1672,14 +2246,10 @@ class SyncService {
     }
     return cascadeWarnings;
   }
-  async clearGraph() {
-    await this.graph.query("MATCH (n) DETACH DELETE n");
-    this.logger.log("Graph cleared");
-  }
   async clearManifest() {
     const manifest = await this.manifest.load();
-    for (const path of Object.keys(manifest.documents)) {
-      this.manifest.removeEntry(path);
+    for (const path2 of Object.keys(manifest.documents)) {
+      this.manifest.removeEntry(path2);
     }
     this.logger.log("Manifest cleared");
   }
@@ -1694,80 +2264,23 @@ class SyncService {
     }
     this.logger.log(`Marked ${normalizedPaths.length} document(s) for re-sync`);
   }
-  composeEmbeddingText(doc) {
-    const parts = [];
-    if (doc.title) {
-      parts.push(`Title: ${doc.title}`);
-    }
-    if (doc.topic) {
-      parts.push(`Topic: ${doc.topic}`);
-    }
-    if (doc.tags && doc.tags.length > 0) {
-      parts.push(`Tags: ${doc.tags.join(", ")}`);
-    }
-    if (doc.entities && doc.entities.length > 0) {
-      const entityNames = doc.entities.map((e) => e.name).join(", ");
-      parts.push(`Entities: ${entityNames}`);
-    }
-    if (doc.summary) {
-      parts.push(doc.summary);
-    } else {
-      parts.push(doc.content.slice(0, 500));
-    }
-    return parts.join(" | ");
-  }
-  getChangeReason(changeType) {
-    switch (changeType) {
-      case "new":
-        return "New document";
-      case "updated":
-        return "Content or frontmatter changed";
-      case "deleted":
-        return "File no longer exists";
-      case "unchanged":
-        return "No changes detected";
-    }
-  }
-  async getOldDocumentFromManifest(path) {
+  async getOldDocumentFromManifest(path2) {
     try {
       const manifest = await this.manifest.load();
-      const entry = manifest.documents[path];
+      const entry = manifest.documents[path2];
       if (!entry) {
         return null;
       }
       try {
-        return await this.parser.parseDocument(path);
+        return await this.parser.parseDocument(path2);
       } catch {
         return null;
       }
     } catch (error) {
-      this.logger.warn(`Failed to retrieve old document for ${path}: ${error instanceof Error ? error.message : String(error)}`);
+      this.logger.warn(`Failed to retrieve old document for ${path2}: ${error instanceof Error ? error.message : String(error)}`);
       return null;
     }
   }
-  collectUniqueEntities(docs) {
-    const entities = new Map;
-    for (const doc of docs) {
-      for (const entity of doc.entities) {
-        const key = `${entity.type}:${entity.name}`;
-        if (!entities.has(key)) {
-          entities.set(key, {
-            type: entity.type,
-            name: entity.name,
-            description: entity.description,
-            documentPaths: [doc.path]
-          });
-        } else {
-          const existing = entities.get(key);
-          existing.documentPaths.push(doc.path);
-          if (entity.description && (!existing.description || entity.description.length > existing.description.length)) {
-            existing.description = entity.description;
-          }
-        }
-      }
-    }
-    return entities;
-  }
   async syncEntities(entities, options) {
     let embeddingsGenerated = 0;
     for (const [_key, entity] of entities) {
@@ -1780,7 +2293,7 @@ class SyncService {
       await this.graph.upsertNode(entity.type, entityProps);
       if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
         try {
-          const text = this.composeEntityEmbeddingText(entity);
+          const text = composeEntityEmbeddingText(entity);
           const embedding = await this.embeddingService.generateEmbedding(text);
           await this.graph.updateNodeEmbedding(entity.type, entity.name, embedding);
           embeddingsGenerated++;
@@ -1793,13 +2306,6 @@ class SyncService {
     }
     return embeddingsGenerated;
   }
-  composeEntityEmbeddingText(entity) {
-    const parts = [`${entity.type}: ${entity.name}`];
-    if (entity.description) {
-      parts.push(entity.description);
-    }
-    return parts.join(". ");
-  }
   async createEntityVectorIndices() {
     if (!this.embeddingService)
       return;
@@ -1814,7 +2320,7 @@ class SyncService {
   }
 }
 SyncService = __legacyDecorateClassTS([
-  Injectable7(),
+  Injectable11(),
   __legacyMetadataTS("design:paramtypes", [
     typeof ManifestService === "undefined" ? Object : ManifestService,
     typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
@@ -1825,170 +2331,98 @@ SyncService = __legacyDecorateClassTS([
   ])
 ], SyncService);
 
-// src/sync/ontology.service.ts
-import { Injectable as Injectable8 } from "@nestjs/common";
-class OntologyService {
-  parser;
-  constructor(parser) {
-    this.parser = parser;
-  }
-  async deriveOntology() {
-    const docs = await this.parser.parseAllDocuments();
-    return this.deriveFromDocuments(docs);
+// src/commands/status.command.ts
+class StatusCommand extends CommandRunner4 {
+  syncService;
+  manifestService;
+  constructor(syncService, manifestService) {
+    super();
+    this.syncService = syncService;
+    this.manifestService = manifestService;
   }
-  deriveFromDocuments(docs) {
-    const entityTypeSet = new Set;
-    const relationshipTypeSet = new Set;
-    const entityCounts = {};
-    const relationshipCounts = {};
-    const entityExamples = {};
-    let documentsWithEntities = 0;
-    let documentsWithoutEntities = 0;
-    let totalRelationships = 0;
-    for (const doc of docs) {
-      if (doc.entities.length > 0) {
-        documentsWithEntities++;
-      } else {
-        documentsWithoutEntities++;
-      }
-      for (const entity of doc.entities) {
-        entityTypeSet.add(entity.type);
-        entityCounts[entity.type] = (entityCounts[entity.type] || 0) + 1;
-        if (!entityExamples[entity.name]) {
-          entityExamples[entity.name] = { type: entity.type, documents: [] };
-        }
-        if (!entityExamples[entity.name].documents.includes(doc.path)) {
-          entityExamples[entity.name].documents.push(doc.path);
-        }
+  async run(_inputs, options) {
+    try {
+      await this.manifestService.load();
+      const changes = await this.syncService.detectChanges();
+      const newDocs = changes.filter((c) => c.changeType === "new");
+      const updatedDocs = changes.filter((c) => c.changeType === "updated");
+      const deletedDocs = changes.filter((c) => c.changeType === "deleted");
+      const unchangedDocs = changes.filter((c) => c.changeType === "unchanged");
+      const pendingCount = newDocs.length + updatedDocs.length + deletedDocs.length;
+      console.log(`
+\uD83D\uDCCA Graph Status
+`);
+      if (newDocs.length > 0) {
+        console.log(`New (${newDocs.length}):`);
+        newDocs.forEach((doc) => {
+          console.log(`  + ${doc.path}`);
+        });
+        console.log();
       }
-      for (const rel of doc.relationships) {
-        relationshipTypeSet.add(rel.relation);
-        relationshipCounts[rel.relation] = (relationshipCounts[rel.relation] || 0) + 1;
-        totalRelationships++;
+      if (updatedDocs.length > 0) {
+        console.log(`Updated (${updatedDocs.length}):`);
+        updatedDocs.forEach((doc) => {
+          console.log(`  ~ ${doc.path}`);
+        });
+        console.log();
       }
-    }
-    return {
-      entityTypes: Array.from(entityTypeSet).sort(),
-      relationshipTypes: Array.from(relationshipTypeSet).sort(),
-      entityCounts,
-      relationshipCounts,
-      totalEntities: Object.keys(entityExamples).length,
-      totalRelationships,
-      documentsWithEntities,
-      documentsWithoutEntities,
-      entityExamples
-    };
-  }
-  printSummary(ontology) {
-    console.log(`
-Derived Ontology Summary
-`);
-    console.log(`Documents: ${ontology.documentsWithEntities} with entities, ${ontology.documentsWithoutEntities} without`);
-    console.log(`Unique Entities: ${ontology.totalEntities}`);
-    console.log(`Total Relationships: ${ontology.totalRelationships}`);
-    console.log(`
-Entity Types:`);
-    for (const type of ontology.entityTypes) {
-      console.log(`  ${type}: ${ontology.entityCounts[type]} instances`);
-    }
-    console.log(`
-Relationship Types:`);
-    for (const type of ontology.relationshipTypes) {
-      console.log(`  ${type}: ${ontology.relationshipCounts[type]} instances`);
-    }
-    console.log(`
-Top Entities (by document count):`);
-    const sorted = Object.entries(ontology.entityExamples).sort((a, b) => b[1].documents.length - a[1].documents.length).slice(0, 10);
-    for (const [name, info] of sorted) {
-      console.log(`  ${name} (${info.type}): ${info.documents.length} docs`);
-    }
-  }
-}
-OntologyService = __legacyDecorateClassTS([
-  Injectable8(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], OntologyService);
-
-// src/embedding/embedding.module.ts
-import { Module as Module2 } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-class EmbeddingModule {
-}
-EmbeddingModule = __legacyDecorateClassTS([
-  Module2({
-    imports: [ConfigModule],
-    providers: [EmbeddingService],
-    exports: [EmbeddingService]
-  })
-], EmbeddingModule);
-
-// src/sync/sync.module.ts
-class SyncModule {
-}
-SyncModule = __legacyDecorateClassTS([
-  Module3({
-    imports: [GraphModule, EmbeddingModule],
-    providers: [
-      SyncService,
-      ManifestService,
-      DocumentParserService,
-      OntologyService,
-      CascadeService,
-      PathResolverService
-    ],
-    exports: [
-      SyncService,
-      ManifestService,
-      DocumentParserService,
-      OntologyService,
-      CascadeService,
-      PathResolverService
-    ]
-  })
-], SyncModule);
-
-// src/query/query.module.ts
-import { Module as Module4 } from "@nestjs/common";
-
-// src/query/query.service.ts
-import { Injectable as Injectable9, Logger as Logger7 } from "@nestjs/common";
-class QueryService {
-  graphService;
-  logger = new Logger7(QueryService.name);
-  constructor(graphService) {
-    this.graphService = graphService;
+      if (deletedDocs.length > 0) {
+        console.log(`Deleted (${deletedDocs.length}):`);
+        deletedDocs.forEach((doc) => {
+          console.log(`  - ${doc.path}`);
+        });
+        console.log();
+      }
+      if (options.verbose && unchangedDocs.length > 0) {
+        console.log(`Unchanged (${unchangedDocs.length}):`);
+        unchangedDocs.forEach((doc) => {
+          console.log(`  \xB7 ${doc.path}`);
+        });
+        console.log();
+      }
+      if (pendingCount === 0) {
+        console.log(`\u2705 All documents are in sync
+`);
+      } else {
+        console.log(`Total: ${pendingCount} document(s) need syncing`);
+        console.log("\uD83D\uDCA1 Run `lattice sync` to apply changes\n");
+      }
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
   }
-  async query(cypher) {
-    this.logger.debug(`Executing query: ${cypher}`);
-    return await this.graphService.query(cypher);
+  parseVerbose() {
+    return true;
   }
 }
-QueryService = __legacyDecorateClassTS([
-  Injectable9(),
+__legacyDecorateClassTS([
+  Option3({
+    flags: "-v, --verbose",
+    description: "Show all documents including unchanged"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], StatusCommand.prototype, "parseVerbose", null);
+StatusCommand = __legacyDecorateClassTS([
+  Injectable12(),
+  Command4({
+    name: "status",
+    description: "Show documents that need syncing (new or updated)"
+  }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
+    typeof SyncService === "undefined" ? Object : SyncService,
+    typeof ManifestService === "undefined" ? Object : ManifestService
   ])
-], QueryService);
-
-// src/query/query.module.ts
-class QueryModule {
-}
-QueryModule = __legacyDecorateClassTS([
-  Module4({
-    imports: [GraphModule, EmbeddingModule],
-    providers: [QueryService, GraphService],
-    exports: [QueryService, GraphService]
-  })
-], QueryModule);
-
+], StatusCommand);
 // src/commands/sync.command.ts
-import { Injectable as Injectable10 } from "@nestjs/common";
-import { Command, CommandRunner, Option } from "nest-commander";
 import { watch } from "fs";
-import { join } from "path";
-class SyncCommand extends CommandRunner {
+import { join as join2 } from "path";
+import { Injectable as Injectable13 } from "@nestjs/common";
+import { Command as Command5, CommandRunner as CommandRunner5, Option as Option4 } from "nest-commander";
+class SyncCommand extends CommandRunner5 {
   syncService;
   watcher = null;
   isShuttingDown = false;
@@ -2110,8 +2544,8 @@ class SyncCommand extends CommandRunner {
 \uD83D\uDC41\uFE0F  Watch mode enabled
 `);
     this.watcher = watch(docsPath, { recursive: true }, (event, filename) => {
-      if (filename && filename.endsWith(".md")) {
-        const fullPath = join(docsPath, filename);
+      if (filename?.endsWith(".md")) {
+        const fullPath = join2(docsPath, filename);
         trackedFiles.add(fullPath);
         debouncedSync();
       }
@@ -2150,464 +2584,166 @@ class SyncCommand extends CommandRunner {
       result.errors.forEach((e) => {
         console.log(`  ${e.path}: ${e.error}`);
       });
-    }
-    if (result.changes && result.changes.length > 0) {
-      console.log(`
-\uD83D\uDCDD Changes:
-`);
-      result.changes.forEach((c) => {
-        const icon = {
-          new: "\u2795",
-          updated: "\uD83D\uDD04",
-          deleted: "\uD83D\uDDD1\uFE0F",
-          unchanged: "\u23ED\uFE0F"
-        }[c.changeType];
-        console.log(`  ${icon} ${c.changeType}: ${c.path}`);
-        if (c.reason) {
-          console.log(`     ${c.reason}`);
-        }
-      });
-    }
-    if (result.cascadeWarnings && result.cascadeWarnings.length > 0) {
-      console.log(`
-\u26A0\uFE0F  Cascade Impacts Detected:
-`);
-      const warningsByTrigger = new Map;
-      for (const warning of result.cascadeWarnings) {
-        const existing = warningsByTrigger.get(warning.trigger) || [];
-        existing.push(warning);
-        warningsByTrigger.set(warning.trigger, existing);
-      }
-      for (const [trigger, warnings] of warningsByTrigger) {
-        const triggerLabel = trigger.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-        console.log(`  \uD83D\uDCCC ${triggerLabel}
-`);
-        for (const analysis of warnings) {
-          console.log(`    ${analysis.summary}`);
-          console.log(`    Source: ${analysis.sourceDocument}
-`);
-          if (analysis.affectedDocuments.length > 0) {
-            for (const affected of analysis.affectedDocuments) {
-              const icon = affected.confidence === "high" ? "\uD83D\uDD34" : affected.confidence === "medium" ? "\uD83D\uDFE1" : "\uD83D\uDFE2";
-              console.log(`      ${icon} [${affected.confidence.toUpperCase()}] ${affected.path}`);
-              console.log(`         ${affected.reason}`);
-              const suggestedAction = affected.suggestedAction.split("_").join(" ").replace(/\b\w/g, (char) => char.toUpperCase());
-              console.log(`         \u2192 ${suggestedAction}`);
-            }
-          } else {
-            console.log(`      \u2139\uFE0F  No directly affected documents detected`);
-          }
-          console.log();
-        }
-      }
-      console.log(`  \uD83D\uDCA1 Run /update-related to apply suggested changes
-`);
-    }
-    if (isWatchMode) {
-      console.log(`
-\u23F3 Watching for changes... (Ctrl+C to stop)
-`);
-    }
-  }
-  parseForce() {
-    return true;
-  }
-  parseDryRun() {
-    return true;
-  }
-  parseVerbose() {
-    return true;
-  }
-  parseWatch() {
-    return true;
-  }
-  parseDiff() {
-    return true;
-  }
-  parseSkipCascade() {
-    return true;
-  }
-  parseNoEmbeddings() {
-    return false;
-  }
-}
-__legacyDecorateClassTS([
-  Option({
-    flags: "-f, --force",
-    description: "Force re-sync: with paths, clears only those docs; without paths, rebuilds entire graph"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseForce", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-d, --dry-run",
-    description: "Show what would change without applying"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseDryRun", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-v, --verbose",
-    description: "Show detailed output"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseVerbose", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-w, --watch",
-    description: "Watch for file changes and sync automatically"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseWatch", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--diff",
-    description: "Show only changed documents (alias for --dry-run)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseDiff", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--skip-cascade",
-    description: "Skip cascade analysis (faster for large repos)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseSkipCascade", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--no-embeddings",
-    description: "Disable embedding generation during sync"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseNoEmbeddings", null);
-SyncCommand = __legacyDecorateClassTS([
-  Injectable10(),
-  Command({
-    name: "sync",
-    arguments: "[paths...]",
-    description: "Synchronize documents to the knowledge graph"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService
-  ])
-], SyncCommand);
-// src/commands/status.command.ts
-import { Injectable as Injectable11 } from "@nestjs/common";
-import { Command as Command2, CommandRunner as CommandRunner2, Option as Option2 } from "nest-commander";
-class StatusCommand extends CommandRunner2 {
-  syncService;
-  manifestService;
-  constructor(syncService, manifestService) {
-    super();
-    this.syncService = syncService;
-    this.manifestService = manifestService;
-  }
-  async run(_inputs, options) {
-    try {
-      await this.manifestService.load();
-      const changes = await this.syncService.detectChanges();
-      const newDocs = changes.filter((c) => c.changeType === "new");
-      const updatedDocs = changes.filter((c) => c.changeType === "updated");
-      const deletedDocs = changes.filter((c) => c.changeType === "deleted");
-      const unchangedDocs = changes.filter((c) => c.changeType === "unchanged");
-      const pendingCount = newDocs.length + updatedDocs.length + deletedDocs.length;
-      console.log(`
-\uD83D\uDCCA Graph Status
-`);
-      if (newDocs.length > 0) {
-        console.log(`New (${newDocs.length}):`);
-        newDocs.forEach((doc) => {
-          console.log(`  + ${doc.path}`);
-        });
-        console.log();
-      }
-      if (updatedDocs.length > 0) {
-        console.log(`Updated (${updatedDocs.length}):`);
-        updatedDocs.forEach((doc) => {
-          console.log(`  ~ ${doc.path}`);
-        });
-        console.log();
-      }
-      if (deletedDocs.length > 0) {
-        console.log(`Deleted (${deletedDocs.length}):`);
-        deletedDocs.forEach((doc) => {
-          console.log(`  - ${doc.path}`);
-        });
-        console.log();
-      }
-      if (options.verbose && unchangedDocs.length > 0) {
-        console.log(`Unchanged (${unchangedDocs.length}):`);
-        unchangedDocs.forEach((doc) => {
-          console.log(`  \xB7 ${doc.path}`);
-        });
-        console.log();
+    }
+    if (result.changes && result.changes.length > 0) {
+      console.log(`
+\uD83D\uDCDD Changes:
+`);
+      const icons = {
+        new: "\u2795",
+        updated: "\uD83D\uDD04",
+        deleted: "\uD83D\uDDD1\uFE0F",
+        unchanged: "\u23ED\uFE0F"
+      };
+      result.changes.forEach((c) => {
+        const icon = icons[c.changeType];
+        console.log(`  ${icon} ${c.changeType}: ${c.path}`);
+        if (c.reason) {
+          console.log(`     ${c.reason}`);
+        }
+      });
+    }
+    if (result.cascadeWarnings && result.cascadeWarnings.length > 0) {
+      console.log(`
+\u26A0\uFE0F  Cascade Impacts Detected:
+`);
+      const warningsByTrigger = new Map;
+      for (const warning of result.cascadeWarnings) {
+        const existing = warningsByTrigger.get(warning.trigger) || [];
+        existing.push(warning);
+        warningsByTrigger.set(warning.trigger, existing);
       }
-      if (pendingCount === 0) {
-        console.log(`\u2705 All documents are in sync
+      for (const [trigger, warnings] of warningsByTrigger) {
+        const triggerLabel = trigger.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+        console.log(`  \uD83D\uDCCC ${triggerLabel}
 `);
-      } else {
-        console.log(`Total: ${pendingCount} document(s) need syncing`);
-        console.log("\uD83D\uDCA1 Run `lattice sync` to apply changes\n");
+        for (const analysis of warnings) {
+          console.log(`    ${analysis.summary}`);
+          console.log(`    Source: ${analysis.sourceDocument}
+`);
+          if (analysis.affectedDocuments.length > 0) {
+            for (const affected of analysis.affectedDocuments) {
+              const icon = affected.confidence === "high" ? "\uD83D\uDD34" : affected.confidence === "medium" ? "\uD83D\uDFE1" : "\uD83D\uDFE2";
+              console.log(`      ${icon} [${affected.confidence.toUpperCase()}] ${affected.path}`);
+              console.log(`         ${affected.reason}`);
+              const suggestedAction = affected.suggestedAction.split("_").join(" ").replace(/\b\w/g, (char) => char.toUpperCase());
+              console.log(`         \u2192 ${suggestedAction}`);
+            }
+          } else {
+            console.log(`      \u2139\uFE0F  No directly affected documents detected`);
+          }
+          console.log();
+        }
       }
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
+      console.log(`  \uD83D\uDCA1 Run /update-related to apply suggested changes
+`);
+    }
+    if (isWatchMode) {
+      console.log(`
+\u23F3 Watching for changes... (Ctrl+C to stop)
+`);
     }
   }
+  parseForce() {
+    return true;
+  }
+  parseDryRun() {
+    return true;
+  }
   parseVerbose() {
     return true;
   }
+  parseWatch() {
+    return true;
+  }
+  parseDiff() {
+    return true;
+  }
+  parseSkipCascade() {
+    return true;
+  }
+  parseNoEmbeddings() {
+    return false;
+  }
 }
 __legacyDecorateClassTS([
-  Option2({
-    flags: "-v, --verbose",
-    description: "Show all documents including unchanged"
+  Option4({
+    flags: "-f, --force",
+    description: "Force re-sync: with paths, clears only those docs; without paths, rebuilds entire graph"
   }),
   __legacyMetadataTS("design:type", Function),
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
-], StatusCommand.prototype, "parseVerbose", null);
-StatusCommand = __legacyDecorateClassTS([
-  Injectable11(),
-  Command2({
-    name: "status",
-    description: "Show documents that need syncing (new or updated)"
+], SyncCommand.prototype, "parseForce", null);
+__legacyDecorateClassTS([
+  Option4({
+    flags: "-d, --dry-run",
+    description: "Show what would change without applying"
   }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService,
-    typeof ManifestService === "undefined" ? Object : ManifestService
-  ])
-], StatusCommand);
-// src/commands/query.command.ts
-import { Injectable as Injectable12 } from "@nestjs/common";
-import { Command as Command3, CommandRunner as CommandRunner3, Option as Option3 } from "nest-commander";
-class SearchCommand extends CommandRunner3 {
-  graphService;
-  embeddingService;
-  constructor(graphService, embeddingService) {
-    super();
-    this.graphService = graphService;
-    this.embeddingService = embeddingService;
-  }
-  async run(inputs, options) {
-    const query = inputs[0];
-    const limit = Math.min(parseInt(options.limit || "20", 10), 100);
-    try {
-      const queryEmbedding = await this.embeddingService.generateEmbedding(query);
-      let results;
-      if (options.label) {
-        const labelResults = await this.graphService.vectorSearch(options.label, queryEmbedding, limit);
-        results = labelResults.map((r) => ({
-          name: r.name,
-          label: options.label,
-          title: r.title,
-          score: r.score
-        }));
-      } else {
-        results = await this.graphService.vectorSearchAll(queryEmbedding, limit);
-      }
-      const labelSuffix = options.label ? ` (${options.label})` : "";
-      console.log(`
-=== Semantic Search Results for "${query}"${labelSuffix} ===
-`);
-      if (results.length === 0) {
-        console.log(`No results found.
-`);
-        if (options.label) {
-          console.log(`Tip: Try without --label to search all entity types.
-`);
-        }
-        process.exit(0);
-      }
-      results.forEach((result, idx) => {
-        console.log(`${idx + 1}. [${result.label}] ${result.name}`);
-        if (result.title) {
-          console.log(`   Title: ${result.title}`);
-        }
-        if (result.description && result.label !== "Document") {
-          const desc = result.description.length > 80 ? result.description.slice(0, 80) + "..." : result.description;
-          console.log(`   ${desc}`);
-        }
-        console.log(`   Similarity: ${(result.score * 100).toFixed(2)}%`);
-      });
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      console.error("Error:", errorMsg);
-      if (errorMsg.includes("no embeddings") || errorMsg.includes("vector")) {
-        console.log(`
-Note: Semantic search requires embeddings to be generated first.`);
-        console.log(`Run 'lattice sync' to generate embeddings for documents.
-`);
-      }
-      process.exit(1);
-    }
-  }
-  parseLabel(value) {
-    return value;
-  }
-  parseLimit(value) {
-    return value;
-  }
-}
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseDryRun", null);
 __legacyDecorateClassTS([
-  Option3({
-    flags: "-l, --label <label>",
-    description: "Filter by entity label (e.g., Technology, Concept, Document)"
+  Option4({
+    flags: "-v, --verbose",
+    description: "Show detailed output"
   }),
   __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", [
-    String
-  ]),
-  __legacyMetadataTS("design:returntype", String)
-], SearchCommand.prototype, "parseLabel", null);
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseVerbose", null);
 __legacyDecorateClassTS([
-  Option3({
-    flags: "--limit <n>",
-    description: "Limit results",
-    defaultValue: "20"
+  Option4({
+    flags: "-w, --watch",
+    description: "Watch for file changes and sync automatically"
   }),
   __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", [
-    String
-  ]),
-  __legacyMetadataTS("design:returntype", String)
-], SearchCommand.prototype, "parseLimit", null);
-SearchCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "search",
-    arguments: "<query>",
-    description: "Semantic search across the knowledge graph"
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseWatch", null);
+__legacyDecorateClassTS([
+  Option4({
+    flags: "--diff",
+    description: "Show only changed documents (alias for --dry-run)"
   }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
-  ])
-], SearchCommand);
-
-class RelsCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
-  }
-  async run(inputs) {
-    const name = inputs[0];
-    try {
-      const escapedName = name.replace(/'/g, "\\'");
-      const cypher = `MATCH (a { name: '${escapedName}' })-[r]-(b) RETURN a, r, b`;
-      const result = await this.graphService.query(cypher);
-      const results = result.resultSet || [];
-      console.log(`
-=== Relationships for "${name}" ===
-`);
-      if (results.length === 0) {
-        console.log(`No relationships found.
-`);
-        process.exit(0);
-      }
-      const incoming = [];
-      const outgoing = [];
-      results.forEach((row) => {
-        const [source, rel, target] = row;
-        const sourceObj = Object.fromEntries(source);
-        const targetObj = Object.fromEntries(target);
-        const relObj = Object.fromEntries(rel);
-        const sourceProps = Object.fromEntries(sourceObj.properties || []);
-        const targetProps = Object.fromEntries(targetObj.properties || []);
-        const sourceName = sourceProps.name || "unknown";
-        const targetName = targetProps.name || "unknown";
-        const relType = relObj.type || "UNKNOWN";
-        if (sourceName === name) {
-          outgoing.push(`  -[${relType}]-> ${targetName}`);
-        } else {
-          incoming.push(`  <-[${relType}]- ${sourceName}`);
-        }
-      });
-      if (outgoing.length > 0) {
-        console.log("Outgoing:");
-        outgoing.forEach((r) => console.log(r));
-      }
-      if (incoming.length > 0) {
-        if (outgoing.length > 0)
-          console.log();
-        console.log("Incoming:");
-        incoming.forEach((r) => console.log(r));
-      }
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-RelsCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "rels",
-    arguments: "<name>",
-    description: "Show relationships for a node"
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseDiff", null);
+__legacyDecorateClassTS([
+  Option4({
+    flags: "--skip-cascade",
+    description: "Skip cascade analysis (faster for large repos)"
   }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], RelsCommand);
-
-class CypherCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
-  }
-  async run(inputs) {
-    const query = inputs[0];
-    try {
-      const result = await this.graphService.query(query);
-      console.log(`
-=== Cypher Query Results ===
-`);
-      console.log(JSON.stringify(result, null, 2));
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-CypherCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "cypher",
-    arguments: "<query>",
-    description: "Execute raw Cypher query"
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseSkipCascade", null);
+__legacyDecorateClassTS([
+  Option4({
+    flags: "--no-embeddings",
+    description: "Disable embedding generation during sync"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseNoEmbeddings", null);
+SyncCommand = __legacyDecorateClassTS([
+  Injectable13(),
+  Command5({
+    name: "sync",
+    arguments: "[paths...]",
+    description: "Synchronize documents to the knowledge graph"
   }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
+    typeof SyncService === "undefined" ? Object : SyncService
   ])
-], CypherCommand);
+], SyncCommand);
 // src/commands/validate.command.ts
-import { Injectable as Injectable13 } from "@nestjs/common";
-import { Command as Command4, CommandRunner as CommandRunner4, Option as Option4 } from "nest-commander";
-class ValidateCommand extends CommandRunner4 {
+import { Injectable as Injectable14 } from "@nestjs/common";
+import { Command as Command6, CommandRunner as CommandRunner6, Option as Option5 } from "nest-commander";
+class ValidateCommand extends CommandRunner6 {
   parserService;
   constructor(parserService) {
     super();
@@ -2629,13 +2765,15 @@ class ValidateCommand extends CommandRunner4 {
       const entityIndex = new Map;
       for (const doc of docs) {
         for (const entity of doc.entities) {
-          if (!entityIndex.has(entity.name)) {
-            entityIndex.set(entity.name, new Set);
+          let docPaths = entityIndex.get(entity.name);
+          if (!docPaths) {
+            docPaths = new Set;
+            entityIndex.set(entity.name, docPaths);
           }
-          entityIndex.get(entity.name).add(doc.path);
+          docPaths.add(doc.path);
         }
       }
-      const validationErrors = validateDocuments(docs);
+      const validationErrors = validateDocuments2(docs);
       for (const err of validationErrors) {
         issues.push({
           type: "error",
@@ -2673,7 +2811,7 @@ class ValidateCommand extends CommandRunner4 {
   }
 }
 __legacyDecorateClassTS([
-  Option4({
+  Option5({
     flags: "--fix",
     description: "Show suggestions for common issues"
   }),
@@ -2682,8 +2820,8 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], ValidateCommand.prototype, "parseFix", null);
 ValidateCommand = __legacyDecorateClassTS([
-  Injectable13(),
-  Command4({
+  Injectable14(),
+  Command6({
     name: "validate",
     description: "Validate entity references and relationships across documents"
   }),
@@ -2691,138 +2829,90 @@ ValidateCommand = __legacyDecorateClassTS([
     typeof DocumentParserService === "undefined" ? Object : DocumentParserService
   ])
 ], ValidateCommand);
-// src/commands/ontology.command.ts
-import { Injectable as Injectable14 } from "@nestjs/common";
-import { Command as Command5, CommandRunner as CommandRunner5 } from "nest-commander";
-class OntologyCommand extends CommandRunner5 {
-  ontologyService;
-  constructor(ontologyService) {
-    super();
-    this.ontologyService = ontologyService;
+// src/embedding/embedding.module.ts
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+class EmbeddingModule {
+}
+EmbeddingModule = __legacyDecorateClassTS([
+  Module({
+    imports: [ConfigModule],
+    providers: [EmbeddingService],
+    exports: [EmbeddingService]
+  })
+], EmbeddingModule);
+
+// src/graph/graph.module.ts
+import { Module as Module2 } from "@nestjs/common";
+class GraphModule {
+}
+GraphModule = __legacyDecorateClassTS([
+  Module2({
+    providers: [GraphService],
+    exports: [GraphService]
+  })
+], GraphModule);
+
+// src/query/query.module.ts
+import { Module as Module3 } from "@nestjs/common";
+
+// src/query/query.service.ts
+import { Injectable as Injectable15, Logger as Logger6 } from "@nestjs/common";
+class QueryService {
+  graphService;
+  logger = new Logger6(QueryService.name);
+  constructor(graphService) {
+    this.graphService = graphService;
   }
-  async run() {
-    try {
-      const ontology = await this.ontologyService.deriveOntology();
-      this.ontologyService.printSummary(ontology);
-      process.exit(0);
-    } catch (error) {
-      console.error(`
-\u274C Ontology derivation failed:`, error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
+  async query(sql) {
+    this.logger.debug(`Executing query: ${sql}`);
+    return await this.graphService.query(sql);
   }
 }
-OntologyCommand = __legacyDecorateClassTS([
-  Injectable14(),
-  Command5({
-    name: "ontology",
-    description: "Derive and display ontology from all documents"
-  }),
+QueryService = __legacyDecorateClassTS([
+  Injectable15(),
   __legacyMetadataTS("design:paramtypes", [
-    typeof OntologyService === "undefined" ? Object : OntologyService
+    typeof GraphService === "undefined" ? Object : GraphService
   ])
-], OntologyCommand);
-// src/commands/init.command.ts
-import { Injectable as Injectable15 } from "@nestjs/common";
-import { Command as Command6, CommandRunner as CommandRunner6, Option as Option5 } from "nest-commander";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { homedir } from "os";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var COMMANDS = ["research.md", "graph-sync.md", "entity-extract.md"];
+], QueryService);
 
-class InitCommand extends CommandRunner6 {
-  async run(_inputs, options) {
-    try {
-      const targetDir = options.global ? path.join(homedir(), ".claude", "commands") : path.join(process.cwd(), ".claude", "commands");
-      let commandsSourceDir = path.resolve(__dirname2, "..", "commands");
-      try {
-        await fs.access(commandsSourceDir);
-      } catch {
-        commandsSourceDir = path.resolve(__dirname2, "..", "..", "commands");
-      }
-      try {
-        await fs.access(commandsSourceDir);
-      } catch {
-        console.error("Error: Commands source directory not found at", commandsSourceDir);
-        console.error("This may indicate a corrupted installation. Try reinstalling @zabaca/lattice.");
-        process.exit(1);
-      }
-      await fs.mkdir(targetDir, { recursive: true });
-      let copied = 0;
-      let skipped = 0;
-      const installed = [];
-      for (const file of COMMANDS) {
-        const sourcePath = path.join(commandsSourceDir, file);
-        const targetPath = path.join(targetDir, file);
-        try {
-          await fs.access(sourcePath);
-          try {
-            await fs.access(targetPath);
-            const sourceContent = await fs.readFile(sourcePath, "utf-8");
-            const targetContent = await fs.readFile(targetPath, "utf-8");
-            if (sourceContent === targetContent) {
-              skipped++;
-              continue;
-            }
-          } catch {}
-          await fs.copyFile(sourcePath, targetPath);
-          installed.push(file);
-          copied++;
-        } catch (err) {
-          console.error(`Warning: Could not copy ${file}:`, err instanceof Error ? err.message : String(err));
-        }
-      }
-      console.log();
-      console.log(`\u2705 Lattice commands installed to ${targetDir}`);
-      console.log();
-      if (copied > 0) {
-        console.log(`Installed ${copied} command(s):`);
-        installed.forEach((f) => {
-          const name = f.replace(".md", "");
-          console.log(`  - /${name}`);
-        });
-      }
-      if (skipped > 0) {
-        console.log(`Skipped ${skipped} unchanged command(s)`);
-      }
-      console.log();
-      console.log("Available commands in Claude Code:");
-      console.log("  /research <topic>    - AI-assisted research workflow");
-      console.log("  /graph-sync          - Extract entities and sync to graph");
-      console.log("  /entity-extract      - Extract entities from a single document");
-      console.log();
-      if (!options.global) {
-        console.log("\uD83D\uDCA1 Tip: Use 'lattice init --global' to install for all projects");
-      }
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseGlobal() {
-    return true;
-  }
+// src/query/query.module.ts
+class QueryModule {
 }
-__legacyDecorateClassTS([
-  Option5({
-    flags: "-g, --global",
-    description: "Install to ~/.claude/commands/ (available in all projects)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], InitCommand.prototype, "parseGlobal", null);
-InitCommand = __legacyDecorateClassTS([
-  Injectable15(),
-  Command6({
-    name: "init",
-    description: "Install Claude Code slash commands for Lattice"
+QueryModule = __legacyDecorateClassTS([
+  Module3({
+    imports: [GraphModule, EmbeddingModule],
+    providers: [QueryService, GraphService],
+    exports: [QueryService, GraphService]
   })
-], InitCommand);
+], QueryModule);
+
+// src/sync/sync.module.ts
+import { Module as Module4 } from "@nestjs/common";
+class SyncModule {
+}
+SyncModule = __legacyDecorateClassTS([
+  Module4({
+    imports: [GraphModule, EmbeddingModule],
+    providers: [
+      SyncService,
+      ManifestService,
+      DocumentParserService,
+      OntologyService,
+      CascadeService,
+      PathResolverService
+    ],
+    exports: [
+      SyncService,
+      ManifestService,
+      DocumentParserService,
+      OntologyService,
+      CascadeService,
+      PathResolverService
+    ]
+  })
+], SyncModule);
+
 // src/app.module.ts
 class AppModule {
 }
@@ -2842,7 +2932,7 @@ AppModule = __legacyDecorateClassTS([
       StatusCommand,
       SearchCommand,
       RelsCommand,
-      CypherCommand,
+      SqlCommand,
       ValidateCommand,
       OntologyCommand,
       InitCommand