diff --git a/src/components/Activities/ReportTask.jsx b/src/components/Activities/ReportTask.jsx
index 8194a5cc..6bfe3b95 100644
--- a/src/components/Activities/ReportTask.jsx
+++ b/src/components/Activities/ReportTask.jsx
@@ -54,7 +54,6 @@ export const ReportTask = ({ report, closeModal }) => {
   }, [report, reset]);
 
   const onSubmit = (data) => {
-
     const reportData = {
       ...data,
       id: report?.id,
@@ -62,7 +61,12 @@ export const ReportTask = ({ report, closeModal }) => {
       checkList: [],
     };
 
-    reportTask({ reportData, workAreaId: report?.workItem?.workArea?.id });
+    reportTask({
+      reportData,
+      workAreaId: report?.workItem?.workArea?.id,
+      buildingId: report?.workItem?.workArea?.floor?.building.id,
+      floorId: report?.workItem?.workArea?.floor?.id,
+    });
   };
   const handleClose = () => {
     closeModal();
@@ -181,7 +185,11 @@ export const ReportTask = ({ report, closeModal }) => {
           </div>
         </div>
         <div className="col-12 text-center my-2">
-          <button type="submit" className="btn btn-sm btn-primary me-3" disabled={isPending}>
+          <button
+            type="submit"
+            className="btn btn-sm btn-primary me-3"
+            disabled={isPending}
+          >
             {isPending ? "Please wait" : "Submit Report"}
           </button>
           <button
diff --git a/src/components/Project/Infrastructure/EditActivityModal.jsx b/src/components/Project/Infrastructure/EditActivityModal.jsx
index 06a6e41e..36b9e98c 100644
--- a/src/components/Project/Infrastructure/EditActivityModal.jsx
+++ b/src/components/Project/Infrastructure/EditActivityModal.jsx
@@ -116,7 +116,8 @@ useEffect(() => {
       floorId: floor?.id,
       workAreaId: workArea?.id,
     };
-   UpdateTask([payload])
+    let plannedTask =   workItem?.workItem?.plannedWork || workItem?.plannedWork || 0
+   UpdateTask({payload:[payload],PreviousPlannedWork:plannedTask})
  }
   return (
     <form className="row g-2 p-2 p-md-1" onSubmit={handleSubmit(onSubmitForm)}>
diff --git a/src/components/Project/Infrastructure/TaskModel.jsx b/src/components/Project/Infrastructure/TaskModel.jsx
index 12cf8c87..24365622 100644
--- a/src/components/Project/Infrastructure/TaskModel.jsx
+++ b/src/components/Project/Infrastructure/TaskModel.jsx
@@ -97,7 +97,7 @@ const TaskModel = ({ project, onSubmit, onClose }) => {
 
   const onSubmitForm = async (data) => {
     const payload = [data];
-    CreateTask(payload);
+    CreateTask({payload,PreviousPlannedWork:0});
   };
 
   return (
@@ -177,8 +177,8 @@ const TaskModel = ({ project, onSubmit, onClose }) => {
             className="form-select form-select-sm"
             {...register("activityID")}
           >
-            <option value="">Select Activity</option>
-            {activityData.map((a) => (
+            <option value={activityLoading ? "Loading.....":" "}>{!activityLoading && "Select Activity"}</option>
+            {activityData?.length > 0 && activityData.map((a) => (
               <option key={a.id} value={a.id}>
                 {a.activityName}
               </option>
@@ -197,7 +197,8 @@ const TaskModel = ({ project, onSubmit, onClose }) => {
             className="form-select form-select-sm"
             {...register("workCategoryId")}
           >
-            {categoryData.map((c) => (
+            <option value={categoryLoading ? "Loading.....":" "}>{!categoryLoading && "Select Activity"}</option>
+            {categoryData?.length > 0 && categoryData.map((c) => (
               <option key={c.id} value={c.id}>
                 {c.name}
               </option>
@@ -263,13 +264,14 @@ const TaskModel = ({ project, onSubmit, onClose }) => {
         <button
           type="submit"
           className="btn btn-sm btn-primary me-3"
-          disabled={isSubmitting}
+          disabled={isPending}
         >
-          {isSubmitting ? "Please Wait..." : "Add Task"}
+          {isPending ? "Please Wait..." : "Add Task"}
         </button>
         <button
           type="button"
           className="btn btn-sm btn-label-secondary"
+          disabled={isPending}
           onClick={onClose}
         >
           Cancel
diff --git a/src/hooks/useProjects.js b/src/hooks/useProjects.js
index 2cc5ee1d..aace5f74 100644
--- a/src/hooks/useProjects.js
+++ b/src/hooks/useProjects.js
@@ -6,200 +6,14 @@ import { useDispatch, useSelector } from "react-redux";
 import { setProjectId } from "../slices/localVariablesSlice";
 import EmployeeList from "../components/Directory/EmployeeList";
 import eventBus from "../services/eventBus";
-import {Mutation, useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
+import {
+  Mutation,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
 import showToast from "../services/toastService";
 
-// export const useProjects = () => {
-//   const loggedUser = useSelector((store) => store.globalVariables.loginUser);
-//   const [projects, setProjects] = useState([]);
-//   const [loading, setLoading] = useState(true);
-//   const [error, setError] = useState("");
-
-//   const fetchData = async () => {
-//     const projectIds = loggedUser?.projects || [];
-
-//     const filterProjects = (projectsList) => {
-//       return projectsList
-//         .filter((proj) => projectIds.includes(String(proj.id)))
-//         .sort((a, b) => a?.name?.localeCompare(b.name));
-//     };
-
-//     const projects_cache = getCachedData("projectslist");
-
-//     if (!projects_cache) {
-//       setLoading(true);
-//       try {
-//         const response = await ProjectRepository.getProjectList();
-//         const allProjects = response.data;
-//         const filtered = filterProjects(allProjects);
-//         setProjects(filtered);
-//         cacheData("projectslist", allProjects);
-//       } catch (err) {
-//         setError("Failed to fetch data.");
-//       } finally {
-//         setLoading(false);
-//       }
-//     } else {
-//       if (!projects.length) {
-//         const filtered = filterProjects(projects_cache);
-//         setProjects(filtered);
-//         setLoading(false);
-//       }
-//     }
-//   };
-//   useEffect(() => {
-//     if (loggedUser) {
-//       fetchData();
-//     }
-//   }, [loggedUser]);
-
-//   return { projects, loading, error, refetch: fetchData };
-// };
-
-// export const useEmployeesByProjectAllocated = (selectedProject) => {
-//   const [projectEmployees, setEmployeeList] = useState([]);
-//   const [loading, setLoading] = useState(true);
-//   const [projects, setProjects] = useState([]);
-
-//   const fetchData = async (projectid) => {
-//     try {
-//       let EmployeeByProject_Cache = getCachedData("empListByProjectAllocated");
-//       if (
-//         !EmployeeByProject_Cache ||
-//         !EmployeeByProject_Cache.projectId === projectid
-//       ) {
-//         let response = await ProjectRepository.getProjectAllocation(projectid);
-//         setEmployeeList(response.data);
-//         cacheData("empListByProjectAllocated", {
-//           data: response.data,
-//           projectId: projectid,
-//         });
-//         setLoading(false);
-//       } else {
-//         setEmployeeList(EmployeeByProject_Cache.data);
-//         setLoading(false);
-//       }
-//     } catch (err) {
-//       setError("Failed to fetch data.");
-//       setLoading(false);
-//     }
-//   };
-
-//   useEffect(() => {
-//     if (selectedProject) {
-//       fetchData(selectedProject);
-//     }
-//   }, [selectedProject]);
-
-//   return { projectEmployees, loading, projects };
-// };
-
-// export const useProjectDetails = (projectId) => {
-//   const { profile } = useProfile();
-//   const [projects_Details, setProject_Details] = useState(null);
-//   const [loading, setLoading] = useState(true);
-//   const [error, setError] = useState("");
-
-//   const fetchData = async () => {
-//     setLoading(true);
-
-//     const project_cache = getCachedData("projectInfo");
-//     if (!project_cache || project_cache?.projectId != projectId) {
-//       ProjectRepository.getProjectByprojectId(projectId)
-//         .then((response) => {
-//           setProject_Details(response.data);
-//           cacheData("projectInfo", {
-//             projectId: projectId,
-//             data: response.data,
-//           });
-//           setLoading(false);
-//         })
-//         .catch((error) => {
-//           console.error(error);
-//           setError("Failed to fetch data.");
-//           setLoading(false);
-//         });
-//     } else {
-//       setProject_Details(project_cache.data);
-//       setLoading(false);
-//     }
-//   };
-
-//   useEffect(() => {
-//     if (profile && projectId != undefined) {
-//       fetchData();
-//     }
-//   }, [projectId, profile]);
-
-//   return { projects_Details, loading, error, refetch: fetchData };
-// };
-
-// export const useProjectsByEmployee = (employeeId) => {
-//   const [projectList, setProjectList] = useState([]);
-//   const [loading, setLoading] = useState(false);
-//   const [error, setError] = useState("");
-
-//   const fetchProjects = async (id) => {
-//     try {
-//       setLoading(true);
-//       setError(""); // clear previous error
-//       const res = await ProjectRepository.getProjectsByEmployee(id);
-//       setProjectList(res.data);
-//       cacheData("ProjectsByEmployee", { data: res.data, employeeId: id });
-//       setLoading(false);
-//     } catch (err) {
-//       setError(err?.message || "Failed to fetch projects");
-//       setLoading(false);
-//     }
-//   };
-
-//   useEffect(() => {
-//     if (!employeeId) return;
-
-//     const cache_project = getCachedData("ProjectsByEmployee");
-
-//     if (!cache_project?.data || cache_project?.employeeId !== employeeId) {
-//       fetchProjects(employeeId);
-//     } else {
-//       setProjectList(cache_project.data);
-//     }
-//   }, [employeeId]);
-
-//   return {
-//     projectList,
-//     loading,
-//     error,
-//     refetch: fetchProjects,
-//   };
-// };
-
-// export const useProjectName = () => {
-//   const [loading, setLoading] = useState(true);
-//   const [projectNames, setProjectName] = useState([]);
-//   const [Error, setError] = useState();
-//   const dispatch = useDispatch();
-
-//   const fetchData = async () => {
-//     try {
-//       let response = await ProjectRepository.projectNameList();
-//       setProjectName(response.data);
-//       cacheData("basicProjectNameList", response.data);
-//       setLoading(false);
-//       if(response.data.length === 1){
-//         dispatch(setProjectId(response.data[0]?.id));
-//       }
-//     } catch (err) {
-//       setError("Failed to fetch data.");
-//       setLoading(false);
-//     }
-//   };
-//   useEffect(() => {
-//     fetchData();
-//   }, []);
-
-//   return { projectNames, loading, Error, fetchData };
-// };
-
 // ------------------------------Query-------------------
 
 export const useProjects = () => {
@@ -211,7 +25,7 @@ export const useProjects = () => {
     error,
     refetch,
   } = useQuery({
-    queryKey: ['ProjectsList'],
+    queryKey: ["ProjectsList"],
     queryFn: async () => {
       const response = await ProjectRepository.getProjectList();
       return response.data;
@@ -227,97 +41,112 @@ export const useProjects = () => {
   };
 };
 
-export const useEmployeesByProjectAllocated = (selectedProject) =>
-{
-  const {data = [], isLoading, refetch, error} = useQuery( {
-    queryKey: ["empListByProjectAllocated", selectedProject ],
-    queryFn: async () =>
-    {
-      const res = await ProjectRepository.getProjectAllocation( selectedProject );
-      return res.data || res
+export const useEmployeesByProjectAllocated = (selectedProject) => {
+  const {
+    data = [],
+    isLoading,
+    refetch,
+    error,
+  } = useQuery({
+    queryKey: ["empListByProjectAllocated", selectedProject],
+    queryFn: async () => {
+      const res = await ProjectRepository.getProjectAllocation(selectedProject);
+      return res.data || res;
     },
     enabled: !!selectedProject,
-    onError: ( error ) =>
-    {
-       showToast(error.message || "Error while Fetching project Allocated Employees", "error");
-    }
-  } )
-  
+    onError: (error) => {
+      showToast(
+        error.message || "Error while Fetching project Allocated Employees",
+        "error"
+      );
+    },
+  });
+
   return {
     projectEmployees: data,
-    loading:isLoading,
+    loading: isLoading,
     error,
-  refetch
-  }
-}
+    refetch,
+  };
+};
 
-export const useProjectDetails = ( projectId,isAuto = true ) =>
-{
-  const {data: projects_Details, isLoading, error, refetch} = useQuery( {
-    queryKey: [ "projectInfo", projectId ],
-    queryFn: async () =>
-    {
-      const res = await ProjectRepository.getProjectByprojectId( projectId );
+export const useProjectDetails = (projectId, isAuto = true) => {
+  const {
+    data: projects_Details,
+    isLoading,
+    error,
+    refetch,
+  } = useQuery({
+    queryKey: ["projectInfo", projectId],
+    queryFn: async () => {
+      const res = await ProjectRepository.getProjectByprojectId(projectId);
       return res.data || res;
     },
     enabled: !!projectId && isAuto,
-    onError: ( error ) =>
-    {
-       showToast(error.message || "Error while Fetching project Details", "error");
-    }
-  } )
- return { projects_Details, loading:isLoading, error, refetch };
-}
+    onError: (error) => {
+      showToast(
+        error.message || "Error while Fetching project Details",
+        "error"
+      );
+    },
+  });
+  return { projects_Details, loading: isLoading, error, refetch };
+};
 
-export const useProjectsByEmployee = (employeeId) =>
-{
-  const { data:projectNameList =[],isLoading,error,refetch} = useQuery( {
-    queryKey: [ "ProjectsByEmployee", employeeId ],
-    queryFn: async () =>
-    {
-      const res = await ProjectRepository.getProjectsByEmployee( employeeId );
+export const useProjectsByEmployee = (employeeId) => {
+  const {
+    data: projectNameList = [],
+    isLoading,
+    error,
+    refetch,
+  } = useQuery({
+    queryKey: ["ProjectsByEmployee", employeeId],
+    queryFn: async () => {
+      const res = await ProjectRepository.getProjectsByEmployee(employeeId);
       return res.data || res;
     },
     enabled: !!employeeId,
-    onError: ( error ) =>
-    {
-       showToast(error.message || "Error while Fetching project Employee", "error");
-    }
-   })
-  return {projectList, loading:isLoading,error,refetch }
-}
+    onError: (error) => {
+      showToast(
+        error.message || "Error while Fetching project Employee",
+        "error"
+      );
+    },
+  });
+  return { projectList, loading: isLoading, error, refetch };
+};
 
-export const useProjectName = () =>
-{
-  const {data = [],isLoading,error,refetch} = useQuery( {
-    queryKey: [ "basicProjectNameList" ],
-    queryFn: async () =>
-    {
+export const useProjectName = () => {
+  const {
+    data = [],
+    isLoading,
+    error,
+    refetch,
+  } = useQuery({
+    queryKey: ["basicProjectNameList"],
+    queryFn: async () => {
       const res = await ProjectRepository.projectNameList();
       return res.data || res;
     },
-    onError: ( error ) =>
-    {
-       showToast(error.message || "Error while Fetching project Name", "error");
-    }
-  } )
-  return {projectNames:data,loading:isLoading,Error:error,refetch}
-}
+    onError: (error) => {
+      showToast(error.message || "Error while Fetching project Name", "error");
+    },
+  });
+  return { projectNames: data, loading: isLoading, Error: error, refetch };
+};
 
-
-  
 export const useProjectInfra = (projectId) => {
   const {
     data: projectInfra,
     isLoading,
     error,
   } = useQuery({
-    queryKey: ["ProjectInfra", projectId], 
+    queryKey: ["ProjectInfra", projectId],
     queryFn: async () => {
       const res = await ProjectRepository.getProjectInfraByproject(projectId);
       return res.data;
     },
-    enabled: !!projectId , 
+    enabled: !!projectId,
     onError: (error) => {
       showToast(error.message || "Error while fetching project infra", "error");
     },
@@ -326,30 +155,27 @@ export const useProjectInfra = (projectId) => {
   return { projectInfra, isLoading, error };
 };
 
-
-export const useProjectTasks = (workAreaId,IsExpandedArea=false) =>
-{
-  const { data:ProjectTaskList,isLoading,error } = useQuery( {
-    queryKey: [ "WorkItems",workAreaId ],
-    queryFn: async () =>
-    {
+export const useProjectTasks = (workAreaId, IsExpandedArea = false) => {
+  const {
+    data: ProjectTaskList,
+    isLoading,
+    error,
+  } = useQuery({
+    queryKey: ["WorkItems", workAreaId],
+    queryFn: async () => {
       const res = await ProjectRepository.getProjectTasksByWorkArea(workAreaId);
       return res.data;
     },
     enabled: !!workAreaId && !!IsExpandedArea,
-    onError: ( error ) =>
-    {
-       showToast(error.message || "Error while Fetching project Tasks", "error");
-    }
-  } )
-  return {ProjectTaskList,isLoading,error}
-}
-
+    onError: (error) => {
+      showToast(error.message || "Error while Fetching project Tasks", "error");
+    },
+  });
+  return { ProjectTaskList, isLoading, error };
+};
 
 // -- -------------Mutation-------------------------------
 
-
-
 export const useCreateProject = ({ onSuccessCallback }) => {
   const queryClient = useQueryClient();
 
@@ -360,8 +186,8 @@ export const useCreateProject = ({ onSuccessCallback }) => {
     },
     onSuccess: (data) => {
       //  Invalidate the cache
-      queryClient.invalidateQueries( {queryKey: [ 'ProjectsList' ]} );
-      queryClient.invalidateQueries({queryKey:['basicProjectNameList']});
+      queryClient.invalidateQueries({ queryKey: ["ProjectsList"] });
+      queryClient.invalidateQueries({ queryKey: ["basicProjectNameList"] });
 
       //  Emit event for consumers (like useProjects or others)
       eventBus.emit("project", {
@@ -381,27 +207,19 @@ export const useCreateProject = ({ onSuccessCallback }) => {
   });
 };
 
-
 export const useUpdateProject = ({ onSuccessCallback }) => {
   const queryClient = useQueryClient();
-    const {
-    mutate,
-    isPending,
-    isSuccess,
-    isError,
-  } = useMutation({
-    mutationFn: async ( {projectId, updatedData} ) =>
-    {
+  const { mutate, isPending, isSuccess, isError } = useMutation({
+    mutationFn: async ({ projectId, updatedData }) => {
       return await ProjectRepository.updateProject(projectId, updatedData);
     },
 
-    onSuccess: ( data, variables ) =>
-    {
+    onSuccess: (data, variables) => {
       const { projectId } = variables;
-   
-      queryClient.invalidateQueries({queryKey:["ProjectsList"]});
-      queryClient.invalidateQueries( {queryKey: [ "projectInfo", projectId ]} );
-      queryClient.invalidateQueries({queryKey:['basicProjectNameList']});
+
+      queryClient.invalidateQueries({ queryKey: ["ProjectsList"] });
+      queryClient.invalidateQueries({ queryKey: ["projectInfo", projectId] });
+      queryClient.invalidateQueries({ queryKey: ["basicProjectNameList"] });
 
       eventBus.emit("project", {
         keyword: "Update_Project",
@@ -415,9 +233,8 @@ export const useUpdateProject = ({ onSuccessCallback }) => {
       }
     },
 
-    onError: ( error ) =>
-    {
-      console.log(error)
+    onError: (error) => {
+      console.log(error);
       showToast(error?.message || "Error while updating project", "error");
     },
   });
@@ -430,20 +247,16 @@ export const useUpdateProject = ({ onSuccessCallback }) => {
   };
 };
 
-
-export const useManageProjectInfra = ( {onSuccessCallback} ) =>
-{
+export const useManageProjectInfra = ({ onSuccessCallback }) => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ( {infraObject, projectId} ) =>
-    {
+    mutationFn: async ({ infraObject, projectId }) => {
       return await ProjectRepository.manageProjectInfra(infraObject);
     },
-    onSuccess: ( data, variables ) =>
-    {
-      const { projectId } = variables;      
-      queryClient.invalidateQueries({queryKey:["ProjectInfra", projectId]});
-       if (onSuccessCallback) onSuccessCallback(data,variables);
+    onSuccess: (data, variables) => {
+      const { projectId } = variables;
+      queryClient.invalidateQueries({ queryKey: ["ProjectInfra", projectId] });
+      if (onSuccessCallback) onSuccessCallback(data, variables);
     },
     onError: (error) => {
       showToast(error.message || "Failed to update Project Infra", "error");
@@ -451,39 +264,36 @@ export const useManageProjectInfra = ( {onSuccessCallback} ) =>
   });
 };
 
-
 export const useManageProjectAllocation = ({
   onSuccessCallback,
   onErrorCallback,
 }) => {
   const queryClient = useQueryClient();
 
-  const {
-    mutate,
-    isPending,
-    isSuccess,
-    isError,
-  } = useMutation({
-    mutationFn: async ( {items} ) =>
-    {
+  const { mutate, isPending, isSuccess, isError } = useMutation({
+    mutationFn: async ({ items }) => {
       const response = await ProjectRepository.manageProjectAllocation(items);
       return response.data;
     },
     onSuccess: (data, variables, context) => {
-      queryClient.invalidateQueries({queryKey:['empListByProjectAllocated']});
-       queryClient.removeQueries({queryKey:["projectEmployees"]})
+      queryClient.invalidateQueries({
+        queryKey: ["empListByProjectAllocated"],
+      });
+      queryClient.removeQueries({ queryKey: ["projectEmployees"] });
       if (variables?.added) {
-        showToast('Employee Assigned Successfully', 'success');
+        showToast("Employee Assigned Successfully", "success");
       } else {
-        showToast('Removed Employee Successfully', 'success');
+        showToast("Removed Employee Successfully", "success");
       }
 
       if (onSuccessCallback) onSuccessCallback(data, context);
     },
     onError: (error) => {
       const message =
-        error?.response?.data?.message || error.message || 'Error occurred during API call';
-      showToast(message, 'error');
+        error?.response?.data?.message ||
+        error.message ||
+        "Error occurred during API call";
+      showToast(message, "error");
       if (onErrorCallback) onErrorCallback(error);
     },
   });
@@ -496,48 +306,74 @@ export const useManageProjectAllocation = ({
   };
 };
 
-export const useManageTask = ({onSuccessCallback}) =>
-{
+export const useManageTask = ({ onSuccessCallback }) => {
   const queryClient = useQueryClient();
+  const selectedProject = useSelector(
+    (store) => store.localVariables.projectId
+  );
+
+  return useMutation({
+    mutationFn: async ({ payload, PreviousPlannedWork }) =>
+      await ProjectRepository.manageProjectTasks(payload),
+    onSuccess: (data, variables) => {
+      const { PreviousPlannedWork } = variables;
+      queryClient.invalidateQueries({ queryKey: ["WorkItems"] });
+      const getPlannedDelta = (previous, current) => current - previous;
+
+      queryClient.setQueryData(["ProjectsList"], (projects) => {
+        if (!projects) return projects;
+
+        return projects.map((project) => {
+          if (project.id !== selectedProject) return project;
+
+          const previous = PreviousPlannedWork ?? 0;
+          const current = data?.data[0]?.workItem.plannedWork ?? 0;
+
+          const plannedWorkDelta = getPlannedDelta(previous, current);
+          const updatedPlannedWork =
+            (project.plannedWork ?? 0) + plannedWorkDelta;
+
+          return {
+            ...project,
+            plannedWork: updatedPlannedWork,
+          };
+        });
+      });
 
-  return useMutation( {
-    mutationFn: async ( payload ) => await ProjectRepository.manageProjectTasks( payload ),
-    onSuccess: ( data, variables ) =>
-    {
-      queryClient.invalidateQueries({ queryKey: ["WorkItems"] })
       if (onSuccessCallback) onSuccessCallback(data);
     },
-    onError: (error) =>
-    {
-       const message =
-        error?.response?.data?.message || error.message || 'Error occurred during API call';
-       showToast(message, 'error');
-    }
-   
-  })
-}
+    onError: (error) => {
+      const message =
+        error?.response?.data?.message ||
+        error.message ||
+        "Error occurred during API call";
+      showToast(message, "error");
+    },
+  });
+};
 
 export const useDeleteProjectTask = (onSuccessCallback) => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async ( {workItemId, workAreaId} ) =>
-    {
+    mutationFn: async ({ workItemId, workAreaId }) => {
       return await ProjectRepository.deleteProjectTask(workItemId);
     },
-    onSuccess: ( _, variables ) =>
-    {
+    onSuccess: (_, variables) => {
       showToast("Task deleted successfully", "success");
-      queryClient.invalidateQueries({queryKey:[ "WorkItems",variables.workAreaId]});
+      queryClient.invalidateQueries({
+        queryKey: ["WorkItems", variables.workAreaId],
+      });
       if (onSuccessCallback) onSuccessCallback();
     },
     onError: (error) => {
       showToast(
-        error?.response?.data?.message || error.message || "Failed to delete task",
+        error?.response?.data?.message ||
+          error.message ||
+          "Failed to delete task",
         "error"
       );
-       if (onSuccessCallback) onSuccessCallback();
+      if (onSuccessCallback) onSuccessCallback();
     },
   });
 };
-
diff --git a/src/hooks/useTasks.js b/src/hooks/useTasks.js
index 1cf531c0..7b70201c 100644
--- a/src/hooks/useTasks.js
+++ b/src/hooks/useTasks.js
@@ -1,11 +1,10 @@
 import { useEffect, useState } from "react";
 import { TasksRepository } from "../repositories/TaskRepository";
 import { cacheData, getCachedData } from "../slices/apiDataManager";
-import {MasterRespository} from "../repositories/MastersRepository";
+import { MasterRespository } from "../repositories/MastersRepository";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import showToast from "../services/toastService";
-import {useSelector} from "react-redux";
-
+import { useSelector } from "react-redux";
 
 // ---------Query---------------------------------
 
@@ -28,7 +27,6 @@ export const useTaskList = (projectId, dateFrom, toDate) => {
       return response.data;
     },
     enabled,
- 
   });
 
   return { TaskList, loading, error, refetch };
@@ -46,7 +44,7 @@ export const useTaskById = (TaskId) => {
       const res = await TasksRepository.getTaskById(TaskId);
       return res.data;
     },
-    enabled: !!TaskId, 
+    enabled: !!TaskId,
   });
 
   return { Task, loading, error, refetch };
@@ -75,47 +73,81 @@ export const useAuditStatus = () => {
       const res = await MasterRespository.getAuditStatus();
       return res.data;
     },
-
   });
 
   return { status, loading, error, refetch };
 };
 
+// ---------====================Mutation================------------------
+const toDate = new Date().toISOString().split("T")[0];
+const dateFrom = new Date(Date.now() - 6 * 24 * 60 * 60 * 1000)
+  .toISOString()
+  .split("T")[0];
 
-// -----------------------Mutation------------------------
-const toDate = new Date().toISOString().split('T')[0];
-const dateFrom = new Date(Date.now() - 6 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-
-
-
-export const useReportTask = ( {onSuccessCallback, onErrorCallback} = {} ) =>
-{
+export const useReportTask = ({ onSuccessCallback, onErrorCallback } = {}) => {
+  const selectedProject = useSelector(
+    (store) => store.localVariables.projectId
+  );
   const queryClient = useQueryClient();
-  const {
-    mutate,
-    isPending,
-    isSuccess,
-    isError,
-    error,
-  } = useMutation({
-    mutationFn: async ( {reportData,workAreaId} ) =>
-    {
-      debugger
+  const { mutate, isPending, isSuccess, isError, error } = useMutation({
+    mutationFn: async ({ reportData, workAreaId }) => {
       return await TasksRepository.reportTask(reportData);
     },
-    onSuccess: ( data, variables ) =>
-    {
-      const {workAreaId} = variables;
-      queryClient.invalidateQueries( {queryKey: [ "taskList" ]} ); 
-      queryClient.invalidateQueries( {queryKey: [ "WorkItems", workAreaId ]} );
-      queryClient.invalidateQueries( {queryKey: [ 'ProjectsList' ]} );
-      showToast( "Task Reported Successfully.", "success" );
+    onSuccess: (data, variables) => {
+      const { workAreaId, buildingId, floorId } = variables;
+      queryClient.invalidateQueries({ queryKey: ["taskList"] });
+      queryClient.invalidateQueries({ queryKey: ["WorkItems", workAreaId] });
+      queryClient.setQueryData(["ProjectInfra", selectedProject], (oldData) => {
+        if (!oldData) return oldData;
+        const { workAreaId, floorId, buildingId } = variables;
+        const updatedData = JSON.parse(JSON.stringify(oldData));
+
+        return updatedData.map((building) => {
+          if (building.id !== buildingId) return building;
+          return {
+            ...building,
+            floors: building.floors.map((floor) => {
+              if (floor.id !== floorId) return floor;
+
+              return {
+                ...floor,
+                workAreas: floor.workAreas.map((area) => {
+                  if (area.id !== workAreaId) return area;
+                  return {
+                    ...area,
+                    completedWork:
+                      (area.completedWork ?? 0) +
+                      (data?.data?.completedTask ?? 0),
+                  };
+                }),
+              };
+            }),
+          };
+        });
+      });
+      queryClient.setQueryData(["ProjectsList"], (projects) => {
+        if (!projects) return projects;
+        const updatedProject = JSON.parse(JSON.stringify(projects));
+        return updatedProject.map((project) => {
+          if (project.id !== selectedProject) return project;
+
+          return {
+            ...project,
+            completedWork:
+              (project.completedWork ?? 0) + (data?.data?.completedTask ?? 0),
+          };
+        });
+      });
+
+      showToast("Task Reported Successfully.", "success");
       if (onSuccessCallback) onSuccessCallback(data);
     },
     onError: (error) => {
       const msg =
-        error?.response?.data?.message || error.message || "Error occurred during API call";
-      showToast( msg, "error" );
+        error?.response?.data?.message ||
+        error.message ||
+        "Error occurred during API call";
+      showToast(msg, "error");
     },
   });
 
@@ -145,16 +177,12 @@ export const useSubmitTaskComment = ({ actionAllow, onSuccessCallback }) => {
       return response.data;
     },
 
-    onSuccess: ( data,variables ) =>
-    {
-
+    onSuccess: (data, variables) => {
       const workAreaId = variables?.commentsData?.workItem?.workArea?.id;
       queryClient.invalidateQueries({ queryKey: ["taskList"] });
       if (actionAllow) {
-        showToast( "Review submitted successfully.", "success" );
-        
-      } else
-      {
+        showToast("Review submitted successfully.", "success");
+      } else {
         showToast("Comment sent successfully.", "success");
       }
 
@@ -162,7 +190,10 @@ export const useSubmitTaskComment = ({ actionAllow, onSuccessCallback }) => {
     },
 
     onError: (error) => {
-      const msg = error?.response?.data?.message || error.message || "Error during API call";
+      const msg =
+        error?.response?.data?.message ||
+        error.message ||
+        "Error during API call";
       showToast(msg, "error");
     },
   });
@@ -170,24 +201,23 @@ export const useSubmitTaskComment = ({ actionAllow, onSuccessCallback }) => {
   return { submitComment: mutate, isPending };
 };
 
-export const useCreateTask = ( {onSuccessCallback, onErrorCallback} = {} ) =>
-{
+export const useCreateTask = ({ onSuccessCallback, onErrorCallback } = {}) => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({payload,workAreaId}) => {
+    mutationFn: async ({ payload, workAreaId }) => {
       return await TasksRepository.assignTask(payload);
     },
-    onSuccess: ( _, variables ) =>
-    {
-      queryClient.invalidateQueries( {queryKey: [ "taskList" ]} );
-      queryClient.invalidateQueries( {queryKey: [ "WorkItems", variables?.workAreaId ]} );
-      showToast( "Task Assigned Successfully.", "success" );
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: ["taskList"] });
+      queryClient.invalidateQueries({
+        queryKey: ["WorkItems", variables?.workAreaId],
+      });
+      showToast("Task Assigned Successfully.", "success");
       if (onSuccessCallback) onSuccessCallback(variables);
     },
-    onError: ( error ) =>
-    {
+    onError: (error) => {
       showToast("Something went wrong. Please try again.", "error");
       if (onErrorCallback) onErrorCallback(error);
     },
   });
-};
\ No newline at end of file
+};