@gzoo/cortex 0.5.9

package/dist/cortex-mcp.mjs

@@ -0,0 +1,3153 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/mcp/dist/index.js
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// packages/core/dist/types/llm.js
+var LLMTask;
+(function(LLMTask2) {
+  LLMTask2["ENTITY_EXTRACTION"] = "entity_extraction";
+  LLMTask2["RELATIONSHIP_INFERENCE"] = "relationship_inference";
+  LLMTask2["EMBEDDING_GENERATION"] = "embedding_generation";
+  LLMTask2["CONVERSATIONAL_QUERY"] = "conversational_query";
+  LLMTask2["CONTRADICTION_DETECTION"] = "contradiction_detection";
+  LLMTask2["CONTEXT_RANKING"] = "context_ranking";
+})(LLMTask || (LLMTask = {}));
+
+// packages/core/dist/errors/cortex-error.js
+var CortexError = class extends Error {
+  code;
+  severity;
+  layer;
+  context;
+  recoveryAction;
+  retryable;
+  httpStatus;
+  name = "CortexError";
+  constructor(code, severity, layer, message, context, recoveryAction, retryable = false, httpStatus) {
+    super(message);
+    this.code = code;
+    this.severity = severity;
+    this.layer = layer;
+    this.context = context;
+    this.recoveryAction = recoveryAction;
+    this.retryable = retryable;
+    this.httpStatus = httpStatus;
+  }
+};
+var LLM_PROVIDER_UNAVAILABLE = "LLM_PROVIDER_UNAVAILABLE";
+var LLM_EXTRACTION_FAILED = "LLM_EXTRACTION_FAILED";
+var LLM_RATE_LIMITED = "LLM_RATE_LIMITED";
+var LLM_BUDGET_EXHAUSTED = "LLM_BUDGET_EXHAUSTED";
+var LLM_AUTH_FAILED = "LLM_AUTH_FAILED";
+var LLM_TIMEOUT = "LLM_TIMEOUT";
+var GRAPH_DB_ERROR = "GRAPH_DB_ERROR";
+var GRAPH_ENTITY_NOT_FOUND = "GRAPH_ENTITY_NOT_FOUND";
+var CONFIG_INVALID = "CONFIG_INVALID";
+var CONFIG_MISSING = "CONFIG_MISSING";
+
+// packages/core/dist/events/event-bus.js
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  emit(event) {
+    const typeHandlers = this.handlers.get(event.type);
+    if (!typeHandlers)
+      return;
+    for (const handler of typeHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(type).add(handler);
+    return () => this.off(type, handler);
+  }
+  off(type, handler) {
+    const typeHandlers = this.handlers.get(type);
+    if (!typeHandlers)
+      return;
+    typeHandlers.delete(handler);
+    if (typeHandlers.size === 0) {
+      this.handlers.delete(type);
+    }
+  }
+  once(type, handler) {
+    const wrappedHandler = (event) => {
+      this.off(type, wrappedHandler);
+      handler(event);
+    };
+    this.on(type, wrappedHandler);
+  }
+};
+var eventBus = new EventBus();
+
+// packages/core/dist/config/schema.js
+import { z } from "zod";
+var ingestConfigSchema = z.object({
+  watchDirs: z.array(z.string()).default(["."]),
+  exclude: z.array(z.string()).default([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".git",
+    "*.min.js",
+    "*.min.css",
+    "*.map",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "__pycache__",
+    "*.pyc",
+    ".DS_Store",
+    "Thumbs.db"
+  ]),
+  fileTypes: z.array(z.string()).default(["md", "ts", "tsx", "js", "jsx", "json", "yaml", "yml"]),
+  maxFileSize: z.number().positive().default(10485760),
+  maxFilesPerDir: z.number().positive().default(1e4),
+  maxTotalFiles: z.number().positive().default(5e4),
+  debounceMs: z.number().nonnegative().default(500),
+  parseTimeoutMs: z.number().positive().default(3e4),
+  batchSize: z.number().positive().default(5),
+  followSymlinks: z.boolean().default(false),
+  confirmCost: z.boolean().default(true)
+});
+var graphConfigSchema = z.object({
+  dbPath: z.string().default("~/.cortex/cortex.db"),
+  vectorDbPath: z.string().default("~/.cortex/vector.lance"),
+  walMode: z.boolean().default(true),
+  backupOnStartup: z.boolean().default(true),
+  integrityCheckInterval: z.enum(["daily", "weekly", "monthly", "never"]).default("weekly"),
+  softDelete: z.boolean().default(true),
+  mergeConfidenceThreshold: z.number().min(0).max(1).default(0.95)
+});
+var llmBudgetSchema = z.object({
+  monthlyLimitUsd: z.number().nonnegative().default(25),
+  warningThresholds: z.array(z.number().min(0).max(1)).default([0.5, 0.8, 0.9]),
+  enforcementAction: z.enum(["warn", "fallback-local", "stop"]).default("fallback-local")
+});
+var llmCacheSchema = z.object({
+  enabled: z.boolean().default(true),
+  ttlDays: z.number().positive().default(7),
+  maxSizeMb: z.number().positive().default(500)
+});
+var llmLocalSchema = z.object({
+  provider: z.string().default("ollama"),
+  host: z.string().url().default("http://localhost:11434"),
+  model: z.string().default("mistral:7b-instruct-q5_K_M"),
+  embeddingModel: z.string().default("nomic-embed-text"),
+  numCtx: z.number().positive().default(8192),
+  numGpu: z.number().default(-1),
+  timeoutMs: z.number().positive().default(9e4),
+  // 90 seconds
+  keepAlive: z.string().default("5m")
+});
+var llmCloudSchema = z.object({
+  provider: z.string().default("anthropic"),
+  baseUrl: z.string().url().optional(),
+  apiKeySource: z.string().default("env:CORTEX_ANTHROPIC_API_KEY"),
+  models: z.object({
+    primary: z.string().default("claude-sonnet-4-5-20250929"),
+    fast: z.string().default("claude-haiku-4-5-20251001")
+  }).default({}),
+  timeoutMs: z.number().positive().default(6e4),
+  maxRetries: z.number().nonnegative().default(3),
+  promptCaching: z.boolean().default(true)
+});
+var llmConfigSchema = z.object({
+  mode: z.enum(["cloud-first", "hybrid", "local-first", "local-only"]).default("cloud-first"),
+  taskRouting: z.record(z.string(), z.enum(["auto", "local", "cloud"])).default({
+    entity_extraction: "auto",
+    relationship_inference: "auto",
+    contradiction_detection: "local",
+    conversational_query: "auto",
+    context_ranking: "auto",
+    embedding_generation: "local"
+  }),
+  temperature: z.record(z.string(), z.number().min(0).max(2)).default({
+    extraction: 0.1,
+    chat: 0.7,
+    ranking: 0.1,
+    proactive: 0.5
+  }),
+  maxContextTokens: z.number().positive().default(5e4),
+  cache: llmCacheSchema.default({}),
+  budget: llmBudgetSchema.default({}),
+  local: llmLocalSchema.default({}),
+  cloud: llmCloudSchema.default({})
+});
+var privacyConfigSchema = z.object({
+  defaultLevel: z.enum(["standard", "sensitive", "restricted"]).default("standard"),
+  directoryOverrides: z.record(z.string(), z.enum(["standard", "sensitive", "restricted"])).default({}),
+  autoClassify: z.boolean().default(true),
+  logTransmissions: z.boolean().default(true),
+  showTransmissionIndicator: z.boolean().default(true),
+  secretPatterns: z.array(z.string()).default([
+    "(?i)(api[_-]?key|secret[_-]?key|access[_-]?token)\\s*[:=]\\s*[\\w\\-]{20,}",
+    "AKIA[0-9A-Z]{16}",
+    "sk-ant-[a-zA-Z0-9\\-]{40,}",
+    "ghp_[a-zA-Z0-9]{36}",
+    "(?i)password\\s*[:=]\\s*\\S{8,}"
+  ])
+});
+var serverConfigSchema = z.object({
+  port: z.number().int().min(1).max(65535).default(3710),
+  host: z.string().default("127.0.0.1"),
+  cors: z.array(z.string()).default(["http://localhost:5173"])
+});
+var loggingConfigSchema = z.object({
+  level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  file: z.string().default("~/.cortex/logs/cortex.log"),
+  structured: z.boolean().default(true),
+  maxSizeMb: z.number().positive().default(10),
+  maxFiles: z.number().positive().default(5),
+  redactPrompts: z.boolean().default(false)
+});
+var cortexConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string().default("1.0"),
+  ingest: ingestConfigSchema.default({}),
+  graph: graphConfigSchema.default({}),
+  llm: llmConfigSchema.default({}),
+  privacy: privacyConfigSchema.default({}),
+  server: serverConfigSchema.default({}),
+  logging: loggingConfigSchema.default({})
+});
+
+// packages/core/dist/config/loader.js
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+function loadDotEnv() {
+  const envPath = join(homedir(), ".cortex", ".env");
+  if (!existsSync(envPath))
+    return;
+  try {
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#"))
+        continue;
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1)
+        continue;
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (process.env[key] === void 0) {
+        process.env[key] = value;
+      }
+    }
+  } catch {
+  }
+}
+var CONFIG_FILENAME = "cortex.config.json";
+function findConfigFile(startDir) {
+  const searchPaths = [
+    startDir ? resolve(startDir, CONFIG_FILENAME) : null,
+    resolve(process.cwd(), CONFIG_FILENAME),
+    join(homedir(), ".cortex", CONFIG_FILENAME)
+  ].filter((p) => p !== null);
+  const envPath = process.env["CORTEX_CONFIG_PATH"];
+  if (envPath) {
+    searchPaths.unshift(resolve(envPath));
+  }
+  for (const p of searchPaths) {
+    if (existsSync(p))
+      return p;
+  }
+  return null;
+}
+function readConfigFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new CortexError(CONFIG_INVALID, "critical", "config", `Failed to read config file: ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { filePath });
+  }
+}
+function applyEnvOverrides(config8) {
+  const env = process.env;
+  if (env["CORTEX_LLM_MODE"]) {
+    config8.llm = { ...config8.llm, mode: env["CORTEX_LLM_MODE"] };
+  }
+  if (env["CORTEX_SERVER_PORT"]) {
+    config8.server = { ...config8.server, port: parseInt(env["CORTEX_SERVER_PORT"], 10) };
+  }
+  if (env["CORTEX_DB_PATH"]) {
+    config8.graph = { ...config8.graph, dbPath: env["CORTEX_DB_PATH"] };
+  }
+  if (env["CORTEX_LOG_LEVEL"]) {
+    config8.logging = { ...config8.logging, level: env["CORTEX_LOG_LEVEL"] };
+  }
+  if (env["CORTEX_BUDGET_LIMIT"]) {
+    const budget = { ...config8.llm?.budget, monthlyLimitUsd: parseFloat(env["CORTEX_BUDGET_LIMIT"]) };
+    config8.llm = { ...config8.llm, budget };
+  }
+  if (env["CORTEX_OLLAMA_HOST"]) {
+    const local = { ...config8.llm?.local, host: env["CORTEX_OLLAMA_HOST"] };
+    config8.llm = { ...config8.llm, local };
+  }
+  return config8;
+}
+function loadConfig(options = {}) {
+  loadDotEnv();
+  const { configDir, overrides, requireFile = false } = options;
+  let fileConfig = {};
+  const configPath = findConfigFile(configDir);
+  if (configPath) {
+    fileConfig = readConfigFile(configPath);
+  } else if (requireFile) {
+    throw new CortexError(CONFIG_MISSING, "critical", "config", "No cortex.config.json found. Run `cortex init` to create one.", void 0, "Run `cortex init` to create a configuration file.");
+  }
+  let merged = { ...fileConfig };
+  merged = applyEnvOverrides(merged);
+  if (overrides) {
+    merged = { ...merged, ...overrides };
+  }
+  const result = cortexConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const messages = result.error.issues.map((issue) => `  ${issue.path.join(".")}: ${issue.message}`);
+    throw new CortexError(CONFIG_INVALID, "critical", "config", `Invalid configuration:
+${messages.join("\n")}`, { issues: result.error.issues });
+  }
+  return result.data;
+}
+
+// packages/core/dist/config/project-registry.js
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { z as z2 } from "zod";
+var REGISTRY_PATH = join2(homedir2(), ".cortex", "projects.json");
+var projectEntrySchema = z2.object({
+  name: z2.string(),
+  path: z2.string(),
+  configPath: z2.string().optional(),
+  addedAt: z2.string(),
+  lastWatched: z2.string().optional()
+});
+var projectRegistrySchema = z2.object({
+  version: z2.literal("1.0"),
+  projects: z2.record(z2.string(), projectEntrySchema)
+});
+
+// packages/core/dist/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var globalLogLevel = null;
+var Logger = class _Logger {
+  level;
+  source;
+  constructor(source, level = "info") {
+    this.source = source;
+    this.level = LOG_LEVELS[level];
+  }
+  setLevel(level) {
+    this.level = LOG_LEVELS[level];
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  child(source) {
+    const childLogger = new _Logger(`${this.source}:${source}`);
+    childLogger.level = this.level;
+    return childLogger;
+  }
+  log(level, message, context) {
+    const effectiveLevel = globalLogLevel ?? this.level;
+    if (LOG_LEVELS[level] < effectiveLevel)
+      return;
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: this.source,
+      ...context && { context }
+    };
+    const output = level === "error" || level === "warn" ? process.stderr : process.stdout;
+    output.write(JSON.stringify(entry) + "\n");
+  }
+};
+function createLogger(source, level) {
+  const effectiveLevel = level ?? process.env["CORTEX_LOG_LEVEL"] ?? "info";
+  return new Logger(source, effectiveLevel);
+}
+
+// packages/llm/dist/providers/anthropic.js
+import Anthropic from "@anthropic-ai/sdk";
+var logger = createLogger("llm:anthropic");
+var AnthropicProvider = class {
+  name = "anthropic";
+  type = "cloud";
+  client;
+  primaryModel;
+  fastModel;
+  promptCaching;
+  capabilities = {
+    supportedTasks: [
+      LLMTask.ENTITY_EXTRACTION,
+      LLMTask.RELATIONSHIP_INFERENCE,
+      LLMTask.CONTRADICTION_DETECTION,
+      LLMTask.CONVERSATIONAL_QUERY,
+      LLMTask.CONTEXT_RANKING
+    ],
+    maxContextTokens: 2e5,
+    supportsStructuredOutput: true,
+    supportsStreaming: true,
+    estimatedTokensPerSecond: 80,
+    costPerMillionInputTokens: 3,
+    costPerMillionOutputTokens: 15
+  };
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env["CORTEX_ANTHROPIC_API_KEY"];
+    if (!apiKey) {
+      throw new CortexError(LLM_AUTH_FAILED, "critical", "llm", "Anthropic API key not found. Set CORTEX_ANTHROPIC_API_KEY environment variable.", void 0, "Set CORTEX_ANTHROPIC_API_KEY or run `cortex init`.", false, 401);
+    }
+    this.client = new Anthropic({
+      apiKey,
+      timeout: options.timeoutMs ?? 3e4,
+      maxRetries: options.maxRetries ?? 3
+    });
+    this.primaryModel = options.primaryModel ?? "claude-sonnet-4-5-20250929";
+    this.fastModel = options.fastModel ?? "claude-haiku-4-5-20251001";
+    this.promptCaching = options.promptCaching ?? true;
+  }
+  getModel(preference = "primary") {
+    return preference === "fast" ? this.fastModel : this.primaryModel;
+  }
+  async complete(prompt, options) {
+    const result = await this.completeWithSystem(void 0, prompt, options);
+    return result.content;
+  }
+  async completeWithSystem(systemPrompt2, userPrompt, options, modelPreference = "primary") {
+    const model = this.getModel(modelPreference);
+    try {
+      const systemMessages = systemPrompt2 ? this.buildSystemMessages(systemPrompt2) : void 0;
+      const response = await this.client.messages.create({
+        model,
+        max_tokens: options?.maxTokens ?? 4096,
+        temperature: options?.temperature ?? 0.7,
+        ...systemMessages && { system: systemMessages },
+        messages: [{ role: "user", content: userPrompt }],
+        ...options?.stopSequences?.length && { stop_sequences: options.stopSequences }
+      });
+      const textBlock = response.content.find((b) => b.type === "text");
+      const content = textBlock?.text ?? "";
+      return {
+        content,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        model
+      };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async completeStructured(prompt, _schema, options) {
+    const result = await this.complete(prompt, options);
+    return JSON.parse(result);
+  }
+  async *stream(prompt, options) {
+    yield* this.streamWithSystem(void 0, prompt, options);
+  }
+  async *streamWithSystem(systemPrompt2, userPrompt, options, modelPreference = "primary") {
+    const model = this.getModel(modelPreference);
+    try {
+      const systemMessages = systemPrompt2 ? this.buildSystemMessages(systemPrompt2) : void 0;
+      const stream = this.client.messages.stream({
+        model,
+        max_tokens: options?.maxTokens ?? 4096,
+        temperature: options?.temperature ?? 0.7,
+        ...systemMessages && { system: systemMessages },
+        messages: [{ role: "user", content: userPrompt }],
+        ...options?.stopSequences?.length && { stop_sequences: options.stopSequences }
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          yield event.delta.text;
+        }
+      }
+      const finalMessage = await stream.finalMessage();
+      return {
+        inputTokens: finalMessage.usage.input_tokens,
+        outputTokens: finalMessage.usage.output_tokens,
+        model
+      };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async embed(_texts) {
+    throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "medium", "llm", "Anthropic does not support embeddings. Use local embedding model.");
+  }
+  async isAvailable() {
+    try {
+      await this.client.messages.create({
+        model: this.fastModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildSystemMessages(systemPrompt2) {
+    if (this.promptCaching) {
+      return [{
+        type: "text",
+        text: systemPrompt2,
+        cache_control: { type: "ephemeral" }
+      }];
+    }
+    return [{ type: "text", text: systemPrompt2 }];
+  }
+  mapError(err) {
+    if (err instanceof Anthropic.AuthenticationError) {
+      return new CortexError(LLM_AUTH_FAILED, "critical", "llm", "Anthropic API authentication failed. Check your API key.", void 0, "Verify CORTEX_ANTHROPIC_API_KEY is correct.", false, 401);
+    }
+    if (err instanceof Anthropic.RateLimitError) {
+      return new CortexError(LLM_RATE_LIMITED, "medium", "llm", "Anthropic rate limit exceeded.", void 0, "Wait and retry with backoff.", true, 429);
+    }
+    if (err instanceof Anthropic.APIConnectionTimeoutError) {
+      return new CortexError(LLM_TIMEOUT, "medium", "llm", "Anthropic API request timed out.", void 0, "Retry the request.", true, 504);
+    }
+    if (err instanceof Anthropic.APIError) {
+      return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Anthropic API error: ${err.message}`, { status: err.status }, "Retry or check Anthropic status page.", true, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Anthropic provider error: ${message}`, void 0, "Check network connectivity.", true);
+  }
+};
+
+// packages/llm/dist/providers/ollama.js
+var logger2 = createLogger("llm:ollama");
+var OllamaProvider = class {
+  name = "ollama";
+  type = "local";
+  host;
+  model;
+  embeddingModel;
+  numCtx;
+  numGpu;
+  timeoutMs;
+  keepAlive;
+  capabilities = {
+    supportedTasks: [
+      LLMTask.ENTITY_EXTRACTION,
+      LLMTask.RELATIONSHIP_INFERENCE,
+      LLMTask.CONTRADICTION_DETECTION,
+      LLMTask.CONVERSATIONAL_QUERY,
+      LLMTask.CONTEXT_RANKING,
+      LLMTask.EMBEDDING_GENERATION
+    ],
+    maxContextTokens: 8192,
+    supportsStructuredOutput: true,
+    supportsStreaming: true,
+    estimatedTokensPerSecond: 30,
+    costPerMillionInputTokens: 0,
+    costPerMillionOutputTokens: 0
+  };
+  constructor(options = {}) {
+    this.host = options.host ?? process.env["CORTEX_OLLAMA_HOST"] ?? "http://localhost:11434";
+    this.model = options.model ?? "mistral:7b-instruct-q5_K_M";
+    this.embeddingModel = options.embeddingModel ?? "nomic-embed-text";
+    this.numCtx = options.numCtx ?? 8192;
+    this.numGpu = options.numGpu ?? -1;
+    this.timeoutMs = options.timeoutMs ?? 3e5;
+    this.keepAlive = options.keepAlive ?? "5m";
+    this.capabilities.maxContextTokens = this.numCtx;
+  }
+  getModel() {
+    return this.model;
+  }
+  async complete(prompt, options) {
+    const result = await this.completeWithSystem(void 0, prompt, options);
+    return result.content;
+  }
+  async completeWithSystem(systemPrompt2, userPrompt, options, _modelPreference = "primary") {
+    const numPredict = options?.maxTokens ? Math.min(options.maxTokens, Math.floor(this.numCtx / 2)) : void 0;
+    const requestBody = {
+      model: this.model,
+      prompt: userPrompt,
+      stream: false,
+      options: {
+        temperature: options?.temperature ?? 0.7,
+        num_ctx: this.numCtx,
+        num_gpu: this.numGpu,
+        ...numPredict !== void 0 && { num_predict: numPredict },
+        ...options?.stopSequences?.length && { stop: options.stopSequences }
+      },
+      keep_alive: this.keepAlive
+    };
+    if (systemPrompt2) {
+      requestBody.system = systemPrompt2;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+      const response = await fetch(`${this.host}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+      }
+      const result = await response.json();
+      const inputTokens = result.prompt_eval_count ?? 0;
+      const outputTokens = result.eval_count ?? 0;
+      logger2.debug("Ollama completion", {
+        model: this.model,
+        inputTokens,
+        outputTokens,
+        durationMs: result.total_duration ? Math.round(result.total_duration / 1e6) : void 0
+      });
+      return {
+        content: result.response,
+        inputTokens,
+        outputTokens,
+        model: this.model
+      };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async completeStructured(prompt, _schema, options) {
+    const result = await this.complete(prompt, options);
+    return JSON.parse(result);
+  }
+  async *stream(prompt, options) {
+    yield* this.streamWithSystem(void 0, prompt, options);
+  }
+  async *streamWithSystem(systemPrompt2, userPrompt, options, _modelPreference = "primary") {
+    const streamNumPredict = options?.maxTokens ? Math.min(options.maxTokens, Math.floor(this.numCtx / 2)) : void 0;
+    const requestBody = {
+      model: this.model,
+      prompt: userPrompt,
+      stream: true,
+      options: {
+        temperature: options?.temperature ?? 0.7,
+        num_ctx: this.numCtx,
+        num_gpu: this.numGpu,
+        ...streamNumPredict !== void 0 && { num_predict: streamNumPredict },
+        ...options?.stopSequences?.length && { stop: options.stopSequences }
+      },
+      keep_alive: this.keepAlive
+    };
+    if (systemPrompt2) {
+      requestBody.system = systemPrompt2;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+      const response = await fetch(`${this.host}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+      }
+      if (!response.body) {
+        throw new Error("No response body from Ollama");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let inputTokens = 0;
+      let outputTokens = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n").filter((line) => line.trim());
+        for (const line of lines) {
+          try {
+            const data = JSON.parse(line);
+            if (data.response) {
+              yield data.response;
+            }
+            if (data.done) {
+              inputTokens = data.prompt_eval_count ?? 0;
+              outputTokens = data.eval_count ?? 0;
+            }
+          } catch {
+          }
+        }
+      }
+      return {
+        inputTokens,
+        outputTokens,
+        model: this.model
+      };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async embed(texts) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+      const requestBody = {
+        model: this.embeddingModel,
+        input: texts
+      };
+      const response = await fetch(`${this.host}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama embed API error (${response.status}): ${errorText}`);
+      }
+      const result = await response.json();
+      logger2.debug("Ollama embeddings", {
+        model: this.embeddingModel,
+        count: texts.length,
+        dimensions: result.embeddings[0]?.length
+      });
+      return result.embeddings.map((emb) => new Float32Array(emb));
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async isAvailable() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.host}/api/tags`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return false;
+      }
+      const result = await response.json();
+      const hasModel = result.models.some((m) => m.name === this.model || m.model === this.model);
+      if (!hasModel) {
+        logger2.warn("Ollama model not found", { model: this.model, available: result.models.map((m) => m.name) });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async ensureModel() {
+    const available = await this.isAvailable();
+    if (!available) {
+      throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Ollama is not running or not reachable at ${this.host}`, void 0, "Start Ollama with `ollama serve` or check the host configuration.", false);
+    }
+    const response = await fetch(`${this.host}/api/tags`);
+    const result = await response.json();
+    const hasModel = result.models.some((m) => m.name === this.model || m.model === this.model);
+    if (!hasModel) {
+      logger2.info("Pulling Ollama model", { model: this.model });
+      throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Ollama model "${this.model}" is not installed.`, { model: this.model }, `Run: ollama pull ${this.model}`, false);
+    }
+  }
+  async listModels() {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch(`${this.host}/api/tags`, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      if (!response.ok)
+        return [];
+      const result = await response.json();
+      return result.models.map((m) => ({ name: m.name, sizeBytes: m.size, modifiedAt: m.modified_at }));
+    } catch {
+      clearTimeout(timeoutId);
+      return [];
+    }
+  }
+  getHost() {
+    return this.host;
+  }
+  getNumCtx() {
+    return this.numCtx;
+  }
+  getNumGpu() {
+    return this.numGpu;
+  }
+  getEmbeddingModel() {
+    return this.embeddingModel;
+  }
+  mapError(err) {
+    if (err instanceof CortexError) {
+      return err;
+    }
+    if (err instanceof Error) {
+      if (err.name === "AbortError") {
+        return new CortexError(LLM_TIMEOUT, "medium", "llm", `Ollama request timed out after ${this.timeoutMs}ms`, { timeoutMs: this.timeoutMs }, "Increase timeout or check if model is loaded.", true, 504);
+      }
+      if (err.message.includes("ECONNREFUSED") || err.message.includes("fetch failed")) {
+        return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Cannot connect to Ollama at ${this.host}`, { host: this.host }, "Start Ollama with `ollama serve` or check the host configuration.", false);
+      }
+      return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Ollama provider error: ${err.message}`, void 0, "Check Ollama logs for details.", true);
+    }
+    return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `Ollama provider error: ${String(err)}`, void 0, "Check Ollama logs for details.", true);
+  }
+};
+
+// packages/llm/dist/providers/openai-compatible.js
+import OpenAI from "openai";
+var logger3 = createLogger("llm:openai-compatible");
+var OpenAICompatibleProvider = class {
+  name = "openai-compatible";
+  type = "cloud";
+  client;
+  primaryModel;
+  fastModel;
+  isGemini;
+  capabilities = {
+    supportedTasks: [
+      LLMTask.ENTITY_EXTRACTION,
+      LLMTask.RELATIONSHIP_INFERENCE,
+      LLMTask.CONTRADICTION_DETECTION,
+      LLMTask.CONVERSATIONAL_QUERY,
+      LLMTask.CONTEXT_RANKING
+    ],
+    maxContextTokens: 128e3,
+    supportsStructuredOutput: true,
+    supportsStreaming: true,
+    estimatedTokensPerSecond: 80,
+    // Set to 0 — pricing varies by provider; budget tracking is approximate
+    costPerMillionInputTokens: 0,
+    costPerMillionOutputTokens: 0
+  };
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new CortexError(LLM_AUTH_FAILED, "critical", "llm", "OpenAI-compatible API key not found. Check llm.cloud.apiKeySource in your config.", void 0, "Set the environment variable specified in llm.cloud.apiKeySource.", false, 401);
+    }
+    this.client = new OpenAI({
+      apiKey: options.apiKey,
+      baseURL: options.baseUrl,
+      timeout: options.timeoutMs ?? 6e4,
+      maxRetries: options.maxRetries ?? 3
+    });
+    this.primaryModel = options.primaryModel ?? "gpt-4o";
+    this.fastModel = options.fastModel ?? "gpt-4o-mini";
+    this.isGemini = options.baseUrl.includes("generativelanguage.googleapis.com");
+    logger3.info("OpenAI-compatible provider initialized", {
+      baseUrl: options.baseUrl,
+      primaryModel: this.primaryModel,
+      fastModel: this.fastModel
+    });
+  }
+  getModel(preference = "primary") {
+    return preference === "fast" ? this.fastModel : this.primaryModel;
+  }
+  /** Gemini uses max_completion_tokens; others use max_tokens */
+  tokenLimitParams(maxTokens) {
+    return this.isGemini ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens };
+  }
+  async complete(prompt, options) {
+    const result = await this.completeWithSystem(void 0, prompt, options);
+    return result.content;
+  }
+  async completeWithSystem(systemPrompt2, userPrompt, options, modelPreference = "primary") {
+    const model = this.getModel(modelPreference);
+    try {
+      const messages = [];
+      if (systemPrompt2) {
+        messages.push({ role: "system", content: systemPrompt2 });
+      }
+      messages.push({ role: "user", content: userPrompt });
+      const response = await this.client.chat.completions.create({
+        model,
+        ...this.tokenLimitParams(options?.maxTokens ?? 4096),
+        temperature: options?.temperature ?? 0.7,
+        messages,
+        ...options?.stopSequences?.length && { stop: options.stopSequences }
+      });
+      const content = response.choices[0]?.message?.content ?? "";
+      return {
+        content,
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0,
+        model
+      };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async completeStructured(prompt, _schema, options) {
+    const result = await this.complete(prompt, options);
+    return JSON.parse(result);
+  }
+  async *stream(prompt, options) {
+    yield* this.streamWithSystem(void 0, prompt, options);
+  }
+  async *streamWithSystem(systemPrompt2, userPrompt, options, modelPreference = "primary") {
+    const model = this.getModel(modelPreference);
+    try {
+      const messages = [];
+      if (systemPrompt2) {
+        messages.push({ role: "system", content: systemPrompt2 });
+      }
+      messages.push({ role: "user", content: userPrompt });
+      const stream = await this.client.chat.completions.create({
+        model,
+        ...this.tokenLimitParams(options?.maxTokens ?? 4096),
+        temperature: options?.temperature ?? 0.7,
+        messages,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...options?.stopSequences?.length && { stop: options.stopSequences }
+      });
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta) {
+          yield delta;
+        }
+        if (chunk.usage) {
+          inputTokens = chunk.usage.prompt_tokens;
+          outputTokens = chunk.usage.completion_tokens;
+        }
+      }
+      return { inputTokens, outputTokens, model };
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async embed(_texts) {
+    throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "medium", "llm", "OpenAI-compatible provider does not handle embeddings. Use local embedding model.");
+  }
+  async isAvailable() {
+    try {
+      await this.client.chat.completions.create({
+        model: this.fastModel,
+        ...this.tokenLimitParams(1),
+        messages: [{ role: "user", content: "ping" }]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  mapError(err) {
+    if (err instanceof OpenAI.AuthenticationError) {
+      return new CortexError(LLM_AUTH_FAILED, "critical", "llm", "OpenAI-compatible API authentication failed. Check your API key.", void 0, "Verify the environment variable in llm.cloud.apiKeySource is correct.", false, 401);
+    }
+    if (err instanceof OpenAI.RateLimitError) {
+      return new CortexError(LLM_RATE_LIMITED, "medium", "llm", "OpenAI-compatible API rate limit exceeded.", void 0, "Wait and retry with backoff.", true, 429);
+    }
+    if (err instanceof OpenAI.APIConnectionTimeoutError) {
+      return new CortexError(LLM_TIMEOUT, "medium", "llm", "OpenAI-compatible API request timed out.", void 0, "Retry the request or increase llm.cloud.timeoutMs.", true, 504);
+    }
+    if (err instanceof OpenAI.APIError) {
+      const body = typeof err.error === "object" ? JSON.stringify(err.error) : String(err.error ?? "");
+      logger3.debug("API error details", { status: err.status, body, headers: err.headers });
+      return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `OpenAI-compatible API error: ${err.status} ${err.message}${body ? ` \u2014 ${body}` : ""}`, { status: err.status }, "Retry or check your provider status page.", true, err.status);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", `OpenAI-compatible provider error: ${message}`, void 0, "Check network connectivity and llm.cloud.baseUrl configuration.", true);
+  }
+};
+
+// packages/llm/dist/token-tracker.js
+var logger4 = createLogger("llm:token-tracker");
+var MODEL_COSTS = {
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 }
+};
+var DEFAULT_COST = { input: 3, output: 15 };
+function estimateCost(model, inputTokens, outputTokens) {
+  const costs = MODEL_COSTS[model] ?? DEFAULT_COST;
+  return inputTokens / 1e6 * costs.input + outputTokens / 1e6 * costs.output;
+}
+var TokenTracker = class {
+  records = [];
+  monthlyBudgetUsd;
+  warningThresholds;
+  warningsFired = /* @__PURE__ */ new Set();
+  constructor(monthlyBudgetUsd = 25, warningThresholds = [0.5, 0.8, 0.9]) {
+    this.monthlyBudgetUsd = monthlyBudgetUsd;
+    this.warningThresholds = warningThresholds;
+  }
+  record(requestId, task, provider, model, inputTokens, outputTokens, latencyMs) {
+    const costUsd = estimateCost(model, inputTokens, outputTokens);
+    const record = {
+      id: crypto.randomUUID(),
+      requestId,
+      task,
+      provider,
+      model,
+      inputTokens,
+      outputTokens,
+      estimatedCostUsd: costUsd,
+      latencyMs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.records.push(record);
+    this.checkBudget();
+    return record;
+  }
+  checkBudget() {
+    const spent = this.getCurrentMonthSpend();
+    const usedPercent = this.monthlyBudgetUsd > 0 ? spent / this.monthlyBudgetUsd : 0;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    for (const threshold of this.warningThresholds) {
+      if (usedPercent >= threshold && !this.warningsFired.has(threshold)) {
+        this.warningsFired.add(threshold);
+        const remaining = this.monthlyBudgetUsd - spent;
+        logger4.warn(`Budget warning: ${(usedPercent * 100).toFixed(1)}% used`, {
+          spent,
+          budget: this.monthlyBudgetUsd,
+          remaining
+        });
+        eventBus.emit({
+          type: "budget.warning",
+          payload: { usedPercent: Math.round(usedPercent * 100), remainingUsd: remaining },
+          timestamp: ts,
+          source: "llm:token-tracker"
+        });
+      }
+    }
+    if (this.monthlyBudgetUsd > 0 && usedPercent >= 1 && !this.warningsFired.has(1)) {
+      this.warningsFired.add(1);
+      logger4.warn("Budget exhausted", { spent, budget: this.monthlyBudgetUsd });
+      eventBus.emit({
+        type: "budget.exhausted",
+        payload: { totalSpentUsd: spent },
+        timestamp: ts,
+        source: "llm:token-tracker"
+      });
+    }
+  }
+  getCurrentMonthSpend() {
+    const currentMonth = (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+    return this.records.filter((r) => r.timestamp.startsWith(currentMonth)).reduce((sum, r) => sum + r.estimatedCostUsd, 0);
+  }
+  isBudgetExhausted() {
+    return this.getCurrentMonthSpend() >= this.monthlyBudgetUsd;
+  }
+  getBudgetRemaining() {
+    return Math.max(0, this.monthlyBudgetUsd - this.getCurrentMonthSpend());
+  }
+  getRecords() {
+    return [...this.records];
+  }
+  getSummary() {
+    const currentMonth = (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+    const monthRecords = this.records.filter((r) => r.timestamp.startsWith(currentMonth));
+    const costByTask = {};
+    const costByProvider = {};
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCost = 0;
+    for (const r of monthRecords) {
+      totalInput += r.inputTokens;
+      totalOutput += r.outputTokens;
+      totalCost += r.estimatedCostUsd;
+      costByTask[r.task] = (costByTask[r.task] ?? 0) + r.estimatedCostUsd;
+      costByProvider[r.provider] = (costByProvider[r.provider] ?? 0) + r.estimatedCostUsd;
+    }
+    return {
+      totalCostUsd: totalCost,
+      totalInputTokens: totalInput,
+      totalOutputTokens: totalOutput,
+      requestCount: monthRecords.length,
+      costByTask,
+      costByProvider
+    };
+  }
+};
+
+// packages/llm/dist/cache.js
+import { createHash } from "node:crypto";
+var logger5 = createLogger("llm:cache");
+var ResponseCache = class {
+  cache = /* @__PURE__ */ new Map();
+  enabled;
+  ttlMs;
+  maxEntries;
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.ttlMs = options.ttlMs ?? 7 * 24 * 60 * 60 * 1e3;
+    this.maxEntries = options.maxEntries ?? 1e4;
+  }
+  buildKey(contentHash, promptId, promptVersion) {
+    return createHash("sha256").update(`${contentHash}:${promptId}:${promptVersion}`).digest("hex");
+  }
+  get(contentHash, promptId, promptVersion) {
+    if (!this.enabled)
+      return null;
+    const key = this.buildKey(contentHash, promptId, promptVersion);
+    const entry = this.cache.get(key);
+    if (!entry)
+      return null;
+    if (Date.now() - entry.createdAt > this.ttlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+    logger5.debug("Cache hit", { promptId, promptVersion });
+    return entry;
+  }
+  set(contentHash, promptId, promptVersion, response, model, inputTokens, outputTokens) {
+    if (!this.enabled)
+      return;
+    if (this.cache.size >= this.maxEntries) {
+      const oldest = [...this.cache.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt)[0];
+      if (oldest) {
+        this.cache.delete(oldest[0]);
+      }
+    }
+    const key = this.buildKey(contentHash, promptId, promptVersion);
+    this.cache.set(key, {
+      response,
+      model,
+      inputTokens,
+      outputTokens,
+      createdAt: Date.now()
+    });
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// packages/llm/dist/output-parser.js
+function extractJson(raw) {
+  let cleaned = raw.replace(/```(?:json)?\s*/g, "").replace(/```/g, "").trim();
+  const startIdx = findJsonStart(cleaned);
+  if (startIdx === -1) {
+    throw new Error("No JSON found in response");
+  }
+  const openChar = cleaned[startIdx];
+  const closeChar = openChar === "{" ? "}" : "]";
+  const endIdx = findMatchingClose(cleaned, startIdx, openChar, closeChar);
+  if (endIdx === -1) {
+    const repaired = repairTruncatedJson(cleaned.slice(startIdx));
+    if (repaired)
+      return repaired;
+    throw new Error("Unterminated JSON in response");
+  }
+  cleaned = cleaned.slice(startIdx, endIdx + 1);
+  return cleaned;
+}
+function repairTruncatedJson(truncated) {
+  let lastGoodIdx = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  const openStack = [];
+  for (let i = 0; i < truncated.length; i++) {
+    const ch = truncated[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (ch === "{" || ch === "[") {
+      openStack.push(ch);
+      depth++;
+    } else if (ch === "}" || ch === "]") {
+      openStack.pop();
+      depth--;
+      if (depth >= 1)
+        lastGoodIdx = i;
+    } else if (ch === "," && depth >= 1) {
+      lastGoodIdx = i - 1;
+    }
+  }
+  if (lastGoodIdx <= 0)
+    return null;
+  let repaired = truncated.slice(0, lastGoodIdx + 1).trimEnd();
+  if (repaired.endsWith(","))
+    repaired = repaired.slice(0, -1);
+  const remaining = [];
+  inString = false;
+  escaped = false;
+  for (let i = 0; i < repaired.length; i++) {
+    const ch = repaired[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (ch === "{")
+      remaining.push("}");
+    else if (ch === "[")
+      remaining.push("]");
+    else if (ch === "}" || ch === "]")
+      remaining.pop();
+  }
+  repaired += remaining.reverse().join("");
+  try {
+    JSON.parse(repaired);
+    return repaired;
+  } catch {
+    return null;
+  }
+}
+function findJsonStart(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "{" || s[i] === "[")
+      return i;
+  }
+  return -1;
+}
+function findMatchingClose(s, start, open, close) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (ch === open)
+      depth++;
+    if (ch === close) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function parseStructuredOutput(raw, schema) {
+  const jsonStr = extractJson(raw);
+  let parsed = JSON.parse(jsonStr);
+  if (Array.isArray(parsed)) {
+    parsed = inferObjectWrapper(parsed, schema);
+  }
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new CortexError(LLM_EXTRACTION_FAILED, "medium", "llm", `Schema validation failed: ${issues}`, { raw: raw.slice(0, 500), issues: result.error.issues }, "Retry with correction prompt", true);
+  }
+  return result.data;
+}
+function inferObjectWrapper(arr, schema) {
+  const def = schema._def;
+  if (def?.typeName === "ZodObject" && typeof def.shape === "function") {
+    const shape = def.shape();
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      const fieldDef = fieldSchema._def;
+      if (fieldDef?.typeName === "ZodArray") {
+        return { [key]: arr };
+      }
+    }
+  }
+  return { entities: arr };
+}
+function buildCorrectionPrompt(originalPrompt, failedOutput, error) {
+  return `${originalPrompt}
+
+Your previous response was invalid JSON or didn't match the schema.
+
+Previous response (DO NOT repeat this):
+${failedOutput.slice(0, 500)}
+
+Error: ${error}
+
+Please return ONLY valid JSON matching the required schema. No explanation.`;
+}
+
+// packages/llm/dist/router.js
+var logger6 = createLogger("llm:router");
+function resolveApiKeySource(source) {
+  if (source.startsWith("env:")) {
+    return process.env[source.slice(4)];
+  }
+  return void 0;
+}
+var Router = class {
+  cloudProvider = null;
+  localProvider = null;
+  mode;
+  taskRouting;
+  tracker;
+  cache;
+  config;
+  constructor(options) {
+    const { config: config8 } = options;
+    this.config = config8;
+    this.mode = config8.llm.mode;
+    this.taskRouting = config8.llm.taskRouting;
+    if (this.mode !== "local-only") {
+      try {
+        if (config8.llm.cloud.provider === "openai-compatible") {
+          const baseUrl = config8.llm.cloud.baseUrl;
+          if (!baseUrl) {
+            logger6.warn("openai-compatible provider requires llm.cloud.baseUrl \u2014 skipping cloud");
+          } else {
+            this.cloudProvider = new OpenAICompatibleProvider({
+              baseUrl,
+              apiKey: options.apiKey ?? resolveApiKeySource(config8.llm.cloud.apiKeySource),
+              primaryModel: config8.llm.cloud.models.primary,
+              fastModel: config8.llm.cloud.models.fast,
+              timeoutMs: config8.llm.cloud.timeoutMs,
+              maxRetries: config8.llm.cloud.maxRetries
+            });
+          }
+        } else {
+          this.cloudProvider = new AnthropicProvider({
+            apiKey: options.apiKey,
+            primaryModel: config8.llm.cloud.models.primary,
+            fastModel: config8.llm.cloud.models.fast,
+            timeoutMs: config8.llm.cloud.timeoutMs,
+            maxRetries: config8.llm.cloud.maxRetries,
+            promptCaching: config8.llm.cloud.promptCaching
+          });
+        }
+      } catch (err) {
+        if (this.mode === "cloud-first") {
+          throw err;
+        }
+        logger6.warn("Cloud provider unavailable, falling back to local-only", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (this.mode !== "cloud-first" || !this.cloudProvider) {
+      this.localProvider = new OllamaProvider({
+        host: config8.llm.local.host,
+        model: config8.llm.local.model,
+        embeddingModel: config8.llm.local.embeddingModel,
+        numCtx: config8.llm.local.numCtx,
+        numGpu: config8.llm.local.numGpu,
+        timeoutMs: config8.llm.local.timeoutMs,
+        keepAlive: config8.llm.local.keepAlive
+      });
+    }
+    this.tracker = new TokenTracker(config8.llm.budget.monthlyLimitUsd, config8.llm.budget.warningThresholds);
+    this.cache = new ResponseCache({
+      enabled: config8.llm.cache.enabled,
+      ttlMs: config8.llm.cache.ttlDays * 24 * 60 * 60 * 1e3
+    });
+    logger6.info("Router initialized", {
+      mode: this.mode,
+      hasCloud: !!this.cloudProvider,
+      hasLocal: !!this.localProvider
+    });
+  }
+  /**
+   * Select provider based on mode, task routing, and availability
+   */
+  async selectProvider(task, forceProvider) {
+    const cloudName = () => this.cloudProvider?.name ?? "anthropic";
+    if (forceProvider === "cloud") {
+      if (!this.cloudProvider) {
+        throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "Cloud provider requested but not available.", { mode: this.mode }, "Set your cloud API key or change LLM mode.", false);
+      }
+      return { provider: this.cloudProvider, name: cloudName() };
+    }
+    if (forceProvider === "local") {
+      if (!this.localProvider) {
+        throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "Local provider requested but not configured.", { mode: this.mode }, "Change LLM mode to include local provider.", false);
+      }
+      return { provider: this.localProvider, name: "ollama" };
+    }
+    const taskRoute = this.taskRouting[task] ?? "auto";
+    if (taskRoute === "cloud" && this.cloudProvider) {
+      return { provider: this.cloudProvider, name: cloudName() };
+    }
+    if (taskRoute === "local" && this.localProvider) {
+      return { provider: this.localProvider, name: "ollama" };
+    }
+    switch (this.mode) {
+      case "local-only":
+        if (!this.localProvider) {
+          throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "Local-only mode but Ollama provider not available.", void 0, "Ensure Ollama is running with `ollama serve`.", false);
+        }
+        return { provider: this.localProvider, name: "ollama" };
+      case "local-first":
+        if (this.localProvider && await this.localProvider.isAvailable()) {
+          return { provider: this.localProvider, name: "ollama" };
+        }
+        if (this.cloudProvider) {
+          logger6.info("Local provider unavailable, falling back to cloud");
+          return { provider: this.cloudProvider, name: cloudName() };
+        }
+        throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "No LLM provider available.", { mode: this.mode }, "Start Ollama or configure cloud API key.", false);
+      case "hybrid":
+        const cheapTasks = [
+          LLMTask.ENTITY_EXTRACTION,
+          LLMTask.CONTEXT_RANKING,
+          LLMTask.EMBEDDING_GENERATION
+        ];
+        if (cheapTasks.includes(task) && this.localProvider && await this.localProvider.isAvailable()) {
+          logger6.debug("Hybrid routing to local provider", { task });
+          return { provider: this.localProvider, name: "ollama" };
+        }
+        if (this.cloudProvider) {
+          logger6.debug("Hybrid routing to cloud provider", { task });
+          return { provider: this.cloudProvider, name: cloudName() };
+        }
+        if (this.localProvider) {
+          logger6.warn("Cloud provider unavailable in hybrid mode, falling back to local", { task });
+          return { provider: this.localProvider, name: "ollama" };
+        }
+        throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "No LLM provider available.", { mode: this.mode }, "Configure cloud API key or start Ollama.", false);
+      case "cloud-first":
+      default:
+        if (this.cloudProvider && !this.tracker.isBudgetExhausted()) {
+          return { provider: this.cloudProvider, name: cloudName() };
+        }
+        if (this.localProvider && this.config.llm.budget.enforcementAction === "fallback-local") {
+          logger6.info("Budget exhausted or cloud unavailable, falling back to local");
+          return { provider: this.localProvider, name: "ollama" };
+        }
+        if (!this.cloudProvider) {
+          throw new CortexError(LLM_PROVIDER_UNAVAILABLE, "high", "llm", "Cloud provider not available.", { mode: this.mode }, "Set your cloud API key or change LLM mode.", false);
+        }
+        throw new CortexError(LLM_BUDGET_EXHAUSTED, "high", "llm", "Monthly budget exhausted.", { spent: this.tracker.getCurrentMonthSpend() }, "Increase budget, wait for next month, or enable local fallback.", false, 402);
+    }
+  }
+  // Keep legacy provider getter for backward compatibility
+  get provider() {
+    return this.cloudProvider ?? this.localProvider;
+  }
+  async complete(request) {
+    const { provider, name: providerName } = await this.selectProvider(request.task, request.forceProvider);
+    if (request.contentHash) {
+      const cached = this.cache.get(request.contentHash, request.promptId, request.promptVersion);
+      if (cached) {
+        return {
+          content: cached.response,
+          model: cached.model,
+          inputTokens: cached.inputTokens,
+          outputTokens: cached.outputTokens,
+          cached: true,
+          latencyMs: 0,
+          costUsd: 0,
+          provider: providerName
+        };
+      }
+    }
+    const requestId = crypto.randomUUID();
+    eventBus.emit({
+      type: "llm.request.start",
+      payload: { requestId, task: request.task, provider: providerName },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "llm:router"
+    });
+    const startMs = performance.now();
+    const result = await provider.completeWithSystem(request.systemPrompt, request.userPrompt, {
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    }, request.modelPreference ?? "primary");
+    const latencyMs = Math.round(performance.now() - startMs);
+    const usageRecord = this.tracker.record(requestId, request.task, providerName, result.model, result.inputTokens, result.outputTokens, latencyMs);
+    if (request.contentHash) {
+      this.cache.set(request.contentHash, request.promptId, request.promptVersion, result.content, result.model, result.inputTokens, result.outputTokens);
+    }
+    eventBus.emit({
+      type: "llm.request.complete",
+      payload: {
+        requestId,
+        task: request.task,
+        provider: providerName,
+        model: result.model,
+        usage: {
+          inputTokens: result.inputTokens,
+          outputTokens: result.outputTokens,
+          estimatedCostUsd: usageRecord.estimatedCostUsd
+        },
+        latencyMs
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "llm:router"
+    });
+    return {
+      content: result.content,
+      model: result.model,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      cached: false,
+      latencyMs,
+      costUsd: usageRecord.estimatedCostUsd,
+      provider: providerName
+    };
+  }
+  async completeStructured(request, schema) {
+    const result = await this.complete(request);
+    try {
+      const data = parseStructuredOutput(result.content, schema);
+      if (this.mode === "local-first" && result.provider === "ollama" && this.cloudProvider && !request.forceProvider) {
+        const entities = data.entities;
+        if (Array.isArray(entities) && entities.length > 0) {
+          const confidences = entities.map((e) => typeof e.confidence === "number" ? e.confidence : null).filter((c) => c !== null).sort((a, b) => a - b);
+          if (confidences.length > 0) {
+            const mid = Math.floor(confidences.length / 2);
+            const median = confidences.length % 2 !== 0 ? confidences[mid] : (confidences[mid - 1] + confidences[mid]) / 2;
+            if (median < 0.6) {
+              logger6.info("Local confidence below threshold, escalating to cloud", {
+                median: Math.round(median * 100) / 100,
+                task: request.task
+              });
+              const cloudResult = await this.complete({ ...request, forceProvider: "cloud", contentHash: void 0 });
+              const cloudData = parseStructuredOutput(cloudResult.content, schema);
+              return { ...cloudResult, data: cloudData };
+            }
+          }
+        }
+      }
+      return { ...result, data };
+    } catch (firstErr) {
+      logger6.warn("Structured output parse failed, retrying with correction", {
+        promptId: request.promptId,
+        error: firstErr instanceof Error ? firstErr.message : String(firstErr)
+      });
+      const correctedPrompt = buildCorrectionPrompt(request.userPrompt, result.content, firstErr instanceof Error ? firstErr.message : String(firstErr));
+      const retryResult = await this.complete({
+        ...request,
+        userPrompt: correctedPrompt,
+        contentHash: void 0
+        // Don't cache correction attempts
+      });
+      const data = parseStructuredOutput(retryResult.content, schema);
+      return { ...retryResult, data };
+    }
+  }
+  async *stream(request) {
+    const { provider, name: providerName } = await this.selectProvider(request.task, request.forceProvider);
+    const requestId = crypto.randomUUID();
+    eventBus.emit({
+      type: "llm.request.start",
+      payload: { requestId, task: request.task, provider: providerName },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "llm:router"
+    });
+    const startMs = performance.now();
+    let fullContent = "";
+    const gen = provider.streamWithSystem(request.systemPrompt, request.userPrompt, {
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    }, request.modelPreference ?? "primary");
+    let streamResult;
+    while (true) {
+      const { value, done } = await gen.next();
+      if (done) {
+        streamResult = value;
+        break;
+      }
+      fullContent += value;
+      yield value;
+    }
+    const latencyMs = Math.round(performance.now() - startMs);
+    const tokens = streamResult ?? { inputTokens: 0, outputTokens: 0, model: provider.getModel() };
+    const usageRecord = this.tracker.record(requestId, request.task, providerName, tokens.model, tokens.inputTokens, tokens.outputTokens, latencyMs);
+    eventBus.emit({
+      type: "llm.request.complete",
+      payload: {
+        requestId,
+        task: request.task,
+        provider: providerName,
+        model: tokens.model,
+        usage: {
+          inputTokens: tokens.inputTokens,
+          outputTokens: tokens.outputTokens,
+          estimatedCostUsd: usageRecord.estimatedCostUsd
+        },
+        latencyMs
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "llm:router"
+    });
+    return {
+      content: fullContent,
+      model: tokens.model,
+      inputTokens: tokens.inputTokens,
+      outputTokens: tokens.outputTokens,
+      cached: false,
+      latencyMs,
+      costUsd: usageRecord.estimatedCostUsd,
+      provider: providerName
+    };
+  }
+  getTracker() {
+    return this.tracker;
+  }
+  getCache() {
+    return this.cache;
+  }
+  getLocalProvider() {
+    return this.localProvider;
+  }
+  getCloudProvider() {
+    return this.cloudProvider;
+  }
+  getMode() {
+    return this.mode;
+  }
+  async isAvailable() {
+    switch (this.mode) {
+      case "local-only":
+        return this.localProvider?.isAvailable() ?? false;
+      case "cloud-first":
+        return this.cloudProvider?.isAvailable() ?? false;
+      default:
+        const localAvailable = await this.localProvider?.isAvailable() ?? false;
+        const cloudAvailable = await this.cloudProvider?.isAvailable() ?? false;
+        return localAvailable || cloudAvailable;
+    }
+  }
+};
+
+// packages/llm/dist/prompts/entity-extraction.js
+import { z as z3 } from "zod";
+var VALID_TYPES = [
+  "Decision",
+  "Requirement",
+  "Pattern",
+  "Component",
+  "Dependency",
+  "Interface",
+  "Constraint",
+  "ActionItem",
+  "Risk",
+  "Note"
+];
+function coerceEntityType(val) {
+  if (VALID_TYPES.includes(val)) {
+    return val;
+  }
+  if (/rule|lint|option|setting|config/i.test(val))
+    return "Constraint";
+  if (/action|task|todo/i.test(val))
+    return "ActionItem";
+  if (/component|module|class|service/i.test(val))
+    return "Component";
+  if (/depend|import|library|package/i.test(val))
+    return "Dependency";
+  if (/require|must|shall|need/i.test(val))
+    return "Requirement";
+  return "Note";
+}
+var outputSchema = z3.object({
+  entities: z3.array(z3.object({
+    type: z3.enum(VALID_TYPES).catch((ctx) => coerceEntityType(String(ctx.input))),
+    name: z3.string().min(3).max(100),
+    content: z3.string().min(10),
+    summary: z3.string().max(300),
+    confidence: z3.number().min(0).max(1),
+    tags: z3.array(z3.string()),
+    properties: z3.record(z3.unknown())
+  }))
+});
+var config = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.1,
+  maxTokens: 8192,
+  task: LLMTask.ENTITY_EXTRACTION
+};
+
+// packages/llm/dist/prompts/relationship-inference.js
+import { z as z4 } from "zod";
+var outputSchema2 = z4.object({
+  relationships: z4.array(z4.object({
+    type: z4.enum([
+      "depends_on",
+      "implements",
+      "contradicts",
+      "evolved_from",
+      "relates_to",
+      "uses",
+      "constrains",
+      "resolves",
+      "documents",
+      "derived_from"
+    ]),
+    sourceEntityId: z4.string(),
+    targetEntityId: z4.string(),
+    description: z4.string(),
+    confidence: z4.number().min(0).max(1)
+  }))
+});
+var config2 = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.1,
+  maxTokens: 8192,
+  task: LLMTask.RELATIONSHIP_INFERENCE
+};
+
+// packages/llm/dist/prompts/merge-detection.js
+import { z as z5 } from "zod";
+var outputSchema3 = z5.object({
+  shouldMerge: z5.boolean(),
+  confidence: z5.number().min(0).max(1),
+  reason: z5.string()
+});
+var config3 = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.1,
+  maxTokens: 500,
+  task: LLMTask.ENTITY_EXTRACTION
+};
+
+// packages/llm/dist/prompts/contradiction-detection.js
+import { z as z6 } from "zod";
+var outputSchema4 = z6.object({
+  isContradiction: z6.boolean(),
+  severity: z6.enum(["low", "medium", "high"]),
+  description: z6.string(),
+  suggestedResolution: z6.string()
+});
+var config4 = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.1,
+  maxTokens: 1e3,
+  task: LLMTask.CONTRADICTION_DETECTION
+};
+
+// packages/llm/dist/prompts/conversational-query.js
+var conversational_query_exports = {};
+__export(conversational_query_exports, {
+  PROMPT_ID: () => PROMPT_ID,
+  PROMPT_VERSION: () => PROMPT_VERSION,
+  buildUserPrompt: () => buildUserPrompt,
+  config: () => config5,
+  systemPrompt: () => systemPrompt
+});
+var PROMPT_ID = "conversational_query";
+var PROMPT_VERSION = "1.0.0";
+var systemPrompt = `You are Cortex, a knowledge assistant. Answer questions using the provided context from the user's knowledge graph.
+Be concise and specific. Refer to decisions, patterns, and components by name.
+Mention the source file when citing a fact. If the context lacks enough information, say so briefly.`;
+function buildUserPrompt(vars) {
+  const parts = [];
+  if (vars.graphSummary) {
+    parts.push(`Graph stats:
+${vars.graphSummary}`);
+  }
+  if (vars.contextEntities.length > 0) {
+    const context = vars.contextEntities.map((e) => {
+      const file = e.sourceFile.replace(/\\/g, "/").split("/").pop() ?? e.sourceFile;
+      const rels = e.relationships.length > 0 ? `
+  Relations: ${e.relationships.map((r) => r.type).join(", ")}` : "";
+      return `[${e.type}] ${e.name}
+  ${e.content}
+  (${file})${rels}`;
+    }).join("\n\n");
+    parts.push(`Relevant entities:
+${context}`);
+  }
+  return `${parts.join("\n\n")}
+
+Question: ${vars.userQuery}`;
+}
+var config5 = {
+  provider: "cloud",
+  model: "primary",
+  temperature: 0.7,
+  maxTokens: 600,
+  task: LLMTask.CONVERSATIONAL_QUERY,
+  stream: true
+};
+
+// packages/llm/dist/prompts/context-ranking.js
+import { z as z7 } from "zod";
+var outputSchema5 = z7.object({
+  rankedIds: z7.array(z7.string()),
+  excludeIds: z7.array(z7.string())
+});
+var config6 = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.1,
+  maxTokens: 500,
+  task: LLMTask.CONTEXT_RANKING
+};
+
+// packages/llm/dist/prompts/follow-up-generation.js
+import { z as z8 } from "zod";
+var outputSchema6 = z8.object({
+  followUps: z8.array(z8.string()).min(1).max(5)
+});
+var config7 = {
+  provider: "cloud",
+  model: "fast",
+  temperature: 0.8,
+  maxTokens: 300,
+  task: LLMTask.CONVERSATIONAL_QUERY
+};
+
+// packages/graph/dist/sqlite-store.js
+import Database from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { copyFileSync, statSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { homedir as homedir3 } from "node:os";
+
+// packages/graph/dist/migrations/001-initial.js
+var MIGRATION_VERSION = 1;
+function up(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      root_path TEXT NOT NULL UNIQUE,
+      privacy_level TEXT NOT NULL DEFAULT 'standard',
+      file_count INTEGER DEFAULT 0,
+      entity_count INTEGER DEFAULT 0,
+      last_ingested_at TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      content TEXT NOT NULL,
+      summary TEXT,
+      properties TEXT,
+      confidence REAL NOT NULL,
+      source_file TEXT NOT NULL,
+      source_start_line INTEGER,
+      source_end_line INTEGER,
+      project_id TEXT NOT NULL,
+      extracted_by TEXT NOT NULL,
+      tags TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      deleted_at TEXT,
+      FOREIGN KEY (project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationships (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      source_entity_id TEXT NOT NULL,
+      target_entity_id TEXT NOT NULL,
+      description TEXT,
+      confidence REAL NOT NULL,
+      properties TEXT,
+      extracted_by TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (source_entity_id) REFERENCES entities(id),
+      FOREIGN KEY (target_entity_id) REFERENCES entities(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS files (
+      id TEXT PRIMARY KEY,
+      path TEXT NOT NULL UNIQUE,
+      relative_path TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      file_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      last_modified TEXT NOT NULL,
+      last_ingested_at TEXT,
+      entity_ids TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      parse_error TEXT,
+      FOREIGN KEY (project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS contradictions (
+      id TEXT PRIMARY KEY,
+      entity_id_a TEXT NOT NULL,
+      entity_id_b TEXT NOT NULL,
+      description TEXT NOT NULL,
+      severity TEXT NOT NULL,
+      suggested_resolution TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      resolved_action TEXT,
+      resolved_at TEXT,
+      detected_at TEXT NOT NULL,
+      FOREIGN KEY (entity_id_a) REFERENCES entities(id),
+      FOREIGN KEY (entity_id_b) REFERENCES entities(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id TEXT PRIMARY KEY,
+      request_id TEXT NOT NULL,
+      task TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL,
+      output_tokens INTEGER NOT NULL,
+      estimated_cost_usd REAL NOT NULL,
+      latency_ms INTEGER NOT NULL,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS dead_letter_queue (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      error_code TEXT NOT NULL,
+      error_message TEXT NOT NULL,
+      retry_count INTEGER NOT NULL DEFAULT 0,
+      first_failed_at TEXT NOT NULL,
+      last_failed_at TEXT NOT NULL,
+      next_retry_at TEXT,
+      status TEXT NOT NULL DEFAULT 'pending'
+    );
+
+    -- Full-text search
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(name, content, summary, tags);
+
+    -- Indexes
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_entities_project ON entities(project_id);
+    CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status);
+    CREATE INDEX IF NOT EXISTS idx_entities_source ON entities(source_file);
+    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_type ON relationships(type);
+    CREATE INDEX IF NOT EXISTS idx_files_project ON files(project_id);
+    CREATE INDEX IF NOT EXISTS idx_files_status ON files(status);
+    CREATE INDEX IF NOT EXISTS idx_files_hash ON files(content_hash);
+    CREATE INDEX IF NOT EXISTS idx_token_usage_month ON token_usage(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_dlq_status ON dead_letter_queue(status);
+
+    -- Schema version tracking
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+
+    INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (${MIGRATION_VERSION}, datetime('now'));
+  `);
+}
+
+// packages/graph/dist/sqlite-store.js
+function resolveHomePath(p) {
+  return p.startsWith("~") ? p.replace("~", homedir3()) : p;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function rowToContradiction(row) {
+  return {
+    id: row.id,
+    entityIds: [row.entity_id_a, row.entity_id_b],
+    description: row.description,
+    severity: row.severity,
+    suggestedResolution: row.suggested_resolution ?? void 0,
+    status: row.status,
+    resolvedAction: row.resolved_action ?? void 0,
+    resolvedAt: row.resolved_at ?? void 0,
+    detectedAt: row.detected_at
+  };
+}
+function rowToEntity(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    name: row.name,
+    content: row.content,
+    summary: row.summary ?? void 0,
+    properties: row.properties ? JSON.parse(row.properties) : {},
+    confidence: row.confidence,
+    sourceFile: row.source_file,
+    sourceRange: row.source_start_line != null && row.source_end_line != null ? { startLine: row.source_start_line, endLine: row.source_end_line } : void 0,
+    projectId: row.project_id,
+    extractedBy: JSON.parse(row.extracted_by),
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToRelationship(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    sourceEntityId: row.source_entity_id,
+    targetEntityId: row.target_entity_id,
+    description: row.description ?? void 0,
+    confidence: row.confidence,
+    properties: row.properties ? JSON.parse(row.properties) : {},
+    extractedBy: JSON.parse(row.extracted_by),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToFile(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    relativePath: row.relative_path,
+    projectId: row.project_id,
+    contentHash: row.content_hash,
+    fileType: row.file_type,
+    sizeBytes: row.size_bytes,
+    lastModified: row.last_modified,
+    lastIngestedAt: row.last_ingested_at ?? void 0,
+    entityIds: row.entity_ids ? JSON.parse(row.entity_ids) : [],
+    status: row.status,
+    parseError: row.parse_error ?? void 0
+  };
+}
+function rowToProject(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    rootPath: row.root_path,
+    privacyLevel: row.privacy_level,
+    fileCount: row.file_count,
+    entityCount: row.entity_count,
+    lastIngestedAt: row.last_ingested_at ?? void 0,
+    createdAt: row.created_at
+  };
+}
+var SQLiteStore = class {
+  db;
+  dbPath;
+  constructor(options = {}) {
+    const { dbPath = "~/.cortex/cortex.db", walMode = true, backupOnStartup = true } = options;
+    this.dbPath = resolveHomePath(dbPath);
+    mkdirSync(dirname(this.dbPath), { recursive: true });
+    if (backupOnStartup) {
+      this.backupSync();
+    }
+    this.db = new Database(this.dbPath);
+    if (walMode) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("busy_timeout = 5000");
+    this.migrate();
+  }
+  migrate() {
+    try {
+      up(this.db);
+    } catch (err) {
+      throw new CortexError(GRAPH_DB_ERROR, "critical", "graph", `Migration failed: ${err instanceof Error ? err.message : String(err)}`, void 0, "Delete the database and restart.");
+    }
+  }
+  backupSync() {
+    try {
+      const stat = statSync(this.dbPath);
+      if (stat.isFile()) {
+        const backupPath = `${this.dbPath}.backup`;
+        copyFileSync(this.dbPath, backupPath);
+      }
+    } catch {
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  // --- Entities ---
+  async createEntity(entity) {
+    const id = randomUUID();
+    const ts = now();
+    this.db.prepare(`
+      INSERT INTO entities (
+        id, type, name, content, summary, properties, confidence,
+        source_file, source_start_line, source_end_line,
+        project_id, extracted_by, tags, status, created_at, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?,
+        ?, ?, ?,
+        ?, ?, ?, ?, ?, ?
+      )
+    `).run(id, entity.type, entity.name, entity.content, entity.summary ?? null, JSON.stringify(entity.properties), entity.confidence, entity.sourceFile, entity.sourceRange?.startLine ?? null, entity.sourceRange?.endLine ?? null, entity.projectId, JSON.stringify(entity.extractedBy), JSON.stringify(entity.tags), entity.status, ts, ts);
+    this.db.prepare(`
+      INSERT INTO entities_fts (rowid, name, content, summary, tags)
+      VALUES (
+        (SELECT rowid FROM entities WHERE id = ?),
+        ?, ?, ?, ?
+      )
+    `).run(id, entity.name, entity.content, entity.summary ?? "", entity.tags.join(" "));
+    return { ...entity, id, createdAt: ts, updatedAt: ts };
+  }
+  async getEntity(id) {
+    const row = this.db.prepare("SELECT * FROM entities WHERE id = ? AND deleted_at IS NULL").get(id);
+    return row ? rowToEntity(row) : null;
+  }
+  async updateEntity(id, updates) {
+    const existing = await this.getEntity(id);
+    if (!existing) {
+      throw new CortexError(GRAPH_ENTITY_NOT_FOUND, "low", "graph", `Entity not found: ${id}`, { entityId: id });
+    }
+    const merged = { ...existing, ...updates, updatedAt: now() };
+    this.db.prepare(`
+      UPDATE entities SET
+        type = ?, name = ?, content = ?, summary = ?,
+        properties = ?, confidence = ?,
+        source_file = ?, source_start_line = ?, source_end_line = ?,
+        extracted_by = ?, tags = ?, status = ?, updated_at = ?
+      WHERE id = ?
+    `).run(merged.type, merged.name, merged.content, merged.summary ?? null, JSON.stringify(merged.properties), merged.confidence, merged.sourceFile, merged.sourceRange?.startLine ?? null, merged.sourceRange?.endLine ?? null, JSON.stringify(merged.extractedBy), JSON.stringify(merged.tags), merged.status, merged.updatedAt, id);
+    this.db.prepare(`
+      UPDATE entities_fts SET name = ?, content = ?, summary = ?, tags = ?
+      WHERE rowid = (SELECT rowid FROM entities WHERE id = ?)
+    `).run(merged.name, merged.content, merged.summary ?? "", merged.tags.join(" "), id);
+    return merged;
+  }
+  async deleteEntity(id, soft = true) {
+    if (soft) {
+      this.db.prepare("UPDATE entities SET deleted_at = ?, status = ? WHERE id = ?").run(now(), "deleted", id);
+    } else {
+      this.db.prepare("DELETE FROM entities_fts WHERE rowid = (SELECT rowid FROM entities WHERE id = ?)").run(id);
+      this.db.prepare("DELETE FROM entities WHERE id = ?").run(id);
+    }
+  }
+  async findEntities(query) {
+    const conditions = ["deleted_at IS NULL"];
+    const params = [];
+    if (query.type) {
+      conditions.push("type = ?");
+      params.push(query.type);
+    }
+    if (query.projectId) {
+      conditions.push("project_id = ?");
+      params.push(query.projectId);
+    }
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.since) {
+      conditions.push("created_at >= ?");
+      params.push(query.since);
+    }
+    if (query.before) {
+      conditions.push("created_at < ?");
+      params.push(query.before);
+    }
+    let sql;
+    if (query.search) {
+      sql = `
+        SELECT e.* FROM entities e
+        JOIN entities_fts fts ON fts.rowid = e.rowid
+        WHERE fts.entities_fts MATCH ? AND ${conditions.join(" AND ")}
+        ORDER BY rank
+      `;
+      params.unshift(query.search);
+    } else {
+      sql = `
+        SELECT * FROM entities
+        WHERE ${conditions.join(" AND ")}
+        ORDER BY created_at DESC
+      `;
+    }
+    if (query.limit) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    if (query.offset) {
+      sql += " OFFSET ?";
+      params.push(query.offset);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToEntity);
+  }
+  // --- Relationships ---
+  async createRelationship(rel) {
+    const id = randomUUID();
+    const ts = now();
+    this.db.prepare(`
+      INSERT INTO relationships (
+        id, type, source_entity_id, target_entity_id,
+        description, confidence, properties, extracted_by,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, rel.type, rel.sourceEntityId, rel.targetEntityId, rel.description ?? null, rel.confidence, JSON.stringify(rel.properties), JSON.stringify(rel.extractedBy), ts, ts);
+    return { ...rel, id, createdAt: ts, updatedAt: ts };
+  }
+  async getRelationship(id) {
+    const row = this.db.prepare("SELECT * FROM relationships WHERE id = ?").get(id);
+    return row ? rowToRelationship(row) : null;
+  }
+  async getRelationshipsForEntity(entityId, direction = "both") {
+    let sql;
+    let params;
+    if (direction === "out") {
+      sql = "SELECT * FROM relationships WHERE source_entity_id = ?";
+      params = [entityId];
+    } else if (direction === "in") {
+      sql = "SELECT * FROM relationships WHERE target_entity_id = ?";
+      params = [entityId];
+    } else {
+      sql = "SELECT * FROM relationships WHERE source_entity_id = ? OR target_entity_id = ?";
+      params = [entityId, entityId];
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToRelationship);
+  }
+  async deleteRelationship(id) {
+    this.db.prepare("DELETE FROM relationships WHERE id = ?").run(id);
+  }
+  deleteBySourcePath(pathPrefix) {
+    const normalized = pathPrefix.replace(/\//g, "\\");
+    const pattern = normalized.endsWith("%") ? normalized : normalized + "%";
+    return this.db.transaction(() => {
+      const relResult = this.db.prepare(`
+        DELETE FROM relationships
+        WHERE source_entity_id IN (SELECT id FROM entities WHERE source_file LIKE ?)
+           OR target_entity_id IN (SELECT id FROM entities WHERE source_file LIKE ?)
+      `).run(pattern, pattern);
+      this.db.prepare(`
+        DELETE FROM entities_fts
+        WHERE rowid IN (SELECT rowid FROM entities WHERE source_file LIKE ? AND deleted_at IS NULL)
+      `).run(pattern);
+      const entityResult = this.db.prepare("DELETE FROM entities WHERE source_file LIKE ?").run(pattern);
+      const fileResult = this.db.prepare("DELETE FROM files WHERE path LIKE ?").run(pattern);
+      return {
+        deletedEntities: entityResult.changes,
+        deletedRelationships: relResult.changes,
+        deletedFiles: fileResult.changes
+      };
+    })();
+  }
+  resetDatabase() {
+    this.db.transaction(() => {
+      this.db.prepare("DELETE FROM contradictions").run();
+      this.db.prepare("DELETE FROM relationships").run();
+      this.db.prepare("DELETE FROM entities_fts").run();
+      this.db.prepare("DELETE FROM entities").run();
+      this.db.prepare("DELETE FROM files").run();
+    })();
+  }
+  pruneSoftDeleted() {
+    return this.db.transaction(() => {
+      const relResult = this.db.prepare(`
+        DELETE FROM relationships
+        WHERE source_entity_id IN (SELECT id FROM entities WHERE deleted_at IS NOT NULL)
+           OR target_entity_id IN (SELECT id FROM entities WHERE deleted_at IS NOT NULL)
+      `).run();
+      this.db.prepare(`
+        DELETE FROM entities_fts
+        WHERE rowid IN (SELECT rowid FROM entities WHERE deleted_at IS NOT NULL)
+      `).run();
+      const entityResult = this.db.prepare("DELETE FROM entities WHERE deleted_at IS NOT NULL").run();
+      return {
+        deletedEntities: entityResult.changes,
+        deletedRelationships: relResult.changes
+      };
+    })();
+  }
+  // --- Files ---
+  async upsertFile(file) {
+    const existing = this.db.prepare("SELECT * FROM files WHERE path = ?").get(file.path);
+    if (existing) {
+      this.db.prepare(`
+        UPDATE files SET
+          relative_path = ?, project_id = ?, content_hash = ?,
+          file_type = ?, size_bytes = ?, last_modified = ?,
+          last_ingested_at = ?, entity_ids = ?, status = ?, parse_error = ?
+        WHERE path = ?
+      `).run(file.relativePath, file.projectId, file.contentHash, file.fileType, file.sizeBytes, file.lastModified, file.lastIngestedAt ?? null, JSON.stringify(file.entityIds), file.status, file.parseError ?? null, file.path);
+      return { ...file, id: existing.id };
+    }
+    const id = randomUUID();
+    this.db.prepare(`
+      INSERT INTO files (
+        id, path, relative_path, project_id, content_hash,
+        file_type, size_bytes, last_modified, last_ingested_at,
+        entity_ids, status, parse_error
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, file.path, file.relativePath, file.projectId, file.contentHash, file.fileType, file.sizeBytes, file.lastModified, file.lastIngestedAt ?? null, JSON.stringify(file.entityIds), file.status, file.parseError ?? null);
+    return { ...file, id };
+  }
+  async getFile(path) {
+    const row = this.db.prepare("SELECT * FROM files WHERE path = ?").get(path);
+    return row ? rowToFile(row) : null;
+  }
+  async getFilesByProject(projectId) {
+    const rows = this.db.prepare("SELECT * FROM files WHERE project_id = ?").all(projectId);
+    return rows.map(rowToFile);
+  }
+  // --- Projects ---
+  async createProject(project) {
+    const id = randomUUID();
+    const ts = now();
+    this.db.prepare(`
+      INSERT INTO projects (
+        id, name, root_path, privacy_level,
+        file_count, entity_count, last_ingested_at, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, project.name, project.rootPath, project.privacyLevel, project.fileCount, project.entityCount, project.lastIngestedAt ?? null, ts);
+    return { ...project, id, createdAt: ts };
+  }
+  async getProject(id) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+    return row ? rowToProject(row) : null;
+  }
+  async listProjects() {
+    const rows = this.db.prepare("SELECT * FROM projects ORDER BY created_at DESC").all();
+    return rows.map(rowToProject);
+  }
+  // --- Contradictions ---
+  async createContradiction(contradiction) {
+    const id = randomUUID();
+    this.db.prepare(`
+      INSERT INTO contradictions (
+        id, entity_id_a, entity_id_b, description, severity,
+        suggested_resolution, status, resolved_action, resolved_at, detected_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, contradiction.entityIds[0], contradiction.entityIds[1], contradiction.description, contradiction.severity, contradiction.suggestedResolution ?? null, contradiction.status, contradiction.resolvedAction ?? null, contradiction.resolvedAt ?? null, contradiction.detectedAt);
+    return { ...contradiction, id };
+  }
+  async findContradictions(query = {}) {
+    const conditions = [];
+    const params = [];
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.entityId) {
+      conditions.push("(entity_id_a = ? OR entity_id_b = ?)");
+      params.push(query.entityId, query.entityId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    let sql = `SELECT * FROM contradictions ${where} ORDER BY detected_at DESC`;
+    if (query.limit) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToContradiction);
+  }
+  async updateContradiction(id, update) {
+    this.db.prepare(`
+      UPDATE contradictions SET status = ?, resolved_action = ?, resolved_at = ? WHERE id = ?
+    `).run(update.status, update.resolvedAction ?? null, update.resolvedAt ?? null, id);
+  }
+  // --- Search ---
+  async searchEntities(text, limit = 20) {
+    const rows = this.db.prepare(`
+      SELECT e.* FROM entities e
+      JOIN entities_fts fts ON fts.rowid = e.rowid
+      WHERE fts.entities_fts MATCH ? AND e.deleted_at IS NULL
+      ORDER BY rank
+      LIMIT ?
+    `).all(text, limit);
+    return rows.map(rowToEntity);
+  }
+  async semanticSearch(_embedding, _limit = 20) {
+    return [];
+  }
+  // --- Stats ---
+  async getStats() {
+    const entityCount = this.db.prepare("SELECT COUNT(*) as count FROM entities WHERE deleted_at IS NULL AND status != 'deleted'").get().count;
+    const relationshipCount = this.db.prepare("SELECT COUNT(*) as count FROM relationships").get().count;
+    const fileCount = this.db.prepare("SELECT COUNT(*) as count FROM files").get().count;
+    const projectCount = this.db.prepare("SELECT COUNT(*) as count FROM projects").get().count;
+    const contradictionCount = this.db.prepare("SELECT COUNT(*) as count FROM contradictions WHERE status = 'active'").get().count;
+    let dbSizeBytes = 0;
+    try {
+      dbSizeBytes = statSync(this.dbPath).size;
+    } catch {
+    }
+    return {
+      entityCount,
+      relationshipCount,
+      fileCount,
+      projectCount,
+      contradictionCount,
+      dbSizeBytes,
+      vectorDbSizeBytes: 0
+      // Managed by VectorStore
+    };
+  }
+  // --- Report ---
+  getReportData() {
+    const fileRows = this.db.prepare("SELECT status, COUNT(*) as count FROM files GROUP BY status").all();
+    const fileStatus = { ingested: 0, failed: 0, skipped: 0, pending: 0 };
+    for (const row of fileRows) {
+      if (row.status in fileStatus) {
+        fileStatus[row.status] = row.count;
+      }
+    }
+    const failedFiles = this.db.prepare(`SELECT path, relative_path, parse_error FROM files
+       WHERE status = 'failed' AND parse_error IS NOT NULL
+       ORDER BY path LIMIT 50`).all().map((r) => ({ path: r.path, relativePath: r.relative_path, parseError: r.parse_error }));
+    const entityRows = this.db.prepare(`SELECT type, COUNT(*) as count, AVG(confidence) as avg_confidence
+       FROM entities WHERE deleted_at IS NULL AND status = 'active'
+       GROUP BY type ORDER BY count DESC`).all();
+    const entityBreakdown = entityRows.map((r) => ({
+      type: r.type,
+      count: r.count,
+      avgConfidence: r.avg_confidence
+    }));
+    const supersededCount = this.db.prepare("SELECT COUNT(*) as count FROM entities WHERE status = 'superseded'").get().count;
+    const relRows = this.db.prepare("SELECT type, COUNT(*) as count FROM relationships GROUP BY type ORDER BY count DESC").all();
+    const relationshipBreakdown = relRows.map((r) => ({ type: r.type, count: r.count }));
+    const contrRows = this.db.prepare("SELECT status, severity, COUNT(*) as count FROM contradictions GROUP BY status, severity").all();
+    const contradictions = {
+      active: 0,
+      resolved: 0,
+      dismissed: 0,
+      highSeverity: 0,
+      mediumSeverity: 0,
+      lowSeverity: 0
+    };
+    for (const r of contrRows) {
+      if (r.status === "active")
+        contradictions.active += r.count;
+      if (r.status === "resolved")
+        contradictions.resolved += r.count;
+      if (r.status === "dismissed")
+        contradictions.dismissed += r.count;
+      if (r.severity === "high" || r.severity === "critical")
+        contradictions.highSeverity += r.count;
+      if (r.severity === "medium")
+        contradictions.mediumSeverity += r.count;
+      if (r.severity === "low")
+        contradictions.lowSeverity += r.count;
+    }
+    const topContrRows = this.db.prepare(`SELECT c.id, c.severity, c.description, ea.name as entity_a, eb.name as entity_b
+       FROM contradictions c
+       LEFT JOIN entities ea ON c.entity_id_a = ea.id
+       LEFT JOIN entities eb ON c.entity_id_b = eb.id
+       WHERE c.status = 'active'
+       ORDER BY CASE c.severity
+         WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 ELSE 3
+       END, c.detected_at DESC
+       LIMIT 10`).all();
+    const topContradictions = topContrRows.map((r) => ({
+      id: r.id.slice(0, 8),
+      severity: r.severity,
+      description: r.description,
+      entityA: r.entity_a ?? "unknown",
+      entityB: r.entity_b ?? "unknown"
+    }));
+    const tokenRow = this.db.prepare(`SELECT
+        SUM(CAST(JSON_EXTRACT(extracted_by, '$.tokensUsed.input') AS INTEGER)) as total_input,
+        SUM(CAST(JSON_EXTRACT(extracted_by, '$.tokensUsed.output') AS INTEGER)) as total_output
+       FROM entities WHERE deleted_at IS NULL`).get();
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fileStatus,
+      failedFiles,
+      entityBreakdown,
+      supersededCount,
+      relationshipBreakdown,
+      contradictions,
+      topContradictions,
+      tokenEstimate: {
+        totalInput: tokenRow.total_input ?? 0,
+        totalOutput: tokenRow.total_output ?? 0
+      }
+    };
+  }
+  // --- Maintenance ---
+  async backup() {
+    const backupPath = `${this.dbPath}.backup-${Date.now()}`;
+    await this.db.backup(backupPath);
+    return backupPath;
+  }
+  async integrityCheck() {
+    const details = [];
+    const orphanedRels = this.db.prepare(`
+      SELECT COUNT(*) as count FROM relationships r
+      WHERE NOT EXISTS (SELECT 1 FROM entities WHERE id = r.source_entity_id)
+         OR NOT EXISTS (SELECT 1 FROM entities WHERE id = r.target_entity_id)
+    `).get().count;
+    if (orphanedRels > 0) {
+      details.push(`Found ${orphanedRels} orphaned relationships`);
+    }
+    const missingProjects = this.db.prepare(`
+      SELECT COUNT(*) as count FROM files f
+      WHERE NOT EXISTS (SELECT 1 FROM projects WHERE id = f.project_id)
+    `).get().count;
+    if (missingProjects > 0) {
+      details.push(`Found ${missingProjects} files referencing missing projects`);
+    }
+    const integrityResult = this.db.pragma("integrity_check");
+    const sqliteOk = integrityResult.length === 1 && integrityResult[0].integrity_check === "ok";
+    if (!sqliteOk) {
+      details.push("SQLite integrity check failed");
+    }
+    return {
+      ok: orphanedRels === 0 && missingProjects === 0 && sqliteOk,
+      orphanedRelationships: orphanedRels,
+      missingFiles: missingProjects,
+      details
+    };
+  }
+  // --- Graph visualization data ---
+  getGraphData(options = {}) {
+    const limit = options.limit ?? 2e3;
+    let entitySql = `SELECT id, name, type, confidence, source_file FROM entities WHERE status = 'active'`;
+    const params = [];
+    if (options.projectId) {
+      entitySql += ` AND project_id = ?`;
+      params.push(options.projectId);
+    }
+    entitySql += ` ORDER BY confidence DESC LIMIT ?`;
+    params.push(limit);
+    const entityRows = this.db.prepare(entitySql).all(...params);
+    const entityIds = new Set(entityRows.map((e) => e.id));
+    const relRows = this.db.prepare(`SELECT id, type, source_entity_id, target_entity_id, confidence
+       FROM relationships
+       LIMIT ?`).all(limit * 2);
+    const edges = relRows.filter((r) => entityIds.has(r.source_entity_id) && entityIds.has(r.target_entity_id)).map((r) => ({
+      id: r.id,
+      source: r.source_entity_id,
+      target: r.target_entity_id,
+      type: r.type,
+      confidence: r.confidence
+    }));
+    return {
+      nodes: entityRows.map((e) => ({
+        id: e.id,
+        name: e.name,
+        type: e.type,
+        confidence: e.confidence,
+        sourceFile: e.source_file
+      })),
+      edges
+    };
+  }
+};
+
+// packages/graph/dist/vector-store.js
+import { connect } from "@lancedb/lancedb";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+var logger7 = createLogger("graph:vector-store");
+function resolveHomePath2(p) {
+  return p.startsWith("~") ? p.replace("~", homedir4()) : p;
+}
+var TABLE_NAME = "entity_embeddings";
+var VectorStore = class {
+  db = null;
+  table = null;
+  dbPath;
+  dimensions;
+  constructor(options = {}) {
+    this.dbPath = resolveHomePath2(options.dbPath ?? "~/.cortex/vector.lance");
+    this.dimensions = options.dimensions ?? 384;
+  }
+  async initialize() {
+    mkdirSync2(this.dbPath, { recursive: true });
+    this.db = await connect(this.dbPath);
+    try {
+      this.table = await this.db.openTable(TABLE_NAME);
+    } catch {
+      logger7.debug("Vector table does not exist yet, will create on first add");
+    }
+  }
+  async ensureTable() {
+    if (this.table)
+      return this.table;
+    if (!this.db)
+      throw new Error("VectorStore not initialized");
+    this.table = await this.db.createTable(TABLE_NAME, [
+      {
+        id: "_init",
+        entityId: "_init",
+        vector: new Array(this.dimensions).fill(0),
+        text: ""
+      }
+    ]);
+    await this.table.delete('id = "_init"');
+    return this.table;
+  }
+  async addVectors(records) {
+    if (records.length === 0)
+      return;
+    const table = await this.ensureTable();
+    const rows = records.map((r) => ({
+      id: r.entityId,
+      entityId: r.entityId,
+      vector: Array.from(r.vector),
+      text: r.text
+    }));
+    await table.add(rows);
+    logger7.debug(`Added ${rows.length} vectors`);
+  }
+  async search(queryVector, limit = 20) {
+    if (!this.table)
+      return [];
+    const results = await this.table.search(Array.from(queryVector)).limit(limit).toArray();
+    return results.map((r) => ({
+      entityId: r.entityId,
+      distance: r._distance,
+      text: r.text
+    }));
+  }
+  async deleteByEntityId(entityId) {
+    if (!this.table)
+      return;
+    await this.table.delete(`entityId = "${entityId}"`);
+  }
+  async count() {
+    if (!this.table)
+      return 0;
+    return await this.table.countRows();
+  }
+};
+
+// packages/graph/dist/query-engine.js
+var logger8 = createLogger("graph:query-engine");
+var AVG_CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / AVG_CHARS_PER_TOKEN);
+}
+var QueryEngine = class {
+  sqliteStore;
+  vectorStore;
+  maxContextTokens;
+  maxResultEntities;
+  ftsWeight;
+  vectorWeight;
+  constructor(sqliteStore, vectorStore, options = {}) {
+    this.sqliteStore = sqliteStore;
+    this.vectorStore = vectorStore;
+    this.maxContextTokens = options.maxContextTokens ?? 5e4;
+    this.maxResultEntities = options.maxResultEntities ?? 30;
+    this.ftsWeight = options.ftsWeight ?? 0.4;
+    this.vectorWeight = options.vectorWeight ?? 0.6;
+  }
+  async assembleContext(query, queryEmbedding, projectId) {
+    const [ftsResults, vectorResults] = await Promise.all([
+      this.ftsSearch(query, projectId),
+      queryEmbedding ? this.vectorStore.search(queryEmbedding, 30) : Promise.resolve([])
+    ]);
+    const rankedEntities = this.mergeAndRank(ftsResults, vectorResults);
+    const contextEntities = [];
+    let totalTokens = 0;
+    const budgetForEntities = Math.floor(this.maxContextTokens * 0.7);
+    for (const entity of rankedEntities) {
+      if (contextEntities.length >= this.maxResultEntities)
+        break;
+      const entityTokens = estimateTokens(entity.content) + estimateTokens(entity.name);
+      if (totalTokens + entityTokens > budgetForEntities)
+        break;
+      contextEntities.push(entity);
+      totalTokens += entityTokens;
+    }
+    const entityIds = new Set(contextEntities.map((e) => e.id));
+    const relationships = [];
+    for (const entity of contextEntities) {
+      const rels = await this.sqliteStore.getRelationshipsForEntity(entity.id);
+      for (const rel of rels) {
+        if (entityIds.has(rel.sourceEntityId) && entityIds.has(rel.targetEntityId)) {
+          relationships.push(rel);
+        }
+      }
+    }
+    const uniqueRels = [...new Map(relationships.map((r) => [r.id, r])).values()];
+    const relTokens = uniqueRels.reduce((sum, r) => sum + estimateTokens(r.description ?? "") + 20, 0);
+    logger8.debug("Context assembled", {
+      entities: contextEntities.length,
+      relationships: uniqueRels.length,
+      totalTokensEstimate: totalTokens + relTokens
+    });
+    return {
+      entities: contextEntities,
+      relationships: uniqueRels,
+      totalTokensEstimate: totalTokens + relTokens
+    };
+  }
+  /**
+   * Converts a natural language query to an FTS5-safe keyword query.
+   * FTS5 uses AND semantics by default, so "what is the architecture" would
+   * require ALL words to match. We strip stop words and use OR semantics so
+   * entities matching ANY meaningful keyword are returned.
+   */
+  buildFtsQuery(query) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "and",
+      "or",
+      "but",
+      "in",
+      "on",
+      "at",
+      "to",
+      "for",
+      "of",
+      "with",
+      "by",
+      "from",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "need",
+      "must",
+      "what",
+      "which",
+      "who",
+      "how",
+      "why",
+      "when",
+      "where",
+      "that",
+      "this",
+      "these",
+      "those",
+      "it",
+      "its",
+      "me",
+      "my",
+      "you",
+      "your",
+      "we",
+      "our",
+      "they",
+      "their",
+      "he",
+      "she",
+      "i",
+      "all",
+      "any",
+      "each",
+      "some",
+      "no",
+      "not",
+      "so",
+      "yet",
+      "use",
+      "used",
+      "using",
+      "about",
+      "tell",
+      "know",
+      "get",
+      "got",
+      "make",
+      "made",
+      "see",
+      "give",
+      "go",
+      "come",
+      "take"
+    ]);
+    const keywords = query.replace(/[^a-zA-Z0-9\s]/g, " ").toLowerCase().split(/\s+/).filter((w) => w.length >= 3 && !stopWords.has(w));
+    if (keywords.length === 0) {
+      return query.replace(/[^a-zA-Z0-9\s]/g, " ").trim();
+    }
+    return keywords.join(" OR ");
+  }
+  async ftsSearch(query, projectId) {
+    const ftsQuery = this.buildFtsQuery(query);
+    try {
+      if (projectId) {
+        return await this.sqliteStore.findEntities({
+          search: ftsQuery,
+          projectId,
+          limit: 30
+        });
+      }
+      return await this.sqliteStore.searchEntities(ftsQuery, 30);
+    } catch (err) {
+      logger8.warn("FTS search failed, returning empty results", {
+        error: err instanceof Error ? err.message : String(err),
+        query: ftsQuery
+      });
+      return [];
+    }
+  }
+  mergeAndRank(ftsResults, vectorResults) {
+    const scores = /* @__PURE__ */ new Map();
+    for (let i = 0; i < ftsResults.length; i++) {
+      const entity = ftsResults[i];
+      const positionScore = 1 - i / Math.max(ftsResults.length, 1);
+      scores.set(entity.id, {
+        entity,
+        score: positionScore * this.ftsWeight
+      });
+    }
+    if (vectorResults.length > 0) {
+      const maxDist = Math.max(...vectorResults.map((r) => r.distance), 1);
+      for (const vr of vectorResults) {
+        const distScore = 1 - vr.distance / maxDist;
+        const existing = scores.get(vr.entityId);
+        if (existing) {
+          existing.score += distScore * this.vectorWeight;
+        }
+      }
+    }
+    return [...scores.values()].sort((a, b) => b.score - a.score).map((s) => s.entity);
+  }
+};
+
+// packages/mcp/dist/store-factory.js
+async function createStoreBundle(configDir) {
+  const config8 = loadConfig({ configDir });
+  const store = new SQLiteStore({
+    dbPath: config8.graph.dbPath,
+    walMode: config8.graph.walMode,
+    backupOnStartup: false
+    // never backup on MCP startup — adds latency, not needed
+  });
+  const vectorStore = new VectorStore({
+    dbPath: config8.graph.vectorDbPath
+  });
+  await vectorStore.initialize();
+  const queryEngine = new QueryEngine(store, vectorStore, {
+    maxContextTokens: config8.llm.maxContextTokens,
+    maxResultEntities: 10
+    // keep LLM context small for fast MCP responses
+  });
+  return {
+    store,
+    queryEngine,
+    cleanup: () => store.close()
+  };
+}
+
+// packages/mcp/dist/server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z9 } from "zod";
+
+// packages/mcp/dist/tools/query.js
+async function handleQueryCortex(input, queryEngine, router, store) {
+  const [context, graphStats, projects] = await Promise.all([
+    queryEngine.assembleContext(input.question, void 0, input.projectId),
+    store.getStats(),
+    store.listProjects()
+  ]);
+  const graphSummary = [
+    `${graphStats.entityCount} entities, ${graphStats.relationshipCount} relationships, ${graphStats.fileCount} files indexed`,
+    projects.length > 0 ? `Projects: ${projects.map((p) => `${p.name} (${p.rootPath})`).join(", ")}` : "No projects configured.",
+    projects.some((p) => p.lastIngestedAt) ? `Last ingested: ${projects.map((p) => p.lastIngestedAt).filter(Boolean).sort().pop()}` : ""
+  ].filter(Boolean).join("\n");
+  if (context.entities.length === 0 && graphStats.entityCount === 0) {
+    return {
+      answer: "No entities found. Make sure `cortex watch` has been run on your project files.",
+      citations: [],
+      entityCount: 0,
+      provider: "none",
+      model: "none"
+    };
+  }
+  const contextEntities = context.entities.map((e) => ({
+    id: e.id,
+    type: e.type,
+    name: e.name,
+    content: e.content,
+    sourceFile: e.sourceFile,
+    createdAt: e.createdAt,
+    relationships: context.relationships.filter((r) => r.sourceEntityId === e.id).map((r) => ({ type: r.type, targetEntityId: r.targetEntityId }))
+  }));
+  const result = await router.complete({
+    systemPrompt: conversational_query_exports.systemPrompt,
+    userPrompt: conversational_query_exports.buildUserPrompt({
+      contextEntities,
+      userQuery: input.question,
+      graphSummary
+    }),
+    promptId: conversational_query_exports.PROMPT_ID,
+    promptVersion: conversational_query_exports.PROMPT_VERSION,
+    task: LLMTask.CONVERSATIONAL_QUERY,
+    modelPreference: conversational_query_exports.config.model,
+    temperature: conversational_query_exports.config.temperature,
+    maxTokens: conversational_query_exports.config.maxTokens
+  });
+  return {
+    answer: result.content,
+    citations: context.entities.map((e) => ({
+      entityId: e.id,
+      entityType: e.type,
+      entityName: e.name,
+      sourceFile: e.sourceFile
+    })),
+    entityCount: context.entities.length,
+    provider: result.provider,
+    model: result.model
+  };
+}
+
+// packages/mcp/dist/tools/find.js
+async function handleFindEntity(input, store) {
+  let entities = [];
+  const byId = await store.getEntity(input.name);
+  if (byId) {
+    entities = [byId];
+  } else {
+    const results = await store.searchEntities(input.name, 20);
+    entities = input.type ? results.filter((e) => e.type === input.type) : results;
+  }
+  if (entities.length === 0) {
+    return { found: false, matches: [] };
+  }
+  const matches = await Promise.all(entities.map(async (entity) => {
+    let relationships = [];
+    if (input.expand) {
+      const rels = await store.getRelationshipsForEntity(entity.id, "both");
+      relationships = await Promise.all(rels.map(async (rel) => {
+        const isOutgoing = rel.sourceEntityId === entity.id;
+        const otherId = isOutgoing ? rel.targetEntityId : rel.sourceEntityId;
+        const other = await store.getEntity(otherId);
+        return {
+          id: rel.id,
+          type: rel.type,
+          direction: isOutgoing ? "outgoing" : "incoming",
+          otherEntityId: otherId,
+          otherEntityName: other?.name,
+          description: rel.description,
+          confidence: rel.confidence
+        };
+      }));
+    }
+    return {
+      id: entity.id,
+      type: entity.type,
+      name: entity.name,
+      summary: entity.summary,
+      content: entity.content,
+      sourceFile: entity.sourceFile,
+      sourceRange: entity.sourceRange,
+      confidence: entity.confidence,
+      tags: entity.tags,
+      createdAt: entity.createdAt,
+      relationships
+    };
+  }));
+  return { found: true, matches };
+}
+
+// packages/mcp/dist/tools/projects.js
+async function handleListProjects(store) {
+  const projects = await store.listProjects();
+  return {
+    projects: projects.map((p) => ({
+      id: p.id,
+      name: p.name,
+      rootPath: p.rootPath,
+      privacyLevel: p.privacyLevel,
+      fileCount: p.fileCount,
+      entityCount: p.entityCount,
+      lastIngestedAt: p.lastIngestedAt,
+      createdAt: p.createdAt
+    })),
+    total: projects.length
+  };
+}
+
+// packages/mcp/dist/tools/status.js
+async function handleGetStatus(store) {
+  const stats = await store.getStats();
+  const ready = stats.entityCount > 0;
+  return {
+    graph: {
+      entityCount: stats.entityCount,
+      relationshipCount: stats.relationshipCount,
+      fileCount: stats.fileCount,
+      projectCount: stats.projectCount,
+      contradictionCount: stats.contradictionCount,
+      dbSizeBytes: stats.dbSizeBytes
+    },
+    ready,
+    ...!ready && { hint: "No entities yet. Run `cortex watch` in your project directory to ingest files." }
+  };
+}
+
+// packages/mcp/dist/tools/contradictions.js
+async function handleGetContradictions(input, store) {
+  const contradictions = await store.findContradictions({
+    status: input.status,
+    entityId: input.entityId,
+    limit: input.limit ?? 50
+  });
+  const enriched = await Promise.all(contradictions.map(async (c) => {
+    const [entityA, entityB] = await Promise.all([
+      store.getEntity(c.entityIds[0]).catch(() => null),
+      store.getEntity(c.entityIds[1]).catch(() => null)
+    ]);
+    return {
+      ...c,
+      entityA: entityA ? { id: entityA.id, name: entityA.name, type: entityA.type, summary: entityA.summary } : null,
+      entityB: entityB ? { id: entityB.id, name: entityB.name, type: entityB.type, summary: entityB.summary } : null
+    };
+  }));
+  return JSON.stringify({ count: enriched.length, contradictions: enriched }, null, 2);
+}
+async function handleResolveContradiction(input, store) {
+  const validActions = ["supersede", "dismiss", "keep_old", "both_valid"];
+  if (!validActions.includes(input.action)) {
+    return JSON.stringify({ error: `Invalid action. Must be one of: ${validActions.join(", ")}` });
+  }
+  const status = input.action === "dismiss" ? "dismissed" : "resolved";
+  await store.updateContradiction(input.id, {
+    status,
+    resolvedAction: input.action,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return JSON.stringify({ success: true, id: input.id, action: input.action, status });
+}
+
+// packages/mcp/dist/server.js
+function createCortexMcpServer(bundle, router) {
+  const server = new McpServer({
+    name: "cortex",
+    version: "0.1.0"
+  });
+  server.registerTool("get_status", {
+    title: "Get Cortex Status",
+    description: "Get current status of the Cortex knowledge graph: entity count, relationship count, file count, and whether the graph has data. Check this first to verify Cortex is populated."
+  }, async () => {
+    const result = await handleGetStatus(bundle.store);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  server.registerTool("list_projects", {
+    title: "List Cortex Projects",
+    description: "List all projects registered in Cortex with their file and entity counts. Use the project id to scope query_cortex to a specific project."
+  }, async () => {
+    const result = await handleListProjects(bundle.store);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  server.registerTool("find_entity", {
+    title: "Find Entity",
+    description: "Look up a specific entity by name or UUID in the Cortex knowledge graph. Returns entity details and optionally its relationships to other entities. Use this for precise lookups: decisions, patterns, components, dependencies.",
+    inputSchema: {
+      name: z9.string().describe("Entity name (fuzzy matched) or exact UUID"),
+      expand: z9.boolean().optional().describe("Include all relationships with neighbor entity names (default: false)"),
+      type: z9.string().optional().describe("Filter by entity type: Decision, Requirement, Pattern, Component, Dependency, Interface, Constraint, ActionItem, Risk, Note")
+    }
+  }, async ({ name, expand, type }) => {
+    const result = await handleFindEntity({ name, expand: expand ?? false, type }, bundle.store);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  server.registerTool("query_cortex", {
+    title: "Query Cortex Knowledge Graph",
+    description: "Answer a natural language question using the Cortex knowledge graph. Returns an LLM-generated answer with cited entities. Use this to understand decisions, architectural choices, patterns, and dependencies across watched projects.",
+    inputSchema: {
+      question: z9.string().describe("The natural language question to answer"),
+      projectId: z9.string().optional().describe("Scope context to a specific project. Get IDs from list_projects.")
+    }
+  }, async ({ question, projectId }) => {
+    const result = await handleQueryCortex({ question, projectId }, bundle.queryEngine, router, bundle.store);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  server.registerTool("get_contradictions", {
+    title: "Get Contradictions",
+    description: "List contradictions detected in the knowledge graph. Contradictions occur when two entities make conflicting claims (e.g., different tech choices for the same thing). Returns both entities with summaries so you can understand and help resolve them.",
+    inputSchema: {
+      status: z9.string().optional().describe("Filter by status: active, resolved, or dismissed (default: all)"),
+      limit: z9.number().optional().describe("Max results to return (default: 50)")
+    }
+  }, async ({ status, limit }) => {
+    const result = await handleGetContradictions({ status, limit }, bundle.store);
+    return { content: [{ type: "text", text: result }] };
+  });
+  server.registerTool("resolve_contradiction", {
+    title: "Resolve Contradiction",
+    description: "Resolve a contradiction by choosing an action: supersede (entity A replaces B), keep_old (keep B, discard A), dismiss (not a real contradiction), both_valid (both are correct in context). Get contradiction IDs from get_contradictions first.",
+    inputSchema: {
+      id: z9.string().describe("The contradiction ID to resolve"),
+      action: z9.string().describe("Resolution action: supersede, keep_old, dismiss, or both_valid")
+    }
+  }, async ({ id, action }) => {
+    const result = await handleResolveContradiction({ id, action }, bundle.store);
+    return { content: [{ type: "text", text: result }] };
+  });
+  return server;
+}
+
+// packages/mcp/dist/index.js
+if (!process.env["CORTEX_LOG_LEVEL"]) {
+  process.env["CORTEX_LOG_LEVEL"] = "error";
+}
+async function main() {
+  const configDir = process.env["CORTEX_CONFIG_DIR"];
+  const config8 = loadConfig({ configDir });
+  const bundle = await createStoreBundle(configDir);
+  const router = new Router({ config: config8 });
+  const server = createCortexMcpServer(bundle, router);
+  const transport = new StdioServerTransport();
+  process.on("SIGINT", () => {
+    bundle.cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    bundle.cleanup();
+    process.exit(0);
+  });
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(`[cortex-mcp] Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});