@ordinatio/entities 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2265 @@
+import {
+  AGENTKNOW_ERRORS,
+  ContactAlreadyConvertedError,
+  ContactExistsError,
+  ContactNotFoundError,
+  KNOWLEDGE_ERRORS,
+  agentKnowledgeError,
+  checkConstraints,
+  evaluateConstraint,
+  fireObservers,
+  knowledgeError
+} from "./chunk-QXBSEBJW.mjs";
+
+// src/knowledge/field-definitions.ts
+import { Prisma } from "@prisma/client";
+async function getFieldDefinitions(db, entityType, status) {
+  try {
+    const fields = await db.entityFieldDefinition.findMany({
+      where: {
+        ...entityType ? { entityType } : {},
+        ...status ? { status } : { status: { not: "dismissed" } },
+        isActive: true
+      },
+      orderBy: [{ category: "asc" }, { sortOrder: "asc" }, { label: "asc" }]
+    });
+    const grouped = {};
+    for (const field of fields) {
+      if (!grouped[field.category]) grouped[field.category] = [];
+      grouped[field.category].push(field);
+    }
+    return { fields, grouped };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_300", { entityType, status, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function createFieldDefinition(db, input, callbacks) {
+  try {
+    const field = await db.entityFieldDefinition.create({
+      data: {
+        entityType: input.entityType,
+        key: input.key,
+        label: input.label,
+        dataType: input.dataType,
+        category: input.category,
+        enumOptions: input.enumOptions ?? Prisma.JsonNull,
+        extractionHint: input.extractionHint ?? null,
+        sortOrder: input.sortOrder ?? 0,
+        status: "approved"
+      }
+    });
+    try {
+      await callbacks?.logActivity?.(
+        "KNOWLEDGE_FIELD_CREATED",
+        `Knowledge field "${input.label}" created for ${input.entityType}`
+      );
+    } catch {
+    }
+    return field;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_301", { input, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function updateFieldDefinition(db, id, input, callbacks) {
+  try {
+    const existing = await db.entityFieldDefinition.findUnique({ where: { id } });
+    if (!existing) return null;
+    const field = await db.entityFieldDefinition.update({
+      where: { id },
+      data: {
+        ...input.label !== void 0 ? { label: input.label } : {},
+        ...input.category !== void 0 ? { category: input.category } : {},
+        ...input.enumOptions !== void 0 ? { enumOptions: input.enumOptions ?? Prisma.JsonNull } : {},
+        ...input.extractionHint !== void 0 ? { extractionHint: input.extractionHint } : {},
+        ...input.status !== void 0 ? { status: input.status } : {},
+        ...input.mergedIntoId !== void 0 ? { mergedIntoId: input.mergedIntoId } : {},
+        ...input.sortOrder !== void 0 ? { sortOrder: input.sortOrder } : {},
+        ...input.isActive !== void 0 ? { isActive: input.isActive } : {}
+      }
+    });
+    if (input.status && input.status !== existing.status) {
+      const actionMap = {
+        approved: "KNOWLEDGE_FIELD_APPROVED",
+        dismissed: "KNOWLEDGE_FIELD_DISMISSED"
+      };
+      const action = actionMap[input.status];
+      if (action) {
+        try {
+          await callbacks?.logActivity?.(action, `Knowledge field "${existing.label}" ${input.status}`);
+        } catch {
+        }
+      }
+    }
+    return field;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_302", { id, input, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getFieldDefinitionById(db, id) {
+  return db.entityFieldDefinition.findUnique({ where: { id } });
+}
+
+// src/knowledge/ledger.ts
+async function getEntityFields(db, entityType, entityId) {
+  try {
+    const entries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        supersededAt: null
+      },
+      include: {
+        field: true
+      },
+      orderBy: { createdAt: "desc" }
+    });
+    const grouped = {};
+    for (const entry of entries) {
+      const cat = entry.field.category;
+      if (!grouped[cat]) grouped[cat] = [];
+      grouped[cat].push({
+        fieldId: entry.fieldId,
+        key: entry.field.key,
+        label: entry.field.label,
+        dataType: entry.field.dataType,
+        category: cat,
+        value: entry.value,
+        confidence: Number(entry.confidence),
+        source: entry.source,
+        updatedAt: entry.createdAt
+      });
+    }
+    return { entries, grouped };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_310", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function setEntityFields(db, entityType, entityId, fields, source, sourceId, confidence = 1, setBy, callbacks) {
+  try {
+    const fieldKeys = Object.keys(fields);
+    const fieldDefs = await db.entityFieldDefinition.findMany({
+      where: {
+        entityType,
+        key: { in: fieldKeys },
+        isActive: true,
+        status: "approved"
+      }
+    });
+    const defMap = new Map(fieldDefs.map((d) => [d.key, d]));
+    const results = [];
+    const skipped = [];
+    for (const [key, value] of Object.entries(fields)) {
+      const def = defMap.get(key);
+      if (!def) {
+        skipped.push(key);
+        continue;
+      }
+      await db.knowledgeLedgerEntry.updateMany({
+        where: {
+          fieldId: def.id,
+          entityType,
+          entityId,
+          supersededAt: null
+        },
+        data: { supersededAt: /* @__PURE__ */ new Date() }
+      });
+      const entry = await db.knowledgeLedgerEntry.create({
+        data: {
+          fieldId: def.id,
+          entityType,
+          entityId,
+          value,
+          confidence,
+          source,
+          sourceId: sourceId ?? null,
+          setBy: setBy ?? null
+        }
+      });
+      results.push({ key, entryId: entry.id });
+    }
+    if (skipped.length > 0) {
+      const err = knowledgeError("KNOWLEDGE_313", { entityType, entityId, skippedKeys: skipped });
+      console.warn(`[${err.ref}] ${err.description}`, skipped);
+    }
+    if (results.length > 0) {
+      try {
+        await callbacks?.logActivity?.(
+          "KNOWLEDGE_VALUE_SET",
+          `${results.length} knowledge field(s) set on ${entityType} ${entityId}`,
+          entityType === "client" ? { clientId: entityId } : void 0
+        );
+      } catch {
+      }
+      try {
+        const { fireObservers: fireObservers2 } = await import("./observer-YUTEGG4S.mjs");
+        await fireObservers2(db, entityType, entityId, results.map((r) => r.key), callbacks);
+      } catch {
+      }
+    }
+    return { written: results, skipped };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_311", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getFieldHistory(db, entityType, entityId, fieldId, limit = 50) {
+  try {
+    const entries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        ...fieldId ? { fieldId } : {}
+      },
+      include: { field: true },
+      orderBy: { createdAt: "desc" },
+      take: limit
+    });
+    return entries;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_312", { entityType, entityId, fieldId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/search.ts
+async function searchByFields(db, entityType, filters, limit = 50) {
+  try {
+    const filterEntries = Object.entries(filters);
+    let matchingEntityIds = null;
+    for (const [key, value] of filterEntries) {
+      const fieldDef = await db.entityFieldDefinition.findFirst({
+        where: { entityType, key, isActive: true }
+      });
+      if (!fieldDef) continue;
+      const entries = await db.knowledgeLedgerEntry.findMany({
+        where: {
+          fieldId: fieldDef.id,
+          entityType,
+          supersededAt: null,
+          value: { equals: value }
+        },
+        select: { entityId: true },
+        distinct: ["entityId"]
+      });
+      const ids = entries.map((e) => e.entityId);
+      if (matchingEntityIds === null) {
+        matchingEntityIds = ids;
+      } else {
+        const idSet = new Set(ids);
+        matchingEntityIds = matchingEntityIds.filter((id) => idSet.has(id));
+      }
+      if (matchingEntityIds.length === 0) break;
+    }
+    const entityIds = (matchingEntityIds ?? []).slice(0, limit);
+    return { entityIds, total: matchingEntityIds?.length ?? 0 };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_305", { entityType, filters, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function logSearchQuery(db, input) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    await db.searchQueryLog.create({
+      data: {
+        query: input.query,
+        source: input.source,
+        userId: input.userId ?? null,
+        entityType: input.entityType ?? null,
+        resultCount: input.resultCount ?? null,
+        hourOfDay: now.getHours(),
+        dayOfWeek: now.getDay(),
+        monthOfYear: now.getMonth() + 1,
+        weekOfYear: getWeekOfYear(now)
+      }
+    });
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_320", { input, error: String(error) });
+    console.warn(`[${err.ref}] ${err.description}`);
+  }
+}
+function getWeekOfYear(date) {
+  const start = new Date(date.getFullYear(), 0, 1);
+  const diff = date.getTime() - start.getTime();
+  const oneWeek = 7 * 24 * 60 * 60 * 1e3;
+  return Math.ceil(diff / oneWeek + 1);
+}
+
+// src/knowledge/time-travel.ts
+async function getKnowledgeAt(db, entityType, entityId, timestamp) {
+  try {
+    const entries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        createdAt: { lte: timestamp },
+        OR: [
+          { supersededAt: null },
+          { supersededAt: { gt: timestamp } }
+        ]
+      },
+      include: { field: true },
+      orderBy: { createdAt: "desc" }
+    });
+    const fields = {};
+    for (const entry of entries) {
+      const key = entry.field.key;
+      if (!fields[key]) {
+        fields[key] = {
+          value: entry.value,
+          confidence: Number(entry.confidence),
+          source: entry.source,
+          setAt: entry.createdAt
+        };
+      }
+    }
+    return { fields };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_340", { entityType, entityId, timestamp: timestamp.toISOString(), error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getFieldValueAt(db, entityType, entityId, fieldKey, timestamp) {
+  try {
+    const fieldDef = await db.entityFieldDefinition.findFirst({
+      where: { entityType, key: fieldKey }
+    });
+    if (!fieldDef) return null;
+    const entry = await db.knowledgeLedgerEntry.findFirst({
+      where: {
+        fieldId: fieldDef.id,
+        entityType,
+        entityId,
+        createdAt: { lte: timestamp },
+        OR: [
+          { supersededAt: null },
+          { supersededAt: { gt: timestamp } }
+        ]
+      },
+      orderBy: { createdAt: "desc" }
+    });
+    if (!entry) return null;
+    return {
+      value: entry.value,
+      confidence: Number(entry.confidence),
+      source: entry.source,
+      setAt: entry.createdAt
+    };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_340", { entityType, entityId, fieldKey, timestamp: timestamp.toISOString(), error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getKnowledgeTimeline(db, entityType, entityId, from, to, limit = 100) {
+  if (from > to) {
+    const err = knowledgeError("KNOWLEDGE_341", { entityType, entityId, from: from.toISOString(), to: to.toISOString() });
+    console.error(`[${err.ref}] ${err.description}`);
+    throw new Error(err.description);
+  }
+  try {
+    const entries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        createdAt: { gte: from, lte: to }
+      },
+      include: { field: true },
+      orderBy: { createdAt: "asc" },
+      take: limit
+    });
+    return entries.map((entry) => ({
+      fieldKey: entry.field.key,
+      value: entry.value,
+      confidence: Number(entry.confidence),
+      source: entry.source,
+      createdAt: entry.createdAt,
+      supersededAt: entry.supersededAt
+    }));
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_340", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/scoring.ts
+var SOURCE_RELIABILITY = {
+  manual: 1,
+  note: 0.9,
+  email: 0.7,
+  agent: 0.6,
+  "ai-batch": 0.5,
+  predicted: 0.3
+};
+function computeRecencyFactor(createdAt, now, maxAgeDays = 365) {
+  const current = now ?? /* @__PURE__ */ new Date();
+  const ageDays = (current.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+  if (ageDays <= 0) return 1;
+  return Math.exp(-ageDays / maxAgeDays * 3);
+}
+function computeTruthScore(assertions, now) {
+  if (assertions.length === 0) return 0;
+  let numerator = 0;
+  let denominator = 0;
+  for (const a of assertions) {
+    const reliability = SOURCE_RELIABILITY[a.source] ?? 0.5;
+    const recency = computeRecencyFactor(a.createdAt, now);
+    const weight = a.confidence * reliability;
+    numerator += weight * recency;
+    denominator += weight;
+  }
+  if (denominator === 0) return 0;
+  return numerator / denominator;
+}
+function computeComplexityScore(fieldsUsed, fieldsAvailable, categoriesUsed, maxCategories) {
+  if (fieldsAvailable === 0 || maxCategories === 0) return 0;
+  const categoryRatio = Math.min(categoriesUsed / maxCategories, 1);
+  const fieldRatio = Math.min(fieldsUsed / fieldsAvailable, 1);
+  return 0.6 * categoryRatio + 0.4 * fieldRatio;
+}
+async function computeEntityTruthScores(db, entityType, entityId) {
+  try {
+    const allEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId },
+      include: { field: true },
+      orderBy: { createdAt: "desc" }
+    });
+    const byField = /* @__PURE__ */ new Map();
+    const currentByField = /* @__PURE__ */ new Map();
+    for (const entry of allEntries) {
+      const key = entry.field.key;
+      if (!byField.has(key)) byField.set(key, []);
+      byField.get(key).push({
+        confidence: Number(entry.confidence),
+        source: entry.source,
+        createdAt: entry.createdAt,
+        supersededAt: entry.supersededAt
+      });
+      if (!entry.supersededAt && !currentByField.has(key)) {
+        currentByField.set(key, {
+          confidence: Number(entry.confidence),
+          source: entry.source
+        });
+      }
+    }
+    const result = {};
+    for (const [key, assertions] of byField) {
+      const current = currentByField.get(key);
+      if (!current) continue;
+      result[key] = {
+        truthScore: computeTruthScore(assertions),
+        confidence: current.confidence,
+        source: current.source,
+        assertions: assertions.length
+      };
+    }
+    return result;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_348", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/decay.ts
+function computeDecayedConfidence(originalConfidence, createdAt, halfLifeDays, now) {
+  if (halfLifeDays <= 0) return originalConfidence;
+  const current = now ?? /* @__PURE__ */ new Date();
+  const ageDays = (current.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+  if (ageDays <= 0) return originalConfidence;
+  return originalConfidence * Math.pow(0.5, ageDays / halfLifeDays);
+}
+function isStale(originalConfidence, createdAt, halfLifeDays, threshold = 0.3, now) {
+  const decayed = computeDecayedConfidence(originalConfidence, createdAt, halfLifeDays, now);
+  return decayed < threshold;
+}
+async function getStaleFields(db, entityType, entityId, threshold = 0.3) {
+  try {
+    const entries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        supersededAt: null
+      },
+      include: { field: true }
+    });
+    const now = /* @__PURE__ */ new Date();
+    const staleFields = [];
+    for (const entry of entries) {
+      const halfLife = entry.field.halfLifeDays;
+      if (halfLife == null) continue;
+      const originalConfidence = Number(entry.confidence);
+      const decayed = computeDecayedConfidence(originalConfidence, entry.createdAt, halfLife, now);
+      if (decayed < threshold) {
+        const ageDays = (now.getTime() - entry.createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+        staleFields.push({
+          fieldKey: entry.field.key,
+          label: entry.field.label,
+          originalConfidence,
+          decayedConfidence: decayed,
+          halfLifeDays: halfLife,
+          lastUpdated: entry.createdAt,
+          staleSinceDays: Math.floor(ageDays)
+        });
+      }
+    }
+    return staleFields;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_342", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+function formatStalenessWarnings(staleFields) {
+  return staleFields.map((f) => {
+    const pct = Math.round(f.decayedConfidence * 100);
+    return `"${f.label}" confidence has decayed to ${pct}% (${f.staleSinceDays} days since last update)`;
+  });
+}
+
+// src/knowledge/branching.ts
+function shouldBranch(newConfidence, existingConfidence, threshold = 0.7) {
+  if (newConfidence >= threshold) return "proceed";
+  if (existingConfidence != null && existingConfidence > newConfidence) return "validate";
+  return "proceed";
+}
+async function setEntityFieldsWithBranching(db, entityType, entityId, fields, source, confidence, options) {
+  const threshold = options?.branchingThreshold ?? 0.7;
+  const written = [];
+  const skipped = [];
+  const deferred = [];
+  const validationRequested = [];
+  try {
+    const fieldKeys = Object.keys(fields);
+    const fieldDefs = await db.entityFieldDefinition.findMany({
+      where: {
+        entityType,
+        key: { in: fieldKeys },
+        isActive: true,
+        status: "approved"
+      }
+    });
+    const defMap = new Map(fieldDefs.map((d) => [d.key, d]));
+    const existingEntries = await db.knowledgeLedgerEntry.findMany({
+      where: {
+        entityType,
+        entityId,
+        fieldId: { in: fieldDefs.map((d) => d.id) },
+        supersededAt: null
+      },
+      include: { field: true }
+    });
+    const existingByKey = new Map(
+      existingEntries.map((e) => [e.field.key, { confidence: Number(e.confidence), value: e.value }])
+    );
+    for (const [key, value] of Object.entries(fields)) {
+      const def = defMap.get(key);
+      if (!def) {
+        skipped.push(key);
+        continue;
+      }
+      const existing = existingByKey.get(key);
+      const decision = shouldBranch(confidence, existing?.confidence, threshold);
+      if (decision === "validate") {
+        if (options?.validationCallbacks?.requestValidation) {
+          try {
+            const verdict = await options.validationCallbacks.requestValidation(
+              entityType,
+              entityId,
+              key,
+              value,
+              confidence,
+              existing?.value,
+              existing?.confidence
+            );
+            if (verdict === "reject") {
+              skipped.push(key);
+              continue;
+            }
+            if (verdict === "defer") {
+              deferred.push({ key, reason: "Validation deferred by reviewer" });
+              validationRequested.push({ key, value, confidence });
+              continue;
+            }
+          } catch (error) {
+            const err = knowledgeError("KNOWLEDGE_344", { entityType, entityId, key, error: String(error) });
+            console.error(`[${err.ref}] ${err.description}`, error);
+            deferred.push({ key, reason: "Validation callback failed" });
+            validationRequested.push({ key, value, confidence });
+            continue;
+          }
+        } else {
+          deferred.push({ key, reason: "Low confidence, no validator available" });
+          validationRequested.push({ key, value, confidence });
+          continue;
+        }
+      }
+      await db.knowledgeLedgerEntry.updateMany({
+        where: {
+          fieldId: def.id,
+          entityType,
+          entityId,
+          supersededAt: null
+        },
+        data: { supersededAt: /* @__PURE__ */ new Date() }
+      });
+      const entry = await db.knowledgeLedgerEntry.create({
+        data: {
+          fieldId: def.id,
+          entityType,
+          entityId,
+          value,
+          confidence,
+          source,
+          sourceId: options?.sourceId ?? null,
+          setBy: options?.setBy ?? null
+        }
+      });
+      written.push({ key, entryId: entry.id });
+    }
+    if (written.length > 0) {
+      try {
+        await options?.callbacks?.logActivity?.(
+          "KNOWLEDGE_VALUE_SET",
+          `${written.length} knowledge field(s) set on ${entityType} ${entityId}`,
+          entityType === "client" ? { clientId: entityId } : void 0
+        );
+      } catch {
+      }
+    }
+    return { written, skipped, deferred, validationRequested };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_343", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/shadow-graph.ts
+function computeRelationshipStrength(sharedFields, totalFieldsOnSource) {
+  if (sharedFields.length === 0 || totalFieldsOnSource === 0) return 0;
+  const avgConfProduct = sharedFields.reduce(
+    (sum, f) => sum + f.sourceConfidence * f.targetConfidence,
+    0
+  ) / sharedFields.length;
+  const coverage = Math.min(sharedFields.length / totalFieldsOnSource, 1);
+  return avgConfProduct * coverage;
+}
+async function findRelatedEntities(db, entityType, entityId, options) {
+  try {
+    const minShared = options?.minSharedFields ?? 1;
+    const minStrength = options?.minStrength ?? 0;
+    const limit = options?.limit ?? 20;
+    const sourceEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId, supersededAt: null },
+      include: { field: true }
+    });
+    if (sourceEntries.length === 0) return [];
+    const relationships = /* @__PURE__ */ new Map();
+    for (const sourceEntry of sourceEntries) {
+      if (sourceEntry.value === null || sourceEntry.value === void 0) continue;
+      const matchingEntries = await db.knowledgeLedgerEntry.findMany({
+        where: {
+          fieldId: sourceEntry.fieldId,
+          value: { equals: sourceEntry.value },
+          supersededAt: null,
+          NOT: {
+            AND: [
+              { entityType },
+              { entityId }
+            ]
+          },
+          ...options?.targetEntityType ? { entityType: options.targetEntityType } : {}
+        },
+        include: { field: true },
+        take: 100
+        // Unbounded query guard
+      });
+      for (const match of matchingEntries) {
+        const targetKey = `${match.entityType}:${match.entityId}`;
+        if (!relationships.has(targetKey)) {
+          relationships.set(targetKey, {
+            sourceEntityType: entityType,
+            sourceEntityId: entityId,
+            targetEntityType: match.entityType,
+            targetEntityId: match.entityId,
+            sharedFields: [],
+            strength: 0
+          });
+        }
+        relationships.get(targetKey).sharedFields.push({
+          fieldKey: sourceEntry.field.key,
+          value: sourceEntry.value,
+          sourceConfidence: Number(sourceEntry.confidence),
+          targetConfidence: Number(match.confidence)
+        });
+      }
+    }
+    const results = [];
+    for (const rel of relationships.values()) {
+      if (rel.sharedFields.length < minShared) continue;
+      rel.strength = computeRelationshipStrength(
+        rel.sharedFields,
+        sourceEntries.length
+      );
+      if (rel.strength < minStrength) continue;
+      results.push(rel);
+    }
+    results.sort((a, b) => b.strength - a.strength);
+    return results.slice(0, limit);
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_345", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getEntityRelationships(db, entityType, entityId, limit = 20) {
+  return findRelatedEntities(db, entityType, entityId, { limit });
+}
+
+// src/knowledge/reflection.ts
+var DEFAULT_CONFLICT_RULES = [
+  {
+    type: "value_contradiction",
+    description: "Budget range contradicts premium preference",
+    fieldA: "budget_range",
+    fieldB: "quality_preference",
+    check: (budgetVal, qualityVal) => {
+      const budget = String(budgetVal).toLowerCase();
+      const quality = String(qualityVal).toLowerCase();
+      const isLowBudget = budget.includes("budget") || budget.includes("economy") || budget.includes("under");
+      const isPremium = quality.includes("premium") || quality.includes("luxury") || quality.includes("high-end");
+      return isLowBudget && isPremium;
+    }
+  }
+];
+function evaluateConflictRule(rule, fields) {
+  const fieldA = fields[rule.fieldA];
+  if (!fieldA) return null;
+  const fieldB = rule.fieldB ? fields[rule.fieldB] : void 0;
+  if (rule.fieldB && !fieldB) return null;
+  const isConflict = rule.check(fieldA.value, fieldB?.value);
+  if (!isConflict) return null;
+  const minTruth = Math.min(fieldA.truthScore, fieldB?.truthScore ?? fieldA.truthScore);
+  const severity = minTruth > 0.7 ? "high" : minTruth > 0.4 ? "medium" : "low";
+  return {
+    rule,
+    entityType: "",
+    entityId: "",
+    fieldA: { key: rule.fieldA, ...fieldA },
+    fieldB: fieldB ? { key: rule.fieldB, ...fieldB } : void 0,
+    severity,
+    suggestion: rule.fieldB ? `Review "${rule.fieldA}" and "${rule.fieldB}" \u2014 ${rule.description}` : `Review "${rule.fieldA}" \u2014 ${rule.description}`
+  };
+}
+async function detectConflicts(db, entityType, entityId, rules) {
+  try {
+    const activeRules = rules ?? DEFAULT_CONFLICT_RULES;
+    const allEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId },
+      include: { field: true },
+      orderBy: { createdAt: "desc" }
+    });
+    const entriesByField = /* @__PURE__ */ new Map();
+    const currentByField = /* @__PURE__ */ new Map();
+    for (const entry of allEntries) {
+      const key = entry.field.key;
+      if (!entriesByField.has(key)) entriesByField.set(key, []);
+      entriesByField.get(key).push({
+        confidence: Number(entry.confidence),
+        source: entry.source,
+        createdAt: entry.createdAt,
+        supersededAt: entry.supersededAt
+      });
+      if (!entry.supersededAt && !currentByField.has(key)) {
+        currentByField.set(key, { value: entry.value, confidence: Number(entry.confidence) });
+      }
+    }
+    const fields = {};
+    for (const [key, current] of currentByField) {
+      const assertions = entriesByField.get(key) ?? [];
+      fields[key] = {
+        value: current.value,
+        confidence: current.confidence,
+        truthScore: computeTruthScore(assertions)
+      };
+    }
+    const conflicts = [];
+    for (const rule of activeRules) {
+      const conflict = evaluateConflictRule(rule, fields);
+      if (conflict) {
+        conflict.entityType = entityType;
+        conflict.entityId = entityId;
+        conflicts.push(conflict);
+      }
+    }
+    return conflicts;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_346", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function scanForConflicts(db, entityType, rules, limit = 100) {
+  try {
+    const distinctEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, supersededAt: null },
+      select: { entityId: true },
+      distinct: ["entityId"],
+      take: limit
+    });
+    const results = [];
+    for (const { entityId } of distinctEntries) {
+      const conflicts = await detectConflicts(db, entityType, entityId, rules);
+      if (conflicts.length > 0) {
+        results.push({ entityId, conflicts });
+      }
+    }
+    return results;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_347", { entityType, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/co-occurrence.ts
+async function buildCoOccurrenceMap(db, entityType, fieldKeyA, fieldKeyB, minOccurrences = 3) {
+  try {
+    const fieldDefs = await db.entityFieldDefinition.findMany({
+      where: { entityType, key: { in: [fieldKeyA, fieldKeyB] }, isActive: true }
+    });
+    const defA = fieldDefs.find((d) => d.key === fieldKeyA);
+    const defB = fieldDefs.find((d) => d.key === fieldKeyB);
+    if (!defA || !defB) return /* @__PURE__ */ new Map();
+    const entriesA = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, fieldId: defA.id, supersededAt: null },
+      take: 1e3
+    });
+    const entriesB = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, fieldId: defB.id, supersededAt: null },
+      take: 1e3
+    });
+    const bByEntity = /* @__PURE__ */ new Map();
+    for (const entry of entriesB) {
+      bByEntity.set(entry.entityId, entry.value);
+    }
+    const coOccurrence = /* @__PURE__ */ new Map();
+    const totalPerA = /* @__PURE__ */ new Map();
+    for (const entryA of entriesA) {
+      const valA = String(entryA.value);
+      const valB = bByEntity.get(entryA.entityId);
+      if (valB === void 0) continue;
+      const strB = String(valB);
+      totalPerA.set(valA, (totalPerA.get(valA) ?? 0) + 1);
+      if (!coOccurrence.has(valA)) coOccurrence.set(valA, /* @__PURE__ */ new Map());
+      const inner = coOccurrence.get(valA);
+      inner.set(strB, (inner.get(strB) ?? 0) + 1);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [valA, innerMap] of coOccurrence) {
+      const total = totalPerA.get(valA) ?? 0;
+      if (total < minOccurrences) continue;
+      const rateMap = /* @__PURE__ */ new Map();
+      for (const [valB, count] of innerMap) {
+        rateMap.set(valB, { count, total, rate: count / total });
+      }
+      result.set(valA, rateMap);
+    }
+    return result;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_355", { entityType, fieldKeyA, fieldKeyB, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/ghost-fields.ts
+async function predictGhostFields(db, entityType, entityId, options) {
+  try {
+    const minConfidence = options?.minConfidence ?? 0.3;
+    const maxPredictions = options?.maxPredictions ?? 10;
+    const currentEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId, supersededAt: null },
+      include: { field: true }
+    });
+    if (currentEntries.length === 0) return [];
+    const currentKeys = new Set(currentEntries.map((e) => e.field.key));
+    const allFields = await db.entityFieldDefinition.findMany({
+      where: { entityType, isActive: true, status: "approved" }
+    });
+    const missingFields = allFields.filter((f) => !currentKeys.has(f.key));
+    if (missingFields.length === 0) return [];
+    const predictions = [];
+    for (const missingField of missingFields) {
+      if (predictions.length >= maxPredictions) break;
+      for (const currentEntry of currentEntries) {
+        const coMap = await buildCoOccurrenceMap(
+          db,
+          entityType,
+          currentEntry.field.key,
+          missingField.key,
+          3
+        );
+        const currentValStr = String(currentEntry.value);
+        const rates = coMap.get(currentValStr);
+        if (!rates) continue;
+        let bestValue;
+        let bestRate = 0;
+        for (const [val, data] of rates) {
+          if (data.rate > bestRate) {
+            bestRate = data.rate;
+            bestValue = val;
+          }
+        }
+        if (bestValue && bestRate >= minConfidence) {
+          const existing = predictions.find((p) => p.fieldKey === missingField.key);
+          if (existing) {
+            if (bestRate > existing.confidence) {
+              existing.predictedValue = bestValue;
+              existing.confidence = bestRate;
+              existing.basedOn = [{
+                fieldKey: currentEntry.field.key,
+                value: currentEntry.value,
+                coOccurrenceRate: bestRate
+              }];
+            }
+          } else {
+            predictions.push({
+              fieldKey: missingField.key,
+              label: missingField.label,
+              predictedValue: bestValue,
+              confidence: bestRate,
+              basedOn: [{
+                fieldKey: currentEntry.field.key,
+                value: currentEntry.value,
+                coOccurrenceRate: bestRate
+              }],
+              source: "predicted"
+            });
+          }
+        }
+      }
+    }
+    return predictions;
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_355", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function writeGhostFields(db, entityType, entityId, predictions, callbacks) {
+  try {
+    let written = 0;
+    let skipped = 0;
+    for (const prediction of predictions) {
+      const fieldDef = await db.entityFieldDefinition.findFirst({
+        where: { entityType, key: prediction.fieldKey, isActive: true }
+      });
+      if (!fieldDef) {
+        skipped++;
+        continue;
+      }
+      const existing = await db.knowledgeLedgerEntry.findFirst({
+        where: {
+          fieldId: fieldDef.id,
+          entityType,
+          entityId,
+          supersededAt: null,
+          NOT: { source: "predicted" }
+        }
+      });
+      if (existing) {
+        skipped++;
+        continue;
+      }
+      await db.knowledgeLedgerEntry.updateMany({
+        where: {
+          fieldId: fieldDef.id,
+          entityType,
+          entityId,
+          supersededAt: null
+        },
+        data: { supersededAt: /* @__PURE__ */ new Date() }
+      });
+      await db.knowledgeLedgerEntry.create({
+        data: {
+          fieldId: fieldDef.id,
+          entityType,
+          entityId,
+          value: prediction.predictedValue,
+          confidence: prediction.confidence,
+          source: "predicted",
+          sourceId: null,
+          setBy: null
+        }
+      });
+      written++;
+    }
+    if (written > 0) {
+      try {
+        await callbacks?.logActivity?.(
+          "KNOWLEDGE_GHOST_WRITTEN",
+          `${written} predicted field(s) written for ${entityType} ${entityId}`
+        );
+      } catch {
+      }
+    }
+    return { written, skipped };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_356", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/knowledge/health.ts
+function computeOverallScore(completeness, freshness, conflictRate, truthAverage) {
+  return 0.4 * completeness + 0.3 * freshness + 0.2 * (1 - conflictRate) + 0.1 * truthAverage;
+}
+async function computeEntityHealth(db, entityType, entityId, conflictRules) {
+  try {
+    const fieldDefs = await db.entityFieldDefinition.findMany({
+      where: { entityType, isActive: true, status: "approved" }
+    });
+    const totalFieldCount = fieldDefs.length;
+    const currentEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId, supersededAt: null },
+      include: { field: true }
+    });
+    const filledFieldCount = currentEntries.length;
+    const completeness = totalFieldCount > 0 ? Math.min(filledFieldCount / totalFieldCount, 1) : 0;
+    const now = /* @__PURE__ */ new Date();
+    let freshnessSum = 0;
+    let staleFieldCount = 0;
+    for (const entry of currentEntries) {
+      const halfLife = entry.field.halfLifeDays;
+      if (halfLife != null) {
+        const decayed = computeDecayedConfidence(Number(entry.confidence), entry.createdAt, halfLife, now);
+        freshnessSum += decayed / Number(entry.confidence || 1);
+        if (decayed < 0.3) staleFieldCount++;
+      } else {
+        freshnessSum += computeRecencyFactor(entry.createdAt, now);
+      }
+    }
+    const freshness = currentEntries.length > 0 ? freshnessSum / currentEntries.length : 0;
+    const allEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, entityId },
+      include: { field: true },
+      orderBy: { createdAt: "desc" }
+    });
+    const entriesByField = /* @__PURE__ */ new Map();
+    for (const entry of allEntries) {
+      const key = entry.field.key;
+      if (!entriesByField.has(key)) entriesByField.set(key, []);
+      entriesByField.get(key).push({
+        confidence: Number(entry.confidence),
+        source: entry.source,
+        createdAt: entry.createdAt,
+        supersededAt: entry.supersededAt
+      });
+    }
+    let truthSum = 0;
+    let truthCount = 0;
+    for (const assertions of entriesByField.values()) {
+      const score = computeTruthScore(assertions, now);
+      truthSum += score;
+      truthCount++;
+    }
+    const truthAverage = truthCount > 0 ? truthSum / truthCount : 0;
+    const conflicts = await detectConflicts(db, entityType, entityId, conflictRules);
+    const conflictCount = conflicts.length;
+    const conflictRate = filledFieldCount > 0 ? Math.min(conflictCount / filledFieldCount, 1) : 0;
+    const overallScore = computeOverallScore(completeness, freshness, conflictRate, truthAverage);
+    const warnings = [];
+    if (completeness < 0.3) warnings.push("Entity has very few fields filled");
+    if (freshness < 0.3) warnings.push("Many fields are stale \u2014 data may be outdated");
+    if (conflictCount > 0) warnings.push(`${conflictCount} contradiction(s) detected`);
+    if (staleFieldCount > 0) warnings.push(`${staleFieldCount} field(s) have decayed below threshold`);
+    return {
+      entityType,
+      entityId,
+      completeness,
+      freshness,
+      conflictRate,
+      truthAverage,
+      overallScore,
+      staleFieldCount,
+      conflictCount,
+      filledFieldCount,
+      totalFieldCount,
+      warnings
+    };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_360", { entityType, entityId, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+async function getEntityTypeHealth(db, entityType, options) {
+  try {
+    const limit = options?.limit ?? 200;
+    const worstN = options?.worstN ?? 5;
+    const bestN = options?.bestN ?? 5;
+    const distinctEntries = await db.knowledgeLedgerEntry.findMany({
+      where: { entityType, supersededAt: null },
+      select: { entityId: true },
+      distinct: ["entityId"],
+      take: limit
+    });
+    const entityCount = distinctEntries.length;
+    if (entityCount === 0) {
+      return {
+        entityType,
+        entityCount: 0,
+        avgCompleteness: 0,
+        avgFreshness: 0,
+        avgConflictRate: 0,
+        avgOverallScore: 0,
+        worstEntities: [],
+        bestEntities: []
+      };
+    }
+    const reports = [];
+    for (const { entityId } of distinctEntries) {
+      const report = await computeEntityHealth(db, entityType, entityId);
+      reports.push(report);
+    }
+    const avgCompleteness = reports.reduce((s, r) => s + r.completeness, 0) / entityCount;
+    const avgFreshness = reports.reduce((s, r) => s + r.freshness, 0) / entityCount;
+    const avgConflictRate = reports.reduce((s, r) => s + r.conflictRate, 0) / entityCount;
+    const avgOverallScore = reports.reduce((s, r) => s + r.overallScore, 0) / entityCount;
+    const sorted = [...reports].sort((a, b) => a.overallScore - b.overallScore);
+    return {
+      entityType,
+      entityCount,
+      avgCompleteness,
+      avgFreshness,
+      avgConflictRate,
+      avgOverallScore,
+      worstEntities: sorted.slice(0, worstN).map((r) => ({
+        entityId: r.entityId,
+        overallScore: r.overallScore
+      })),
+      bestEntities: sorted.slice(-bestN).reverse().map((r) => ({
+        entityId: r.entityId,
+        overallScore: r.overallScore
+      }))
+    };
+  } catch (error) {
+    const err = knowledgeError("KNOWLEDGE_361", { entityType, error: String(error) });
+    console.error(`[${err.ref}] ${err.description}`, error);
+    throw error;
+  }
+}
+
+// src/agent/knowledge.ts
+import { Prisma as Prisma2 } from "@prisma/client";
+var seedChecked = false;
+async function queryKnowledge(db, input, seedProvider) {
+  if (!seedChecked) {
+    await ensureKnowledgeDefaults(db, seedProvider);
+    seedChecked = true;
+  }
+  const { entity, field, search, category, limit } = input;
+  const where = {
+    entity,
+    isActive: true
+  };
+  if (field) where.field = field;
+  if (category) where.category = category;
+  if (search) {
+    const searchLower = search.toLowerCase();
+    const terms = searchLower.split(/\s+/).filter(Boolean);
+    const entries = await db.agentKnowledge.findMany({
+      where: {
+        ...where,
+        OR: [
+          { value: { contains: searchLower, mode: "insensitive" } },
+          { label: { contains: searchLower, mode: "insensitive" } }
+        ]
+      },
+      orderBy: [{ sortOrder: "asc" }, { label: "asc" }],
+      take: limit
+    });
+    const aliasEntries = await db.agentKnowledge.findMany({
+      where: {
+        ...where,
+        id: { notIn: entries.map((e) => e.id) }
+      },
+      orderBy: [{ sortOrder: "asc" }, { label: "asc" }]
+    });
+    const aliasMatches = aliasEntries.filter(
+      (entry) => entry.aliases.some(
+        (alias) => terms.every((term) => alias.toLowerCase().includes(term))
+      )
+    );
+    return [...entries, ...aliasMatches].slice(0, limit);
+  }
+  return db.agentKnowledge.findMany({
+    where,
+    orderBy: [{ sortOrder: "asc" }, { label: "asc" }],
+    take: limit
+  });
+}
+async function createKnowledgeEntry(db, input) {
+  const existing = await db.agentKnowledge.findUnique({
+    where: {
+      entity_field_value: {
+        entity: input.entity,
+        field: input.field,
+        value: input.value
+      }
+    }
+  });
+  if (existing) {
+    throw agentKnowledgeError("AGENTKNOW_403", {
+      entity: input.entity,
+      field: input.field,
+      value: input.value
+    });
+  }
+  return db.agentKnowledge.create({
+    data: {
+      entity: input.entity,
+      field: input.field,
+      value: input.value,
+      label: input.label,
+      aliases: input.aliases,
+      category: input.category ?? null,
+      metadata: input.metadata ?? Prisma2.JsonNull,
+      sortOrder: input.sortOrder,
+      source: "manual"
+    }
+  });
+}
+async function updateKnowledgeEntry(db, id, input) {
+  const existing = await db.agentKnowledge.findUnique({ where: { id } });
+  if (!existing) {
+    throw agentKnowledgeError("AGENTKNOW_404", { id });
+  }
+  return db.agentKnowledge.update({
+    where: { id },
+    data: {
+      ...input.label !== void 0 && { label: input.label },
+      ...input.aliases !== void 0 && { aliases: input.aliases },
+      ...input.category !== void 0 && { category: input.category },
+      ...input.metadata !== void 0 && { metadata: input.metadata },
+      ...input.sortOrder !== void 0 && { sortOrder: input.sortOrder },
+      ...input.isActive !== void 0 && { isActive: input.isActive }
+    }
+  });
+}
+async function deleteKnowledgeEntry(db, id) {
+  const existing = await db.agentKnowledge.findUnique({ where: { id } });
+  if (!existing) {
+    throw agentKnowledgeError("AGENTKNOW_405", { id });
+  }
+  return db.agentKnowledge.delete({ where: { id } });
+}
+async function ensureKnowledgeDefaults(db, seedProvider) {
+  const count = await db.agentKnowledge.count();
+  if (count > 0) return;
+  const seedData = seedProvider?.getKnowledgeSeedData?.();
+  if (!seedData || seedData.length === 0) return;
+  try {
+    await db.agentKnowledge.createMany({
+      data: seedData.map((entry) => ({
+        ...entry,
+        metadata: entry.metadata === null ? Prisma2.JsonNull : entry.metadata
+      })),
+      skipDuplicates: true
+    });
+  } catch (error) {
+    console.error(
+      "[AGENTKNOW_409] Failed to seed knowledge defaults:",
+      error instanceof Error ? error.message : error
+    );
+  }
+}
+async function resetKnowledgeDefaults(db, seedProvider) {
+  const seedData = seedProvider?.getKnowledgeSeedData?.();
+  if (!seedData || seedData.length === 0) {
+    throw agentKnowledgeError("AGENTKNOW_410", { error: "No seed data provider available" });
+  }
+  try {
+    await db.$transaction(async (tx) => {
+      await tx.agentKnowledge.deleteMany({ where: { source: "seed" } });
+      await tx.agentKnowledge.createMany({
+        data: seedData.map((entry) => ({
+          ...entry,
+          metadata: entry.metadata === null ? Prisma2.JsonNull : entry.metadata
+        })),
+        skipDuplicates: true
+      });
+    });
+    seedChecked = false;
+  } catch (error) {
+    throw agentKnowledgeError("AGENTKNOW_410", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function resetSeedCheck() {
+  seedChecked = false;
+}
+
+// src/agent/preferences.ts
+import { Prisma as Prisma3 } from "@prisma/client";
+async function getPreferences(db, input) {
+  const { entity, userId, field } = input;
+  const where = {
+    entity,
+    isActive: true
+  };
+  if (field) where.field = field;
+  if (userId) {
+    where.OR = [{ userId: null }, { userId }];
+  } else {
+    where.userId = null;
+  }
+  return db.agentPreference.findMany({
+    where,
+    orderBy: [{ priority: "desc" }, { createdAt: "asc" }]
+  });
+}
+async function setPreference(db, input) {
+  const existing = await db.agentPreference.findFirst({
+    where: {
+      entity: input.entity,
+      field: input.field,
+      userId: input.userId ?? null
+    }
+  });
+  if (existing) {
+    return db.agentPreference.update({
+      where: { id: existing.id },
+      data: {
+        value: input.value,
+        label: input.label,
+        conditions: input.conditions ?? Prisma3.JsonNull,
+        priority: input.priority
+      }
+    });
+  }
+  return db.agentPreference.create({
+    data: {
+      entity: input.entity,
+      field: input.field,
+      value: input.value,
+      label: input.label,
+      conditions: input.conditions ?? Prisma3.JsonNull,
+      userId: input.userId ?? null,
+      priority: input.priority
+    }
+  });
+}
+async function deletePreference(db, id) {
+  const existing = await db.agentPreference.findUnique({ where: { id } });
+  if (!existing) {
+    throw agentKnowledgeError("AGENTKNOW_408", { id });
+  }
+  return db.agentPreference.delete({ where: { id } });
+}
+
+// src/agent/analytics.ts
+var INTENT_PATTERNS = [
+  { pattern: /^\/report\b/i, intent: "report" },
+  { pattern: /^\/tour\b/i, intent: "tour" },
+  { pattern: /^\/automation\b/i, intent: "command" },
+  { pattern: /\b(generate|create|make|build|add|set up|configure)\b/i, intent: "command" },
+  { pattern: /\b(delete|remove|disable|turn off)\b/i, intent: "command" },
+  { pattern: /\b(update|change|modify|edit|fix)\b/i, intent: "command" },
+  { pattern: /\b(how|what|why|when|where|explain|tell me|describe)\b/i, intent: "question" },
+  { pattern: /\b(show|find|search|list|get|check|look up)\b/i, intent: "search" }
+];
+var TOPIC_KEYWORDS = {
+  "email campaigns": ["email campaign", "newsletter", "mass email", "email blast", "email marketing"],
+  "email templates": ["email template", "template", "email format"],
+  "fabric stock": ["fabric", "stock", "in stock", "out of stock", "availability"],
+  "order management": ["order", "placement", "order status", "delivery"],
+  "client management": ["client", "customer", "contact", "profile"],
+  "fit profiles": ["fit profile", "measurement", "try-on", "size", "adjustment"],
+  "tax operations": ["tax", "transaction", "categorize", "deduction", "irs"],
+  "reports": ["report", "export", "pdf", "csv", "analytics", "summary"],
+  "automations": ["automation", "workflow", "trigger", "automate"],
+  "scheduling": ["schedule", "calendar", "deadline", "reminder"],
+  "billing": ["billing", "invoice", "payment", "charge"],
+  "inventory": ["inventory", "stock", "supply", "reorder"],
+  "social media": ["social media", "post", "tweet", "instagram", "facebook"],
+  "customer support": ["support", "ticket", "complaint", "help desk"],
+  "onboarding": ["onboarding", "training", "getting started", "tutorial"]
+};
+function classifyIntent(query) {
+  const normalized = query.trim().toLowerCase();
+  for (const { pattern, intent } of INTENT_PATTERNS) {
+    if (pattern.test(normalized)) return intent;
+  }
+  if (normalized.includes("?")) return "question";
+  return "search";
+}
+function extractTopic(query) {
+  const normalized = query.toLowerCase();
+  let bestTopic = null;
+  let bestScore = 0;
+  for (const [topic, keywords] of Object.entries(TOPIC_KEYWORDS)) {
+    for (const keyword of keywords) {
+      if (normalized.includes(keyword)) {
+        const score = keyword.length;
+        if (score > bestScore) {
+          bestScore = score;
+          bestTopic = topic;
+        }
+      }
+    }
+  }
+  return bestTopic;
+}
+function extractModules(toolNames) {
+  const MODULE_MAP = {
+    email: "email",
+    template: "email",
+    automation: "automation",
+    order: "orders",
+    client: "clients",
+    fabric: "fabric",
+    tax: "tax",
+    transaction: "tax",
+    report: "reports",
+    tour: "tours",
+    task: "tasks",
+    activity: "activities",
+    navigate: "navigation",
+    setting: "settings"
+  };
+  const modules = /* @__PURE__ */ new Set();
+  for (const tool of toolNames) {
+    const lower = tool.toLowerCase();
+    for (const [keyword, mod] of Object.entries(MODULE_MAP)) {
+      if (lower.includes(keyword)) {
+        modules.add(mod);
+        break;
+      }
+    }
+  }
+  return Array.from(modules);
+}
+
+// src/agent/interactions.ts
+async function logInteraction(db, input) {
+  const intent = classifyIntent(input.query);
+  const topic = extractTopic(input.query);
+  const modules = extractModules(input.toolsUsed ?? []);
+  return db.agentInteraction.create({
+    data: {
+      userId: input.userId,
+      query: input.query,
+      intent,
+      topic,
+      modules,
+      toolsUsed: input.toolsUsed ?? [],
+      sessionId: input.sessionId ?? null,
+      satisfied: null
+    }
+  });
+}
+async function markSatisfied(db, id, satisfied) {
+  return db.agentInteraction.update({
+    where: { id },
+    data: { satisfied }
+  });
+}
+async function getTopicDistribution(db, days = 30) {
+  const since = /* @__PURE__ */ new Date();
+  since.setDate(since.getDate() - days);
+  const interactions = await db.agentInteraction.findMany({
+    where: {
+      createdAt: { gte: since },
+      topic: { not: null }
+    },
+    select: {
+      topic: true,
+      toolsUsed: true,
+      modules: true
+    }
+  });
+  const topicMap = /* @__PURE__ */ new Map();
+  for (const interaction of interactions) {
+    if (!interaction.topic) continue;
+    const existing = topicMap.get(interaction.topic) ?? {
+      count: 0,
+      modules: /* @__PURE__ */ new Set(),
+      tools: /* @__PURE__ */ new Set()
+    };
+    existing.count++;
+    for (const m of interaction.modules) existing.modules.add(m);
+    for (const t of interaction.toolsUsed) existing.tools.add(t);
+    topicMap.set(interaction.topic, existing);
+  }
+  return Array.from(topicMap.entries()).map(([topic, data]) => ({
+    topic,
+    count: data.count,
+    modules: Array.from(data.modules),
+    tools: Array.from(data.tools)
+  })).sort((a, b) => b.count - a.count);
+}
+async function getRecentInteractions(db, userId, limit = 20) {
+  return db.agentInteraction.findMany({
+    where: { userId },
+    orderBy: { createdAt: "desc" },
+    take: limit
+  });
+}
+async function getInteractionCount(db, days = 30) {
+  const since = /* @__PURE__ */ new Date();
+  since.setDate(since.getDate() - days);
+  return db.agentInteraction.count({
+    where: { createdAt: { gte: since } }
+  });
+}
+
+// src/agent/suggestions.ts
+var TOPIC_TO_AGENT = {
+  "email campaigns": {
+    name: "Marketing Agent",
+    category: "communication",
+    description: "Handles email campaigns, newsletter scheduling, and audience segmentation."
+  },
+  "social media": {
+    name: "Social Media Agent",
+    category: "communication",
+    description: "Manages social media posts, scheduling, and engagement tracking."
+  },
+  "customer support": {
+    name: "Support Agent",
+    category: "service",
+    description: "Handles support tickets, customer complaints, and FAQ automation."
+  },
+  "reports": {
+    name: "Analytics Agent",
+    category: "analytics",
+    description: "Generates custom reports, dashboards, and data analysis."
+  },
+  "inventory": {
+    name: "Inventory Agent",
+    category: "operations",
+    description: "Tracks stock levels, reorder points, and supply chain status."
+  },
+  "billing": {
+    name: "Billing Agent",
+    category: "finance",
+    description: "Manages invoices, payment tracking, and billing automation."
+  },
+  "onboarding": {
+    name: "Onboarding Agent",
+    category: "workflow",
+    description: "Guides new users through setup, training, and documentation."
+  },
+  "scheduling": {
+    name: "Scheduling Agent",
+    category: "workflow",
+    description: "Manages appointments, calendars, and deadline tracking."
+  }
+};
+var SPECIALIST_TOPICS = /* @__PURE__ */ new Set([
+  "tax operations",
+  "order management",
+  "fabric stock",
+  "client management",
+  "fit profiles",
+  "email templates",
+  "automations"
+]);
+var MIN_QUERY_THRESHOLD = 10;
+var DISMISS_COOLDOWN_DAYS = 90;
+async function analyzeAndSuggest(db) {
+  const topics = await getTopicDistribution(db, 30);
+  const totalCount = await getInteractionCount(db, 30);
+  let created = 0;
+  for (const topicData of topics) {
+    if (SPECIALIST_TOPICS.has(topicData.topic)) continue;
+    if (topicData.count < MIN_QUERY_THRESHOLD) continue;
+    const proposal = TOPIC_TO_AGENT[topicData.topic];
+    if (!proposal) continue;
+    const topicConsistency = totalCount > 0 ? topicData.count / totalCount : 0;
+    const volumeScore = Math.min(1, topicData.count / 50);
+    const confidence = Number((volumeScore * (0.5 + topicConsistency * 0.5)).toFixed(3));
+    const evidence = `${topicData.count} queries about "${topicData.topic}" in the last 30 days (${Math.round(topicConsistency * 100)}% of all queries).`;
+    const existing = await db.agentSuggestion.findFirst({
+      where: { name: proposal.name }
+    });
+    if (existing) {
+      if (existing.status === "dismissed" && existing.dismissedAt && Date.now() - existing.dismissedAt.getTime() < DISMISS_COOLDOWN_DAYS * 24 * 60 * 60 * 1e3) {
+        continue;
+      }
+      await db.agentSuggestion.update({
+        where: { id: existing.id },
+        data: {
+          confidence,
+          evidence,
+          queryCount: topicData.count,
+          suggestedTools: topicData.tools,
+          status: existing.status === "dismissed" ? "pending" : existing.status,
+          dismissedAt: existing.status === "dismissed" ? null : existing.dismissedAt,
+          dismissedBy: existing.status === "dismissed" ? null : existing.dismissedBy
+        }
+      });
+    } else {
+      await db.agentSuggestion.create({
+        data: {
+          name: proposal.name,
+          description: proposal.description,
+          category: proposal.category,
+          evidence,
+          confidence,
+          queryCount: topicData.count,
+          suggestedTools: topicData.tools,
+          status: "pending"
+        }
+      });
+      created++;
+    }
+  }
+  return created;
+}
+async function getSuggestions(db, status) {
+  return db.agentSuggestion.findMany({
+    where: status ? { status } : void 0,
+    orderBy: { confidence: "desc" }
+  });
+}
+async function dismissSuggestion(db, id, userId) {
+  return db.agentSuggestion.update({
+    where: { id },
+    data: {
+      status: "dismissed",
+      dismissedBy: userId,
+      dismissedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function approveSuggestion(db, id) {
+  return db.agentSuggestion.update({
+    where: { id },
+    data: { status: "approved" }
+  });
+}
+
+// src/notes/notes.ts
+async function createNote(db, input, callbacks) {
+  const note = await db.clientNote.create({
+    data: {
+      clientId: input.entityId,
+      content: input.content,
+      contentHtml: input.contentHtml ?? null,
+      isDraft: input.isDraft ?? false,
+      authorId: input.authorId ?? null,
+      source: input.source ?? "MANUAL",
+      ...input.attachments && input.attachments.length > 0 ? {
+        attachments: {
+          create: input.attachments.map((a) => ({
+            filename: a.filename,
+            mimeType: a.mimeType,
+            size: a.size,
+            storagePath: a.storagePath
+          }))
+        }
+      } : {}
+    },
+    include: {
+      author: { select: { id: true, name: true } },
+      attachments: true
+    }
+  });
+  if (!input.isDraft) {
+    try {
+      const truncated = truncateText(input.content, 200);
+      await callbacks?.logActivity?.(
+        "CLIENT_NOTE_ADDED",
+        truncated,
+        {
+          userId: input.authorId ?? null,
+          clientId: input.entityId,
+          metadata: {
+            noteId: note.id,
+            contentPreview: truncateText(input.content, 500),
+            source: input.source ?? "MANUAL"
+          }
+        }
+      );
+    } catch {
+    }
+  }
+  if (input.fields && Object.keys(input.fields).length > 0) {
+    try {
+      const source = input.source === "AGENT" ? "agent" : "note";
+      await callbacks?.setEntityFields?.(
+        input.entityType,
+        input.entityId,
+        input.fields,
+        source,
+        note.id,
+        1,
+        input.authorId ?? void 0
+      );
+    } catch {
+    }
+  }
+  return note;
+}
+async function updateNote(db, noteId, entityId, input, callbacks) {
+  const note = await db.clientNote.findFirst({
+    where: { id: noteId, clientId: entityId }
+  });
+  if (!note) return null;
+  const isPublishing = note.isDraft && input.isDraft === false;
+  const updated = await db.clientNote.update({
+    where: { id: noteId },
+    data: {
+      ...input.content !== void 0 ? { content: input.content } : {},
+      ...input.contentHtml !== void 0 ? { contentHtml: input.contentHtml } : {},
+      ...input.isDraft !== void 0 ? { isDraft: input.isDraft } : {}
+    },
+    include: {
+      author: { select: { id: true, name: true } },
+      attachments: true
+    }
+  });
+  if (input.attachments !== void 0) {
+    await db.noteAttachment.deleteMany({ where: { noteId } });
+    if (input.attachments.length > 0) {
+      await db.noteAttachment.createMany({
+        data: input.attachments.map((a) => ({
+          noteId,
+          filename: a.filename,
+          mimeType: a.mimeType,
+          size: a.size,
+          storagePath: a.storagePath
+        }))
+      });
+    }
+  }
+  if (isPublishing) {
+    try {
+      const noteContent = input.content ?? note.content;
+      const truncated = truncateText(noteContent, 200);
+      await callbacks?.logActivity?.(
+        "CLIENT_NOTE_ADDED",
+        truncated,
+        {
+          userId: note.authorId ?? null,
+          clientId: entityId,
+          metadata: {
+            noteId,
+            contentPreview: truncateText(noteContent, 500),
+            source: note.source ?? "MANUAL"
+          }
+        }
+      );
+    } catch {
+    }
+  }
+  return db.clientNote.findUnique({
+    where: { id: noteId },
+    include: {
+      author: { select: { id: true, name: true } },
+      attachments: true
+    }
+  });
+}
+async function getNotes(db, { entityId, limit = 50, cursor, isDraft }) {
+  const notes = await db.clientNote.findMany({
+    where: {
+      clientId: entityId,
+      ...isDraft !== void 0 ? { isDraft } : { isDraft: false }
+    },
+    orderBy: { createdAt: "desc" },
+    take: limit + 1,
+    ...cursor ? { cursor: { id: cursor }, skip: 1 } : {},
+    include: {
+      author: { select: { id: true, name: true } },
+      attachments: true
+    }
+  });
+  const hasMore = notes.length > limit;
+  const items = hasMore ? notes.slice(0, limit) : notes;
+  const nextCursor = hasMore ? items[items.length - 1]?.id : void 0;
+  return { items, nextCursor, hasMore };
+}
+async function deleteNote(db, noteId, entityId) {
+  const note = await db.clientNote.findFirst({
+    where: { id: noteId, clientId: entityId }
+  });
+  if (!note) return null;
+  await db.clientNote.delete({ where: { id: noteId } });
+  return note;
+}
+function truncateText(text, maxLength) {
+  if (!text || text.length <= maxLength) return text;
+  return text.slice(0, maxLength).trimEnd() + "...";
+}
+
+// src/contacts/contacts.ts
+async function getAllContacts(db, options) {
+  const {
+    limit = 50,
+    offset = 0,
+    source,
+    search,
+    excludeConverted = true
+  } = options ?? {};
+  const where = {};
+  if (source) where.source = source;
+  if (excludeConverted) where.convertedToClientId = null;
+  if (search) {
+    where.OR = [
+      { name: { contains: search, mode: "insensitive" } },
+      { email: { contains: search, mode: "insensitive" } }
+    ];
+  }
+  const [contacts, total] = await Promise.all([
+    db.contact.findMany({
+      where,
+      include: {
+        tags: { include: { tag: true } },
+        _count: { select: { linkedEmails: true } }
+      },
+      orderBy: { createdAt: "desc" },
+      take: limit,
+      skip: offset
+    }),
+    db.contact.count({ where })
+  ]);
+  return { contacts, total, limit, offset };
+}
+async function getContactById(db, id) {
+  const contact = await db.contact.findUnique({
+    where: { id },
+    include: {
+      tags: { include: { tag: true } },
+      linkedEmails: {
+        take: 10,
+        orderBy: { emailDate: "desc" },
+        select: {
+          id: true,
+          subject: true,
+          snippet: true,
+          emailDate: true,
+          status: true
+        }
+      },
+      _count: { select: { linkedEmails: true } }
+    }
+  });
+  if (!contact) {
+    throw new ContactNotFoundError(id);
+  }
+  return contact;
+}
+async function getContactByEmail(db, email) {
+  return db.contact.findUnique({
+    where: { email: email.toLowerCase() }
+  });
+}
+async function createContact(db, params, callbacks) {
+  const normalizedEmail = params.email.toLowerCase();
+  const existing = await db.contact.findUnique({
+    where: { email: normalizedEmail }
+  });
+  if (existing) {
+    throw new ContactExistsError(normalizedEmail);
+  }
+  const contact = await db.contact.create({
+    data: {
+      email: normalizedEmail,
+      name: params.name ?? null,
+      notes: params.notes ?? null,
+      source: params.source ?? "MANUAL"
+    }
+  });
+  try {
+    await callbacks?.emitEvent?.("CONTACT_CREATED", {
+      entityType: "contact",
+      entityId: contact.id,
+      data: {
+        email: contact.email,
+        name: contact.name,
+        source: contact.source
+      }
+    });
+  } catch {
+  }
+  if (params.fields && Object.keys(params.fields).length > 0) {
+    try {
+      await callbacks?.setEntityFields?.(
+        "contact",
+        contact.id,
+        params.fields,
+        params.source ?? "MANUAL"
+      );
+    } catch {
+    }
+  }
+  return contact;
+}
+async function updateContact(db, id, data) {
+  const contact = await db.contact.findUnique({ where: { id } });
+  if (!contact) {
+    throw new ContactNotFoundError(id);
+  }
+  return db.contact.update({
+    where: { id },
+    data,
+    include: {
+      tags: { include: { tag: true } }
+    }
+  });
+}
+async function deleteContact(db, id) {
+  const contact = await db.contact.findUnique({ where: { id } });
+  if (!contact) {
+    throw new ContactNotFoundError(id);
+  }
+  await db.contact.delete({ where: { id } });
+  return { success: true };
+}
+async function findOrCreateContact(db, email, name, source = "EMAIL_SYNC") {
+  const normalizedEmail = email.toLowerCase();
+  const existing = await db.contact.findUnique({
+    where: { email: normalizedEmail }
+  });
+  if (existing) {
+    if (name && !existing.name) {
+      return db.contact.update({
+        where: { id: existing.id },
+        data: { name }
+      });
+    }
+    return existing;
+  }
+  return db.contact.create({
+    data: {
+      email: normalizedEmail,
+      name: name ?? null,
+      source
+    }
+  });
+}
+
+// src/knowledge/contact-fields-seed.ts
+var CONTACT_FIELD_DEFINITIONS = [
+  // --- Communication ---
+  { entityType: "contact", key: "preferred_contact_method", label: "Preferred Contact Method", dataType: "enum", category: "communication", enumOptions: ["email", "phone", "text", "in-person"], sortOrder: 0 },
+  { entityType: "contact", key: "preferred_contact_time", label: "Preferred Contact Time", dataType: "text", category: "communication", extractionHint: "Time of day or day of week the contact prefers to be reached", sortOrder: 1 },
+  { entityType: "contact", key: "timezone", label: "Timezone", dataType: "text", category: "communication", sortOrder: 2 },
+  // --- Professional ---
+  { entityType: "contact", key: "company", label: "Company", dataType: "text", category: "professional", sortOrder: 0 },
+  { entityType: "contact", key: "title", label: "Job Title", dataType: "text", category: "professional", sortOrder: 1 },
+  { entityType: "contact", key: "industry", label: "Industry", dataType: "text", category: "professional", sortOrder: 2 },
+  // --- Relationship ---
+  { entityType: "contact", key: "referral_source", label: "Referral Source", dataType: "text", category: "relationship", sortOrder: 0 },
+  { entityType: "contact", key: "relationship_type", label: "Relationship Type", dataType: "enum", category: "relationship", enumOptions: ["prospect", "vendor", "partner", "personal", "other"], sortOrder: 1 },
+  { entityType: "contact", key: "last_interaction_notes", label: "Last Interaction Notes", dataType: "text", category: "relationship", extractionHint: "Brief summary of last meaningful interaction", sortOrder: 2 }
+];
+async function seedContactFieldDefinitions(db) {
+  const result = await db.entityFieldDefinition.createMany({
+    data: CONTACT_FIELD_DEFINITIONS.map((d) => ({
+      entityType: d.entityType,
+      key: d.key,
+      label: d.label,
+      dataType: d.dataType,
+      category: d.category,
+      enumOptions: "enumOptions" in d ? d.enumOptions : null,
+      extractionHint: "extractionHint" in d ? d.extractionHint : null,
+      sortOrder: d.sortOrder,
+      status: "approved",
+      isActive: true
+    })),
+    skipDuplicates: true
+  });
+  return result.count;
+}
+
+// src/knowledge/schemas.ts
+import { z } from "zod";
+var ENTITY_TYPES = ["client", "contact", "order"];
+var FIELD_DATA_TYPES = ["text", "number", "date", "boolean", "enum", "multi-select"];
+var FIELD_STATUSES = ["suggested", "approved", "dismissed", "merged"];
+var LEDGER_SOURCES = ["manual", "note", "email", "agent", "ai-batch", "predicted"];
+var SEARCH_SOURCES = ["search_bar", "agent_chat", "api"];
+var CreateFieldDefinitionSchema = z.object({
+  entityType: z.enum(ENTITY_TYPES),
+  key: z.string().min(1).max(100).regex(/^[a-z][a-z0-9_]*$/, "Key must be lowercase snake_case"),
+  label: z.string().min(1).max(200),
+  dataType: z.enum(FIELD_DATA_TYPES),
+  category: z.string().min(1).max(100),
+  enumOptions: z.array(z.string()).optional(),
+  extractionHint: z.string().max(500).optional(),
+  sortOrder: z.number().int().min(0).default(0),
+  halfLifeDays: z.number().int().min(1).nullable().optional()
+});
+var UpdateFieldDefinitionSchema = z.object({
+  label: z.string().min(1).max(200).optional(),
+  category: z.string().min(1).max(100).optional(),
+  enumOptions: z.array(z.string()).optional(),
+  extractionHint: z.string().max(500).optional(),
+  status: z.enum(FIELD_STATUSES).optional(),
+  mergedIntoId: z.string().optional(),
+  sortOrder: z.number().int().min(0).optional(),
+  isActive: z.boolean().optional(),
+  halfLifeDays: z.number().int().min(1).nullable().optional(),
+  constraints: z.array(z.object({
+    targetField: z.string(),
+    operator: z.enum(["not_in", "in", "not_equal", "less_than", "greater_than", "regex"]),
+    values: z.array(z.unknown()).optional(),
+    value: z.unknown().optional(),
+    pattern: z.string().optional(),
+    message: z.string(),
+    severity: z.enum(["warning", "error"])
+  })).nullable().optional()
+});
+var ListFieldDefinitionsQuery = z.object({
+  entityType: z.enum(ENTITY_TYPES).optional(),
+  status: z.enum(FIELD_STATUSES).optional()
+});
+var SetEntityFieldsSchema = z.object({
+  fields: z.record(z.string(), z.unknown()).refine(
+    (obj) => Object.keys(obj).length > 0,
+    "At least one field is required"
+  ),
+  source: z.enum(LEDGER_SOURCES).default("manual"),
+  sourceId: z.string().optional(),
+  confidence: z.number().min(0).max(1).default(1)
+});
+var SearchByFieldsSchema = z.object({
+  entityType: z.enum(ENTITY_TYPES),
+  filters: z.record(z.string(), z.unknown()).refine(
+    (obj) => Object.keys(obj).length > 0,
+    "At least one filter is required"
+  ),
+  limit: z.number().int().min(1).max(100).default(50)
+});
+var LogSearchQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  source: z.enum(SEARCH_SOURCES),
+  userId: z.string().optional(),
+  entityType: z.enum(ENTITY_TYPES).optional(),
+  resultCount: z.number().int().min(0).optional()
+});
+var FieldHistoryQuery = z.object({
+  fieldId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(200).default(50)
+});
+
+// src/agent/schemas.ts
+import { z as z2 } from "zod";
+var QueryKnowledgeSchema = z2.object({
+  entity: z2.string().min(1).max(50),
+  field: z2.string().min(1).max(100).optional(),
+  search: z2.string().min(1).optional(),
+  category: z2.string().min(1).max(100).optional(),
+  limit: z2.coerce.number().int().min(1).max(200).default(50)
+});
+var CreateKnowledgeEntrySchema = z2.object({
+  entity: z2.string().min(1).max(50),
+  field: z2.string().min(1).max(100),
+  value: z2.string().min(1),
+  label: z2.string().min(1),
+  aliases: z2.array(z2.string().min(1)).default([]),
+  category: z2.string().min(1).max(100).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  sortOrder: z2.number().int().default(0)
+});
+var UpdateKnowledgeEntrySchema = z2.object({
+  label: z2.string().min(1).optional(),
+  aliases: z2.array(z2.string().min(1)).optional(),
+  category: z2.string().min(1).max(100).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  sortOrder: z2.number().int().optional(),
+  isActive: z2.boolean().optional()
+});
+var GetPreferencesSchema = z2.object({
+  entity: z2.string().min(1).max(50),
+  userId: z2.string().optional(),
+  field: z2.string().min(1).max(100).optional()
+});
+var SetPreferenceSchema = z2.object({
+  entity: z2.string().min(1).max(50),
+  field: z2.string().min(1).max(100),
+  value: z2.string().min(1),
+  label: z2.string().min(1),
+  conditions: z2.record(z2.string(), z2.unknown()).optional(),
+  userId: z2.string().optional(),
+  priority: z2.number().int().default(0)
+});
+
+// src/notes/schemas.ts
+import { z as z3 } from "zod";
+var AttachmentSchema = z3.object({
+  filename: z3.string().min(1).max(255),
+  mimeType: z3.string().min(1).max(100),
+  size: z3.number().int().min(1).max(10 * 1024 * 1024),
+  // 10MB
+  storagePath: z3.string().min(1).max(500)
+});
+var CreateNoteSchema = z3.object({
+  content: z3.string().min(1, "Note content is required").max(5e3, "Note content must be 5000 characters or fewer"),
+  contentHtml: z3.string().max(5e4).optional(),
+  isDraft: z3.boolean().default(false),
+  source: z3.enum(["MANUAL", "AGENT", "SYSTEM"]).default("MANUAL"),
+  attachments: z3.array(AttachmentSchema).max(5, "Maximum 5 attachments").default([]),
+  fields: z3.record(z3.string(), z3.unknown()).optional()
+});
+var UpdateNoteSchema = z3.object({
+  content: z3.string().min(1).max(5e3).optional(),
+  contentHtml: z3.string().max(5e4).optional(),
+  isDraft: z3.boolean().optional(),
+  attachments: z3.array(AttachmentSchema).max(5).optional()
+});
+var ListNotesQuery = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(50),
+  cursor: z3.string().optional(),
+  isDraft: z3.enum(["true", "false"]).optional()
+});
+
+// src/contacts/schemas.ts
+import { z as z4 } from "zod";
+var CreateContactSchema = z4.object({
+  email: z4.string().email().max(255),
+  name: z4.string().max(255).optional(),
+  notes: z4.string().max(5e3).optional(),
+  source: z4.enum(["EMAIL_SYNC", "MANUAL", "AUTOMATION", "IMPORT"]).default("MANUAL"),
+  fields: z4.record(z4.string(), z4.unknown()).optional()
+});
+var UpdateContactSchema = z4.object({
+  name: z4.string().max(255).optional().nullable(),
+  notes: z4.string().max(5e3).optional().nullable()
+});
+var ListContactsQuery = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(50),
+  offset: z4.coerce.number().int().min(0).default(0),
+  source: z4.enum(["EMAIL_SYNC", "MANUAL", "AUTOMATION", "IMPORT"]).optional(),
+  search: z4.string().max(200).optional(),
+  excludeConverted: z4.enum(["true", "false"]).default("true")
+});
+export {
+  AGENTKNOW_ERRORS,
+  AttachmentSchema,
+  CONTACT_FIELD_DEFINITIONS,
+  ContactAlreadyConvertedError,
+  ContactExistsError,
+  ContactNotFoundError,
+  CreateContactSchema,
+  CreateFieldDefinitionSchema,
+  CreateKnowledgeEntrySchema,
+  CreateNoteSchema,
+  DEFAULT_CONFLICT_RULES,
+  ENTITY_TYPES,
+  FIELD_DATA_TYPES,
+  FIELD_STATUSES,
+  FieldHistoryQuery,
+  GetPreferencesSchema,
+  KNOWLEDGE_ERRORS,
+  LEDGER_SOURCES,
+  ListContactsQuery,
+  ListFieldDefinitionsQuery,
+  ListNotesQuery,
+  LogSearchQuerySchema,
+  QueryKnowledgeSchema,
+  SEARCH_SOURCES,
+  SOURCE_RELIABILITY,
+  SearchByFieldsSchema,
+  SetEntityFieldsSchema,
+  SetPreferenceSchema,
+  UpdateContactSchema,
+  UpdateFieldDefinitionSchema,
+  UpdateKnowledgeEntrySchema,
+  UpdateNoteSchema,
+  agentKnowledgeError,
+  analyzeAndSuggest,
+  approveSuggestion,
+  buildCoOccurrenceMap,
+  checkConstraints,
+  classifyIntent,
+  computeComplexityScore,
+  computeDecayedConfidence,
+  computeEntityHealth,
+  computeEntityTruthScores,
+  computeOverallScore,
+  computeRecencyFactor,
+  computeRelationshipStrength,
+  computeTruthScore,
+  createContact,
+  createFieldDefinition,
+  createKnowledgeEntry,
+  createNote,
+  deleteContact,
+  deleteKnowledgeEntry,
+  deleteNote,
+  deletePreference,
+  detectConflicts,
+  dismissSuggestion,
+  ensureKnowledgeDefaults,
+  evaluateConflictRule,
+  evaluateConstraint,
+  extractModules,
+  extractTopic,
+  findOrCreateContact,
+  findRelatedEntities,
+  fireObservers,
+  formatStalenessWarnings,
+  getAllContacts,
+  getContactByEmail,
+  getContactById,
+  getEntityFields,
+  getEntityRelationships,
+  getEntityTypeHealth,
+  getFieldDefinitionById,
+  getFieldDefinitions,
+  getFieldHistory,
+  getFieldValueAt,
+  getInteractionCount,
+  getKnowledgeAt,
+  getKnowledgeTimeline,
+  getNotes,
+  getPreferences,
+  getRecentInteractions,
+  getStaleFields,
+  getSuggestions,
+  getTopicDistribution,
+  getWeekOfYear,
+  isStale,
+  knowledgeError,
+  logInteraction,
+  logSearchQuery,
+  markSatisfied,
+  predictGhostFields,
+  queryKnowledge,
+  resetKnowledgeDefaults,
+  resetSeedCheck,
+  scanForConflicts,
+  searchByFields,
+  seedContactFieldDefinitions,
+  setEntityFields,
+  setEntityFieldsWithBranching,
+  setPreference,
+  shouldBranch,
+  updateContact,
+  updateFieldDefinition,
+  updateKnowledgeEntry,
+  updateNote,
+  writeGhostFields
+};