unforgit 0.5.1 → 0.5.4

package/dist/chunk-CKUDYQYP.js

@@ -0,0 +1,3652 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../packages/core/dist/index.js
+import OpenAI from "openai";
+import OpenAI2 from "openai";
+var DEFAULT_TTL_SECONDS_BY_TYPE = {
+  episodic: 30 * 24 * 60 * 60,
+  semantic: void 0,
+  procedural: void 0
+};
+var DEFAULT_USAGE_BOOST = {
+  enabled: true,
+  topKToRecord: 5,
+  minUsageCount: 2,
+  maxBoost: 0.15,
+  halfLifeDays: 30
+};
+var DEFAULT_MAINTENANCE = {
+  staleEpisodicDays: 30,
+  consolidationThreshold: 0.5,
+  consolidationMinGroupSize: 2,
+  consolidationMaxGroups: 5,
+  promoteRecallCount: 5,
+  pinRecallCount: 8,
+  dryRunDefault: true,
+  autoRunOnStore: true,
+  autoRunOnRecall: true,
+  debounceMs: 3e4
+};
+function resolveLifecycleConfig(config2) {
+  return {
+    ttlSecondsByType: {
+      ...DEFAULT_TTL_SECONDS_BY_TYPE,
+      ...config2?.ttlSecondsByType ?? {}
+    },
+    usageBoost: {
+      ...DEFAULT_USAGE_BOOST,
+      ...config2?.usageBoost ?? {}
+    },
+    maintenance: {
+      ...DEFAULT_MAINTENANCE,
+      ...config2?.maintenance ?? {}
+    }
+  };
+}
+function getDefaultTtlSeconds(memoryType, lifecycle) {
+  return resolveLifecycleConfig(lifecycle).ttlSecondsByType[memoryType];
+}
+function applyLifecycleDefaults(input, lifecycle) {
+  if (input.ttlSeconds !== void 0) {
+    return input;
+  }
+  const ttlSeconds = getDefaultTtlSeconds(input.memoryType, lifecycle);
+  if (ttlSeconds === void 0) {
+    return input;
+  }
+  return {
+    ...input,
+    ttlSeconds
+  };
+}
+function isExpiredTtl(createdAt, ttlSeconds, now = /* @__PURE__ */ new Date()) {
+  if (!ttlSeconds || ttlSeconds <= 0) {
+    return false;
+  }
+  return createdAt.getTime() + ttlSeconds * 1e3 <= now.getTime();
+}
+function isMemoryExpired(memory, now = /* @__PURE__ */ new Date()) {
+  if (memory.status === "deleted") {
+    return false;
+  }
+  return isExpiredTtl(memory.createdAt, memory.ttlSeconds, now);
+}
+function computeUsageBoost(usageCount, lastUsed, lifecycle, now = /* @__PURE__ */ new Date()) {
+  const { usageBoost } = resolveLifecycleConfig(lifecycle);
+  if (!usageBoost.enabled || usageCount < usageBoost.minUsageCount) {
+    return 0;
+  }
+  const effectiveCount = usageCount - usageBoost.minUsageCount + 1;
+  const usageFactor = 1 - Math.exp(-effectiveCount / usageBoost.minUsageCount);
+  const ageDays = lastUsed ? Math.max(0, (now.getTime() - lastUsed.getTime()) / (1e3 * 60 * 60 * 24)) : usageBoost.halfLifeDays;
+  const recencyFactor = Math.exp(-ageDays / usageBoost.halfLifeDays);
+  return Math.min(usageBoost.maxBoost, usageBoost.maxBoost * usageFactor * recencyFactor);
+}
+var LifecycleScheduler = class {
+  constructor(runner, options) {
+    this.runner = runner;
+    this.options = options;
+  }
+  states = /* @__PURE__ */ new Map();
+  schedule(orgId, repoId) {
+    const key = `${orgId}:${repoId}`;
+    const state = this.states.get(key) ?? {
+      running: false,
+      pending: false,
+      orgId,
+      repoId
+    };
+    state.orgId = orgId;
+    state.repoId = repoId;
+    if (state.running) {
+      state.pending = true;
+      this.states.set(key, state);
+      return;
+    }
+    if (state.timer) {
+      clearTimeout(state.timer);
+    }
+    state.timer = setTimeout(() => {
+      void this.run(key);
+    }, this.options.debounceMs);
+    this.states.set(key, state);
+  }
+  dispose() {
+    for (const state of this.states.values()) {
+      if (state.timer) {
+        clearTimeout(state.timer);
+      }
+    }
+    this.states.clear();
+  }
+  async run(key) {
+    const state = this.states.get(key);
+    if (!state) {
+      return;
+    }
+    state.timer = void 0;
+    state.running = true;
+    this.states.set(key, state);
+    try {
+      await this.runner(state.orgId, state.repoId);
+    } catch (error) {
+      this.options.onError?.(error, {
+        orgId: state.orgId,
+        repoId: state.repoId
+      });
+    } finally {
+      state.running = false;
+      if (state.pending) {
+        state.pending = false;
+        this.states.set(key, state);
+        this.schedule(state.orgId, state.repoId);
+      } else {
+        this.states.delete(key);
+      }
+    }
+  }
+};
+function recencyScore(createdAt) {
+  const ageMs = Date.now() - createdAt.getTime();
+  const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+  return Math.max(0, 1 - ageDays / 365);
+}
+function rankResults(results) {
+  return results.sort((a, b) => b.score - a.score);
+}
+function computeCompositeScore(textScore, createdAt, confidence, usageBoost = 0) {
+  const recency = recencyScore(createdAt);
+  const conf = confidence ?? 0.5;
+  return Math.min(1, textScore * 0.55 + recency * 0.15 + conf * 0.15 + usageBoost);
+}
+function computeHybridScore(ftsScore, embeddingScore, createdAt, confidence, usageBoost = 0) {
+  const recency = recencyScore(createdAt);
+  const conf = confidence ?? 0.5;
+  return Math.min(
+    1,
+    embeddingScore * 0.45 + ftsScore * 0.15 + recency * 0.125 + conf * 0.125 + usageBoost
+  );
+}
+function deduplicateResults(results) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const existing = seen.get(r.id);
+    if (!existing || r.score > existing.score) {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+function mergeAndRank(localResults, remoteResults, k) {
+  const all = [...localResults, ...remoteResults];
+  const deduped = deduplicateResults(all);
+  const ranked = rankResults(deduped);
+  return ranked.slice(0, k);
+}
+var SENSITIVE_PATTERNS = [
+  /password/i,
+  /secret/i,
+  /api[_-]?key/i,
+  /token/i,
+  /credential/i,
+  /private[_-]?key/i,
+  /-----BEGIN/
+];
+var RULE_LIKE_TAGS = /* @__PURE__ */ new Set([
+  "decision",
+  "adr",
+  "playbook",
+  "gotcha",
+  "convention",
+  "rule",
+  "standard",
+  "process",
+  "checklist"
+]);
+function containsSensitive(text) {
+  return SENSITIVE_PATTERNS.some((p) => p.test(text));
+}
+function hasRuleLikeTags(tags) {
+  return tags.some((t) => RULE_LIKE_TAGS.has(t.toLowerCase()));
+}
+function resolveVisibility(input) {
+  if (containsSensitive(input.text)) {
+    return { visibility: "private" };
+  }
+  if (input.memoryType === "episodic" && !input.sourceRefs) {
+    return { visibility: "private" };
+  }
+  const hasSource = input.sourceRefs && Object.keys(input.sourceRefs).length > 0;
+  const tags = input.tags ?? [];
+  if ((input.memoryType === "semantic" || input.memoryType === "procedural") && (hasSource || hasRuleLikeTags(tags))) {
+    return { visibility: "repo" };
+  }
+  return { visibility: "private", suggestion: "promote" };
+}
+var EMBEDDING_MODEL = "text-embedding-3-small";
+var cachedClient = null;
+function isOpenAIConfigured(apiKey) {
+  const key = apiKey ?? process.env.OPENAI_API_KEY;
+  return !!key && key !== "sk-your-api-key-here" && key.startsWith("sk-");
+}
+function getClient(apiKey) {
+  const key = apiKey ?? process.env.OPENAI_API_KEY;
+  if (!key) {
+    throw new Error(
+      "OpenAI API key not configured. Set OPENAI_API_KEY environment variable or pass apiKey option. Semantic search features are disabled. Unforgit will use FTS-only search."
+    );
+  }
+  if (!cachedClient || apiKey) {
+    cachedClient = new OpenAI({ apiKey: key });
+  }
+  return cachedClient;
+}
+async function generateEmbedding(text, config2) {
+  const client = getClient(config2?.apiKey);
+  const model = config2?.model ?? EMBEDDING_MODEL;
+  const cleanText = text.trim().slice(0, 8e3);
+  const response = await client.embeddings.create({
+    model,
+    input: cleanText
+  });
+  const data = response.data[0];
+  if (!data?.embedding) {
+    throw new Error("OpenAI returned empty embedding");
+  }
+  return {
+    embedding: data.embedding,
+    model,
+    tokensUsed: response.usage?.total_tokens ?? 0
+  };
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(
+      `Embedding dimensions mismatch: ${a.length} vs ${b.length}`
+    );
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0) return 0;
+  return dotProduct / magnitude;
+}
+function serializeEmbedding(embedding) {
+  const buffer = Buffer.alloc(embedding.length * 4);
+  for (let i = 0; i < embedding.length; i++) {
+    buffer.writeFloatLE(embedding[i], i * 4);
+  }
+  return buffer;
+}
+function deserializeEmbedding(buffer) {
+  const embedding = [];
+  const count = buffer.length / 4;
+  for (let i = 0; i < count; i++) {
+    embedding.push(buffer.readFloatLE(i * 4));
+  }
+  return embedding;
+}
+var CONSOLIDATION_PROMPT = `You are consolidating multiple related memories into a single unified memory.
+
+Source memories:
+{{MEMORIES}}
+
+Instructions:
+1. Identify the core knowledge/insight shared across these memories
+2. Merge complementary information without losing important details
+3. Remove redundancy while preserving unique facts
+4. Keep the consolidated text concise (ideally under 200 words)
+5. Maintain technical accuracy
+6. Write in the same language as the source memories
+
+Output format (JSON):
+{
+  "text": "The consolidated memory text",
+  "suggestedTags": ["tag1", "tag2"],
+  "suggestedType": "semantic" | "procedural" | "episodic"
+}
+
+Output only valid JSON, nothing else.`;
+function formatMemoriesForPrompt(memories) {
+  return memories.map(
+    (m, i) => `${i + 1}. [${m.type}] ${m.text}
+   Tags: ${m.tags.length > 0 ? m.tags.join(", ") : "none"}`
+  ).join("\n\n");
+}
+function inferMemoryType(memories) {
+  const hasProcedural = memories.some((m) => m.type === "procedural");
+  const hasSemantic = memories.some((m) => m.type === "semantic");
+  if (hasProcedural) return "procedural";
+  if (hasSemantic) return "semantic";
+  return "episodic";
+}
+function mergeTags(memories) {
+  const tagSet = /* @__PURE__ */ new Set();
+  for (const m of memories) {
+    for (const tag of m.tags) {
+      tagSet.add(tag);
+    }
+  }
+  return Array.from(tagSet);
+}
+async function generateConsolidatedText(input, options) {
+  const apiKey = options?.apiKey ?? process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "OpenAI API key not configured. Set OPENAI_API_KEY environment variable."
+    );
+  }
+  const client = new OpenAI2({ apiKey });
+  const model = options?.model ?? "gpt-5.4";
+  const memoriesText = formatMemoriesForPrompt(input.memories);
+  const prompt = CONSOLIDATION_PROMPT.replace("{{MEMORIES}}", memoriesText);
+  const response = await client.chat.completions.create({
+    model,
+    messages: [
+      {
+        role: "user",
+        content: prompt
+      }
+    ],
+    temperature: 0.3,
+    max_completion_tokens: 1e3
+  });
+  const content = response.choices[0]?.message?.content;
+  if (!content) {
+    throw new Error("OpenAI returned empty response");
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.text || typeof parsed.text !== "string") {
+      throw new Error("Invalid response: missing text field");
+    }
+    const validTypes = ["episodic", "semantic", "procedural"];
+    const suggestedType = parsed.suggestedType && validTypes.includes(parsed.suggestedType) ? parsed.suggestedType : inferMemoryType(input.memories);
+    return {
+      text: parsed.text,
+      suggestedTags: Array.isArray(parsed.suggestedTags) ? parsed.suggestedTags.filter((t) => typeof t === "string") : mergeTags(input.memories),
+      suggestedType
+    };
+  } catch (_parseError) {
+    const textMatch = content.match(/"text"\s*:\s*"([^"]+)"/);
+    if (textMatch) {
+      return {
+        text: textMatch[1],
+        suggestedTags: mergeTags(input.memories),
+        suggestedType: inferMemoryType(input.memories)
+      };
+    }
+    return {
+      text: content.trim(),
+      suggestedTags: mergeTags(input.memories),
+      suggestedType: inferMemoryType(input.memories)
+    };
+  }
+}
+function memoriesToConsolidationInput(memories) {
+  return {
+    memories: memories.map((m) => ({
+      text: m.text,
+      type: m.memoryType,
+      tags: m.tags
+    }))
+  };
+}
+var QUALITY_WEIGHTS = {
+  textQuality: 0.2,
+  recallCount: 0.25,
+  consolidationStatus: 0.1,
+  age: 0.15,
+  hasLinks: 0.1,
+  hasTags: 0.1,
+  hasEmbedding: 0.1
+};
+function computeTextQuality(text) {
+  const length = text.trim().length;
+  if (length < 20) return 0.2;
+  if (length < 50) return 0.4;
+  if (length < 100) return 0.6;
+  if (length < 300) return 0.9;
+  if (length < 500) return 1;
+  if (length < 1e3) return 0.9;
+  return 0.7;
+}
+function computeRecallScore(recallCount) {
+  if (recallCount === 0) return 0;
+  if (recallCount < 3) return 0.3;
+  if (recallCount < 10) return 0.6;
+  if (recallCount < 25) return 0.8;
+  return 1;
+}
+function computeAgeScore(daysSinceCreation, daysSinceLastRecall) {
+  if (daysSinceLastRecall !== null && daysSinceLastRecall < 7) {
+    return 1;
+  }
+  if (daysSinceCreation < 7) return 1;
+  if (daysSinceCreation < 30) return 0.9;
+  if (daysSinceCreation < 90) return 0.7;
+  if (daysSinceCreation < 180) return 0.5;
+  if (daysSinceCreation < 365) return 0.3;
+  return 0.1;
+}
+function computeConsolidationScore(memory) {
+  if (memory.isConsolidation) return 1;
+  if (memory.status === "superseded") return 0.3;
+  if (memory.status === "deprecated") return 0.1;
+  return 0.7;
+}
+function computeQualityScore(memory, stats) {
+  const factors = {
+    textQuality: computeTextQuality(memory.text),
+    recallCount: computeRecallScore(stats.recallCount),
+    consolidationStatus: computeConsolidationScore(memory),
+    age: computeAgeScore(stats.daysSinceCreation, stats.daysSinceLastRecall),
+    hasLinks: stats.linkCount > 0 ? 1 : 0.3,
+    hasTags: memory.tags.length > 0 ? 1 : 0.3,
+    hasEmbedding: stats.hasEmbedding ? 1 : 0.5
+  };
+  const overall = factors.textQuality * QUALITY_WEIGHTS.textQuality + factors.recallCount * QUALITY_WEIGHTS.recallCount + factors.consolidationStatus * QUALITY_WEIGHTS.consolidationStatus + factors.age * QUALITY_WEIGHTS.age + factors.hasLinks * QUALITY_WEIGHTS.hasLinks + factors.hasTags * QUALITY_WEIGHTS.hasTags + factors.hasEmbedding * QUALITY_WEIGHTS.hasEmbedding;
+  const suggestions = [];
+  if (factors.textQuality < 0.5) {
+    suggestions.push("Consider expanding this memory with more detail");
+  }
+  if (factors.recallCount < 0.3 && stats.daysSinceCreation > 30) {
+    suggestions.push("This memory has never been recalled - consider deprecating if no longer relevant");
+  }
+  if (factors.hasLinks < 0.5) {
+    suggestions.push("Consider linking this memory to related memories");
+  }
+  if (factors.hasTags < 0.5) {
+    suggestions.push("Add tags to improve discoverability");
+  }
+  if (!stats.hasEmbedding) {
+    suggestions.push("Generate embedding for better semantic search");
+  }
+  if (stats.daysSinceCreation > 180 && stats.daysSinceLastRecall === null) {
+    suggestions.push("Old memory with no recalls - review for deprecation");
+  }
+  return {
+    overall: Math.round(overall * 100) / 100,
+    factors,
+    suggestions
+  };
+}
+function getHealthStatus(score) {
+  if (score >= 0.7) return "healthy";
+  if (score >= 0.4) return "needs_attention";
+  return "critical";
+}
+function computeRepositoryHealth(memories) {
+  if (memories.length === 0) {
+    return {
+      overallScore: 1,
+      status: "healthy",
+      memoryCounts: { total: 0, healthy: 0, needs_attention: 0, critical: 0 },
+      topIssues: []
+    };
+  }
+  const scores = memories.map(
+    ({ memory, stats }) => computeQualityScore(memory, stats)
+  );
+  const totalScore = scores.reduce((sum, s) => sum + s.overall, 0);
+  const overallScore = Math.round(totalScore / scores.length * 100) / 100;
+  const counts = { healthy: 0, needs_attention: 0, critical: 0 };
+  for (const score of scores) {
+    const status = getHealthStatus(score.overall);
+    counts[status]++;
+  }
+  const issueCount = {};
+  for (const score of scores) {
+    for (const suggestion of score.suggestions) {
+      issueCount[suggestion] = (issueCount[suggestion] || 0) + 1;
+    }
+  }
+  const topIssues = Object.entries(issueCount).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([description, count]) => ({
+    type: categorizeIssue(description),
+    count,
+    description
+  }));
+  return {
+    overallScore,
+    status: getHealthStatus(overallScore),
+    memoryCounts: {
+      total: memories.length,
+      ...counts
+    },
+    topIssues
+  };
+}
+function categorizeIssue(description) {
+  if (description.includes("tag")) return "tagging";
+  if (description.includes("link")) return "linking";
+  if (description.includes("embedding")) return "embedding";
+  if (description.includes("deprecat") || description.includes("recall")) return "maintenance";
+  if (description.includes("detail") || description.includes("expand")) return "content";
+  return "other";
+}
+function generateSuggestions(store, orgId, repoId, options) {
+  const maxSuggestions = options?.maxSuggestions ?? 20;
+  const suggestions = [];
+  const memories = store.list({
+    orgId,
+    repoId,
+    status: ["active"],
+    limit: 500
+  });
+  const usageStats = store.getUsageStats(orgId, repoId);
+  const usageMap = new Map(usageStats.map((s) => [s.memoryId, s]));
+  const memoryData = [];
+  for (const memory of memories) {
+    const usage = usageMap.get(memory.id);
+    const links = store.getLinks({ memoryId: memory.id });
+    const hasEmbedding = store.hasEmbedding(memory.id);
+    const stats = {
+      recallCount: usage?.count ?? 0,
+      linkCount: links.length,
+      hasEmbedding,
+      daysSinceCreation: Math.floor(
+        (Date.now() - memory.createdAt.getTime()) / (1e3 * 60 * 60 * 24)
+      ),
+      daysSinceLastRecall: usage ? Math.floor(
+        (Date.now() - usage.lastUsed.getTime()) / (1e3 * 60 * 60 * 24)
+      ) : null
+    };
+    const quality = computeQualityScore(memory, stats);
+    memoryData.push({ memory, stats, quality });
+  }
+  const similarPairs = findSimilarMemoryPairs(store, memoryData, orgId, repoId);
+  for (const pair of similarPairs.slice(0, 5)) {
+    suggestions.push({
+      id: `consolidate-${pair.id1.slice(0, 8)}-${pair.id2.slice(0, 8)}`,
+      type: "consolidate",
+      priority: pair.similarity > 0.8 ? "high" : "medium",
+      memoryIds: [pair.id1, pair.id2],
+      reason: `These memories are ${Math.round(pair.similarity * 100)}% similar and could be merged`,
+      confidence: pair.similarity,
+      action: {
+        command: `unforgit merge ${pair.id1} ${pair.id2}`,
+        description: "Merge these memories into one"
+      }
+    });
+  }
+  const staleMemories = memoryData.filter(
+    ({ stats, quality }) => stats.daysSinceCreation > 90 && stats.recallCount === 0 && quality.overall < 0.5
+  );
+  for (const { memory } of staleMemories.slice(0, 5)) {
+    suggestions.push({
+      id: `deprecate-${memory.id.slice(0, 8)}`,
+      type: "deprecate",
+      priority: "medium",
+      memoryIds: [memory.id],
+      reason: "No recalls in 90+ days with low quality score",
+      confidence: 0.7,
+      action: {
+        command: `unforgit deprecate ${memory.id}`,
+        description: "Mark as deprecated"
+      }
+    });
+  }
+  const untagged = memoryData.filter(({ memory }) => memory.tags.length === 0);
+  if (untagged.length > 0) {
+    const ids = untagged.slice(0, 10).map(({ memory }) => memory.id);
+    suggestions.push({
+      id: "add-tags-batch",
+      type: "add_tags",
+      priority: "low",
+      memoryIds: ids,
+      reason: `${untagged.length} memories have no tags`,
+      confidence: 0.9,
+      action: {
+        command: "unforgit web",
+        description: "Open dashboard to add tags"
+      }
+    });
+  }
+  const unlinked = memoryData.filter(
+    ({ stats, memory }) => stats.linkCount === 0 && !memory.isConsolidation && stats.daysSinceCreation > 7
+  );
+  if (unlinked.length > 5) {
+    suggestions.push({
+      id: "add-links-batch",
+      type: "add_links",
+      priority: "low",
+      memoryIds: unlinked.slice(0, 10).map(({ memory }) => memory.id),
+      reason: `${unlinked.length} memories are isolated (no links)`,
+      confidence: 0.8,
+      action: {
+        command: "unforgit web",
+        description: "Open graph view to create links"
+      }
+    });
+  }
+  const withoutEmbedding = memoryData.filter(({ stats }) => !stats.hasEmbedding);
+  if (withoutEmbedding.length > 0) {
+    suggestions.push({
+      id: "generate-embeddings",
+      type: "generate_embedding",
+      priority: withoutEmbedding.length > 10 ? "high" : "medium",
+      memoryIds: withoutEmbedding.map(({ memory }) => memory.id),
+      reason: `${withoutEmbedding.length} memories lack embeddings for semantic search`,
+      confidence: 1,
+      action: {
+        command: "unforgit embeddings backfill",
+        description: "Generate embeddings for all memories"
+      }
+    });
+  }
+  const popularPrivate = memoryData.filter(
+    ({ memory, stats }) => memory.visibility === "private" && stats.recallCount >= 5
+  );
+  for (const { memory, stats } of popularPrivate.slice(0, 3)) {
+    suggestions.push({
+      id: `promote-${memory.id.slice(0, 8)}`,
+      type: "promote",
+      priority: "medium",
+      memoryIds: [memory.id],
+      reason: `Private memory with ${stats.recallCount} recalls - consider sharing with team`,
+      confidence: 0.75,
+      action: {
+        command: `unforgit promote ${memory.id}`,
+        description: "Promote to shared visibility"
+      }
+    });
+  }
+  const sorted = suggestions.sort((a, b) => {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
+      return priorityOrder[a.priority] - priorityOrder[b.priority];
+    }
+    return b.confidence - a.confidence;
+  }).slice(0, maxSuggestions);
+  return {
+    suggestions: sorted,
+    stats: {
+      totalMemories: memories.length,
+      memoriesAnalyzed: memoryData.length,
+      suggestionsGenerated: sorted.length
+    }
+  };
+}
+function findSimilarMemoryPairs(store, memoryData, orgId, repoId) {
+  const pairs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { memory } of memoryData.slice(0, 50)) {
+    try {
+      const similar = store.findSimilar({
+        orgId,
+        repoId,
+        memoryId: memory.id,
+        threshold: 0.6,
+        k: 3
+      });
+      for (const match of similar) {
+        const pairKey = [memory.id, match.id].sort().join("-");
+        if (seen.has(pairKey)) continue;
+        seen.add(pairKey);
+        pairs.push({
+          id1: memory.id,
+          id2: match.id,
+          similarity: match.score
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return pairs.sort((a, b) => b.similarity - a.similarity);
+}
+function persistReviewableSuggestions(store, orgId, repoId, suggestions, options = {}) {
+  const existingPending = store.listCurationSuggestions({
+    orgId,
+    repoId,
+    status: ["pending"],
+    limit: 500
+  });
+  const existingKeys = new Set(
+    existingPending.map(
+      (suggestion) => reviewableSuggestionKey(suggestion.type, suggestion.memoryIds)
+    )
+  );
+  let created = 0;
+  let skippedExisting = 0;
+  for (const suggestion of suggestions) {
+    const key = reviewableSuggestionKey(suggestion.type, suggestion.memoryIds);
+    if (existingKeys.has(key)) {
+      skippedExisting++;
+      continue;
+    }
+    store.createCurationSuggestion({
+      orgId,
+      repoId,
+      type: suggestion.type,
+      priority: suggestion.priority,
+      memoryIds: suggestion.memoryIds,
+      reason: suggestion.reason,
+      confidence: suggestion.confidence,
+      createdBy: options.createdBy,
+      payload: {
+        sourceSuggestionId: suggestion.id,
+        ...suggestion.action ? { action: suggestion.action } : {}
+      }
+    });
+    existingKeys.add(key);
+    created++;
+  }
+  return { created, skippedExisting };
+}
+function reviewableSuggestionKey(type, memoryIds) {
+  return `${type}:${[...memoryIds].sort().join(",")}`;
+}
+function formatSuggestion(suggestion) {
+  const priorityEmoji = {
+    high: "\u{1F534}",
+    medium: "\u{1F7E1}",
+    low: "\u{1F7E2}"
+  };
+  const lines = [
+    `${priorityEmoji[suggestion.priority]} [${suggestion.type}] ${suggestion.reason}`,
+    `   Confidence: ${Math.round(suggestion.confidence * 100)}%`,
+    `   Memories: ${suggestion.memoryIds.map((id) => id.slice(0, 8)).join(", ")}`
+  ];
+  if (suggestion.action) {
+    lines.push(`   Action: ${suggestion.action.command}`);
+  }
+  return lines.join("\n");
+}
+function findConsolidationCandidates(store, orgId, repoId, options = {}) {
+  const {
+    threshold = 0.4,
+    minGroupSize = 2,
+    maxGroups = 10,
+    types,
+    excludeConsolidations = true
+  } = options;
+  const memories = store.list({
+    orgId,
+    repoId,
+    status: ["active"],
+    types,
+    limit: 1e3
+  });
+  const filteredMemories = excludeConsolidations ? memories.filter((m) => !m.isConsolidation) : memories;
+  if (filteredMemories.length < 2) {
+    return {
+      candidates: [],
+      totalMemoriesScanned: filteredMemories.length,
+      totalCandidateGroups: 0
+    };
+  }
+  const similarityScores = /* @__PURE__ */ new Map();
+  const memoryMap = new Map(filteredMemories.map((m) => [m.id, m]));
+  for (const memory of filteredMemories) {
+    try {
+      const similar = store.findSimilar({
+        orgId,
+        repoId,
+        memoryId: memory.id,
+        threshold,
+        k: 10
+      });
+      for (const sim of similar) {
+        const targetMemory = memoryMap.get(sim.id);
+        if (!targetMemory) continue;
+        if (excludeConsolidations && targetMemory.isConsolidation) continue;
+        if (!similarityScores.has(memory.id)) {
+          similarityScores.set(memory.id, /* @__PURE__ */ new Map());
+        }
+        similarityScores.get(memory.id).set(sim.id, sim.score);
+      }
+    } catch {
+      continue;
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const groups = [];
+  const sortedMemories = [...filteredMemories].sort((a, b) => {
+    const aCount = similarityScores.get(a.id)?.size ?? 0;
+    const bCount = similarityScores.get(b.id)?.size ?? 0;
+    return bCount - aCount;
+  });
+  for (const seed of sortedMemories) {
+    if (used.has(seed.id)) continue;
+    const seedSimilar = similarityScores.get(seed.id);
+    if (!seedSimilar || seedSimilar.size === 0) continue;
+    const group = [seed.id];
+    let totalScore = 0;
+    let scoreCount = 0;
+    const candidates2 = Array.from(seedSimilar.entries()).filter(([id]) => !used.has(id)).sort((a, b) => b[1] - a[1]);
+    for (const [candidateId, score] of candidates2) {
+      if (group.length >= 5) break;
+      let isCompatible = true;
+      for (const memberId of group) {
+        if (memberId === seed.id) continue;
+        const memberSimilar = similarityScores.get(memberId);
+        const reverseScore = memberSimilar?.get(candidateId);
+        const candidateSimilar = similarityScores.get(candidateId);
+        const forwardScore = candidateSimilar?.get(memberId);
+        const pairScore = Math.max(reverseScore ?? 0, forwardScore ?? 0);
+        if (pairScore < threshold * 0.8) {
+          isCompatible = false;
+          break;
+        }
+      }
+      if (isCompatible) {
+        group.push(candidateId);
+        totalScore += score;
+        scoreCount++;
+      }
+    }
+    if (group.length >= minGroupSize) {
+      for (const id of group) {
+        used.add(id);
+      }
+      groups.push({
+        ids: group,
+        avgScore: scoreCount > 0 ? totalScore / scoreCount : threshold
+      });
+    }
+  }
+  const candidates = [];
+  for (const group of groups) {
+    const groupMemories = group.ids.map((id) => memoryMap.get(id)).filter((m) => m !== void 0);
+    if (groupMemories.length < minGroupSize) continue;
+    const allTags = /* @__PURE__ */ new Set();
+    for (const m of groupMemories) {
+      for (const tag of m.tags) {
+        allTags.add(tag);
+      }
+    }
+    const typeCount = {};
+    for (const m of groupMemories) {
+      typeCount[m.memoryType] = (typeCount[m.memoryType] || 0) + 1;
+    }
+    const dominantType = Object.entries(typeCount).sort(
+      (a, b) => b[1] - a[1]
+    )[0]?.[0];
+    candidates.push({
+      memories: groupMemories.sort(
+        (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+      ),
+      reason: `${groupMemories.length} similar ${dominantType ?? "mixed"} memories with avg similarity ${group.avgScore.toFixed(2)}`,
+      suggestedTags: Array.from(allTags),
+      averageScore: group.avgScore
+    });
+  }
+  candidates.sort((a, b) => {
+    if (b.memories.length !== a.memories.length) {
+      return b.memories.length - a.memories.length;
+    }
+    return b.averageScore - a.averageScore;
+  });
+  return {
+    candidates: candidates.slice(0, maxGroups),
+    totalMemoriesScanned: filteredMemories.length,
+    totalCandidateGroups: candidates.length
+  };
+}
+async function executeConsolidation(store, candidate, orgId, repoId, options = {}) {
+  const { apiKey, model, preserveOriginals = true } = options;
+  const input = memoriesToConsolidationInput(candidate.memories);
+  const llmResult = await generateConsolidatedText(input, { apiKey, model });
+  const sourceIds = candidate.memories.map((m) => m.id);
+  const result = store.consolidateMemories({
+    orgId,
+    repoId,
+    sourceIds,
+    consolidatedText: llmResult.text,
+    memoryType: llmResult.suggestedType,
+    tags: llmResult.suggestedTags,
+    preserveOriginals
+  });
+  return {
+    consolidatedId: result.consolidatedId,
+    sourceIds,
+    generatedText: llmResult.text,
+    suggestedTags: llmResult.suggestedTags,
+    memoryType: llmResult.suggestedType
+  };
+}
+function formatCandidatePreview(candidate) {
+  const lines = [];
+  lines.push(`Group: ${candidate.reason}`);
+  lines.push(`Tags: ${candidate.suggestedTags.join(", ") || "none"}`);
+  lines.push("Memories:");
+  for (const mem of candidate.memories) {
+    const preview2 = mem.text.length > 80 ? mem.text.slice(0, 80) + "..." : mem.text;
+    lines.push(`  - [${mem.memoryType}] ${mem.id.slice(0, 8)}: ${preview2}`);
+  }
+  return lines.join("\n");
+}
+var AUTO_LINK_STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "and",
+  "but",
+  "if",
+  "or",
+  "because",
+  "until",
+  "while",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its"
+]);
+function buildAutoLinkQuery(text, maxTerms = 10) {
+  const terms = text.toLowerCase().replace(/[_-]/g, " ").replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 2).filter((word) => !AUTO_LINK_STOP_WORDS.has(word)).filter((word) => word !== "or" && word !== "and");
+  const uniqueTerms = [...new Set(terms)].slice(0, maxTerms);
+  if (uniqueTerms.length === 0) {
+    return void 0;
+  }
+  return uniqueTerms.join(" ");
+}
+function getNotifications(store, orgId, repoId) {
+  const notifications = [];
+  const now = /* @__PURE__ */ new Date();
+  const syncSummary = store.getSyncSummary(orgId, repoId);
+  if (syncSummary.conflicts > 0) {
+    notifications.push({
+      id: "conflicts-pending",
+      type: "conflicts_pending",
+      priority: "high",
+      title: "Sync Conflicts",
+      message: `You have ${syncSummary.conflicts} unresolved sync conflict(s) that need attention.`,
+      action: {
+        command: "unforgit status",
+        description: "View conflicts"
+      },
+      createdAt: now
+    });
+  }
+  const embeddingStats = store.getEmbeddingStats(orgId, repoId);
+  if (embeddingStats.withoutEmbedding > 10) {
+    notifications.push({
+      id: "embeddings-missing",
+      type: "embeddings_missing",
+      priority: "medium",
+      title: "Missing Embeddings",
+      message: `${embeddingStats.withoutEmbedding} memories lack embeddings. Semantic search quality is reduced.`,
+      action: {
+        command: "unforgit embeddings backfill",
+        description: "Generate missing embeddings"
+      },
+      createdAt: now
+    });
+  }
+  const suggestions = generateSuggestions(store, orgId, repoId, { maxSuggestions: 10 });
+  const highPrioritySuggestions = suggestions.suggestions.filter(
+    (s) => s.priority === "high"
+  ).length;
+  if (highPrioritySuggestions > 0) {
+    notifications.push({
+      id: "suggestions-high-priority",
+      type: "pending_suggestions",
+      priority: "medium",
+      title: "Curation Suggestions",
+      message: `${highPrioritySuggestions} high-priority curation suggestion(s) available.`,
+      action: {
+        command: "unforgit web",
+        description: "Open curation dashboard"
+      },
+      createdAt: now
+    });
+  }
+  if (syncSummary.pendingPush > 20) {
+    notifications.push({
+      id: "sync-stale",
+      type: "sync_stale",
+      priority: "low",
+      title: "Pending Sync",
+      message: `${syncSummary.pendingPush} memories waiting to be pushed to remote.`,
+      action: {
+        command: "unforgit push",
+        description: "Push changes to remote"
+      },
+      createdAt: now
+    });
+  }
+  const unusedMemories = store.getUnusedMemories(orgId, repoId, 90);
+  if (unusedMemories.length > 10) {
+    notifications.push({
+      id: "maintenance-unused",
+      type: "maintenance_needed",
+      priority: "low",
+      title: "Maintenance Recommended",
+      message: `${unusedMemories.length} memories haven't been recalled in 90+ days. Consider reviewing or deprecating.`,
+      action: {
+        command: "unforgit web",
+        description: "Open curation dashboard"
+      },
+      createdAt: now
+    });
+  }
+  notifications.sort((a, b) => {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return priorityOrder[a.priority] - priorityOrder[b.priority];
+  });
+  const summary = {
+    total: notifications.length,
+    high: notifications.filter((n) => n.priority === "high").length,
+    medium: notifications.filter((n) => n.priority === "medium").length,
+    low: notifications.filter((n) => n.priority === "low").length
+  };
+  return { notifications, summary };
+}
+function formatNotification(notification) {
+  const priorityEmoji = {
+    high: "\u{1F534}",
+    medium: "\u{1F7E1}",
+    low: "\u{1F7E2}"
+  };
+  const lines = [
+    `${priorityEmoji[notification.priority]} ${notification.title}`,
+    `  ${notification.message}`
+  ];
+  if (notification.action) {
+    lines.push(`  \u2192 ${notification.action.command}`);
+  }
+  return lines.join("\n");
+}
+function formatNotificationsSummary(result) {
+  if (result.notifications.length === 0) {
+    return "No notifications. Everything is up to date!";
+  }
+  const parts = [
+    `${result.summary.total} notification(s):`,
+    `  High: ${result.summary.high}`,
+    `  Medium: ${result.summary.medium}`,
+    `  Low: ${result.summary.low}`,
+    "",
+    ...result.notifications.map(formatNotification)
+  ];
+  return parts.join("\n");
+}
+function preview(text) {
+  return text.length > 120 ? `${text.slice(0, 120)}...` : text;
+}
+function getExpiringCandidates(memories) {
+  return memories.filter(
+    (memory) => memory.memoryType === "episodic" && memory.status === "active" && memory.ttlSeconds !== void 0 && isMemoryExpired(memory)
+  ).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).map((memory) => ({
+    id: memory.id,
+    ttlSeconds: memory.ttlSeconds,
+    reason: `Expired after ${memory.ttlSeconds} seconds without consolidation`,
+    textPreview: preview(memory.text)
+  }));
+}
+function getStrengthenedCandidates(memories, usageStats, lifecycle) {
+  const config2 = resolveLifecycleConfig(lifecycle);
+  const usageMap = new Map(usageStats.map((stat) => [stat.memoryId, stat]));
+  return memories.filter((memory) => memory.memoryType === "episodic" && memory.status === "active").map((memory) => {
+    const usage = usageMap.get(memory.id);
+    if (!usage || usage.count < config2.maintenance.promoteRecallCount) {
+      return void 0;
+    }
+    const isPinned = memory.tags.includes("pinned");
+    const recommendedAction = usage.count >= config2.maintenance.pinRecallCount && !isPinned ? "pin" : "promote";
+    return {
+      id: memory.id,
+      usageCount: usage.count,
+      lastUsed: usage.lastUsed,
+      recommendedAction,
+      reason: recommendedAction === "pin" ? `Frequently reused episodic memory (${usage.count} recalls); consider pinning it` : `Frequently reused episodic memory (${usage.count} recalls); consider promoting it`,
+      textPreview: preview(memory.text)
+    };
+  }).filter((candidate) => candidate !== void 0).sort((a, b) => b.usageCount - a.usageCount);
+}
+async function runLocalLifecycleMaintenance(store, orgId, repoId, options = {}) {
+  const lifecycle = resolveLifecycleConfig(options.lifecycle);
+  const dryRun = options.dryRun ?? lifecycle.maintenance.dryRunDefault;
+  const activeMemories = store.list({
+    orgId,
+    repoId,
+    status: ["active"],
+    includeExpired: true,
+    limit: 1e3
+  });
+  const usageStats = store.getUsageStats(orgId, repoId);
+  const expiredCandidates = getExpiringCandidates(activeMemories);
+  const strengthenedCandidates = getStrengthenedCandidates(
+    activeMemories.filter((memory) => !isMemoryExpired(memory)),
+    usageStats,
+    lifecycle
+  );
+  const consolidationPreview = findConsolidationCandidates(store, orgId, repoId, {
+    threshold: lifecycle.maintenance.consolidationThreshold,
+    minGroupSize: lifecycle.maintenance.consolidationMinGroupSize,
+    maxGroups: lifecycle.maintenance.consolidationMaxGroups,
+    types: ["episodic"],
+    excludeConsolidations: true
+  });
+  const warnings = [];
+  const errors = [];
+  const executedConsolidations = [];
+  if (!dryRun) {
+    store.expireExpiredMemories(orgId, repoId);
+    if (consolidationPreview.candidates.length > 0) {
+      if (!isOpenAIConfigured()) {
+        warnings.push(
+          "Skipping consolidation execution because OpenAI is not configured."
+        );
+      } else {
+        for (const candidate of consolidationPreview.candidates) {
+          try {
+            const result = await executeConsolidation(store, candidate, orgId, repoId, {
+              model: options.model,
+              preserveOriginals: options.preserveOriginals
+            });
+            executedConsolidations.push(result);
+          } catch (error) {
+            errors.push(
+              error instanceof Error ? error.message : String(error)
+            );
+          }
+        }
+      }
+    }
+  }
+  return {
+    dryRun,
+    totalActiveMemories: activeMemories.length,
+    expiredCandidates,
+    expiredCount: dryRun ? expiredCandidates.length : expiredCandidates.length,
+    strengthenedCandidates,
+    consolidationCandidates: consolidationPreview.candidates,
+    executedConsolidations,
+    warnings,
+    errors
+  };
+}
+var MEMORY_TEMPLATES = {
+  decision: {
+    name: "Decision",
+    description: "Technical or architectural decision",
+    memoryType: "semantic",
+    defaultTags: ["decision"],
+    prefix: "Decision:",
+    visibility: "repo"
+  },
+  adr: {
+    name: "ADR",
+    description: "Architecture Decision Record",
+    memoryType: "semantic",
+    defaultTags: ["adr", "architecture", "decision"],
+    prefix: "ADR:",
+    visibility: "repo"
+  },
+  gotcha: {
+    name: "Gotcha",
+    description: "Non-obvious issue or caveat discovered",
+    memoryType: "episodic",
+    defaultTags: ["gotcha", "warning"],
+    prefix: "Gotcha:",
+    visibility: "repo"
+  },
+  bug: {
+    name: "Bug",
+    description: "Bug found and fixed",
+    memoryType: "episodic",
+    defaultTags: ["bug", "fix"],
+    prefix: "Bug:",
+    visibility: "private"
+  },
+  playbook: {
+    name: "Playbook",
+    description: "Step-by-step procedure or workflow",
+    memoryType: "procedural",
+    defaultTags: ["playbook", "howto"],
+    prefix: "Playbook:",
+    visibility: "repo"
+  },
+  deploy: {
+    name: "Deploy",
+    description: "Deployment procedure or notes",
+    memoryType: "procedural",
+    defaultTags: ["deploy", "ops"],
+    prefix: "Deploy:",
+    visibility: "repo"
+  },
+  convention: {
+    name: "Convention",
+    description: "Coding convention or standard",
+    memoryType: "semantic",
+    defaultTags: ["convention", "standard"],
+    prefix: "Convention:",
+    visibility: "repo"
+  },
+  api: {
+    name: "API",
+    description: "API behavior or contract notes",
+    memoryType: "semantic",
+    defaultTags: ["api"],
+    visibility: "repo"
+  },
+  workaround: {
+    name: "Workaround",
+    description: "Temporary workaround for an issue",
+    memoryType: "episodic",
+    defaultTags: ["workaround", "temporary"],
+    prefix: "Workaround:",
+    visibility: "private"
+  },
+  perf: {
+    name: "Performance",
+    description: "Performance finding or optimization",
+    memoryType: "semantic",
+    defaultTags: ["performance", "optimization"],
+    prefix: "Perf:",
+    visibility: "repo"
+  },
+  security: {
+    name: "Security",
+    description: "Security consideration or finding",
+    memoryType: "semantic",
+    defaultTags: ["security"],
+    prefix: "Security:",
+    visibility: "repo"
+  }
+};
+function getTemplate(name) {
+  return MEMORY_TEMPLATES[name.toLowerCase()];
+}
+function applyTemplate(template, text, additionalTags = []) {
+  const finalText = template.prefix && !text.toLowerCase().startsWith(template.prefix.toLowerCase()) ? `${template.prefix} ${text}` : text;
+  const tags = [.../* @__PURE__ */ new Set([...template.defaultTags, ...additionalTags])];
+  return {
+    text: finalText,
+    memoryType: template.memoryType,
+    tags,
+    visibility: template.visibility
+  };
+}
+function formatTemplateList() {
+  const lines = ["Available templates:", ""];
+  for (const [key, template] of Object.entries(MEMORY_TEMPLATES)) {
+    lines.push(`  ${key.padEnd(12)} - ${template.description}`);
+    lines.push(`                 Type: ${template.memoryType}, Tags: ${template.defaultTags.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// ../../packages/config/dist/index.js
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+import YAML from "yaml";
+import { z } from "zod";
+var syncConfigSchema = z.object({
+  enabled: z.boolean(),
+  intervalMs: z.number().positive(),
+  debounceMs: z.number().nonnegative(),
+  autoResolveConflicts: z.enum([
+    "last_write_wins",
+    "local_wins",
+    "remote_wins",
+    "manual"
+  ])
+});
+var embeddingConfigSchema = z.object({
+  enabled: z.boolean(),
+  model: z.string(),
+  autoGenerate: z.boolean()
+});
+var lifecycleTtlConfigSchema = z.object({
+  episodic: z.number().int().positive().optional(),
+  semantic: z.number().int().positive().optional(),
+  procedural: z.number().int().positive().optional()
+});
+var lifecycleUsageBoostSchema = z.object({
+  enabled: z.boolean(),
+  topKToRecord: z.number().int().positive(),
+  minUsageCount: z.number().int().positive(),
+  maxBoost: z.number().min(0).max(1),
+  halfLifeDays: z.number().positive()
+});
+var lifecycleMaintenanceSchema = z.object({
+  staleEpisodicDays: z.number().int().positive(),
+  consolidationThreshold: z.number().min(0).max(1),
+  consolidationMinGroupSize: z.number().int().min(2),
+  consolidationMaxGroups: z.number().int().positive(),
+  promoteRecallCount: z.number().int().positive(),
+  pinRecallCount: z.number().int().positive(),
+  dryRunDefault: z.boolean(),
+  autoRunOnStore: z.boolean(),
+  autoRunOnRecall: z.boolean(),
+  debounceMs: z.number().int().positive()
+});
+var lifecycleConfigSchema = z.object({
+  ttlSecondsByType: lifecycleTtlConfigSchema.optional(),
+  usageBoost: lifecycleUsageBoostSchema.partial().optional(),
+  maintenance: lifecycleMaintenanceSchema.partial().optional()
+});
+var remoteConfigSchema = z.object({
+  url: z.string(),
+  orgId: z.string(),
+  repoId: z.string()
+});
+var appConfigSchema = z.object({
+  configVersion: z.number().optional(),
+  remote: remoteConfigSchema,
+  defaults: z.object({
+    visibility: z.enum(["private", "repo", "auto"]),
+    memoryType: z.enum(["episodic", "semantic", "procedural"])
+  }),
+  sync: syncConfigSchema.optional(),
+  embeddings: embeddingConfigSchema.optional(),
+  lifecycle: lifecycleConfigSchema.optional(),
+  remotes: z.record(z.string(), remoteConfigSchema).optional()
+});
+var VALID_MEMORY_TYPES = ["episodic", "semantic", "procedural"];
+function validateMemoryType(value) {
+  return VALID_MEMORY_TYPES.includes(value);
+}
+function parseConfidence(value) {
+  const n = parseFloat(value);
+  if (Number.isNaN(n) || n < 0 || n > 1) {
+    throw new Error("--confidence must be a number between 0 and 1");
+  }
+  return n;
+}
+function parseThreshold(value) {
+  const n = parseFloat(value);
+  if (Number.isNaN(n) || n < 0 || n > 1) {
+    throw new Error("--threshold must be a number between 0 and 1");
+  }
+  return n;
+}
+function parseTtl(value) {
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n) || n <= 0) {
+    throw new Error("--ttl must be a positive integer (seconds)");
+  }
+  return n;
+}
+function parsePositiveInt(value, name) {
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n) || n <= 0) {
+    throw new Error(`--${name} must be a positive integer`);
+  }
+  return n;
+}
+var DATA_DIR = ".unforgit";
+var CONFIG_FILE = "unforgit.yaml";
+var DB_FILE = "local.db";
+function writeConfigYaml(configPath, value) {
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = path.join(
+    dir,
+    `.${path.basename(configPath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  const fd = fs.openSync(
+    tmpPath,
+    fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY,
+    384
+  );
+  try {
+    fs.writeFileSync(fd, YAML.stringify(value), "utf-8");
+    fs.fsyncSync(fd);
+  } catch (err) {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    fs.rmSync(tmpPath, { force: true });
+    throw err;
+  }
+  fs.closeSync(fd);
+  fs.renameSync(tmpPath, configPath);
+  fs.chmodSync(configPath, 384);
+}
+function detectGitInfo(cwd = process.cwd()) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remoteUrl.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/) ?? void 0;
+    if (match) {
+      return { orgId: match[1], repoId: match[2] };
+    }
+  } catch {
+  }
+  return { orgId: "", repoId: "" };
+}
+function getDataDir(cwd = process.cwd()) {
+  return path.join(cwd, DATA_DIR);
+}
+function getDbPath(cwd = process.cwd()) {
+  return path.join(getDataDir(cwd), DB_FILE);
+}
+function getConfigPath(cwd = process.cwd()) {
+  return path.join(getDataDir(cwd), CONFIG_FILE);
+}
+function isInitialized(cwd = process.cwd()) {
+  return fs.existsSync(getDataDir(cwd)) && fs.existsSync(getConfigPath(cwd));
+}
+function findRepoRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    if (isInitialized(dir)) return dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+var CURRENT_CONFIG_VERSION = 2;
+function migrateConfig(parsed, configPath) {
+  const version = parsed.configVersion ?? 0;
+  if (version === CURRENT_CONFIG_VERSION) return parsed;
+  if (version === 0) {
+    parsed.configVersion = CURRENT_CONFIG_VERSION;
+    writeConfigYaml(configPath, parsed);
+  }
+  if (version === 1) {
+    parsed.configVersion = CURRENT_CONFIG_VERSION;
+    writeConfigYaml(configPath, parsed);
+  }
+  return parsed;
+}
+function warnDeprecatedKeys(parsed) {
+  const deprecated = [];
+  if (parsed.remote?.apiKey) {
+    deprecated.push("remote.apiKey \u2192 use UNFORGIT_API_KEY env var instead");
+  }
+  if (parsed.openaiApiKey) {
+    deprecated.push("openaiApiKey \u2192 use OPENAI_API_KEY env var instead");
+  }
+  if (deprecated.length > 0) {
+    console.error(
+      `[unforgit] Deprecated keys found in unforgit.yaml (ignored):
+${deprecated.map((d) => `  - ${d}`).join("\n")}
+Remove them from your config. Secrets should be set via environment variables.
+`
+    );
+  }
+}
+function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      "Unforgit not initialized. Run 'unforgit init' first."
+    );
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const parsed = YAML.parse(raw) ?? {};
+  const migrated = migrateConfig(parsed, configPath);
+  warnDeprecatedKeys(migrated);
+  const result = appConfigSchema.safeParse(migrated);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(
+      `Invalid unforgit.yaml configuration:
+${issues}
+
+Fix the config at ${configPath} or re-run 'unforgit init'.`
+    );
+  }
+  const defaults = defaultConfig();
+  const { openaiApiKey: _oai, ...cleanMigrated } = migrated;
+  if (cleanMigrated.remote && typeof cleanMigrated.remote === "object") {
+    const { apiKey: _ak, ...cleanRemote } = cleanMigrated.remote;
+    cleanMigrated.remote = cleanRemote;
+  }
+  return {
+    ...defaults,
+    ...cleanMigrated,
+    ...result.data,
+    remote: {
+      ...defaults.remote,
+      ...result.data.remote
+    },
+    defaults: {
+      ...defaults.defaults,
+      ...result.data.defaults
+    },
+    sync: {
+      ...defaults.sync,
+      ...result.data.sync ?? {}
+    },
+    embeddings: {
+      ...defaults.embeddings,
+      ...result.data.embeddings ?? {}
+    },
+    lifecycle: resolveLifecycleConfig(result.data.lifecycle)
+  };
+}
+function saveConfig(config2, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  writeConfigYaml(configPath, config2);
+}
+function defaultConfig() {
+  return {
+    configVersion: CURRENT_CONFIG_VERSION,
+    remote: {
+      url: "http://localhost:3737",
+      orgId: "",
+      repoId: ""
+    },
+    defaults: {
+      visibility: "auto",
+      memoryType: "episodic"
+    },
+    sync: {
+      enabled: true,
+      intervalMs: 6e4,
+      debounceMs: 5e3,
+      autoResolveConflicts: "last_write_wins"
+    },
+    embeddings: {
+      enabled: true,
+      model: "text-embedding-3-small",
+      autoGenerate: true
+    },
+    lifecycle: resolveLifecycleConfig()
+  };
+}
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 1e3;
+function isTransientError(status) {
+  return status >= 500 || status === 429;
+}
+var RemoteClient = class {
+  constructor(baseUrl, apiKey, options) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey || process.env.UNFORGIT_API_KEY;
+    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  apiKey;
+  timeoutMs;
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  handleError(res, operation, errorText) {
+    if (res.status === 401) {
+      throw new Error(
+        `Authentication failed for ${operation}: Invalid or missing API key. Set the UNFORGIT_API_KEY environment variable.`
+      );
+    }
+    if (res.status === 404 && operation === "resetAll") {
+      throw new Error(
+        "Remote resetAll failed (404): the configured server does not support /v1/memories/reset. Rebuild or restart the remote API so it is running a version that includes the reset endpoint."
+      );
+    }
+    throw new Error(`Remote ${operation} failed (${res.status}): ${errorText}`);
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new Error(`Request timed out after ${this.timeoutMs}ms`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async fetchWithRetry(url, init, operation) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const res = await this.fetchWithTimeout(url, init);
+        if (res.ok || !isTransientError(res.status)) {
+          return res;
+        }
+        lastError = new Error(
+          `Remote ${operation} failed (${res.status}): ${await res.text()}`
+        );
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const isFatalAbort = lastError.message.includes("timed out") && attempt === MAX_RETRIES - 1;
+        if (isFatalAbort) throw lastError;
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+      }
+    }
+    throw lastError ?? new Error(`Remote ${operation} failed after ${MAX_RETRIES} retries`);
+  }
+  async store(input) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory`,
+      { method: "POST", headers: this.getHeaders(), body: JSON.stringify(input) },
+      "store"
+    );
+    if (!res.ok) {
+      this.handleError(res, "store", await res.text());
+    }
+    return res.json();
+  }
+  async recall(query) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/recall`,
+      { method: "POST", headers: this.getHeaders(), body: JSON.stringify(query) },
+      "recall"
+    );
+    if (!res.ok) {
+      this.handleError(res, "recall", await res.text());
+    }
+    return res.json();
+  }
+  async deprecate(id, reason) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${id}/deprecate`,
+      { method: "POST", headers: this.getHeaders(), body: JSON.stringify({ reason }) },
+      "deprecate"
+    );
+    if (!res.ok) {
+      this.handleError(res, "deprecate", await res.text());
+    }
+    return res.json();
+  }
+  async supersede(oldId, newId) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${oldId}/supersede`,
+      { method: "POST", headers: this.getHeaders(), body: JSON.stringify({ newId }) },
+      "supersede"
+    );
+    if (!res.ok) {
+      this.handleError(res, "supersede", await res.text());
+    }
+    return res.json();
+  }
+  async link(sourceId, targetId, linkType, metadata) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${sourceId}/link`,
+      {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ targetId, linkType, metadata })
+      },
+      "link"
+    );
+    if (!res.ok) {
+      this.handleError(res, "link", await res.text());
+    }
+    return res.json();
+  }
+  async unlink(sourceId, targetId, linkType) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${sourceId}/link`,
+      {
+        method: "DELETE",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ targetId, linkType })
+      },
+      "unlink"
+    );
+    if (!res.ok) {
+      this.handleError(res, "unlink", await res.text());
+    }
+    return res.json();
+  }
+  async getLinks(memoryId, linkType) {
+    const params = new URLSearchParams();
+    if (linkType) params.set("linkType", linkType);
+    const qs = params.toString();
+    const url = `${this.baseUrl}/v1/memory/${memoryId}/links${qs ? `?${qs}` : ""}`;
+    const res = await this.fetchWithRetry(url, { headers: this.getHeaders() }, "getLinks");
+    if (!res.ok) {
+      this.handleError(res, "getLinks", await res.text());
+    }
+    return res.json();
+  }
+  async consolidate(body) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/consolidate`,
+      { method: "POST", headers: this.getHeaders(), body: JSON.stringify(body) },
+      "consolidate"
+    );
+    if (!res.ok) {
+      this.handleError(res, "consolidate", await res.text());
+    }
+    return res.json();
+  }
+  async delete(id, deletedBy, hardDelete) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${id}`,
+      {
+        method: "DELETE",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ deletedBy, hardDelete })
+      },
+      "delete"
+    );
+    if (!res.ok) {
+      this.handleError(res, "delete", await res.text());
+    }
+    return res.json();
+  }
+  async restore(id) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memory/${id}/restore`,
+      { method: "POST", headers: this.getHeaders() },
+      "restore"
+    );
+    if (!res.ok) {
+      this.handleError(res, "restore", await res.text());
+    }
+    return res.json();
+  }
+  async resetAll(orgId, repoId) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/memories/reset`,
+      {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ orgId, repoId })
+      },
+      "resetAll"
+    );
+    if (!res.ok) {
+      this.handleError(res, "resetAll", await res.text());
+    }
+    return res.json();
+  }
+  async runLifecycle(body) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/lifecycle/run`,
+      {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(body)
+      },
+      "runLifecycle"
+    );
+    if (!res.ok) {
+      this.handleError(res, "runLifecycle", await res.text());
+    }
+    return res.json();
+  }
+  async createApiKey(name, orgId) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/api-keys`,
+      {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({ name, orgId })
+      },
+      "createApiKey"
+    );
+    if (!res.ok) {
+      this.handleError(res, "createApiKey", await res.text());
+    }
+    return res.json();
+  }
+  async listApiKeys(orgId) {
+    const params = new URLSearchParams();
+    if (orgId) params.set("orgId", orgId);
+    const qs = params.toString();
+    const url = `${this.baseUrl}/v1/api-keys${qs ? `?${qs}` : ""}`;
+    const res = await this.fetchWithRetry(url, { headers: this.getHeaders() }, "listApiKeys");
+    if (!res.ok) {
+      this.handleError(res, "listApiKeys", await res.text());
+    }
+    return res.json();
+  }
+  async revokeApiKey(id) {
+    const res = await this.fetchWithRetry(
+      `${this.baseUrl}/v1/api-keys/${id}`,
+      { method: "DELETE", headers: this.getHeaders() },
+      "revokeApiKey"
+    );
+    if (!res.ok) {
+      if (res.status === 404) {
+        throw new Error(`API key '${id}' not found.`);
+      }
+      this.handleError(res, "revokeApiKey", await res.text());
+    }
+  }
+};
+
+// ../../packages/db/dist/index.js
+import Database from "better-sqlite3";
+import { v4 as uuid } from "uuid";
+import path2 from "path";
+import fs2 from "fs";
+import * as path22 from "path";
+import { fileURLToPath } from "url";
+import * as runtime from "@prisma/client/runtime/client";
+import * as runtime2 from "@prisma/client/runtime/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS memories (
+  id TEXT PRIMARY KEY,
+  org_id TEXT NOT NULL,
+  repo_id TEXT NOT NULL,
+  scope_type TEXT NOT NULL DEFAULT 'repo',
+  memory_type TEXT NOT NULL CHECK(memory_type IN ('episodic','semantic','procedural')),
+  visibility TEXT NOT NULL DEFAULT 'private' CHECK(visibility IN ('private','repo')),
+  status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','deprecated','superseded','deleted')),
+  text TEXT NOT NULL,
+  summary TEXT,
+  tags TEXT NOT NULL DEFAULT '[]',
+  source_refs TEXT,
+  confidence REAL,
+  ttl_seconds INTEGER,
+  supersedes_id TEXT,
+  is_consolidation INTEGER NOT NULL DEFAULT 0,
+  consolidation_version INTEGER,
+  author_id TEXT,
+  author_name TEXT,
+  version INTEGER NOT NULL DEFAULT 1,
+  deleted_at TEXT,
+  deleted_by TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS tombstones (
+  id TEXT PRIMARY KEY,
+  memory_id TEXT NOT NULL UNIQUE,
+  org_id TEXT NOT NULL,
+  repo_id TEXT NOT NULL,
+  deleted_at TEXT NOT NULL,
+  deleted_by TEXT,
+  synced_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_tombstones_sync ON tombstones(org_id, repo_id, synced_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  text, summary, content=memories, content_rowid=rowid
+);
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, text, summary)
+    VALUES (new.rowid, new.text, new.summary);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, text, summary)
+    VALUES ('delete', old.rowid, old.text, old.summary);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, text, summary)
+    VALUES ('delete', old.rowid, old.text, old.summary);
+  INSERT INTO memories_fts(rowid, text, summary)
+    VALUES (new.rowid, new.text, new.summary);
+END;
+
+CREATE TABLE IF NOT EXISTS memory_links (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  target_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  link_type TEXT NOT NULL CHECK(link_type IN ('related_to','derived_from','contradicts','depends_on')),
+  metadata TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(source_id, target_id, link_type)
+);
+
+CREATE TABLE IF NOT EXISTS sync_state (
+  memory_id TEXT PRIMARY KEY,
+  local_version INTEGER NOT NULL,
+  remote_version INTEGER,
+  last_pushed_at TEXT,
+  last_pulled_at TEXT,
+  sync_status TEXT NOT NULL DEFAULT 'pending_push' CHECK(sync_status IN ('synced','pending_push','pending_pull','conflict'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_sync_state_status ON sync_state(sync_status);
+
+CREATE TABLE IF NOT EXISTS synced_links (
+  link_id TEXT PRIMARY KEY,
+  synced_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS memory_embeddings (
+  memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+  embedding BLOB NOT NULL,
+  model TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS memory_usage (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  memory_id TEXT NOT NULL,
+  recalled_at TEXT NOT NULL DEFAULT (datetime('now')),
+  query TEXT,
+  session_id TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_usage_memory ON memory_usage(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_usage_recalled ON memory_usage(recalled_at);
+
+CREATE TABLE IF NOT EXISTS curation_suggestions (
+  id TEXT PRIMARY KEY,
+  org_id TEXT NOT NULL,
+  repo_id TEXT NOT NULL,
+  type TEXT NOT NULL CHECK(type IN ('consolidate','deprecate','delete','add_tags','add_links','review','promote','generate_embedding')),
+  priority TEXT NOT NULL CHECK(priority IN ('high','medium','low')),
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','approved','rejected','applied')),
+  memory_ids TEXT NOT NULL DEFAULT '[]',
+  reason TEXT NOT NULL,
+  confidence REAL NOT NULL,
+  payload TEXT,
+  created_by TEXT,
+  reviewed_by TEXT,
+  review_note TEXT,
+  reviewed_at TEXT,
+  applied_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_curation_suggestions_repo_status ON curation_suggestions(org_id, repo_id, status, created_at);
+`;
+function rowToLink(row) {
+  return {
+    id: row.id,
+    sourceId: row.source_id,
+    targetId: row.target_id,
+    linkType: row.link_type,
+    metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+    createdAt: new Date(row.created_at)
+  };
+}
+function rowToMemory(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    repoId: row.repo_id,
+    scopeType: row.scope_type ?? "repo",
+    memoryType: row.memory_type,
+    visibility: row.visibility,
+    status: row.status,
+    text: row.text,
+    summary: row.summary ?? void 0,
+    tags: JSON.parse(row.tags ?? "[]"),
+    sourceRefs: row.source_refs ? JSON.parse(row.source_refs) : void 0,
+    confidence: row.confidence ?? void 0,
+    ttlSeconds: row.ttl_seconds ?? void 0,
+    supersedesId: row.supersedes_id ?? void 0,
+    isConsolidation: row.is_consolidation === 1,
+    consolidationVersion: row.consolidation_version ?? void 0,
+    authorId: row.author_id ?? void 0,
+    authorName: row.author_name ?? void 0,
+    version: row.version ?? 1,
+    deletedAt: row.deleted_at ? new Date(row.deleted_at) : void 0,
+    deletedBy: row.deleted_by ?? void 0,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function rowToCurationSuggestion(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    repoId: row.repo_id,
+    type: row.type,
+    priority: row.priority,
+    status: row.status,
+    memoryIds: JSON.parse(row.memory_ids ?? "[]"),
+    reason: row.reason,
+    confidence: row.confidence,
+    payload: row.payload ? JSON.parse(row.payload) : void 0,
+    createdBy: row.created_by ?? void 0,
+    reviewedBy: row.reviewed_by ?? void 0,
+    reviewNote: row.review_note ?? void 0,
+    reviewedAt: row.reviewed_at ? new Date(row.reviewed_at) : void 0,
+    appliedAt: row.applied_at ? new Date(row.applied_at) : void 0,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function rowToTombstone(row) {
+  return {
+    id: row.id,
+    memoryId: row.memory_id,
+    orgId: row.org_id,
+    repoId: row.repo_id,
+    deletedAt: new Date(row.deleted_at),
+    deletedBy: row.deleted_by ?? void 0,
+    syncedAt: row.synced_at ? new Date(row.synced_at) : void 0
+  };
+}
+function nonExpiredMemoryClause(alias) {
+  const prefix = alias ? `${alias}.` : "";
+  return `(${prefix}status != 'active' OR ${prefix}ttl_seconds IS NULL OR datetime(${prefix}created_at, '+' || ${prefix}ttl_seconds || ' seconds') >= datetime('now'))`;
+}
+var LocalStore = class {
+  db;
+  constructor(dbPath) {
+    const dir = path2.dirname(dbPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(SCHEMA_SQL);
+    this.migrateSchema();
+  }
+  migrateSchema() {
+    const columns = this.db.prepare("PRAGMA table_info(memories)").all();
+    const columnNames = columns.map((c) => c.name);
+    if (!columnNames.includes("is_consolidation")) {
+      this.db.exec(
+        "ALTER TABLE memories ADD COLUMN is_consolidation INTEGER NOT NULL DEFAULT 0"
+      );
+    }
+    if (!columnNames.includes("consolidation_version")) {
+      this.db.exec(
+        "ALTER TABLE memories ADD COLUMN consolidation_version INTEGER"
+      );
+    }
+    if (!columnNames.includes("author_id")) {
+      this.db.exec("ALTER TABLE memories ADD COLUMN author_id TEXT");
+    }
+    if (!columnNames.includes("author_name")) {
+      this.db.exec("ALTER TABLE memories ADD COLUMN author_name TEXT");
+    }
+    if (!columnNames.includes("version")) {
+      this.db.exec("ALTER TABLE memories ADD COLUMN version INTEGER NOT NULL DEFAULT 1");
+    }
+    if (!columnNames.includes("deleted_at")) {
+      this.db.exec("ALTER TABLE memories ADD COLUMN deleted_at TEXT");
+    }
+    if (!columnNames.includes("deleted_by")) {
+      this.db.exec("ALTER TABLE memories ADD COLUMN deleted_by TEXT");
+    }
+    const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tombstones'").all();
+    if (tables.length === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tombstones (
+          id TEXT PRIMARY KEY,
+          memory_id TEXT NOT NULL UNIQUE,
+          org_id TEXT NOT NULL,
+          repo_id TEXT NOT NULL,
+          deleted_at TEXT NOT NULL,
+          deleted_by TEXT,
+          synced_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_tombstones_sync ON tombstones(org_id, repo_id, synced_at);
+      `);
+    }
+    const syncTables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sync_state'").all();
+    if (syncTables.length === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS sync_state (
+          memory_id TEXT PRIMARY KEY,
+          local_version INTEGER NOT NULL,
+          remote_version INTEGER,
+          last_pushed_at TEXT,
+          last_pulled_at TEXT,
+          sync_status TEXT NOT NULL DEFAULT 'pending_push' CHECK(sync_status IN ('synced','pending_push','pending_pull','conflict'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_sync_state_status ON sync_state(sync_status);
+      `);
+    }
+    const embeddingTables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_embeddings'").all();
+    if (embeddingTables.length === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_embeddings (
+          memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+          embedding BLOB NOT NULL,
+          model TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+      `);
+    }
+    const usageTables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_usage'").all();
+    if (usageTables.length === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_usage (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          memory_id TEXT NOT NULL,
+          recalled_at TEXT NOT NULL DEFAULT (datetime('now')),
+          query TEXT,
+          session_id TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_memory_usage_memory ON memory_usage(memory_id);
+        CREATE INDEX IF NOT EXISTS idx_memory_usage_recalled ON memory_usage(recalled_at);
+      `);
+    }
+    const curationSuggestionTables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='curation_suggestions'").all();
+    if (curationSuggestionTables.length === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS curation_suggestions (
+          id TEXT PRIMARY KEY,
+          org_id TEXT NOT NULL,
+          repo_id TEXT NOT NULL,
+          type TEXT NOT NULL CHECK(type IN ('consolidate','deprecate','delete','add_tags','add_links','review','promote','generate_embedding')),
+          priority TEXT NOT NULL CHECK(priority IN ('high','medium','low')),
+          status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','approved','rejected','applied')),
+          memory_ids TEXT NOT NULL DEFAULT '[]',
+          reason TEXT NOT NULL,
+          confidence REAL NOT NULL,
+          payload TEXT,
+          created_by TEXT,
+          reviewed_by TEXT,
+          review_note TEXT,
+          reviewed_at TEXT,
+          applied_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_curation_suggestions_repo_status ON curation_suggestions(org_id, repo_id, status, created_at);
+      `);
+    }
+  }
+  store(input) {
+    const resolvedInput = applyLifecycleDefaults(input);
+    const id = uuid();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const normalizedOrgId = resolvedInput.orgId.toLowerCase();
+    const normalizedRepoId = resolvedInput.repoId.toLowerCase();
+    const visibility = resolvedInput.visibility === "auto" || !resolvedInput.visibility ? "private" : resolvedInput.visibility;
+    this.db.prepare(
+      `INSERT INTO memories
+        (id, org_id, repo_id, scope_type, memory_type, visibility, status, text, summary, tags, source_refs, confidence, ttl_seconds, author_id, author_name, created_at, updated_at)
+        VALUES (?, ?, ?, 'repo', ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      normalizedOrgId,
+      normalizedRepoId,
+      resolvedInput.memoryType,
+      visibility,
+      resolvedInput.text,
+      resolvedInput.summary ?? null,
+      JSON.stringify(resolvedInput.tags ?? []),
+      resolvedInput.sourceRefs ? JSON.stringify(resolvedInput.sourceRefs) : null,
+      resolvedInput.confidence ?? null,
+      resolvedInput.ttlSeconds ?? null,
+      resolvedInput.authorId ?? null,
+      resolvedInput.authorName ?? null,
+      now,
+      now
+    );
+    this.setSyncState({
+      memoryId: id,
+      localVersion: 1,
+      syncStatus: "pending_push"
+    });
+    return this.getById(id);
+  }
+  getById(id) {
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    return row ? rowToMemory(row) : void 0;
+  }
+  recall(query) {
+    const conditions = ["m.org_id = ?", "m.repo_id = ?"];
+    const params = [query.orgId, query.repoId];
+    if (!query.includeDeprecated) {
+      conditions.push("m.status = 'active'");
+    }
+    if (!query.includeExpired) {
+      conditions.push(nonExpiredMemoryClause("m"));
+    }
+    if (query.types && query.types.length > 0) {
+      conditions.push(
+        `m.memory_type IN (${query.types.map(() => "?").join(",")})`
+      );
+      params.push(...query.types);
+    }
+    if (query.timeRange?.from) {
+      conditions.push("m.created_at >= ?");
+      params.push(query.timeRange.from.toISOString());
+    }
+    if (query.timeRange?.to) {
+      conditions.push("m.created_at <= ?");
+      params.push(query.timeRange.to.toISOString());
+    }
+    const whereClause = conditions.join(" AND ");
+    const k = query.k ?? 10;
+    const rawQuery = query.query.replace(/[^\w\s]/g, " ").trim();
+    const words = rawQuery.split(/\s+/).filter((w) => w.length > 0);
+    const searchableWords = words.filter((w) => w.length >= 2);
+    const ftsQuery = searchableWords.length > 0 ? `(${searchableWords.map((w) => `${w}*`).join(" OR ")})` : "";
+    let sql;
+    let finalParams;
+    if (ftsQuery) {
+      sql = `
+        SELECT m.*, fts.rank AS fts_rank
+        FROM memories_fts fts
+        JOIN memories m ON m.rowid = fts.rowid
+        WHERE fts.memories_fts MATCH ?
+          AND ${whereClause}
+        ORDER BY m.is_consolidation DESC, fts.rank
+        LIMIT ?
+      `;
+      finalParams = [ftsQuery, ...params, k * 2];
+    } else {
+      sql = `
+        SELECT m.*, 0 AS fts_rank
+        FROM memories m
+        WHERE ${whereClause}
+        ORDER BY m.is_consolidation DESC, m.created_at DESC
+        LIMIT ?
+      `;
+      finalParams = [...params, k * 2];
+    }
+    let rows = this.db.prepare(sql).all(...finalParams);
+    if (rows.length === 0 && searchableWords.length > 0) {
+      const likeConditions = searchableWords.slice(0, 5).map(() => "(m.text LIKE ? OR m.summary LIKE ?)").join(" OR ");
+      const likeParams = [];
+      for (const word of searchableWords.slice(0, 5)) {
+        likeParams.push(`%${word}%`, `%${word}%`);
+      }
+      const fallbackSql = `
+        SELECT m.*, 0 AS fts_rank
+        FROM memories m
+        WHERE ${whereClause}
+          AND (${likeConditions})
+        ORDER BY m.is_consolidation DESC, m.created_at DESC
+        LIMIT ?
+      `;
+      rows = this.db.prepare(fallbackSql).all(...params, ...likeParams, k * 2);
+    }
+    const usageStats = this.getUsageStats(query.orgId, query.repoId);
+    const usageMap = new Map(usageStats.map((stat) => [stat.memoryId, stat]));
+    let results = rows.map((row) => {
+      const memory = rowToMemory(row);
+      const textScore = ftsQuery ? Math.min(1, Math.abs(row.fts_rank) / 10) : 0.5;
+      const consolidationBoost = memory.isConsolidation ? 0.1 : 0;
+      const usage = usageMap.get(memory.id);
+      const usageBoost = computeUsageBoost(
+        usage?.count ?? 0,
+        usage?.lastUsed
+      );
+      const result = {
+        id: memory.id,
+        memoryType: memory.memoryType,
+        text: memory.text,
+        summary: memory.summary,
+        tags: memory.tags,
+        sourceRefs: memory.sourceRefs,
+        score: computeCompositeScore(
+          textScore + consolidationBoost,
+          memory.createdAt,
+          memory.confidence,
+          usageBoost
+        ),
+        source: "local",
+        status: memory.status,
+        supersedesId: memory.supersedesId,
+        isConsolidation: memory.isConsolidation,
+        consolidationVersion: memory.consolidationVersion
+      };
+      if (query.includeConsolidatedSources && memory.isConsolidation) {
+        const sources = this.getConsolidatedSources(memory.id);
+        result.sourceMemories = sources.map((src) => ({
+          id: src.id,
+          memoryType: src.memoryType,
+          text: src.text,
+          summary: src.summary,
+          tags: src.tags,
+          sourceRefs: src.sourceRefs,
+          score: 0,
+          source: "local"
+        }));
+      }
+      return result;
+    });
+    if (query.tags && query.tags.length > 0) {
+      results = results.filter((r) => {
+        const memTags = r.tags;
+        return query.tags.some((t) => memTags.includes(t));
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, k);
+  }
+  list(query) {
+    const conditions = ["org_id = ?", "repo_id = ?"];
+    const params = [query.orgId, query.repoId];
+    if (!query.includeExpired) {
+      conditions.push(nonExpiredMemoryClause());
+    }
+    if (query.types && query.types.length > 0) {
+      conditions.push(
+        `memory_type IN (${query.types.map(() => "?").join(",")})`
+      );
+      params.push(...query.types);
+    }
+    if (query.status && query.status.length > 0) {
+      conditions.push(
+        `status IN (${query.status.map(() => "?").join(",")})`
+      );
+      params.push(...query.status);
+    }
+    if (query.visibility && query.visibility.length > 0) {
+      conditions.push(
+        `visibility IN (${query.visibility.map(() => "?").join(",")})`
+      );
+      params.push(...query.visibility);
+    }
+    if (query.search) {
+      const rawSearch = query.search.replace(/[^\w\s]/g, " ").trim();
+      const searchWords = rawSearch.split(/\s+/).filter((w) => w.length >= 2);
+      const ftsSearch = searchWords.length > 0 ? `(${searchWords.map((w) => `${w}*`).join(" OR ")})` : "";
+      if (ftsSearch) {
+        conditions.push(
+          "rowid IN (SELECT rowid FROM memories_fts WHERE memories_fts MATCH ?)"
+        );
+        params.push(ftsSearch);
+      }
+    }
+    const sortCol = query.sortBy === "updatedAt" ? "updated_at" : query.sortBy === "confidence" ? "confidence" : "created_at";
+    const sortDir = query.sortOrder === "asc" ? "ASC" : "DESC";
+    const limit = query.limit ?? 50;
+    const offset = query.offset ?? 0;
+    const sql = `
+      SELECT * FROM memories
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY ${sortCol} ${sortDir}
+      LIMIT ? OFFSET ?
+    `;
+    params.push(limit, offset);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToMemory);
+  }
+  count(query) {
+    const conditions = ["org_id = ?", "repo_id = ?"];
+    const params = [query.orgId, query.repoId];
+    if (!query.includeExpired) {
+      conditions.push(nonExpiredMemoryClause());
+    }
+    if (query.types && query.types.length > 0) {
+      conditions.push(
+        `memory_type IN (${query.types.map(() => "?").join(",")})`
+      );
+      params.push(...query.types);
+    }
+    if (query.status && query.status.length > 0) {
+      conditions.push(
+        `status IN (${query.status.map(() => "?").join(",")})`
+      );
+      params.push(...query.status);
+    }
+    if (query.visibility && query.visibility.length > 0) {
+      conditions.push(
+        `visibility IN (${query.visibility.map(() => "?").join(",")})`
+      );
+      params.push(...query.visibility);
+    }
+    if (query.search) {
+      const rawSearch = query.search.replace(/[^\w\s]/g, " ").trim();
+      const searchWords = rawSearch.split(/\s+/).filter((w) => w.length >= 2);
+      const ftsSearch = searchWords.length > 0 ? `(${searchWords.map((w) => `${w}*`).join(" OR ")})` : "";
+      if (ftsSearch) {
+        conditions.push(
+          "rowid IN (SELECT rowid FROM memories_fts WHERE memories_fts MATCH ?)"
+        );
+        params.push(ftsSearch);
+      }
+    }
+    const sql = `SELECT COUNT(*) as cnt FROM memories WHERE ${conditions.join(" AND ")}`;
+    const row = this.db.prepare(sql).get(...params);
+    return row.cnt;
+  }
+  stats(orgId, repoId) {
+    const rows = this.db.prepare(
+      `SELECT memory_type, status, visibility, COUNT(*) as cnt
+         FROM memories WHERE org_id = ? AND repo_id = ?
+         GROUP BY memory_type, status, visibility`
+    ).all(orgId, repoId);
+    const stats = {
+      total: 0,
+      byType: { episodic: 0, semantic: 0, procedural: 0 },
+      byStatus: { active: 0, deprecated: 0, superseded: 0, deleted: 0 },
+      byVisibility: { private: 0, repo: 0 }
+    };
+    for (const row of rows) {
+      stats.total += row.cnt;
+      if (row.memory_type in stats.byType) {
+        stats.byType[row.memory_type] += row.cnt;
+      }
+      if (row.status in stats.byStatus) {
+        stats.byStatus[row.status] += row.cnt;
+      }
+      if (row.visibility in stats.byVisibility) {
+        stats.byVisibility[row.visibility] += row.cnt;
+      }
+    }
+    return stats;
+  }
+  deprecate(id, reason) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare(
+      "UPDATE memories SET status = 'deprecated', updated_at = ? WHERE id = ?"
+    ).run(now, id);
+    if (reason && result.changes > 0) {
+      const mem = this.getById(id);
+      if (mem) {
+        const refs = mem.sourceRefs ?? {};
+        refs.deprecation_reason = reason;
+        this.db.prepare("UPDATE memories SET source_refs = ? WHERE id = ?").run(JSON.stringify(refs), id);
+      }
+    }
+    return result.changes > 0;
+  }
+  supersede(oldId, newId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare(
+      "UPDATE memories SET status = 'superseded', supersedes_id = ?, updated_at = ? WHERE id = ?"
+    ).run(newId, now, oldId);
+    return result.changes > 0;
+  }
+  updateVisibility(id, visibility) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare(
+      "UPDATE memories SET visibility = ?, updated_at = ? WHERE id = ?"
+    ).run(visibility, now, id);
+    return result.changes > 0;
+  }
+  expireExpiredMemories(orgId, repoId, deletedBy = "system:ttl-expiry") {
+    const conditions = [
+      "status = 'active'",
+      "ttl_seconds IS NOT NULL",
+      "datetime(created_at, '+' || ttl_seconds || ' seconds') < datetime('now')"
+    ];
+    const params = [];
+    if (orgId) {
+      conditions.push("org_id = ?");
+      params.push(orgId);
+    }
+    if (repoId) {
+      conditions.push("repo_id = ?");
+      params.push(repoId);
+    }
+    const rows = this.db.prepare(
+      `SELECT id FROM memories WHERE ${conditions.join(" AND ")}`
+    ).all(...params);
+    let expired = 0;
+    for (const row of rows) {
+      if (this.softDelete({ id: row.id, deletedBy })) {
+        expired += 1;
+      }
+    }
+    return expired;
+  }
+  purgeExpired() {
+    return this.expireExpiredMemories();
+  }
+  link(input) {
+    const id = uuid();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO memory_links (id, source_id, target_id, link_type, metadata, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      input.sourceId,
+      input.targetId,
+      input.linkType,
+      input.metadata ? JSON.stringify(input.metadata) : null,
+      now
+    );
+    return this.getLinkById(id);
+  }
+  unlink(sourceId, targetId, linkType) {
+    const result = this.db.prepare(
+      "DELETE FROM memory_links WHERE source_id = ? AND target_id = ? AND link_type = ?"
+    ).run(sourceId, targetId, linkType);
+    return result.changes > 0;
+  }
+  getLinks(query) {
+    const conditions = [
+      "(source_id = ? OR target_id = ?)"
+    ];
+    const params = [query.memoryId, query.memoryId];
+    if (query.linkType) {
+      conditions.push("link_type = ?");
+      params.push(query.linkType);
+    }
+    const sql = `SELECT * FROM memory_links WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`;
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToLink);
+  }
+  getLinkedMemories(memoryId, linkType) {
+    const conditions = [
+      "(l.source_id = ? OR l.target_id = ?)"
+    ];
+    const params = [memoryId, memoryId];
+    if (linkType) {
+      conditions.push("l.link_type = ?");
+      params.push(linkType);
+    }
+    const sql = `
+      SELECT m.* FROM memories m
+      JOIN memory_links l ON (
+        (l.source_id = ? AND l.target_id = m.id) OR
+        (l.target_id = ? AND l.source_id = m.id)
+      )
+      ${linkType ? "WHERE l.link_type = ?" : ""}
+      ORDER BY m.created_at DESC
+    `;
+    const linkedParams = linkType ? [memoryId, memoryId, linkType] : [memoryId, memoryId];
+    const rows = this.db.prepare(sql).all(...linkedParams);
+    return rows.map(rowToMemory);
+  }
+  getLinkById(id) {
+    const row = this.db.prepare("SELECT * FROM memory_links WHERE id = ?").get(id);
+    return row ? rowToLink(row) : void 0;
+  }
+  consolidateMemories(input) {
+    const { sourceIds, consolidatedText, memoryType, tags, preserveOriginals = true } = input;
+    const orgId = input.orgId.toLowerCase();
+    const repoId = input.repoId.toLowerCase();
+    if (sourceIds.length < 2) {
+      throw new Error("At least 2 source memories are required for consolidation");
+    }
+    const sourceMemories = sourceIds.map((id2) => this.getById(id2)).filter((m) => m !== void 0);
+    if (sourceMemories.length !== sourceIds.length) {
+      const foundIds = sourceMemories.map((m) => m.id);
+      const missingIds = sourceIds.filter((id2) => !foundIds.includes(id2));
+      throw new Error(`Source memories not found: ${missingIds.join(", ")}`);
+    }
+    const inferredType = memoryType ?? this.inferMemoryType(sourceMemories);
+    const mergedTags = tags ?? this.mergeTags(sourceMemories);
+    const inheritedVisibility = sourceMemories.some((m) => m.visibility === "repo") ? "repo" : "private";
+    const id = uuid();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const version = 1;
+    this.db.prepare(
+      `INSERT INTO memories
+        (id, org_id, repo_id, scope_type, memory_type, visibility, status, text, summary, tags, source_refs, confidence, is_consolidation, consolidation_version, created_at, updated_at)
+        VALUES (?, ?, ?, 'repo', ?, ?, 'active', ?, ?, ?, ?, ?, 1, ?, ?, ?)`
+    ).run(
+      id,
+      orgId,
+      repoId,
+      inferredType,
+      inheritedVisibility,
+      consolidatedText,
+      null,
+      JSON.stringify(mergedTags),
+      JSON.stringify({ consolidated_from: sourceIds }),
+      null,
+      version,
+      now,
+      now
+    );
+    for (const sourceId of sourceIds) {
+      this.link({
+        sourceId: id,
+        targetId: sourceId,
+        linkType: "derived_from",
+        metadata: { consolidation: true }
+      });
+    }
+    if (preserveOriginals) {
+      for (const sourceId of sourceIds) {
+        this.supersede(sourceId, id);
+      }
+    }
+    if (inheritedVisibility === "repo") {
+      this.setSyncState({
+        memoryId: id,
+        localVersion: version,
+        syncStatus: "pending_push"
+      });
+    }
+    return {
+      consolidatedId: id,
+      version,
+      sourcesPreserved: sourceIds.length,
+      sourceIds
+    };
+  }
+  reconsolidate(input) {
+    const { existingConsolidationId, additionalSourceIds = [], newText, tags } = input;
+    const orgId = input.orgId.toLowerCase();
+    const repoId = input.repoId.toLowerCase();
+    const existing = this.getById(existingConsolidationId);
+    if (!existing) {
+      throw new Error(`Consolidation not found: ${existingConsolidationId}`);
+    }
+    if (!existing.isConsolidation) {
+      throw new Error(`Memory ${existingConsolidationId} is not a consolidation`);
+    }
+    const existingLinks = this.getLinks({ memoryId: existingConsolidationId, linkType: "derived_from" });
+    const existingSourceIds = existingLinks.filter((l) => l.sourceId === existingConsolidationId).map((l) => l.targetId);
+    const allSourceIds = [.../* @__PURE__ */ new Set([...existingSourceIds, ...additionalSourceIds])];
+    for (const id2 of additionalSourceIds) {
+      const mem = this.getById(id2);
+      if (!mem) {
+        throw new Error(`Additional source memory not found: ${id2}`);
+      }
+    }
+    const newVersion = (existing.consolidationVersion ?? 1) + 1;
+    const mergedTags = tags ?? existing.tags;
+    const inheritedVisibility = existing.visibility;
+    const id = uuid();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `INSERT INTO memories
+        (id, org_id, repo_id, scope_type, memory_type, visibility, status, text, summary, tags, source_refs, confidence, is_consolidation, consolidation_version, created_at, updated_at)
+        VALUES (?, ?, ?, 'repo', ?, ?, 'active', ?, ?, ?, ?, ?, 1, ?, ?, ?)`
+    ).run(
+      id,
+      orgId,
+      repoId,
+      existing.memoryType,
+      inheritedVisibility,
+      newText,
+      null,
+      JSON.stringify(mergedTags),
+      JSON.stringify({
+        consolidated_from: allSourceIds,
+        previous_consolidation: existingConsolidationId
+      }),
+      null,
+      newVersion,
+      now,
+      now
+    );
+    this.link({
+      sourceId: id,
+      targetId: existingConsolidationId,
+      linkType: "derived_from",
+      metadata: { reconsolidation: true, previous_version: existing.consolidationVersion ?? 1 }
+    });
+    for (const sourceId of additionalSourceIds) {
+      this.link({
+        sourceId: id,
+        targetId: sourceId,
+        linkType: "derived_from",
+        metadata: { consolidation: true }
+      });
+      this.supersede(sourceId, id);
+    }
+    this.supersede(existingConsolidationId, id);
+    if (inheritedVisibility === "repo") {
+      this.setSyncState({
+        memoryId: id,
+        localVersion: newVersion,
+        syncStatus: "pending_push"
+      });
+    }
+    return {
+      consolidatedId: id,
+      version: newVersion,
+      sourcesPreserved: allSourceIds.length,
+      sourceIds: allSourceIds
+    };
+  }
+  findSimilar(query) {
+    const { orgId, repoId, memoryId, threshold = 0.3, k = 10 } = query;
+    const memory = this.getById(memoryId);
+    if (!memory) {
+      throw new Error(`Memory not found: ${memoryId}`);
+    }
+    const results = this.recall({
+      orgId,
+      repoId,
+      query: memory.text,
+      k: k + 1
+    });
+    return results.filter((r) => r.id !== memoryId && r.score >= threshold).slice(0, k);
+  }
+  getConsolidationHistory(memoryId) {
+    const memory = this.getById(memoryId);
+    if (!memory) {
+      return [];
+    }
+    const history = [];
+    if (memory.isConsolidation) {
+      const sourceLinks = this.getLinks({ memoryId, linkType: "derived_from" });
+      for (const link of sourceLinks) {
+        const targetId = link.sourceId === memoryId ? link.targetId : link.sourceId;
+        const target = this.getById(targetId);
+        if (target) {
+          history.push(target);
+          if (target.isConsolidation) {
+            history.push(...this.getConsolidationHistory(targetId));
+          }
+        }
+      }
+    }
+    return history;
+  }
+  getConsolidatedSources(consolidationId) {
+    const memory = this.getById(consolidationId);
+    if (!memory || !memory.isConsolidation) {
+      return [];
+    }
+    const sourceLinks = this.getLinks({ memoryId: consolidationId, linkType: "derived_from" });
+    const sources = [];
+    for (const link of sourceLinks) {
+      if (link.sourceId === consolidationId) {
+        const source = this.getById(link.targetId);
+        if (source && !source.isConsolidation) {
+          sources.push(source);
+        }
+      }
+    }
+    return sources;
+  }
+  inferMemoryType(memories) {
+    const typeCounts = { episodic: 0, semantic: 0, procedural: 0 };
+    for (const m of memories) {
+      typeCounts[m.memoryType]++;
+    }
+    if (typeCounts.procedural > 0) return "procedural";
+    if (typeCounts.semantic >= typeCounts.episodic) return "semantic";
+    return "episodic";
+  }
+  mergeTags(memories) {
+    const tagSet = /* @__PURE__ */ new Set();
+    for (const m of memories) {
+      for (const tag of m.tags) {
+        tagSet.add(tag);
+      }
+    }
+    return Array.from(tagSet);
+  }
+  softDelete(input) {
+    const memory = this.getById(input.id);
+    if (!memory) return false;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const newVersion = (memory.version ?? 1) + 1;
+    const result = this.db.transaction(() => {
+      this.db.prepare(
+        `UPDATE memories 
+           SET status = 'deleted', deleted_at = ?, deleted_by = ?, version = ?, updated_at = ?
+           WHERE id = ?`
+      ).run(now, input.deletedBy ?? null, newVersion, now, input.id);
+      this.db.prepare(
+        `INSERT OR REPLACE INTO tombstones (id, memory_id, org_id, repo_id, deleted_at, deleted_by, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        uuid(),
+        input.id,
+        memory.orgId,
+        memory.repoId,
+        now,
+        input.deletedBy ?? null,
+        now
+      );
+      return true;
+    })();
+    return result;
+  }
+  hardDelete(id) {
+    const result = this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  restore(id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.transaction(() => {
+      const updateResult = this.db.prepare(
+        `UPDATE memories 
+           SET status = 'active', deleted_at = NULL, deleted_by = NULL, version = version + 1, updated_at = ?
+           WHERE id = ? AND status = 'deleted'`
+      ).run(now, id);
+      if (updateResult.changes > 0) {
+        this.db.prepare("DELETE FROM tombstones WHERE memory_id = ?").run(id);
+      }
+      return updateResult.changes > 0;
+    })();
+    return result;
+  }
+  getTombstones(orgId, repoId, sinceSyncedAt) {
+    let sql = "SELECT * FROM tombstones WHERE org_id = ? AND repo_id = ?";
+    const params = [orgId, repoId];
+    if (sinceSyncedAt) {
+      sql += " AND (synced_at IS NULL OR synced_at > ?)";
+      params.push(sinceSyncedAt.toISOString());
+    } else {
+      sql += " AND synced_at IS NULL";
+    }
+    sql += " ORDER BY deleted_at ASC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(rowToTombstone);
+  }
+  getUnsyncedTombstones(orgId, repoId) {
+    const rows = this.db.prepare(
+      "SELECT * FROM tombstones WHERE org_id = ? AND repo_id = ? AND synced_at IS NULL ORDER BY deleted_at ASC"
+    ).all(orgId, repoId);
+    return rows.map(rowToTombstone);
+  }
+  markTombstoneSynced(memoryId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare("UPDATE tombstones SET synced_at = ? WHERE memory_id = ?").run(now, memoryId);
+    return result.changes > 0;
+  }
+  applyTombstone(tombstone) {
+    const memory = this.getById(tombstone.memoryId);
+    if (!memory) {
+      this.db.prepare(
+        `INSERT OR REPLACE INTO tombstones (id, memory_id, org_id, repo_id, deleted_at, deleted_by, synced_at, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        tombstone.id,
+        tombstone.memoryId,
+        tombstone.orgId,
+        tombstone.repoId,
+        tombstone.deletedAt.toISOString(),
+        tombstone.deletedBy ?? null,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      return true;
+    }
+    return this.softDelete({
+      id: tombstone.memoryId,
+      deletedBy: tombstone.deletedBy
+    });
+  }
+  incrementVersion(id) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare("UPDATE memories SET version = version + 1, updated_at = ? WHERE id = ?").run(now, id);
+    const row = this.db.prepare("SELECT version FROM memories WHERE id = ?").get(id);
+    return row?.version ?? 1;
+  }
+  getModifiedSince(orgId, repoId, since) {
+    const rows = this.db.prepare(
+      `SELECT * FROM memories 
+         WHERE org_id = ? AND repo_id = ? AND updated_at > ?
+         ORDER BY updated_at ASC`
+    ).all(orgId, repoId, since.toISOString());
+    return rows.map(rowToMemory);
+  }
+  upsertFromRemote(memory) {
+    const existing = this.getById(memory.id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const normalizedOrgId = memory.orgId.toLowerCase();
+    const normalizedRepoId = memory.repoId.toLowerCase();
+    if (!existing) {
+      this.db.prepare(
+        `INSERT INTO memories
+          (id, org_id, repo_id, scope_type, memory_type, visibility, status, text, summary, tags, source_refs, confidence, ttl_seconds, supersedes_id, is_consolidation, consolidation_version, author_id, author_name, version, deleted_at, deleted_by, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        memory.id,
+        normalizedOrgId,
+        normalizedRepoId,
+        memory.scopeType ?? "repo",
+        memory.memoryType,
+        memory.visibility,
+        memory.status,
+        memory.text,
+        memory.summary ?? null,
+        JSON.stringify(memory.tags ?? []),
+        memory.sourceRefs ? JSON.stringify(memory.sourceRefs) : null,
+        memory.confidence ?? null,
+        memory.ttlSeconds ?? null,
+        memory.supersedesId ?? null,
+        memory.isConsolidation ? 1 : 0,
+        memory.consolidationVersion ?? null,
+        memory.authorId ?? null,
+        memory.authorName ?? null,
+        memory.version ?? 1,
+        memory.deletedAt?.toISOString() ?? null,
+        memory.deletedBy ?? null,
+        memory.createdAt.toISOString(),
+        now
+      );
+      return { action: "created", conflict: false };
+    }
+    const remoteVersion = memory.version ?? 1;
+    const localVersion = existing.version ?? 1;
+    if (remoteVersion <= localVersion) {
+      if (memory.updatedAt <= existing.updatedAt) {
+        return { action: "skipped", conflict: false };
+      }
+    }
+    const hasConflict = localVersion !== remoteVersion && existing.updatedAt > memory.updatedAt;
+    this.db.prepare(
+      `UPDATE memories SET
+          memory_type = ?, visibility = ?, status = ?, text = ?, summary = ?, tags = ?,
+          source_refs = ?, confidence = ?, ttl_seconds = ?, supersedes_id = ?,
+          is_consolidation = ?, consolidation_version = ?, author_id = ?, author_name = ?,
+          version = ?, deleted_at = ?, deleted_by = ?, updated_at = ?
+         WHERE id = ?`
+    ).run(
+      memory.memoryType,
+      memory.visibility,
+      memory.status,
+      memory.text,
+      memory.summary ?? null,
+      JSON.stringify(memory.tags ?? []),
+      memory.sourceRefs ? JSON.stringify(memory.sourceRefs) : null,
+      memory.confidence ?? null,
+      memory.ttlSeconds ?? null,
+      memory.supersedesId ?? null,
+      memory.isConsolidation ? 1 : 0,
+      memory.consolidationVersion ?? null,
+      memory.authorId ?? null,
+      memory.authorName ?? null,
+      Math.max(remoteVersion, localVersion) + 1,
+      memory.deletedAt?.toISOString() ?? null,
+      memory.deletedBy ?? null,
+      now,
+      memory.id
+    );
+    return { action: "updated", conflict: hasConflict };
+  }
+  getSyncState(memoryId) {
+    const row = this.db.prepare("SELECT * FROM sync_state WHERE memory_id = ?").get(memoryId);
+    return row ? this.rowToSyncState(row) : void 0;
+  }
+  getAllSyncStates() {
+    const rows = this.db.prepare("SELECT * FROM sync_state").all();
+    return rows.map((row) => this.rowToSyncState(row));
+  }
+  getSyncStatesByStatus(status) {
+    const rows = this.db.prepare("SELECT * FROM sync_state WHERE sync_status = ?").all(status);
+    return rows.map((row) => this.rowToSyncState(row));
+  }
+  getPendingPush() {
+    const rows = this.db.prepare(`
+        SELECT m.*, s.local_version as sync_local_version, s.remote_version as sync_remote_version,
+               s.last_pushed_at, s.last_pulled_at, s.sync_status
+        FROM memories m
+        JOIN sync_state s ON m.id = s.memory_id
+        WHERE s.sync_status = 'pending_push'
+        ORDER BY m.updated_at ASC
+      `).all();
+    return rows.map((row) => ({
+      memory: rowToMemory(row),
+      syncState: {
+        memoryId: row.id,
+        localVersion: row.sync_local_version,
+        remoteVersion: row.sync_remote_version,
+        lastPushedAt: row.last_pushed_at ? new Date(row.last_pushed_at) : void 0,
+        lastPulledAt: row.last_pulled_at ? new Date(row.last_pulled_at) : void 0,
+        syncStatus: row.sync_status
+      }
+    }));
+  }
+  getConflicts() {
+    const rows = this.db.prepare(`
+        SELECT m.*, s.local_version as sync_local_version, s.remote_version as sync_remote_version,
+               s.last_pushed_at, s.last_pulled_at, s.sync_status
+        FROM memories m
+        JOIN sync_state s ON m.id = s.memory_id
+        WHERE s.sync_status = 'conflict'
+        ORDER BY m.updated_at ASC
+      `).all();
+    return rows.map((row) => ({
+      memory: rowToMemory(row),
+      syncState: {
+        memoryId: row.id,
+        localVersion: row.sync_local_version,
+        remoteVersion: row.sync_remote_version,
+        lastPushedAt: row.last_pushed_at ? new Date(row.last_pushed_at) : void 0,
+        lastPulledAt: row.last_pulled_at ? new Date(row.last_pulled_at) : void 0,
+        syncStatus: row.sync_status
+      }
+    }));
+  }
+  setSyncState(state) {
+    this.db.prepare(`
+        INSERT OR REPLACE INTO sync_state (memory_id, local_version, remote_version, last_pushed_at, last_pulled_at, sync_status)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(
+      state.memoryId,
+      state.localVersion,
+      state.remoteVersion ?? null,
+      state.lastPushedAt?.toISOString() ?? null,
+      state.lastPulledAt?.toISOString() ?? null,
+      state.syncStatus
+    );
+  }
+  markAsPushed(memoryId, remoteVersion) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+        UPDATE sync_state 
+        SET sync_status = 'synced', remote_version = ?, last_pushed_at = ?
+        WHERE memory_id = ?
+      `).run(remoteVersion, now, memoryId);
+  }
+  markAsPulled(memoryId, localVersion) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+        UPDATE sync_state 
+        SET sync_status = 'synced', local_version = ?, last_pulled_at = ?
+        WHERE memory_id = ?
+      `).run(localVersion, now, memoryId);
+  }
+  markAsConflict(memoryId, remoteVersion) {
+    this.db.prepare(`
+        UPDATE sync_state 
+        SET sync_status = 'conflict', remote_version = ?
+        WHERE memory_id = ?
+      `).run(remoteVersion, memoryId);
+  }
+  getUntrackedMemories(orgId, repoId) {
+    const rows = this.db.prepare(`
+        SELECT m.* FROM memories m
+        LEFT JOIN sync_state s ON m.id = s.memory_id
+        WHERE m.org_id = ? AND m.repo_id = ? AND s.memory_id IS NULL
+        ORDER BY m.created_at ASC
+      `).all(orgId, repoId);
+    return rows.map(rowToMemory);
+  }
+  initSyncStateForMemory(memoryId) {
+    const memory = this.getById(memoryId);
+    if (!memory) return;
+    const existing = this.getSyncState(memoryId);
+    if (existing) return;
+    this.setSyncState({
+      memoryId,
+      localVersion: memory.version,
+      syncStatus: "pending_push"
+    });
+  }
+  getSyncSummary(orgId, repoId) {
+    const row = this.db.prepare(`
+        SELECT
+          SUM(CASE WHEN s.sync_status = 'synced' THEN 1 ELSE 0 END) as synced,
+          SUM(CASE WHEN s.sync_status = 'pending_push' THEN 1 ELSE 0 END) as pending_push,
+          SUM(CASE WHEN s.sync_status = 'pending_pull' THEN 1 ELSE 0 END) as pending_pull,
+          SUM(CASE WHEN s.sync_status = 'conflict' THEN 1 ELSE 0 END) as conflicts
+        FROM sync_state s
+        JOIN memories m ON s.memory_id = m.id
+        WHERE m.org_id = ? AND m.repo_id = ?
+      `).get(orgId, repoId);
+    return {
+      synced: row.synced ?? 0,
+      pendingPush: row.pending_push ?? 0,
+      pendingPull: row.pending_pull ?? 0,
+      conflicts: row.conflicts ?? 0
+    };
+  }
+  rowToSyncState(row) {
+    return {
+      memoryId: row.memory_id,
+      localVersion: row.local_version,
+      remoteVersion: row.remote_version,
+      lastPushedAt: row.last_pushed_at ? new Date(row.last_pushed_at) : void 0,
+      lastPulledAt: row.last_pulled_at ? new Date(row.last_pulled_at) : void 0,
+      syncStatus: row.sync_status
+    };
+  }
+  getSupersededMemoriesToSync(orgId, repoId) {
+    const rows = this.db.prepare(`
+        SELECT m.*
+        FROM memories m
+        LEFT JOIN sync_state s ON s.memory_id = m.id
+        WHERE m.org_id = ?
+          AND m.repo_id = ?
+          AND m.status = 'superseded'
+          AND m.supersedes_id IS NOT NULL
+          AND (
+            s.memory_id IS NULL
+            OR s.sync_status = 'pending_push'
+            OR (s.sync_status = 'synced' AND (s.last_pushed_at IS NULL OR s.last_pushed_at < m.updated_at))
+          )
+      `).all(orgId, repoId);
+    return rows.map((row) => ({
+      memory: rowToMemory(row),
+      newId: row.supersedes_id
+    }));
+  }
+  getLinksToSync(orgId, repoId) {
+    const rows = this.db.prepare(`
+        SELECT l.*, ms.id as source_mem_id, mt.id as target_mem_id
+        FROM memory_links l
+        JOIN memories ms ON ms.id = l.source_id
+        JOIN memories mt ON mt.id = l.target_id
+        WHERE ms.org_id = ?
+          AND ms.repo_id = ?
+          AND l.id NOT IN (SELECT link_id FROM synced_links)
+      `).all(orgId, repoId);
+    return rows.map((row) => ({
+      link: rowToLink(row),
+      sourceMemoryId: row.source_mem_id,
+      targetMemoryId: row.target_mem_id
+    }));
+  }
+  markLinkSynced(linkId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`INSERT OR IGNORE INTO synced_links (link_id, synced_at) VALUES (?, ?)`).run(linkId, now);
+  }
+  markStatusSynced(memoryId) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`UPDATE sync_state SET last_pushed_at = ? WHERE memory_id = ?`).run(now, memoryId);
+  }
+  unconsolidate(consolidationId) {
+    const memory = this.getById(consolidationId);
+    if (!memory) {
+      throw new Error(`Memory not found: ${consolidationId}`);
+    }
+    if (!memory.isConsolidation) {
+      throw new Error(`Memory ${consolidationId} is not a consolidation`);
+    }
+    const sourceLinks = this.getLinks({ memoryId: consolidationId, linkType: "derived_from" });
+    const sourceIds = sourceLinks.filter((l) => l.sourceId === consolidationId).map((l) => l.targetId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const restoredIds = [];
+    let linksRemoved = 0;
+    this.db.transaction(() => {
+      for (const sourceId of sourceIds) {
+        const source = this.getById(sourceId);
+        if (source && source.status === "superseded" && source.supersedesId === consolidationId) {
+          this.db.prepare(
+            `UPDATE memories
+               SET status = 'active', supersedes_id = NULL, version = version + 1, updated_at = ?
+               WHERE id = ?`
+          ).run(now, sourceId);
+          restoredIds.push(sourceId);
+          this.setSyncState({
+            memoryId: sourceId,
+            localVersion: (source.version ?? 1) + 1,
+            syncStatus: "pending_push"
+          });
+        }
+      }
+      const deleteLinksResult = this.db.prepare(
+        `DELETE FROM memory_links 
+           WHERE source_id = ? AND link_type = 'derived_from'`
+      ).run(consolidationId);
+      linksRemoved = deleteLinksResult.changes;
+      const deleteTargetLinksResult = this.db.prepare(
+        `DELETE FROM memory_links 
+           WHERE target_id = ?`
+      ).run(consolidationId);
+      linksRemoved += deleteTargetLinksResult.changes;
+      this.db.prepare(
+        `DELETE FROM synced_links 
+           WHERE link_id IN (
+             SELECT id FROM memory_links WHERE source_id = ? OR target_id = ?
+           )`
+      ).run(consolidationId, consolidationId);
+      this.softDelete({
+        id: consolidationId,
+        deletedBy: "unconsolidate"
+      });
+    })();
+    return {
+      restoredIds,
+      consolidationDeleted: true,
+      linksRemoved
+    };
+  }
+  cleanupOrphanLinks() {
+    const result = this.db.prepare(
+      `DELETE FROM memory_links
+         WHERE id IN (
+           SELECT ml.id FROM memory_links ml
+           LEFT JOIN memories ms ON ms.id = ml.source_id
+           LEFT JOIN memories mt ON mt.id = ml.target_id
+           WHERE ms.id IS NULL 
+              OR mt.id IS NULL
+              OR ms.status = 'deleted'
+              OR mt.status = 'deleted'
+         )`
+    ).run();
+    this.db.prepare(
+      `DELETE FROM synced_links
+         WHERE link_id NOT IN (SELECT id FROM memory_links)`
+    ).run();
+    return result.changes;
+  }
+  async storeEmbedding(memoryId, embedding, model) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const blob = serializeEmbedding(embedding);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO memory_embeddings (memory_id, embedding, model, created_at)
+         VALUES (?, ?, ?, ?)`
+    ).run(memoryId, blob, model, now);
+  }
+  async generateAndStoreEmbedding(memoryId, text, config2) {
+    try {
+      const result = await generateEmbedding(text, config2);
+      await this.storeEmbedding(memoryId, result.embedding, result.model);
+    } catch (error) {
+      console.error(`Failed to generate embedding for ${memoryId}:`, error);
+    }
+  }
+  getEmbedding(memoryId) {
+    const row = this.db.prepare("SELECT embedding FROM memory_embeddings WHERE memory_id = ?").get(memoryId);
+    if (!row) return void 0;
+    return deserializeEmbedding(row.embedding);
+  }
+  hasEmbedding(memoryId) {
+    const row = this.db.prepare("SELECT 1 FROM memory_embeddings WHERE memory_id = ?").get(memoryId);
+    return !!row;
+  }
+  getAllEmbeddings(orgId, repoId) {
+    const rows = this.db.prepare(
+      `SELECT e.memory_id, e.embedding FROM memory_embeddings e
+         JOIN memories m ON e.memory_id = m.id
+         WHERE m.org_id = ? AND m.repo_id = ? AND m.status = 'active'`
+    ).all(orgId, repoId);
+    return rows.map((row) => ({
+      memoryId: row.memory_id,
+      embedding: deserializeEmbedding(row.embedding)
+    }));
+  }
+  getMemoriesWithoutEmbeddings(orgId, repoId) {
+    const rows = this.db.prepare(
+      `SELECT m.* FROM memories m
+         LEFT JOIN memory_embeddings e ON m.id = e.memory_id
+         WHERE m.org_id = ? AND m.repo_id = ? AND m.status = 'active' AND e.memory_id IS NULL`
+    ).all(orgId, repoId);
+    return rows.map(rowToMemory);
+  }
+  async recallWithEmbeddings(query, queryEmbedding) {
+    const ftsResults = this.recall(query);
+    if (!queryEmbedding) {
+      return ftsResults;
+    }
+    const allEmbeddings = this.getAllEmbeddings(query.orgId, query.repoId);
+    if (allEmbeddings.length === 0) {
+      return ftsResults;
+    }
+    const embeddingScores = /* @__PURE__ */ new Map();
+    for (const { memoryId, embedding } of allEmbeddings) {
+      const similarity = cosineSimilarity(queryEmbedding, embedding);
+      embeddingScores.set(memoryId, Math.max(0, similarity));
+    }
+    const ftsIds = new Set(ftsResults.map((r) => r.id));
+    const k = query.k ?? 10;
+    const usageStats = this.getUsageStats(query.orgId, query.repoId);
+    const usageMap = new Map(usageStats.map((stat) => [stat.memoryId, stat]));
+    const sortedByEmbedding = Array.from(embeddingScores.entries()).filter(([id]) => !ftsIds.has(id)).sort((a, b) => b[1] - a[1]).slice(0, k);
+    const additionalMemories = [];
+    for (const [memoryId, similarity] of sortedByEmbedding) {
+      if (similarity < 0.3) continue;
+      const memory = this.getById(memoryId);
+      if (!memory || memory.status !== "active" || !query.includeExpired && memory.ttlSeconds && memory.createdAt.getTime() + memory.ttlSeconds * 1e3 <= Date.now()) {
+        continue;
+      }
+      const usage = usageMap.get(memory.id);
+      const usageBoost = computeUsageBoost(
+        usage?.count ?? 0,
+        usage?.lastUsed
+      );
+      additionalMemories.push({
+        id: memory.id,
+        memoryType: memory.memoryType,
+        text: memory.text,
+        summary: memory.summary,
+        tags: memory.tags,
+        sourceRefs: memory.sourceRefs,
+        score: computeHybridScore(0, similarity, memory.createdAt, memory.confidence, usageBoost),
+        source: "local",
+        status: memory.status,
+        supersedesId: memory.supersedesId,
+        isConsolidation: memory.isConsolidation,
+        consolidationVersion: memory.consolidationVersion
+      });
+    }
+    const hybridResults = ftsResults.map((r) => {
+      const embScore = embeddingScores.get(r.id) ?? 0;
+      const memory = this.getById(r.id);
+      if (!memory) return r;
+      const usage = usageMap.get(r.id);
+      const usageBoost = computeUsageBoost(
+        usage?.count ?? 0,
+        usage?.lastUsed
+      );
+      return {
+        ...r,
+        score: computeHybridScore(r.score, embScore, memory.createdAt, memory.confidence, usageBoost)
+      };
+    });
+    const combined = [...hybridResults, ...additionalMemories];
+    return combined.sort((a, b) => b.score - a.score).slice(0, k);
+  }
+  recordUsage(memoryId, query, sessionId) {
+    this.db.prepare(
+      `INSERT INTO memory_usage (memory_id, query, session_id) VALUES (?, ?, ?)`
+    ).run(memoryId, query ?? null, sessionId ?? null);
+  }
+  recordUsageBatch(memoryIds, query, sessionId) {
+    const stmt = this.db.prepare(
+      `INSERT INTO memory_usage (memory_id, query, session_id) VALUES (?, ?, ?)`
+    );
+    const insertMany = this.db.transaction((ids) => {
+      for (const id of ids) {
+        stmt.run(id, query ?? null, sessionId ?? null);
+      }
+    });
+    insertMany(memoryIds);
+  }
+  getUsageCount(memoryId) {
+    const row = this.db.prepare("SELECT COUNT(*) as cnt FROM memory_usage WHERE memory_id = ?").get(memoryId);
+    return row.cnt;
+  }
+  getUsageStats(orgId, repoId) {
+    const rows = this.db.prepare(
+      `SELECT u.memory_id, COUNT(*) as cnt, MAX(u.recalled_at) as last_used
+         FROM memory_usage u
+         JOIN memories m ON u.memory_id = m.id
+         WHERE m.org_id = ? AND m.repo_id = ?
+         GROUP BY u.memory_id
+         ORDER BY cnt DESC`
+    ).all(orgId, repoId);
+    return rows.map((row) => ({
+      memoryId: row.memory_id,
+      count: row.cnt,
+      lastUsed: new Date(row.last_used)
+    }));
+  }
+  getTopUsedMemories(orgId, repoId, limit = 10) {
+    const rows = this.db.prepare(
+      `SELECT m.*, COUNT(u.id) as usage_count
+         FROM memories m
+         LEFT JOIN memory_usage u ON m.id = u.memory_id
+         WHERE m.org_id = ? AND m.repo_id = ? AND m.status = 'active'
+         GROUP BY m.id
+         ORDER BY usage_count DESC
+         LIMIT ?`
+    ).all(orgId, repoId, limit);
+    return rows.map((row) => ({
+      memory: rowToMemory(row),
+      usageCount: row.usage_count
+    }));
+  }
+  getUnusedMemories(orgId, repoId, daysSinceCreation = 30) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - daysSinceCreation);
+    const rows = this.db.prepare(
+      `SELECT m.* FROM memories m
+         LEFT JOIN memory_usage u ON m.id = u.memory_id
+         WHERE m.org_id = ? 
+           AND m.repo_id = ? 
+           AND m.status = 'active'
+           AND m.created_at < ?
+           AND u.id IS NULL`
+    ).all(orgId, repoId, cutoff.toISOString());
+    return rows.map(rowToMemory);
+  }
+  getEmbeddingStats(orgId, repoId) {
+    const row = this.db.prepare(
+      `SELECT 
+           COUNT(m.id) as total,
+           COUNT(e.memory_id) as with_embedding
+         FROM memories m
+         LEFT JOIN memory_embeddings e ON m.id = e.memory_id
+         WHERE m.org_id = ? AND m.repo_id = ? AND m.status = 'active'`
+    ).get(orgId, repoId);
+    return {
+      total: row.total,
+      withEmbedding: row.with_embedding,
+      withoutEmbedding: row.total - row.with_embedding
+    };
+  }
+  createCurationSuggestion(input) {
+    const id = uuid();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const normalizedOrgId = input.orgId.toLowerCase();
+    const normalizedRepoId = input.repoId.toLowerCase();
+    this.db.prepare(
+      `INSERT INTO curation_suggestions
+        (id, org_id, repo_id, type, priority, status, memory_ids, reason, confidence, payload, created_by, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      normalizedOrgId,
+      normalizedRepoId,
+      input.type,
+      input.priority,
+      JSON.stringify(input.memoryIds),
+      input.reason,
+      input.confidence,
+      input.payload ? JSON.stringify(input.payload) : null,
+      input.createdBy ?? null,
+      now,
+      now
+    );
+    return this.getCurationSuggestionById(id);
+  }
+  listCurationSuggestions(query) {
+    const clauses = ["org_id = ?", "repo_id = ?"];
+    const params = [query.orgId.toLowerCase(), query.repoId.toLowerCase()];
+    if (query.status && query.status.length > 0) {
+      clauses.push(`status IN (${query.status.map(() => "?").join(",")})`);
+      params.push(...query.status);
+    }
+    if (query.types && query.types.length > 0) {
+      clauses.push(`type IN (${query.types.map(() => "?").join(",")})`);
+      params.push(...query.types);
+    }
+    const limit = Math.min(query.limit ?? 100, 500);
+    const offset = query.offset ?? 0;
+    params.push(limit, offset);
+    const rows = this.db.prepare(
+      `SELECT * FROM curation_suggestions
+         WHERE ${clauses.join(" AND ")}
+         ORDER BY created_at DESC
+         LIMIT ? OFFSET ?`
+    ).all(...params);
+    return rows.map(rowToCurationSuggestion);
+  }
+  reviewCurationSuggestion(input) {
+    const existing = this.getCurationSuggestionById(input.id);
+    if (!existing) {
+      throw new Error(`Curation suggestion not found: ${input.id}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      `UPDATE curation_suggestions
+         SET status = ?, reviewed_by = ?, review_note = ?, reviewed_at = ?,
+             applied_at = CASE WHEN ? = 'applied' THEN ? ELSE applied_at END,
+             updated_at = ?
+         WHERE id = ?`
+    ).run(
+      input.status,
+      input.reviewedBy ?? null,
+      input.reviewNote ?? null,
+      now,
+      input.status,
+      now,
+      now,
+      input.id
+    );
+    return this.getCurationSuggestionById(input.id);
+  }
+  getCurationSuggestionById(id) {
+    const row = this.db.prepare("SELECT * FROM curation_suggestions WHERE id = ?").get(id);
+    return row ? rowToCurationSuggestion(row) : void 0;
+  }
+  resetAll() {
+    const result = this.db.transaction(() => {
+      const embeddingsDeleted = this.db.prepare("DELETE FROM memory_embeddings").run().changes;
+      const linksDeleted = this.db.prepare("DELETE FROM memory_links").run().changes;
+      this.db.prepare("DELETE FROM synced_links").run();
+      this.db.prepare("DELETE FROM sync_state").run();
+      this.db.prepare("DELETE FROM tombstones").run();
+      this.db.prepare("DELETE FROM memory_usage").run();
+      const memoriesDeleted = this.db.prepare("DELETE FROM memories").run().changes;
+      this.db.exec("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+      return { memoriesDeleted, linksDeleted, embeddingsDeleted };
+    })();
+    return result;
+  }
+  clearEmbeddings() {
+    return this.db.prepare("DELETE FROM memory_embeddings").run().changes;
+  }
+  close() {
+    this.db.close();
+  }
+};
+var config = {
+  "previewFeatures": [],
+  "clientVersion": "7.8.0",
+  "engineVersion": "3c6e192761c0362d496ed980de936e2f3cebcd3a",
+  "activeProvider": "postgresql",
+  "inlineSchema": 'datasource db {\n  provider = "postgresql"\n}\n\ngenerator client {\n  provider = "prisma-client"\n  output   = "../packages/db/src/generated/prisma"\n}\n\nmodel Memory {\n  id           String    @id @default(uuid()) @db.Uuid\n  orgId        String    @map("org_id")\n  repoId       String    @map("repo_id")\n  scopeType    String    @default("repo") @map("scope_type")\n  memoryType   String    @map("memory_type")\n  visibility   String    @default("repo")\n  status       String    @default("active")\n  text         String\n  summary      String?\n  tags         String[]\n  sourceRefs   Json?     @map("source_refs")\n  confidence   Float?\n  ttlSeconds   Int?      @map("ttl_seconds")\n  supersedesId String?   @map("supersedes_id") @db.Uuid\n  version      Int       @default(1)\n  deletedAt    DateTime? @map("deleted_at")\n  deletedBy    String?   @map("deleted_by")\n  createdAt    DateTime  @default(now()) @map("created_at")\n  updatedAt    DateTime  @updatedAt @map("updated_at")\n\n  supersedes   Memory?  @relation("Supersedes", fields: [supersedesId], references: [id])\n  supersededBy Memory[] @relation("Supersedes")\n\n  sourceLinks MemoryLink[]     @relation("SourceLinks")\n  targetLinks MemoryLink[]     @relation("TargetLinks")\n  embedding   MemoryEmbedding?\n  usages      MemoryUsage[]\n\n  @@index([orgId, repoId, memoryType, status])\n  @@index([orgId, repoId, updatedAt])\n  @@index([deletedAt])\n  @@map("memories")\n}\n\nmodel MemoryEmbedding {\n  memoryId  String   @id @map("memory_id") @db.Uuid\n  embedding Bytes\n  model     String\n  createdAt DateTime @default(now()) @map("created_at")\n\n  memory Memory @relation(fields: [memoryId], references: [id], onDelete: Cascade)\n\n  @@map("memory_embeddings")\n}\n\nmodel MemoryUsage {\n  id         Int      @id @default(autoincrement())\n  memoryId   String   @map("memory_id") @db.Uuid\n  recalledAt DateTime @default(now()) @map("recalled_at")\n  query      String?\n  sessionId  String?  @map("session_id")\n\n  memory Memory @relation(fields: [memoryId], references: [id], onDelete: Cascade)\n\n  @@index([memoryId])\n  @@index([recalledAt])\n  @@map("memory_usage")\n}\n\nmodel MemoryLink {\n  id        String   @id @default(uuid()) @db.Uuid\n  sourceId  String   @map("source_id") @db.Uuid\n  targetId  String   @map("target_id") @db.Uuid\n  linkType  String   @map("link_type")\n  metadata  Json?\n  createdAt DateTime @default(now()) @map("created_at")\n\n  source Memory @relation("SourceLinks", fields: [sourceId], references: [id], onDelete: Cascade)\n  target Memory @relation("TargetLinks", fields: [targetId], references: [id], onDelete: Cascade)\n\n  @@unique([sourceId, targetId, linkType])\n  @@map("memory_links")\n}\n\nmodel Tombstone {\n  id        String    @id @default(uuid()) @db.Uuid\n  memoryId  String    @map("memory_id") @db.Uuid\n  orgId     String    @map("org_id")\n  repoId    String    @map("repo_id")\n  deletedAt DateTime  @map("deleted_at")\n  deletedBy String?   @map("deleted_by")\n  syncedAt  DateTime? @map("synced_at")\n  createdAt DateTime  @default(now()) @map("created_at")\n\n  @@unique([memoryId])\n  @@index([orgId, repoId, syncedAt])\n  @@map("tombstones")\n}\n\nmodel ApiKey {\n  id         String    @id @default(uuid()) @db.Uuid\n  key        String    @unique\n  name       String\n  label      String?\n  orgId      String    @map("org_id")\n  repoId     String?   @map("repo_id")\n  userId     String?   @map("user_id") @db.Uuid\n  createdBy  String?   @map("created_by") @db.Uuid\n  isActive   Boolean   @default(true) @map("is_active")\n  createdAt  DateTime  @default(now()) @map("created_at")\n  lastUsedAt DateTime? @map("last_used_at")\n\n  user User?       @relation(fields: [userId], references: [id])\n  logs ApiKeyLog[]\n\n  @@index([key])\n  @@index([orgId])\n  @@index([userId])\n  @@map("api_keys")\n}\n\nmodel ApiKeyLog {\n  id        String   @id @default(uuid()) @db.Uuid\n  apiKeyId  String   @map("api_key_id") @db.Uuid\n  operation String\n  memoryId  String?  @map("memory_id") @db.Uuid\n  orgId     String   @map("org_id")\n  repoId    String   @map("repo_id")\n  query     String?\n  metadata  Json?\n  createdAt DateTime @default(now()) @map("created_at")\n\n  apiKey ApiKey @relation(fields: [apiKeyId], references: [id], onDelete: Cascade)\n\n  @@index([apiKeyId])\n  @@index([createdAt])\n  @@index([memoryId])\n  @@index([orgId, repoId])\n  @@map("api_key_logs")\n}\n\nmodel User {\n  id          String   @id @default(uuid()) @db.Uuid\n  githubId    Int      @unique @map("github_id")\n  githubLogin String   @map("github_login")\n  name        String?\n  email       String?\n  avatarUrl   String?  @map("avatar_url")\n  isAdmin     Boolean  @default(false) @map("is_admin")\n  createdAt   DateTime @default(now()) @map("created_at")\n  updatedAt   DateTime @updatedAt @map("updated_at")\n\n  apiKeys    ApiKey[]\n  repoAccess UserRepoAccess[]\n\n  @@map("users")\n}\n\nmodel UserRepoAccess {\n  id         String   @id @default(uuid()) @db.Uuid\n  userId     String   @map("user_id") @db.Uuid\n  orgId      String   @map("org_id")\n  repoId     String   @map("repo_id")\n  permission String\n  grantedAt  DateTime @default(now()) @map("granted_at")\n  grantedBy  String?  @map("granted_by") @db.Uuid\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([userId, orgId, repoId])\n  @@index([orgId, repoId])\n  @@map("user_repo_access")\n}\n',
+  "runtimeDataModel": {
+    "models": {},
+    "enums": {},
+    "types": {}
+  },
+  "parameterizationSchema": {
+    "strings": [],
+    "graph": ""
+  }
+};
+config.runtimeDataModel = JSON.parse('{"models":{"Memory":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"orgId","kind":"scalar","type":"String","dbName":"org_id"},{"name":"repoId","kind":"scalar","type":"String","dbName":"repo_id"},{"name":"scopeType","kind":"scalar","type":"String","dbName":"scope_type"},{"name":"memoryType","kind":"scalar","type":"String","dbName":"memory_type"},{"name":"visibility","kind":"scalar","type":"String"},{"name":"status","kind":"scalar","type":"String"},{"name":"text","kind":"scalar","type":"String"},{"name":"summary","kind":"scalar","type":"String"},{"name":"tags","kind":"scalar","type":"String"},{"name":"sourceRefs","kind":"scalar","type":"Json","dbName":"source_refs"},{"name":"confidence","kind":"scalar","type":"Float"},{"name":"ttlSeconds","kind":"scalar","type":"Int","dbName":"ttl_seconds"},{"name":"supersedesId","kind":"scalar","type":"String","dbName":"supersedes_id"},{"name":"version","kind":"scalar","type":"Int"},{"name":"deletedAt","kind":"scalar","type":"DateTime","dbName":"deleted_at"},{"name":"deletedBy","kind":"scalar","type":"String","dbName":"deleted_by"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"updatedAt","kind":"scalar","type":"DateTime","dbName":"updated_at"},{"name":"supersedes","kind":"object","type":"Memory","relationName":"Supersedes"},{"name":"supersededBy","kind":"object","type":"Memory","relationName":"Supersedes"},{"name":"sourceLinks","kind":"object","type":"MemoryLink","relationName":"SourceLinks"},{"name":"targetLinks","kind":"object","type":"MemoryLink","relationName":"TargetLinks"},{"name":"embedding","kind":"object","type":"MemoryEmbedding","relationName":"MemoryToMemoryEmbedding"},{"name":"usages","kind":"object","type":"MemoryUsage","relationName":"MemoryToMemoryUsage"}],"dbName":"memories"},"MemoryEmbedding":{"fields":[{"name":"memoryId","kind":"scalar","type":"String","dbName":"memory_id"},{"name":"embedding","kind":"scalar","type":"Bytes"},{"name":"model","kind":"scalar","type":"String"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"memory","kind":"object","type":"Memory","relationName":"MemoryToMemoryEmbedding"}],"dbName":"memory_embeddings"},"MemoryUsage":{"fields":[{"name":"id","kind":"scalar","type":"Int"},{"name":"memoryId","kind":"scalar","type":"String","dbName":"memory_id"},{"name":"recalledAt","kind":"scalar","type":"DateTime","dbName":"recalled_at"},{"name":"query","kind":"scalar","type":"String"},{"name":"sessionId","kind":"scalar","type":"String","dbName":"session_id"},{"name":"memory","kind":"object","type":"Memory","relationName":"MemoryToMemoryUsage"}],"dbName":"memory_usage"},"MemoryLink":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"sourceId","kind":"scalar","type":"String","dbName":"source_id"},{"name":"targetId","kind":"scalar","type":"String","dbName":"target_id"},{"name":"linkType","kind":"scalar","type":"String","dbName":"link_type"},{"name":"metadata","kind":"scalar","type":"Json"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"source","kind":"object","type":"Memory","relationName":"SourceLinks"},{"name":"target","kind":"object","type":"Memory","relationName":"TargetLinks"}],"dbName":"memory_links"},"Tombstone":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"memoryId","kind":"scalar","type":"String","dbName":"memory_id"},{"name":"orgId","kind":"scalar","type":"String","dbName":"org_id"},{"name":"repoId","kind":"scalar","type":"String","dbName":"repo_id"},{"name":"deletedAt","kind":"scalar","type":"DateTime","dbName":"deleted_at"},{"name":"deletedBy","kind":"scalar","type":"String","dbName":"deleted_by"},{"name":"syncedAt","kind":"scalar","type":"DateTime","dbName":"synced_at"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"}],"dbName":"tombstones"},"ApiKey":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"key","kind":"scalar","type":"String"},{"name":"name","kind":"scalar","type":"String"},{"name":"label","kind":"scalar","type":"String"},{"name":"orgId","kind":"scalar","type":"String","dbName":"org_id"},{"name":"repoId","kind":"scalar","type":"String","dbName":"repo_id"},{"name":"userId","kind":"scalar","type":"String","dbName":"user_id"},{"name":"createdBy","kind":"scalar","type":"String","dbName":"created_by"},{"name":"isActive","kind":"scalar","type":"Boolean","dbName":"is_active"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"lastUsedAt","kind":"scalar","type":"DateTime","dbName":"last_used_at"},{"name":"user","kind":"object","type":"User","relationName":"ApiKeyToUser"},{"name":"logs","kind":"object","type":"ApiKeyLog","relationName":"ApiKeyToApiKeyLog"}],"dbName":"api_keys"},"ApiKeyLog":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"apiKeyId","kind":"scalar","type":"String","dbName":"api_key_id"},{"name":"operation","kind":"scalar","type":"String"},{"name":"memoryId","kind":"scalar","type":"String","dbName":"memory_id"},{"name":"orgId","kind":"scalar","type":"String","dbName":"org_id"},{"name":"repoId","kind":"scalar","type":"String","dbName":"repo_id"},{"name":"query","kind":"scalar","type":"String"},{"name":"metadata","kind":"scalar","type":"Json"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"apiKey","kind":"object","type":"ApiKey","relationName":"ApiKeyToApiKeyLog"}],"dbName":"api_key_logs"},"User":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"githubId","kind":"scalar","type":"Int","dbName":"github_id"},{"name":"githubLogin","kind":"scalar","type":"String","dbName":"github_login"},{"name":"name","kind":"scalar","type":"String"},{"name":"email","kind":"scalar","type":"String"},{"name":"avatarUrl","kind":"scalar","type":"String","dbName":"avatar_url"},{"name":"isAdmin","kind":"scalar","type":"Boolean","dbName":"is_admin"},{"name":"createdAt","kind":"scalar","type":"DateTime","dbName":"created_at"},{"name":"updatedAt","kind":"scalar","type":"DateTime","dbName":"updated_at"},{"name":"apiKeys","kind":"object","type":"ApiKey","relationName":"ApiKeyToUser"},{"name":"repoAccess","kind":"object","type":"UserRepoAccess","relationName":"UserToUserRepoAccess"}],"dbName":"users"},"UserRepoAccess":{"fields":[{"name":"id","kind":"scalar","type":"String"},{"name":"userId","kind":"scalar","type":"String","dbName":"user_id"},{"name":"orgId","kind":"scalar","type":"String","dbName":"org_id"},{"name":"repoId","kind":"scalar","type":"String","dbName":"repo_id"},{"name":"permission","kind":"scalar","type":"String"},{"name":"grantedAt","kind":"scalar","type":"DateTime","dbName":"granted_at"},{"name":"grantedBy","kind":"scalar","type":"String","dbName":"granted_by"},{"name":"user","kind":"object","type":"User","relationName":"UserToUserRepoAccess"}],"dbName":"user_repo_access"}},"enums":{},"types":{}}');
+config.parameterizationSchema = {
+  strings: JSON.parse('["where","supersedes","orderBy","cursor","supersededBy","source","target","sourceLinks","targetLinks","memory","embedding","usages","_count","Memory.findUnique","Memory.findUniqueOrThrow","Memory.findFirst","Memory.findFirstOrThrow","Memory.findMany","data","Memory.createOne","Memory.createMany","Memory.createManyAndReturn","Memory.updateOne","Memory.updateMany","Memory.updateManyAndReturn","create","update","Memory.upsertOne","Memory.deleteOne","Memory.deleteMany","having","_avg","_sum","_min","_max","Memory.groupBy","Memory.aggregate","MemoryEmbedding.findUnique","MemoryEmbedding.findUniqueOrThrow","MemoryEmbedding.findFirst","MemoryEmbedding.findFirstOrThrow","MemoryEmbedding.findMany","MemoryEmbedding.createOne","MemoryEmbedding.createMany","MemoryEmbedding.createManyAndReturn","MemoryEmbedding.updateOne","MemoryEmbedding.updateMany","MemoryEmbedding.updateManyAndReturn","MemoryEmbedding.upsertOne","MemoryEmbedding.deleteOne","MemoryEmbedding.deleteMany","MemoryEmbedding.groupBy","MemoryEmbedding.aggregate","MemoryUsage.findUnique","MemoryUsage.findUniqueOrThrow","MemoryUsage.findFirst","MemoryUsage.findFirstOrThrow","MemoryUsage.findMany","MemoryUsage.createOne","MemoryUsage.createMany","MemoryUsage.createManyAndReturn","MemoryUsage.updateOne","MemoryUsage.updateMany","MemoryUsage.updateManyAndReturn","MemoryUsage.upsertOne","MemoryUsage.deleteOne","MemoryUsage.deleteMany","MemoryUsage.groupBy","MemoryUsage.aggregate","MemoryLink.findUnique","MemoryLink.findUniqueOrThrow","MemoryLink.findFirst","MemoryLink.findFirstOrThrow","MemoryLink.findMany","MemoryLink.createOne","MemoryLink.createMany","MemoryLink.createManyAndReturn","MemoryLink.updateOne","MemoryLink.updateMany","MemoryLink.updateManyAndReturn","MemoryLink.upsertOne","MemoryLink.deleteOne","MemoryLink.deleteMany","MemoryLink.groupBy","MemoryLink.aggregate","Tombstone.findUnique","Tombstone.findUniqueOrThrow","Tombstone.findFirst","Tombstone.findFirstOrThrow","Tombstone.findMany","Tombstone.createOne","Tombstone.createMany","Tombstone.createManyAndReturn","Tombstone.updateOne","Tombstone.updateMany","Tombstone.updateManyAndReturn","Tombstone.upsertOne","Tombstone.deleteOne","Tombstone.deleteMany","Tombstone.groupBy","Tombstone.aggregate","apiKeys","user","repoAccess","apiKey","logs","ApiKey.findUnique","ApiKey.findUniqueOrThrow","ApiKey.findFirst","ApiKey.findFirstOrThrow","ApiKey.findMany","ApiKey.createOne","ApiKey.createMany","ApiKey.createManyAndReturn","ApiKey.updateOne","ApiKey.updateMany","ApiKey.updateManyAndReturn","ApiKey.upsertOne","ApiKey.deleteOne","ApiKey.deleteMany","ApiKey.groupBy","ApiKey.aggregate","ApiKeyLog.findUnique","ApiKeyLog.findUniqueOrThrow","ApiKeyLog.findFirst","ApiKeyLog.findFirstOrThrow","ApiKeyLog.findMany","ApiKeyLog.createOne","ApiKeyLog.createMany","ApiKeyLog.createManyAndReturn","ApiKeyLog.updateOne","ApiKeyLog.updateMany","ApiKeyLog.updateManyAndReturn","ApiKeyLog.upsertOne","ApiKeyLog.deleteOne","ApiKeyLog.deleteMany","ApiKeyLog.groupBy","ApiKeyLog.aggregate","User.findUnique","User.findUniqueOrThrow","User.findFirst","User.findFirstOrThrow","User.findMany","User.createOne","User.createMany","User.createManyAndReturn","User.updateOne","User.updateMany","User.updateManyAndReturn","User.upsertOne","User.deleteOne","User.deleteMany","User.groupBy","User.aggregate","UserRepoAccess.findUnique","UserRepoAccess.findUniqueOrThrow","UserRepoAccess.findFirst","UserRepoAccess.findFirstOrThrow","UserRepoAccess.findMany","UserRepoAccess.createOne","UserRepoAccess.createMany","UserRepoAccess.createManyAndReturn","UserRepoAccess.updateOne","UserRepoAccess.updateMany","UserRepoAccess.updateManyAndReturn","UserRepoAccess.upsertOne","UserRepoAccess.deleteOne","UserRepoAccess.deleteMany","UserRepoAccess.groupBy","UserRepoAccess.aggregate","AND","OR","NOT","id","userId","orgId","repoId","permission","grantedAt","grantedBy","equals","in","notIn","lt","lte","gt","gte","not","contains","startsWith","endsWith","githubId","githubLogin","name","email","avatarUrl","isAdmin","createdAt","updatedAt","every","some","none","apiKeyId","operation","memoryId","query","metadata","string_contains","string_starts_with","string_ends_with","array_starts_with","array_ends_with","array_contains","key","label","createdBy","isActive","lastUsedAt","userId_orgId_repoId","deletedAt","deletedBy","syncedAt","sourceId","targetId","linkType","recalledAt","sessionId","model","scopeType","memoryType","visibility","status","text","summary","tags","sourceRefs","confidence","ttlSeconds","supersedesId","version","has","hasEvery","hasSome","sourceId_targetId_linkType","is","isNot","connectOrCreate","upsert","createMany","set","disconnect","delete","connect","updateMany","deleteMany","increment","decrement","multiply","divide","push"]'),
+  graph: "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"
+};
+async function decodeBase64AsWasm(wasmBase64) {
+  const { Buffer: Buffer2 } = await import("buffer");
+  const wasmArray = Buffer2.from(wasmBase64, "base64");
+  return new WebAssembly.Module(wasmArray);
+}
+config.compilerWasm = {
+  getRuntime: async () => await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.mjs"),
+  getQueryCompilerWasmModule: async () => {
+    const { wasm } = await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.wasm-base64.mjs");
+    return await decodeBase64AsWasm(wasm);
+  },
+  importName: "./query_compiler_fast_bg.js"
+};
+function getPrismaClientClass() {
+  return runtime.getPrismaClient(config);
+}
+var getExtensionContext = runtime2.Extensions.getExtensionContext;
+var NullTypes2 = {
+  DbNull: runtime2.NullTypes.DbNull,
+  JsonNull: runtime2.NullTypes.JsonNull,
+  AnyNull: runtime2.NullTypes.AnyNull
+};
+var TransactionIsolationLevel = runtime2.makeStrictEnum({
+  ReadUncommitted: "ReadUncommitted",
+  ReadCommitted: "ReadCommitted",
+  RepeatableRead: "RepeatableRead",
+  Serializable: "Serializable"
+});
+var defineExtension = runtime2.Extensions.defineExtension;
+globalThis["__dirname"] = path22.dirname(fileURLToPath(import.meta.url));
+var PrismaClient = getPrismaClientClass();
+
+export {
+  __require,
+  resolveLifecycleConfig,
+  applyLifecycleDefaults,
+  LifecycleScheduler,
+  mergeAndRank,
+  resolveVisibility,
+  generateEmbedding,
+  computeRepositoryHealth,
+  generateSuggestions,
+  persistReviewableSuggestions,
+  formatSuggestion,
+  findConsolidationCandidates,
+  executeConsolidation,
+  formatCandidatePreview,
+  buildAutoLinkQuery,
+  getNotifications,
+  formatNotificationsSummary,
+  runLocalLifecycleMaintenance,
+  MEMORY_TEMPLATES,
+  getTemplate,
+  applyTemplate,
+  formatTemplateList,
+  validateMemoryType,
+  parseConfidence,
+  parseThreshold,
+  parseTtl,
+  parsePositiveInt,
+  detectGitInfo,
+  getDataDir,
+  getDbPath,
+  getConfigPath,
+  isInitialized,
+  findRepoRoot,
+  loadConfig,
+  saveConfig,
+  defaultConfig,
+  RemoteClient,
+  LocalStore
+};
+//# sourceMappingURL=chunk-CKUDYQYP.js.map