diff --git a/.cspell.json b/.cspell.json
index 9deeb59..8c1387e 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -4,7 +4,22 @@
   "ignorePaths": ["**/*.json", "**/*.css", "node_modules", "**/*.log", "**/*.http", "**/*.toml", "src/types/database.ts", "supabase/migrations/**", "tests/**"],
   "useGitignore": true,
   "language": "en",
-  "words": ["dataurl", "devpool", "outdir", "servedir", "typebox", "supabase", "ubiquibot", "mswjs", "luxon", "millis", "handl"],
+  "words": [
+    "dataurl",
+    "devpool",
+    "outdir",
+    "servedir",
+    "typebox",
+    "supabase",
+    "ubiquibot",
+    "mswjs",
+    "luxon",
+    "millis",
+    "handl",
+    "sonarjs",
+    "mischeck",
+    "unassigns"
+  ],
   "dictionaries": ["typescript", "node", "software-terms"],
   "import": ["@cspell/dict-typescript/cspell-ext.json", "@cspell/dict-node/cspell-ext.json", "@cspell/dict-software-terms"],
   "ignoreRegExpList": ["[0-9a-fA-F]{6}"]
diff --git a/README.md b/README.md
index 3070da2..7045e1a 100644
--- a/README.md
+++ b/README.md
@@ -43,4 +43,9 @@ yarn test
       optOut:
         - "repoName"
         - "repoName2"
