@talkpilot/core-db 1.3.11 → 1.3.13

package/src/talkpilot/calls/__tests__/calls.statistics.spec.ts

@@ -52,14 +52,26 @@ const filter = (overrides?: Partial<CallsStatsFilter>): CallsStatsFilter => ({
 });
 
 const ticketDateScope = (statsFilter: CallsStatsFilter) =>
-  ticketStatsDateScopeFromYmd(statsFilter.startStr, statsFilter.endStr, statsFilter.timezone);
+  ticketStatsDateScopeFromYmd(
+    statsFilter.startStr,
+    statsFilter.endStr,
+    statsFilter.timezone,
+  );
 
 const summaryWithTicketSids = async (overrides?: Partial<CallsStatsFilter>) => {
   const statsFilter = filter(overrides);
   const dateScope = ticketDateScope(statsFilter);
-  const callSidTicketCounts = await findCallSidTicketCountsByCity(CITY, dateScope);
-  const callSidDraftTicketCounts = await findCallSidDraftTicketCountsByCity(CITY, dateScope);
-  return aggregateCallsSummary(filter({ callSidTicketCounts, callSidDraftTicketCounts, ...overrides }));
+  const callSidTicketCounts = await findCallSidTicketCountsByCity(
+    CITY,
+    dateScope,
+  );
+  const callSidDraftTicketCounts = await findCallSidDraftTicketCountsByCity(
+    CITY,
+    dateScope,
+  );
+  return aggregateCallsSummary(
+    filter({ callSidTicketCounts, callSidDraftTicketCounts, ...overrides }),
+  );
 };
 
 describe("calls statistics getters", () => {
@@ -117,10 +129,14 @@ describe("calls statistics getters", () => {
       openTickets: 2,
       draftTickets: 0,
       avgDurationSeconds: 90,
+      callsWithTickets: 1,
     });
 
     const statsFilter = filter();
-    const callSidTicketCounts = await findCallSidTicketCountsByCity(CITY, ticketDateScope(statsFilter));
+    const callSidTicketCounts = await findCallSidTicketCountsByCity(
+      CITY,
+      ticketDateScope(statsFilter),
+    );
     const openedOnly = await aggregateCallsSummary(
       filter({ callSidTicketCounts, ticketStatusFilters: ["opened"] }),
     );
@@ -137,9 +153,21 @@ describe("calls statistics getters", () => {
 
   it("should aggregate subjects only for calls passing the filter", async () => {
     await getDepartmentsSubjectsCollection().insertMany([
-      createDepartmentSubject({ cityName: CITY, subject_id: "100", subjectName: "Water" }),
-      createDepartmentSubject({ cityName: CITY, subject_id: "200", subjectName: "Roads" }),
-      createDepartmentSubject({ cityName: CITY, subject_id: "300", subjectName: "Lighting" }),
+      createDepartmentSubject({
+        cityName: CITY,
+        subject_id: "100",
+        subjectName: "Water",
+      }),
+      createDepartmentSubject({
+        cityName: CITY,
+        subject_id: "200",
+        subjectName: "Roads",
+      }),
+      createDepartmentSubject({
+        cityName: CITY,
+        subject_id: "300",
+        subjectName: "Lighting",
+      }),
     ]);
     await getTicketsCollection().insertMany([
       createTicket({
@@ -159,7 +187,13 @@ describe("calls statistics getters", () => {
     ]);
 
     const statsFilter = filter();
-    expect(await findSubjectsByCityAndDateRange(CITY, statsFilter, ticketDateScope(statsFilter))).toEqual([
+    expect(
+      await findSubjectsByCityAndDateRange(
+        CITY,
+        statsFilter,
+        ticketDateScope(statsFilter),
+      ),
+    ).toEqual([
       { subject: "Water", count: 2 },
       { subject: "Lighting", count: 1 },
       { subject: "Roads", count: 1 },
@@ -167,14 +201,26 @@ describe("calls statistics getters", () => {
 
     const transferredOnly = filter({ callRouting: ["transferred"] });
     expect(
-      await findSubjectsByCityAndDateRange(CITY, transferredOnly, ticketDateScope(transferredOnly)),
+      await findSubjectsByCityAndDateRange(
+        CITY,
+        transferredOnly,
+        ticketDateScope(transferredOnly),
+      ),
     ).toEqual([{ subject: "Roads", count: 1 }]);
   });
 
   it("should aggregate subjects over a wide date range", async () => {
     await getDepartmentsSubjectsCollection().insertMany([
-      createDepartmentSubject({ cityName: CITY, subject_id: "100", subjectName: "Water" }),
-      createDepartmentSubject({ cityName: CITY, subject_id: "200", subjectName: "Roads" }),
+      createDepartmentSubject({
+        cityName: CITY,
+        subject_id: "100",
+        subjectName: "Water",
+      }),
+      createDepartmentSubject({
+        cityName: CITY,
+        subject_id: "200",
+        subjectName: "Roads",
+      }),
     ]);
     await incoming("CA-old-roads", "2024-01-01T10:00:00.000Z");
     await getTicketsCollection().insertOne(
@@ -187,8 +233,17 @@ describe("calls statistics getters", () => {
       }),
     );
 
-    const statsFilter = filter({ startStr: "2024-01-01", endStr: "2026-12-31" });
-    expect(await findSubjectsByCityAndDateRange(CITY, statsFilter, ticketDateScope(statsFilter))).toEqual([
+    const statsFilter = filter({
+      startStr: "2024-01-01",
+      endStr: "2026-12-31",
+    });
+    expect(
+      await findSubjectsByCityAndDateRange(
+        CITY,
+        statsFilter,
+        ticketDateScope(statsFilter),
+      ),
+    ).toEqual([
       { subject: "Water", count: 2 },
       { subject: "Roads", count: 1 },
     ]);
@@ -196,7 +251,10 @@ describe("calls statistics getters", () => {
 
   it("should aggregate hourly buckets with averages and optional hour window", async () => {
     const statsFilter = filter();
-    const daysInRange = rangeDurationDays(statsFilter.startStr, statsFilter.endStr);
+    const daysInRange = rangeDurationDays(
+      statsFilter.startStr,
+      statsFilter.endStr,
+    );
     const full = await aggregateCallsHourlyByRange(statsFilter);
 
     expect(full).toHaveLength(24);
@@ -209,20 +267,30 @@ describe("calls statistics getters", () => {
     });
 
     expect(
-      (await aggregateCallsHourlyByRange(filter({ startStr: "2026-05-12", endStr: "2026-05-12" }))).find(
-        (h) => h.hour === 12,
-      ),
+      (
+        await aggregateCallsHourlyByRange(
+          filter({ startStr: "2026-05-12", endStr: "2026-05-12" }),
+        )
+      ).find((h) => h.hour === 12),
     ).toEqual({ hour: 12, totalCalls: 1, avgCalls: 1 });
 
     const avgForOneCall = Math.round((1 / daysInRange) * 10) / 10;
-    expect(await aggregateCallsHourlyByRange(filter({ hourFrom: "10:00", hourTo: "13:00" }))).toEqual([
+    expect(
+      await aggregateCallsHourlyByRange(
+        filter({ hourFrom: "10:00", hourTo: "13:00" }),
+      ),
+    ).toEqual([
       { hour: 10, totalCalls: 0, avgCalls: 0 },
       { hour: 11, totalCalls: 0, avgCalls: 0 },
       { hour: 12, totalCalls: 1, avgCalls: avgForOneCall },
     ]);
 
     // hourTo is exclusive: ending at "12:00" stops before the 12:00 call, last bucket is 11.
-    expect(await aggregateCallsHourlyByRange(filter({ hourFrom: "10:00", hourTo: "12:00" }))).toEqual([
+    expect(
+      await aggregateCallsHourlyByRange(
+        filter({ hourFrom: "10:00", hourTo: "12:00" }),
+      ),
+    ).toEqual([
       { hour: 10, totalCalls: 0, avgCalls: 0 },
       { hour: 11, totalCalls: 0, avgCalls: 0 },
     ]);
@@ -249,9 +317,9 @@ describe("calls statistics getters", () => {
 
   it("should respect wrap-around hour window boundaries on both the first and last day", async () => {
     await incoming("CA-jun8-morning", "2026-06-08T07:00:00.000Z"); // Jun 8 10:00 local — excluded (first-day guard)
-    await incoming("CA-jun8-night",   "2026-06-08T20:30:00.000Z"); // Jun 8 23:30 local — included
+    await incoming("CA-jun8-night", "2026-06-08T20:30:00.000Z"); // Jun 8 23:30 local — included
     await incoming("CA-jun9-morning", "2026-06-09T05:00:00.000Z"); // Jun 9 08:00 local — included
-    await incoming("CA-jun9-noon",    "2026-06-09T10:30:00.000Z"); // Jun 9 13:30 local — excluded (>= hourTo)
+    await incoming("CA-jun9-noon", "2026-06-09T10:30:00.000Z"); // Jun 9 13:30 local — excluded (>= hourTo)
     await incoming("CA-jun9-evening", "2026-06-09T20:30:00.000Z"); // Jun 9 23:30 local — excluded (last-day guard)
 
     const twoDay = { startStr: "2026-06-08", endStr: "2026-06-09" } as const;
@@ -265,14 +333,21 @@ describe("calls statistics getters", () => {
 
     // Hourly: hours [23, 0, ..., 12] — only the 2 included calls appear.
     const hourly = await aggregateCallsHourlyByRange(f);
-    expect(hourly.map((b) => b.hour)).toEqual([23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+    expect(hourly.map((b) => b.hour)).toEqual([
+      23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+    ]);
     expect(hourly.find((b) => b.hour === 23)?.totalCalls).toBe(1); // Jun 8 23:30
-    expect(hourly.find((b) => b.hour === 8)?.totalCalls).toBe(1);  // Jun 9 08:00
+    expect(hourly.find((b) => b.hour === 8)?.totalCalls).toBe(1); // Jun 9 08:00
     expect(hourly.reduce((sum, b) => sum + b.totalCalls, 0)).toBe(2);
   });
 
   it("should fill day trend buckets with zeros", async () => {
-    expect(await aggregateCallsTrend(filter({ startStr: "2026-05-10", endStr: "2026-05-14" }), "day")).toEqual([
+    expect(
+      await aggregateCallsTrend(
+        filter({ startStr: "2026-05-10", endStr: "2026-05-14" }),
+        "day",
+      ),
+    ).toEqual([
       { bucket: "2026-05-10", totalCalls: 1, openTickets: 0 },
       { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
       { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
@@ -282,8 +357,15 @@ describe("calls statistics getters", () => {
   });
 
   it("should bucket calls by calendar day in filter timezone", async () => {
-    await incoming("CA-jerusalem-midnight", "2026-05-09T21:00:00.000Z", { callLength: 45 });
-    expect(await aggregateCallsTrend(filter({ startStr: "2026-05-10", endStr: "2026-05-12" }), "day")).toEqual([
+    await incoming("CA-jerusalem-midnight", "2026-05-09T21:00:00.000Z", {
+      callLength: 45,
+    });
+    expect(
+      await aggregateCallsTrend(
+        filter({ startStr: "2026-05-10", endStr: "2026-05-12" }),
+        "day",
+      ),
+    ).toEqual([
       { bucket: "2026-05-10", totalCalls: 2, openTickets: 0 },
       { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
       { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
@@ -292,7 +374,9 @@ describe("calls statistics getters", () => {
 
   it("should pick month, week, or day bucket from calendar-month span", () => {
     expect(rangeDurationMonths("2025-06-01", "2026-05-31")).toBe(12);
-    expect(resolveTimeBucketFromRange("2025-06-01", "2026-05-31")).toBe("month");
+    expect(resolveTimeBucketFromRange("2025-06-01", "2026-05-31")).toBe(
+      "month",
+    );
     expect(resolveTimeBucketFromRange("2026-01-01", "2026-06-30")).toBe("week");
     expect(resolveTimeBucketFromRange("2026-04-01", "2026-06-30")).toBe("day");
   });
@@ -300,7 +384,10 @@ describe("calls statistics getters", () => {
   it("should fill month trend buckets with zeros", async () => {
     await incoming("CA-feb", "2026-02-15T10:00:00.000Z");
     await incoming("CA-apr", "2026-04-15T10:00:00.000Z");
-    const month = await aggregateCallsTrend(filter({ startStr: "2026-01-01", endStr: "2026-06-30" }), "month");
+    const month = await aggregateCallsTrend(
+      filter({ startStr: "2026-01-01", endStr: "2026-06-30" }),
+      "month",
+    );
     expect(month.map((row) => row.bucket)).toEqual([
       "2026-01-01",
       "2026-02-01",
@@ -309,14 +396,23 @@ describe("calls statistics getters", () => {
       "2026-05-01",
       "2026-06-01",
     ]);
-    expect(month.find((row) => row.bucket === "2026-02-01")).toMatchObject({ totalCalls: 1, openTickets: 0 });
-    expect(month.find((row) => row.bucket === "2026-05-01")).toMatchObject({ totalCalls: 3, openTickets: 0 });
+    expect(month.find((row) => row.bucket === "2026-02-01")).toMatchObject({
+      totalCalls: 1,
+      openTickets: 0,
+    });
+    expect(month.find((row) => row.bucket === "2026-05-01")).toMatchObject({
+      totalCalls: 3,
+      openTickets: 0,
+    });
   });
 
   it("should fill week trend buckets with zeros", async () => {
     await incoming("CA-week-2", "2026-05-18T10:00:00.000Z");
     expect(
-      await aggregateCallsTrend(filter({ startStr: "2026-05-04", endStr: "2026-05-24" }), "week"),
+      await aggregateCallsTrend(
+        filter({ startStr: "2026-05-04", endStr: "2026-05-24" }),
+        "week",
+      ),
     ).toEqual([
       { bucket: "2026-05-04/2026-05-09", totalCalls: 0, openTickets: 0 },
       { bucket: "2026-05-10/2026-05-16", totalCalls: 3, openTickets: 0 },
@@ -329,11 +425,18 @@ describe("calls statistics getters", () => {
     const startStr = "2025-07-02";
     const endStr = "2026-06-02";
     const startedAt = Date.now();
-    const trend = await aggregateCallsTrend(filter({ startStr, endStr }), "day");
+    const trend = await aggregateCallsTrend(
+      filter({ startStr, endStr }),
+      "day",
+    );
     const elapsedMs = Date.now() - startedAt;
 
     expect(trend).toHaveLength(rangeDurationDays(startStr, endStr));
-    expect(trend[0]).toEqual({ bucket: startStr, totalCalls: 0, openTickets: 0 });
+    expect(trend[0]).toEqual({
+      bucket: startStr,
+      totalCalls: 0,
+      openTickets: 0,
+    });
     expect(trend[trend.length - 1].bucket).toBe(endStr);
     expect(elapsedMs).toBeLessThan(5000);
   });
@@ -366,10 +469,15 @@ describe("calls statistics getters", () => {
 
     const statsFilter = filter();
     const dateScope = ticketDateScope(statsFilter);
-    const callSidDraftTicketCounts = await findCallSidDraftTicketCountsByCity(CITY, dateScope);
+    const callSidDraftTicketCounts = await findCallSidDraftTicketCountsByCity(
+      CITY,
+      dateScope,
+    );
     const summary = await summaryWithTicketSids();
 
-    expect([...callSidDraftTicketCounts.keys()].sort()).toEqual(["CA-hijacked", "CA-whitespace-draft"].sort());
+    expect([...callSidDraftTicketCounts.keys()].sort()).toEqual(
+      ["CA-hijacked", "CA-whitespace-draft"].sort(),
+    );
     expect(summary).toMatchObject({ openTickets: 4, draftTickets: 1 });
   });
 });

package/src/talkpilot/calls/calls.statistics.getters.ts

@@ -41,6 +41,7 @@ const emptySummary = (): CallsSummaryAggregation => ({
   avgDurationSeconds: 0,
   openTickets: 0,
   draftTickets: 0,
+  callsWithTickets: 0,
 });
 
 const emptyRouting = (): CallsRoutingAggregation => ({
@@ -62,7 +63,9 @@ const countIf = (condition: Record<string, unknown>) => ({
   $sum: { $cond: [condition, 1, 0] },
 });
 
-const needsTicketStatusFilter = (filters?: CallsStatsFilter["ticketStatusFilters"]) => {
+const needsTicketStatusFilter = (
+  filters?: CallsStatsFilter["ticketStatusFilters"],
+) => {
   if (!filters?.length) return false;
   const hasOpened = filters.includes("opened");
   const hasNotOpened = filters.includes("not_opened");
@@ -100,9 +103,13 @@ const ticketStatusMatch = (filter: CallsStatsFilter) => {
 
 // "HH:mm" → minute-of-day (0-1439), for the per-call time-of-day filter.
 const parseMinuteOfDay = (time?: string): number | undefined =>
-  time == null ? undefined : Number(time.slice(0, 2)) * 60 + Number(time.slice(3, 5));
+  time == null
+    ? undefined
+    : Number(time.slice(0, 2)) * 60 + Number(time.slice(3, 5));
 
-const hourMatch = (filter: CallsStatsFilter): Record<string, unknown> | null => {
+const hourMatch = (
+  filter: CallsStatsFilter,
+): Record<string, unknown> | null => {
   const from = parseMinuteOfDay(filter.hourFrom);
   const to = parseMinuteOfDay(filter.hourTo);
   if (from == null && to == null) return null;
@@ -133,7 +140,9 @@ const createdAtMatchForFilter = (
   return { createdAt: { $gte: bounds.from!, $lte: bounds.to! } };
 };
 
-const buildCallsMatchStages = (filter: CallsStatsFilter): Record<string, unknown>[] => {
+const buildCallsMatchStages = (
+  filter: CallsStatsFilter,
+): Record<string, unknown>[] => {
   const hourRange = hourMatch(filter);
   const routing = routingMatch(filter.callRouting);
   const ticketMatch = ticketStatusMatch(filter);
@@ -158,7 +167,12 @@ const buildCallsMatchStages = (filter: CallsStatsFilter): Record<string, unknown
         hour: { $hour: { date: "$createdAt", timezone: filter.timezone } },
         minuteOfDay: {
           $add: [
-            { $multiply: [{ $hour: { date: "$createdAt", timezone: filter.timezone } }, 60] },
+            {
+              $multiply: [
+                { $hour: { date: "$createdAt", timezone: filter.timezone } },
+                60,
+              ],
+            },
             { $minute: { date: "$createdAt", timezone: filter.timezone } },
           ],
         },
@@ -183,14 +197,16 @@ const trendBucketExpr = (bucket: ResolvedTimeBucket, timezone: string) =>
   bucket === "day"
     ? { bucket: "$dateLocal" }
     : {
-      bucket: {
-        $dateToString: {
-          format: "%Y-%m-%d",
-          date: { $dateTrunc: { date: "$createdAt", unit: bucket, timezone } },
-          timezone,
+        bucket: {
+          $dateToString: {
+            format: "%Y-%m-%d",
+            date: {
+              $dateTrunc: { date: "$createdAt", unit: bucket, timezone },
+            },
+            timezone,
+          },
         },
-      },
-    };
+      };
 
 const mapTrendRow = (row: {
   _id: unknown;
@@ -212,7 +228,10 @@ export const rangeDurationDays = (startStr: string, endStr: string): number => {
  * Number of distinct calendar months the [startStr, endStr] range spans, inclusive.
  * Counts month boundaries rather than 30-day periods: e.g. Jan 31 -> Feb 1 returns 2.
  */
-export const rangeDurationMonths = (startStr: string, endStr: string): number => {
+export const rangeDurationMonths = (
+  startStr: string,
+  endStr: string,
+): number => {
   const [sy, sm] = parseYmd(startStr);
   const [ey, em] = parseYmd(endStr);
   return (ey - sy) * 12 + (em - sm) + 1;
@@ -235,7 +254,9 @@ export const resolveTimeBucketFromRange = (
 
 const weekBucketKeyForDate = (dateStr: string, timezone: string): string => {
   const anchor = dateAtNoonUtc(dateStr);
-  const weekStart = new Date(anchor.getTime() - getWeekdayInTz(anchor, timezone) * DAY_MS);
+  const weekStart = new Date(
+    anchor.getTime() - getWeekdayInTz(anchor, timezone) * DAY_MS,
+  );
   return formatYmdInTz(weekStart, timezone);
 };
 
@@ -270,7 +291,11 @@ const fillDailyTrendBuckets = (
   const byBucket = indexTrendRowsByBucket(rows);
   const filled: CallsTrendBucket[] = [];
 
-  for (let cursor = startStr; cursor <= endStr; cursor = ymdToStr(...incrementYmd(...parseYmd(cursor)))) {
+  for (
+    let cursor = startStr;
+    cursor <= endStr;
+    cursor = ymdToStr(...incrementYmd(...parseYmd(cursor)))
+  ) {
     filled.push(byBucket.get(cursor) ?? emptyTrendBucket(cursor));
   }
 
@@ -313,7 +338,11 @@ const fillWeeklyTrendBuckets = (
   const filled: CallsTrendBucket[] = [];
   const seen = new Set<string>();
 
-  for (let i = 0, days = rangeDurationDays(startStr, endStr); i < days; i += 1) {
+  for (
+    let i = 0, days = rangeDurationDays(startStr, endStr);
+    i < days;
+    i += 1
+  ) {
     const bucket = formatWeekBucketRange(
       weekBucketKeyForDate(addDaysToDateStr(startStr, i), timezone),
       startStr,
@@ -347,10 +376,13 @@ const fillTrendBuckets = (
   }
 };
 
-const resolveHourRange = (filter: CallsStatsFilter): { hourFrom: number; hourTo: number } => {
+const resolveHourRange = (
+  filter: CallsStatsFilter,
+): { hourFrom: number; hourTo: number } => {
   const from = parseMinuteOfDay(filter.hourFrom);
   const to = parseMinuteOfDay(filter.hourTo);
-  if (from == null && to == null) return { hourFrom: 0, hourTo: HOURS_PER_DAY - 1 };
+  if (from == null && to == null)
+    return { hourFrom: 0, hourTo: HOURS_PER_DAY - 1 };
   return {
     hourFrom: from == null ? 0 : Math.floor(from / 60),
     // hourTo is exclusive: last populated bucket is the hour holding minute (to - 1).
@@ -392,12 +424,18 @@ const toHourlyDistribution = (
 export const aggregateCallsSummary = async (
   filter: CallsStatsFilter,
 ): Promise<CallsSummaryAggregation> => {
-  const hasTickets = Boolean(filter.callSidTicketCounts?.size || filter.callSidDraftTicketCounts?.size);
+  const hasTickets = Boolean(
+    filter.callSidTicketCounts?.size || filter.callSidDraftTicketCounts?.size,
+  );
   const hasStatusFilter = needsTicketStatusFilter(filter.ticketStatusFilters);
 
   if (!hasTickets && !hasStatusFilter) {
     const result = await aggregateCalls(filter, {
-      $group: { _id: null, totalCalls: { $sum: 1 }, avgDurationSeconds: { $avg: "$callLength" } },
+      $group: {
+        _id: null,
+        totalCalls: { $sum: 1 },
+        avgDurationSeconds: { $avg: "$callLength" },
+      },
     }).next();
     if (!result) return emptySummary();
     return {
@@ -405,6 +443,7 @@ export const aggregateCallsSummary = async (
       avgDurationSeconds: roundOneDecimal(result.avgDurationSeconds ?? 0),
       openTickets: 0,
       draftTickets: 0,
+      callsWithTickets: 0,
     };
   }
 
@@ -417,13 +456,16 @@ export const aggregateCallsSummary = async (
 
   const ticketMap = filter.callSidTicketCounts ?? new Map<string, number>();
   const draftMap = filter.callSidDraftTicketCounts ?? new Map<string, number>();
-  const openedOnly = hasStatusFilter && filter.ticketStatusFilters!.includes("opened");
-  const notOpenedOnly = hasStatusFilter && filter.ticketStatusFilters!.includes("not_opened");
+  const openedOnly =
+    hasStatusFilter && filter.ticketStatusFilters!.includes("opened");
+  const notOpenedOnly =
+    hasStatusFilter && filter.ticketStatusFilters!.includes("not_opened");
 
   let totalCalls = 0;
   let totalDuration = 0;
   let openTickets = 0;
   let draftTickets = 0;
+  let callsWithTickets = 0;
 
   for (const row of rows) {
     const sid = row.callSid as string;
@@ -433,6 +475,7 @@ export const aggregateCallsSummary = async (
     totalCalls += 1;
     totalDuration += (row.callLength as number | undefined) ?? 0;
     openTickets += ticketMap.get(sid) ?? 0;
+    if (ticketMap.has(sid)) callsWithTickets += 1;
     draftTickets += draftMap.get(sid) ?? 0;
   }
 
@@ -443,6 +486,7 @@ export const aggregateCallsSummary = async (
     avgDurationSeconds: roundOneDecimal(totalDuration / totalCalls),
     openTickets,
     draftTickets,
+    callsWithTickets,
   };
 };
 
@@ -461,10 +505,17 @@ export const aggregateCallsTrend = async (
       { $project: { _id: 0, bucket: 1, callSid: 1 } },
     ).toArray();
 
-    const openedOnly = needsTicketStatusFilter(filter.ticketStatusFilters) && filter.ticketStatusFilters!.includes("opened");
-    const notOpenedOnly = needsTicketStatusFilter(filter.ticketStatusFilters) && filter.ticketStatusFilters!.includes("not_opened");
-
-    const byBucket = new Map<string, { totalCalls: number; openTickets: number }>();
+    const openedOnly =
+      needsTicketStatusFilter(filter.ticketStatusFilters) &&
+      filter.ticketStatusFilters!.includes("opened");
+    const notOpenedOnly =
+      needsTicketStatusFilter(filter.ticketStatusFilters) &&
+      filter.ticketStatusFilters!.includes("not_opened");
+
+    const byBucket = new Map<
+      string,
+      { totalCalls: number; openTickets: number }
+    >();
     for (const row of rows) {
       const sid = row.callSid as string;
       const hasTicket = ticketMap.has(sid);
@@ -472,7 +523,11 @@ export const aggregateCallsTrend = async (
       if (notOpenedOnly && hasTicket) continue;
       const label =
         bucket === "week"
-          ? formatWeekBucketRange(String(row.bucket), filter.startStr, filter.endStr)
+          ? formatWeekBucketRange(
+              String(row.bucket),
+              filter.startStr,
+              filter.endStr,
+            )
           : String(row.bucket);
       const cur = byBucket.get(label) ?? { totalCalls: 0, openTickets: 0 };
       cur.totalCalls += 1;
@@ -480,10 +535,18 @@ export const aggregateCallsTrend = async (
       byBucket.set(label, cur);
     }
 
-    const mappedRows = [...byBucket.entries()]
-      .map(([label, counts]) => ({ bucket: label, ...counts }));
-
-    return fillTrendBuckets(mappedRows, bucket, filter.startStr, filter.endStr, filter.timezone);
+    const mappedRows = [...byBucket.entries()].map(([label, counts]) => ({
+      bucket: label,
+      ...counts,
+    }));
+
+    return fillTrendBuckets(
+      mappedRows,
+      bucket,
+      filter.startStr,
+      filter.endStr,
+      filter.timezone,
+    );
   }
 
   const rows = await aggregateCalls(
@@ -496,15 +559,29 @@ export const aggregateCallsTrend = async (
   const mappedRows =
     bucket === "week"
       ? rows.map((row) => ({
-        bucket: formatWeekBucketRange(String(row._id), filter.startStr, filter.endStr),
-        totalCalls: row.totalCalls as number,
-        openTickets: 0,
-      }))
+          bucket: formatWeekBucketRange(
+            String(row._id),
+            filter.startStr,
+            filter.endStr,
+          ),
+          totalCalls: row.totalCalls as number,
+          openTickets: 0,
+        }))
       : rows.map((row) =>
-        mapTrendRow({ _id: row._id, totalCalls: row.totalCalls as number, openTickets: 0 }),
-      );
-
-  return fillTrendBuckets(mappedRows, bucket, filter.startStr, filter.endStr, filter.timezone);
+          mapTrendRow({
+            _id: row._id,
+            totalCalls: row.totalCalls as number,
+            openTickets: 0,
+          }),
+        );
+
+  return fillTrendBuckets(
+    mappedRows,
+    bucket,
+    filter.startStr,
+    filter.endStr,
+    filter.timezone,
+  );
 };
 
 export const aggregateCallsHourlyByRange = async (
@@ -554,11 +631,12 @@ export const aggregateCallsRouting = async (
   };
 };
 
-export const findFilteredCallSids = async (filter: CallsStatsFilter): Promise<string[]> => {
-  const rows = await aggregateCalls(
-    filter,
-    { $group: { _id: "$callSid" } },
-  ).toArray();
+export const findFilteredCallSids = async (
+  filter: CallsStatsFilter,
+): Promise<string[]> => {
+  const rows = await aggregateCalls(filter, {
+    $group: { _id: "$callSid" },
+  }).toArray();
   return rows.map((r) => String(r._id)).filter(Boolean);
 };
 

package/src/talkpilot/calls/calls.statistics.types.ts

@@ -25,6 +25,7 @@ export type CallsSummaryAggregation = {
   avgDurationSeconds: number;
   openTickets: number;
   draftTickets: number;
+  callsWithTickets?: number;
 };
 
 export type CallsTrendBucket = {