diff --git a/src/api/GoalsAPI/index.ts b/src/api/GoalsAPI/index.ts
index b0cd37cae..d869fa21b 100644
--- a/src/api/GoalsAPI/index.ts
+++ b/src/api/GoalsAPI/index.ts
@@ -6,6 +6,8 @@ import { getInstallId } from "@src/utils";
 import { IHintRequestBody } from "@src/models/HintItem";
 import { sortGoalsByProps } from "../GCustomAPI";
 import { deleteAvailableGoalHint, deleteHintItem, getGoalHintItem } from "../HintsAPI";
+import { deleteTasksDoneTodayByGoalId } from "../TasksDoneTodayAPI";
+import { deleteTaskHistoryItem } from "../TaskHistoryAPI";
 
 export const addDeletedGoal = async (goal: GoalItem) => {
   await db
@@ -173,6 +175,8 @@ export const removeChildrenGoals = async (parentGoalId: string) => {
   childrenGoals.forEach((goal) => {
     removeChildrenGoals(goal.id);
     removeGoal(goal);
+    deleteTasksDoneTodayByGoalId(goal.id);
+    deleteTaskHistoryItem(goal.id);
   });
 };
 
@@ -315,6 +319,8 @@ export const notifyNewColabRequest = async (id: string, relId: string) => {
 export const removeGoalWithChildrens = async (goal: GoalItem) => {
   await removeChildrenGoals(goal.id);
   await removeGoal(goal);
+  await deleteTasksDoneTodayByGoalId(goal.id);
+  await deleteTaskHistoryItem(goal.id);
   if (goal.parentGoalId !== "root") {
     getGoal(goal.parentGoalId).then(async (parentGoal: GoalItem) => {
       const parentGoalSublist = parentGoal.sublist;
diff --git a/src/api/DumpboxAPI/index.ts b/src/api/SchedulerOutputCache/index.ts
similarity index 51%
rename from src/api/DumpboxAPI/index.ts
rename to src/api/SchedulerOutputCache/index.ts
index 07f0a0a8d..a0ff76c10 100644
--- a/src/api/DumpboxAPI/index.ts
+++ b/src/api/SchedulerOutputCache/index.ts
@@ -1,22 +1,22 @@
 /* eslint-disable no-param-reassign */
 import { db } from "@models";
-import { DumpboxItem } from "@src/models/DumpboxItem";
+import { SchedulerOutputCacheItem } from "@src/models/SchedulerOutputCacheItem";
 import { v4 as uuidv4 } from "uuid";
 
-export const getFromOutbox = async (key: string) => {
+export const getSchedulerCachedRes = async (key: string) => {
   try {
-    const dumpbox = await db.dumpboxCollection.where("key").equals(key).toArray();
-    return dumpbox[0];
+    const schedulerOutputCache = await db.schedulerOutputCacheCollection.where("key").equals(key).toArray();
+    return schedulerOutputCache[0];
   } catch (err) {
     return null;
   }
 };
 
-export const addSchedulerRes = async (uniqueId: string, output: string) => {
+export const addSchedulerResToCache = async (uniqueId: string, output: string) => {
   let newId;
   await db
-    .transaction("rw", db.dumpboxCollection, async () => {
-      newId = await db.dumpboxCollection.add({
+    .transaction("rw", db.schedulerOutputCacheCollection, async () => {
+      newId = await db.schedulerOutputCacheCollection.add({
         key: "scheduler",
         value: JSON.stringify({
           uniqueId,
@@ -32,11 +32,11 @@ export const addSchedulerRes = async (uniqueId: string, output: string) => {
 };
 
 export const updateSchedulerCachedRes = async (uniqueId: string, output: string) => {
-  db.transaction("rw", db.dumpboxCollection, async () => {
-    await db.dumpboxCollection
+  db.transaction("rw", db.schedulerOutputCacheCollection, async () => {
+    await db.schedulerOutputCacheCollection
       .where("key")
       .equals("scheduler")
-      .modify((obj: DumpboxItem) => {
+      .modify((obj: SchedulerOutputCacheItem) => {
         obj.value = JSON.stringify({
           uniqueId,
           output,
diff --git a/src/api/TaskHistoryAPI/index.ts b/src/api/TaskHistoryAPI/index.ts
new file mode 100644
index 000000000..ebb5efe34
--- /dev/null
+++ b/src/api/TaskHistoryAPI/index.ts
@@ -0,0 +1,22 @@
+import { db } from "@src/models";
+import { TaskHistoryEvents, TaskHistoryItem } from "@src/models/TaskHistoryItem";
+import { ITask } from "@src/Interfaces/Task";
+
+export async function addTaskActionEvent(task: ITask, eventType: TaskHistoryEvents) {
+  if (!task) return;
+
+  const newEvent: TaskHistoryItem = {
+    goalId: task.goalid,
+    eventType,
+    duration: task.duration,
+    scheduledStart: task.start,
+    scheduledEnd: task.deadline,
+    eventTime: new Date().toISOString(),
+  };
+
+  await db.taskHistoryCollection.add(newEvent);
+}
+
+export async function deleteTaskHistoryItem(goalId: string) {
+  await db.taskHistoryCollection.where("goalId").equals(goalId).delete();
+}
diff --git a/src/api/TasksAPI/index.ts b/src/api/TasksAPI/index.ts
index a041cde00..9345bc46f 100644
--- a/src/api/TasksAPI/index.ts
+++ b/src/api/TasksAPI/index.ts
@@ -4,7 +4,6 @@ import { blockedSlotOfTask, TaskItem } from "@src/models/TaskItem";
 import { GoalItem } from "@src/models/GoalItem";
 import { calDays, convertDateToString, getLastDayDate } from "@src/utils";
 import { convertDateToDay } from "@src/utils/SchedulerUtils";
-import { ITask } from "@src/Interfaces/Task";
 import { ISchedulerInputGoal } from "@src/Interfaces/IScheduler";
 import { getGoal } from "../GoalsAPI";
 
@@ -106,45 +105,6 @@ export const refreshTaskCollection = async () => {
     console.error("Error updating field:", error);
   }
 };
-export const completeTask = async (id: string, duration: number, task: ITask) => {
-  db.transaction("rw", db.taskCollection, async () => {
-    await db.taskCollection
-      .where("id")
-      .equals(id)
-      .modify((obj: TaskItem) => {
-        obj.completedToday += duration;
-        obj.completedTodayTimings.push({
-          goalid: task.goalid,
-          start: task.start,
-          deadline: task.deadline,
-        });
-        obj.completedTodayIds.push(task.taskid);
-      });
-  }).catch((e) => {
-    console.log(e.stack || e);
-  });
-};
-
-export const skipTask = async (id: string, period: string, task: ITask) => {
-  db.transaction("rw", db.taskCollection, async () => {
-    await db.taskCollection
-      .where("id")
-      .equals(id)
-      .modify((obj: TaskItem) => {
-        obj.skippedToday.push(period);
-        obj.completedTodayTimings.push({
-          goalid: task.goalid,
-          start: task.start,
-          deadline: task.deadline,
-        });
-        if (obj.skippedToday.length > 1) {
-          obj.skippedToday.sort((a, b) => Number(a.split("-")[0]) - Number(b.split("-")[0]));
-        }
-      });
-  }).catch((e) => {
-    console.log(e.stack || e);
-  });
-};
 
 export const getAllTasks = async () => {
   const allGoals = await db.taskCollection.toArray();
diff --git a/src/api/TasksDoneTodayAPI/index.ts b/src/api/TasksDoneTodayAPI/index.ts
new file mode 100644
index 000000000..8d5562ed5
--- /dev/null
+++ b/src/api/TasksDoneTodayAPI/index.ts
@@ -0,0 +1,44 @@
+import { db } from "@src/models";
+import { TasksDoneTodayItem } from "@src/models/TasksDoneTodayItem";
+
+export const addTaskDoneToday = async (completedTask: TasksDoneTodayItem) => {
+  try {
+    await db.tasksDoneTodayCollection.add(completedTask);
+  } catch (error) {
+    console.error("Error adding task:", error);
+  }
+};
+
+export const getAllTasksDoneToday = async () => {
+  try {
+    const tasks = await db.tasksDoneTodayCollection.toArray();
+    return tasks;
+  } catch (error) {
+    console.error("Error fetching tasks:", error);
+    return [];
+  }
+};
+
+export const deleteTaskDoneToday = async (id: string) => {
+  try {
+    await db.tasksDoneTodayCollection.delete(id);
+  } catch (error) {
+    console.error("Error deleting task:", error);
+  }
+};
+
+export const deleteTasksDoneTodayByGoalId = async (goalId: string) => {
+  try {
+    await db.tasksDoneTodayCollection.where("goalId").equals(goalId).delete();
+  } catch (error) {
+    console.error("Error deleting tasks by goalId:", error);
+  }
+};
+
+export const deleteAllTasksDoneToday = async () => {
+  try {
+    await db.tasksDoneTodayCollection.clear();
+  } catch (error) {
+    console.error("Error clearing tasks:", error);
+  }
+};
diff --git a/src/components/GoalsComponents/DisplayChangesModal/DisplayChangesModal.tsx b/src/components/GoalsComponents/DisplayChangesModal/DisplayChangesModal.tsx
index 24df73de1..1b5679818 100644
--- a/src/components/GoalsComponents/DisplayChangesModal/DisplayChangesModal.tsx
+++ b/src/components/GoalsComponents/DisplayChangesModal/DisplayChangesModal.tsx
@@ -8,7 +8,7 @@ import { ITagsChanges } from "@src/Interfaces/IDisplayChangesModal";
 import { sendNewGoals } from "@src/helpers/BatchPublisher";
 import { darkModeState, lastAction } from "@src/store";
 import { getAllContacts } from "@src/api/ContactsAPI";
-import { sendUpdatedGoal } from "@src/helpers/PubSubController";
+import { sendUpdatedGoal } from "@src/controllers/PubSubController";
 import { typeOfChange, typeOfIntent } from "@src/models/InboxItem";
 import { archiveUserGoal, getGoal, removeGoalWithChildrens, updateGoal } from "@src/api/GoalsAPI";
 import { deleteGoalChangesInID, getInboxItem, removeGoalInbox, removePPTFromInboxOfGoal } from "@src/api/InboxAPI";
diff --git a/src/components/MyTimeComponents/MyTimeline/MyTimeline.tsx b/src/components/MyTimeComponents/MyTimeline/MyTimeline.tsx
index 3729a26a8..501a7da78 100644
--- a/src/components/MyTimeComponents/MyTimeline/MyTimeline.tsx
+++ b/src/components/MyTimeComponents/MyTimeline/MyTimeline.tsx
@@ -11,14 +11,16 @@ import chevronLeftIcon from "@assets/images/chevronLeft.svg";
 
 import { ITask, TaskAction } from "@src/Interfaces/Task";
 import { getGoal } from "@src/api/GoalsAPI";
-import { TaskItem } from "@src/models/TaskItem";
 import { GoalItem } from "@src/models/GoalItem";
 import { useTranslation } from "react-i18next";
 import { displayToast, focusTaskTitle } from "@src/store";
-import { addTask, completeTask, getTaskByGoalId } from "@src/api/TasksAPI";
+import { addTask, getTaskByGoalId } from "@src/api/TasksAPI";
 
 import "./index.scss";
 import { displayReschedule } from "@src/store/TaskState";
+import { TasksDoneTodayItem } from "@src/models/TasksDoneTodayItem";
+import { addTaskActionEvent } from "@src/api/TaskHistoryAPI";
+import { completeTask } from "@src/controllers/TaskDoneTodayController";
 import { GoalTiming } from "./GoalTiming";
 import { TaskOptions } from "./TaskOptions";
 import { updateImpossibleGoals } from "./updateImpossibleGoals";
@@ -27,21 +29,16 @@ type ImpossibleTaskId = string;
 
 interface MyTimelineProps {
   day: string;
-  taskDetails: { [goalid: string]: TaskItem };
-  setTaskDetails: React.Dispatch<
-    React.SetStateAction<{
-      [goalid: string]: TaskItem;
-    }>
-  >;
   myTasks: {
     scheduled: ITask[];
     impossible: ImpossibleTaskId[];
     freeHrsOfDay: number;
     scheduledHrs: number;
   };
+  doneTasks: TasksDoneTodayItem[];
 }
 
-export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, taskDetails, setTaskDetails }) => {
+export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, doneTasks }) => {
   const { t } = useTranslation();
   const navigate = useNavigate();
   const { state } = useLocation();
@@ -89,6 +86,12 @@ export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, taskDetail
     navigate("/", { state: { ...state, displayFocus: true } });
   };
 
+  const handleDoneClick = async (task: ITask) => {
+    await completeTask(task.taskid, task.goalid, task.start, task.deadline);
+    await addTaskActionEvent(task, "completed");
+    await doneSound.play();
+  };
+
   const handleActionClick = async (actionName: TaskAction, task: ITask) => {
     if (actionName === TaskAction.Goal) {
       return handleOpenGoal(task.goalid);
@@ -96,6 +99,12 @@ export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, taskDetail
     if (actionName === TaskAction.Focus) {
       return handleFocusClick(task);
     }
+    if (actionName === TaskAction.Done) {
+      return handleDoneClick(task);
+    }
+    if (actionName === TaskAction.NotNow) {
+      return setOpenReschedule({ ...task });
+    }
     if (day === "Today") {
       const taskItem = await getTaskByGoalId(task.goalid);
       if (!taskItem) {
@@ -107,40 +116,12 @@ export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, taskDetail
           title: task.title,
           completedTodayIds: [],
           skippedToday: [],
-          completedToday: actionName === TaskAction.Done ? Number(task.duration) : 0,
+          completedToday: 0,
           lastSkipped: "",
-          lastCompleted: actionName === TaskAction.Done ? new Date().toLocaleDateString() : "",
+          lastCompleted: "",
           hoursSpent: 0,
-          completedTodayTimings:
-            actionName === TaskAction.Done
-              ? [
-                  {
-                    goalid: task.goalid,
-                    start: task.start,
-                    deadline: task.deadline,
-                  },
-                ]
-              : [],
           blockedSlots: [],
         });
-      } else if (actionName === TaskAction.Done) {
-        const markDone = !!taskDetails[task.goalid]?.completedTodayIds.includes(task.taskid);
-        if (markDone) return null;
-        await completeTask(taskItem.id, Number(task.duration), task);
-      } else if (actionName === TaskAction.NotNow) {
-        setOpenReschedule(task);
-      }
-      if (actionName === TaskAction.Done) {
-        await doneSound.play();
-        const updatedTask = await getTaskByGoalId(task.goalid);
-        if (updatedTask) {
-          setTaskDetails({
-            ...taskDetails,
-            [task.goalid]: updatedTask,
-          });
-        }
-      } else if (actionName === TaskAction.NotNow) {
-        setOpenReschedule({ ...task });
       }
     } else {
       setShowToast({ open: true, message: "Let's focus on Today :)", extra: "" });
@@ -160,9 +141,7 @@ export const MyTimeline: React.FC<MyTimelineProps> = ({ day, myTasks, taskDetail
         const nextTask = myTasks.scheduled[index + 1];
         const nextStartTime = nextTask ? nextTask.start.split("T")[1].slice(0, 2) : null;
         const displayEndTime = endTime !== nextStartTime;
-        const markDone = !!taskDetails[task.goalid]?.completedTodayTimings.find(
-          (ele) => ele.start === task.start && ele.deadline === task.deadline,
-        );
+        const markDone = doneTasks.some((doneTask) => doneTask.scheduledTaskId === task.taskid);
         const showTaskOptions = displayOptionsIndex === task.taskid;
         return (
           <button
diff --git a/src/components/MyTimeComponents/NotNow/NotNowModal.tsx b/src/components/MyTimeComponents/NotNow/NotNowModal.tsx
index b2b9b3f76..e7d0c9089 100644
--- a/src/components/MyTimeComponents/NotNow/NotNowModal.tsx
+++ b/src/components/MyTimeComponents/NotNow/NotNowModal.tsx
@@ -4,14 +4,15 @@ import React, { useEffect, useState } from "react";
 import { lastAction } from "@src/store";
 import "./NotNowModal.scss";
 import ZModal from "@src/common/ZModal";
-import { addBlockedSlot, getTaskByGoalId, skipTask } from "@src/api/TasksAPI"; // Assume getGoalById exists
+import { addBlockedSlot } from "@src/api/TasksAPI";
 import { displayReschedule } from "@src/store/TaskState";
 import { MILLISECONDS_IN_HOUR, RESCHEDULE_OPTIONS } from "@src/constants/rescheduleOptions";
 import { convertDateToString } from "@src/utils";
 import ActionDiv from "@components/GoalsComponents/MyGoalActions/ActionDiv";
 import { getGoalById } from "@src/api/GoalsAPI";
-import { getHrFromDateString } from "@src/utils/SchedulerUtils";
 import forgetTune from "@assets/forget.mp3";
+import { addTaskActionEvent } from "@src/api/TaskHistoryAPI";
+import { addTaskDoneToday } from "@src/api/TasksDoneTodayAPI";
 
 const NotNowModal = () => {
   const [task, setDisplayReschedule] = useRecoilState(displayReschedule);
@@ -36,7 +37,7 @@ const NotNowModal = () => {
 
   if (!task) return null;
 
-  const handleReschedule = (hours: number) => {
+  const handleReschedule = async (hours: number) => {
     const startTime = new Date(task.start);
     const endTime = new Date(startTime.getTime() + hours * MILLISECONDS_IN_HOUR);
     const start = convertDateToString(startTime, false);
@@ -46,6 +47,7 @@ const NotNowModal = () => {
       start,
       end,
     });
+    await addTaskActionEvent(task, "postponed");
 
     console.log(`Task rescheduled from ${start} to ${end}`);
     setDisplayReschedule(null);
@@ -53,12 +55,13 @@ const NotNowModal = () => {
   };
 
   const handleSkip = async () => {
-    const taskItem = await getTaskByGoalId(task.goalid);
-    if (!taskItem) {
-      return;
-    }
-    const period = `${getHrFromDateString(task.start)}-${getHrFromDateString(task.deadline)}`;
-    await skipTask(taskItem?.id, period, task);
+    await addTaskDoneToday({
+      scheduledTaskId: task.taskid,
+      scheduledStart: task.start,
+      scheduledEnd: task.deadline,
+      goalId: task.goalid,
+    });
+    await addTaskActionEvent(task, "skipped");
     setDisplayReschedule(null);
     setLastAction("TaskSkipped");
     forgetSound.play();
diff --git a/src/helpers/GoalController.ts b/src/controllers/GoalController.ts
similarity index 98%
rename from src/helpers/GoalController.ts
rename to src/controllers/GoalController.ts
index eca44850a..c5c9d87b6 100644
--- a/src/helpers/GoalController.ts
+++ b/src/controllers/GoalController.ts
@@ -1,5 +1,5 @@
 import { GoalItem } from "@src/models/GoalItem";
-import { getSelectedLanguage, inheritParentProps } from "@src/utils";
+import { inheritParentProps } from "@src/utils";
 import { sendUpdatesToSubscriber } from "@src/services/contact.service";
 import { getSharedWMGoal, removeSharedWMChildrenGoals, updateSharedWMGoal } from "@src/api/SharedWMAPI";
 import {
diff --git a/src/helpers/NewUserController.ts b/src/controllers/NewUserController.ts
similarity index 100%
rename from src/helpers/NewUserController.ts
rename to src/controllers/NewUserController.ts
diff --git a/src/helpers/PartnerController.ts b/src/controllers/PartnerController.ts
similarity index 95%
rename from src/helpers/PartnerController.ts
rename to src/controllers/PartnerController.ts
index 29ff5953b..ad769d96c 100644
--- a/src/helpers/PartnerController.ts
+++ b/src/controllers/PartnerController.ts
@@ -3,7 +3,7 @@ import { GoalItem, IParticipant } from "@src/models/GoalItem";
 import { sendUpdatesToSubscriber } from "@src/services/contact.service";
 import { getSelectedLanguage, inheritParentProps } from "@src/utils";
 
-import { createGoalObjectFromTags } from "./GoalProcessor";
+import { createGoalObjectFromTags } from "../helpers/GoalProcessor";
 
 const sendUpdate = (
   subscribers: IParticipant[],
diff --git a/src/helpers/PubSubController.ts b/src/controllers/PubSubController.ts
similarity index 96%
rename from src/helpers/PubSubController.ts
rename to src/controllers/PubSubController.ts
index a1c7ca09f..e8b7d9454 100644
--- a/src/helpers/PubSubController.ts
+++ b/src/controllers/PubSubController.ts
@@ -2,7 +2,7 @@
 import { sendUpdatesToSubscriber } from "@src/services/contact.service";
 import { getGoal, getParticipantsOfGoals } from "@src/api/GoalsAPI";
 import { getParticipantsOfDeletedGoal } from "@src/api/TrashAPI";
-import { getHistoryUptoGoal } from "./GoalProcessor";
+import { getHistoryUptoGoal } from "../helpers/GoalProcessor";
 
 export const sendUpdatedGoal = async (
   goalId: string,
diff --git a/src/controllers/TaskDoneTodayController.ts b/src/controllers/TaskDoneTodayController.ts
new file mode 100644
index 000000000..4940dedf0
--- /dev/null
+++ b/src/controllers/TaskDoneTodayController.ts
@@ -0,0 +1,41 @@
+import { addTaskDoneToday, deleteAllTasksDoneToday, getAllTasksDoneToday } from "@src/api/TasksDoneTodayAPI";
+
+export const completeTask = async (
+  scheduledTaskId: string,
+  goalId: string,
+  scheduledStart: string,
+  scheduledEnd: string,
+) => {
+  try {
+    await addTaskDoneToday({
+      scheduledTaskId,
+      goalId,
+      scheduledStart,
+      scheduledEnd,
+    });
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+export const checkAndCleanupDoneTodayCollection = async () => {
+  const tasks = await getAllTasksDoneToday();
+
+  if (tasks.length === 0) {
+    return;
+  }
+
+  const firstTaskScheduledStart = new Date(tasks[0].scheduledStart);
+  const today = new Date();
+  const isSameDay = (date1: Date, date2: Date): boolean => {
+    return (
+      date1.getDate() === date2.getDate() &&
+      date1.getMonth() === date2.getMonth() &&
+      date1.getFullYear() === date2.getFullYear()
+    );
+  };
+
+  if (!isSameDay(firstTaskScheduledStart, today)) {
+    await deleteAllTasksDoneToday();
+  }
+};
diff --git a/src/helpers/GoalActionHelper.tsx b/src/helpers/GoalActionHelper.tsx
index ed1ef1722..523f6518d 100644
--- a/src/helpers/GoalActionHelper.tsx
+++ b/src/helpers/GoalActionHelper.tsx
@@ -1,6 +1,6 @@
 import { GoalItem } from "@src/models/GoalItem";
 import pageCrumplingSound from "@assets/page-crumpling-sound.mp3";
-import { deleteSharedGoal, deleteGoal, archiveGoal } from "./GoalController";
+import { deleteSharedGoal, deleteGoal, archiveGoal } from "../controllers/GoalController";
 
 const pageCrumple = new Audio(pageCrumplingSound);
 
diff --git a/src/helpers/MyTimeHelper.ts b/src/helpers/MyTimeHelper.ts
index db87668eb..1a8fc1551 100644
--- a/src/helpers/MyTimeHelper.ts
+++ b/src/helpers/MyTimeHelper.ts
@@ -7,9 +7,10 @@ import {
   ISchedulerOutputGoal,
 } from "@src/Interfaces/IScheduler";
 import { ITaskOfDay } from "@src/Interfaces/Task";
-import { addSchedulerRes, getFromOutbox, updateSchedulerCachedRes } from "@src/api/DumpboxAPI";
+import { addSchedulerResToCache, getSchedulerCachedRes, updateSchedulerCachedRes } from "@src/api/SchedulerOutputCache";
 import { getAllGoals } from "@src/api/GoalsAPI";
 import { getAllTasks, getAllBlockedTasks, adjustNotOnBlocks } from "@src/api/TasksAPI";
+import { getAllTasksDoneToday } from "@src/api/TasksDoneTodayAPI";
 import { GoalItem } from "@src/models/GoalItem";
 import { TCompletedTaskTiming, TaskItem, blockedSlotOfTask } from "@src/models/TaskItem";
 import { convertDateToString } from "@src/utils";
@@ -154,9 +155,16 @@ export const organizeDataForInptPrep = async (inputGoals: GoalItem[]) => {
   const startDate = convertDateToString(new Date(_today));
   const endDate = convertDateToString(new Date(_today.setDate(_today.getDate() + 7)));
   const tasksCompletedToday: TCompletedTaskTiming[] = [];
-  getAllTasks().then((docs) =>
-    docs.filter((doc) => doc.completedToday > 0).map((doc) => tasksCompletedToday.push(...doc.completedTodayTimings)),
-  );
+
+  getAllTasksDoneToday().then((task) => {
+    task.forEach((ele) => {
+      tasksCompletedToday.push({
+        goalid: ele.goalId,
+        start: ele.scheduledStart,
+        deadline: ele.scheduledEnd,
+      });
+    });
+  });
 
   const schedulerInput: ISchedulerInput = {
     startDate,
@@ -178,7 +186,7 @@ export const organizeDataForInptPrep = async (inputGoals: GoalItem[]) => {
 };
 
 export const getCachedSchedule = async (generatedInputId: string) => {
-  const schedulerCachedRes = await getFromOutbox("scheduler");
+  const schedulerCachedRes = await getSchedulerCachedRes("scheduler");
 
   if (!schedulerCachedRes) {
     return { code: "not-exist" };
@@ -196,5 +204,5 @@ export const getCachedSchedule = async (generatedInputId: string) => {
 export const putSchedulerRes = async (code: string, generatedInputId: string, output: string) => {
   return code === "expired"
     ? updateSchedulerCachedRes(generatedInputId, output)
-    : addSchedulerRes(generatedInputId, output);
+    : addSchedulerResToCache(generatedInputId, output);
 };
diff --git a/src/hooks/useApp.tsx b/src/hooks/useApp.tsx
index 0a4f4ecda..234d2a24f 100644
--- a/src/hooks/useApp.tsx
+++ b/src/hooks/useApp.tsx
@@ -6,7 +6,7 @@ import { getTheme } from "@src/store/ThemeState";
 import { GoalItem } from "@src/models/GoalItem";
 import { checkMagicGoal, getAllLevelGoalsOfId, getGoal, updateSharedStatusOfGoal } from "@src/api/GoalsAPI";
 import { addSharedWMGoal } from "@src/api/SharedWMAPI";
-import { createDefaultGoals } from "@src/helpers/NewUserController";
+import { createDefaultGoals } from "@src/controllers/NewUserController";
 import { refreshTaskCollection } from "@src/api/TasksAPI";
 import { handleIncomingChanges } from "@src/helpers/InboxProcessor";
 import { getContactSharedGoals, shareGoalWithContact } from "@src/services/contact.service";
@@ -15,6 +15,7 @@ import { useSetRecoilState, useRecoilValue, useRecoilState } from "recoil";
 import { scheduledHintCalls } from "@src/api/HintsAPI/ScheduledHintCall";
 import { LocalStorageKeys } from "@src/constants/localStorageKeys";
 import { checkAndCleanupTrash } from "@src/api/TrashAPI";
+import { checkAndCleanupDoneTodayCollection } from "@src/controllers/TaskDoneTodayController";
 
 const langFromStorage = localStorage.getItem(LocalStorageKeys.LANGUAGE)?.slice(1, -1);
 const exceptionRoutes = ["/", "/invest", "/feedback", "/donate"];
@@ -147,6 +148,7 @@ function useApp() {
 
   useEffect(() => {
     checkAndCleanupTrash();
+    checkAndCleanupDoneTodayCollection();
   }, []);
 
   useEffect(() => {
diff --git a/src/hooks/useGoalActions.tsx b/src/hooks/useGoalActions.tsx
index 20d0925e7..da0f13a07 100644
--- a/src/hooks/useGoalActions.tsx
+++ b/src/hooks/useGoalActions.tsx
@@ -1,8 +1,8 @@
 import { getAllLevelGoalsOfId, unarchiveUserGoal, updateSharedStatusOfGoal } from "@src/api/GoalsAPI";
 import { getSharedWMGoalById } from "@src/api/SharedWMAPI";
 import { restoreUserGoal } from "@src/api/TrashAPI";
-import { createGoal, deleteGoal, deleteSharedGoal, modifyGoal } from "@src/helpers/GoalController";
-import { suggestChanges, suggestNewGoal } from "@src/helpers/PartnerController";
+import { createGoal, deleteGoal, deleteSharedGoal, modifyGoal } from "@src/controllers/GoalController";
+import { suggestChanges, suggestNewGoal } from "@src/controllers/PartnerController";
 import { GoalItem } from "@src/models/GoalItem";
 import { displayToast, lastAction, openDevMode } from "@src/store";
 
diff --git a/src/models/DumpboxItem.ts b/src/models/SchedulerOutputCacheItem.ts
similarity index 52%
rename from src/models/DumpboxItem.ts
rename to src/models/SchedulerOutputCacheItem.ts
index 2c65dd14a..adc7cb9da 100644
--- a/src/models/DumpboxItem.ts
+++ b/src/models/SchedulerOutputCacheItem.ts
@@ -1,4 +1,4 @@
-export interface DumpboxItem {
+export interface SchedulerOutputCacheItem {
   id: string;
   key: string;
   value: string;
diff --git a/src/models/TaskHistoryItem.ts b/src/models/TaskHistoryItem.ts
new file mode 100644
index 000000000..33846584d
--- /dev/null
+++ b/src/models/TaskHistoryItem.ts
@@ -0,0 +1,10 @@
+export type TaskHistoryEvents = "completed" | "postponed" | "skipped";
+
+export interface TaskHistoryItem {
+  goalId: string;
+  eventType: TaskHistoryEvents;
+  scheduledStart: string;
+  scheduledEnd: string;
+  eventTime: string;
+  duration: number;
+}
diff --git a/src/models/TaskItem.ts b/src/models/TaskItem.ts
index 5973e2b27..36db5808d 100644
--- a/src/models/TaskItem.ts
+++ b/src/models/TaskItem.ts
@@ -15,5 +15,4 @@ export interface TaskItem {
   lastCompleted: string; // date
   lastSkipped: string; // date
   blockedSlots: blockedSlotOfTask[];
-  completedTodayTimings: TCompletedTaskTiming[]; //  to store timings of the tasks that are completed today
 }
diff --git a/src/models/TasksDoneTodayItem.ts b/src/models/TasksDoneTodayItem.ts
new file mode 100644
index 000000000..a4e8c72e2
--- /dev/null
+++ b/src/models/TasksDoneTodayItem.ts
@@ -0,0 +1,6 @@
+export interface TasksDoneTodayItem {
+  scheduledTaskId: string;
+  goalId: string;
+  scheduledStart: string;
+  scheduledEnd: string;
+}
diff --git a/src/models/db.ts b/src/models/db.ts
index 6b5865a6a..f50050ef9 100644
--- a/src/models/db.ts
+++ b/src/models/db.ts
@@ -7,13 +7,15 @@ import ContactItem from "./ContactItem";
 import { InboxItem } from "./InboxItem";
 import { TaskItem } from "./TaskItem";
 import { GCustomItem } from "./GCustomItem";
-import { DumpboxItem } from "./DumpboxItem";
+import { SchedulerOutputCacheItem } from "./SchedulerOutputCacheItem";
 import { TrashItem } from "./TrashItem";
 import { HintItem } from "./HintItem";
 import { ImpossibleGoalItem } from "./ImpossibleGoalItem";
 import { dbStoreSchema, syncVersion } from "./dexie";
+import { TaskHistoryItem } from "./TaskHistoryItem";
+import { TasksDoneTodayItem } from "./TasksDoneTodayItem";
 
-export const dexieVersion = 21;
+export const dexieVersion = 22;
 
 const currentVersion = Number(localStorage.getItem(LocalStorageKeys.DEXIE_VERSION) || dexieVersion);
 localStorage.setItem(LocalStorageKeys.DEXIE_VERSION, `${dexieVersion}`);
@@ -33,7 +35,7 @@ export class ZinZenDB extends Dexie {
 
   customizationCollection!: Table<GCustomItem, number>;
 
-  dumpboxCollection!: Table<DumpboxItem, string>;
+  schedulerOutputCacheCollection!: Table<SchedulerOutputCacheItem, string>;
 
   goalTrashCollection!: Table<TrashItem, string>;
 
@@ -41,6 +43,10 @@ export class ZinZenDB extends Dexie {
 
   impossibleGoalsCollection!: Table<ImpossibleGoalItem, string>;
 
+  taskHistoryCollection!: Table<TaskHistoryItem, string>;
+
+  tasksDoneTodayCollection!: Table<TasksDoneTodayItem, string>;
+
   constructor() {
     super("ZinZenDB");
     this.version(dexieVersion)
diff --git a/src/models/dexie.ts b/src/models/dexie.ts
index 423927085..1fdfe9fbb 100644
--- a/src/models/dexie.ts
+++ b/src/models/dexie.ts
@@ -16,14 +16,17 @@ export const dbStoreSchema = {
   pubSubCollection: "id, subscribers",
   publicGroupsCollection: null,
   taskCollection:
-    "id, goalId, title, hoursSpent, completedTodayIds, completedTodayTimings, lastCompleted, lastSkipped, blockedSlots, skippedToday, completedToday",
+    "id, goalId, title, hoursSpent, completedTodayIds, lastCompleted, lastSkipped, blockedSlots, skippedToday, completedToday",
   customizationCollection: "++id, goalId, posIndex",
-  dumpboxCollection: "id, key, value",
+  dumpboxCollection: null,
   partnersCollection: null,
   goalTrashCollection:
     "id, category, deletedAt, title, duration, sublist, habit, on, start, due, afterTime, beforeTime, createdAt, parentGoalId, archived, participants, goalColor, language, link, rootGoalId, timeBudget, typeOfGoal",
   hintsCollection: "id, hintOptionEnabled, availableGoalHints, lastCheckedDate, nextCheckDate",
   impossibleGoalsCollection: "goalId, goalTitle",
+  schedulerOutputCacheCollection: "id, key, value",
+  taskHistoryCollection: "++id, goalId, eventType, eventTime, scheduledStart, scheduledEnd, duration",
+  tasksDoneTodayCollection: "++id, goalId, scheduledStart, scheduledEnd",
 };
 export const syncVersion = (transaction: Transaction, currentVersion: number) => {
   if (currentVersion < 9) {
@@ -158,8 +161,15 @@ export const syncVersion = (transaction: Transaction, currentVersion: number) =>
   if (currentVersion < 21) {
     console.log("processing updates for 20th version");
     const taskCollection = transaction.table("taskCollection");
-    taskCollection.toCollection().modify((task: TaskItem) => {
+    taskCollection.toCollection().modify((task) => {
       task.completedTodayTimings = [];
     });
   }
+  if (currentVersion < 22) {
+    console.log("processing updates for 22th version");
+    const taskCollection = transaction.table("taskCollection");
+    taskCollection.toCollection().modify((task) => {
+      delete task.completedTodayTimings;
+    });
+  }
 };
diff --git a/src/pages/MyTimePage/MyTimePage.tsx b/src/pages/MyTimePage/MyTimePage.tsx
index 7c4890f1b..d1bdd2947 100644
--- a/src/pages/MyTimePage/MyTimePage.tsx
+++ b/src/pages/MyTimePage/MyTimePage.tsx
@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React, { useEffect, useState } from "react";
 import { MyTimeline } from "@components/MyTimeComponents/MyTimeline/MyTimeline";
 import { Focus } from "@components/MyTimeComponents/Focus.tsx/Focus";
 import { getOrdinalSuffix } from "@src/utils";
@@ -16,16 +16,25 @@ import ConfigGoal from "@components/GoalsComponents/GoalConfigModal/ConfigGoal";
 import { TGoalCategory } from "@src/models/GoalItem";
 import { goalCategories } from "@src/constants/goals";
 import { createGoalObjectFromTags } from "@src/helpers/GoalProcessor";
+import { getAllTasksDoneToday } from "@src/api/TasksDoneTodayAPI";
+import { TasksDoneTodayItem } from "@src/models/TasksDoneTodayItem";
 
 export const MyTimePage = () => {
   const today = new Date();
-  const { tasks, tasksStatus, setTasksStatus } = useScheduler();
+  const { tasks } = useScheduler();
   const [showTasks, setShowTasks] = useState<string[]>(["Today"]);
+  const [doneTasks, setDoneTasks] = useState<TasksDoneTodayItem[]>([]);
   const { state } = useLocation();
   const [searchParams] = useSearchParams();
 
   const goalType = (searchParams.get("type") as TGoalCategory) || "";
 
+  useEffect(() => {
+    getAllTasksDoneToday().then((task) => {
+      setDoneTasks(task);
+    });
+  });
+
   const handleShowTasks = (dayName: string) => {
     if (showTasks.includes(dayName)) {
       setShowTasks([...showTasks.filter((day: string) => day !== dayName)]);
@@ -72,7 +81,7 @@ export const MyTimePage = () => {
         </button>
         <div style={showTasks.includes(day) ? { background: "var(--bottom-nav-color)" } : {}}>
           {showTasks.includes(day) && tasks[day] && tasks[day].scheduled.length > 0 && (
-            <MyTimeline day={day} myTasks={tasks[day]} taskDetails={tasksStatus} setTaskDetails={setTasksStatus} />
+            <MyTimeline day={day} myTasks={tasks[day]} doneTasks={doneTasks} />
           )}
         </div>
       </div>