@zabaca/lattice 1.0.11 → 1.0.17

package/dist/main.js

@@ -23,17 +23,350 @@ import { CommandFactory } from "nest-commander";
 import { Module as Module5 } from "@nestjs/common";
 import { ConfigModule as ConfigModule2 } from "@nestjs/config";
 
+// src/commands/extract.command.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+import { Injectable as Injectable2 } from "@nestjs/common";
+import { Command, CommandRunner, Option } from "nest-commander";
+
+// src/sync/entity-extractor.service.ts
+import { readFile } from "fs/promises";
+import {
+  createSdkMcpServer,
+  query,
+  tool
+} from "@anthropic-ai/claude-agent-sdk";
+import { Injectable, Logger } from "@nestjs/common";
+import { z } from "zod";
+function validateExtraction(input, _filePath) {
+  const errors = [];
+  const { entities, relationships } = input ?? {};
+  if (!entities || !Array.isArray(entities)) {
+    return ["Entities array is missing or invalid"];
+  }
+  if (!relationships || !Array.isArray(relationships)) {
+    return ["Relationships array is missing or invalid"];
+  }
+  const entityNames = new Set(entities.map((e) => e.name));
+  for (const rel of relationships) {
+    if (rel.source !== "this" && !entityNames.has(rel.source)) {
+      errors.push(`Relationship source "${rel.source}" not found in extracted entities`);
+    }
+    if (!entityNames.has(rel.target)) {
+      errors.push(`Relationship target "${rel.target}" not found in extracted entities`);
+    }
+  }
+  return errors;
+}
+function createValidationServer(filePath) {
+  return createSdkMcpServer({
+    name: "entity-validator",
+    version: "1.0.0",
+    tools: [
+      tool("validate_extraction", "Validate your extracted entities and relationships. Call this to check your work before finishing.", {
+        entities: z.array(z.object({
+          name: z.string().min(1),
+          type: z.enum([
+            "Topic",
+            "Technology",
+            "Concept",
+            "Tool",
+            "Process",
+            "Person",
+            "Organization",
+            "Document"
+          ]),
+          description: z.string().min(1)
+        })),
+        relationships: z.array(z.object({
+          source: z.string().min(1),
+          relation: z.enum(["REFERENCES"]),
+          target: z.string().min(1)
+        })),
+        summary: z.string().min(10)
+      }, async (args) => {
+        const errors = validateExtraction(args, filePath);
+        if (errors.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "\u2713 Validation passed. Your extraction is correct."
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u2717 Validation failed:
+${errors.map((e) => `- ${e}`).join(`
+`)}
+
+Please fix these errors and call validate_extraction again.`
+            }
+          ]
+        };
+      })
+    ]
+  });
+}
+
+class EntityExtractorService {
+  logger = new Logger(EntityExtractorService.name);
+  lastExtractionTime = 0;
+  minIntervalMs = 500;
+  async extractFromDocument(filePath) {
+    await this.rateLimit();
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const promptText = this.buildExtractionPrompt(filePath, content);
+      const validationServer = createValidationServer(filePath);
+      let lastValidExtraction = null;
+      for await (const message of query({
+        prompt: promptText,
+        options: {
+          maxTurns: 3,
+          model: "claude-haiku-4-5-20251001",
+          mcpServers: {
+            "entity-validator": validationServer
+          },
+          allowedTools: ["mcp__entity-validator__validate_extraction"],
+          permissionMode: "default"
+        }
+      })) {
+        if (message.type === "assistant") {
+          for (const block of message.message?.content ?? []) {
+            if (block.type === "tool_use" && block.name === "mcp__entity-validator__validate_extraction") {
+              const input = block.input;
+              const validationErrors = validateExtraction(input, filePath);
+              if (validationErrors.length === 0) {
+                lastValidExtraction = input;
+              }
+            }
+          }
+        } else if (message.type === "result") {
+          if (lastValidExtraction) {
+            this.logger.debug(`Extraction for ${filePath} completed in ${message.duration_ms}ms`);
+            return this.buildSuccessResult(lastValidExtraction, filePath);
+          }
+          const errorReason = message.subtype === "error_max_turns" ? "Max turns reached without valid extraction" : message.subtype === "error_during_execution" ? "Error during execution" : `Extraction failed: ${message.subtype}`;
+          return {
+            entities: [],
+            relationships: [],
+            summary: "",
+            success: false,
+            error: errorReason
+          };
+        }
+      }
+      throw new Error("No result received from SDK");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Entity extraction failed for ${filePath}: ${errorMsg}`);
+      return {
+        entities: [],
+        relationships: [],
+        summary: "",
+        success: false,
+        error: errorMsg
+      };
+    }
+  }
+  async extractFromDocuments(filePaths, onProgress) {
+    const results = new Map;
+    for (let i = 0;i < filePaths.length; i++) {
+      const path = filePaths[i];
+      onProgress?.(i, filePaths.length, path);
+      const result = await this.extractFromDocument(path);
+      results.set(path, result);
+    }
+    return results;
+  }
+  async rateLimit() {
+    const now = Date.now();
+    const elapsed = now - this.lastExtractionTime;
+    if (elapsed < this.minIntervalMs) {
+      const waitTime = this.minIntervalMs - elapsed;
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    this.lastExtractionTime = Date.now();
+  }
+  buildExtractionPrompt(filePath, content) {
+    return `Analyze this markdown document and extract entities, relationships, and a summary.
+
+File: ${filePath}
+
+<document>
+${content}
+</document>
+
+## Instructions
+
+Extract the following and call the validation tool with EXACTLY this schema:
+
+### 1. Entities (array of 3-10 objects)
+Each entity must have:
+- "name": string (entity name)
+- "type": one of "Topic", "Technology", "Concept", "Tool", "Process", "Person", "Organization", "Document"
+- "description": string (brief description)
+
+### 2. Relationships (array of objects)
+Each relationship must have:
+- "source": "this" (for document-to-entity) or an entity name
+- "relation": "REFERENCES" (IMPORTANT: use "relation", not "type")
+- "target": an entity name from your entities list
+
+### 3. Summary
+A 50-100 word summary of the document's main purpose and key concepts.
+
+## IMPORTANT: Validation Required
+
+You MUST call mcp__entity-validator__validate_extraction tool.
+Pass the three fields DIRECTLY as top-level arguments (NOT wrapped in an "extraction" object):
+- entities: your entities array
+- relationships: your relationships array
+- summary: your summary string
+
+Example tool call structure:
+{
+  "entities": [...],
+  "relationships": [...],
+  "summary": "..."
+}
+
+If validation fails, fix the errors and call the tool again.
+Only finish after validation passes.`;
+  }
+  buildSuccessResult(extraction, filePath) {
+    const relationships = extraction.relationships.map((rel) => ({
+      ...rel,
+      source: rel.source === "this" ? filePath : rel.source
+    }));
+    return {
+      entities: extraction.entities,
+      relationships,
+      summary: extraction.summary,
+      success: true
+    };
+  }
+}
+EntityExtractorService = __legacyDecorateClassTS([
+  Injectable()
+], EntityExtractorService);
+
+// src/commands/extract.command.ts
+class ExtractCommand extends CommandRunner {
+  entityExtractor;
+  constructor(entityExtractor) {
+    super();
+    this.entityExtractor = entityExtractor;
+  }
+  async run(inputs, options) {
+    const [filePath] = inputs;
+    if (!filePath) {
+      console.error("Error: File path is required");
+      console.error("Usage: lattice extract <file>");
+      process.exit(1);
+    }
+    const absolutePath = resolve(process.cwd(), filePath);
+    if (!existsSync(absolutePath)) {
+      console.error(`Error: File not found: ${absolutePath}`);
+      process.exit(1);
+    }
+    try {
+      console.error(`Extracting entities from: ${absolutePath}
+`);
+      if (options.raw) {
+        await this.extractRaw(absolutePath);
+      } else {
+        const result = await this.entityExtractor.extractFromDocument(absolutePath);
+        const output = options.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+        console.log(output);
+        process.exit(result.success ? 0 : 1);
+      }
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+  async extractRaw(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    const prompt = this.entityExtractor.buildExtractionPrompt(filePath, content);
+    console.error("--- Prompt ---");
+    console.error(`${prompt.substring(0, 500)}...
+`);
+    console.error("--- Raw Response ---");
+    let rawResponse = "";
+    for await (const message of query2({
+      prompt,
+      options: {
+        maxTurns: 5,
+        model: "claude-haiku-4-5-20251001",
+        allowedTools: [],
+        permissionMode: "default"
+      }
+    })) {
+      if (message.type === "assistant" && message.message?.content) {
+        for (const block of message.message.content) {
+          if ("text" in block) {
+            rawResponse += block.text;
+          }
+        }
+      }
+    }
+    console.log(rawResponse);
+    process.exit(0);
+  }
+  parsePretty() {
+    return true;
+  }
+  parseRaw() {
+    return true;
+  }
+}
+__legacyDecorateClassTS([
+  Option({
+    flags: "-p, --pretty",
+    description: "Pretty-print JSON output"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], ExtractCommand.prototype, "parsePretty", null);
+__legacyDecorateClassTS([
+  Option({
+    flags: "-r, --raw",
+    description: "Show raw Claude response (for debugging parse errors)"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], ExtractCommand.prototype, "parseRaw", null);
+ExtractCommand = __legacyDecorateClassTS([
+  Injectable2(),
+  Command({
+    name: "extract",
+    description: "Extract entities from a document (debug tool)",
+    arguments: "<file>"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof EntityExtractorService === "undefined" ? Object : EntityExtractorService
+  ])
+], ExtractCommand);
 // src/commands/init.command.ts
-import { existsSync as existsSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, writeFileSync } from "fs";
 import * as fs from "fs/promises";
 import { homedir as homedir2 } from "os";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { Injectable } from "@nestjs/common";
-import { Command, CommandRunner } from "nest-commander";
+import { Injectable as Injectable3 } from "@nestjs/common";
+import { Command as Command2, CommandRunner as CommandRunner2 } from "nest-commander";
 
 // src/utils/paths.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync as existsSync2, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var latticeHomeOverride = null;
@@ -60,11 +393,11 @@ function getEnvPath() {
 }
 function ensureLatticeHome() {
   const home = getLatticeHomeInternal();
-  if (!existsSync(home)) {
+  if (!existsSync2(home)) {
     mkdirSync(home, { recursive: true });
   }
   const docsPath = getDocsPath();
-  if (!existsSync(docsPath)) {
+  if (!existsSync2(docsPath)) {
     mkdirSync(docsPath, { recursive: true });
   }
 }
@@ -74,12 +407,12 @@ 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 {
+class InitCommand extends CommandRunner2 {
   async run(_inputs, _options) {
     try {
       ensureLatticeHome();
       const envPath = getEnvPath();
-      if (!existsSync2(envPath)) {
+      if (!existsSync3(envPath)) {
         writeFileSync(envPath, `# Lattice Configuration
 # Get your API key from: https://www.voyageai.com/
 
@@ -158,1504 +491,1224 @@ VOYAGE_API_KEY=
   }
 }
 InitCommand = __legacyDecorateClassTS([
-  Injectable(),
-  Command({
+  Injectable3(),
+  Command2({
     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 { Injectable as Injectable2, Logger } from "@nestjs/common";
-import { glob } from "glob";
+// src/commands/migrate.command.ts
+import { Injectable as Injectable12, Logger as Logger8 } from "@nestjs/common";
+import { Command as Command3, CommandRunner as CommandRunner3, Option as Option2 } from "nest-commander";
 
-// src/utils/frontmatter.ts
-import matter from "gray-matter";
-import { z } from "zod";
-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().min(1)
-});
-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/graph/graph.service.ts
+import { DuckDBInstance } from "@duckdb/node-api";
+import { Injectable as Injectable4, Logger as Logger2 } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+class GraphService {
+  configService;
+  logger = new Logger2(GraphService.name);
+  instance = null;
+  connection = null;
+  dbPath;
+  connecting = null;
+  vectorIndexes = new Set;
+  embeddingDimensions;
+  signalHandlersRegistered = false;
+  constructor(configService) {
+    this.configService = configService;
+    ensureLatticeHome();
+    this.dbPath = getDatabasePath();
+    this.embeddingDimensions = this.configService.get("EMBEDDING_DIMENSIONS") || 512;
+    this.registerSignalHandlers();
   }
-  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
+  registerSignalHandlers() {
+    if (this.signalHandlersRegistered)
+      return;
+    this.signalHandlersRegistered = true;
+    const gracefulShutdown = async (signal) => {
+      this.logger.log(`Received ${signal}, checkpointing before exit...`);
+      try {
+        await this.checkpoint();
+        await this.disconnect();
+      } catch (error) {
+        this.logger.error(`Error during graceful shutdown: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      process.exit(0);
     };
-  } 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];
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+    process.on("beforeExit", async () => {
+      if (this.connection) {
+        await this.checkpoint();
+      }
+    });
   }
-  if (Array.isArray(data)) {
-    return data.map(normalizeData);
+  async onModuleDestroy() {
+    await this.disconnect();
   }
-  if (data !== null && typeof data === "object") {
-    const normalized = {};
-    for (const [key, value] of Object.entries(data)) {
-      normalized[key] = normalizeData(value);
+  async ensureConnected() {
+    if (this.connection) {
+      return this.connection;
     }
-    return normalized;
-  }
-  return data;
-}
-
-// src/sync/document-parser.service.ts
-class DocumentParserService {
-  logger = new Logger(DocumentParserService.name);
-  docsPath;
-  constructor() {
-    ensureLatticeHome();
-    this.docsPath = getDocsPath();
-  }
-  getDocsPath() {
-    return this.docsPath;
+    if (this.connecting) {
+      await this.connecting;
+      if (!this.connection) {
+        throw new Error("Connection failed to establish");
+      }
+      return this.connection;
+    }
+    this.connecting = this.connect();
+    await this.connecting;
+    this.connecting = null;
+    if (!this.connection) {
+      throw new Error("Connection failed to establish");
+    }
+    return this.connection;
   }
-  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) {
+  async connect() {
+    try {
+      this.instance = await DuckDBInstance.create(":memory:", {
+        allow_unsigned_extensions: "true"
+      });
+      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 {
-        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}`);
+        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.connection.run(`ATTACH '${this.dbPath}' AS lattice (READ_WRITE);`);
+      await this.connection.run("USE lattice;");
+      await this.initializeSchema();
+      await this.connection.run("FORCE CHECKPOINT lattice;");
+      this.logger.log(`Connected to DuckDB (in-memory + ATTACH) at ${this.dbPath}`);
+    } catch (error) {
+      this.connection = null;
+      this.instance = null;
+      this.logger.error(`Failed to connect to DuckDB: ${error instanceof Error ? error.message : String(error)}`);
+      throw 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);
-        const zodErrors = result.error.issues.map((issue) => {
-          const path2 = issue.path.length > 0 ? issue.path.join(".") : "root";
-          return `${path2}: ${issue.message}`;
-        }).join("; ");
-        errors.push(`Entity[${i}]: ${entityPreview} - ${zodErrors}`);
-      }
+  async disconnect() {
+    if (this.connection) {
+      await this.checkpoint();
+      this.connection.closeSync();
+      this.connection = null;
+      this.logger.log("Disconnected from DuckDB");
     }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid entity schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
+    if (this.instance) {
+      this.instance = null;
     }
-    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}`);
-        }
-      }
+  async checkpoint() {
+    if (!this.connection) {
+      return;
     }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid relationship schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
+    try {
+      await this.connection.run("FORCE CHECKPOINT lattice;");
+      this.logger.debug("Checkpoint completed");
+    } catch (error) {
+      this.logger.warn(`Checkpoint failed: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return validRelationships;
   }
-  extractGraphMetadata(frontmatter) {
-    const fm = frontmatter;
-    if (!fm?.graph) {
-      return;
+  async initializeSchema() {
+    if (!this.connection) {
+      throw new Error("Cannot initialize schema: not connected");
     }
-    const result = GraphMetadataSchema.safeParse(fm.graph);
-    return result.success ? result.data : undefined;
-  }
-  computeHash(content) {
-    return createHash("sha256").update(content).digest("hex");
+    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)");
+    await this.applyV2SchemaMigration(conn);
   }
-}
-DocumentParserService = __legacyDecorateClassTS([
-  Injectable2(),
-  __legacyMetadataTS("design:paramtypes", [])
-], DocumentParserService);
-
-// src/sync/ontology.service.ts
-class OntologyService {
-  parser;
-  constructor(parser) {
-    this.parser = parser;
+  async applyV2SchemaMigration(conn) {
+    try {
+      await conn.run("ALTER TABLE nodes ADD COLUMN IF NOT EXISTS content_hash VARCHAR");
+    } catch {}
+    try {
+      await conn.run("ALTER TABLE nodes ADD COLUMN IF NOT EXISTS embedding_source_hash VARCHAR");
+    } catch {}
+    try {
+      await conn.run("ALTER TABLE nodes ADD COLUMN IF NOT EXISTS extraction_method VARCHAR DEFAULT 'frontmatter'");
+    } catch {}
+    try {
+      await conn.run("CREATE INDEX IF NOT EXISTS idx_nodes_content_hash ON nodes(content_hash) WHERE label = 'Document'");
+    } catch {}
   }
-  async deriveOntology() {
-    const docs = await this.parser.parseAllDocuments();
-    return this.deriveFromDocuments(docs);
+  async runV2Migration() {
+    const conn = await this.ensureConnected();
+    await this.applyV2SchemaMigration(conn);
+    this.logger.log("V2 schema migration completed");
   }
-  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++;
-      }
+  async query(sql, _params) {
+    try {
+      const conn = await this.ensureConnected();
+      const reader = await conn.runAndReadAll(sql);
+      const rows = reader.getRows();
+      return {
+        resultSet: rows,
+        stats: undefined
+      };
+    } catch (error) {
+      this.logger.error(`Query failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
     }
-    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`);
+  async upsertNode(label, properties) {
+    try {
+      const { name, ...otherProps } = properties;
+      if (!name) {
+        throw new Error("Node must have a 'name' property");
+      }
+      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;
     }
   }
-}
-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() {
+  async upsertRelationship(sourceLabel, sourceName, relation, targetLabel, targetName, properties) {
     try {
-      const ontology = await this.ontologyService.deriveOntology();
-      this.ontologyService.printSummary(ontology);
-      process.exit(0);
+      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) {
-      console.error(`
-\u274C Ontology derivation failed:`, error instanceof Error ? error.message : String(error));
-      process.exit(1);
+      this.logger.error(`Failed to upsert relationship: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
     }
   }
-}
-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 } from "nest-commander";
-
-// src/embedding/embedding.service.ts
-import { Injectable as Injectable5, Logger as Logger2 } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-
-// src/schemas/config.schemas.ts
-import { z as z2 } from "zod";
-var DuckDBConfigSchema = z2.object({
-  embeddingDimensions: z2.coerce.number().int().positive().default(512)
-});
-var EmbeddingConfigSchema = z2.object({
-  provider: z2.enum(["openai", "voyage", "nomic", "mock"]).default("voyage"),
-  apiKey: z2.string().optional(),
-  model: z2.string().min(1).default("voyage-3.5-lite"),
-  dimensions: z2.coerce.number().int().positive().default(512)
-});
-
-// 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;
+  async deleteNode(label, name) {
+    try {
+      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;
     }
-    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.");
+  async deleteDocumentRelationships(documentPath) {
+    try {
+      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;
     }
-    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) {
+  async findNodesByLabel(label, limit) {
+    try {
+      const conn = await this.ensureConnected();
+      const limitClause = limit ? ` LIMIT ${limit}` : "";
+      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 [];
     }
+  }
+  async findRelationships(nodeName) {
     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
-        })
+      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];
       });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`OpenAI API error: ${response.status} ${JSON.stringify(error)}`);
+    } catch (error) {
+      this.logger.error(`Failed to find relationships: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
+  async createVectorIndex(label, property, dimensions) {
+    try {
+      const indexKey = `${label}_${property}`;
+      if (this.vectorIndexes.has(indexKey)) {
+        return;
       }
-      const data = await response.json();
-      const sortedData = data.data.sort((a, b) => a.index - b.index);
-      return sortedData.map((item) => item.embedding);
+      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) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to generate embeddings: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (!errorMessage.includes("already exists")) {
+        this.logger.error(`Failed to create vector index: ${errorMessage}`);
+        throw error;
       }
-      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().nonnegative()
-  })
-});
-
-// 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.");
+  async updateNodeEmbedding(label, name, embedding) {
+    try {
+      const conn = await this.ensureConnected();
+      const vectorStr = `[${embedding.join(", ")}]`;
+      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;
     }
-    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 vectorSearch(label, queryVector, k = 10) {
+    try {
+      const conn = await this.ensureConnected();
+      const vectorStr = `[${queryVector.join(", ")}]`;
+      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 generateQueryEmbedding(text) {
-    const embeddings = await this.generateEmbeddingsWithType([text], "query");
-    return embeddings[0];
+  async vectorSearchAll(queryVector, k = 10) {
+    const allResults = [];
+    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: 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);
   }
-  async generateEmbeddings(texts) {
-    return this.generateEmbeddingsWithType(texts, this.inputType);
+  escape(value) {
+    return value.replace(/'/g, "''");
   }
-  async generateEmbeddingsWithType(texts, inputType) {
-    if (!texts || texts.length === 0) {
-      return [];
+  async loadAllDocumentHashes() {
+    try {
+      const conn = await this.ensureConnected();
+      const reader = await conn.runAndReadAll(`
+				SELECT name, content_hash, embedding_source_hash
+				FROM nodes
+				WHERE label = 'Document'
+			`);
+      const hashMap = new Map;
+      for (const row of reader.getRows()) {
+        const [name, contentHash, embeddingSourceHash] = row;
+        hashMap.set(name, { contentHash, embeddingSourceHash });
+      }
+      return hashMap;
+    } catch (error) {
+      this.logger.error(`Failed to load document hashes: ${error instanceof Error ? error.message : String(error)}`);
+      return new Map;
     }
+  }
+  async updateDocumentHashes(path2, contentHash, embeddingSourceHash) {
     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: inputType
-        })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`Voyage API error: ${response.status} ${JSON.stringify(error)}`);
+      const conn = await this.ensureConnected();
+      if (embeddingSourceHash) {
+        await conn.run(`
+					UPDATE nodes
+					SET content_hash = '${this.escape(contentHash)}',
+					    embedding_source_hash = '${this.escape(embeddingSourceHash)}',
+					    updated_at = NOW()
+					WHERE label = 'Document' AND name = '${this.escape(path2)}'
+				`);
+      } else {
+        await conn.run(`
+					UPDATE nodes
+					SET content_hash = '${this.escape(contentHash)}',
+					    updated_at = NOW()
+					WHERE label = 'Document' AND name = '${this.escape(path2)}'
+				`);
       }
-      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}`);
+      this.logger.error(`Failed to update document hashes: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async batchUpdateDocumentHashes(updates) {
+    if (updates.length === 0)
+      return;
+    try {
+      const conn = await this.ensureConnected();
+      await conn.run("BEGIN TRANSACTION");
+      for (const { path: path2, contentHash, embeddingSourceHash } of updates) {
+        if (embeddingSourceHash) {
+          await conn.run(`
+						UPDATE nodes
+						SET content_hash = '${this.escape(contentHash)}',
+						    embedding_source_hash = '${this.escape(embeddingSourceHash)}',
+						    updated_at = NOW()
+						WHERE label = 'Document' AND name = '${this.escape(path2)}'
+					`);
+        } else {
+          await conn.run(`
+						UPDATE nodes
+						SET content_hash = '${this.escape(contentHash)}',
+						    updated_at = NOW()
+						WHERE label = 'Document' AND name = '${this.escape(path2)}'
+					`);
+        }
       }
+      await conn.run("COMMIT");
+    } catch (error) {
+      this.logger.error(`Failed to batch update document hashes: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
+  async getTrackedDocumentPaths() {
+    try {
+      const conn = await this.ensureConnected();
+      const reader = await conn.runAndReadAll(`
+				SELECT name FROM nodes WHERE label = 'Document'
+			`);
+      return reader.getRows().map((row) => row[0]);
+    } catch (error) {
+      this.logger.error(`Failed to get tracked document paths: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    }
+  }
 }
+GraphService = __legacyDecorateClassTS([
+  Injectable4(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ConfigService === "undefined" ? Object : ConfigService
+  ])
+], GraphService);
 
-// 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}`);
+// src/sync/manifest.service.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { Injectable as Injectable5 } from "@nestjs/common";
+
+// src/schemas/manifest.schemas.ts
+import { z as z2 } from "zod";
+var ManifestEntrySchema = z2.object({
+  contentHash: z2.string(),
+  frontmatterHash: z2.string(),
+  lastSynced: z2.string(),
+  entityCount: z2.number().int().nonnegative(),
+  relationshipCount: z2.number().int().nonnegative()
+});
+var SyncManifestSchema = z2.object({
+  version: z2.string(),
+  lastSync: z2.string(),
+  documents: z2.record(z2.string(), ManifestEntrySchema)
+});
+
+// src/sync/manifest.service.ts
+class ManifestService {
+  manifestPath;
+  manifest = null;
+  constructor() {
+    this.manifestPath = getManifestPath();
   }
-  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");
+  async load() {
+    try {
+      if (existsSync4(this.manifestPath)) {
+        const content = await readFile3(this.manifestPath, "utf-8");
+        this.manifest = SyncManifestSchema.parse(JSON.parse(content));
+      } else {
+        this.manifest = this.createEmptyManifest();
+      }
+    } catch (_error) {
+      this.manifest = this.createEmptyManifest();
     }
-    return EmbeddingConfigSchema.parse({
-      provider: providerEnv,
-      apiKey,
-      model: this.configService.get("EMBEDDING_MODEL"),
-      dimensions: this.configService.get("EMBEDDING_DIMENSIONS")
-    });
+    return this.manifest;
   }
-  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'.`);
+  async save() {
+    if (!this.manifest) {
+      throw new Error("Manifest not loaded. Call load() first.");
     }
+    this.manifest.lastSync = new Date().toISOString();
+    const content = JSON.stringify(this.manifest, null, 2);
+    await writeFile(this.manifestPath, content, "utf-8");
   }
-  getProviderName() {
-    return this.provider.name;
-  }
-  getDimensions() {
-    return this.provider.dimensions;
+  getContentHash(content) {
+    return createHash("sha256").update(content).digest("hex");
   }
-  async generateEmbedding(text) {
-    if (!text || text.trim().length === 0) {
-      throw new Error("Cannot generate embedding for empty text");
+  detectChange(path2, contentHash, frontmatterHash) {
+    if (!this.manifest) {
+      throw new Error("Manifest not loaded. Call load() first.");
     }
-    return this.provider.generateEmbedding(text);
-  }
-  async generateQueryEmbedding(text) {
-    if (!text || text.trim().length === 0) {
-      throw new Error("Cannot generate embedding for empty text");
+    const existing = this.manifest.documents[path2];
+    if (!existing) {
+      return "new";
     }
-    if (this.provider.generateQueryEmbedding) {
-      return this.provider.generateQueryEmbedding(text);
+    if (existing.contentHash === contentHash && existing.frontmatterHash === frontmatterHash) {
+      return "unchanged";
     }
-    return this.provider.generateEmbedding(text);
+    return "updated";
   }
-  async generateEmbeddings(texts) {
-    const validTexts = texts.filter((t) => t && t.trim().length > 0);
-    if (validTexts.length === 0) {
-      return [];
+  updateEntry(path2, contentHash, frontmatterHash, entityCount, relationshipCount) {
+    if (!this.manifest) {
+      throw new Error("Manifest not loaded. Call load() first.");
     }
-    return this.provider.generateEmbeddings(validTexts);
+    this.manifest.documents[path2] = {
+      contentHash,
+      frontmatterHash,
+      lastSynced: new Date().toISOString(),
+      entityCount,
+      relationshipCount
+    };
   }
-  isRealProvider() {
-    return this.provider.name !== "mock";
+  removeEntry(path2) {
+    if (!this.manifest) {
+      throw new Error("Manifest not loaded. Call load() first.");
+    }
+    delete this.manifest.documents[path2];
+  }
+  getTrackedPaths() {
+    if (!this.manifest) {
+      throw new Error("Manifest not loaded. Call load() first.");
+    }
+    return Object.keys(this.manifest.documents);
+  }
+  createEmptyManifest() {
+    return {
+      version: "1.0",
+      lastSync: new Date().toISOString(),
+      documents: {}
+    };
   }
 }
-EmbeddingService = __legacyDecorateClassTS([
+ManifestService = __legacyDecorateClassTS([
   Injectable5(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof ConfigService === "undefined" ? Object : ConfigService
-  ])
-], EmbeddingService);
+  __legacyMetadataTS("design:paramtypes", [])
+], ManifestService);
 
-// src/graph/graph.service.ts
-import { DuckDBInstance } from "@duckdb/node-api";
+// src/sync/sync.service.ts
+import { Injectable as Injectable11, Logger as Logger7 } from "@nestjs/common";
+
+// src/embedding/embedding.service.ts
 import { Injectable as Injectable6, Logger as Logger3 } from "@nestjs/common";
 import { ConfigService as ConfigService2 } from "@nestjs/config";
-class GraphService {
-  configService;
-  logger = new Logger3(GraphService.name);
-  instance = null;
-  connection = null;
-  dbPath;
-  connecting = null;
-  vectorIndexes = new Set;
-  embeddingDimensions;
-  signalHandlersRegistered = false;
-  constructor(configService) {
-    this.configService = configService;
-    ensureLatticeHome();
-    this.dbPath = getDatabasePath();
-    this.embeddingDimensions = this.configService.get("EMBEDDING_DIMENSIONS") || 512;
-    this.registerSignalHandlers();
+
+// src/schemas/config.schemas.ts
+import { z as z3 } from "zod";
+var DuckDBConfigSchema = z3.object({
+  embeddingDimensions: z3.coerce.number().int().positive().default(512)
+});
+var EmbeddingConfigSchema = z3.object({
+  provider: z3.enum(["openai", "voyage", "nomic", "mock"]).default("voyage"),
+  apiKey: z3.string().optional(),
+  model: z3.string().min(1).default("voyage-3.5-lite"),
+  dimensions: z3.coerce.number().int().positive().default(512)
+});
+
+// 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;
   }
-  registerSignalHandlers() {
-    if (this.signalHandlersRegistered)
-      return;
-    this.signalHandlersRegistered = true;
-    const gracefulShutdown = async (signal) => {
-      this.logger.log(`Received ${signal}, checkpointing before exit...`);
-      try {
-        await this.checkpoint();
-        await this.disconnect();
-      } catch (error) {
-        this.logger.error(`Error during graceful shutdown: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      process.exit(0);
-    };
-    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-    process.on("beforeExit", async () => {
-      if (this.connection) {
-        await this.checkpoint();
-      }
-    });
+  async generateEmbedding(text) {
+    return this.generateDeterministicEmbedding(text);
   }
-  async onModuleDestroy() {
-    await this.disconnect();
+  async generateEmbeddings(texts) {
+    return Promise.all(texts.map((text) => this.generateEmbedding(text)));
   }
-  async ensureConnected() {
-    if (this.connection) {
-      return this.connection;
+  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;
     }
-    if (this.connecting) {
-      await this.connecting;
-      if (!this.connection) {
-        throw new Error("Connection failed to establish");
-      }
-      return this.connection;
+    for (let i = 0;i < this.dimensions; i++) {
+      const seed = hash * (i + 1) ^ i * 31;
+      embedding[i] = (seed % 2000 - 1000) / 1000;
     }
-    this.connecting = this.connect();
-    await this.connecting;
-    this.connecting = null;
-    if (!this.connection) {
-      throw new Error("Connection failed to establish");
+    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.");
     }
-    return this.connection;
+    this.apiKey = apiKey;
+    this.model = config?.model || "text-embedding-3-small";
+    this.dimensions = config?.dimensions || 1536;
   }
-  async connect() {
+  async generateEmbedding(text) {
+    const embeddings = await this.generateEmbeddings([text]);
+    return embeddings[0];
+  }
+  async generateEmbeddings(texts) {
+    if (!texts || texts.length === 0) {
+      return [];
+    }
     try {
-      this.instance = await DuckDBInstance.create(":memory:", {
-        allow_unsigned_extensions: "true"
+      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
+        })
       });
-      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)}`);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(`OpenAI API error: ${response.status} ${JSON.stringify(error)}`);
       }
-      await this.connection.run(`ATTACH '${this.dbPath}' AS lattice (READ_WRITE);`);
-      await this.connection.run("USE lattice;");
-      await this.initializeSchema();
-      this.logger.log(`Connected to DuckDB (in-memory + ATTACH) at ${this.dbPath}`);
+      const data = await response.json();
+      const sortedData = data.data.sort((a, b) => a.index - b.index);
+      return sortedData.map((item) => item.embedding);
     } catch (error) {
-      this.connection = null;
-      this.instance = null;
-      this.logger.error(`Failed to connect to DuckDB: ${error instanceof Error ? error.message : String(error)}`);
+      if (error instanceof Error) {
+        throw new Error(`Failed to generate embeddings: ${error.message}`);
+      }
       throw error;
     }
   }
-  async disconnect() {
-    if (this.connection) {
-      await this.checkpoint();
-      this.connection.closeSync();
-      this.connection = null;
-      this.logger.log("Disconnected from DuckDB");
-    }
-    if (this.instance) {
-      this.instance = null;
+}
+
+// src/schemas/embedding.schemas.ts
+import { z as z4 } from "zod";
+var VoyageEmbeddingResponseSchema = z4.object({
+  object: z4.string(),
+  data: z4.array(z4.object({
+    object: z4.string(),
+    embedding: z4.array(z4.number()),
+    index: z4.number().int().nonnegative()
+  })),
+  model: z4.string(),
+  usage: z4.object({
+    total_tokens: z4.number().int().nonnegative()
+  })
+});
+
+// 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 checkpoint() {
-    if (!this.connection) {
-      return;
+  async generateEmbedding(text) {
+    const embeddings = await this.generateEmbeddings([text]);
+    return embeddings[0];
+  }
+  async generateQueryEmbedding(text) {
+    const embeddings = await this.generateEmbeddingsWithType([text], "query");
+    return embeddings[0];
+  }
+  async generateEmbeddings(texts) {
+    return this.generateEmbeddingsWithType(texts, this.inputType);
+  }
+  async generateEmbeddingsWithType(texts, inputType) {
+    if (!texts || texts.length === 0) {
+      return [];
     }
     try {
-      await this.connection.run("CHECKPOINT;");
-      this.logger.debug("Checkpoint completed");
+      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: 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) {
-      this.logger.warn(`Checkpoint failed: ${error instanceof Error ? error.message : String(error)}`);
+      if (error instanceof Error) {
+        throw new Error(`Failed to generate embeddings: ${error.message}`);
+      }
+      throw error;
     }
   }
-  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)");
+}
+
+// src/embedding/embedding.service.ts
+class EmbeddingService {
+  configService;
+  logger = new Logger3(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}`);
   }
-  async query(sql, _params) {
-    try {
-      const conn = await this.ensureConnected();
-      const reader = await conn.runAndReadAll(sql);
-      const rows = reader.getRows();
-      return {
-        resultSet: rows,
-        stats: undefined
-      };
-    } catch (error) {
-      this.logger.error(`Query failed: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
+  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")
+    });
   }
-  async upsertNode(label, properties) {
-    try {
-      const { name, ...otherProps } = properties;
-      if (!name) {
-        throw new Error("Node must have a 'name' property");
-      }
-      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;
+  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'.`);
     }
   }
-  async upsertRelationship(sourceLabel, sourceName, relation, targetLabel, targetName, properties) {
-    try {
-      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;
-    }
+  getProviderName() {
+    return this.provider.name;
   }
-  async deleteNode(label, name) {
-    try {
-      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;
-    }
+  getDimensions() {
+    return this.provider.dimensions;
   }
-  async deleteDocumentRelationships(documentPath) {
-    try {
-      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;
+  async generateEmbedding(text) {
+    if (!text || text.trim().length === 0) {
+      throw new Error("Cannot generate embedding for empty text");
     }
+    return this.provider.generateEmbedding(text);
   }
-  async findNodesByLabel(label, limit) {
-    try {
-      const conn = await this.ensureConnected();
-      const limitClause = limit ? ` LIMIT ${limit}` : "";
-      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 [];
+  async generateQueryEmbedding(text) {
+    if (!text || text.trim().length === 0) {
+      throw new Error("Cannot generate embedding for empty text");
     }
+    if (this.provider.generateQueryEmbedding) {
+      return this.provider.generateQueryEmbedding(text);
+    }
+    return this.provider.generateEmbedding(text);
   }
-  async findRelationships(nodeName) {
-    try {
-      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)}`);
+  async generateEmbeddings(texts) {
+    const validTexts = texts.filter((t) => t && t.trim().length > 0);
+    if (validTexts.length === 0) {
       return [];
     }
+    return this.provider.generateEmbeddings(validTexts);
   }
-  async createVectorIndex(label, property, dimensions) {
-    try {
-      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 exists")) {
-        this.logger.error(`Failed to create vector index: ${errorMessage}`);
-        throw error;
-      }
-    }
-  }
-  async updateNodeEmbedding(label, name, embedding) {
-    try {
-      const conn = await this.ensureConnected();
-      const vectorStr = `[${embedding.join(", ")}]`;
-      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;
-    }
-  }
-  async vectorSearch(label, queryVector, k = 10) {
-    try {
-      const conn = await this.ensureConnected();
-      const vectorStr = `[${queryVector.join(", ")}]`;
-      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 allResults = [];
-    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: 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);
-  }
-  escape(value) {
-    return value.replace(/'/g, "''");
+  isRealProvider() {
+    return this.provider.name !== "mock";
   }
 }
-GraphService = __legacyDecorateClassTS([
+EmbeddingService = __legacyDecorateClassTS([
   Injectable6(),
   __legacyMetadataTS("design:paramtypes", [
     typeof ConfigService2 === "undefined" ? Object : ConfigService2
   ])
-], GraphService);
+], EmbeddingService);
 
-// src/commands/query.command.ts
-class SearchCommand extends CommandRunner3 {
-  graphService;
-  embeddingService;
-  constructor(graphService, embeddingService) {
-    super();
-    this.graphService = graphService;
-    this.embeddingService = embeddingService;
+// src/pure/embedding-text.ts
+function composeDocumentEmbeddingText(doc) {
+  const parts = [];
+  if (doc.title) {
+    parts.push(`Title: ${doc.title}`);
   }
-  async run(inputs, options) {
-    const query = inputs[0];
-    const limit = Math.min(parseInt(options.limit || "20", 10), 100);
-    try {
-      const queryEmbedding = await this.embeddingService.generateQueryEmbedding(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
-        }));
+  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(" | ");
+}
+function composeEntityEmbeddingText(entity) {
+  const parts = [`${entity.type}: ${entity.name}`];
+  if (entity.description) {
+    parts.push(entity.description);
+  }
+  return parts.join(". ");
+}
+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 {
-        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.
-`);
+        existing.documentPaths.push(doc.path);
+        if (entity.description && (!existing.description || entity.description.length > existing.description.length)) {
+          existing.description = entity.description;
         }
-        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)}%`);
+    }
+  }
+  return entities;
+}
+// src/pure/validation.ts
+function validateDocuments(docs) {
+  const errors = [];
+  for (const doc of docs) {
+    if (!doc.title || doc.title.trim() === "") {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: title"
       });
-      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.
-`);
+    }
+    if (!doc.summary || doc.summary.trim() === "") {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: summary"
+      });
+    }
+    if (!doc.created) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: created"
+      });
+    }
+    if (!doc.updated) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: updated"
+      });
+    }
+    if (!doc.status) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: status"
+      });
+    }
+  }
+  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);
       }
-      process.exit(1);
+      docSet.add(doc.path);
     }
   }
-  parseLabel(value) {
-    return value;
+  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`
+        });
+      }
+    }
   }
-  parseLimit(value) {
-    return value;
+  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";
   }
 }
-__legacyDecorateClassTS([
-  Option({
-    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([
-  Option({
-    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);
+// src/sync/cascade.service.ts
+import { Injectable as Injectable8, Logger as Logger5 } from "@nestjs/common";
 
-class RelsCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
+// src/sync/document-parser.service.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile4 } from "fs/promises";
+import { Injectable as Injectable7, Logger as Logger4 } from "@nestjs/common";
+import { glob } from "glob";
+
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+import { z as z5 } from "zod";
+var EntityTypeSchema = z5.enum([
+  "Topic",
+  "Technology",
+  "Concept",
+  "Tool",
+  "Process",
+  "Person",
+  "Organization",
+  "Document"
+]);
+var RelationTypeSchema = z5.enum(["REFERENCES"]);
+var EntitySchema = z5.object({
+  name: z5.string().min(1),
+  type: EntityTypeSchema,
+  description: z5.string().min(1)
+});
+var RelationshipSchema = z5.object({
+  source: z5.string().min(1),
+  relation: RelationTypeSchema,
+  target: z5.string().min(1)
+});
+var GraphMetadataSchema = z5.object({
+  importance: z5.enum(["high", "medium", "low"]).optional(),
+  domain: z5.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;
   }
-  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 day <= daysInMonth[month - 1];
+};
+var FrontmatterSchema = z5.object({
+  created: z5.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  updated: z5.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
+  status: z5.enum(["draft", "ongoing", "complete"]).optional(),
+  topic: z5.string().optional(),
+  tags: z5.array(z5.string()).optional(),
+  summary: z5.string().optional(),
+  entities: z5.array(EntitySchema).optional(),
+  relationships: z5.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}`);
   }
 }
-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;
+function normalizeData(data) {
+  if (data instanceof Date) {
+    return data.toISOString().split("T")[0];
   }
-  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);
+  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;
 }
-SqlCommand = __legacyDecorateClassTS([
-  Injectable7(),
-  Command3({
-    name: "sql",
-    arguments: "<query>",
-    description: "Execute raw SQL query against DuckDB"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], SqlCommand);
-// src/commands/status.command.ts
-import { Injectable as Injectable12 } from "@nestjs/common";
-import { Command as Command4, CommandRunner as CommandRunner4, Option as Option2 } from "nest-commander";
-
-// src/sync/manifest.service.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile3, writeFile } from "fs/promises";
-import { Injectable as Injectable8 } 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
-class ManifestService {
-  manifestPath;
-  manifest = null;
+// src/sync/document-parser.service.ts
+class DocumentParserService {
+  logger = new Logger4(DocumentParserService.name);
+  docsPath;
   constructor() {
-    this.manifestPath = getManifestPath();
-  }
-  async load() {
-    try {
-      if (existsSync3(this.manifestPath)) {
-        const content = await readFile3(this.manifestPath, "utf-8");
-        this.manifest = SyncManifestSchema.parse(JSON.parse(content));
-      } else {
-        this.manifest = this.createEmptyManifest();
-      }
-    } catch (_error) {
-      this.manifest = this.createEmptyManifest();
-    }
-    return this.manifest;
-  }
-  async save() {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    this.manifest.lastSync = new Date().toISOString();
-    const content = JSON.stringify(this.manifest, null, 2);
-    await writeFile(this.manifestPath, content, "utf-8");
+    ensureLatticeHome();
+    this.docsPath = getDocsPath();
   }
-  getContentHash(content) {
-    return createHash2("sha256").update(content).digest("hex");
+  getDocsPath() {
+    return this.docsPath;
   }
-  detectChange(path2, contentHash, frontmatterHash) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    const existing = this.manifest.documents[path2];
-    if (!existing) {
-      return "new";
-    }
-    if (existing.contentHash === contentHash && existing.frontmatterHash === frontmatterHash) {
-      return "unchanged";
-    }
-    return "updated";
+  async discoverDocuments() {
+    const pattern = `${this.docsPath}/**/*.md`;
+    const files = await glob(pattern, {
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    return files.sort();
   }
-  updateEntry(path2, contentHash, frontmatterHash, entityCount, relationshipCount) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    this.manifest.documents[path2] = {
+  async parseDocument(filePath) {
+    const content = await readFile4(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 graphMetadata = this.extractGraphMetadata(parsed.frontmatter);
+    return {
+      path: filePath,
+      title,
+      content: parsed.content,
       contentHash,
       frontmatterHash,
-      lastSynced: new Date().toISOString(),
-      entityCount,
-      relationshipCount
-    };
-  }
-  removeEntry(path2) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    delete this.manifest.documents[path2];
-  }
-  getTrackedPaths() {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    return Object.keys(this.manifest.documents);
-  }
-  createEmptyManifest() {
-    return {
-      version: "1.0",
-      lastSync: new Date().toISOString(),
-      documents: {}
+      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
     };
   }
-}
-ManifestService = __legacyDecorateClassTS([
-  Injectable8(),
-  __legacyMetadataTS("design:paramtypes", [])
-], ManifestService);
-
-// src/sync/sync.service.ts
-import { Injectable as Injectable11, Logger as Logger5 } from "@nestjs/common";
-
-// src/pure/embedding-text.ts
-function composeDocumentEmbeddingText(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(" | ");
-}
-function composeEntityEmbeddingText(entity) {
-  const parts = [`${entity.type}: ${entity.name}`];
-  if (entity.description) {
-    parts.push(entity.description);
+  async parseAllDocuments() {
+    const { docs } = await this.parseAllDocumentsWithErrors();
+    return docs;
   }
-  return parts.join(". ");
-}
-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 {
-        existing.documentPaths.push(doc.path);
-        if (entity.description && (!existing.description || entity.description.length > existing.description.length)) {
-          existing.description = entity.description;
-        }
+  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 };
   }
-  return entities;
-}
-// src/pure/validation.ts
-function validateDocuments(docs) {
-  const errors = [];
-  for (const doc of docs) {
-    if (!doc.title || doc.title.trim() === "") {
-      errors.push({
-        path: doc.path,
-        error: "Missing required field: title"
-      });
-    }
-    if (!doc.summary || doc.summary.trim() === "") {
-      errors.push({
-        path: doc.path,
-        error: "Missing required field: summary"
-      });
-    }
-    if (!doc.created) {
-      errors.push({
-        path: doc.path,
-        error: "Missing required field: created"
-      });
-    }
-    if (!doc.updated) {
-      errors.push({
-        path: doc.path,
-        error: "Missing required field: updated"
-      });
-    }
-    if (!doc.status) {
-      errors.push({
-        path: doc.path,
-        error: "Missing required field: status"
-      });
-    }
-  }
-  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);
+  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", "");
   }
-  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`
-        });
-      }
+  extractGraphMetadata(frontmatter) {
+    const fm = frontmatter;
+    if (!fm?.graph) {
+      return;
     }
+    const result = GraphMetadataSchema.safeParse(fm.graph);
+    return result.success ? result.data : undefined;
   }
-  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";
+  computeHash(content) {
+    return createHash2("sha256").update(content).digest("hex");
   }
 }
+DocumentParserService = __legacyDecorateClassTS([
+  Injectable7(),
+  __legacyMetadataTS("design:paramtypes", [])
+], DocumentParserService);
+
 // src/sync/cascade.service.ts
-import { Injectable as Injectable9, Logger as Logger4 } from "@nestjs/common";
 class CascadeService {
   graph;
   _parser;
-  logger = new Logger4(CascadeService.name);
+  logger = new Logger5(CascadeService.name);
   constructor(graph, _parser) {
     this.graph = graph;
     this._parser = _parser;
@@ -1764,14 +1817,14 @@ class CascadeService {
   async findAffectedByRename(entityName, _newName) {
     try {
       const escapedName = this.escapeForSql(entityName);
-      const query = `
+      const query3 = `
 				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);
+      const result = await this.graph.query(query3);
       return (result.resultSet || []).map((row) => ({
         path: row[0],
         reason: `References "${entityName}" in entities`,
@@ -1787,14 +1840,14 @@ class CascadeService {
   async findAffectedByDeletion(entityName) {
     try {
       const escapedName = this.escapeForSql(entityName);
-      const query = `
+      const query3 = `
 				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);
+      const result = await this.graph.query(query3);
       return (result.resultSet || []).map((row) => ({
         path: row[0],
         reason: `References deleted entity "${entityName}"`,
@@ -1810,14 +1863,14 @@ class CascadeService {
   async findAffectedByTypeChange(entityName, oldType, newType) {
     try {
       const escapedName = this.escapeForSql(entityName);
-      const query = `
+      const query3 = `
 				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);
+      const result = await this.graph.query(query3);
       return (result.resultSet || []).map((row) => ({
         path: row[0],
         reason: `References "${entityName}" with type "${oldType}" (now "${newType}")`,
@@ -1833,14 +1886,14 @@ class CascadeService {
   async findAffectedByRelationshipChange(entityName) {
     try {
       const escapedName = this.escapeForSql(entityName);
-      const query = `
+      const query3 = `
 				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);
+      const result = await this.graph.query(query3);
       return (result.resultSet || []).map((row) => ({
         path: row[0],
         reason: `Has relationship with "${entityName}"`,
@@ -1856,14 +1909,14 @@ class CascadeService {
   async findAffectedByDocumentDeletion(documentPath) {
     try {
       const escapedPath = this.escapeForSql(documentPath);
-      const query = `
+      const query3 = `
 				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);
+      const result = await this.graph.query(query3);
       return (result.resultSet || []).map((row) => ({
         path: row[0],
         reason: `Links to deleted document "${documentPath}"`,
@@ -1953,16 +2006,118 @@ class CascadeService {
   }
 }
 CascadeService = __legacyDecorateClassTS([
-  Injectable9(),
+  Injectable8(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService,
     typeof DocumentParserService === "undefined" ? Object : DocumentParserService
   ])
 ], CascadeService);
 
+// src/sync/database-change-detector.service.ts
+import { createHash as createHash3 } from "crypto";
+import { Injectable as Injectable9, Logger as Logger6 } from "@nestjs/common";
+class DatabaseChangeDetectorService {
+  graph;
+  logger = new Logger6(DatabaseChangeDetectorService.name);
+  hashCache = new Map;
+  loaded = false;
+  constructor(graph) {
+    this.graph = graph;
+  }
+  async loadHashes() {
+    this.hashCache = await this.graph.loadAllDocumentHashes();
+    this.loaded = true;
+    this.logger.debug(`Loaded ${this.hashCache.size} document hashes from DB`);
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+  reset() {
+    this.hashCache.clear();
+    this.loaded = false;
+  }
+  getContentHash(content) {
+    return createHash3("sha256").update(content).digest("hex");
+  }
+  detectChange(path2, currentContentHash) {
+    if (!this.loaded) {
+      throw new Error("Hashes not loaded. Call loadHashes() before detectChange().");
+    }
+    const cached = this.hashCache.get(path2);
+    if (!cached) {
+      return "new";
+    }
+    if (!cached.contentHash) {
+      return "updated";
+    }
+    return cached.contentHash === currentContentHash ? "unchanged" : "updated";
+  }
+  detectChangeWithReason(path2, currentContentHash) {
+    const changeType = this.detectChange(path2, currentContentHash);
+    let reason;
+    switch (changeType) {
+      case "new":
+        reason = "New document not in database";
+        break;
+      case "updated":
+        reason = "Content hash changed";
+        break;
+      case "unchanged":
+        reason = "Content unchanged";
+        break;
+      default:
+        reason = "Unknown";
+    }
+    return { path: path2, changeType, reason };
+  }
+  getTrackedPaths() {
+    if (!this.loaded) {
+      throw new Error("Hashes not loaded. Call loadHashes() before getTrackedPaths().");
+    }
+    return Array.from(this.hashCache.keys());
+  }
+  isEmbeddingStale(path2, currentSourceHash) {
+    if (!this.loaded) {
+      throw new Error("Hashes not loaded. Call loadHashes() before isEmbeddingStale().");
+    }
+    const cached = this.hashCache.get(path2);
+    if (!cached?.embeddingSourceHash) {
+      return true;
+    }
+    return cached.embeddingSourceHash !== currentSourceHash;
+  }
+  getCachedEntry(path2) {
+    if (!this.loaded) {
+      throw new Error("Hashes not loaded. Call loadHashes() before getCachedEntry().");
+    }
+    return this.hashCache.get(path2);
+  }
+  getCacheSize() {
+    return this.hashCache.size;
+  }
+  findDocumentsNeedingEmbeddings() {
+    if (!this.loaded) {
+      throw new Error("Hashes not loaded. Call loadHashes() before findDocumentsNeedingEmbeddings().");
+    }
+    const needsEmbedding = [];
+    for (const [path2, entry] of this.hashCache) {
+      if (!entry.embeddingSourceHash) {
+        needsEmbedding.push(path2);
+      }
+    }
+    return needsEmbedding;
+  }
+}
+DatabaseChangeDetectorService = __legacyDecorateClassTS([
+  Injectable9(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService
+  ])
+], DatabaseChangeDetectorService);
+
 // src/sync/path-resolver.service.ts
-import { existsSync as existsSync4 } from "fs";
-import { isAbsolute, resolve as resolve2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { isAbsolute, resolve as resolve3 } from "path";
 import { Injectable as Injectable10 } from "@nestjs/common";
 class PathResolverService {
   docsPath;
@@ -1978,12 +2133,12 @@ class PathResolverService {
     if (isAbsolute(userPath)) {
       resolvedPath = userPath;
     } else {
-      resolvedPath = resolve2(this.docsPath, userPath);
+      resolvedPath = resolve3(this.docsPath, userPath);
     }
     if (requireInDocs && !this.isUnderDocs(resolvedPath)) {
       throw new Error(`Path "${userPath}" resolves to "${resolvedPath}" which is outside the docs directory (${this.docsPath})`);
     }
-    if (requireExists && !existsSync4(resolvedPath)) {
+    if (requireExists && !existsSync5(resolvedPath)) {
       throw new Error(`Path "${userPath}" does not exist (resolved to: ${resolvedPath})`);
     }
     return resolvedPath;
@@ -2030,14 +2185,18 @@ class SyncService {
   graph;
   cascade;
   pathResolver;
+  dbChangeDetector;
+  entityExtractor;
   embeddingService;
-  logger = new Logger5(SyncService.name);
-  constructor(manifest, parser, graph, cascade, pathResolver, embeddingService) {
+  logger = new Logger7(SyncService.name);
+  constructor(manifest, parser, graph, cascade, pathResolver, dbChangeDetector, entityExtractor, embeddingService) {
     this.manifest = manifest;
     this.parser = parser;
     this.graph = graph;
     this.cascade = cascade;
     this.pathResolver = pathResolver;
+    this.dbChangeDetector = dbChangeDetector;
+    this.entityExtractor = entityExtractor;
     this.embeddingService = embeddingService;
   }
   async sync(options = {}) {
@@ -2054,8 +2213,16 @@ class SyncService {
       embeddingsGenerated: 0,
       entityEmbeddingsGenerated: 0
     };
+    const useDbDetection = options.legacy ? false : options.useDbChangeDetection ?? true;
+    const useAiExtraction = options.legacy ? false : options.aiExtraction ?? true;
     try {
       await this.manifest.load();
+      if (useDbDetection) {
+        await this.dbChangeDetector.loadHashes();
+        if (options.verbose) {
+          this.logger.log(`v2 mode: Loaded ${this.dbChangeDetector.getCacheSize()} document hashes from database`);
+        }
+      }
       if (options.force) {
         if (options.paths && options.paths.length > 0) {
           if (options.verbose) {
@@ -2069,7 +2236,7 @@ class SyncService {
           await this.clearManifest();
         }
       }
-      const changes = await this.detectChanges(options.paths);
+      const changes = await this.detectChanges(options.paths, useDbDetection);
       result.changes = changes;
       const docsToSync = [];
       const docsByPath = new Map;
@@ -2086,15 +2253,42 @@ class SyncService {
           }
         }
       }
-      const validationErrors = validateDocuments2(docsToSync);
-      if (validationErrors.length > 0) {
-        for (const err of validationErrors) {
-          result.errors.push(err);
-          this.logger.error(`Validation error in ${err.path}: ${err.error}`);
+      if (useAiExtraction && docsToSync.length > 0) {
+        if (options.verbose) {
+          this.logger.log(`v2 AI extraction: Processing ${docsToSync.length} documents...`);
+        }
+        for (const doc of docsToSync) {
+          try {
+            const extraction = await this.entityExtractor.extractFromDocument(doc.path);
+            if (extraction.success) {
+              doc.entities = extraction.entities;
+              doc.relationships = extraction.relationships;
+              if (extraction.summary) {
+                doc.summary = extraction.summary;
+              }
+              if (options.verbose) {
+                this.logger.log(`  Extracted ${extraction.entities.length} entities from ${doc.path}`);
+              }
+            } else {
+              this.logger.warn(`AI extraction failed for ${doc.path}: ${extraction.error}`);
+            }
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger.warn(`AI extraction error for ${doc.path}: ${errorMsg}`);
+          }
+        }
+      }
+      if (!useAiExtraction) {
+        const validationErrors = validateDocuments2(docsToSync);
+        if (validationErrors.length > 0) {
+          for (const err of validationErrors) {
+            result.errors.push(err);
+            this.logger.error(`Validation error in ${err.path}: ${err.error}`);
+          }
+          this.logger.error(`Sync aborted: ${validationErrors.length} validation error(s) found. Fix the errors and try again.`);
+          result.duration = Date.now() - startTime;
+          return result;
         }
-        this.logger.error(`Sync aborted: ${validationErrors.length} validation error(s) found. Fix the errors and try again.`);
-        result.duration = Date.now() - startTime;
-        return result;
       }
       const uniqueEntities = collectUniqueEntities(docsToSync);
       if (options.verbose) {
@@ -2119,43 +2313,37 @@ class SyncService {
       const CHECKPOINT_BATCH_SIZE = 10;
       let processedCount = 0;
       for (const change of changes) {
-        try {
-          const doc = docsByPath.get(change.path);
-          const cascadeWarnings = await this.processChange(change, options, doc);
-          result.cascadeWarnings.push(...cascadeWarnings);
-          switch (change.changeType) {
-            case "new":
-              result.added++;
-              break;
-            case "updated":
-              result.updated++;
-              break;
-            case "deleted":
-              result.deleted++;
-              break;
-            case "unchanged":
-              result.unchanged++;
-              break;
-          }
-          if (change.embeddingGenerated) {
-            result.embeddingsGenerated++;
-          }
-          processedCount++;
-          if (!options.dryRun && processedCount % CHECKPOINT_BATCH_SIZE === 0) {
-            await this.graph.checkpoint();
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          result.errors.push({ path: change.path, error: errorMessage });
-          this.logger.warn(`Error processing ${change.path}: ${errorMessage}`);
+        const doc = docsByPath.get(change.path);
+        const cascadeWarnings = await this.processChange(change, options, doc);
+        result.cascadeWarnings.push(...cascadeWarnings);
+        switch (change.changeType) {
+          case "new":
+            result.added++;
+            break;
+          case "updated":
+            result.updated++;
+            break;
+          case "deleted":
+            result.deleted++;
+            break;
+          case "unchanged":
+            result.unchanged++;
+            break;
+        }
+        if (change.embeddingGenerated) {
+          result.embeddingsGenerated++;
+        }
+        if (!options.dryRun && change.changeType !== "unchanged") {
+          await this.manifest.save();
+        }
+        processedCount++;
+        if (!options.dryRun && processedCount % CHECKPOINT_BATCH_SIZE === 0) {
+          await this.graph.checkpoint();
         }
       }
       if (!options.dryRun && processedCount > 0) {
         await this.graph.checkpoint();
       }
-      if (!options.dryRun) {
-        await this.manifest.save();
-      }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.error(`Sync failed: ${errorMessage}`);
@@ -2164,7 +2352,7 @@ class SyncService {
     result.duration = Date.now() - startTime;
     return result;
   }
-  async detectChanges(paths) {
+  async detectChanges(paths, useDbDetection = false) {
     const changes = [];
     let allDocPaths = await this.parser.discoverDocuments();
     if (paths && paths.length > 0) {
@@ -2175,11 +2363,11 @@ class SyncService {
       const pathSet = new Set(normalizedPaths);
       allDocPaths = allDocPaths.filter((p) => pathSet.has(p));
     }
-    const trackedPaths = new Set(this.manifest.getTrackedPaths());
+    const trackedPaths = new Set(useDbDetection ? this.dbChangeDetector.getTrackedPaths() : this.manifest.getTrackedPaths());
     for (const docPath of allDocPaths) {
       try {
         const doc = await this.parser.parseDocument(docPath);
-        const changeType = this.manifest.detectChange(docPath, doc.contentHash, doc.frontmatterHash);
+        const changeType = useDbDetection ? this.dbChangeDetector.detectChange(docPath, doc.contentHash) : this.manifest.detectChange(docPath, doc.contentHash, doc.frontmatterHash);
         changes.push({
           path: docPath,
           changeType,
@@ -2245,7 +2433,7 @@ class SyncService {
         }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logger.warn(`Failed to generate embedding for ${doc.path}: ${errorMessage}`);
+        throw new Error(`Failed to generate embedding for ${doc.path}: ${errorMessage}`);
       }
     }
     const entityTypeMap = new Map;
@@ -2336,6 +2524,11 @@ class SyncService {
         change.embeddingGenerated = embeddingGenerated;
         const currentDoc = await this.parser.parseDocument(change.path);
         this.manifest.updateEntry(currentDoc.path, currentDoc.contentHash, currentDoc.frontmatterHash, currentDoc.entities.length, currentDoc.relationships.length);
+        const shouldUpdateDbHashes = options.legacy ? false : options.useDbChangeDetection ?? true;
+        if (shouldUpdateDbHashes) {
+          const embeddingSourceHash = embeddingGenerated ? currentDoc.contentHash : undefined;
+          await this.graph.updateDocumentHashes(currentDoc.path, currentDoc.contentHash, embeddingSourceHash);
+        }
         break;
       }
       case "deleted": {
@@ -2366,86 +2559,582 @@ class SyncService {
     }
     this.logger.log(`Marked ${normalizedPaths.length} document(s) for re-sync`);
   }
-  async getOldDocumentFromManifest(path2) {
+  async getOldDocumentFromManifest(path2) {
+    try {
+      const manifest = await this.manifest.load();
+      const entry = manifest.documents[path2];
+      if (!entry) {
+        return null;
+      }
+      try {
+        return await this.parser.parseDocument(path2);
+      } catch {
+        return null;
+      }
+    } catch (error) {
+      this.logger.warn(`Failed to retrieve old document for ${path2}: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  async syncEntities(entities, options) {
+    let embeddingsGenerated = 0;
+    for (const [_key, entity] of entities) {
+      const entityProps = {
+        name: entity.name
+      };
+      if (entity.description) {
+        entityProps.description = entity.description;
+      }
+      await this.graph.upsertNode(entity.type, entityProps);
+      if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
+        try {
+          const text = composeEntityEmbeddingText(entity);
+          const embedding = await this.embeddingService.generateEmbedding(text);
+          await this.graph.updateNodeEmbedding(entity.type, entity.name, embedding);
+          embeddingsGenerated++;
+          this.logger.debug(`Generated embedding for ${entity.type}:${entity.name}`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(`Failed to generate embedding for ${entity.type}:${entity.name}: ${errorMessage}`);
+        }
+      }
+    }
+    return embeddingsGenerated;
+  }
+  async createEntityVectorIndices() {
+    if (!this.embeddingService)
+      return;
+    const dimensions = this.embeddingService.getDimensions();
+    for (const entityType of ENTITY_TYPES) {
+      try {
+        await this.graph.createVectorIndex(entityType, "embedding", dimensions);
+      } catch (error) {
+        this.logger.debug(`Vector index setup for ${entityType}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}
+SyncService = __legacyDecorateClassTS([
+  Injectable11(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ManifestService === "undefined" ? Object : ManifestService,
+    typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
+    typeof GraphService === "undefined" ? Object : GraphService,
+    typeof CascadeService === "undefined" ? Object : CascadeService,
+    typeof PathResolverService === "undefined" ? Object : PathResolverService,
+    typeof DatabaseChangeDetectorService === "undefined" ? Object : DatabaseChangeDetectorService,
+    typeof EntityExtractorService === "undefined" ? Object : EntityExtractorService,
+    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
+  ])
+], SyncService);
+
+// src/commands/migrate.command.ts
+class MigrateCommand extends CommandRunner3 {
+  graph;
+  manifest;
+  syncService;
+  logger = new Logger8(MigrateCommand.name);
+  constructor(graph, manifest, syncService) {
+    super();
+    this.graph = graph;
+    this.manifest = manifest;
+    this.syncService = syncService;
+  }
+  async run(_passedParams, options) {
+    console.log(`
+\uD83D\uDD04 Migrating to Lattice v2...
+`);
+    if (options.dryRun) {
+      console.log(`\uD83D\uDCCB Dry run mode: No changes will be applied
+`);
+    }
+    try {
+      console.log("\uD83D\uDCE6 Step 1/3: Applying v2 schema changes...");
+      if (!options.dryRun) {
+        await this.graph.runV2Migration();
+        console.log(`   \u2705 Schema updated with content_hash and embedding_source_hash columns
+`);
+      } else {
+        console.log(`   [DRY-RUN] Would add content_hash and embedding_source_hash columns
+`);
+      }
+      console.log("\uD83D\uDCCB Step 2/3: Migrating manifest hashes to database...");
+      const manifestStats = await this.migrateManifestHashes(options);
+      if (manifestStats.total > 0) {
+        if (!options.dryRun) {
+          console.log(`   \u2705 Migrated ${manifestStats.migrated}/${manifestStats.total} document hashes
+`);
+        } else {
+          console.log(`   [DRY-RUN] Would migrate ${manifestStats.total} document hashes
+`);
+        }
+      } else {
+        console.log(`   \u2139\uFE0F  No manifest found or manifest is empty (fresh install)
+`);
+      }
+      if (!options.skipSync) {
+        console.log("\uD83E\uDD16 Step 3/3: Running full sync with AI entity extraction...");
+        console.log(`   This may take a while depending on the number of documents...
+`);
+        if (!options.dryRun) {
+          const result = await this.syncService.sync({
+            force: false,
+            useDbChangeDetection: true,
+            aiExtraction: true,
+            verbose: options.verbose,
+            embeddings: true
+          });
+          console.log(`
+\uD83D\uDCCA Sync Results:`);
+          console.log(`   \u2705 Added: ${result.added}`);
+          console.log(`   \uD83D\uDD04 Updated: ${result.updated}`);
+          console.log(`   \uD83D\uDDD1\uFE0F  Deleted: ${result.deleted}`);
+          console.log(`   \u23ED\uFE0F  Unchanged: ${result.unchanged}`);
+          if (result.errors.length > 0) {
+            console.log(`   \u274C Errors: ${result.errors.length}`);
+            for (const err of result.errors) {
+              console.log(`      ${err.path}: ${err.error}`);
+            }
+          }
+          console.log(`   \u23F1\uFE0F  Duration: ${result.duration}ms
+`);
+        } else {
+          console.log(`   [DRY-RUN] Would run full sync with AI extraction
+`);
+        }
+      } else {
+        console.log(`\u23ED\uFE0F  Step 3/3: Skipping sync (--skip-sync flag)
+`);
+      }
+      console.log(`\u2705 Migration complete!
+`);
+      console.log("Next steps:");
+      console.log("  1. Verify your graph: lattice status");
+      console.log("  2. Test semantic search: lattice search <query>");
+      console.log("  3. Future syncs will use v2 mode automatically");
+      console.log(`  4. Optional: Delete ~/.lattice/.sync-manifest.json (no longer needed)
+`);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`
+\u274C Migration failed: ${errorMsg}
+`);
+      this.logger.error(`Migration failed: ${errorMsg}`, error instanceof Error ? error.stack : undefined);
+      process.exit(1);
+    }
+  }
+  async migrateManifestHashes(options) {
+    const stats = { total: 0, migrated: 0, skipped: 0 };
+    try {
+      const manifestData = await this.manifest.load();
+      const entries = Object.entries(manifestData.documents);
+      stats.total = entries.length;
+      if (stats.total === 0) {
+        return stats;
+      }
+      for (const [path2, entry] of entries) {
+        if (options.verbose) {
+          console.log(`   Processing: ${path2}`);
+        }
+        if (!options.dryRun) {
+          try {
+            await this.graph.updateDocumentHashes(path2, entry.contentHash);
+            stats.migrated++;
+          } catch (error) {
+            stats.skipped++;
+            if (options.verbose) {
+              const errorMsg = error instanceof Error ? error.message : String(error);
+              console.log(`   \u26A0\uFE0F  Skipped ${path2}: ${errorMsg}`);
+            }
+          }
+        } else {
+          stats.migrated++;
+        }
+      }
+    } catch (error) {
+      if (options.verbose) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        this.logger.debug(`No manifest to migrate: ${errorMsg}`);
+      }
+    }
+    return stats;
+  }
+  parseDryRun() {
+    return true;
+  }
+  parseVerbose() {
+    return true;
+  }
+  parseSkipSync() {
+    return true;
+  }
+}
+__legacyDecorateClassTS([
+  Option2({
+    flags: "--dry-run",
+    description: "Show what would be done without making changes"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], MigrateCommand.prototype, "parseDryRun", null);
+__legacyDecorateClassTS([
+  Option2({
+    flags: "-v, --verbose",
+    description: "Show detailed progress"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], MigrateCommand.prototype, "parseVerbose", null);
+__legacyDecorateClassTS([
+  Option2({
+    flags: "--skip-sync",
+    description: "Skip the full sync step (only apply schema and migrate hashes)"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], MigrateCommand.prototype, "parseSkipSync", null);
+MigrateCommand = __legacyDecorateClassTS([
+  Injectable12(),
+  Command3({
+    name: "migrate",
+    description: "Migrate from v1 (manifest) to v2 (database-based) architecture"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService,
+    typeof ManifestService === "undefined" ? Object : ManifestService,
+    typeof SyncService === "undefined" ? Object : SyncService
+  ])
+], MigrateCommand);
+// src/commands/ontology.command.ts
+import { Injectable as Injectable14 } from "@nestjs/common";
+import { Command as Command4, CommandRunner as CommandRunner4 } from "nest-commander";
+
+// src/sync/ontology.service.ts
+import { Injectable as Injectable13 } from "@nestjs/common";
+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([
+  Injectable13(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
+  ])
+], OntologyService);
+
+// src/commands/ontology.command.ts
+class OntologyCommand extends CommandRunner4 {
+  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([
+  Injectable14(),
+  Command4({
+    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 Injectable15 } from "@nestjs/common";
+import { Command as Command5, CommandRunner as CommandRunner5, Option as Option3 } from "nest-commander";
+class SearchCommand extends CommandRunner5 {
+  graphService;
+  embeddingService;
+  constructor(graphService, embeddingService) {
+    super();
+    this.graphService = graphService;
+    this.embeddingService = embeddingService;
+  }
+  async run(inputs, options) {
+    const query3 = inputs[0];
+    const limit = Math.min(parseInt(options.limit || "20", 10), 100);
+    try {
+      const queryEmbedding = await this.embeddingService.generateQueryEmbedding(query3);
+      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 "${query3}"${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;
+  }
+}
+__legacyDecorateClassTS([
+  Option3({
+    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([
+  Option3({
+    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([
+  Injectable15(),
+  Command5({
+    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 CommandRunner5 {
+  graphService;
+  constructor(graphService) {
+    super();
+    this.graphService = graphService;
+  }
+  async run(inputs) {
+    const name = inputs[0];
     try {
-      const manifest = await this.manifest.load();
-      const entry = manifest.documents[path2];
-      if (!entry) {
-        return null;
+      const relationships = await this.graphService.findRelationships(name);
+      console.log(`
+=== Relationships for "${name}" ===
+`);
+      if (relationships.length === 0) {
+        console.log(`No relationships found.
+`);
+        process.exit(0);
       }
-      try {
-        return await this.parser.parseDocument(path2);
-      } catch {
-        return null;
+      console.log("Relationships:");
+      for (const rel of relationships) {
+        const [relType, targetName] = rel;
+        console.log(`  -[${relType}]-> ${targetName}`);
       }
+      console.log();
+      process.exit(0);
     } catch (error) {
-      this.logger.warn(`Failed to retrieve old document for ${path2}: ${error instanceof Error ? error.message : String(error)}`);
-      return null;
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
     }
   }
-  async syncEntities(entities, options) {
-    let embeddingsGenerated = 0;
-    for (const [_key, entity] of entities) {
-      const entityProps = {
-        name: entity.name
-      };
-      if (entity.description) {
-        entityProps.description = entity.description;
-      }
-      await this.graph.upsertNode(entity.type, entityProps);
-      if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
-        try {
-          const text = composeEntityEmbeddingText(entity);
-          const embedding = await this.embeddingService.generateEmbedding(text);
-          await this.graph.updateNodeEmbedding(entity.type, entity.name, embedding);
-          embeddingsGenerated++;
-          this.logger.debug(`Generated embedding for ${entity.type}:${entity.name}`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          this.logger.warn(`Failed to generate embedding for ${entity.type}:${entity.name}: ${errorMessage}`);
-        }
-      }
-    }
-    return embeddingsGenerated;
+}
+RelsCommand = __legacyDecorateClassTS([
+  Injectable15(),
+  Command5({
+    name: "rels",
+    arguments: "<name>",
+    description: "Show relationships for a node"
+  }),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService
+  ])
+], RelsCommand);
+
+class SqlCommand extends CommandRunner5 {
+  graphService;
+  constructor(graphService) {
+    super();
+    this.graphService = graphService;
   }
-  async createEntityVectorIndices() {
-    if (!this.embeddingService)
-      return;
-    const dimensions = this.embeddingService.getDimensions();
-    for (const entityType of ENTITY_TYPES) {
-      try {
-        await this.graph.createVectorIndex(entityType, "embedding", dimensions);
-      } catch (error) {
-        this.logger.debug(`Vector index setup for ${entityType}: ${error instanceof Error ? error.message : String(error)}`);
-      }
+  async run(inputs) {
+    const query3 = inputs[0];
+    try {
+      const result = await this.graphService.query(query3);
+      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);
     }
   }
 }
-SyncService = __legacyDecorateClassTS([
-  Injectable11(),
+SqlCommand = __legacyDecorateClassTS([
+  Injectable15(),
+  Command5({
+    name: "sql",
+    arguments: "<query>",
+    description: "Execute raw SQL query against DuckDB"
+  }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof ManifestService === "undefined" ? Object : ManifestService,
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof CascadeService === "undefined" ? Object : CascadeService,
-    typeof PathResolverService === "undefined" ? Object : PathResolverService,
-    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
+    typeof GraphService === "undefined" ? Object : GraphService
   ])
-], SyncService);
-
+], SqlCommand);
 // src/commands/status.command.ts
-class StatusCommand extends CommandRunner4 {
+import { Injectable as Injectable16 } from "@nestjs/common";
+import { Command as Command6, CommandRunner as CommandRunner6, Option as Option4 } from "nest-commander";
+class StatusCommand extends CommandRunner6 {
   syncService;
   manifestService;
-  constructor(syncService, manifestService) {
+  dbChangeDetector;
+  constructor(syncService, manifestService, dbChangeDetector) {
     super();
     this.syncService = syncService;
     this.manifestService = manifestService;
+    this.dbChangeDetector = dbChangeDetector;
   }
   async run(_inputs, options) {
     try {
-      await this.manifestService.load();
-      const changes = await this.syncService.detectChanges();
+      const useDbDetection = !options.legacy;
+      if (useDbDetection) {
+        await this.dbChangeDetector.loadHashes();
+      } else {
+        await this.manifestService.load();
+      }
+      const changes = await this.syncService.detectChanges(undefined, useDbDetection);
       const newDocs = changes.filter((c) => c.changeType === "new");
       const updatedDocs = changes.filter((c) => c.changeType === "updated");
       const deletedDocs = changes.filter((c) => c.changeType === "deleted");
@@ -2498,9 +3187,12 @@ class StatusCommand extends CommandRunner4 {
   parseVerbose() {
     return true;
   }
+  parseLegacy() {
+    return true;
+  }
 }
 __legacyDecorateClassTS([
-  Option2({
+  Option4({
     flags: "-v, --verbose",
     description: "Show all documents including unchanged"
   }),
@@ -2508,28 +3200,38 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
 ], StatusCommand.prototype, "parseVerbose", null);
+__legacyDecorateClassTS([
+  Option4({
+    flags: "--legacy",
+    description: "Use legacy v1 mode: manifest-based change detection"
+  }),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], StatusCommand.prototype, "parseLegacy", null);
 StatusCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command4({
+  Injectable16(),
+  Command6({
     name: "status",
     description: "Show documents that need syncing (new or updated)"
   }),
   __legacyMetadataTS("design:paramtypes", [
     typeof SyncService === "undefined" ? Object : SyncService,
-    typeof ManifestService === "undefined" ? Object : ManifestService
+    typeof ManifestService === "undefined" ? Object : ManifestService,
+    typeof DatabaseChangeDetectorService === "undefined" ? Object : DatabaseChangeDetectorService
   ])
 ], StatusCommand);
 // src/commands/sync.command.ts
 import { watch } from "fs";
 import { join as join3 } from "path";
-import { Injectable as Injectable14 } from "@nestjs/common";
-import { Command as Command5, CommandRunner as CommandRunner5, Option as Option3 } from "nest-commander";
+import { Injectable as Injectable18 } from "@nestjs/common";
+import { Command as Command7, CommandRunner as CommandRunner7, Option as Option5 } from "nest-commander";
 
 // src/sync/graph-validator.service.ts
-import { Injectable as Injectable13, Logger as Logger6 } from "@nestjs/common";
+import { Injectable as Injectable17, Logger as Logger9 } from "@nestjs/common";
 class GraphValidatorService {
   graph;
-  logger = new Logger6(GraphValidatorService.name);
+  logger = new Logger9(GraphValidatorService.name);
   constructor(graph) {
     this.graph = graph;
   }
@@ -2675,14 +3377,14 @@ class GraphValidatorService {
   }
 }
 GraphValidatorService = __legacyDecorateClassTS([
-  Injectable13(),
+  Injectable17(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService
   ])
 ], GraphValidatorService);
 
 // src/commands/sync.command.ts
-class SyncCommand extends CommandRunner5 {
+class SyncCommand extends CommandRunner7 {
   syncService;
   _graphValidator;
   watcher = null;
@@ -2702,6 +3404,14 @@ class SyncCommand extends CommandRunner5 {
     if (options.watch && options.force) {
       console.log(`
 \u26A0\uFE0F  Watch mode is not compatible with --force mode (for safety)
+`);
+      process.exit(1);
+    }
+    if (options.force && paths.length === 0) {
+      console.log(`
+\u26A0\uFE0F  --force requires specific paths to be specified.
+`);
+      console.log(`   Usage: lattice sync --force <path1> [path2] ...
 `);
       process.exit(1);
     }
@@ -2711,19 +3421,16 @@ class SyncCommand extends CommandRunner5 {
       verbose: options.verbose,
       paths: paths.length > 0 ? paths : undefined,
       skipCascade: options.skipCascade,
-      embeddings: options.embeddings !== false
+      embeddings: options.embeddings !== false,
+      legacy: options.legacy,
+      aiExtraction: !options.skipExtraction
     };
     console.log(`
 \uD83D\uDD04 Graph Sync
 `);
     if (syncOptions.force) {
-      if (syncOptions.paths && syncOptions.paths.length > 0) {
-        console.log(`\u26A0\uFE0F  Force mode: ${syncOptions.paths.length} document(s) will be cleared and re-synced
+      console.log(`\u26A0\uFE0F  Force mode: ${syncOptions.paths?.length} document(s) will be cleared and re-synced
 `);
-      } else {
-        console.log(`\u26A0\uFE0F  Force mode: Entire graph will be cleared and rebuilt
-`);
-      }
     }
     if (syncOptions.dryRun) {
       console.log(`\uD83D\uDCCB Dry run mode: No changes will be applied
@@ -2737,6 +3444,15 @@ class SyncCommand extends CommandRunner5 {
       console.log(`\uD83D\uDEAB Embedding generation disabled
 `);
     }
+    if (syncOptions.legacy) {
+      console.log(`\uD83D\uDCDC Legacy mode: Using manifest-based change detection
+`);
+    } else {
+      if (!syncOptions.aiExtraction) {
+        console.log(`\u23ED\uFE0F  AI entity extraction skipped (--skip-extraction)
+`);
+      }
+    }
     if (syncOptions.paths) {
       console.log(`\uD83D\uDCC1 Syncing specific paths: ${syncOptions.paths.join(", ")}
 `);
@@ -2930,18 +3646,24 @@ class SyncCommand extends CommandRunner5 {
   parseNoEmbeddings() {
     return false;
   }
+  parseSkipExtraction() {
+    return true;
+  }
+  parseLegacy() {
+    return true;
+  }
 }
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "-f, --force",
-    description: "Force re-sync: with paths, clears only those docs; without paths, rebuilds entire graph"
+    description: "Force re-sync specified documents (requires paths to be specified)"
   }),
   __legacyMetadataTS("design:type", Function),
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseForce", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "-d, --dry-run",
     description: "Show what would change without applying"
   }),
@@ -2950,7 +3672,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseDryRun", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "-v, --verbose",
     description: "Show detailed output"
   }),
@@ -2959,7 +3681,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseVerbose", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "-w, --watch",
     description: "Watch for file changes and sync automatically"
   }),
@@ -2968,7 +3690,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseWatch", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "--diff",
     description: "Show only changed documents (alias for --dry-run)"
   }),
@@ -2977,7 +3699,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseDiff", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "--skip-cascade",
     description: "Skip cascade analysis (faster for large repos)"
   }),
@@ -2986,7 +3708,7 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseSkipCascade", null);
 __legacyDecorateClassTS([
-  Option3({
+  Option5({
     flags: "--no-embeddings",
     description: "Disable embedding generation during sync"
   }),
@@ -2994,131 +3716,36 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseNoEmbeddings", null);
-SyncCommand = __legacyDecorateClassTS([
-  Injectable14(),
-  Command5({
-    name: "sync",
-    arguments: "[paths...]",
-    description: "Synchronize documents to the knowledge graph"
+__legacyDecorateClassTS([
+  Option5({
+    flags: "--skip-extraction",
+    description: "Skip AI entity extraction (sync without re-extracting entities)"
   }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService,
-    typeof GraphValidatorService === "undefined" ? Object : GraphValidatorService
-  ])
-], SyncCommand);
-// src/commands/validate.command.ts
-import { Injectable as Injectable15 } from "@nestjs/common";
-import { Command as Command6, CommandRunner as CommandRunner6, Option as Option4 } from "nest-commander";
-class ValidateCommand extends CommandRunner6 {
-  parserService;
-  _graphValidator;
-  constructor(parserService, _graphValidator) {
-    super();
-    this.parserService = parserService;
-    this._graphValidator = _graphValidator;
-  }
-  async run(_inputs, options) {
-    try {
-      console.log(`=== Document Validation ===
-`);
-      const { docs, errors: schemaErrors } = await this.parserService.parseAllDocumentsWithErrors();
-      const issues = [];
-      for (const schemaError of schemaErrors) {
-        issues.push({
-          type: "error",
-          path: schemaError.path,
-          message: schemaError.error
-        });
-      }
-      const entityIndex = new Map;
-      for (const doc of docs) {
-        for (const entity of doc.entities) {
-          let docPaths = entityIndex.get(entity.name);
-          if (!docPaths) {
-            docPaths = new Set;
-            entityIndex.set(entity.name, docPaths);
-          }
-          docPaths.add(doc.path);
-        }
-      }
-      const validationErrors = validateDocuments2(docs);
-      for (const err of validationErrors) {
-        issues.push({
-          type: "error",
-          path: err.path,
-          message: err.error,
-          suggestion: "Add entity definition or fix the reference"
-        });
-      }
-      console.log(`Scanned ${docs.length} documents`);
-      console.log(`Found ${entityIndex.size} unique entities
-`);
-      if (issues.length > 0) {
-        console.log(`Document Errors (${issues.length}):
-`);
-        issues.forEach((i) => {
-          console.log(`  ${i.path}`);
-          console.log(`    Error: ${i.message}`);
-          if (options.fix && i.suggestion) {
-            console.log(`    Suggestion: ${i.suggestion}`);
-          }
-          console.log("");
-        });
-      } else {
-        console.log(`\u2713 Markdown files valid (schema + relationships)
-`);
-      }
-      const graphResult = {
-        valid: true,
-        issues: [],
-        stats: {
-          totalNodes: 0,
-          documentsChecked: 0,
-          entitiesChecked: 0,
-          errorsFound: 0,
-          warningsFound: 0
-        }
-      };
-      const totalErrors = issues.length + graphResult.stats.errorsFound;
-      const totalWarnings = graphResult.stats.warningsFound;
-      console.log(`
-=== Validation Summary ===`);
-      console.log(`Markdown files: ${issues.length === 0 ? "\u2713 PASSED" : `\u2717 ${issues.length} errors`}`);
-      console.log(`Graph database: ${graphResult.stats.errorsFound === 0 ? "\u2713 PASSED" : `\u2717 ${graphResult.stats.errorsFound} errors`}`);
-      console.log(`Warnings: ${totalWarnings}`);
-      console.log(`
-Overall: ${totalErrors === 0 ? "\u2713 PASSED" : "\u2717 FAILED"}${totalWarnings > 0 ? ` (${totalWarnings} warnings)` : ""}
-`);
-      process.exit(totalErrors > 0 ? 1 : 0);
-    } catch (error) {
-      console.error("Validation failed:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseFix() {
-    return true;
-  }
-}
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", []),
+  __legacyMetadataTS("design:returntype", Boolean)
+], SyncCommand.prototype, "parseSkipExtraction", null);
 __legacyDecorateClassTS([
-  Option4({
-    flags: "--fix",
-    description: "Show suggestions for common issues"
+  Option5({
+    flags: "--legacy",
+    description: "Use legacy v1 mode: manifest-based change detection, no AI extraction"
   }),
   __legacyMetadataTS("design:type", Function),
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
-], ValidateCommand.prototype, "parseFix", null);
-ValidateCommand = __legacyDecorateClassTS([
-  Injectable15(),
-  Command6({
-    name: "validate",
-    description: "Validate entity references and relationships across documents"
+], SyncCommand.prototype, "parseLegacy", null);
+SyncCommand = __legacyDecorateClassTS([
+  Injectable18(),
+  Command7({
+    name: "sync",
+    arguments: "[paths...]",
+    description: "Synchronize documents to the knowledge graph"
   }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
+    typeof SyncService === "undefined" ? Object : SyncService,
     typeof GraphValidatorService === "undefined" ? Object : GraphValidatorService
   ])
-], ValidateCommand);
+], SyncCommand);
 // src/embedding/embedding.module.ts
 import { Module } from "@nestjs/common";
 import { ConfigModule } from "@nestjs/config";
@@ -3147,10 +3774,10 @@ GraphModule = __legacyDecorateClassTS([
 import { Module as Module3 } from "@nestjs/common";
 
 // src/query/query.service.ts
-import { Injectable as Injectable16, Logger as Logger7 } from "@nestjs/common";
+import { Injectable as Injectable19, Logger as Logger10 } from "@nestjs/common";
 class QueryService {
   graphService;
-  logger = new Logger7(QueryService.name);
+  logger = new Logger10(QueryService.name);
   constructor(graphService) {
     this.graphService = graphService;
   }
@@ -3160,7 +3787,7 @@ class QueryService {
   }
 }
 QueryService = __legacyDecorateClassTS([
-  Injectable16(),
+  Injectable19(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService
   ])
@@ -3187,6 +3814,8 @@ SyncModule = __legacyDecorateClassTS([
     providers: [
       SyncService,
       ManifestService,
+      DatabaseChangeDetectorService,
+      EntityExtractorService,
       DocumentParserService,
       OntologyService,
       CascadeService,
@@ -3196,6 +3825,8 @@ SyncModule = __legacyDecorateClassTS([
     exports: [
       SyncService,
       ManifestService,
+      DatabaseChangeDetectorService,
+      EntityExtractorService,
       DocumentParserService,
       OntologyService,
       CascadeService,
@@ -3221,14 +3852,15 @@ AppModule = __legacyDecorateClassTS([
       QueryModule
     ],
     providers: [
+      ExtractCommand,
       SyncCommand,
       StatusCommand,
       SearchCommand,
       RelsCommand,
       SqlCommand,
-      ValidateCommand,
       OntologyCommand,
-      InitCommand
+      InitCommand,
+      MigrateCommand
     ]
   })
 ], AppModule);