@talkpilot/core-db 1.3.6 → 1.3.8

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

@@ -1,344 +1,351 @@
-import {
-  aggregateCallsHourlyByRange,
-  aggregateCallsRouting,
-  aggregateCallsSummary,
-  aggregateCallsTrend,
-  findCallSidsWithDraftTicketsByCity,
-  findCallSidsWithTicketsByCity,
-  getCallsCollection,
-  getDepartmentsSubjectsCollection,
-  getTicketsCollection,
-  findSubjectsByCityAndDateRange,
-  rangeDurationDays,
-  rangeDurationMonths,
-  resolveTimeBucketFromRange,
-  ticketStatsDateScopeFromYmd,
-} from "../../../index";
-import type { Call } from "../calls.types";
-import type { CallsStatsFilter } from "../calls.statistics.types";
-import {
-  createDepartmentSubject,
-  createIncomingCallDoc,
-  createOutGoingCallDoc,
-  createTicket,
-} from "../../../test-utils/factories";
-const CLIENT_ID = "stats-client";
-const CITY = "tests" as const;
-const TZ = "Asia/Jerusalem";
-const at = (iso: string) => new Date(iso);
-
-const insertCall = (call: Call) =>
-  getCallsCollection().insertOne({ ...call, env: call.env ?? "test" });
-
-const incoming = (callSid: string, createdAt: string, extra?: Partial<Call>) =>
-  insertCall(
-    createIncomingCallDoc({
-      clientId: CLIENT_ID,
-      callSid,
-      createdAt: at(createdAt),
-      updatedAt: at(extra?.updatedAt?.toISOString() ?? createdAt),
-      ...extra,
-    }),
-  );
-
-const filter = (overrides?: Partial<CallsStatsFilter>): CallsStatsFilter => ({
-  clientId: CLIENT_ID,
-  startStr: "2026-05-01",
-  endStr: "2026-05-31",
-  timezone: TZ,
-  callSidsWithTickets: [],
-  callSidsWithDraftTickets: [],
-  ...overrides,
-});
-
-const ticketDateScope = (statsFilter: CallsStatsFilter) =>
-  ticketStatsDateScopeFromYmd(statsFilter.startStr, statsFilter.endStr, statsFilter.timezone);
-
-const summaryWithTicketSids = async (overrides?: Partial<CallsStatsFilter>) => {
-  const statsFilter = filter(overrides);
-  const dateScope = ticketDateScope(statsFilter);
-  const callSidsWithTickets = await findCallSidsWithTicketsByCity(CITY, dateScope);
-  const callSidsWithDraftTickets = await findCallSidsWithDraftTicketsByCity(CITY, dateScope);
-  return aggregateCallsSummary(filter({ callSidsWithTickets, callSidsWithDraftTickets, ...overrides }));
-};
-
-describe("calls statistics getters", () => {
-  beforeEach(async () => {
-    await incoming("CA-with-ticket", "2026-05-10T10:00:00.000Z", {
-      callLength: 120,
-      updatedAt: at("2026-05-10T10:02:00.000Z"),
-    });
-    await incoming("CA-transferred", "2026-05-11T14:00:00.000Z", {
-      callLength: 60,
-      redirectedCall: true,
-      updatedAt: at("2026-05-11T14:01:00.000Z"),
-    });
-    await incoming("CA-hijacked", "2026-05-12T09:00:00.000Z", {
-      callLength: 90,
-      isConferenceCall: true,
-      redirectedCall: false,
-      updatedAt: at("2026-05-12T09:01:30.000Z"),
-    });
-    await insertCall(
-      createOutGoingCallDoc({
-        clientId: CLIENT_ID,
-        callSid: "CA-outgoing",
-        createdAt: at("2026-05-10T11:00:00.000Z"),
-        updatedAt: at("2026-05-10T11:01:00.000Z"),
-      }),
-    );
-    await getTicketsCollection().insertOne(
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-with-ticket",
-        createdAt: at("2026-05-10T10:00:00.000Z"),
-        updatedAt: at("2026-05-10T10:00:00.000Z"),
-        externalCallFields: { event_subject_id: "100" },
-      }),
-    );
-  });
-
-  it("should exclude calls outside the filter date range from summary", async () => {
-    await incoming("CA-old", "2024-01-01T10:00:00.000Z", { callLength: 999 });
-    const summary = await aggregateCallsSummary(filter());
-    expect(summary).toMatchObject({ totalCalls: 3, avgDurationSeconds: 90 });
-  });
-
-  it("should aggregate summary with ticket sids and opened-ticket filter", async () => {
-    expect(await summaryWithTicketSids()).toEqual({
-      totalCalls: 3,
-      openTickets: 1,
-      draftTickets: 0,
-      avgDurationSeconds: 90,
-    });
-
-    const statsFilter = filter();
-    const callSidsWithTickets = await findCallSidsWithTicketsByCity(CITY, ticketDateScope(statsFilter));
-    const openedOnly = await aggregateCallsSummary(
-      filter({ callSidsWithTickets, ticketStatusFilters: ["opened"] }),
-    );
-    expect(openedOnly).toMatchObject({ totalCalls: 1, openTickets: 1 });
-  });
-
-  it("should classify routing into mutually exclusive buckets", async () => {
-    expect(await aggregateCallsRouting(filter())).toEqual({
-      transferred: 1,
-      hijacked: 1,
-      aiHandled: 1,
-    });
-  });
-
-  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" }),
-    ]);
-    await getTicketsCollection().insertMany([
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-transferred",
-        createdAt: at("2026-05-11T14:00:00.000Z"),
-        updatedAt: at("2026-05-11T14:00:00.000Z"),
-        externalCallFields: { event_subject_id: "200" },
-      }),
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-hijacked",
-        createdAt: at("2026-05-12T09:00:00.000Z"),
-        updatedAt: at("2026-05-12T09:00:00.000Z"),
-        externalCallFields: { event_subject_id: "300" },
-      }),
-    ]);
-
-    const statsFilter = filter();
-    expect(await findSubjectsByCityAndDateRange(CITY, statsFilter, ticketDateScope(statsFilter))).toEqual([
-      { subject: "Lighting", count: 1 },
-      { subject: "Roads", count: 1 },
-      { subject: "Water", count: 1 },
-    ]);
-
-    const transferredOnly = filter({ callRouting: ["transferred"] });
-    expect(
-      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" }),
-    ]);
-    await incoming("CA-old-roads", "2024-01-01T10:00:00.000Z");
-    await getTicketsCollection().insertOne(
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-old-roads",
-        createdAt: at("2024-01-01T10:00:00.000Z"),
-        updatedAt: at("2024-01-01T10:00:00.000Z"),
-        externalCallFields: { event_subject_id: "200" },
-      }),
-    );
-
-    const statsFilter = filter({ startStr: "2024-01-01", endStr: "2026-12-31" });
-    expect(await findSubjectsByCityAndDateRange(CITY, statsFilter, ticketDateScope(statsFilter))).toEqual([
-      { subject: "Roads", count: 1 },
-      { subject: "Water", count: 1 },
-    ]);
-  });
-
-  it("should aggregate hourly buckets with averages and optional hour window", async () => {
-    const statsFilter = filter();
-    const daysInRange = rangeDurationDays(statsFilter.startStr, statsFilter.endStr);
-    const full = await aggregateCallsHourlyByRange(statsFilter);
-
-    expect(full).toHaveLength(24);
-    expect(full[0]).toEqual({ hour: 0, totalCalls: 0, avgCalls: 0 });
-    expect(full.reduce((sum, h) => sum + h.totalCalls, 0)).toBe(3);
-    expect(full.find((h) => h.hour === 12)).toEqual({
-      hour: 12,
-      totalCalls: 1,
-      avgCalls: Math.round((1 / daysInRange) * 10) / 10,
-    });
-
-    expect(
-      (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([
-      { 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([
-      { hour: 10, totalCalls: 0, avgCalls: 0 },
-      { hour: 11, totalCalls: 0, avgCalls: 0 },
-    ]);
-  });
-
-  it("should emit a wrap-around hour window and count calls on both sides of midnight", async () => {
-    // 2026-05-12 local: 23:30 (20:30Z) and 01:00 (2026-05-12 22:00Z) straddle midnight;
-    // CA-two-am at 02:00 local (2026-05-11 23:00Z) sits exactly on the exclusive end.
-    await incoming("CA-late", "2026-05-12T20:30:00.000Z");
-    await incoming("CA-early", "2026-05-12T22:00:00.000Z");
-    await incoming("CA-two-am", "2026-05-11T23:00:00.000Z");
-    const oneDay = { startStr: "2026-05-12", endStr: "2026-05-13" } as const;
-
-    const buckets = await aggregateCallsHourlyByRange(
-      filter({ ...oneDay, hourFrom: "22:00", hourTo: "02:00" }),
-    );
-
-    // hourTo "02:00" is exclusive: last bucket is 1, and the 02:00 call is not counted.
-    expect(buckets.map((b) => b.hour)).toEqual([22, 23, 0, 1]);
-    expect(buckets.find((b) => b.hour === 23)?.totalCalls).toBe(1);
-    expect(buckets.find((b) => b.hour === 1)?.totalCalls).toBe(1);
-    expect(buckets.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([
-      { bucket: "2026-05-10", totalCalls: 1, openTickets: 0 },
-      { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
-      { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
-      { bucket: "2026-05-13", totalCalls: 0, openTickets: 0 },
-      { bucket: "2026-05-14", totalCalls: 0, openTickets: 0 },
-    ]);
-  });
-
-  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([
-      { bucket: "2026-05-10", totalCalls: 2, openTickets: 0 },
-      { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
-      { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
-    ]);
-  });
-
-  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("2026-01-01", "2026-06-30")).toBe("week");
-    expect(resolveTimeBucketFromRange("2026-04-01", "2026-06-30")).toBe("day");
-  });
-
-  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");
-    expect(month.map((row) => row.bucket)).toEqual([
-      "2026-01-01",
-      "2026-02-01",
-      "2026-03-01",
-      "2026-04-01",
-      "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 });
-  });
-
-  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"),
-    ).toEqual([
-      { bucket: "2026-05-04/2026-05-09", totalCalls: 0, openTickets: 0 },
-      { bucket: "2026-05-10/2026-05-16", totalCalls: 3, openTickets: 0 },
-      { bucket: "2026-05-17/2026-05-23", totalCalls: 1, openTickets: 0 },
-      { bucket: "2026-05-24/2026-05-24", totalCalls: 0, openTickets: 0 },
-    ]);
-  });
-
-  it("should complete every day bucket across a 12-month range without hanging (DST regression)", async () => {
-    const startStr = "2025-07-02";
-    const endStr = "2026-06-02";
-    const startedAt = Date.now();
-    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[trend.length - 1].bucket).toBe(endStr);
-    expect(elapsedMs).toBeLessThan(5000);
-  });
-
-  it("should count draft tickets and distinct draft call sids", async () => {
-    const descriptionDraft = createTicket({
-      cityName: CITY,
-      callSid: "CA-hijacked",
-      createdAt: at("2026-05-12T09:00:00.000Z"),
-      updatedAt: at("2026-05-12T09:00:00.000Z"),
-    });
-    descriptionDraft.externalCallFields = { event_description: "draft ticket" };
-    await getTicketsCollection().insertMany([
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-transferred",
-        createdAt: at("2026-05-11T14:00:00.000Z"),
-        updatedAt: at("2026-05-11T14:00:00.000Z"),
-        externalCallFields: { event_subject_id: "100" },
-      }),
-      descriptionDraft,
-      createTicket({
-        cityName: CITY,
-        callSid: "CA-whitespace-draft",
-        createdAt: at("2026-05-12T10:00:00.000Z"),
-        updatedAt: at("2026-05-12T10:00:00.000Z"),
-        externalCallFields: { event_subject_id: "   " },
-      }),
-    ]);
-
-    const statsFilter = filter();
-    const dateScope = ticketDateScope(statsFilter);
-    const callSidsWithDraftTickets = await findCallSidsWithDraftTicketsByCity(CITY, dateScope);
-    const summary = await summaryWithTicketSids();
-
-    expect(callSidsWithDraftTickets.sort()).toEqual(["CA-hijacked", "CA-whitespace-draft"].sort());
-    expect(summary).toMatchObject({ openTickets: 3, draftTickets: 1 });
-  });
-});
+import {
+  aggregateCallsHourlyByRange,
+  aggregateCallsRouting,
+  aggregateCallsSummary,
+  aggregateCallsTrend,
+  findCallSidDraftTicketCountsByCity,
+  findCallSidTicketCountsByCity,
+  getCallsCollection,
+  getDepartmentsSubjectsCollection,
+  getTicketsCollection,
+  findSubjectsByCityAndDateRange,
+  rangeDurationDays,
+  rangeDurationMonths,
+  resolveTimeBucketFromRange,
+  ticketStatsDateScopeFromYmd,
+} from "../../../index";
+import type { Call } from "../calls.types";
+import type { CallsStatsFilter } from "../calls.statistics.types";
+import {
+  createDepartmentSubject,
+  createIncomingCallDoc,
+  createOutGoingCallDoc,
+  createTicket,
+} from "../../../test-utils/factories";
+const CLIENT_ID = "stats-client";
+const CITY = "tests" as const;
+const TZ = "Asia/Jerusalem";
+const at = (iso: string) => new Date(iso);
+
+const insertCall = (call: Call) =>
+  getCallsCollection().insertOne({ ...call, env: call.env ?? "test" });
+
+const incoming = (callSid: string, createdAt: string, extra?: Partial<Call>) =>
+  insertCall(
+    createIncomingCallDoc({
+      clientId: CLIENT_ID,
+      callSid,
+      createdAt: at(createdAt),
+      updatedAt: at(extra?.updatedAt?.toISOString() ?? createdAt),
+      ...extra,
+    }),
+  );
+
+const filter = (overrides?: Partial<CallsStatsFilter>): CallsStatsFilter => ({
+  clientId: CLIENT_ID,
+  startStr: "2026-05-01",
+  endStr: "2026-05-31",
+  timezone: TZ,
+  callSidTicketCounts: new Map(),
+  callSidDraftTicketCounts: new Map(),
+  ...overrides,
+});
+
+const ticketDateScope = (statsFilter: CallsStatsFilter) =>
+  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 }));
+};
+
+describe("calls statistics getters", () => {
+  beforeEach(async () => {
+    await incoming("CA-with-ticket", "2026-05-10T10:00:00.000Z", {
+      callLength: 120,
+      updatedAt: at("2026-05-10T10:02:00.000Z"),
+    });
+    await incoming("CA-transferred", "2026-05-11T14:00:00.000Z", {
+      callLength: 60,
+      redirectedCall: true,
+      updatedAt: at("2026-05-11T14:01:00.000Z"),
+    });
+    await incoming("CA-hijacked", "2026-05-12T09:00:00.000Z", {
+      callLength: 90,
+      isConferenceCall: true,
+      redirectedCall: false,
+      updatedAt: at("2026-05-12T09:01:30.000Z"),
+    });
+    await insertCall(
+      createOutGoingCallDoc({
+        clientId: CLIENT_ID,
+        callSid: "CA-outgoing",
+        createdAt: at("2026-05-10T11:00:00.000Z"),
+        updatedAt: at("2026-05-10T11:01:00.000Z"),
+      }),
+    );
+    await getTicketsCollection().insertMany([
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-with-ticket",
+        createdAt: at("2026-05-10T10:00:00.000Z"),
+        updatedAt: at("2026-05-10T10:00:00.000Z"),
+        externalCallFields: { event_subject_id: "100" },
+      }),
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-with-ticket",
+        createdAt: at("2026-05-10T10:30:00.000Z"),
+        updatedAt: at("2026-05-10T10:30:00.000Z"),
+        externalCallFields: { event_subject_id: "100" },
+      }),
+    ]);
+  });
+
+  it("should exclude calls outside the filter date range from summary", async () => {
+    await incoming("CA-old", "2024-01-01T10:00:00.000Z", { callLength: 999 });
+    const summary = await aggregateCallsSummary(filter());
+    expect(summary).toMatchObject({ totalCalls: 3, avgDurationSeconds: 90 });
+  });
+
+  it("should aggregate summary with ticket sids and opened-ticket filter", async () => {
+    expect(await summaryWithTicketSids()).toEqual({
+      totalCalls: 3,
+      openTickets: 2,
+      draftTickets: 0,
+      avgDurationSeconds: 90,
+    });
+
+    const statsFilter = filter();
+    const callSidTicketCounts = await findCallSidTicketCountsByCity(CITY, ticketDateScope(statsFilter));
+    const openedOnly = await aggregateCallsSummary(
+      filter({ callSidTicketCounts, ticketStatusFilters: ["opened"] }),
+    );
+    expect(openedOnly).toMatchObject({ totalCalls: 1, openTickets: 2 });
+  });
+
+  it("should classify routing into mutually exclusive buckets", async () => {
+    expect(await aggregateCallsRouting(filter())).toEqual({
+      transferred: 1,
+      hijacked: 1,
+      aiHandled: 1,
+    });
+  });
+
+  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" }),
+    ]);
+    await getTicketsCollection().insertMany([
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-transferred",
+        createdAt: at("2026-05-11T14:00:00.000Z"),
+        updatedAt: at("2026-05-11T14:00:00.000Z"),
+        externalCallFields: { event_subject_id: "200" },
+      }),
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-hijacked",
+        createdAt: at("2026-05-12T09:00:00.000Z"),
+        updatedAt: at("2026-05-12T09:00:00.000Z"),
+        externalCallFields: { event_subject_id: "300" },
+      }),
+    ]);
+
+    const statsFilter = filter();
+    expect(await findSubjectsByCityAndDateRange(CITY, statsFilter, ticketDateScope(statsFilter))).toEqual([
+      { subject: "Water", count: 2 },
+      { subject: "Lighting", count: 1 },
+      { subject: "Roads", count: 1 },
+    ]);
+
+    const transferredOnly = filter({ callRouting: ["transferred"] });
+    expect(
+      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" }),
+    ]);
+    await incoming("CA-old-roads", "2024-01-01T10:00:00.000Z");
+    await getTicketsCollection().insertOne(
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-old-roads",
+        createdAt: at("2024-01-01T10:00:00.000Z"),
+        updatedAt: at("2024-01-01T10:00:00.000Z"),
+        externalCallFields: { event_subject_id: "200" },
+      }),
+    );
+
+    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 },
+    ]);
+  });
+
+  it("should aggregate hourly buckets with averages and optional hour window", async () => {
+    const statsFilter = filter();
+    const daysInRange = rangeDurationDays(statsFilter.startStr, statsFilter.endStr);
+    const full = await aggregateCallsHourlyByRange(statsFilter);
+
+    expect(full).toHaveLength(24);
+    expect(full[0]).toEqual({ hour: 0, totalCalls: 0, avgCalls: 0 });
+    expect(full.reduce((sum, h) => sum + h.totalCalls, 0)).toBe(3);
+    expect(full.find((h) => h.hour === 12)).toEqual({
+      hour: 12,
+      totalCalls: 1,
+      avgCalls: Math.round((1 / daysInRange) * 10) / 10,
+    });
+
+    expect(
+      (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([
+      { 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([
+      { hour: 10, totalCalls: 0, avgCalls: 0 },
+      { hour: 11, totalCalls: 0, avgCalls: 0 },
+    ]);
+  });
+
+  it("should emit a wrap-around hour window and count calls on both sides of midnight", async () => {
+    // 2026-05-12 local: 23:30 (20:30Z) and 01:00 (2026-05-12 22:00Z) straddle midnight;
+    // CA-two-am at 02:00 local (2026-05-11 23:00Z) sits exactly on the exclusive end.
+    await incoming("CA-late", "2026-05-12T20:30:00.000Z");
+    await incoming("CA-early", "2026-05-12T22:00:00.000Z");
+    await incoming("CA-two-am", "2026-05-11T23:00:00.000Z");
+    const oneDay = { startStr: "2026-05-12", endStr: "2026-05-13" } as const;
+
+    const buckets = await aggregateCallsHourlyByRange(
+      filter({ ...oneDay, hourFrom: "22:00", hourTo: "02:00" }),
+    );
+
+    // hourTo "02:00" is exclusive: last bucket is 1, and the 02:00 call is not counted.
+    expect(buckets.map((b) => b.hour)).toEqual([22, 23, 0, 1]);
+    expect(buckets.find((b) => b.hour === 23)?.totalCalls).toBe(1);
+    expect(buckets.find((b) => b.hour === 1)?.totalCalls).toBe(1);
+    expect(buckets.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([
+      { bucket: "2026-05-10", totalCalls: 1, openTickets: 0 },
+      { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
+      { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
+      { bucket: "2026-05-13", totalCalls: 0, openTickets: 0 },
+      { bucket: "2026-05-14", totalCalls: 0, openTickets: 0 },
+    ]);
+  });
+
+  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([
+      { bucket: "2026-05-10", totalCalls: 2, openTickets: 0 },
+      { bucket: "2026-05-11", totalCalls: 1, openTickets: 0 },
+      { bucket: "2026-05-12", totalCalls: 1, openTickets: 0 },
+    ]);
+  });
+
+  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("2026-01-01", "2026-06-30")).toBe("week");
+    expect(resolveTimeBucketFromRange("2026-04-01", "2026-06-30")).toBe("day");
+  });
+
+  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");
+    expect(month.map((row) => row.bucket)).toEqual([
+      "2026-01-01",
+      "2026-02-01",
+      "2026-03-01",
+      "2026-04-01",
+      "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 });
+  });
+
+  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"),
+    ).toEqual([
+      { bucket: "2026-05-04/2026-05-09", totalCalls: 0, openTickets: 0 },
+      { bucket: "2026-05-10/2026-05-16", totalCalls: 3, openTickets: 0 },
+      { bucket: "2026-05-17/2026-05-23", totalCalls: 1, openTickets: 0 },
+      { bucket: "2026-05-24/2026-05-24", totalCalls: 0, openTickets: 0 },
+    ]);
+  });
+
+  it("should complete every day bucket across a 12-month range without hanging (DST regression)", async () => {
+    const startStr = "2025-07-02";
+    const endStr = "2026-06-02";
+    const startedAt = Date.now();
+    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[trend.length - 1].bucket).toBe(endStr);
+    expect(elapsedMs).toBeLessThan(5000);
+  });
+
+  it("should count draft tickets and distinct draft call sids", async () => {
+    const descriptionDraft = createTicket({
+      cityName: CITY,
+      callSid: "CA-hijacked",
+      createdAt: at("2026-05-12T09:00:00.000Z"),
+      updatedAt: at("2026-05-12T09:00:00.000Z"),
+    });
+    descriptionDraft.externalCallFields = { event_description: "draft ticket" };
+    await getTicketsCollection().insertMany([
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-transferred",
+        createdAt: at("2026-05-11T14:00:00.000Z"),
+        updatedAt: at("2026-05-11T14:00:00.000Z"),
+        externalCallFields: { event_subject_id: "100" },
+      }),
+      descriptionDraft,
+      createTicket({
+        cityName: CITY,
+        callSid: "CA-whitespace-draft",
+        createdAt: at("2026-05-12T10:00:00.000Z"),
+        updatedAt: at("2026-05-12T10:00:00.000Z"),
+        externalCallFields: { event_subject_id: "   " },
+      }),
+    ]);
+
+    const statsFilter = filter();
+    const dateScope = ticketDateScope(statsFilter);
+    const callSidDraftTicketCounts = await findCallSidDraftTicketCountsByCity(CITY, dateScope);
+    const summary = await summaryWithTicketSids();
+
+    expect([...callSidDraftTicketCounts.keys()].sort()).toEqual(["CA-hijacked", "CA-whitespace-draft"].sort());
+    expect(summary).toMatchObject({ openTickets: 4, draftTickets: 1 });
+  });
+});