+    eventWhitelist: # these are the tail of the webhook event i.e pull_request.review_requested
+      - "review_requested"
+      - "ready_for_review"
+      - "commented"
+      - "committed"
 ```
diff --git a/src/helpers/get-assignee-activity.ts b/src/helpers/get-assignee-activity.ts
index a8371b3..14dcd34 100644
--- a/src/helpers/get-assignee-activity.ts
+++ b/src/helpers/get-assignee-activity.ts
@@ -2,14 +2,14 @@ import { DateTime } from "luxon";
 import { collectLinkedPullRequests } from "../handlers/collect-linked-pulls";
 import { Context } from "../types/context";
 import { parseIssueUrl } from "./github-url";
-import { GitHubListEvents, ListIssueForRepo } from "../types/github-types";
+import { GitHubTimelineEvents, ListIssueForRepo } from "../types/github-types";
 
 /**
  * Retrieves all the activity for users that are assigned to the issue. Also takes into account linked pull requests.
  */
 export async function getAssigneesActivityForIssue(context: Context, issue: ListIssueForRepo, assigneeIds: number[]) {
   const gitHubUrl = parseIssueUrl(issue.html_url);
-  const issueEvents: GitHubListEvents[] = await context.octokit.paginate(context.octokit.rest.issues.listEvents, {
+  const issueEvents: GitHubTimelineEvents[] = await context.octokit.paginate(context.octokit.rest.issues.listEventsForTimeline, {
     owner: gitHubUrl.owner,
     repo: gitHubUrl.repo,
     issue_number: gitHubUrl.issue_number,
@@ -18,7 +18,7 @@ export async function getAssigneesActivityForIssue(context: Context, issue: List
   const linkedPullRequests = await collectLinkedPullRequests(context, gitHubUrl);
   for (const linkedPullRequest of linkedPullRequests) {
     const { owner, repo, issue_number } = parseIssueUrl(linkedPullRequest.url || "");
-    const events = await context.octokit.paginate(context.octokit.rest.issues.listEvents, {
+    const events: GitHubTimelineEvents[] = await context.octokit.paginate(context.octokit.rest.issues.listEventsForTimeline, {
       owner,
       repo,
       issue_number,
@@ -27,7 +27,53 @@ export async function getAssigneesActivityForIssue(context: Context, issue: List
     issueEvents.push(...events);
   }
 
-  return issueEvents
-    .filter((o) => o.actor && o.actor.id && assigneeIds.includes(o.actor.id))
-    .sort((a, b) => DateTime.fromISO(b.created_at).toMillis() - DateTime.fromISO(a.created_at).toMillis());
+  return filterEvents(issueEvents, assigneeIds);
+}
+
+function filterEvents(issueEvents: GitHubTimelineEvents[], assigneeIds: number[]) {
+  const userIdMap = new Map<string, number>();
+
+  let assigneeEvents = [];
+
+  for (const event of issueEvents) {
+    let actorId = null;
+    let actorLogin = null;
+    let createdAt = null;
+    let eventName = event.event;
+
+    if ("actor" in event && event.actor) {
+      actorLogin = event.actor.login.toLowerCase();
+      if (!userIdMap.has(actorLogin)) {
+        userIdMap.set(actorLogin, event.actor.id);
+      }
+      actorId = userIdMap.get(actorLogin);
+      createdAt = event.created_at;
+    } else if (event.event === "committed") {
+      const commitAuthor = "author" in event ? event.author : null;
+      const commitCommitter = "committer" in event ? event.committer : null;
+
+      if (commitAuthor || commitCommitter) {
+        assigneeEvents.push({
+          event: eventName,
+          created_at: createdAt,
+        });
+
+        continue;
+      }
+    }
+
+    if (actorId && assigneeIds.includes(actorId)) {
+      assigneeEvents.push({
+        event: eventName,
+        created_at: createdAt,
+      });
+    }
+  }
+
+  return assigneeEvents.sort((a, b) => {
+    if (!a.created_at || !b.created_at) {
+      return 0;
+    }
+    return DateTime.fromISO(b.created_at).toMillis() - DateTime.fromISO(a.created_at).toMillis();
+  });
 }
diff --git a/src/helpers/task-deadline.ts b/src/helpers/task-deadline.ts
index 5c2b1d8..7a01c9e 100644
--- a/src/helpers/task-deadline.ts
+++ b/src/helpers/task-deadline.ts
@@ -2,17 +2,29 @@ import { DateTime } from "luxon";
 import { Context } from "../types/context";
 import { ListIssueForRepo } from "../types/github-types";
 import { getAssigneesActivityForIssue } from "./get-assignee-activity";
+import { TimelineEvents } from "../types/plugin-inputs";
 
+/**
+ * Retrieves the deadline with the threshold for the issue.
+ *
+ * Uses `startPlusLabelDuration` to set a base deadline and then checks for any activity that has happened after that.
+ *
+ * If activity if detected after the deadline, it will adjust the `deadlineWithThreshold` to the most recent activity.
+ *
+ * Recent activity is determined by the `eventWhitelist`.
+ */
 export async function getDeadlineWithThreshold(
   context: Context,
   metadata: {
-    taskDeadline: string;
+    startPlusLabelDuration: string | null;
     taskAssignees: number[] | undefined;
   },
-  issue: ListIssueForRepo,
-  lastCheck: DateTime
+  issue: ListIssueForRepo
 ) {
-  const { logger, config } = context;
+  const {
+    logger,
+    config: { disqualification, warning, eventWhitelist },
+  } = context;
 
   const assigneeIds = issue.assignees?.map((o) => o.id) || [];
 
@@ -23,26 +35,43 @@ export async function getDeadlineWithThreshold(
     });
   }
 
-  const deadline = DateTime.fromISO(metadata.taskDeadline);
-  const now = DateTime.now();
-
-  if (!deadline.isValid && !lastCheck.isValid) {
-    logger.error(`Invalid date found on ${issue.html_url}`);
+  const deadline = DateTime.fromISO(metadata.startPlusLabelDuration || issue.created_at);
+  if (!deadline.isValid) {
+    logger.error(`Invalid deadline date found on ${issue.html_url}`);
     return false;
   }
 
+  // activity which has happened after either: A) issue start + time label duration or B) just issue creation date
   const activity = (await getAssigneesActivityForIssue(context, issue, assigneeIds)).filter((o) => {
-    return DateTime.fromISO(o.created_at) > lastCheck;
+    if (!o.created_at) {
+      return false;
+    }
+    return DateTime.fromISO(o.created_at) >= deadline;
+  });
+
+  const filteredActivity = activity.filter((o) => {
+    if (!o.event) {
+      return false;
+    }
+    return eventWhitelist.includes(o.event as TimelineEvents);
   });
 
-  let deadlineWithThreshold = deadline.plus({ milliseconds: config.disqualification });
-  let reminderWithThreshold = deadline.plus({ milliseconds: config.warning });
+  // adding the buffer onto the already established issueStart + timeLabelDuration
+  let deadlineWithThreshold = deadline.plus({ milliseconds: disqualification });
+  let reminderWithThreshold = deadline.plus({ milliseconds: warning });
 
-  if (activity?.length) {
-    const lastActivity = DateTime.fromISO(activity[0].created_at);
-    deadlineWithThreshold = lastActivity.plus({ milliseconds: config.disqualification });
-    reminderWithThreshold = lastActivity.plus({ milliseconds: config.warning });
+  // if there is any activity that has happened after the deadline, we need to adjust the deadlineWithThreshold
+  if (filteredActivity?.length) {
+    // use the most recent activity or the intial deadline
+    const lastActivity = filteredActivity[0].created_at ? DateTime.fromISO(filteredActivity[0].created_at) : deadline;
+    if (!lastActivity.isValid) {
+      logger.error(`Invalid date found on last activity for ${issue.html_url}`);
+      return false;
+    }
+    // take the last activity and add the buffer onto it
+    deadlineWithThreshold = lastActivity.plus({ milliseconds: disqualification });
+    reminderWithThreshold = lastActivity.plus({ milliseconds: warning });
   }
 
-  return { deadlineWithThreshold, reminderWithThreshold, now };
+  return { deadlineWithThreshold, reminderWithThreshold };
 }
diff --git a/src/helpers/task-metadata.ts b/src/helpers/task-metadata.ts
index c226214..254c199 100644
--- a/src/helpers/task-metadata.ts
+++ b/src/helpers/task-metadata.ts
@@ -1,64 +1,45 @@
 import { DateTime } from "luxon";
 import { Context } from "../types/context";
-import { ListCommentsForIssue, ListForOrg, ListIssueForRepo } from "../types/github-types";
+import { ListForOrg, ListIssueForRepo } from "../types/github-types";
 import ms from "ms";
 
-export async function getTaskMetadata(
+/**
+ * Retrieves assignment events from the timeline of an issue and calculates the deadline based on the time label.
+ *
+ * It does not care about previous updates, comments or other events that might have happened on the issue.
+ *
+ * It returns who is assigned and the initial calculated deadline (start + time label duration).
+ */
+export async function getTaskAssignmentDetails(
   context: Context,
   repo: ListForOrg["data"][0],
   issue: ListIssueForRepo
-): Promise<{ metadata: { taskDeadline: string; taskAssignees: number[] }; lastCheck: DateTime } | false> {
+): Promise<{ startPlusLabelDuration: string; taskAssignees: number[] } | false> {
   const { logger, octokit } = context;
 
-  const comments = (await octokit.paginate(octokit.rest.issues.listComments, {
+  const assignmentEvents = await octokit.paginate(octokit.rest.issues.listEvents, {
     owner: repo.owner.login,
     repo: repo.name,
     issue_number: issue.number,
-    per_page: 100,
-  })) as ListCommentsForIssue[];
-
-  const botComments = comments.filter((o) => o.user?.type === "Bot");
-  // Has the bot assigned them, typically via the `/start` command
-  const assignmentRegex = /Ubiquity - Assignment - start -/gi;
-  const botAssignmentComments = botComments
-    .filter((o) => assignmentRegex.test(o?.body || ""))
-    .sort((a, b) => DateTime.fromISO(a.created_at).toMillis() - DateTime.fromISO(b.created_at).toMillis());
-
-  // Has the bot previously reminded them?
-  const botFollowup = /<!-- Ubiquity - Followup - remindAssignees/gi;
-  const botFollowupComments = botComments
-    .filter((o) => botFollowup.test(o?.body || ""))
-    .sort((a, b) => DateTime.fromISO(a.created_at).toMillis() - DateTime.fromISO(b.created_at).toMillis());
-
-  // `lastCheck` represents the last time the bot intervened in the issue, separate from the activity tracking of a user.
-  const lastCheckComment = botFollowupComments[0]?.created_at ? botFollowupComments[0] : botAssignmentComments[0];
-  let lastCheck = lastCheckComment?.created_at ? DateTime.fromISO(lastCheckComment.created_at) : null;
-
-  // if we don't have a lastCheck yet, use the assignment event
-  if (!lastCheck) {
-    logger.info("No last check found, using assignment event");
-    const assignmentEvents = await octokit.paginate(octokit.rest.issues.listEvents, {
-      owner: repo.owner.login,
-      repo: repo.name,
-      issue_number: issue.number,
-    });
-
-    const assignmentEvent = assignmentEvents.find((o) => o.event === "assigned");
-    if (assignmentEvent) {
-      lastCheck = DateTime.fromISO(assignmentEvent.created_at);
-    } else {
-      logger.error(`Failed to find last check for ${issue.html_url}`);
-      return false;
-    }
-  }
+  });
 
-  if (!lastCheck) {
-    logger.error(`Failed to find last check for ${issue.html_url}`);
-    return false;
+  const assignedEvents = assignmentEvents
+    .filter((o) => o.event === "assigned")
+    .sort((a, b) => DateTime.fromISO(b.created_at).toMillis() - DateTime.fromISO(a.created_at).toMillis());
+
+  const latestUserAssignment = assignedEvents.find((o) => o.actor?.type === "User");
+  const latestBotAssignment = assignedEvents.find((o) => o.actor?.type === "Bot");
+
+  let mostRecentAssignmentEvent = latestUserAssignment || latestBotAssignment;
+
+  if (latestUserAssignment && latestBotAssignment && DateTime.fromISO(latestUserAssignment.created_at) > DateTime.fromISO(latestBotAssignment.created_at)) {
+    mostRecentAssignmentEvent = latestUserAssignment;
+  } else {
+    mostRecentAssignmentEvent = latestBotAssignment;
   }
 
   const metadata = {
-    taskDeadline: "",
+    startPlusLabelDuration: DateTime.fromISO(issue.created_at).toISO() || "",
     taskAssignees: issue.assignees ? issue.assignees.map((o) => o.id) : issue.assignee ? [issue.assignee.id] : [],
   };
 
@@ -77,9 +58,13 @@ export async function getTaskMetadata(
     return false;
   }
 
-  metadata.taskDeadline = DateTime.fromMillis(lastCheck.toMillis() + durationInMs).toISO() || "";
+  // if there are no assignment events, we can assume the deadline is the issue creation date
+  metadata.startPlusLabelDuration =
+    DateTime.fromISO(mostRecentAssignmentEvent?.created_at || issue.created_at)
+      .plus({ milliseconds: durationInMs })
+      .toISO() || "";
 
-  return { metadata, lastCheck };
+  return metadata;
 }
 
 function parseTimeLabel(
diff --git a/src/helpers/task-update.ts b/src/helpers/task-update.ts
index 58348bf..1f4a65c 100644
--- a/src/helpers/task-update.ts
+++ b/src/helpers/task-update.ts
@@ -3,42 +3,43 @@ import { Context } from "../types/context";
 import { ListForOrg, ListIssueForRepo } from "../types/github-types";
 import { remindAssigneesForIssue, unassignUserFromIssue } from "./remind-and-remove";
 import { getDeadlineWithThreshold } from "./task-deadline";
-import { getTaskMetadata } from "./task-metadata";
+import { getTaskAssignmentDetails } from "./task-metadata";
 
 export async function updateTaskReminder(context: Context, repo: ListForOrg["data"][0], issue: ListIssueForRepo) {
   const { logger } = context;
 
-  let metadata, lastCheck, deadlineWithThreshold, reminderWithThreshold, now;
+  let deadlineWithThreshold, reminderWithThreshold;
+  const now = DateTime.now();
 
-  const handledMetadata = await getTaskMetadata(context, repo, issue);
+  const handledMetadata = await getTaskAssignmentDetails(context, repo, issue);
 
   if (handledMetadata) {
-    metadata = handledMetadata.metadata;
-    lastCheck = handledMetadata.lastCheck;
-
-    const handledDeadline = await getDeadlineWithThreshold(context, metadata, issue, lastCheck);
+    const handledDeadline = await getDeadlineWithThreshold(context, handledMetadata, issue);
     if (handledDeadline) {
       deadlineWithThreshold = handledDeadline.deadlineWithThreshold;
       reminderWithThreshold = handledDeadline.reminderWithThreshold;
-      now = handledDeadline.now;
+
+      logger.info(`Handling metadata and deadline for ${issue.html_url}`, {
+        initialDeadline: DateTime.fromISO(handledMetadata.startPlusLabelDuration).toLocaleString(DateTime.DATETIME_MED),
+        now: now.toLocaleString(DateTime.DATETIME_MED),
+        reminderWithThreshold: reminderWithThreshold.toLocaleString(DateTime.DATETIME_MED),
+        deadlineWithThreshold: deadlineWithThreshold.toLocaleString(DateTime.DATETIME_MED),
+      });
     }
   }
 
-  if (!metadata || !lastCheck || !deadlineWithThreshold || !reminderWithThreshold || !now) {
+  if (!deadlineWithThreshold || !reminderWithThreshold) {
     logger.error(`Failed to handle metadata or deadline for ${issue.html_url}`);
     return false;
   }
 
   if (now >= deadlineWithThreshold) {
+    // if the issue is past due, we should unassign the user
     await unassignUserFromIssue(context, issue);
   } else if (now >= reminderWithThreshold) {
+    // if the issue is within the reminder threshold, we should remind the assignees
     await remindAssigneesForIssue(context, issue);
   } else {
     logger.info(`Nothing to do for ${issue.html_url}, still within due-time.`);
-    logger.info(`Last check was on ${lastCheck.toISO()}`, {
-      now: now.toLocaleString(DateTime.DATETIME_MED),
-      reminder: reminderWithThreshold.toLocaleString(DateTime.DATETIME_MED),
-      deadline: deadlineWithThreshold.toLocaleString(DateTime.DATETIME_MED),
-    });
   }
 }
diff --git a/src/types/github-types.ts b/src/types/github-types.ts
index 74c9dd3..8f63432 100644
--- a/src/types/github-types.ts
+++ b/src/types/github-types.ts
@@ -2,5 +2,4 @@ import { RestEndpointMethodTypes } from "@octokit/rest";
 
 export type ListForOrg = RestEndpointMethodTypes["repos"]["listForOrg"]["response"];
 export type ListIssueForRepo = RestEndpointMethodTypes["issues"]["listForRepo"]["response"]["data"][0];
-export type ListCommentsForIssue = RestEndpointMethodTypes["issues"]["listComments"]["response"]["data"][0];
-export type GitHubListEvents = RestEndpointMethodTypes["issues"]["listEvents"]["response"]["data"][0];
+export type GitHubTimelineEvents = RestEndpointMethodTypes["issues"]["listEventsForTimeline"]["response"]["data"][0];
diff --git a/src/types/plugin-inputs.ts b/src/types/plugin-inputs.ts
index 176046b..1c78ac5 100644
--- a/src/types/plugin-inputs.ts
+++ b/src/types/plugin-inputs.ts
@@ -31,24 +31,94 @@ function thresholdType(options?: StringOptions) {
     });
 }
 
-export const userActivityWatcherSettingsSchema = T.Object({
-  /**
-   * Delay to send reminders. 0 means disabled. Any other value is counted in days, e.g. 1,5 days
-   */
-  warning: thresholdType({ default: "3.5 days" }),
-  /**
-   * By default all repositories are watched. Use this option to opt-out from watching specific repositories
-   * within your organization. The value is an array of repository names.
-   */
-  watch: T.Object({
-    optOut: T.Array(T.String()),
-  }),
-  /**
-   * Delay to unassign users. 0 means disabled. Any other value is counted in days, e.g. 7 days
-   */
-  disqualification: thresholdType({
-    default: "7 days",
-  }),
-});
+const eventWhitelist = [
+  "pull_request.review_requested",
+  "pull_request.ready_for_review",
+  "pull_request_review_comment.created",
+  "issue_comment.created",
+  "push",
+];
+
+type WhitelistEvents =
+  | "push"
+  | "pull_request.review_requested"
+  | "pull_request.ready_for_review"
+  | "pull_request_review_comment.created"
+  | "issue_comment.created";
+
+export type TimelineEvents = "review_requested" | "ready_for_review" | "commented" | "committed";
+
+function mapWebhookToEvent(webhook: WhitelistEvents) {
+  const roleMap: Map<WhitelistEvents, TimelineEvents> = new Map([
+    ["pull_request.review_requested", "review_requested"],
+    ["pull_request.ready_for_review", "ready_for_review"],
+    ["pull_request_review_comment.created", "commented"],
+    ["issue_comment.created", "commented"],
+    ["push", "committed"],
+  ]);
+
+  return roleMap.get(webhook);
+}
+
+export const userActivityWatcherSettingsSchema = T.Object(
+  {
+    /**
+     * Delay to send reminders. 0 means disabled. Any other value is counted in days, e.g. 1,5 days
+     */
+    warning: thresholdType({ default: "3.5 days" }),
+    /**
+     * By default all repositories are watched. Use this option to opt-out from watching specific repositories
+     * within your organization. The value is an array of repository names.
+     */
+    watch: T.Object({
+      optOut: T.Array(T.String()),
+    }),
+    /**
+     * Delay to unassign users. 0 means disabled. Any other value is counted in days, e.g. 7 days
+     */
+    disqualification: thresholdType({
+      default: "7 days",
+    }),
+    /**
+     * List of events to consider as valid activity on a task
+     */
+    eventWhitelist: T.Transform(T.Array(T.String(), { default: eventWhitelist }))
+      .Decode((value) => {
+        const validEvents = Object.values(eventWhitelist);
+        let eventsStripped: TimelineEvents[] = [];
+        for (const event of value) {
+          if (!validEvents.includes(event)) {
+            throw new TypeBoxError(`Invalid event [${event}]`);
+          }
+
+          const mappedEvent = mapWebhookToEvent(event as WhitelistEvents);
+
+          if (!mappedEvent) {
+            throw new TypeBoxError(`Invalid event [${event}]`);
+          }
+
+          if (!eventsStripped.includes(mappedEvent)) {
+            eventsStripped.push(mappedEvent);
+          }
+        }
+
+        return eventsStripped as TimelineEvents[];
+      })
+      .Encode((value) =>
+        value.map((event) => {
+          const roleMap: Map<TimelineEvents, WhitelistEvents> = new Map([
+            ["review_requested", "pull_request.review_requested"],
+            ["ready_for_review", "pull_request.ready_for_review"],
+            ["commented", "pull_request_review_comment.created"],
+            ["commented", "issue_comment.created"],
+            ["committed", "push"],
+          ]);
+
+          return roleMap.get(event as TimelineEvents) as WhitelistEvents;
+        })
+      ),
+  },
+  { default: {} }
+);
 
 export type UserActivityWatcherSettings = StaticDecode<typeof userActivityWatcherSettingsSchema>;
diff --git a/tests/__mocks__/helpers.ts b/tests/__mocks__/helpers.ts
index fc3e8ab..a18bfee 100644
--- a/tests/__mocks__/helpers.ts
+++ b/tests/__mocks__/helpers.ts
@@ -41,14 +41,13 @@ export function createIssue(id: number, assignees: { login: string; id: number }
   });
 }
 
-export function createEvent() {
+export function createEvent(id: number, created_at = new Date(Date.now() - ONE_DAY).toISOString()) {
   db.event.create({
-    id: 1,
+    id,
     actor: {
       id: 1,
       type: "User",
       login: "ubiquity",
-      name: null,
     },
     owner: "ubiquity",
     repo: "test-repo",
@@ -56,7 +55,7 @@ export function createEvent() {
     event: "assigned",
     commit_id: null,
     commit_url: "https://github.com/ubiquity/test-repo/commit/1",
-    created_at: new Date(Date.now() - ONE_DAY).toISOString(),
+    created_at,
     assignee: {
       login: "ubiquity",
     },
diff --git a/tests/__mocks__/mock-users.ts b/tests/__mocks__/mock-users.ts
index 48497b9..fe31f7a 100644
--- a/tests/__mocks__/mock-users.ts
+++ b/tests/__mocks__/mock-users.ts
@@ -2,9 +2,16 @@ export default [
   {
     id: 1,
     login: "ubiquity",
+    type: "User",
+  },
+  {
+    id: 2,
+    login: "bot",
+    type: "Bot",
   },
   {
     id: 100000000,
     login: "user2",
+    type: "User",
   },
 ];
diff --git a/tests/__mocks__/results/valid-configuration.json b/tests/__mocks__/results/valid-configuration.json
index 65fb199..b094dc1 100644
--- a/tests/__mocks__/results/valid-configuration.json
+++ b/tests/__mocks__/results/valid-configuration.json
@@ -3,5 +3,6 @@
   "disqualification": "7 days",
   "watch": {
     "optOut": ["private-repo"]
-  }
+  },
+  "eventWhitelist": ["pull_request.review_requested", "pull_request.ready_for_review", "pull_request_review_comment.created", "issue_comment.created", "push"]
 }
diff --git a/tests/main.test.ts b/tests/main.test.ts
index 172117a..841e4d3 100644
--- a/tests/main.test.ts
+++ b/tests/main.test.ts
@@ -1,7 +1,7 @@
 import { drop } from "@mswjs/data";
 import { TransformDecodeError, Value } from "@sinclair/typebox/value";
 import { runPlugin } from "../src/run";
-import { userActivityWatcherSettingsSchema } from "../src/types/plugin-inputs";
+import { UserActivityWatcherSettings, userActivityWatcherSettingsSchema } from "../src/types/plugin-inputs";
 import { db } from "./__mocks__/db";
 import { server } from "./__mocks__/node";
 import cfg from "./__mocks__/results/valid-configuration.json";
@@ -13,6 +13,8 @@ import mockUsers from "./__mocks__/mock-users";
 import { botAssignmentComment, getIssueHtmlUrl, STRINGS } from "./__mocks__/strings";
 import { createComment, createEvent, createIssue, createRepo, ONE_DAY } from "./__mocks__/helpers";
 import { collectLinkedPullRequests } from "../src/handlers/collect-linked-pulls";
+import ms from "ms";
+import { TypeBoxError } from "@sinclair/typebox";
 
 dotenv.config();
 const octokit = jest.requireActual("@octokit/rest");
@@ -30,10 +32,27 @@ describe("User start/stop", () => {
   beforeEach(async () => {
     await setupTests();
   });
-
+  it("should throw an error if the whitelist events are incorrect", () => {
+    expect(() =>
+      Value.Decode(
+        userActivityWatcherSettingsSchema,
+        Value.Default(userActivityWatcherSettingsSchema, {
+          warning: "12 days",
+          disqualification: "2 days",
+          watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] },
+          eventWhitelist: ["review_requested", "ready_for_review", "commented", "committed"],
+        })
+      )
+    ).toThrow(TypeBoxError);
+  });
   it("Should parse thresholds", async () => {
     const settings = Value.Decode(userActivityWatcherSettingsSchema, Value.Default(userActivityWatcherSettingsSchema, cfg));
-    expect(settings).toEqual({ warning: 302400000, disqualification: 604800000, watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] } });
+    expect(settings).toEqual({
+      warning: 302400000,
+      disqualification: 604800000,
+      watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] },
+      eventWhitelist: ["review_requested", "ready_for_review", "commented", "committed"],
+    });
     expect(() =>
       Value.Decode(
         userActivityWatcherSettingsSchema,
@@ -45,45 +64,89 @@ describe("User start/stop", () => {
       )
     ).toThrow(TransformDecodeError);
   });
+  it("Should correctly transform the eventWhitelist", () => {
+    const settings = Value.Default(userActivityWatcherSettingsSchema, {
+      warning: "12 days",
+      disqualification: "2 days",
+      watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] },
+      eventWhitelist: [
+        "pull_request.review_requested",
+        "pull_request.ready_for_review",
+        "pull_request_review_comment.created",
+        "issue_comment.created",
+        "push",
+      ],
+    });
+    const decodedSettings = Value.Decode(userActivityWatcherSettingsSchema, settings);
+    expect(decodedSettings.eventWhitelist).toEqual(["review_requested", "ready_for_review", "commented", "committed"]);
+  });
+  it("Should define eventWhitelist defaults if omitted", () => {
+    const settings = Value.Default(userActivityWatcherSettingsSchema, {
+      warning: "12 days",
+      disqualification: "2 days",
+      watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] },
+    });
+    const decodedSettings = Value.Decode(userActivityWatcherSettingsSchema, settings);
+    expect(decodedSettings.eventWhitelist).toEqual(["review_requested", "ready_for_review", "commented", "committed"]);
+  });
+  it("Should define all defaults if omitted", () => {
+    const settings = Value.Default(userActivityWatcherSettingsSchema, {
+      watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] }, // has no default
+    }) as UserActivityWatcherSettings;
+
+    const decodedSettings = Value.Decode(userActivityWatcherSettingsSchema, settings);
+
+    console.log("decodedSettings", decodedSettings);
+
+    expect(decodedSettings).toEqual({
+      warning: ms("3.5 days"),
+      disqualification: ms("7 days"),
+      watch: { optOut: [STRINGS.PRIVATE_REPO_NAME] },
+      eventWhitelist: ["review_requested", "ready_for_review", "commented", "committed"],
+    });
+  });
   it("Should run", async () => {
     const context = createContext(1, 1);
     const result = await runPlugin(context);
     expect(result).toBe(true);
   });
 
-  it("Should process update for all repos except optOut", async () => {
+  it("Should process updates for all repos except optOut", async () => {
     const context = createContext(1, 1);
     const infoSpy = jest.spyOn(context.logger, "info");
-    await runPlugin(context);
+    createComment(5, 1, STRINGS.BOT, "Bot", botAssignmentComment(2, daysPriorToNow(1)), daysPriorToNow(1));
+    createEvent(2, daysPriorToNow(1));
 
-    // The logs skipped just contain the timestamp infos: "last check was on...."
+    await expect(runPlugin(context)).resolves.toBe(true);
 
-    expect(infoSpy).toHaveBeenNthCalledWith(1, STRINGS.USING_ASSIGNMENT_EVENT);
     expect(infoSpy).toHaveBeenNthCalledWith(2, `Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(4, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(5, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(7, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(8, `Nothing to do for ${getIssueHtmlUrl(3)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(10, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(11, `Nothing to do for ${getIssueHtmlUrl(4)}, still within due-time.`);
-    expect(infoSpy).not.toHaveBeenNthCalledWith(14, `Nothing to do for https://github.com/ubiquity/private-repo/issues/5, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(4, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(6, `Passed the reminder threshold on ${getIssueHtmlUrl(3)}, sending a reminder.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(7, `@user2, this task has been idle for a while. Please provide an update.\n\n`, {
+      taskAssignees: [2],
+      caller: STRINGS.LOGS_ANON_CALLER,
+    });
+    expect(infoSpy).toHaveBeenNthCalledWith(9, `Passed the deadline on ${getIssueHtmlUrl(4)} and no activity is detected, removing assignees.`);
+    expect(infoSpy).not.toHaveBeenCalledWith(expect.stringContaining(STRINGS.PRIVATE_REPO_NAME));
   });
 
   it("Should include the previously excluded repo", async () => {
     const context = createContext(1, 1, []);
     const infoSpy = jest.spyOn(context.logger, "info");
-    await runPlugin(context);
+    createComment(5, 1, STRINGS.BOT, "Bot", botAssignmentComment(2, daysPriorToNow(1)), daysPriorToNow(1));
+    createEvent(2, daysPriorToNow(1));
+
+    await expect(runPlugin(context)).resolves.toBe(true);
 
-    expect(infoSpy).toHaveBeenNthCalledWith(1, STRINGS.USING_ASSIGNMENT_EVENT);
     expect(infoSpy).toHaveBeenNthCalledWith(2, `Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(4, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(5, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(7, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(8, `Nothing to do for ${getIssueHtmlUrl(3)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(10, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(11, `Nothing to do for ${getIssueHtmlUrl(4)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(13, STRINGS.USING_ASSIGNMENT_EVENT);
-    expect(infoSpy).toHaveBeenNthCalledWith(14, `Nothing to do for https://github.com/ubiquity/private-repo/issues/5, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(4, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(6, `Passed the reminder threshold on ${getIssueHtmlUrl(3)}, sending a reminder.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(7, `@user2, this task has been idle for a while. Please provide an update.\n\n`, {
+      taskAssignees: [2],
+      caller: STRINGS.LOGS_ANON_CALLER,
+    });
+    expect(infoSpy).toHaveBeenNthCalledWith(9, `Passed the deadline on ${getIssueHtmlUrl(4)} and no activity is detected, removing assignees.`);
+    expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining(STRINGS.PRIVATE_REPO_NAME));
   });
 
   it("Should eject the user after the disqualification period", async () => {
@@ -91,33 +154,38 @@ describe("User start/stop", () => {
     const infoSpy = jest.spyOn(context.logger, "info");
 
     const timestamp = daysPriorToNow(9);
-    createComment(3, 3, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
+    createComment(3, 4, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
+    createEvent(2, timestamp);
 
     const issue = db.issue.findFirst({ where: { id: { equals: 4 } } });
     expect(issue?.assignees).toEqual([{ login: STRINGS.USER, id: 2 }]);
 
     await runPlugin(context);
 
-    expect(infoSpy).toHaveBeenNthCalledWith(1, `Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(3, `Passed the deadline on ${getIssueHtmlUrl(2)} and no activity is detected, removing assignees.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(4, `Passed the deadline on ${getIssueHtmlUrl(3)} and no activity is detected, removing assignees.`);
-
+    expect(infoSpy).toHaveBeenNthCalledWith(2, `Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(4, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(6, `Passed the reminder threshold on ${getIssueHtmlUrl(3)}, sending a reminder.`);
+    expect(infoSpy).toHaveBeenNthCalledWith(7, `@user2, this task has been idle for a while. Please provide an update.\n\n`, {
+      taskAssignees: [2],
+      caller: STRINGS.LOGS_ANON_CALLER,
+    });
+    expect(infoSpy).toHaveBeenNthCalledWith(9, `Passed the deadline on ${getIssueHtmlUrl(4)} and no activity is detected, removing assignees.`);
     const updatedIssue = db.issue.findFirst({ where: { id: { equals: 4 } } });
     expect(updatedIssue?.assignees).toEqual([]);
   });
 
   it("Should warn the user after the warning period", async () => {
-    const context = createContext(4, 2);
+    const context = createContext(3, 2);
     const timestamp = daysPriorToNow(5);
 
-    createComment(3, 3, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
+    createComment(3, 2, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
 
-    const issue = db.issue.findFirst({ where: { id: { equals: 4 } } });
+    const issue = db.issue.findFirst({ where: { id: { equals: 3 } } });
     expect(issue?.assignees).toEqual([{ login: STRINGS.USER, id: 2 }]);
 
     await runPlugin(context);
 
-    const updatedIssue = db.issue.findFirst({ where: { id: { equals: 4 } } });
+    const updatedIssue = db.issue.findFirst({ where: { id: { equals: 3 } } });
     expect(updatedIssue?.assignees).toEqual([{ login: STRINGS.USER, id: 2 }]);
 
     const comments = db.issueComments.getAll();
@@ -127,23 +195,21 @@ describe("User start/stop", () => {
   });
 
   it("Should have nothing do within the warning period", async () => {
-    const context = createContext(4, 2);
+    const context = createContext(1, 2);
     const infoSpy = jest.spyOn(context.logger, "info");
 
     const timestamp = daysPriorToNow(2);
-    createComment(3, 3, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
+    createComment(3, 1, STRINGS.BOT, "Bot", botAssignmentComment(2, timestamp), timestamp);
 
-    const issue = db.issue.findFirst({ where: { id: { equals: 4 } } });
-    expect(issue?.assignees).toEqual([{ login: STRINGS.USER, id: 2 }]);
+    const issue = db.issue.findFirst({ where: { id: { equals: 1 } } });
+    expect(issue?.assignees).toEqual([{ login: STRINGS.UBIQUITY, id: 1 }]);
 
     await runPlugin(context);
 
-    expect(infoSpy).toHaveBeenNthCalledWith(1, `Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(3, `Nothing to do for ${getIssueHtmlUrl(2)}, still within due-time.`);
-    expect(infoSpy).toHaveBeenNthCalledWith(5, `Nothing to do for ${getIssueHtmlUrl(3)}, still within due-time.`);
+    expect(infoSpy).toHaveBeenCalledWith(`Nothing to do for ${getIssueHtmlUrl(1)}, still within due-time.`);
 
-    const updatedIssue = db.issue.findFirst({ where: { id: { equals: 4 } } });
-    expect(updatedIssue?.assignees).toEqual([{ login: STRINGS.USER, id: 2 }]);
+    const updatedIssue = db.issue.findFirst({ where: { id: { equals: 1 } } });
+    expect(updatedIssue?.assignees).toEqual([{ login: STRINGS.UBIQUITY, id: 1 }]);
   });
 
   it("Should handle collecting linked PRs", async () => {
@@ -199,7 +265,7 @@ async function setupTests() {
   createComment(1, 1, STRINGS.UBIQUITY);
   createComment(2, 2, STRINGS.UBIQUITY);
 
-  createEvent();
+  createEvent(1);
 }
 
 function daysPriorToNow(days: number) {
@@ -222,6 +288,7 @@ function createContext(issueId: number, senderId: number, optOut = [STRINGS.PRIV
       disqualification: ONE_DAY * 7,
       warning: ONE_DAY * 3.5,
       watch: { optOut },
+      eventWhitelist: ["review_requested", "ready_for_review", "commented", "committed"],
     },
     octokit: new octokit.Octokit(),
     eventName: "issue_comment.created",