@oneuptime/common 11.3.28 → 11.4.0

package/Tests/Types/OnCallDutyPolicy/ScheduleShiftUtil.test.ts

@@ -0,0 +1,260 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import OneUptimeDate from "../../../Types/Date";
+import ScheduleShiftUtil, {
+  CoverageGap,
+  CurrentAndNextShift,
+  OnCallShift,
+} from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+
+/*
+ * These tests pin the pure event -> shift transformation the on-call schedule
+ * summaries depend on. They deliberately do NOT re-test LayerUtil (covered by
+ * its own exhaustive suites) — they only cover the grouping / gap / current-next
+ * logic layered on top of its output.
+ */
+
+// Build a CalendarEvent the way LayerUtil emits one: user id in `title`.
+const event: (userId: string, start: Date, end: Date) => CalendarEvent = (
+  userId: string,
+  start: Date,
+  end: Date,
+): CalendarEvent => {
+  return {
+    id: 0,
+    title: userId,
+    allDay: false,
+    start,
+    end,
+  };
+};
+
+const at: (iso: string) => Date = (iso: string): Date => {
+  return OneUptimeDate.fromString(iso);
+};
+
+/*
+ * Build an OnCallShift literal for the resolver/gap tests (coverageSeconds is
+ * irrelevant to those, so default it to the wall-clock span).
+ */
+const mkShift: (userId: string, start: Date, end: Date) => OnCallShift = (
+  userId: string,
+  start: Date,
+  end: Date,
+): OnCallShift => {
+  return {
+    userId,
+    start,
+    end,
+    coverageSeconds: OneUptimeDate.getDifferenceInSeconds(end, start),
+  };
+};
+
+describe("ScheduleShiftUtil", () => {
+  describe("groupEventsIntoShifts", () => {
+    test("returns empty array for no events", () => {
+      expect(ScheduleShiftUtil.groupEventsIntoShifts([])).toEqual([]);
+    });
+
+    test("keeps distinct users as separate shifts (24/7 rotation)", () => {
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+        event("B", at("2024-01-02T09:00:01Z"), at("2024-01-03T09:00:00Z")),
+        event("A", at("2024-01-03T09:00:01Z"), at("2024-01-04T09:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(3);
+      expect(
+        shifts.map((s: OnCallShift) => {
+          return s.userId;
+        }),
+      ).toEqual(["A", "B", "A"]);
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("merges touching same-user segments into one contiguous shift", () => {
+      // Two segments one second apart -> a single shift.
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-01T17:00:01Z"), at("2024-01-02T09:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(1);
+      expect(shifts[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("does NOT merge same-user segments across a real gap by default", () => {
+      // Daily 9-5 restriction: same user, but a 16h nightly gap between days.
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(shifts).toHaveLength(2);
+    });
+
+    test("merges same-user segments across gaps when mergeAcrossGaps=true", () => {
+      const events: Array<CalendarEvent> = [
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        event("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+        event("B", at("2024-01-03T09:00:00Z"), at("2024-01-03T17:00:00Z")),
+      ];
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events, {
+          mergeAcrossGaps: true,
+        });
+
+      expect(shifts).toHaveLength(2);
+      expect(shifts[0]!.userId).toBe("A");
+      expect(shifts[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      // Turn end is the last covered instant of that user's run.
+      expect(shifts[0]!.end).toEqual(at("2024-01-02T17:00:00Z"));
+      /*
+       * coverageSeconds is the REAL active time (two 8h days = 16h), not the
+       * ~32h wall-clock span across the overnight gap.
+       */
+      expect(shifts[0]!.coverageSeconds).toBe(16 * 3600);
+      expect(shifts[1]!.userId).toBe("B");
+    });
+
+    test("sorts unsorted input by start time and never mutates the caller array", () => {
+      const events: Array<CalendarEvent> = [
+        event("B", at("2024-01-02T09:00:00Z"), at("2024-01-03T09:00:00Z")),
+        event("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+      ];
+      const snapshot: Array<string> = events.map((e: CalendarEvent) => {
+        return e.title;
+      });
+
+      const shifts: Array<OnCallShift> =
+        ScheduleShiftUtil.groupEventsIntoShifts(events);
+
+      expect(
+        shifts.map((s: OnCallShift) => {
+          return s.userId;
+        }),
+      ).toEqual(["A", "B"]);
+      // input order preserved (we copy before sorting)
+      expect(
+        events.map((e: CalendarEvent) => {
+          return e.title;
+        }),
+      ).toEqual(snapshot);
+    });
+  });
+
+  describe("getCurrentAndNextShift", () => {
+    const shifts: Array<OnCallShift> = [
+      mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-02T09:00:00Z")),
+      mkShift("B", at("2024-01-02T09:00:00Z"), at("2024-01-03T09:00:00Z")),
+    ];
+
+    test("resolves the current and next shift when now is inside a shift", () => {
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          shifts,
+          at("2024-01-01T12:00:00Z"),
+        );
+
+      expect(result.current?.userId).toBe("A");
+      expect(result.next?.userId).toBe("B");
+    });
+
+    test("current is null inside a coverage gap but next is still found", () => {
+      const gapped: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          gapped,
+          at("2024-01-01T20:00:00Z"),
+        );
+
+      expect(result.current).toBeNull();
+      expect(result.next?.start).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("next is null when now is past the last shift", () => {
+      const result: CurrentAndNextShift =
+        ScheduleShiftUtil.getCurrentAndNextShift(
+          shifts,
+          at("2024-01-05T00:00:00Z"),
+        );
+
+      expect(result.current).toBeNull();
+      expect(result.next).toBeNull();
+    });
+  });
+
+  describe("getCoverageGaps", () => {
+    test("reports a leading gap before the first shift", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T12:00:00Z"), at("2024-01-01T18:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-01T20:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+      expect(gaps[0]!.start).toEqual(at("2024-01-01T09:00:00Z"));
+      expect(gaps[0]!.end).toEqual(at("2024-01-01T12:00:00Z"));
+    });
+
+    test("reports gaps between shifts but not trailing time after the last", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("A", at("2024-01-02T09:00:00Z"), at("2024-01-02T17:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-03T00:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+      expect(gaps[0]!.start).toEqual(at("2024-01-01T17:00:00Z"));
+      expect(gaps[0]!.end).toEqual(at("2024-01-02T09:00:00Z"));
+    });
+
+    test("treats the whole window as a gap when there are no shifts", () => {
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        [],
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-02T09:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(1);
+    });
+
+    test("ignores the one-second boundaries between touching segments", () => {
+      const shifts: Array<OnCallShift> = [
+        mkShift("A", at("2024-01-01T09:00:00Z"), at("2024-01-01T17:00:00Z")),
+        mkShift("B", at("2024-01-01T17:00:01Z"), at("2024-01-02T09:00:00Z")),
+      ];
+
+      const gaps: Array<CoverageGap> = ScheduleShiftUtil.getCoverageGaps(
+        shifts,
+        at("2024-01-01T09:00:00Z"),
+        at("2024-01-02T09:00:00Z"),
+      );
+
+      expect(gaps).toHaveLength(0);
+    });
+  });
+});

package/Types/Date.ts

@@ -286,6 +286,52 @@ export default class OneUptimeDate {
       .format(use12HourFormat ? "h:mm A" : "HH:mm");
   }
 
+  /**
+   * Format a single instant as a human-readable "weekday, month day, time"
+   * string resolved in a specific IANA timezone (e.g. "America/New_York").
+   *
+   * Used by the on-call schedule summaries to render each shift's start / end in
+   * the SAME zone the rotation engine schedules people in, with a DST-aware zone
+   * abbreviation appended so the reader is never in doubt which wall clock the
+   * time refers to. When `timezone` is omitted the instant is formatted in the
+   * viewer's local zone (matching the rest of the local-time UI).
+   */
+  public static getDateAsFormattedStringInTimezone(data: {
+    date: Date | string;
+    timezone?: string | undefined;
+    onlyShowDate?: boolean | undefined;
+    showWeekday?: boolean | undefined;
+    use12HourFormat?: boolean | undefined;
+  }): string {
+    const date: Date = this.fromString(data.date);
+    const use12HourFormat: boolean =
+      data.use12HourFormat ?? this.getUserPrefers12HourFormat();
+
+    const timePart: string = use12HourFormat ? "h:mm A" : "HH:mm";
+    const datePart: string = data.showWeekday
+      ? "ddd, MMM D, YYYY"
+      : "MMM D, YYYY";
+    const formatString: string = data.onlyShowDate
+      ? datePart
+      : `${datePart}, ${timePart}`;
+
+    if (!data.timezone) {
+      const local: moment.Moment = moment(date).local();
+      return (
+        local.format(formatString) +
+        (data.onlyShowDate ? "" : " " + this.getCurrentTimezoneString())
+      ).trim();
+    }
+
+    const zoned: moment.Moment = moment(date).tz(data.timezone);
+    return (
+      zoned.format(formatString) +
+      (data.onlyShowDate
+        ? ""
+        : " " + this.getZoneAbbrByTimezone(data.timezone as Timezone, date))
+    ).trim();
+  }
+
   /**
    * Reinterpret the wall-clock components of `date` — read in the process /
    * browser local zone — as the SAME wall-clock in `timezone`, and return that

package/Types/OnCallDutyPolicy/ScheduleShiftUtil.ts

@@ -0,0 +1,257 @@
+import CalendarEvent from "../Calendar/CalendarEvent";
+import OneUptimeDate from "../Date";
+
+/*
+ * Turns the low-level calendar events produced by LayerUtil into the
+ * human-readable "shifts" the on-call schedule summaries render — e.g.
+ * "Alice is on call from Mon 9:00 AM to Tue 9:00 AM".
+ *
+ * LayerUtil emits one CalendarEvent per contiguous coverage segment. A single
+ * rotation turn can therefore be split into several events (a daily 9-5
+ * restriction produces one event per day), and the merged multi-layer schedule
+ * interleaves events from different users/layers. These helpers collapse those
+ * raw segments back into the shifts a human thinks in, and surface the gaps
+ * where nobody is on call.
+ *
+ * Everything here is pure and timezone-agnostic: it operates on the absolute
+ * instants already resolved by LayerUtil (which itself resolves restriction
+ * wall-clock windows in the schedule's timezone). Rendering code decides which
+ * timezone to display those instants in.
+ */
+
+/*
+ * The identity of the on-call person for an event. LayerUtil stores the user id
+ * in CalendarEvent.title before the UI relabels it, so callers pass the events
+ * straight through from getEvents/getMultiLayerEvents.
+ */
+export interface OnCallShift {
+  userId: string;
+  start: Date;
+  end: Date;
+  /*
+   * Total ACTIVE on-call seconds inside this shift, i.e. the sum of the covered
+   * segments' durations. For a contiguous shift this equals end - start. For a
+   * turn merged across off-hours (mergeAcrossGaps), it is the real time on call,
+   * which is smaller than the wall-clock span — so the summary can show honest
+   * coverage ("40h across the week") instead of the misleading span ("4d 8h").
+   */
+  coverageSeconds: number;
+}
+
+export interface CoverageGap {
+  start: Date;
+  end: Date;
+}
+
+export interface CurrentAndNextShift {
+  current: OnCallShift | null;
+  next: OnCallShift | null;
+}
+
+/*
+ * Two coverage segments are considered part of the same continuous shift when
+ * the gap between them is below this threshold. LayerUtil starts each following
+ * segment exactly one second after the previous one ends, so anything within a
+ * couple of minutes is "touching"; anything larger is a genuine off-hours gap
+ * (a restriction window closing, a rotation with no fallback layer, etc.).
+ */
+const CONTIGUITY_TOLERANCE_SECONDS: number = 90;
+
+export default class ScheduleShiftUtil {
+  /*
+   * Collapse raw coverage events into shifts.
+   *
+   * - mergeAcrossGaps = false (default): only merges segments that actually
+   *   touch, so genuine off-hours gaps remain visible. This is what the "final
+   *   schedule" summary uses so it can honestly show when nobody is on call.
+   * - mergeAcrossGaps = true: merges every consecutive run of the same user
+   *   into a single turn, absorbing the within-turn off-hours gaps. This is what
+   *   the per-layer rotation summary uses so "Alice: Mon -> Fri" reads as one
+   *   rotation turn instead of five separate day rows. The turn's coverageSeconds
+   *   still reflects only the real active on-call time (e.g. 5x8h, not the full
+   *   Mon->Fri wall-clock span), and the summary shows the layer's active-hours
+   *   window as context.
+   */
+  public static groupEventsIntoShifts(
+    events: Array<CalendarEvent>,
+    options?: { mergeAcrossGaps?: boolean | undefined } | undefined,
+  ): Array<OnCallShift> {
+    if (!events || events.length === 0) {
+      return [];
+    }
+
+    const mergeAcrossGaps: boolean = Boolean(options?.mergeAcrossGaps);
+
+    // Work on a copy sorted by start time; never mutate the caller's array.
+    const sorted: Array<CalendarEvent> = [...events]
+      .filter((event: CalendarEvent) => {
+        return (
+          Boolean(event.title) && Boolean(event.start) && Boolean(event.end)
+        );
+      })
+      .sort((a: CalendarEvent, b: CalendarEvent) => {
+        if (OneUptimeDate.isBefore(a.start, b.start)) {
+          return -1;
+        }
+        if (OneUptimeDate.isAfter(a.start, b.start)) {
+          return 1;
+        }
+        return 0;
+      });
+
+    const shifts: Array<OnCallShift> = [];
+
+    for (const event of sorted) {
+      const userId: string = event.title;
+      const eventSeconds: number = OneUptimeDate.getDifferenceInSeconds(
+        event.end,
+        event.start,
+      );
+      const last: OnCallShift | undefined = shifts[shifts.length - 1];
+
+      const sameUser: boolean = Boolean(last) && last!.userId === userId;
+
+      const isContiguous: boolean =
+        Boolean(last) &&
+        OneUptimeDate.getDifferenceInSeconds(last!.end, event.start) <=
+          CONTIGUITY_TOLERANCE_SECONDS &&
+        OneUptimeDate.isOnOrBefore(last!.end, event.end);
+
+      /*
+       * Extend the previous shift when it belongs to the same user AND either we
+       * are merging whole turns, or the two segments physically touch. Only
+       * extend the end forward — never pull it backwards — so overlapping
+       * segments (possible after the multi-layer priority merge) can't shrink a
+       * shift. Accumulate each merged segment's own duration into coverageSeconds
+       * so a turn merged across off-hours reports its real active time on call.
+       */
+      if (last && sameUser && (mergeAcrossGaps || isContiguous)) {
+        if (OneUptimeDate.isAfter(event.end, last.end)) {
+          last.end = event.end;
+        }
+        last.coverageSeconds += eventSeconds;
+        continue;
+      }
+
+      shifts.push({
+        userId,
+        start: event.start,
+        end: event.end,
+        coverageSeconds: eventSeconds,
+      });
+    }
+
+    return shifts;
+  }
+
+  /*
+   * The shift that contains `now` (the person on call right now) and the first
+   * shift that starts after `now` (up next). Either can be null: `current` is
+   * null when nobody is on call at this instant (a coverage gap), and `next` is
+   * null when the computed window does not reach far enough to include another
+   * shift.
+   */
+  public static getCurrentAndNextShift(
+    shifts: Array<OnCallShift>,
+    now: Date,
+  ): CurrentAndNextShift {
+    let current: OnCallShift | null = null;
+    let next: OnCallShift | null = null;
+
+    for (const shift of shifts) {
+      const hasStarted: boolean = OneUptimeDate.isOnOrBefore(shift.start, now);
+      const hasNotEnded: boolean = OneUptimeDate.isAfter(shift.end, now);
+
+      if (hasStarted && hasNotEnded) {
+        current = shift;
+        continue;
+      }
+
+      if (OneUptimeDate.isAfter(shift.start, now)) {
+        if (!next || OneUptimeDate.isBefore(shift.start, next.start)) {
+          next = shift;
+        }
+      }
+    }
+
+    return { current, next };
+  }
+
+  /*
+   * Periods inside [windowStart, windowEnd] during which no shift provides
+   * coverage. Includes a leading gap (from windowStart until the first shift
+   * begins) and gaps between consecutive shifts. Trailing time after the last
+   * shift is intentionally NOT reported as a gap: the summary window is finite,
+   * so "nothing scheduled past the window" is an artifact of the window, not a
+   * real coverage hole.
+   *
+   * `shifts` are assumed sorted by start (as returned by groupEventsIntoShifts).
+   */
+  public static getCoverageGaps(
+    shifts: Array<OnCallShift>,
+    windowStart: Date,
+    windowEnd: Date,
+  ): Array<CoverageGap> {
+    const gaps: Array<CoverageGap> = [];
+
+    if (OneUptimeDate.isOnOrAfter(windowStart, windowEnd)) {
+      return gaps;
+    }
+
+    /*
+     * A gap only "counts" when it is longer than the contiguity tolerance, so
+     * the one-second boundaries LayerUtil leaves between segments never show up
+     * as spurious coverage holes.
+     */
+    const isRealGap: (start: Date, end: Date) => boolean = (
+      start: Date,
+      end: Date,
+    ): boolean => {
+      return (
+        OneUptimeDate.isAfter(end, start) &&
+        OneUptimeDate.getDifferenceInSeconds(end, start) >
+          CONTIGUITY_TOLERANCE_SECONDS
+      );
+    };
+
+    if (shifts.length === 0) {
+      if (isRealGap(windowStart, windowEnd)) {
+        gaps.push({ start: windowStart, end: windowEnd });
+      }
+      return gaps;
+    }
+
+    // Leading gap: nobody on call from the window start until the first shift.
+    const firstShift: OnCallShift = shifts[0]!;
+    if (
+      OneUptimeDate.isAfter(firstShift.start, windowStart) &&
+      isRealGap(windowStart, firstShift.start)
+    ) {
+      gaps.push({ start: windowStart, end: firstShift.start });
+    }
+
+    /*
+     * `coveredUntil` tracks the furthest point covered so far. Shifts can
+     * overlap (multi-layer merges), so we advance it monotonically and only
+     * record a gap when the next shift starts strictly after it.
+     */
+    let coveredUntil: Date = firstShift.end;
+
+    for (let i: number = 1; i < shifts.length; i++) {
+      const shift: OnCallShift = shifts[i]!;
+
+      if (
+        OneUptimeDate.isAfter(shift.start, coveredUntil) &&
+        isRealGap(coveredUntil, shift.start)
+      ) {
+        gaps.push({ start: coveredUntil, end: shift.start });
+      }
+
+      if (OneUptimeDate.isAfter(shift.end, coveredUntil)) {
+        coveredUntil = shift.end;
+      }
+    }
+
+    return gaps;
+  }
+}

package/UI/Components/Calendar/Calendar.tsx

@@ -21,6 +21,12 @@ export interface ComponentProps {
   id?: string | undefined;
   events: Array<CalendarEvent>;
   defaultCalendarView?: DefaultCalendarView;
+  /*
+   * Which date the calendar initially opens on. Defaults to "now". Callers that
+   * render events shifted into a display timezone pass the same-shifted "now" so
+   * the grid opens on that zone's current day rather than the browser's.
+   */
+  defaultDate?: Date | undefined;
   onRangeChange: (startAndEndTime: StartAndEndTime) => void;
 }
 
@@ -38,9 +44,9 @@ const CalendarElement: FunctionComponent<ComponentProps> = (
 ): ReactElement => {
   const { defaultDate } = useMemo(() => {
     return {
-      defaultDate: OneUptimeDate.getCurrentDate(),
+      defaultDate: props.defaultDate || OneUptimeDate.getCurrentDate(),
     };
-  }, []);
+  }, [props.defaultDate]);
 
   const eventStyleGetter: EventPropGetter<any> = (
     event: CalendarEvent,

package/UI/Components/Charts/ChartGroup/ChartGroup.tsx

@@ -38,10 +38,10 @@ export interface Chart {
   exemplarPoints?: Array<ExemplarPoint> | undefined;
   onExemplarClick?: ((exemplar: ExemplarPoint) => void) | undefined;
   /**
-   * Optional control panel rendered between the chart title and the
-   * chart body. Used by per-series-grouped metric charts to surface a
-   * search box, per-series toggles, and a "show all" escape hatch so
-   * the chart stays usable at thousands of unique label combinations.
+   * Optional control panel rendered directly below the chart body. Used by
+   * per-series-grouped metric charts to surface a search box, a sort
+   * control, per-series toggles, and a "show all" escape hatch so the chart
+   * stays usable at thousands of unique label combinations.
    */
   seriesControls?: ReactElement | undefined;
 }
@@ -308,10 +308,10 @@ const ChartGroup: FunctionComponent<ComponentProps> = (
                   {chart.description}
                 </p>
               )}
-              {chart.seriesControls ? chart.seriesControls : null}
               <div className="flex-1 flex flex-col min-h-80">
                 {getChartContent(chart, index)}
               </div>
+              {chart.seriesControls ? chart.seriesControls : null}
             </div>
           );
         })}

package/build/dist/Models/DatabaseModels/AIRun.js

@@ -47,6 +47,8 @@ let AIRun = class AIRun extends BaseModel {
         this.userId = undefined;
         this.conversation = undefined;
         this.conversationId = undefined;
+        this.triggeredByIncidentId = undefined;
+        this.triggeredByAlertId = undefined;
         this.startedAt = undefined;
         this.completedAt = undefined;
         this.lastHeartbeatAt = undefined;
@@ -286,6 +288,56 @@ __decorate([
     }),
     __metadata("design:type", ObjectID)
 ], AIRun.prototype, "conversationId", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+        ],
+        update: [],
+    }),
+    Index(),
+    TableColumn({
+        type: TableColumnType.ObjectID,
+        required: false,
+        canReadOnRelationQuery: true,
+        title: "Triggered By Incident ID",
+        description: "The incident that triggered this run (for autonomous investigations).",
+    }),
+    Column({
+        type: ColumnType.ObjectID,
+        nullable: true,
+        transformer: ObjectID.getDatabaseTransformer(),
+    }),
+    __metadata("design:type", ObjectID)
+], AIRun.prototype, "triggeredByIncidentId", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+        ],
+        update: [],
+    }),
+    Index(),
+    TableColumn({
+        type: TableColumnType.ObjectID,
+        required: false,
+        canReadOnRelationQuery: true,
+        title: "Triggered By Alert ID",
+        description: "The alert that triggered this run (for autonomous investigations).",
+    }),
+    Column({
+        type: ColumnType.ObjectID,
+        nullable: true,
+        transformer: ObjectID.getDatabaseTransformer(),
+    }),
+    __metadata("design:type", ObjectID)
+], AIRun.prototype, "triggeredByAlertId", void 0);
 __decorate([
     ColumnAccessControl({
         create: [],