@astralibx/call-log-engine 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2500 @@
+'use strict';
+
+var zod = require('zod');
+var core = require('@astralibx/core');
+var callLogTypes = require('@astralibx/call-log-types');
+var crypto5 = require('crypto');
+var mongoose = require('mongoose');
+var express = require('express');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto5__default = /*#__PURE__*/_interopDefault(crypto5);
+
+// src/index.ts
+var PipelineStageSchema = new mongoose.Schema(
+  {
+    stageId: { type: String, required: true, default: () => crypto5__default.default.randomUUID() },
+    name: { type: String, required: true },
+    color: { type: String, required: true },
+    order: { type: Number, required: true },
+    isTerminal: { type: Boolean, default: false },
+    isDefault: { type: Boolean, default: false }
+  },
+  { _id: false }
+);
+var PipelineSchema = new mongoose.Schema(
+  {
+    pipelineId: { type: String, required: true, unique: true, default: () => crypto5__default.default.randomUUID() },
+    name: { type: String, required: true },
+    description: { type: String },
+    stages: { type: [PipelineStageSchema], required: true },
+    isActive: { type: Boolean, default: true, index: true },
+    isDeleted: { type: Boolean, default: false },
+    isDefault: { type: Boolean, default: false },
+    createdBy: { type: String, required: true },
+    tenantId: { type: String, sparse: true },
+    metadata: { type: mongoose.Schema.Types.Mixed }
+  },
+  {
+    timestamps: true
+  }
+);
+function createPipelineModel(connection, prefix) {
+  const collectionName = prefix ? `${prefix}_pipelines` : "pipelines";
+  return connection.model("Pipeline", PipelineSchema, collectionName);
+}
+var ContactRefSchema = new mongoose.Schema(
+  {
+    externalId: { type: String, required: true },
+    displayName: { type: String, required: true },
+    phone: { type: String },
+    email: { type: String }
+  },
+  { _id: false }
+);
+var TimelineEntrySchema = new mongoose.Schema(
+  {
+    entryId: { type: String, required: true, default: () => crypto5__default.default.randomUUID() },
+    type: {
+      type: String,
+      required: true,
+      enum: Object.values(callLogTypes.TimelineEntryType)
+    },
+    content: { type: String },
+    authorId: { type: String },
+    authorName: { type: String },
+    fromStageId: { type: String },
+    fromStageName: { type: String },
+    toStageId: { type: String },
+    toStageName: { type: String },
+    fromAgentId: { type: String },
+    fromAgentName: { type: String },
+    toAgentId: { type: String },
+    toAgentName: { type: String },
+    createdAt: { type: Date, default: Date.now }
+  },
+  { _id: false }
+);
+var StageChangeSchema = new mongoose.Schema(
+  {
+    fromStageId: { type: String, required: true },
+    toStageId: { type: String, required: true },
+    fromStageName: { type: String, required: true },
+    toStageName: { type: String, required: true },
+    changedBy: { type: String, required: true },
+    changedAt: { type: Date, required: true },
+    timeInStageMs: { type: Number, required: true }
+  },
+  { _id: false }
+);
+var CallLogSchema = new mongoose.Schema(
+  {
+    callLogId: { type: String, required: true, unique: true, default: () => crypto5__default.default.randomUUID() },
+    pipelineId: { type: String, required: true, index: true },
+    currentStageId: { type: String, required: true, index: true },
+    contactRef: { type: ContactRefSchema, required: true },
+    direction: {
+      type: String,
+      required: true,
+      enum: Object.values(callLogTypes.CallDirection)
+    },
+    callDate: { type: Date, required: true, index: true },
+    nextFollowUpDate: { type: Date, index: true },
+    followUpNotifiedAt: { type: Date },
+    priority: {
+      type: String,
+      required: true,
+      enum: Object.values(callLogTypes.CallPriority),
+      default: callLogTypes.CallPriority.Medium
+    },
+    agentId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+    assignedBy: { type: String },
+    tags: { type: [String], default: [], index: true },
+    category: { type: String },
+    timeline: { type: [TimelineEntrySchema], default: [] },
+    stageHistory: { type: [StageChangeSchema], default: [] },
+    durationMinutes: { type: Number, min: 0 },
+    isClosed: { type: Boolean, default: false, index: true },
+    closedAt: { type: Date },
+    tenantId: { type: String, sparse: true },
+    metadata: { type: mongoose.Schema.Types.Mixed }
+  },
+  {
+    timestamps: true
+  }
+);
+CallLogSchema.index({ "contactRef.externalId": 1 });
+CallLogSchema.index({ pipelineId: 1, currentStageId: 1 });
+CallLogSchema.index({ agentId: 1, isClosed: 1 });
+function createCallLogModel(connection, prefix) {
+  const collectionName = prefix ? `${prefix}_call_logs` : "call_logs";
+  return connection.model("CallLog", CallLogSchema, collectionName);
+}
+
+// src/constants/index.ts
+var ERROR_CODE = {
+  PipelineNotFound: "CALL_PIPELINE_NOT_FOUND",
+  InvalidPipeline: "CALL_INVALID_PIPELINE",
+  StageNotFound: "CALL_STAGE_NOT_FOUND",
+  StageInUse: "CALL_STAGE_IN_USE",
+  CallLogNotFound: "CALL_LOG_NOT_FOUND",
+  CallLogClosed: "CALL_LOG_CLOSED",
+  ContactNotFound: "CALL_CONTACT_NOT_FOUND",
+  AgentCapacityFull: "CALL_AGENT_CAPACITY_FULL",
+  InvalidConfig: "CALL_INVALID_CONFIG",
+  AuthFailed: "CALL_AUTH_FAILED"
+};
+var ERROR_MESSAGE = {
+  PipelineNotFound: "Pipeline not found",
+  PipelineNoDefaultStage: "Pipeline must have exactly one default stage",
+  PipelineNoTerminalStage: "Pipeline must have at least one terminal stage",
+  PipelineDuplicateStageNames: "Stage names must be unique within a pipeline",
+  StageNotFound: "Stage not found in pipeline",
+  StageInUse: "Cannot remove stage that has active calls",
+  CallLogNotFound: "Call log not found",
+  CallLogClosed: "Cannot modify a closed call log",
+  ContactNotFound: "Contact not found",
+  AgentCapacityFull: "Agent has reached maximum concurrent calls",
+  AuthFailed: "Authentication failed"
+};
+var PIPELINE_DEFAULTS = {
+  MaxStages: 20
+};
+var CALL_LOG_DEFAULTS = {
+  MaxTimelineEntries: 200,
+  DefaultFollowUpDays: 3,
+  TimelinePageSize: 20
+};
+var AGENT_CALL_DEFAULTS = {
+  MaxConcurrentCalls: 10
+};
+var SYSTEM_TIMELINE = {
+  CallCreated: "Call log created",
+  CallClosed: "Call closed",
+  CallReopened: "Call reopened",
+  FollowUpCompleted: "Follow-up completed"
+};
+var SYSTEM_TIMELINE_FN = {
+  stageChanged: (from, to) => `Stage changed from "${from}" to "${to}"`,
+  callAssigned: (agentName) => `Call assigned to ${agentName}`,
+  callReassigned: (from, to) => `Call reassigned from ${from} to ${to}`,
+  followUpSet: (date) => `Follow-up scheduled for ${date}`
+};
+
+// src/schemas/call-log-settings.schema.ts
+var DEFAULT_PRIORITY_LEVELS = [
+  { value: callLogTypes.CallPriority.Low, label: "Low", color: "#6b7280", order: 1 },
+  { value: callLogTypes.CallPriority.Medium, label: "Medium", color: "#3b82f6", order: 2 },
+  { value: callLogTypes.CallPriority.High, label: "High", color: "#f59e0b", order: 3 },
+  { value: callLogTypes.CallPriority.Urgent, label: "Urgent", color: "#ef4444", order: 4 }
+];
+var PriorityConfigSchema = new mongoose.Schema(
+  {
+    value: { type: String, required: true },
+    label: { type: String, required: true },
+    color: { type: String, required: true },
+    order: { type: Number, required: true }
+  },
+  { _id: false }
+);
+var CallLogSettingsSchema = new mongoose.Schema(
+  {
+    key: { type: String, required: true, default: "global" },
+    availableTags: { type: [String], default: [] },
+    availableCategories: { type: [String], default: [] },
+    priorityLevels: {
+      type: [PriorityConfigSchema],
+      default: () => DEFAULT_PRIORITY_LEVELS.map((p) => ({ ...p }))
+    },
+    defaultFollowUpDays: {
+      type: Number,
+      default: CALL_LOG_DEFAULTS.DefaultFollowUpDays
+    },
+    followUpReminderEnabled: { type: Boolean, default: true },
+    defaultPipelineId: { type: String },
+    timelinePageSize: {
+      type: Number,
+      default: CALL_LOG_DEFAULTS.TimelinePageSize
+    },
+    maxConcurrentCalls: {
+      type: Number,
+      default: AGENT_CALL_DEFAULTS.MaxConcurrentCalls
+    },
+    tenantId: { type: String, sparse: true },
+    metadata: { type: mongoose.Schema.Types.Mixed }
+  },
+  {
+    timestamps: true
+  }
+);
+CallLogSettingsSchema.index({ key: 1, tenantId: 1 }, { unique: true });
+function createCallLogSettingsModel(connection, prefix) {
+  const collectionName = prefix ? `${prefix}_call_log_settings` : "call_log_settings";
+  return connection.model(
+    "CallLogSettings",
+    CallLogSettingsSchema,
+    collectionName
+  );
+}
+var AlxCallLogError = class extends core.AlxError {
+  constructor(message, code, context) {
+    super(message, code);
+    this.context = context;
+    this.name = "AlxCallLogError";
+  }
+};
+var PipelineNotFoundError = class extends AlxCallLogError {
+  constructor(pipelineId) {
+    super(`Pipeline not found: ${pipelineId}`, ERROR_CODE.PipelineNotFound, { pipelineId });
+    this.pipelineId = pipelineId;
+    this.name = "PipelineNotFoundError";
+  }
+};
+var InvalidPipelineError = class extends AlxCallLogError {
+  constructor(reason, pipelineId) {
+    super(
+      pipelineId ? `Invalid pipeline "${pipelineId}": ${reason}` : `Invalid pipeline: ${reason}`,
+      ERROR_CODE.InvalidPipeline,
+      { pipelineId, reason }
+    );
+    this.reason = reason;
+    this.pipelineId = pipelineId;
+    this.name = "InvalidPipelineError";
+  }
+};
+var StageNotFoundError = class extends AlxCallLogError {
+  constructor(pipelineId, stageId) {
+    super(
+      `Stage "${stageId}" not found in pipeline "${pipelineId}"`,
+      ERROR_CODE.StageNotFound,
+      { pipelineId, stageId }
+    );
+    this.pipelineId = pipelineId;
+    this.stageId = stageId;
+    this.name = "StageNotFoundError";
+  }
+};
+var StageInUseError = class extends AlxCallLogError {
+  constructor(pipelineId, stageId, activeCallCount) {
+    super(
+      `Cannot remove stage "${stageId}" in pipeline "${pipelineId}": ${activeCallCount} active call(s)`,
+      ERROR_CODE.StageInUse,
+      { pipelineId, stageId, activeCallCount }
+    );
+    this.pipelineId = pipelineId;
+    this.stageId = stageId;
+    this.activeCallCount = activeCallCount;
+    this.name = "StageInUseError";
+  }
+};
+var CallLogNotFoundError = class extends AlxCallLogError {
+  constructor(callLogId) {
+    super(`Call log not found: ${callLogId}`, ERROR_CODE.CallLogNotFound, { callLogId });
+    this.callLogId = callLogId;
+    this.name = "CallLogNotFoundError";
+  }
+};
+var CallLogClosedError = class extends AlxCallLogError {
+  constructor(callLogId, attemptedAction) {
+    super(
+      `Cannot ${attemptedAction} on closed call log "${callLogId}"`,
+      ERROR_CODE.CallLogClosed,
+      { callLogId, attemptedAction }
+    );
+    this.callLogId = callLogId;
+    this.attemptedAction = attemptedAction;
+    this.name = "CallLogClosedError";
+  }
+};
+var ContactNotFoundError = class extends AlxCallLogError {
+  constructor(contactQuery) {
+    super(
+      `Contact not found: ${JSON.stringify(contactQuery)}`,
+      ERROR_CODE.ContactNotFound,
+      { contactQuery }
+    );
+    this.contactQuery = contactQuery;
+    this.name = "ContactNotFoundError";
+  }
+};
+var AgentCapacityError = class extends AlxCallLogError {
+  constructor(agentId, currentCalls, maxCalls) {
+    super(
+      `Agent ${agentId} at capacity (${currentCalls}/${maxCalls})`,
+      ERROR_CODE.AgentCapacityFull,
+      { agentId, currentCalls, maxCalls }
+    );
+    this.agentId = agentId;
+    this.currentCalls = currentCalls;
+    this.maxCalls = maxCalls;
+    this.name = "AgentCapacityError";
+  }
+};
+var InvalidConfigError = class extends AlxCallLogError {
+  constructor(field, reason) {
+    super(`Invalid config for "${field}": ${reason}`, ERROR_CODE.InvalidConfig, { field, reason });
+    this.field = field;
+    this.reason = reason;
+    this.name = "InvalidConfigError";
+  }
+};
+var AuthFailedError = class extends AlxCallLogError {
+  constructor(reason) {
+    super(
+      reason ? `Authentication failed: ${reason}` : "Authentication failed",
+      ERROR_CODE.AuthFailed,
+      { reason }
+    );
+    this.reason = reason;
+    this.name = "AuthFailedError";
+  }
+};
+
+// src/services/settings.service.ts
+function validateIntegerRange(value, field, min, max) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new InvalidConfigError(field, `Must be an integer between ${min} and ${max}`);
+  }
+}
+var SettingsService = class {
+  constructor(CallLogSettings, logger, tenantId) {
+    this.CallLogSettings = CallLogSettings;
+    this.logger = logger;
+    this.tenantId = tenantId;
+  }
+  get settingsFilter() {
+    const filter = { key: "global" };
+    if (this.tenantId) filter.tenantId = this.tenantId;
+    return filter;
+  }
+  buildDefaults() {
+    const defaults = {
+      key: "global",
+      availableTags: [],
+      availableCategories: [],
+      priorityLevels: [],
+      defaultFollowUpDays: CALL_LOG_DEFAULTS.DefaultFollowUpDays,
+      followUpReminderEnabled: true,
+      timelinePageSize: CALL_LOG_DEFAULTS.TimelinePageSize,
+      maxConcurrentCalls: AGENT_CALL_DEFAULTS.MaxConcurrentCalls
+    };
+    if (this.tenantId) defaults.tenantId = this.tenantId;
+    return defaults;
+  }
+  async get() {
+    return this.CallLogSettings.findOneAndUpdate(
+      this.settingsFilter,
+      { $setOnInsert: this.buildDefaults() },
+      { upsert: true, new: true }
+    );
+  }
+  async update(data) {
+    if (data.defaultFollowUpDays != null) {
+      validateIntegerRange(data.defaultFollowUpDays, "defaultFollowUpDays", 1, 30);
+    }
+    if (data.timelinePageSize != null) {
+      validateIntegerRange(data.timelinePageSize, "timelinePageSize", 5, 100);
+    }
+    if (data.maxConcurrentCalls != null) {
+      validateIntegerRange(data.maxConcurrentCalls, "maxConcurrentCalls", 1, 50);
+    }
+    const settings = await this.CallLogSettings.findOneAndUpdate(
+      this.settingsFilter,
+      { $set: data },
+      { upsert: true, new: true }
+    );
+    this.logger.info("Call log settings updated", { fields: Object.keys(data) });
+    return settings;
+  }
+};
+
+// src/validation/pipeline.validator.ts
+function validatePipelineStages(stages, pipelineId) {
+  if (stages.length === 0) {
+    throw new InvalidPipelineError("Pipeline must have at least one stage", pipelineId);
+  }
+  const defaultStages = stages.filter((s) => s.isDefault);
+  if (defaultStages.length === 0) {
+    throw new InvalidPipelineError(
+      "Pipeline must have exactly one default stage",
+      pipelineId
+    );
+  }
+  if (defaultStages.length > 1) {
+    throw new InvalidPipelineError(
+      "Pipeline must have exactly one default stage",
+      pipelineId
+    );
+  }
+  const terminalStages = stages.filter((s) => s.isTerminal);
+  if (terminalStages.length === 0) {
+    throw new InvalidPipelineError(
+      "Pipeline must have at least one terminal stage",
+      pipelineId
+    );
+  }
+  const names = stages.map((s) => s.name);
+  const uniqueNames = new Set(names);
+  if (uniqueNames.size !== names.length) {
+    throw new InvalidPipelineError(
+      "Stage names must be unique within a pipeline",
+      pipelineId
+    );
+  }
+  if (stages.length > PIPELINE_DEFAULTS.MaxStages) {
+    throw new InvalidPipelineError(
+      `Pipeline cannot have more than ${PIPELINE_DEFAULTS.MaxStages} stages`,
+      pipelineId
+    );
+  }
+}
+
+// src/services/pipeline.service.ts
+var PipelineService = class {
+  constructor(Pipeline, CallLog, logger, tenantId) {
+    this.Pipeline = Pipeline;
+    this.CallLog = CallLog;
+    this.logger = logger;
+    this.tenantId = tenantId;
+  }
+  get tenantFilter() {
+    if (this.tenantId) return { tenantId: this.tenantId };
+    return {};
+  }
+  async create(data) {
+    const stages = data.stages.map((s) => ({
+      ...s,
+      stageId: crypto5__default.default.randomUUID()
+    }));
+    validatePipelineStages(stages);
+    const pipelineId = crypto5__default.default.randomUUID();
+    if (data.isDefault) {
+      await this.Pipeline.updateMany(
+        { ...this.tenantFilter, isDefault: true },
+        { $set: { isDefault: false } }
+      );
+    }
+    const pipeline = await this.Pipeline.create({
+      pipelineId,
+      name: data.name,
+      description: data.description,
+      stages,
+      isDefault: data.isDefault ?? false,
+      isActive: true,
+      isDeleted: false,
+      createdBy: data.createdBy,
+      ...data.tenantId ? { tenantId: data.tenantId } : this.tenantId ? { tenantId: this.tenantId } : {},
+      metadata: data.metadata
+    });
+    this.logger.info("Pipeline created", { pipelineId, name: data.name });
+    return pipeline;
+  }
+  async update(pipelineId, data) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false, ...this.tenantFilter });
+    if (!pipeline) throw new PipelineNotFoundError(pipelineId);
+    if (data.isDefault) {
+      await this.Pipeline.updateMany(
+        { ...this.tenantFilter, isDefault: true, pipelineId: { $ne: pipelineId } },
+        { $set: { isDefault: false } }
+      );
+    }
+    const updated = await this.Pipeline.findOneAndUpdate(
+      { pipelineId, isDeleted: false },
+      { $set: data },
+      { new: true }
+    );
+    if (!updated) throw new PipelineNotFoundError(pipelineId);
+    this.logger.info("Pipeline updated", { pipelineId, fields: Object.keys(data) });
+    return updated;
+  }
+  async delete(pipelineId) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false, ...this.tenantFilter });
+    if (!pipeline) throw new PipelineNotFoundError(pipelineId);
+    const activeCallCount = await this.CallLog.countDocuments({ pipelineId, isClosed: false });
+    if (activeCallCount > 0) {
+      throw new InvalidPipelineError(`Cannot delete pipeline with ${activeCallCount} active (non-closed) calls`, pipelineId);
+    }
+    await this.Pipeline.findOneAndUpdate(
+      { pipelineId, ...this.tenantFilter },
+      { $set: { isDeleted: true, isActive: false } }
+    );
+    this.logger.info("Pipeline deleted", { pipelineId });
+  }
+  async list(filter) {
+    const query = { isDeleted: false, ...this.tenantFilter };
+    if (filter?.isActive !== void 0) {
+      query.isActive = filter.isActive;
+    }
+    return this.Pipeline.find(query).sort({ createdAt: 1 });
+  }
+  async get(pipelineId) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false, ...this.tenantFilter });
+    if (!pipeline) throw new PipelineNotFoundError(pipelineId);
+    return pipeline;
+  }
+  async addStage(pipelineId, stage) {
+    const pipeline = await this.get(pipelineId);
+    const newStage = {
+      ...stage,
+      stageId: crypto5__default.default.randomUUID()
+    };
+    const updatedStages = [...pipeline.stages, newStage];
+    validatePipelineStages(updatedStages, pipelineId);
+    const updated = await this.Pipeline.findOneAndUpdate(
+      { pipelineId },
+      { $push: { stages: newStage } },
+      { new: true }
+    );
+    if (!updated) throw new PipelineNotFoundError(pipelineId);
+    this.logger.info("Stage added to pipeline", { pipelineId, stageId: newStage.stageId });
+    return updated;
+  }
+  async removeStage(pipelineId, stageId) {
+    const pipeline = await this.get(pipelineId);
+    const stageExists = pipeline.stages.some((s) => s.stageId === stageId);
+    if (!stageExists) throw new StageNotFoundError(pipelineId, stageId);
+    const activeCallCount = await this.CallLog.countDocuments({ pipelineId, currentStageId: stageId, isClosed: false });
+    if (activeCallCount > 0) {
+      throw new StageInUseError(pipelineId, stageId, activeCallCount);
+    }
+    const updatedStages = pipeline.stages.filter((s) => s.stageId !== stageId);
+    validatePipelineStages(updatedStages, pipelineId);
+    const updated = await this.Pipeline.findOneAndUpdate(
+      { pipelineId },
+      { $pull: { stages: { stageId } } },
+      { new: true }
+    );
+    if (!updated) throw new PipelineNotFoundError(pipelineId);
+    this.logger.info("Stage removed from pipeline", { pipelineId, stageId });
+    return updated;
+  }
+  async updateStage(pipelineId, stageId, data) {
+    const pipeline = await this.get(pipelineId);
+    const stageIndex = pipeline.stages.findIndex((s) => s.stageId === stageId);
+    if (stageIndex === -1) throw new StageNotFoundError(pipelineId, stageId);
+    const updatedStages = pipeline.stages.map((s) => {
+      const plain = s.toObject?.() ?? s;
+      if (s.stageId === stageId) {
+        return { ...plain, ...data, stageId };
+      }
+      return plain;
+    });
+    validatePipelineStages(updatedStages, pipelineId);
+    const setFields = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key !== "stageId") {
+        setFields[`stages.${stageIndex}.${key}`] = value;
+      }
+    }
+    const updated = await this.Pipeline.findOneAndUpdate(
+      { pipelineId },
+      { $set: setFields },
+      { new: true }
+    );
+    if (!updated) throw new PipelineNotFoundError(pipelineId);
+    this.logger.info("Stage updated in pipeline", { pipelineId, stageId, fields: Object.keys(data) });
+    return updated;
+  }
+  async reorderStages(pipelineId, stageIds) {
+    const pipeline = await this.get(pipelineId);
+    const existingIds = new Set(pipeline.stages.map((s) => s.stageId));
+    for (const id of stageIds) {
+      if (!existingIds.has(id)) throw new StageNotFoundError(pipelineId, id);
+    }
+    if (stageIds.length !== pipeline.stages.length) {
+      throw new InvalidPipelineError(
+        `reorderStages must include all ${pipeline.stages.length} stage IDs`,
+        pipelineId
+      );
+    }
+    const stageMap = new Map(pipeline.stages.map((s) => [s.stageId, s]));
+    const reorderedStages = stageIds.map((id, index) => {
+      const s = stageMap.get(id);
+      const plain = s.toObject?.() ?? s;
+      return { ...plain, order: index + 1 };
+    });
+    validatePipelineStages(reorderedStages, pipelineId);
+    const updated = await this.Pipeline.findOneAndUpdate(
+      { pipelineId },
+      { $set: { stages: reorderedStages } },
+      { new: true }
+    );
+    if (!updated) throw new PipelineNotFoundError(pipelineId);
+    this.logger.info("Stages reordered in pipeline", { pipelineId });
+    return updated;
+  }
+};
+var TimelineService = class {
+  constructor(CallLog, logger, options) {
+    this.CallLog = CallLog;
+    this.logger = logger;
+    this.options = options;
+  }
+  async addNote(callLogId, content, authorId, authorName) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (callLog.isClosed) throw new CallLogClosedError(callLogId, "add note");
+    const entry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.Note,
+      content,
+      authorId,
+      authorName,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.CallLog.updateOne(
+      { callLogId },
+      {
+        $push: {
+          timeline: {
+            $each: [entry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      }
+    );
+    this.logger.info("Note added to call log", { callLogId, entryId: entry.entryId });
+    return entry;
+  }
+  async addSystemEntry(callLogId, content) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    const entry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.System,
+      content,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.CallLog.updateOne(
+      { callLogId },
+      {
+        $push: {
+          timeline: {
+            $each: [entry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      }
+    );
+    this.logger.info("System entry added to call log", { callLogId, entryId: entry.entryId });
+    return entry;
+  }
+  async getTimeline(callLogId, pagination) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    const total = callLog.timeline.length;
+    const { page, limit } = pagination;
+    const skip = (page - 1) * limit;
+    const reversed = [...callLog.timeline].reverse();
+    const entries = reversed.slice(skip, skip + limit);
+    return { entries, total };
+  }
+  async getContactTimeline(externalId, pagination) {
+    const { page, limit } = pagination;
+    const skip = (page - 1) * limit;
+    const countResult = await this.CallLog.aggregate([
+      { $match: { "contactRef.externalId": externalId } },
+      { $unwind: "$timeline" },
+      { $count: "total" }
+    ]);
+    const total = countResult[0]?.total ?? 0;
+    const results = await this.CallLog.aggregate([
+      { $match: { "contactRef.externalId": externalId } },
+      { $unwind: "$timeline" },
+      { $sort: { "timeline.createdAt": -1 } },
+      { $skip: skip },
+      { $limit: limit },
+      {
+        $addFields: {
+          "timeline.callLogId": "$callLogId"
+        }
+      },
+      { $replaceRoot: { newRoot: "$timeline" } }
+    ]);
+    this.logger.info("Contact timeline fetched", { externalId, total, page, limit });
+    return { entries: results, total };
+  }
+};
+var CallLogService = class {
+  constructor(CallLog, Pipeline, timeline, logger, hooks, options) {
+    this.CallLog = CallLog;
+    this.Pipeline = Pipeline;
+    this.timeline = timeline;
+    this.logger = logger;
+    this.hooks = hooks;
+    this.options = options;
+  }
+  async create(data) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId: data.pipelineId, isDeleted: false });
+    if (!pipeline) throw new PipelineNotFoundError(data.pipelineId);
+    const defaultStage = pipeline.stages.find((s) => s.isDefault);
+    if (!defaultStage) throw new PipelineNotFoundError(data.pipelineId);
+    const callLogId = crypto5__default.default.randomUUID();
+    const initialEntry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.System,
+      content: SYSTEM_TIMELINE.CallCreated,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    const callLog = await this.CallLog.create({
+      callLogId,
+      pipelineId: data.pipelineId,
+      currentStageId: defaultStage.stageId,
+      contactRef: data.contactRef,
+      direction: data.direction,
+      callDate: data.callDate ? new Date(data.callDate) : /* @__PURE__ */ new Date(),
+      agentId: data.agentId,
+      priority: data.priority ?? callLogTypes.CallPriority.Medium,
+      tags: data.tags ?? [],
+      category: data.category,
+      nextFollowUpDate: data.nextFollowUpDate,
+      durationMinutes: data.durationMinutes,
+      timeline: [initialEntry],
+      stageHistory: [],
+      isClosed: false,
+      ...data.tenantId ? { tenantId: data.tenantId } : {},
+      metadata: data.metadata
+    });
+    this.logger.info("Call log created", { callLogId, pipelineId: data.pipelineId });
+    if (this.hooks.onCallCreated) {
+      await this.hooks.onCallCreated(callLog);
+    }
+    return callLog;
+  }
+  async update(callLogId, data) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (callLog.isClosed) throw new CallLogClosedError(callLogId, "update");
+    const setFields = {};
+    const pushEntries = [];
+    if (data.priority !== void 0) setFields.priority = data.priority;
+    if (data.tags !== void 0) setFields.tags = data.tags;
+    if (data.category !== void 0) setFields.category = data.category;
+    if (data.durationMinutes !== void 0) setFields.durationMinutes = data.durationMinutes;
+    if (data.nextFollowUpDate !== void 0) {
+      const prevDate = callLog.nextFollowUpDate?.toISOString();
+      const newDate = data.nextFollowUpDate?.toISOString();
+      if (prevDate !== newDate) {
+        setFields.nextFollowUpDate = data.nextFollowUpDate;
+        if (data.nextFollowUpDate) {
+          const followUpEntry = {
+            entryId: crypto5__default.default.randomUUID(),
+            type: callLogTypes.TimelineEntryType.FollowUpSet,
+            content: SYSTEM_TIMELINE_FN.followUpSet(new Date(data.nextFollowUpDate).toISOString()),
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          pushEntries.push(followUpEntry);
+        }
+      }
+    }
+    const updateOp = { $set: setFields };
+    if (pushEntries.length > 0) {
+      updateOp.$push = {
+        timeline: {
+          $each: pushEntries,
+          $slice: -this.options.maxTimelineEntries
+        }
+      };
+    }
+    const updated = await this.CallLog.findOneAndUpdate(
+      { callLogId },
+      updateOp,
+      { new: true }
+    );
+    if (!updated) throw new CallLogNotFoundError(callLogId);
+    this.logger.info("Call log updated", { callLogId, fields: Object.keys(data) });
+    return updated;
+  }
+  async changeStage(callLogId, newStageId, agentId) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (callLog.isClosed) throw new CallLogClosedError(callLogId, "change stage");
+    const currentStageId = callLog.currentStageId;
+    const pipeline = await this.Pipeline.findOne({ pipelineId: callLog.pipelineId, isDeleted: false });
+    if (!pipeline) throw new PipelineNotFoundError(callLog.pipelineId);
+    const currentStage = pipeline.stages.find((s) => s.stageId === currentStageId);
+    if (!currentStage) throw new StageNotFoundError(callLog.pipelineId, currentStageId);
+    const newStage = pipeline.stages.find((s) => s.stageId === newStageId);
+    if (!newStage) throw new StageNotFoundError(callLog.pipelineId, newStageId);
+    const now = /* @__PURE__ */ new Date();
+    const lastHistory = callLog.stageHistory[callLog.stageHistory.length - 1];
+    const stageStartTime = lastHistory?.changedAt?.getTime() ?? callLog.createdAt?.getTime() ?? now.getTime();
+    const timeInStageMs = now.getTime() - stageStartTime;
+    const stageChangeEntry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.StageChange,
+      content: SYSTEM_TIMELINE_FN.stageChanged(currentStage.name, newStage.name),
+      fromStageId: currentStageId,
+      fromStageName: currentStage.name,
+      toStageId: newStageId,
+      toStageName: newStage.name,
+      authorId: agentId,
+      createdAt: now
+    };
+    const stageHistoryEntry = {
+      fromStageId: currentStageId,
+      toStageId: newStageId,
+      fromStageName: currentStage.name,
+      toStageName: newStage.name,
+      changedBy: agentId,
+      changedAt: now,
+      timeInStageMs
+    };
+    const isTerminal = newStage.isTerminal;
+    const closeFields = isTerminal ? { currentStageId: newStageId, isClosed: true, closedAt: now } : { currentStageId: newStageId };
+    const result = await this.CallLog.findOneAndUpdate(
+      { callLogId, currentStageId },
+      {
+        $set: closeFields,
+        $push: {
+          stageHistory: stageHistoryEntry,
+          timeline: stageChangeEntry
+        }
+      },
+      { new: true }
+    );
+    if (!result) {
+      throw new CallLogClosedError(callLogId, "change stage (concurrent modification detected)");
+    }
+    this.logger.info("Call log stage changed", { callLogId, from: currentStageId, to: newStageId });
+    if (isTerminal && this.hooks.onCallClosed) {
+      await this.hooks.onCallClosed(result);
+    }
+    if (this.hooks.onStageChanged) {
+      await this.hooks.onStageChanged(result, currentStage.name, newStage.name);
+    }
+    return result;
+  }
+  async assign(callLogId, agentId, assignedBy) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    const previousAgentId = callLog.agentId?.toString();
+    const assignmentEntry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.Assignment,
+      content: previousAgentId ? SYSTEM_TIMELINE_FN.callReassigned(previousAgentId, agentId) : SYSTEM_TIMELINE_FN.callAssigned(agentId),
+      toAgentId: agentId,
+      fromAgentId: previousAgentId,
+      authorId: assignedBy,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    const updated = await this.CallLog.findOneAndUpdate(
+      { callLogId },
+      {
+        $set: { agentId, assignedBy },
+        $push: {
+          timeline: {
+            $each: [assignmentEntry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      },
+      { new: true }
+    );
+    if (!updated) throw new CallLogNotFoundError(callLogId);
+    this.logger.info("Call log assigned", { callLogId, agentId, assignedBy });
+    if (this.hooks.onCallAssigned) {
+      await this.hooks.onCallAssigned(updated, previousAgentId);
+    }
+    return updated;
+  }
+  async list(filter = {}) {
+    const query = {};
+    if (filter.pipelineId) query.pipelineId = filter.pipelineId;
+    if (filter.currentStageId) query.currentStageId = filter.currentStageId;
+    if (filter.agentId) query.agentId = filter.agentId;
+    if (filter.tags && filter.tags.length > 0) query.tags = { $in: filter.tags };
+    if (filter.category) query.category = filter.category;
+    if (filter.isClosed !== void 0) query.isClosed = filter.isClosed;
+    if (filter.contactExternalId) query["contactRef.externalId"] = filter.contactExternalId;
+    if (filter.contactName) query["contactRef.displayName"] = { $regex: filter.contactName, $options: "i" };
+    if (filter.contactPhone) query["contactRef.phone"] = { $regex: `^${filter.contactPhone}` };
+    if (filter.contactEmail) query["contactRef.email"] = filter.contactEmail;
+    if (filter.priority) query.priority = filter.priority;
+    if (filter.direction) query.direction = filter.direction;
+    if (filter.dateRange?.from || filter.dateRange?.to) {
+      const dateFilter = {};
+      if (filter.dateRange.from) dateFilter.$gte = new Date(filter.dateRange.from);
+      if (filter.dateRange.to) dateFilter.$lte = new Date(filter.dateRange.to);
+      query.callDate = dateFilter;
+    }
+    const page = filter.page ?? 1;
+    const limit = filter.limit ?? 20;
+    const skip = (page - 1) * limit;
+    const sort = filter.sort ?? { callDate: -1 };
+    const [callLogs, total] = await Promise.all([
+      this.CallLog.find(query).sort(sort).skip(skip).limit(limit),
+      this.CallLog.countDocuments(query)
+    ]);
+    return { callLogs, total, page, limit };
+  }
+  async get(callLogId) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    return callLog;
+  }
+  async getByContact(externalId) {
+    return this.CallLog.find({ "contactRef.externalId": externalId }).sort({ callDate: -1 });
+  }
+  async getFollowUpsDue(agentId, dateRange) {
+    const now = /* @__PURE__ */ new Date();
+    const query = {
+      nextFollowUpDate: { $lte: now },
+      isClosed: false,
+      followUpNotifiedAt: null
+    };
+    if (agentId) query.agentId = agentId;
+    if (dateRange?.from || dateRange?.to) {
+      const dateFilter = {};
+      if (dateRange.from) dateFilter.$gte = new Date(dateRange.from);
+      if (dateRange.to) dateFilter.$lte = new Date(dateRange.to);
+      query.nextFollowUpDate = { ...query.nextFollowUpDate, ...dateFilter };
+    }
+    return this.CallLog.find(query).sort({ nextFollowUpDate: 1 });
+  }
+  async bulkChangeStage(callLogIds, newStageId, agentId) {
+    const succeeded = [];
+    const failed = [];
+    for (const callLogId of callLogIds) {
+      try {
+        await this.changeStage(callLogId, newStageId, agentId);
+        succeeded.push(callLogId);
+      } catch (err) {
+        failed.push({
+          callLogId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this.logger.info("Bulk stage change completed", {
+      total: callLogIds.length,
+      succeeded: succeeded.length,
+      failed: failed.length
+    });
+    return { succeeded, failed, total: callLogIds.length };
+  }
+  async close(callLogId, agentId) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (callLog.isClosed) throw new CallLogClosedError(callLogId, "close");
+    const now = /* @__PURE__ */ new Date();
+    const closeEntry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.System,
+      content: SYSTEM_TIMELINE.CallClosed,
+      authorId: agentId,
+      createdAt: now
+    };
+    const updated = await this.CallLog.findOneAndUpdate(
+      { callLogId },
+      {
+        $set: { isClosed: true, closedAt: now },
+        $push: {
+          timeline: {
+            $each: [closeEntry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      },
+      { new: true }
+    );
+    if (!updated) throw new CallLogNotFoundError(callLogId);
+    this.logger.info("Call log closed", { callLogId, agentId });
+    if (this.hooks.onCallClosed) {
+      await this.hooks.onCallClosed(updated);
+    }
+    return updated;
+  }
+  async reopen(callLogId, agentId) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (!callLog.isClosed) throw new CallLogClosedError(callLogId, "reopen");
+    const now = /* @__PURE__ */ new Date();
+    const reopenEntry = {
+      entryId: crypto5__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.System,
+      content: SYSTEM_TIMELINE.CallReopened,
+      authorId: agentId,
+      createdAt: now
+    };
+    const updated = await this.CallLog.findOneAndUpdate(
+      { callLogId },
+      {
+        $set: { isClosed: false, closedAt: void 0 },
+        $push: {
+          timeline: {
+            $each: [reopenEntry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      },
+      { new: true }
+    );
+    if (!updated) throw new CallLogNotFoundError(callLogId);
+    this.logger.info("Call log reopened", { callLogId, agentId });
+    return updated;
+  }
+};
+
+// src/services/analytics.service.ts
+var AnalyticsService = class {
+  constructor(CallLog, Pipeline, logger, resolveAgent) {
+    this.CallLog = CallLog;
+    this.Pipeline = Pipeline;
+    this.logger = logger;
+    this.resolveAgent = resolveAgent;
+  }
+  async getAgentName(agentId) {
+    if (!this.resolveAgent) return String(agentId);
+    try {
+      const agent = await this.resolveAgent(String(agentId));
+      return agent?.displayName ?? String(agentId);
+    } catch {
+      return String(agentId);
+    }
+  }
+  buildDateMatch(dateRange, field = "callDate") {
+    if (!dateRange.from && !dateRange.to) return {};
+    const dateFilter = {};
+    if (dateRange.from) dateFilter.$gte = new Date(dateRange.from);
+    if (dateRange.to) dateFilter.$lte = new Date(dateRange.to);
+    return { [field]: dateFilter };
+  }
+  async getAgentStats(agentId, dateRange) {
+    const now = /* @__PURE__ */ new Date();
+    const matchStage = {
+      agentId,
+      ...this.buildDateMatch(dateRange)
+    };
+    const pipeline = [
+      { $match: matchStage },
+      {
+        $group: {
+          _id: "$agentId",
+          totalCalls: { $sum: 1 },
+          callsClosed: {
+            $sum: { $cond: [{ $eq: ["$isClosed", true] }, 1, 0] }
+          },
+          followUpsCompleted: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $eq: ["$isClosed", true] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          },
+          overdueFollowUps: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $lt: ["$nextFollowUpDate", now] },
+                    { $eq: ["$isClosed", false] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          }
+        }
+      }
+    ];
+    const [results, pipelineCounts] = await Promise.all([
+      this.CallLog.aggregate(pipeline),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $group: { _id: "$pipelineId", count: { $sum: 1 } } }
+      ])
+    ]);
+    const stat = results[0];
+    const agentName = await this.getAgentName(agentId);
+    if (!stat) {
+      return {
+        agentId,
+        agentName,
+        totalCalls: 0,
+        avgCallsPerDay: 0,
+        followUpsCompleted: 0,
+        overdueFollowUps: 0,
+        callsByPipeline: [],
+        callsClosed: 0,
+        closeRate: 0
+      };
+    }
+    let avgCallsPerDay = 0;
+    if (dateRange.from && dateRange.to) {
+      const days = Math.max(
+        1,
+        Math.ceil((new Date(dateRange.to).getTime() - new Date(dateRange.from).getTime()) / 864e5)
+      );
+      avgCallsPerDay = Math.round(stat.totalCalls / days * 100) / 100;
+    }
+    const callsByPipeline = pipelineCounts.map((p) => ({
+      pipelineId: p._id,
+      pipelineName: p._id,
+      count: p.count
+    }));
+    return {
+      agentId,
+      agentName,
+      totalCalls: stat.totalCalls,
+      avgCallsPerDay,
+      followUpsCompleted: stat.followUpsCompleted,
+      overdueFollowUps: stat.overdueFollowUps,
+      callsByPipeline,
+      callsClosed: stat.callsClosed,
+      closeRate: stat.totalCalls > 0 ? Math.round(stat.callsClosed / stat.totalCalls * 1e4) / 100 : 0
+    };
+  }
+  async getAgentLeaderboard(dateRange) {
+    const now = /* @__PURE__ */ new Date();
+    const matchStage = this.buildDateMatch(dateRange);
+    const pipeline = [
+      { $match: matchStage },
+      {
+        $group: {
+          _id: "$agentId",
+          totalCalls: { $sum: 1 },
+          callsClosed: {
+            $sum: { $cond: [{ $eq: ["$isClosed", true] }, 1, 0] }
+          },
+          followUpsCompleted: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $eq: ["$isClosed", true] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          },
+          overdueFollowUps: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $lt: ["$nextFollowUpDate", now] },
+                    { $eq: ["$isClosed", false] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          }
+        }
+      },
+      { $sort: { totalCalls: -1 } }
+    ];
+    const results = await this.CallLog.aggregate(pipeline);
+    return Promise.all(results.map(async (stat) => ({
+      agentId: String(stat._id),
+      agentName: await this.getAgentName(String(stat._id)),
+      totalCalls: stat.totalCalls,
+      avgCallsPerDay: 0,
+      followUpsCompleted: stat.followUpsCompleted,
+      overdueFollowUps: stat.overdueFollowUps,
+      callsByPipeline: [],
+      callsClosed: stat.callsClosed,
+      closeRate: stat.totalCalls > 0 ? Math.round(stat.callsClosed / stat.totalCalls * 1e4) / 100 : 0
+    })));
+  }
+  async getPipelineStats(pipelineId, dateRange) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false });
+    const pipelineName = pipeline?.name ?? pipelineId;
+    const stages = pipeline?.stages ?? [];
+    const matchStage = {
+      pipelineId,
+      ...this.buildDateMatch(dateRange)
+    };
+    const [totalResult, stageAgg] = await Promise.all([
+      this.CallLog.countDocuments(matchStage),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $unwind: { path: "$stageHistory", preserveNullAndEmptyArrays: false } },
+        {
+          $group: {
+            _id: "$stageHistory.toStageId",
+            count: { $sum: 1 },
+            totalTimeMs: { $sum: "$stageHistory.timeInStageMs" }
+          }
+        },
+        {
+          $project: {
+            stageId: "$_id",
+            count: 1,
+            totalTimeMs: 1
+          }
+        }
+      ])
+    ]);
+    const totalCalls = totalResult;
+    const stageMap = new Map(stageAgg.map((s) => [s.stageId, s]));
+    let bottleneckStage = null;
+    let maxAvgTime = 0;
+    const stageStats = stages.map((s) => {
+      const agg = stageMap.get(s.stageId);
+      const count = agg?.count ?? 0;
+      const avgTimeMs = count > 0 ? Math.round((agg?.totalTimeMs ?? 0) / count) : 0;
+      const conversionRate = totalCalls > 0 ? Math.round(count / totalCalls * 1e4) / 100 : 0;
+      if (avgTimeMs > maxAvgTime) {
+        maxAvgTime = avgTimeMs;
+        bottleneckStage = s.stageId;
+      }
+      return {
+        stageId: s.stageId,
+        stageName: s.name,
+        count,
+        avgTimeMs,
+        conversionRate
+      };
+    });
+    this.logger.info("Pipeline stats computed", { pipelineId, totalCalls });
+    return {
+      pipelineId,
+      pipelineName,
+      totalCalls,
+      stages: stageStats,
+      bottleneckStage
+    };
+  }
+  async getPipelineFunnel(pipelineId, dateRange) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false });
+    const pipelineName = pipeline?.name ?? pipelineId;
+    const stages = pipeline?.stages ?? [];
+    const matchStage = {
+      pipelineId,
+      ...this.buildDateMatch(dateRange)
+    };
+    const [enteredAgg, exitedAgg] = await Promise.all([
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $unwind: "$stageHistory" },
+        { $group: { _id: "$stageHistory.toStageId", count: { $sum: 1 } } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $unwind: "$stageHistory" },
+        { $group: { _id: "$stageHistory.fromStageId", count: { $sum: 1 } } }
+      ])
+    ]);
+    const enteredMap = new Map(enteredAgg.map((r) => [String(r._id), r.count]));
+    const exitedMap = new Map(exitedAgg.map((r) => [String(r._id), r.count]));
+    const funnelStages = stages.map((s) => {
+      const entered = enteredMap.get(s.stageId) ?? 0;
+      const exited = exitedMap.get(s.stageId) ?? 0;
+      return {
+        stageId: s.stageId,
+        stageName: s.name,
+        entered,
+        exited,
+        dropOff: Math.max(0, entered - exited)
+      };
+    });
+    return { pipelineId, pipelineName, stages: funnelStages };
+  }
+  async getTeamStats(teamId, dateRange = {}) {
+    const now = /* @__PURE__ */ new Date();
+    const matchStage = this.buildDateMatch(dateRange);
+    const pipeline = [
+      { $match: matchStage },
+      {
+        $group: {
+          _id: "$agentId",
+          totalCalls: { $sum: 1 },
+          callsClosed: {
+            $sum: { $cond: [{ $eq: ["$isClosed", true] }, 1, 0] }
+          },
+          followUpsCompleted: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $eq: ["$isClosed", true] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          },
+          overdueFollowUps: {
+            $sum: {
+              $cond: [
+                {
+                  $and: [
+                    { $ne: ["$nextFollowUpDate", null] },
+                    { $lt: ["$nextFollowUpDate", now] },
+                    { $eq: ["$isClosed", false] }
+                  ]
+                },
+                1,
+                0
+              ]
+            }
+          }
+        }
+      }
+    ];
+    const results = await this.CallLog.aggregate(pipeline);
+    const agentStats = await Promise.all(results.map(async (stat) => ({
+      agentId: String(stat._id),
+      agentName: await this.getAgentName(String(stat._id)),
+      totalCalls: stat.totalCalls,
+      avgCallsPerDay: 0,
+      followUpsCompleted: stat.followUpsCompleted,
+      overdueFollowUps: stat.overdueFollowUps,
+      callsByPipeline: [],
+      callsClosed: stat.callsClosed,
+      closeRate: stat.totalCalls > 0 ? Math.round(stat.callsClosed / stat.totalCalls * 1e4) / 100 : 0
+    })));
+    const totalCalls = agentStats.reduce((sum, a) => sum + a.totalCalls, 0);
+    return { teamId: teamId ?? null, agentStats, totalCalls };
+  }
+  async getDailyReport(dateRange) {
+    const matchStage = this.buildDateMatch(dateRange);
+    const [dailyAgg, directionAgg, pipelineAgg, agentAgg] = await Promise.all([
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: { $dateToString: { format: "%Y-%m-%d", date: "$callDate" } },
+            count: { $sum: 1 }
+          }
+        },
+        { $sort: { _id: 1 } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: {
+              date: { $dateToString: { format: "%Y-%m-%d", date: "$callDate" } },
+              direction: "$direction"
+            },
+            count: { $sum: 1 }
+          }
+        }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: {
+              date: { $dateToString: { format: "%Y-%m-%d", date: "$callDate" } },
+              pipelineId: "$pipelineId"
+            },
+            count: { $sum: 1 }
+          }
+        }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: {
+              date: { $dateToString: { format: "%Y-%m-%d", date: "$callDate" } },
+              agentId: { $toString: "$agentId" }
+            },
+            count: { $sum: 1 }
+          }
+        }
+      ])
+    ]);
+    const directionByDate = /* @__PURE__ */ new Map();
+    for (const r of directionAgg) {
+      const date = r._id.date;
+      if (!directionByDate.has(date)) directionByDate.set(date, []);
+      directionByDate.get(date).push({ direction: r._id.direction, count: r.count });
+    }
+    const pipelineByDate = /* @__PURE__ */ new Map();
+    for (const r of pipelineAgg) {
+      const date = r._id.date;
+      if (!pipelineByDate.has(date)) pipelineByDate.set(date, []);
+      pipelineByDate.get(date).push({ pipelineId: r._id.pipelineId, pipelineName: r._id.pipelineId, count: r.count });
+    }
+    const agentByDate = /* @__PURE__ */ new Map();
+    await Promise.all(agentAgg.map(async (r) => {
+      const date = r._id.date;
+      if (!agentByDate.has(date)) agentByDate.set(date, []);
+      const agentName = await this.getAgentName(r._id.agentId);
+      agentByDate.get(date).push({ agentId: r._id.agentId, agentName, count: r.count });
+    }));
+    return dailyAgg.map((d) => ({
+      date: d._id,
+      total: d.count,
+      byDirection: directionByDate.get(d._id) ?? [],
+      byPipeline: pipelineByDate.get(d._id) ?? [],
+      byAgent: agentByDate.get(d._id) ?? []
+    }));
+  }
+  async getDashboardStats() {
+    const now = /* @__PURE__ */ new Date();
+    const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const [openCalls, closedToday, overdueFollowUps, callsToday] = await Promise.all([
+      this.CallLog.countDocuments({ isClosed: false }),
+      this.CallLog.countDocuments({ closedAt: { $gte: midnight } }),
+      this.CallLog.countDocuments({
+        nextFollowUpDate: { $lt: now },
+        isClosed: false
+      }),
+      this.CallLog.countDocuments({ callDate: { $gte: midnight } })
+    ]);
+    return {
+      openCalls,
+      closedToday,
+      overdueFollowUps,
+      totalAgents: 0,
+      callsToday
+    };
+  }
+  async getWeeklyTrends(weeks) {
+    const now = /* @__PURE__ */ new Date();
+    const from = new Date(now.getTime() - weeks * 7 * 24 * 60 * 60 * 1e3);
+    const results = await this.CallLog.aggregate([
+      { $match: { callDate: { $gte: from, $lte: now } } },
+      {
+        $group: {
+          _id: {
+            week: { $isoWeek: "$callDate" },
+            year: { $isoWeekYear: "$callDate" }
+          },
+          totalCalls: { $sum: 1 },
+          closedCalls: {
+            $sum: { $cond: [{ $eq: ["$isClosed", true] }, 1, 0] }
+          }
+        }
+      },
+      { $sort: { "_id.year": 1, "_id.week": 1 } },
+      {
+        $project: {
+          _id: 0,
+          week: { $toString: "$_id.week" },
+          year: "$_id.year",
+          totalCalls: 1,
+          closedCalls: 1
+        }
+      }
+    ]);
+    return results;
+  }
+  async getOverallReport(dateRange) {
+    const matchStage = this.buildDateMatch(dateRange);
+    const [summaryAgg, tagAgg, categoryAgg, peakHoursAgg, followUpAgg] = await Promise.all([
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: null,
+            totalCalls: { $sum: 1 },
+            closedCalls: {
+              $sum: { $cond: [{ $eq: ["$isClosed", true] }, 1, 0] }
+            },
+            avgTimeToCloseMs: {
+              $avg: {
+                $cond: [
+                  { $and: [{ $eq: ["$isClosed", true] }, { $ne: ["$closedAt", null] }] },
+                  { $subtract: ["$closedAt", "$createdAt"] },
+                  null
+                ]
+              }
+            }
+          }
+        }
+      ]),
+      this.CallLog.aggregate([
+        { $match: { ...matchStage, tags: { $exists: true, $ne: [] } } },
+        { $unwind: "$tags" },
+        { $group: { _id: "$tags", count: { $sum: 1 } } },
+        { $sort: { count: -1 } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: { ...matchStage, category: { $exists: true, $ne: null } } },
+        { $group: { _id: "$category", count: { $sum: 1 } } },
+        { $sort: { count: -1 } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $group: { _id: { $hour: "$callDate" }, count: { $sum: 1 } } },
+        { $sort: { _id: 1 } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        {
+          $group: {
+            _id: null,
+            total: { $sum: 1 },
+            withFollowUp: {
+              $sum: { $cond: [{ $ne: ["$nextFollowUpDate", null] }, 1, 0] }
+            },
+            completed: {
+              $sum: {
+                $cond: [
+                  {
+                    $and: [
+                      { $ne: ["$nextFollowUpDate", null] },
+                      { $eq: ["$isClosed", true] }
+                    ]
+                  },
+                  1,
+                  0
+                ]
+              }
+            }
+          }
+        }
+      ])
+    ]);
+    const summary = summaryAgg[0] ?? { totalCalls: 0, closedCalls: 0, avgTimeToCloseMs: 0 };
+    const followUp = followUpAgg[0] ?? { withFollowUp: 0, completed: 0 };
+    const followUpComplianceRate = followUp.withFollowUp > 0 ? Math.round(followUp.completed / followUp.withFollowUp * 1e4) / 100 : 0;
+    return {
+      totalCalls: summary.totalCalls,
+      closedCalls: summary.closedCalls,
+      avgTimeToCloseMs: Math.round(summary.avgTimeToCloseMs ?? 0),
+      followUpComplianceRate,
+      tagDistribution: tagAgg.map((r) => ({ tag: String(r._id), count: r.count })),
+      categoryDistribution: categoryAgg.map((r) => ({ category: String(r._id), count: r.count })),
+      peakCallHours: peakHoursAgg.map((r) => ({ hour: Number(r._id), count: r.count }))
+    };
+  }
+};
+
+// src/services/export.service.ts
+var CSV_HEADER = "callLogId,contactName,contactPhone,contactEmail,direction,pipelineId,currentStageId,priority,agentId,callDate,isClosed,tags";
+var ExportService = class {
+  constructor(CallLog, analytics, logger) {
+    this.CallLog = CallLog;
+    this.analytics = analytics;
+    this.logger = logger;
+  }
+  async exportCallLog(callLogId, format) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    if (format === "csv") {
+      return this.toCSV([callLog]);
+    }
+    return JSON.stringify(
+      callLog.toObject ? callLog.toObject() : callLog,
+      null,
+      2
+    );
+  }
+  async exportCallLogs(filter, format) {
+    const query = {};
+    if (filter.pipelineId) query.pipelineId = filter.pipelineId;
+    if (filter.stageId) query.currentStageId = filter.stageId;
+    if (filter.agentId) query.agentId = filter.agentId;
+    if (filter.tags && filter.tags.length > 0) query.tags = { $in: filter.tags };
+    if (filter.category) query.category = filter.category;
+    if (filter.isClosed !== void 0) query.isClosed = filter.isClosed;
+    if (filter.dateFrom || filter.dateTo) {
+      const dateFilter = {};
+      if (filter.dateFrom) dateFilter.$gte = new Date(filter.dateFrom);
+      if (filter.dateTo) dateFilter.$lte = new Date(filter.dateTo);
+      query.callDate = dateFilter;
+    }
+    const callLogs = await this.CallLog.find(query).sort({ callDate: -1 });
+    if (format === "csv") {
+      return this.toCSV(callLogs);
+    }
+    return JSON.stringify(
+      callLogs.map(
+        (c) => c.toObject ? c.toObject() : c
+      ),
+      null,
+      2
+    );
+  }
+  async exportPipelineReport(pipelineId, dateRange, format) {
+    const report = await this.analytics.getPipelineStats(pipelineId, dateRange);
+    if (format === "csv") {
+      const header = "pipelineId,pipelineName,totalCalls,stageId,stageName,count,avgTimeMs,conversionRate,bottleneckStage";
+      const rows = [header];
+      for (const stage of report.stages) {
+        rows.push(
+          [
+            this.escapeCSV(report.pipelineId),
+            this.escapeCSV(report.pipelineName),
+            String(report.totalCalls),
+            this.escapeCSV(stage.stageId),
+            this.escapeCSV(stage.stageName),
+            String(stage.count),
+            String(stage.avgTimeMs),
+            String(stage.conversionRate),
+            this.escapeCSV(report.bottleneckStage ?? "")
+          ].join(",")
+        );
+      }
+      this.logger.info("Pipeline report exported as CSV", { pipelineId });
+      return rows.join("\n");
+    }
+    this.logger.info("Pipeline report exported as JSON", { pipelineId });
+    return JSON.stringify(report, null, 2);
+  }
+  toCSV(callLogs) {
+    const rows = [CSV_HEADER];
+    for (const c of callLogs) {
+      const row = [
+        this.escapeCSV(c.callLogId),
+        this.escapeCSV(c.contactRef?.displayName ?? ""),
+        this.escapeCSV(c.contactRef?.phone ?? ""),
+        this.escapeCSV(c.contactRef?.email ?? ""),
+        this.escapeCSV(c.direction ?? ""),
+        this.escapeCSV(c.pipelineId ?? ""),
+        this.escapeCSV(c.currentStageId ?? ""),
+        this.escapeCSV(c.priority ?? ""),
+        this.escapeCSV(c.agentId?.toString() ?? ""),
+        c.callDate ? new Date(c.callDate).toISOString() : "",
+        String(c.isClosed ?? false),
+        this.escapeCSV((c.tags ?? []).join(";"))
+      ].join(",");
+      rows.push(row);
+    }
+    return rows.join("\n");
+  }
+  escapeCSV(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+      return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+  }
+};
+function createPipelineRoutes(pipeline, logger) {
+  const router = express.Router();
+  router.get("/", async (req, res) => {
+    try {
+      const isActive = req.query["isActive"] !== void 0 ? req.query["isActive"] === "true" : void 0;
+      const result = await pipeline.list({ isActive });
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to list pipelines", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const result = await pipeline.create(req.body);
+      core.sendSuccess(res, result, 201);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to create pipeline", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const result = await pipeline.get(req.params["id"]);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get pipeline", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id", async (req, res) => {
+    try {
+      const result = await pipeline.update(req.params["id"], req.body);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to update pipeline", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.delete("/:id", async (req, res) => {
+    try {
+      await pipeline.delete(req.params["id"]);
+      core.sendSuccess(res, void 0);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to delete pipeline", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.post("/:id/stages", async (req, res) => {
+    try {
+      const result = await pipeline.addStage(req.params["id"], req.body);
+      core.sendSuccess(res, result, 201);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to add stage", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/stages/reorder", async (req, res) => {
+    try {
+      const { stageIds } = req.body;
+      const result = await pipeline.reorderStages(req.params["id"], stageIds);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to reorder stages", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/stages/:stageId", async (req, res) => {
+    try {
+      const result = await pipeline.updateStage(req.params["id"], req.params["stageId"], req.body);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to update stage", { id: req.params["id"], stageId: req.params["stageId"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.delete("/:id/stages/:stageId", async (req, res) => {
+    try {
+      await pipeline.removeStage(req.params["id"], req.params["stageId"]);
+      core.sendSuccess(res, void 0);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to remove stage", { id: req.params["id"], stageId: req.params["stageId"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  return router;
+}
+function createCallLogRoutes(services, logger) {
+  const router = express.Router();
+  const { callLogs, timeline } = services;
+  router.get("/follow-ups", async (req, res) => {
+    try {
+      const { agentId } = req.query;
+      const dateRange = {
+        from: req.query["from"],
+        to: req.query["to"]
+      };
+      const result = await callLogs.getFollowUpsDue(agentId, dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get follow-ups", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/-/bulk/stage", async (req, res) => {
+    try {
+      const { callLogIds, newStageId, agentId } = req.body;
+      const result = await callLogs.bulkChangeStage(callLogIds, newStageId, agentId);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to bulk change stage", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/", async (req, res) => {
+    try {
+      const query = req.query;
+      const filter = {};
+      if (query["pipelineId"]) filter["pipelineId"] = query["pipelineId"];
+      if (query["currentStageId"]) filter["currentStageId"] = query["currentStageId"];
+      if (query["agentId"]) filter["agentId"] = query["agentId"];
+      if (query["category"]) filter["category"] = query["category"];
+      if (query["isClosed"] !== void 0) filter["isClosed"] = query["isClosed"] === "true";
+      if (query["contactExternalId"]) filter["contactExternalId"] = query["contactExternalId"];
+      if (query["contactName"]) filter["contactName"] = query["contactName"];
+      if (query["contactPhone"]) filter["contactPhone"] = query["contactPhone"];
+      if (query["contactEmail"]) filter["contactEmail"] = query["contactEmail"];
+      if (query["priority"]) filter["priority"] = query["priority"];
+      if (query["direction"]) filter["direction"] = query["direction"];
+      if (query["page"]) filter["page"] = parseInt(query["page"], 10);
+      if (query["limit"]) filter["limit"] = parseInt(query["limit"], 10);
+      if (query["from"] || query["to"]) {
+        filter["dateRange"] = { from: query["from"], to: query["to"] };
+      }
+      const result = await callLogs.list(filter);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to list call logs", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const result = await callLogs.create(req.body);
+      core.sendSuccess(res, result, 201);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to create call log", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const result = await callLogs.get(req.params["id"]);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id", async (req, res) => {
+    try {
+      const result = await callLogs.update(req.params["id"], req.body);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to update call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/stage", async (req, res) => {
+    try {
+      const { newStageId, agentId } = req.body;
+      const result = await callLogs.changeStage(req.params["id"], newStageId, agentId);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to change stage", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/assign", async (req, res) => {
+    try {
+      const { agentId, assignedBy } = req.body;
+      const result = await callLogs.assign(req.params["id"], agentId, assignedBy);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to assign call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/close", async (req, res) => {
+    try {
+      const { agentId } = req.body;
+      const result = await callLogs.close(req.params["id"], agentId);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to close call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/:id/reopen", async (req, res) => {
+    try {
+      const { agentId } = req.body;
+      const result = await callLogs.reopen(req.params["id"], agentId);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to reopen call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.post("/:id/notes", async (req, res) => {
+    try {
+      const { content, authorId, authorName } = req.body;
+      const result = await timeline.addNote(req.params["id"], content, authorId, authorName);
+      core.sendSuccess(res, result, 201);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to add timeline note", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/:id/timeline", async (req, res) => {
+    try {
+      const page = parseInt(req.query["page"] || "1", 10);
+      const limit = parseInt(req.query["limit"] || "50", 10);
+      const result = await timeline.getTimeline(req.params["id"], { page, limit });
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get timeline", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  return router;
+}
+function createContactRoutes(services, logger) {
+  const router = express.Router();
+  const { callLogs, timeline } = services;
+  router.get("/:externalId/calls", async (req, res) => {
+    try {
+      const result = await callLogs.getByContact(req.params["externalId"]);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get calls for contact", { externalId: req.params["externalId"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/:externalId/timeline", async (req, res) => {
+    try {
+      const page = parseInt(req.query["page"] || "1", 10);
+      const limit = parseInt(req.query["limit"] || "20", 10);
+      const result = await timeline.getContactTimeline(req.params["externalId"], { page, limit });
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get contact timeline", { externalId: req.params["externalId"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  return router;
+}
+function createAnalyticsRoutes(analytics, logger) {
+  const router = express.Router();
+  function parseDateRange(query) {
+    return {
+      from: query["from"],
+      to: query["to"]
+    };
+  }
+  router.get("/stats", async (req, res) => {
+    try {
+      const result = await analytics.getDashboardStats();
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get dashboard stats", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/agent/:agentId", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getAgentStats(req.params["agentId"], dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get agent stats", { agentId: req.params["agentId"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/agent-leaderboard", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getAgentLeaderboard(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get agent leaderboard", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/pipeline/:id", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getPipelineStats(req.params["id"], dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get pipeline stats", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/pipeline/:id/funnel", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getPipelineFunnel(req.params["id"], dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get pipeline funnel", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/team", async (req, res) => {
+    try {
+      const { teamId } = req.query;
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getTeamStats(teamId, dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get team stats", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/daily", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getDailyReport(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get daily report", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/weekly-trends", async (req, res) => {
+    try {
+      const weeks = parseInt(req.query["weeks"] || "4", 10);
+      const result = await analytics.getWeeklyTrends(weeks);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get weekly trends", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/overall", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await analytics.getOverallReport(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get overall report", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  return router;
+}
+function createSettingsRoutes(settings, exportSvc, logger) {
+  const router = express.Router();
+  router.get("/settings", async (_req, res) => {
+    try {
+      const result = await settings.get();
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get settings", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.put("/settings", async (req, res) => {
+    try {
+      const result = await settings.update(req.body);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to update settings", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/export/calls", async (req, res) => {
+    try {
+      const { format = "json", ...filterParams } = req.query;
+      const filter = {};
+      if (filterParams["pipelineId"]) filter["pipelineId"] = filterParams["pipelineId"];
+      if (filterParams["agentId"]) filter["agentId"] = filterParams["agentId"];
+      if (filterParams["isClosed"] !== void 0) filter["isClosed"] = filterParams["isClosed"] === "true";
+      if (filterParams["from"] || filterParams["to"]) {
+        filter["dateRange"] = { from: filterParams["from"], to: filterParams["to"] };
+      }
+      const result = await exportSvc.exportCallLogs(
+        filter,
+        format
+      );
+      const contentType = format === "csv" ? "text/csv" : "application/json";
+      res.setHeader("Content-Type", contentType);
+      res.send(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to export call logs", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/export/calls/:id", async (req, res) => {
+    try {
+      const format = req.query["format"] || "json";
+      const result = await exportSvc.exportCallLog(req.params["id"], format);
+      const contentType = format === "csv" ? "text/csv" : "application/json";
+      res.setHeader("Content-Type", contentType);
+      res.send(result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 404);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to export call log", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/export/pipeline/:id", async (req, res) => {
+    try {
+      const format = req.query["format"] || "json";
+      const dateRange = {
+        from: req.query["from"],
+        to: req.query["to"]
+      };
+      const result = await exportSvc.exportPipelineReport(req.params["id"], dateRange, format);
+      const contentType = format === "csv" ? "text/csv" : "application/json";
+      res.setHeader("Content-Type", contentType);
+      res.send(result);
+    } catch (error) {
+      if (error instanceof AlxCallLogError) {
+        core.sendError(res, error.message, 400);
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to export pipeline report", { id: req.params["id"], error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  return router;
+}
+
+// src/routes/index.ts
+function createRoutes(services, options) {
+  const router = express.Router();
+  const { logger, authenticateRequest } = options;
+  let authMiddleware;
+  if (authenticateRequest) {
+    authMiddleware = async (req, res, next) => {
+      try {
+        const result = await authenticateRequest(req);
+        if (!result) {
+          core.sendError(res, "Unauthorized", 401);
+          return;
+        }
+        req.user = result;
+        next();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Authentication failed";
+        core.sendError(res, message, 401);
+      }
+    };
+  }
+  const protectedRouter = express.Router();
+  protectedRouter.use("/pipelines", createPipelineRoutes(services.pipelines, logger));
+  protectedRouter.use("/calls", createCallLogRoutes({ callLogs: services.callLogs, timeline: services.timeline }, logger));
+  protectedRouter.use("/contacts", createContactRoutes({ callLogs: services.callLogs, timeline: services.timeline }, logger));
+  protectedRouter.use("/analytics", createAnalyticsRoutes(services.analytics, logger));
+  protectedRouter.use("/", createSettingsRoutes(services.settings, services.export, logger));
+  if (authMiddleware) {
+    router.use(authMiddleware, protectedRouter);
+  } else {
+    router.use(protectedRouter);
+  }
+  return router;
+}
+var FollowUpWorker = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  intervalId = null;
+  running = false;
+  start() {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(() => {
+      this.tick().catch((err) => {
+        this.deps.logger.error("Follow-up worker tick failed", {
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      });
+    }, this.deps.options.followUpCheckIntervalMs);
+    this.deps.logger.info("Follow-up worker started", {
+      intervalMs: this.deps.options.followUpCheckIntervalMs
+    });
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.deps.logger.info("Follow-up worker stopped");
+  }
+  async tick() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      const dueCallLogs = await this.deps.CallLog.find({
+        nextFollowUpDate: { $lte: /* @__PURE__ */ new Date() },
+        isClosed: false,
+        followUpNotifiedAt: null
+      });
+      for (const callLog of dueCallLogs) {
+        try {
+          if (this.deps.hooks.onFollowUpDue) {
+            await this.deps.hooks.onFollowUpDue(callLog);
+          }
+          await this.deps.CallLog.findOneAndUpdate(
+            { _id: callLog._id },
+            {
+              $set: { followUpNotifiedAt: /* @__PURE__ */ new Date() },
+              $push: {
+                timeline: {
+                  entryId: crypto5__default.default.randomUUID(),
+                  type: callLogTypes.TimelineEntryType.FollowUpCompleted,
+                  content: SYSTEM_TIMELINE.FollowUpCompleted,
+                  createdAt: /* @__PURE__ */ new Date()
+                }
+              }
+            }
+          );
+          this.deps.logger.info("Follow-up notification fired", {
+            callLogId: callLog.callLogId
+          });
+        } catch (err) {
+          this.deps.logger.error("Failed to process follow-up for call log", {
+            callLogId: callLog.callLogId,
+            error: err instanceof Error ? err.message : "Unknown error"
+          });
+        }
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+};
+var CallLogEngineConfigSchema = zod.z.object({
+  db: zod.z.object({
+    connection: zod.z.unknown(),
+    collectionPrefix: zod.z.string().optional()
+  }),
+  logger: zod.z.object({
+    info: zod.z.function(),
+    warn: zod.z.function(),
+    error: zod.z.function(),
+    debug: zod.z.function()
+  }).optional(),
+  agents: zod.z.object({
+    collectionName: zod.z.string().optional(),
+    resolveAgent: zod.z.function().optional()
+  }).optional().default({}),
+  adapters: zod.z.object({
+    lookupContact: zod.z.function(),
+    addContact: zod.z.function().optional(),
+    authenticateAgent: zod.z.function()
+  }),
+  hooks: zod.z.object({
+    onCallCreated: zod.z.function().optional(),
+    onStageChanged: zod.z.function().optional(),
+    onCallClosed: zod.z.function().optional(),
+    onCallAssigned: zod.z.function().optional(),
+    onFollowUpDue: zod.z.function().optional(),
+    onMetric: zod.z.function().optional()
+  }).optional(),
+  options: zod.z.object({
+    maxTimelineEntries: zod.z.number().int().positive().optional(),
+    followUpCheckIntervalMs: zod.z.number().int().positive().optional()
+  }).optional()
+});
+function createCallLogEngine(config) {
+  const parseResult = CallLogEngineConfigSchema.safeParse(config);
+  if (!parseResult.success) {
+    const issues = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+    throw new Error(`Invalid CallLogEngineConfig: ${issues}`);
+  }
+  const resolvedOptions = {
+    ...callLogTypes.DEFAULT_OPTIONS,
+    ...config.options
+  };
+  const logger = config.logger ?? core.noopLogger;
+  const conn = config.db.connection;
+  const prefix = config.db.collectionPrefix;
+  const Pipeline = createPipelineModel(conn, prefix);
+  const CallLog = createCallLogModel(conn, prefix);
+  const CallLogSettings = createCallLogSettingsModel(conn, prefix);
+  const settingsService = new SettingsService(CallLogSettings, logger);
+  const pipelineService = new PipelineService(Pipeline, CallLog, logger);
+  const timelineService = new TimelineService(CallLog, logger, resolvedOptions);
+  const callLogService = new CallLogService(
+    CallLog,
+    Pipeline,
+    timelineService,
+    logger,
+    config.hooks ?? {},
+    resolvedOptions
+  );
+  const analyticsService = new AnalyticsService(CallLog, Pipeline, logger, config.agents?.resolveAgent);
+  const exportService = new ExportService(CallLog, analyticsService, logger);
+  const routes = createRoutes(
+    {
+      pipelines: pipelineService,
+      callLogs: callLogService,
+      timeline: timelineService,
+      analytics: analyticsService,
+      settings: settingsService,
+      export: exportService
+    },
+    {
+      authenticateRequest: config.adapters.authenticateAgent ? async (req) => {
+        const expressReq = req;
+        const authHeader = expressReq.headers?.["authorization"];
+        const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+        if (!token) return null;
+        return config.adapters.authenticateAgent(token);
+      } : void 0,
+      logger
+    }
+  );
+  const followUpWorker = new FollowUpWorker({
+    CallLog,
+    hooks: { onFollowUpDue: config.hooks?.onFollowUpDue },
+    logger,
+    options: resolvedOptions
+  });
+  followUpWorker.start();
+  async function destroy() {
+    followUpWorker.stop();
+    logger.info("CallLogEngine destroyed");
+  }
+  return {
+    pipelines: pipelineService,
+    callLogs: callLogService,
+    timeline: timelineService,
+    analytics: analyticsService,
+    settings: settingsService,
+    export: exportService,
+    routes,
+    models: { Pipeline, CallLog, CallLogSettings },
+    destroy
+  };
+}
+
+Object.defineProperty(exports, "DEFAULT_OPTIONS", {
+  enumerable: true,
+  get: function () { return callLogTypes.DEFAULT_OPTIONS; }
+});
+exports.AGENT_CALL_DEFAULTS = AGENT_CALL_DEFAULTS;
+exports.AgentCapacityError = AgentCapacityError;
+exports.AlxCallLogError = AlxCallLogError;
+exports.AnalyticsService = AnalyticsService;
+exports.AuthFailedError = AuthFailedError;
+exports.CALL_LOG_DEFAULTS = CALL_LOG_DEFAULTS;
+exports.CallLogClosedError = CallLogClosedError;
+exports.CallLogNotFoundError = CallLogNotFoundError;
+exports.CallLogSchema = CallLogSchema;
+exports.CallLogService = CallLogService;
+exports.CallLogSettingsSchema = CallLogSettingsSchema;
+exports.ContactNotFoundError = ContactNotFoundError;
+exports.ContactRefSchema = ContactRefSchema;
+exports.ERROR_CODE = ERROR_CODE;
+exports.ERROR_MESSAGE = ERROR_MESSAGE;
+exports.ExportService = ExportService;
+exports.FollowUpWorker = FollowUpWorker;
+exports.InvalidConfigError = InvalidConfigError;
+exports.InvalidPipelineError = InvalidPipelineError;
+exports.PIPELINE_DEFAULTS = PIPELINE_DEFAULTS;
+exports.PipelineNotFoundError = PipelineNotFoundError;
+exports.PipelineSchema = PipelineSchema;
+exports.PipelineService = PipelineService;
+exports.PipelineStageSchema = PipelineStageSchema;
+exports.SYSTEM_TIMELINE = SYSTEM_TIMELINE;
+exports.SYSTEM_TIMELINE_FN = SYSTEM_TIMELINE_FN;
+exports.SettingsService = SettingsService;
+exports.StageChangeSchema = StageChangeSchema;
+exports.StageInUseError = StageInUseError;
+exports.StageNotFoundError = StageNotFoundError;
+exports.TimelineEntrySchema = TimelineEntrySchema;
+exports.TimelineService = TimelineService;
+exports.createCallLogEngine = createCallLogEngine;
+exports.createCallLogModel = createCallLogModel;
+exports.createCallLogSettingsModel = createCallLogSettingsModel;
+exports.createPipelineModel = createPipelineModel;
+exports.createRoutes = createRoutes;
+exports.validatePipelineStages = validatePipelineStages;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map