@astralibx/call-log-engine 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -3,18 +3,18 @@
 var zod = require('zod');
 var core = require('@astralibx/core');
 var callLogTypes = require('@astralibx/call-log-types');
-var crypto5 = require('crypto');
+var crypto6 = 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);
+var crypto6__default = /*#__PURE__*/_interopDefault(crypto6);
 
 // src/index.ts
 var PipelineStageSchema = new mongoose.Schema(
   {
-    stageId: { type: String, required: true, default: () => crypto5__default.default.randomUUID() },
+    stageId: { type: String, required: true, default: () => crypto6__default.default.randomUUID() },
     name: { type: String, required: true },
     color: { type: String, required: true },
     order: { type: Number, required: true },
@@ -25,7 +25,7 @@ var PipelineStageSchema = new mongoose.Schema(
 );
 var PipelineSchema = new mongoose.Schema(
   {
-    pipelineId: { type: String, required: true, unique: true, default: () => crypto5__default.default.randomUUID() },
+    pipelineId: { type: String, required: true, unique: true, default: () => crypto6__default.default.randomUUID() },
     name: { type: String, required: true },
     description: { type: String },
     stages: { type: [PipelineStageSchema], required: true },
@@ -55,7 +55,7 @@ var ContactRefSchema = new mongoose.Schema(
 );
 var TimelineEntrySchema = new mongoose.Schema(
   {
-    entryId: { type: String, required: true, default: () => crypto5__default.default.randomUUID() },
+    entryId: { type: String, required: true, default: () => crypto6__default.default.randomUUID() },
     type: {
       type: String,
       required: true,
@@ -90,7 +90,7 @@ var StageChangeSchema = new mongoose.Schema(
 );
 var CallLogSchema = new mongoose.Schema(
   {
-    callLogId: { type: String, required: true, unique: true, default: () => crypto5__default.default.randomUUID() },
+    callLogId: { type: String, required: true, unique: true, default: () => crypto6__default.default.randomUUID() },
     pipelineId: { type: String, required: true, index: true },
     currentStageId: { type: String, required: true, index: true },
     contactRef: { type: ContactRefSchema, required: true },
@@ -115,6 +115,11 @@ var CallLogSchema = new mongoose.Schema(
     timeline: { type: [TimelineEntrySchema], default: [] },
     stageHistory: { type: [StageChangeSchema], default: [] },
     durationMinutes: { type: Number, min: 0 },
+    channel: { type: String, default: "phone", index: true },
+    outcome: { type: String, default: "pending", index: true },
+    isFollowUp: { type: Boolean, default: false, index: true },
+    isDeleted: { type: Boolean, default: false },
+    deletedAt: { type: Date },
     isClosed: { type: Boolean, default: false, index: true },
     closedAt: { type: Date },
     tenantId: { type: String, sparse: true },
@@ -127,6 +132,7 @@ var CallLogSchema = new mongoose.Schema(
 CallLogSchema.index({ "contactRef.externalId": 1 });
 CallLogSchema.index({ pipelineId: 1, currentStageId: 1 });
 CallLogSchema.index({ agentId: 1, isClosed: 1 });
+CallLogSchema.index({ isDeleted: 1, isClosed: 1 });
 function createCallLogModel(connection, prefix) {
   const collectionName = prefix ? `${prefix}_call_logs` : "call_logs";
   return connection.model("CallLog", CallLogSchema, collectionName);
@@ -140,6 +146,7 @@ var ERROR_CODE = {
   StageInUse: "CALL_STAGE_IN_USE",
   CallLogNotFound: "CALL_LOG_NOT_FOUND",
   CallLogClosed: "CALL_LOG_CLOSED",
+  CallLogDeleted: "CALL_LOG_DELETED",
   ContactNotFound: "CALL_CONTACT_NOT_FOUND",
   AgentCapacityFull: "CALL_AGENT_CAPACITY_FULL",
   InvalidConfig: "CALL_INVALID_CONFIG",
@@ -154,6 +161,7 @@ var ERROR_MESSAGE = {
   StageInUse: "Cannot remove stage that has active calls",
   CallLogNotFound: "Call log not found",
   CallLogClosed: "Cannot modify a closed call log",
+  CallLogDeleted: "Call log has been deleted",
   ContactNotFound: "Contact not found",
   AgentCapacityFull: "Agent has reached maximum concurrent calls",
   AuthFailed: "Authentication failed"
@@ -179,7 +187,9 @@ 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}`
+  followUpSet: (date) => `Follow-up scheduled for ${date}`,
+  callDeleted: (agentName) => `Call deleted by ${agentName}`,
+  followUpCallCreated: () => "This call is a follow-up to a previous interaction"
 };
 
 // src/schemas/call-log-settings.schema.ts
@@ -203,6 +213,8 @@ var CallLogSettingsSchema = new mongoose.Schema(
     key: { type: String, required: true, default: "global" },
     availableTags: { type: [String], default: [] },
     availableCategories: { type: [String], default: [] },
+    availableChannels: { type: [String], default: ["phone", "whatsapp", "telegram", "in_app_chat"] },
+    availableOutcomes: { type: [String], default: ["pending", "interested", "not_interested", "no_answer", "busy", "callback_requested", "subscribed", "complaint"] },
     priorityLevels: {
       type: [PriorityConfigSchema],
       default: () => DEFAULT_PRIORITY_LEVELS.map((p) => ({ ...p }))
@@ -465,10 +477,10 @@ var PipelineService = class {
   async create(data) {
     const stages = data.stages.map((s) => ({
       ...s,
-      stageId: crypto5__default.default.randomUUID()
+      stageId: crypto6__default.default.randomUUID()
     }));
     validatePipelineStages(stages);
-    const pipelineId = crypto5__default.default.randomUUID();
+    const pipelineId = crypto6__default.default.randomUUID();
     if (data.isDefault) {
       await this.Pipeline.updateMany(
         { ...this.tenantFilter, isDefault: true },
@@ -537,7 +549,7 @@ var PipelineService = class {
     const pipeline = await this.get(pipelineId);
     const newStage = {
       ...stage,
-      stageId: crypto5__default.default.randomUUID()
+      stageId: crypto6__default.default.randomUUID()
     };
     const updatedStages = [...pipeline.stages, newStage];
     validatePipelineStages(updatedStages, pipelineId);
@@ -636,7 +648,7 @@ var TimelineService = class {
     if (!callLog) throw new CallLogNotFoundError(callLogId);
     if (callLog.isClosed) throw new CallLogClosedError(callLogId, "add note");
     const entry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.Note,
       content,
       authorId,
@@ -661,7 +673,7 @@ var TimelineService = class {
     const callLog = await this.CallLog.findOne({ callLogId });
     if (!callLog) throw new CallLogNotFoundError(callLogId);
     const entry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.System,
       content,
       createdAt: /* @__PURE__ */ new Date()
@@ -730,13 +742,23 @@ var CallLogService = class {
     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 callLogId = crypto6__default.default.randomUUID();
     const initialEntry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.System,
       content: SYSTEM_TIMELINE.CallCreated,
       createdAt: /* @__PURE__ */ new Date()
     };
+    const timelineEntries = [initialEntry];
+    if (data.isFollowUp) {
+      const followUpEntry = {
+        entryId: crypto6__default.default.randomUUID(),
+        type: callLogTypes.TimelineEntryType.System,
+        content: SYSTEM_TIMELINE_FN.followUpCallCreated(),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      timelineEntries.push(followUpEntry);
+    }
     const callLog = await this.CallLog.create({
       callLogId,
       pipelineId: data.pipelineId,
@@ -750,7 +772,10 @@ var CallLogService = class {
       category: data.category,
       nextFollowUpDate: data.nextFollowUpDate,
       durationMinutes: data.durationMinutes,
-      timeline: [initialEntry],
+      channel: data.channel,
+      outcome: data.outcome,
+      isFollowUp: data.isFollowUp ?? false,
+      timeline: timelineEntries,
       stageHistory: [],
       isClosed: false,
       ...data.tenantId ? { tenantId: data.tenantId } : {},
@@ -772,6 +797,9 @@ var CallLogService = class {
     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.channel !== void 0) setFields.channel = data.channel;
+    if (data.outcome !== void 0) setFields.outcome = data.outcome;
+    if (data.isFollowUp !== void 0) setFields.isFollowUp = data.isFollowUp;
     if (data.nextFollowUpDate !== void 0) {
       const prevDate = callLog.nextFollowUpDate?.toISOString();
       const newDate = data.nextFollowUpDate?.toISOString();
@@ -779,7 +807,7 @@ var CallLogService = class {
         setFields.nextFollowUpDate = data.nextFollowUpDate;
         if (data.nextFollowUpDate) {
           const followUpEntry = {
-            entryId: crypto5__default.default.randomUUID(),
+            entryId: crypto6__default.default.randomUUID(),
             type: callLogTypes.TimelineEntryType.FollowUpSet,
             content: SYSTEM_TIMELINE_FN.followUpSet(new Date(data.nextFollowUpDate).toISOString()),
             createdAt: /* @__PURE__ */ new Date()
@@ -806,6 +834,58 @@ var CallLogService = class {
     this.logger.info("Call log updated", { callLogId, fields: Object.keys(data) });
     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.channel) query.channel = filter.channel;
+    if (filter.outcome) query.outcome = filter.outcome;
+    if (filter.isFollowUp !== void 0) query.isFollowUp = filter.isFollowUp;
+    if (!filter.includeDeleted) query.isDeleted = { $ne: true };
+    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, isDeleted: { $ne: true } });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    return callLog;
+  }
+  async getByContact(externalId) {
+    return this.CallLog.find({ "contactRef.externalId": externalId, isDeleted: { $ne: true } }).sort({ callDate: -1 });
+  }
+};
+var CallLogLifecycleService = 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 changeStage(callLogId, newStageId, agentId) {
     const callLog = await this.CallLog.findOne({ callLogId });
     if (!callLog) throw new CallLogNotFoundError(callLogId);
@@ -822,7 +902,7 @@ var CallLogService = class {
     const stageStartTime = lastHistory?.changedAt?.getTime() ?? callLog.createdAt?.getTime() ?? now.getTime();
     const timeInStageMs = now.getTime() - stageStartTime;
     const stageChangeEntry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.StageChange,
       content: SYSTEM_TIMELINE_FN.stageChanged(currentStage.name, newStage.name),
       fromStageId: currentStageId,
@@ -871,7 +951,7 @@ var CallLogService = class {
     if (!callLog) throw new CallLogNotFoundError(callLogId);
     const previousAgentId = callLog.agentId?.toString();
     const assignmentEntry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.Assignment,
       content: previousAgentId ? SYSTEM_TIMELINE_FN.callReassigned(previousAgentId, agentId) : SYSTEM_TIMELINE_FN.callAssigned(agentId),
       toAgentId: agentId,
@@ -899,88 +979,13 @@ var CallLogService = class {
     }
     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(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.System,
       content: SYSTEM_TIMELINE.CallClosed,
       authorId: agentId,
@@ -1012,7 +1017,7 @@ var CallLogService = class {
     if (!callLog.isClosed) throw new CallLogClosedError(callLogId, "reopen");
     const now = /* @__PURE__ */ new Date();
     const reopenEntry = {
-      entryId: crypto5__default.default.randomUUID(),
+      entryId: crypto6__default.default.randomUUID(),
       type: callLogTypes.TimelineEntryType.System,
       content: SYSTEM_TIMELINE.CallReopened,
       authorId: agentId,
@@ -1035,6 +1040,72 @@ var CallLogService = class {
     this.logger.info("Call log reopened", { callLogId, agentId });
     return updated;
   }
+  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 getFollowUpsDue(agentId, dateRange) {
+    const now = /* @__PURE__ */ new Date();
+    const query = {
+      nextFollowUpDate: { $lte: now },
+      isClosed: false,
+      followUpNotifiedAt: null,
+      isDeleted: { $ne: true }
+    };
+    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 softDelete(callLogId, agentId, agentName) {
+    const callLog = await this.CallLog.findOne({ callLogId });
+    if (!callLog) throw new CallLogNotFoundError(callLogId);
+    const now = /* @__PURE__ */ new Date();
+    const deleteEntry = {
+      entryId: crypto6__default.default.randomUUID(),
+      type: callLogTypes.TimelineEntryType.System,
+      content: agentName ? SYSTEM_TIMELINE_FN.callDeleted(agentName) : SYSTEM_TIMELINE_FN.callDeleted(agentId ?? "unknown"),
+      authorId: agentId,
+      createdAt: now
+    };
+    const updated = await this.CallLog.findOneAndUpdate(
+      { callLogId },
+      {
+        $set: { isDeleted: true, deletedAt: now },
+        $push: {
+          timeline: {
+            $each: [deleteEntry],
+            $slice: -this.options.maxTimelineEntries
+          }
+        }
+      },
+      { new: true }
+    );
+    if (!updated) throw new CallLogNotFoundError(callLogId);
+    this.logger.info("Call log soft deleted", { callLogId });
+    return updated;
+  }
 };
 
 // src/services/analytics.service.ts
@@ -1065,6 +1136,7 @@ var AnalyticsService = class {
     const now = /* @__PURE__ */ new Date();
     const matchStage = {
       agentId,
+      isDeleted: { $ne: true },
       ...this.buildDateMatch(dateRange)
     };
     const pipeline = [
@@ -1157,7 +1229,10 @@ var AnalyticsService = class {
   }
   async getAgentLeaderboard(dateRange) {
     const now = /* @__PURE__ */ new Date();
-    const matchStage = this.buildDateMatch(dateRange);
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
     const pipeline = [
       { $match: matchStage },
       {
@@ -1213,103 +1288,12 @@ var AnalyticsService = class {
       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 ?? [];
+  async getTeamStats(teamId, dateRange = {}) {
+    const now = /* @__PURE__ */ new Date();
     const matchStage = {
-      pipelineId,
+      isDeleted: { $ne: true },
       ...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 },
       {
@@ -1366,8 +1350,12 @@ var AnalyticsService = class {
     const totalCalls = agentStats.reduce((sum, a) => sum + a.totalCalls, 0);
     return { teamId: teamId ?? null, agentStats, totalCalls };
   }
-  async getDailyReport(dateRange) {
-    const matchStage = this.buildDateMatch(dateRange);
+  async getDailyReport(dateRange, agentId) {
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
+    if (agentId) matchStage["agentId"] = agentId;
     const [dailyAgg, directionAgg, pipelineAgg, agentAgg] = await Promise.all([
       this.CallLog.aggregate([
         { $match: matchStage },
@@ -1447,13 +1435,14 @@ var AnalyticsService = class {
     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({ isClosed: false, isDeleted: { $ne: true } }),
+      this.CallLog.countDocuments({ closedAt: { $gte: midnight }, isDeleted: { $ne: true } }),
       this.CallLog.countDocuments({
         nextFollowUpDate: { $lt: now },
-        isClosed: false
+        isClosed: false,
+        isDeleted: { $ne: true }
       }),
-      this.CallLog.countDocuments({ callDate: { $gte: midnight } })
+      this.CallLog.countDocuments({ callDate: { $gte: midnight }, isDeleted: { $ne: true } })
     ]);
     return {
       openCalls,
@@ -1467,7 +1456,7 @@ var AnalyticsService = class {
     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 } } },
+      { $match: { callDate: { $gte: from, $lte: now }, isDeleted: { $ne: true } } },
       {
         $group: {
           _id: {
@@ -1494,8 +1483,11 @@ var AnalyticsService = class {
     return results;
   }
   async getOverallReport(dateRange) {
-    const matchStage = this.buildDateMatch(dateRange);
-    const [summaryAgg, tagAgg, categoryAgg, peakHoursAgg, followUpAgg] = await Promise.all([
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
+    const [summaryAgg, tagAgg, categoryAgg, peakHoursAgg, followUpAgg, channelAgg, outcomeAgg] = await Promise.all([
       this.CallLog.aggregate([
         { $match: matchStage },
         {
@@ -1540,14 +1532,14 @@ var AnalyticsService = class {
             _id: null,
             total: { $sum: 1 },
             withFollowUp: {
-              $sum: { $cond: [{ $ne: ["$nextFollowUpDate", null] }, 1, 0] }
+              $sum: { $cond: [{ $eq: ["$isFollowUp", true] }, 1, 0] }
             },
             completed: {
               $sum: {
                 $cond: [
                   {
                     $and: [
-                      { $ne: ["$nextFollowUpDate", null] },
+                      { $eq: ["$isFollowUp", true] },
                       { $eq: ["$isClosed", true] }
                     ]
                   },
@@ -1558,11 +1550,31 @@ var AnalyticsService = class {
             }
           }
         }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $group: { _id: "$channel", count: { $sum: 1 } } },
+        { $sort: { count: -1 } }
+      ]),
+      this.CallLog.aggregate([
+        { $match: matchStage },
+        { $group: { _id: "$outcome", count: { $sum: 1 } } },
+        { $sort: { count: -1 } }
       ])
     ]);
     const summary = summaryAgg[0] ?? { totalCalls: 0, closedCalls: 0, avgTimeToCloseMs: 0 };
-    const followUp = followUpAgg[0] ?? { withFollowUp: 0, completed: 0 };
+    const followUp = followUpAgg[0] ?? { total: 0, withFollowUp: 0, completed: 0 };
     const followUpComplianceRate = followUp.withFollowUp > 0 ? Math.round(followUp.completed / followUp.withFollowUp * 1e4) / 100 : 0;
+    const followUpCalls = followUp.withFollowUp;
+    const followUpRatio = followUp.total > 0 ? Math.round(followUp.withFollowUp / followUp.total * 1e4) / 100 : 0;
+    const channelDistribution = channelAgg.map((r) => ({
+      channel: r._id != null ? String(r._id) : "unknown",
+      count: r.count
+    }));
+    const outcomeDistribution = outcomeAgg.map((r) => ({
+      outcome: r._id != null ? String(r._id) : "unknown",
+      count: r.count
+    }));
     return {
       totalCalls: summary.totalCalls,
       closedCalls: summary.closedCalls,
@@ -1570,7 +1582,180 @@ var AnalyticsService = class {
       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 }))
+      peakCallHours: peakHoursAgg.map((r) => ({ hour: Number(r._id), count: r.count })),
+      channelDistribution,
+      outcomeDistribution,
+      followUpCalls,
+      followUpRatio
+    };
+  }
+};
+
+// src/services/pipeline-analytics.service.ts
+var PipelineAnalyticsService = class {
+  constructor(CallLog, Pipeline, logger, resolveAgent, tenantId) {
+    this.CallLog = CallLog;
+    this.Pipeline = Pipeline;
+    this.logger = logger;
+    this.resolveAgent = resolveAgent;
+    this.tenantId = tenantId;
+  }
+  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 getPipelineStats(pipelineId, dateRange) {
+    const pipeline = await this.Pipeline.findOne({ pipelineId, isDeleted: false });
+    const pipelineName = pipeline?.name ?? pipelineId;
+    const stages = pipeline?.stages ?? [];
+    const matchStage = {
+      pipelineId,
+      isDeleted: { $ne: true },
+      ...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,
+      isDeleted: { $ne: true },
+      ...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 getChannelDistribution(dateRange) {
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
+    const results = await this.CallLog.aggregate([
+      { $match: matchStage },
+      { $group: { _id: "$channel", count: { $sum: 1 } } },
+      { $sort: { count: -1 } }
+    ]);
+    return results.map((r) => ({
+      channel: r._id != null ? String(r._id) : "unknown",
+      count: r.count
+    }));
+  }
+  async getOutcomeDistribution(dateRange) {
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
+    const results = await this.CallLog.aggregate([
+      { $match: matchStage },
+      { $group: { _id: "$outcome", count: { $sum: 1 } } },
+      { $sort: { count: -1 } }
+    ]);
+    return results.map((r) => ({
+      outcome: r._id != null ? String(r._id) : "unknown",
+      count: r.count
+    }));
+  }
+  async getFollowUpStats(dateRange) {
+    const matchStage = {
+      isDeleted: { $ne: true },
+      ...this.buildDateMatch(dateRange)
+    };
+    const results = await this.CallLog.aggregate([
+      { $match: matchStage },
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          followUpCalls: {
+            $sum: { $cond: [{ $eq: ["$isFollowUp", true] }, 1, 0] }
+          }
+        }
+      }
+    ]);
+    const stat = results[0] ?? { total: 0, followUpCalls: 0 };
+    const followUpRatio = stat.total > 0 ? Math.round(stat.followUpCalls / stat.total * 1e4) / 100 : 0;
+    return {
+      followUpCalls: stat.followUpCalls,
+      totalCalls: stat.total,
+      followUpRatio
     };
   }
 };
@@ -1578,9 +1763,9 @@ var AnalyticsService = class {
 // 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) {
+  constructor(CallLog, pipelineAnalytics, logger) {
     this.CallLog = CallLog;
-    this.analytics = analytics;
+    this.pipelineAnalytics = pipelineAnalytics;
     this.logger = logger;
   }
   async exportCallLog(callLogId, format) {
@@ -1622,7 +1807,7 @@ var ExportService = class {
     );
   }
   async exportPipelineReport(pipelineId, dateRange, format) {
-    const report = await this.analytics.getPipelineStats(pipelineId, dateRange);
+    const report = await this.pipelineAnalytics.getPipelineStats(pipelineId, dateRange);
     if (format === "csv") {
       const header = "pipelineId,pipelineName,totalCalls,stageId,stageName,count,avgTimeMs,conversionRate,bottleneckStage";
       const rows = [header];
@@ -1803,17 +1988,25 @@ function createPipelineRoutes(pipeline, logger) {
   });
   return router;
 }
-function createCallLogRoutes(services, logger) {
+function getScopedAgentId(req, enableAgentScoping) {
+  if (!enableAgentScoping) return void 0;
+  const user = req.user;
+  if (!user) return void 0;
+  if (user.role === "owner") return void 0;
+  return user.adminUserId;
+}
+function createCallLogRoutes(services, logger, enableAgentScoping = false) {
   const router = express.Router();
-  const { callLogs, timeline } = services;
+  const { callLogs, lifecycle, timeline } = services;
   router.get("/follow-ups", async (req, res) => {
     try {
-      const { agentId } = req.query;
+      const scopedAgentId = getScopedAgentId(req, enableAgentScoping);
+      const agentId = scopedAgentId ?? req.query["agentId"];
       const dateRange = {
         from: req.query["from"],
         to: req.query["to"]
       };
-      const result = await callLogs.getFollowUpsDue(agentId, dateRange);
+      const result = await lifecycle.getFollowUpsDue(agentId, dateRange);
       core.sendSuccess(res, result);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -1824,7 +2017,7 @@ function createCallLogRoutes(services, logger) {
   router.put("/-/bulk/stage", async (req, res) => {
     try {
       const { callLogIds, newStageId, agentId } = req.body;
-      const result = await callLogs.bulkChangeStage(callLogIds, newStageId, agentId);
+      const result = await lifecycle.bulkChangeStage(callLogIds, newStageId, agentId);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -1842,7 +2035,12 @@ function createCallLogRoutes(services, logger) {
       const filter = {};
       if (query["pipelineId"]) filter["pipelineId"] = query["pipelineId"];
       if (query["currentStageId"]) filter["currentStageId"] = query["currentStageId"];
-      if (query["agentId"]) filter["agentId"] = query["agentId"];
+      const scopedAgentId = getScopedAgentId(req, enableAgentScoping);
+      if (scopedAgentId) {
+        filter["agentId"] = scopedAgentId;
+      } else 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"];
@@ -1851,6 +2049,14 @@ function createCallLogRoutes(services, logger) {
       if (query["contactEmail"]) filter["contactEmail"] = query["contactEmail"];
       if (query["priority"]) filter["priority"] = query["priority"];
       if (query["direction"]) filter["direction"] = query["direction"];
+      const channel = query["channel"];
+      const outcome = query["outcome"];
+      const isFollowUp = query["isFollowUp"] !== void 0 ? query["isFollowUp"] === "true" : void 0;
+      const includeDeleted = query["includeDeleted"] === "true";
+      if (channel) filter["channel"] = channel;
+      if (outcome) filter["outcome"] = outcome;
+      if (isFollowUp !== void 0) filter["isFollowUp"] = isFollowUp;
+      if (includeDeleted) filter["includeDeleted"] = true;
       if (query["page"]) filter["page"] = parseInt(query["page"], 10);
       if (query["limit"]) filter["limit"] = parseInt(query["limit"], 10);
       if (query["from"] || query["to"]) {
@@ -1906,10 +2112,26 @@ function createCallLogRoutes(services, logger) {
       core.sendError(res, message, 500);
     }
   });
+  router.delete("/:id", async (req, res) => {
+    try {
+      const agentId = req.user?.adminUserId;
+      const agentName = req.user?.displayName;
+      const result = await lifecycle.softDelete(req.params["id"], agentId, agentName);
+      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 soft delete 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);
+      const result = await lifecycle.changeStage(req.params["id"], newStageId, agentId);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -1924,7 +2146,7 @@ function createCallLogRoutes(services, logger) {
   router.put("/:id/assign", async (req, res) => {
     try {
       const { agentId, assignedBy } = req.body;
-      const result = await callLogs.assign(req.params["id"], agentId, assignedBy);
+      const result = await lifecycle.assign(req.params["id"], agentId, assignedBy);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -1939,7 +2161,7 @@ function createCallLogRoutes(services, logger) {
   router.put("/:id/close", async (req, res) => {
     try {
       const { agentId } = req.body;
-      const result = await callLogs.close(req.params["id"], agentId);
+      const result = await lifecycle.close(req.params["id"], agentId);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -1954,7 +2176,7 @@ function createCallLogRoutes(services, logger) {
   router.put("/:id/reopen", async (req, res) => {
     try {
       const { agentId } = req.body;
-      const result = await callLogs.reopen(req.params["id"], agentId);
+      const result = await lifecycle.reopen(req.params["id"], agentId);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -2034,8 +2256,15 @@ function createContactRoutes(services, logger) {
   });
   return router;
 }
-function createAnalyticsRoutes(analytics, logger) {
+function createAnalyticsRoutes(analytics, pipelineAnalytics, logger, enableAgentScoping = false) {
   const router = express.Router();
+  function getScopedAgentId2(req) {
+    if (!enableAgentScoping) return void 0;
+    const user = req.user;
+    if (!user) return void 0;
+    if (user.role === "owner") return void 0;
+    return user.adminUserId;
+  }
   function parseDateRange(query) {
     return {
       from: query["from"],
@@ -2054,6 +2283,11 @@ function createAnalyticsRoutes(analytics, logger) {
   });
   router.get("/agent/:agentId", async (req, res) => {
     try {
+      const scopedAgentId = getScopedAgentId2(req);
+      if (scopedAgentId && scopedAgentId !== req.params["agentId"]) {
+        core.sendError(res, "Forbidden: you may only view your own agent stats", 403);
+        return;
+      }
       const dateRange = parseDateRange(req.query);
       const result = await analytics.getAgentStats(req.params["agentId"], dateRange);
       core.sendSuccess(res, result);
@@ -2081,7 +2315,7 @@ function createAnalyticsRoutes(analytics, logger) {
   router.get("/pipeline/:id", async (req, res) => {
     try {
       const dateRange = parseDateRange(req.query);
-      const result = await analytics.getPipelineStats(req.params["id"], dateRange);
+      const result = await pipelineAnalytics.getPipelineStats(req.params["id"], dateRange);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -2096,7 +2330,7 @@ function createAnalyticsRoutes(analytics, logger) {
   router.get("/pipeline/:id/funnel", async (req, res) => {
     try {
       const dateRange = parseDateRange(req.query);
-      const result = await analytics.getPipelineFunnel(req.params["id"], dateRange);
+      const result = await pipelineAnalytics.getPipelineFunnel(req.params["id"], dateRange);
       core.sendSuccess(res, result);
     } catch (error) {
       if (error instanceof AlxCallLogError) {
@@ -2108,6 +2342,39 @@ function createAnalyticsRoutes(analytics, logger) {
       core.sendError(res, message, 500);
     }
   });
+  router.get("/channel-distribution", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await pipelineAnalytics.getChannelDistribution(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get channel distribution", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/outcome-distribution", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await pipelineAnalytics.getOutcomeDistribution(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get outcome distribution", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
+  router.get("/follow-up-stats", async (req, res) => {
+    try {
+      const dateRange = parseDateRange(req.query);
+      const result = await pipelineAnalytics.getFollowUpStats(dateRange);
+      core.sendSuccess(res, result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Failed to get follow-up stats", { error: message });
+      core.sendError(res, message, 500);
+    }
+  });
   router.get("/team", async (req, res) => {
     try {
       const { teamId } = req.query;
@@ -2122,8 +2389,9 @@ function createAnalyticsRoutes(analytics, logger) {
   });
   router.get("/daily", async (req, res) => {
     try {
+      const scopedAgentId = getScopedAgentId2(req);
       const dateRange = parseDateRange(req.query);
-      const result = await analytics.getDailyReport(dateRange);
+      const result = await analytics.getDailyReport(dateRange, scopedAgentId);
       core.sendSuccess(res, result);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -2248,7 +2516,7 @@ function createSettingsRoutes(settings, exportSvc, logger) {
 // src/routes/index.ts
 function createRoutes(services, options) {
   const router = express.Router();
-  const { logger, authenticateRequest } = options;
+  const { logger, authenticateRequest, enableAgentScoping = false } = options;
   let authMiddleware;
   if (authenticateRequest) {
     authMiddleware = async (req, res, next) => {
@@ -2268,9 +2536,9 @@ function createRoutes(services, options) {
   }
   const protectedRouter = express.Router();
   protectedRouter.use("/pipelines", createPipelineRoutes(services.pipelines, logger));
-  protectedRouter.use("/calls", createCallLogRoutes({ callLogs: services.callLogs, timeline: services.timeline }, logger));
+  protectedRouter.use("/calls", createCallLogRoutes({ callLogs: services.callLogs, lifecycle: services.lifecycle, timeline: services.timeline }, logger, enableAgentScoping));
   protectedRouter.use("/contacts", createContactRoutes({ callLogs: services.callLogs, timeline: services.timeline }, logger));
-  protectedRouter.use("/analytics", createAnalyticsRoutes(services.analytics, logger));
+  protectedRouter.use("/analytics", createAnalyticsRoutes(services.analytics, services.pipelineAnalytics, logger, enableAgentScoping));
   protectedRouter.use("/", createSettingsRoutes(services.settings, services.export, logger));
   if (authMiddleware) {
     router.use(authMiddleware, protectedRouter);
@@ -2325,7 +2593,7 @@ var FollowUpWorker = class {
               $set: { followUpNotifiedAt: /* @__PURE__ */ new Date() },
               $push: {
                 timeline: {
-                  entryId: crypto5__default.default.randomUUID(),
+                  entryId: crypto6__default.default.randomUUID(),
                   type: callLogTypes.TimelineEntryType.FollowUpCompleted,
                   content: SYSTEM_TIMELINE.FollowUpCompleted,
                   createdAt: /* @__PURE__ */ new Date()
@@ -2378,7 +2646,8 @@ var CallLogEngineConfigSchema = zod.z.object({
   }).optional(),
   options: zod.z.object({
     maxTimelineEntries: zod.z.number().int().positive().optional(),
-    followUpCheckIntervalMs: zod.z.number().int().positive().optional()
+    followUpCheckIntervalMs: zod.z.number().int().positive().optional(),
+    enableAgentScoping: zod.z.boolean().optional()
   }).optional()
 });
 function createCallLogEngine(config) {
@@ -2408,14 +2677,30 @@ function createCallLogEngine(config) {
     config.hooks ?? {},
     resolvedOptions
   );
+  const callLogLifecycleService = new CallLogLifecycleService(
+    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 pipelineAnalyticsService = new PipelineAnalyticsService(
+    CallLog,
+    Pipeline,
+    logger,
+    config.agents?.resolveAgent
+  );
+  const exportService = new ExportService(CallLog, pipelineAnalyticsService, logger);
   const routes = createRoutes(
     {
       pipelines: pipelineService,
       callLogs: callLogService,
+      lifecycle: callLogLifecycleService,
       timeline: timelineService,
       analytics: analyticsService,
+      pipelineAnalytics: pipelineAnalyticsService,
       settings: settingsService,
       export: exportService
     },
@@ -2427,7 +2712,8 @@ function createCallLogEngine(config) {
         if (!token) return null;
         return config.adapters.authenticateAgent(token);
       } : void 0,
-      logger
+      logger,
+      enableAgentScoping: resolvedOptions.enableAgentScoping
     }
   );
   const followUpWorker = new FollowUpWorker({
@@ -2444,8 +2730,10 @@ function createCallLogEngine(config) {
   return {
     pipelines: pipelineService,
     callLogs: callLogService,
+    lifecycle: callLogLifecycleService,
     timeline: timelineService,
     analytics: analyticsService,
+    pipelineAnalytics: pipelineAnalyticsService,
     settings: settingsService,
     export: exportService,
     routes,
@@ -2465,6 +2753,7 @@ exports.AnalyticsService = AnalyticsService;
 exports.AuthFailedError = AuthFailedError;
 exports.CALL_LOG_DEFAULTS = CALL_LOG_DEFAULTS;
 exports.CallLogClosedError = CallLogClosedError;
+exports.CallLogLifecycleService = CallLogLifecycleService;
 exports.CallLogNotFoundError = CallLogNotFoundError;
 exports.CallLogSchema = CallLogSchema;
 exports.CallLogService = CallLogService;
@@ -2478,6 +2767,7 @@ exports.FollowUpWorker = FollowUpWorker;
 exports.InvalidConfigError = InvalidConfigError;
 exports.InvalidPipelineError = InvalidPipelineError;
 exports.PIPELINE_DEFAULTS = PIPELINE_DEFAULTS;
+exports.PipelineAnalyticsService = PipelineAnalyticsService;
 exports.PipelineNotFoundError = PipelineNotFoundError;
 exports.PipelineSchema = PipelineSchema;
 exports.PipelineService = PipelineService;