diff --git a/apps/calendar/src/app/[locale]/(root)/scheduler/components/ScheduleDisplay.tsx b/apps/calendar/src/app/[locale]/(root)/scheduler/components/ScheduleDisplay.tsx
index b678398e2..d0a041764 100644
--- a/apps/calendar/src/app/[locale]/(root)/scheduler/components/ScheduleDisplay.tsx
+++ b/apps/calendar/src/app/[locale]/(root)/scheduler/components/ScheduleDisplay.tsx
@@ -13,6 +13,7 @@ import {
   AlertTriangleIcon,
   CalendarIcon,
   ClockIcon,
+  LockIcon,
   SparklesIcon,
   TrendingUpIcon,
 } from '@tuturuuu/ui/icons';
@@ -225,15 +226,29 @@ export function ScheduleDisplay({ events }: ScheduleDisplayProps) {
                             {/* Event Card */}
                             <div
                               className={`group relative rounded-lg border p-4 transition-all hover:shadow-sm ${
-                                event.isPastDeadline
-                                  ? 'border-destructive/30 bg-destructive/5'
-                                  : 'hover:bg-accent/5'
+                                event.locked
+                                  ? 'border-dynamic-blue/30 bg-dynamic-blue/10'
+                                  : event.isPastDeadline
+                                    ? 'border-destructive/30 bg-destructive/5'
+                                    : 'hover:bg-accent/5'
                               }`}
                             >
                               <div className="flex items-start justify-between gap-4">
                                 <div className="flex-1 space-y-2">
                                   {/* Event Header */}
                                   <div className="flex items-center gap-3">
+                                    {event.locked && (
+                                      <Tooltip>
+                                        <TooltipTrigger>
+                                          <LockIcon className="h-5 w-5 shrink-0 text-dynamic-blue" />
+                                        </TooltipTrigger>
+                                        <TooltipContent>
+                                          <p>
+                                            Locked event: this time is blocked
+                                          </p>
+                                        </TooltipContent>
+                                      </Tooltip>
+                                    )}
                                     {event.isPastDeadline && (
                                       <Tooltip>
                                         <TooltipTrigger>
diff --git a/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskList.tsx b/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskList.tsx
index 4429ae772..0aae7d0d5 100644
--- a/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskList.tsx
+++ b/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskList.tsx
@@ -18,6 +18,7 @@ import {
   Trash2Icon,
   ZapIcon,
 } from '@tuturuuu/ui/icons';
+import { SplitIcon } from '@tuturuuu/ui/icons';
 import { Input } from '@tuturuuu/ui/input';
 import { Label } from '@tuturuuu/ui/label';
 import { Progress } from '@tuturuuu/ui/progress';
@@ -28,6 +29,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@tuturuuu/ui/select';
+import { Switch } from '@tuturuuu/ui/switch';
 import { Tooltip, TooltipContent, TooltipTrigger } from '@tuturuuu/ui/tooltip';
 import dayjs from 'dayjs';
 import { useMemo } from 'react';
@@ -245,6 +247,29 @@ export function TaskList({
                                 : ''
                             }`}
                           />
+                          {/* Split Toggle Button */}
+                          <div className="ml-2 flex items-center gap-1">
+                            <Tooltip>
+                              <TooltipTrigger asChild>
+                                <div className="flex items-center gap-1">
+                                  <SplitIcon className="h-4 w-4 text-primary" />
+                                  <Switch
+                                    id={`split-toggle-${task.id}`}
+                                    checked={task.allowSplit ?? true}
+                                    onCheckedChange={(checked) =>
+                                      onUpdateTask(task.id, {
+                                        allowSplit: checked,
+                                      })
+                                    }
+                                    className="scale-90"
+                                  />
+                                </div>
+                              </TooltipTrigger>
+                              <TooltipContent>
+                                Allow this task to be split into sessions
+                              </TooltipContent>
+                            </Tooltip>
+                          </div>
                           {isCompleted && (
                             <CheckCircleIcon className="h-5 w-5 text-dynamic-green" />
                           )}
diff --git a/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskModal.tsx b/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskModal.tsx
index 2c1287040..6b3663d43 100644
--- a/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskModal.tsx
+++ b/apps/calendar/src/app/[locale]/(root)/scheduler/components/TaskModal.tsx
@@ -11,6 +11,7 @@ import {
   DialogTitle,
 } from '@tuturuuu/ui/dialog';
 import { CalendarIcon, ClockIcon, PlusIcon, TagIcon } from '@tuturuuu/ui/icons';
+import { SplitIcon } from '@tuturuuu/ui/icons';
 import { Input } from '@tuturuuu/ui/input';
 import { Label } from '@tuturuuu/ui/label';
 import {
@@ -20,15 +21,15 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@tuturuuu/ui/select';
-import { Separator } from '@tuturuuu/ui/separator';
+import { Switch } from '@tuturuuu/ui/switch';
 import { Textarea } from '@tuturuuu/ui/textarea';
 import dayjs from 'dayjs';
 import { useState } from 'react';
 
 interface TaskModalProps {
   isOpen: boolean;
-  onClose: () => void;
-  onAddTask: (task: Omit<Task, 'id' | 'events'>) => void;
+  onCloseAction: () => void;
+  onAddTaskAction: (task: Omit<Task, 'id' | 'events'>) => void;
 }
 
 const categoryOptions = [
@@ -52,7 +53,11 @@ const categoryOptions = [
   },
 ] as const;
 
-export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
+export function TaskModal({
+  isOpen,
+  onCloseAction,
+  onAddTaskAction,
+}: TaskModalProps) {
   const [formData, setFormData] = useState({
     name: '',
     description: '',
@@ -62,6 +67,7 @@ export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
     category: 'work' as 'work' | 'personal' | 'meeting',
     deadline: '',
     priority: 'medium' as 'low' | 'medium' | 'high',
+    allowSplit: true,
   });
 
   const [errors, setErrors] = useState<Record<string, string>>({});
@@ -115,9 +121,10 @@ export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
       maxDuration: formData.maxDuration,
       category: formData.category,
       deadline: formData.deadline ? dayjs(formData.deadline) : undefined,
+      allowSplit: formData.allowSplit,
     };
 
-    onAddTask(newTask);
+    onAddTaskAction(newTask);
     handleClose();
   };
 
@@ -131,12 +138,13 @@ export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
       category: 'work',
       deadline: '',
       priority: 'medium',
+      allowSplit: true,
     });
     setErrors({});
-    onClose();
+    onCloseAction();
   };
 
-  const updateFormData = (field: string, value: string | number) => {
+  const updateFormData = (field: string, value: string | number | boolean) => {
     setFormData((prev) => ({ ...prev, [field]: value }));
     if (errors[field]) {
       setErrors((prev) => ({ ...prev, [field]: '' }));
@@ -145,7 +153,7 @@ export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
 
   return (
     <Dialog open={isOpen} onOpenChange={handleClose}>
-      <DialogContent className="sm:max-w-md">
+      <DialogContent className="w-full max-w-2xl">
         <DialogHeader>
           <DialogTitle className="flex items-center gap-2">
             <PlusIcon className="h-5 w-5" />
@@ -156,189 +164,185 @@ export function TaskModal({ isOpen, onClose, onAddTask }: TaskModalProps) {
           </DialogDescription>
         </DialogHeader>
 
-        <form onSubmit={handleSubmit} className="space-y-6">
-          {/* Basic Information */}
-          <div className="space-y-4">
-            <div className="space-y-2">
-              <Label htmlFor="task-name">
-                Task Name <span className="text-destructive">*</span>
-              </Label>
-              <Input
-                id="task-name"
-                placeholder="e.g., Design homepage wireframes"
-                value={formData.name}
-                onChange={(e) => updateFormData('name', e.target.value)}
-                className={errors.name ? 'border-destructive' : ''}
-              />
-              {errors.name && (
-                <p className="text-sm text-destructive">{errors.name}</p>
-              )}
-            </div>
-
-            <div className="space-y-2">
-              <Label htmlFor="task-description">Description (Optional)</Label>
-              <Textarea
-                id="task-description"
-                placeholder="Add any additional details about this task..."
-                value={formData.description}
-                onChange={(e) => updateFormData('description', e.target.value)}
-                rows={2}
-              />
-            </div>
-          </div>
-
-          <Separator />
-
-          {/* Duration Settings */}
-          <div className="space-y-4">
-            <div className="mb-3 flex items-center gap-2">
-              <ClockIcon className="h-4 w-4 text-muted-foreground" />
-              <Label className="text-sm font-medium">Duration Settings</Label>
-            </div>
-
-            <div className="grid grid-cols-3 gap-3">
+        <form onSubmit={handleSubmit} className="flex flex-col gap-6">
+          {/* Basic Information, Duration, Category, Deadline in horizontal layout */}
+          <div className="flex flex-row gap-6">
+            {/* Left column: Basic info and description */}
+            <div className="flex min-w-[220px] flex-1 flex-col gap-4">
               <div className="space-y-2">
-                <Label htmlFor="duration" className="text-sm">
-                  Total Duration (h) <span className="text-destructive">*</span>
+                <Label htmlFor="task-name">
+                  Name <span className="text-destructive">*</span>
                 </Label>
                 <Input
-                  id="duration"
-                  type="number"
-                  step="0.25"
-                  min="0.25"
-                  value={formData.duration}
-                  onChange={(e) =>
-                    updateFormData('duration', parseFloat(e.target.value))
-                  }
-                  className={errors.duration ? 'border-destructive' : ''}
+                  id="task-name"
+                  placeholder="e.g., Design homepage wireframes"
+                  value={formData.name}
+                  onChange={(e) => updateFormData('name', e.target.value)}
+                  className={errors.name ? 'border-destructive' : ''}
                 />
-                {errors.duration && (
-                  <p className="text-xs text-destructive">{errors.duration}</p>
+                {errors.name && (
+                  <p className="text-sm text-destructive">{errors.name}</p>
                 )}
               </div>
-
               <div className="space-y-2">
-                <Label htmlFor="min-duration" className="text-sm">
-                  Min Duration (h) <span className="text-destructive">*</span>
-                </Label>
-                <Input
-                  id="min-duration"
-                  type="number"
-                  step="0.25"
-                  min="0.25"
-                  value={formData.minDuration}
+                <Label htmlFor="task-description">Description</Label>
+                <Textarea
+                  id="task-description"
+                  placeholder="Add any additional details about this task..."
+                  value={formData.description}
                   onChange={(e) =>
-                    updateFormData('minDuration', parseFloat(e.target.value))
+                    updateFormData('description', e.target.value)
                   }
-                  className={errors.minDuration ? 'border-destructive' : ''}
+                  rows={3}
                 />
-                {errors.minDuration && (
-                  <p className="text-xs text-destructive">
-                    {errors.minDuration}
-                  </p>
-                )}
               </div>
-
               <div className="space-y-2">
-                <Label htmlFor="max-duration" className="text-sm">
-                  Max Duration (h) <span className="text-destructive">*</span>
-                </Label>
-                <Input
-                  id="max-duration"
-                  type="number"
-                  step="0.25"
-                  min="0.25"
-                  value={formData.maxDuration}
-                  onChange={(e) =>
-                    updateFormData('maxDuration', parseFloat(e.target.value))
+                <div className="mb-2 flex items-center gap-2">
+                  <TagIcon className="h-4 w-4 text-muted-foreground" />
+                  <Label className="text-sm font-medium">Category</Label>
+                </div>
+                <Select
+                  value={formData.category}
+                  onValueChange={(value: 'work' | 'personal' | 'meeting') =>
+                    updateFormData('category', value)
                   }
-                  className={errors.maxDuration ? 'border-destructive' : ''}
+                >
+                  <SelectTrigger>
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {categoryOptions.map((option) => (
+                      <SelectItem key={option.value} value={option.value}>
+                        <div className="flex items-center gap-2">
+                          <span>{option.icon}</span>
+                          <div>
+                            <div className="font-medium">{option.label}</div>
+                            <div className="text-xs text-muted-foreground">
+                              {option.description}
+                            </div>
+                          </div>
+                        </div>
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="space-y-2">
+                <div className="flex items-center gap-2">
+                  <CalendarIcon className="h-4 w-4 text-muted-foreground" />
+                  <Label htmlFor="deadline" className="text-sm font-medium">
+                    Deadline
+                  </Label>
+                </div>
+                <Input
+                  id="deadline"
+                  type="datetime-local"
+                  value={formData.deadline}
+                  onChange={(e) => updateFormData('deadline', e.target.value)}
+                  min={dayjs().format('YYYY-MM-DDTHH:mm')}
+                  className={errors.deadline ? 'border-destructive' : ''}
                 />
-                {errors.maxDuration && (
-                  <p className="text-xs text-destructive">
-                    {errors.maxDuration}
-                  </p>
+                {errors.deadline && (
+                  <p className="text-sm text-destructive">{errors.deadline}</p>
                 )}
               </div>
             </div>
 
-            <div className="rounded-lg bg-accent/50 p-3 text-xs text-muted-foreground">
-              <strong>Duration Guidelines:</strong>
-              <ul className="mt-1 space-y-1">
-                <li>
-                  • <strong>Total:</strong> How long this task should take
-                  overall
-                </li>
-                <li>
-                  • <strong>Min:</strong> Minimum time block needed for
-                  meaningful progress
-                </li>
-                <li>
-                  • <strong>Max:</strong> Maximum time to work on this task at
-                  once
-                </li>
-              </ul>
-            </div>
-          </div>
-
-          <Separator />
-
-          {/* Category and Deadline */}
-          <div className="space-y-4">
-            <div className="space-y-2">
+            {/* Right column: Duration and split toggle */}
+            <div className="flex min-w-[220px] flex-1 flex-col gap-4">
               <div className="mb-2 flex items-center gap-2">
-                <TagIcon className="h-4 w-4 text-muted-foreground" />
-                <Label className="text-sm font-medium">Category</Label>
+                <ClockIcon className="h-4 w-4 text-muted-foreground" />
+                <Label className="text-sm font-medium">Duration</Label>
               </div>
-              <Select
-                value={formData.category}
-                onValueChange={(value: 'work' | 'personal' | 'meeting') =>
-                  updateFormData('category', value)
-                }
-              >
-                <SelectTrigger>
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  {categoryOptions.map((option) => (
-                    <SelectItem key={option.value} value={option.value}>
-                      <div className="flex items-center gap-2">
-                        <span>{option.icon}</span>
-                        <div>
-                          <div className="font-medium">{option.label}</div>
-                          <div className="text-xs text-muted-foreground">
-                            {option.description}
-                          </div>
-                        </div>
-                      </div>
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
-            </div>
-
-            <div className="space-y-2">
-              <div className="flex items-center gap-2">
-                <CalendarIcon className="h-4 w-4 text-muted-foreground" />
-                <Label htmlFor="deadline" className="text-sm font-medium">
-                  Deadline (Optional)
+              <div className="grid grid-cols-3 gap-3">
+                <div className="space-y-2">
+                  <Label htmlFor="duration" className="text-sm">
+                    Total (h) <span className="text-destructive">*</span>
+                  </Label>
+                  <Input
+                    id="duration"
+                    type="number"
+                    step="0.25"
+                    min="0.25"
+                    value={formData.duration}
+                    onChange={(e) =>
+                      updateFormData('duration', parseFloat(e.target.value))
+                    }
+                    className={errors.duration ? 'border-destructive' : ''}
+                  />
+                  {errors.duration && (
+                    <p className="text-xs text-destructive">
+                      {errors.duration}
+                    </p>
+                  )}
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="min-duration" className="text-sm">
+                    Min (h) <span className="text-destructive">*</span>
+                  </Label>
+                  <Input
+                    id="min-duration"
+                    type="number"
+                    step="0.25"
+                    min="0.25"
+                    value={formData.minDuration}
+                    onChange={(e) =>
+                      updateFormData('minDuration', parseFloat(e.target.value))
+                    }
+                    className={errors.minDuration ? 'border-destructive' : ''}
+                  />
+                  {errors.minDuration && (
+                    <p className="text-xs text-destructive">
+                      {errors.minDuration}
+                    </p>
+                  )}
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="max-duration" className="text-sm">
+                    Max (h) <span className="text-destructive">*</span>
+                  </Label>
+                  <Input
+                    id="max-duration"
+                    type="number"
+                    step="0.25"
+                    min="0.25"
+                    value={formData.maxDuration}
+                    onChange={(e) =>
+                      updateFormData('maxDuration', parseFloat(e.target.value))
+                    }
+                    className={errors.maxDuration ? 'border-destructive' : ''}
+                  />
+                  {errors.maxDuration && (
+                    <p className="text-xs text-destructive">
+                      {errors.maxDuration}
+                    </p>
+                  )}
+                </div>
+              </div>
+              <div className="pb-1 pl-1 text-xs text-muted-foreground">
+                Total = overall time. Min/Max = per session.
+              </div>
+              {/* Split Task Toggle */}
+              <div className="mt-2 flex items-center gap-3 rounded-lg border bg-muted/50 p-3">
+                <SplitIcon className="h-5 w-5 text-primary" />
+                <Switch
+                  id="allow-split"
+                  checked={formData.allowSplit}
+                  onCheckedChange={(checked) =>
+                    updateFormData('allowSplit', checked)
+                  }
+                />
+                <Label htmlFor="allow-split" className="text-sm font-medium">
+                  Allow split
                 </Label>
+                <span className="ml-2 text-xs text-muted-foreground">
+                  Let this task be split into sessions
+                </span>
               </div>
-              <Input
-                id="deadline"
-                type="datetime-local"
-                value={formData.deadline}
-                onChange={(e) => updateFormData('deadline', e.target.value)}
-                min={dayjs().format('YYYY-MM-DDTHH:mm')}
-                className={errors.deadline ? 'border-destructive' : ''}
-              />
-              {errors.deadline && (
-                <p className="text-sm text-destructive">{errors.deadline}</p>
-              )}
             </div>
           </div>
 
-          <DialogFooter className="gap-2">
+          <DialogFooter className="mt-4 gap-2">
             <Button type="button" variant="outline" onClick={handleClose}>
               Cancel
             </Button>
diff --git a/apps/calendar/src/app/[locale]/(root)/scheduler/page.tsx b/apps/calendar/src/app/[locale]/(root)/scheduler/page.tsx
index 0d9537dae..6e979fd75 100644
--- a/apps/calendar/src/app/[locale]/(root)/scheduler/page.tsx
+++ b/apps/calendar/src/app/[locale]/(root)/scheduler/page.tsx
@@ -18,6 +18,7 @@ import type {
   Task,
   TemplateScenario,
 } from '@tuturuuu/ai/scheduling/types';
+import { Button } from '@tuturuuu/ui/button';
 import {
   Card,
   CardContent,
@@ -29,11 +30,19 @@ import {
   BrainIcon,
   CalendarIcon,
   ClockIcon,
+  LockIcon,
   SettingsIcon,
   SparklesIcon,
 } from '@tuturuuu/ui/icons';
 import { Input } from '@tuturuuu/ui/input';
 import { Label } from '@tuturuuu/ui/label';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@tuturuuu/ui/select';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@tuturuuu/ui/tabs';
 import { TooltipProvider } from '@tuturuuu/ui/tooltip';
 import dayjs from 'dayjs';
@@ -47,6 +56,8 @@ function SchedulerPage() {
     useState<ActiveHours>(defaultActiveHours);
   const [isScheduling, setIsScheduling] = useState(false);
   const [isTaskModalOpen, setIsTaskModalOpen] = useState(false);
+  const [lockedEvents, setLockedEvents] = useState<Event[]>([]);
+  const [isLockedEventModalOpen, setIsLockedEventModalOpen] = useState(false);
 
   const loadTemplate = (template: TemplateScenario) => {
     setTasks(
@@ -90,13 +101,29 @@ function SchedulerPage() {
     setLogs([]);
   };
 
+  const addLockedEvent = (
+    eventData: Omit<Event, 'id' | 'locked' | 'taskId'>
+  ) => {
+    const newEvent: Event = {
+      ...eventData,
+      id: `locked-${Date.now()}`,
+      locked: true,
+      taskId: 'locked',
+    };
+    setLockedEvents([...lockedEvents, newEvent]);
+  };
+
+  const deleteLockedEvent = (id: string) => {
+    setLockedEvents(lockedEvents.filter((event) => event.id !== id));
+  };
+
   const handleSchedule = async () => {
     setIsScheduling(true);
-    // Add a small delay to show loading state
     setTimeout(() => {
       const { events: scheduledEvents, logs: scheduleLogs } = scheduleTasks(
         tasks,
-        activeHours
+        activeHours,
+        lockedEvents
       );
       setEvents(scheduledEvents);
       setLogs(scheduleLogs);
@@ -182,6 +209,46 @@ function SchedulerPage() {
                   onDeleteTask={deleteTask}
                   onSchedule={handleSchedule}
                 />
+                {/* Locked Events Section */}
+                <div className="mt-8">
+                  <div className="mb-2 flex items-center gap-2">
+                    <LockIcon className="h-5 w-5 text-dynamic-blue" />
+                    <span className="font-semibold">Locked Events</span>
+                    <button
+                      className="ml-auto rounded bg-dynamic-blue px-3 py-1 text-xs text-white transition hover:bg-dynamic-blue/80"
+                      onClick={() => setIsLockedEventModalOpen(true)}
+                    >
+                      Add Locked Event
+                    </button>
+                  </div>
+                  {lockedEvents.length === 0 ? (
+                    <div className="text-sm text-muted-foreground">
+                      No locked events
+                    </div>
+                  ) : (
+                    <ul className="space-y-2">
+                      {lockedEvents.map((event) => (
+                        <li
+                          key={event.id}
+                          className="flex items-center gap-3 rounded border border-dynamic-blue/30 bg-dynamic-blue/5 px-3 py-2"
+                        >
+                          <LockIcon className="h-4 w-4 text-dynamic-blue" />
+                          <span className="font-medium">{event.name}</span>
+                          <span className="text-xs text-muted-foreground">
+                            {event.range.start.format('YYYY-MM-DD HH:mm')} -{' '}
+                            {event.range.end.format('YYYY-MM-DD HH:mm')}
+                          </span>
+                          <button
+                            className="ml-auto text-xs text-destructive hover:underline"
+                            onClick={() => deleteLockedEvent(event.id)}
+                          >
+                            Remove
+                          </button>
+                        </li>
+                      ))}
+                    </ul>
+                  )}
+                </div>
               </div>
               <div>
                 <TemplateScenarios
@@ -190,6 +257,24 @@ function SchedulerPage() {
                 />
               </div>
             </div>
+            {/* Locked Event Modal */}
+            {isLockedEventModalOpen && (
+              <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/30">
+                <div className="w-full max-w-md rounded-lg bg-white p-6 shadow-lg">
+                  <h3 className="mb-4 flex items-center gap-2 text-lg font-semibold">
+                    <LockIcon className="h-5 w-5 text-dynamic-blue" /> Add
+                    Locked Event
+                  </h3>
+                  <LockedEventForm
+                    onAdd={(event) => {
+                      addLockedEvent(event);
+                      setIsLockedEventModalOpen(false);
+                    }}
+                    onCancel={() => setIsLockedEventModalOpen(false)}
+                  />
+                </div>
+              </div>
+            )}
           </TabsContent>
 
           <TabsContent value="schedule" className="space-y-6">
@@ -332,12 +417,127 @@ function SchedulerPage() {
         {/* Task Modal */}
         <TaskModal
           isOpen={isTaskModalOpen}
-          onClose={() => setIsTaskModalOpen(false)}
-          onAddTask={addTask}
+          onCloseAction={() => setIsTaskModalOpen(false)}
+          onAddTaskAction={addTask}
         />
       </div>
     </TooltipProvider>
   );
 }
 
+function LockedEventForm({
+  onAdd,
+  onCancel,
+}: {
+  onAdd: (event: Omit<Event, 'id' | 'locked' | 'taskId'>) => void;
+  onCancel: () => void;
+}) {
+  const [name, setName] = useState('');
+  const [date, setDate] = useState(dayjs().format('YYYY-MM-DD'));
+  const [startTime, setStartTime] = useState('09:00');
+  const [endTime, setEndTime] = useState('10:00');
+  const [category, setCategory] = useState<'work' | 'personal' | 'meeting'>(
+    'work'
+  );
+  const [error, setError] = useState<string | null>(null);
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    const start = dayjs(`${date}T${startTime}`);
+    const end = dayjs(`${date}T${endTime}`);
+    if (!name.trim()) {
+      setError('Name is required');
+      return;
+    }
+    if (!start.isValid() || !end.isValid() || end.isBefore(start)) {
+      setError('Invalid date or time');
+      return;
+    }
+    setError(null);
+    onAdd({
+      name,
+      range: { start, end },
+      isPastDeadline: false,
+      partNumber: undefined,
+      totalParts: undefined,
+      category,
+    });
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className="space-y-4">
+      <div>
+        <Label>Name</Label>
+        <Input
+          value={name}
+          onChange={(e) => setName(e.target.value)}
+          placeholder="Event name"
+          required
+        />
+      </div>
+      <div className="grid grid-cols-2 gap-4">
+        <div>
+          <Label>Date</Label>
+          <Input
+            type="date"
+            value={date}
+            onChange={(e) => setDate(e.target.value)}
+            required
+          />
+        </div>
+        <div>
+          <Label>Category</Label>
+          <Select
+            value={category}
+            onValueChange={(v) =>
+              setCategory(v as 'work' | 'personal' | 'meeting')
+            }
+          >
+            <SelectTrigger>
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="work">💼 Work</SelectItem>
+              <SelectItem value="personal">🏠 Personal</SelectItem>
+              <SelectItem value="meeting">👥 Meeting</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+      </div>
+      <div className="grid grid-cols-2 gap-4">
+        <div>
+          <Label>Start Time</Label>
+          <Input
+            type="time"
+            value={startTime}
+            onChange={(e) => setStartTime(e.target.value)}
+            required
+          />
+        </div>
+        <div>
+          <Label>End Time</Label>
+          <Input
+            type="time"
+            value={endTime}
+            onChange={(e) => setEndTime(e.target.value)}
+            required
+          />
+        </div>
+      </div>
+      {error && <div className="text-sm text-destructive">{error}</div>}
+      <div className="flex justify-end gap-2">
+        <Button type="button" variant="ghost" onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button
+          type="submit"
+          className="bg-dynamic-blue text-white hover:bg-dynamic-blue/80"
+        >
+          Add
+        </Button>
+      </div>
+    </form>
+  );
+}
+
 export default SchedulerPage;
diff --git a/packages/ai/src/scheduling/algorithm.test.ts b/packages/ai/src/scheduling/algorithm.test.ts
index 39fb0b609..8d897bc6a 100644
--- a/packages/ai/src/scheduling/algorithm.test.ts
+++ b/packages/ai/src/scheduling/algorithm.test.ts
@@ -1,3 +1,4 @@
+import { scheduleTasks } from './algorithm';
 import { defaultActiveHours, defaultTasks } from './default';
 import dayjs from 'dayjs';
 import { describe, expect, it } from 'vitest';
@@ -25,6 +26,7 @@ describe('Scheduling Algorithm', () => {
           start: dayjs('2024-01-01T10:00:00'),
           end: dayjs('2024-01-01T11:00:00'),
         },
+        category: 'work',
       };
 
       expect(event.id).toBe('event-1');
@@ -62,6 +64,7 @@ describe('Scheduling Algorithm', () => {
               start: dayjs('2024-01-01T14:00:00'),
               end: dayjs('2024-01-01T15:00:00'),
             },
+            category: 'work',
           },
         ],
       };
@@ -173,12 +176,60 @@ describe('Scheduling Algorithm', () => {
     });
   });
 
-  // TODO: Add tests for the schedule function once it's implemented
   describe('schedule function', () => {
-    it.todo('should schedule tasks without conflicts');
-    it.todo('should respect active hours constraints');
-    it.todo('should handle overlapping events');
-    it.todo('should return empty schedule for no tasks');
-    it.todo('should prioritize tasks based on duration');
+    it('should schedule a non-splittable task as a single block if possible', () => {
+      const tasks = [
+        {
+          id: 'single-block',
+          name: 'Non-splittable Task',
+          duration: 2,
+          minDuration: 1,
+          maxDuration: 2,
+          category: 'work' as const,
+          events: [],
+          allowSplit: false,
+        },
+      ];
+      const result = scheduleTasks(tasks, defaultActiveHours, []);
+      expect(result.events?.length).toBe(1);
+      expect(result.events?.[0]?.name).toBe('Non-splittable Task');
+      expect(result.events?.[0]?.partNumber).toBeUndefined();
+    });
+
+    it('should not schedule a non-splittable task if no single block is available', () => {
+      const tasks = [
+        {
+          id: 'single-block-fail',
+          name: 'Non-splittable Task',
+          duration: 10, // longer than any available slot
+          minDuration: 1,
+          maxDuration: 10,
+          category: 'work' as const,
+          events: [],
+          allowSplit: false,
+        },
+      ];
+      const result = scheduleTasks(tasks, defaultActiveHours, []);
+      expect(result.events?.length).toBe(0);
+      expect(result.logs?.some((log: any) => log.type === 'error')).toBe(true);
+    });
+
+    it('should split a task if allowSplit is true or undefined and needed', () => {
+      const tasks = [
+        {
+          id: 'splittable',
+          name: 'Splittable Task',
+          duration: 6,
+          minDuration: 1,
+          maxDuration: 2,
+          category: 'work' as const,
+          events: [],
+          allowSplit: true,
+        },
+      ];
+      const result = scheduleTasks(tasks, defaultActiveHours, []);
+      expect(result.events?.length).toBeGreaterThan(1);
+      expect(result.events?.[0]?.name).toContain('Part 1');
+    });
   });
 });
diff --git a/packages/ai/src/scheduling/algorithm.ts b/packages/ai/src/scheduling/algorithm.ts
index 6eda1e631..ac57c2298 100644
--- a/packages/ai/src/scheduling/algorithm.ts
+++ b/packages/ai/src/scheduling/algorithm.ts
@@ -46,19 +46,26 @@ function ensureMinimumDuration(hours: number): number {
 
 export const scheduleTasks = (
   tasks: Task[],
-  activeHours: ActiveHours = defaultActiveHours
+  activeHours: ActiveHours = defaultActiveHours,
+  lockedEvents: Event[] = []
 ): ScheduleResult => {
-  const scheduledEvents: Event[] = [];
+  // Start with locked events in the schedule
+  const scheduledEvents: Event[] = lockedEvents.map((e) => ({
+    ...e,
+    locked: true,
+  }));
   const logs: Log[] = [];
 
-  // Sort tasks by deadline, earliest first. Tasks without a deadline are considered last.
-  const sortedTasks = [...tasks].sort((a, b) => {
-    if (a.deadline && b.deadline)
-      return a.deadline.isBefore(b.deadline) ? -1 : 1;
-    if (a.deadline) return -1; // a has a deadline, b doesn't
-    if (b.deadline) return 1; // b has a deadline, a doesn't
-    return 0; // no deadlines
-  });
+  // Prepare a working pool of tasks with remaining duration
+  const taskPool = tasks.map((task) => ({
+    ...task,
+    duration: hoursToQuarterHours(task.duration),
+    minDuration: ensureMinimumDuration(task.minDuration),
+    maxDuration: hoursToQuarterHours(task.maxDuration),
+    remaining: hoursToQuarterHours(task.duration),
+    nextPart: 1,
+    scheduledParts: 0,
+  }));
 
   // Initialize available times for each category - start from now
   const now = dayjs();
@@ -68,172 +75,226 @@ export const scheduleTasks = (
     meeting: getNextAvailableTime(activeHours.meeting, now),
   };
 
-  for (const task of sortedTasks) {
-    const categoryHours = activeHours[task.category];
+  // Sort by deadline, earliest first (for fairness in each round)
+  taskPool.sort((a, b) => {
+    if (a.deadline && b.deadline)
+      return a.deadline.isBefore(b.deadline) ? -1 : 1;
+    if (a.deadline) return -1;
+    if (b.deadline) return 1;
+    return 0;
+  });
 
-    if (!categoryHours || categoryHours.length === 0) {
-      logs.push({
-        type: 'error',
-        message: `No ${task.category} hours defined for task "${task.name}".`,
-      });
-      continue;
-    }
+  let attempts = 0;
+  const maxAttempts = 2000; // Prevent infinite loops
 
-    // Ensure task durations are in 15-minute increments
-    const adjustedTask = {
-      ...task,
-      duration: hoursToQuarterHours(task.duration),
-      minDuration: ensureMinimumDuration(task.minDuration),
-      maxDuration: hoursToQuarterHours(task.maxDuration),
-    };
-
-    let remainingDuration = adjustedTask.duration;
-    let partNumber = 1;
-    const taskParts: Event[] = [];
-    let attempts = 0;
-    const maxAttempts = 50; // Prevent infinite loops
-
-    while (remainingDuration > 0 && attempts < maxAttempts) {
-      attempts++;
-
-      const availableSlots = getAvailableSlots(
-        availableTimes[task.category],
-        categoryHours,
-        scheduledEvents
-      );
-
-      if (availableSlots.length === 0) {
-        // Move to next day and try again
-        availableTimes[task.category] = availableTimes[task.category]
-          .add(1, 'day')
-          .startOf('day');
-        availableTimes[task.category] = getNextAvailableTime(
-          categoryHours,
-          availableTimes[task.category]
-        );
+  while (taskPool.some((t) => t.remaining > 0) && attempts < maxAttempts) {
+    attempts++;
+    let anyScheduled = false;
 
+    for (const task of taskPool) {
+      if (task.remaining <= 0) continue;
+      const categoryHours = activeHours[task.category];
+      if (!categoryHours || categoryHours.length === 0) {
         logs.push({
-          type: 'warning',
-          message: `Moving task "${task.name}" to ${availableTimes[task.category].format('YYYY-MM-DD')} due to lack of available time slots.`,
+          type: 'error',
+          message: `No ${task.category} hours defined for task "${task.name}".`,
         });
+        task.remaining = 0;
         continue;
       }
 
-      const slot = availableSlots[0];
-      if (!slot) {
-        logs.push({
-          type: 'error',
-          message: `No valid slot found for task "${task.name}".`,
-        });
-        break;
+      // Non-splittable: try to schedule as a single block
+      if (task.allowSplit === false) {
+        if (task.scheduledParts > 0) continue; // Already tried
+        let scheduled = false;
+        let tryTime = availableTimes[task.category];
+        let blockAttempts = 0;
+        while (!scheduled && blockAttempts < 50) {
+          blockAttempts++;
+          const availableSlots = getAvailableSlots(
+            tryTime,
+            categoryHours,
+            scheduledEvents
+          );
+          const slot = availableSlots.find((slot) => {
+            const slotDuration = slot.end.diff(slot.start, 'hour', true);
+            return slotDuration >= task.duration;
+          });
+          if (slot) {
+            const partStart = roundToQuarterHour(slot.start, false);
+            const partEnd = partStart.add(task.duration, 'hour');
+            const newEvent: Event = {
+              id: `event-${task.id}`,
+              name: task.name,
+              range: { start: partStart, end: partEnd },
+              isPastDeadline: false,
+              taskId: task.id,
+            };
+            if (task.deadline && partEnd.isAfter(task.deadline)) {
+              newEvent.isPastDeadline = true;
+              logs.push({
+                type: 'warning',
+                message: `Task "${task.name}" is scheduled past its deadline of ${task.deadline.format('YYYY-MM-DD HH:mm')}.`,
+              });
+            }
+            scheduledEvents.push(newEvent);
+            availableTimes[task.category] = roundToQuarterHour(partEnd, true);
+            scheduled = true;
+            task.remaining = 0;
+            task.scheduledParts = 1;
+            anyScheduled = true;
+          } else {
+            tryTime = tryTime.add(1, 'day').startOf('day');
+            tryTime = getNextAvailableTime(categoryHours, tryTime);
+            logs.push({
+              type: 'warning',
+              message: `Moving task "${task.name}" to ${tryTime.format('YYYY-MM-DD')} due to lack of available time slots for non-splittable task.`,
+            });
+          }
+        }
+        if (!scheduled) {
+          logs.push({
+            type: 'error',
+            message: `Task "${task.name}" could not be scheduled as a single block after 50 attempts.`,
+          });
+          task.remaining = 0;
+        }
+        continue;
       }
 
-      const slotDuration = slot.end.diff(slot.start, 'hour', true);
-
-      // Calculate the duration for this part (in quarter-hour increments)
-      let partDuration = Math.min(remainingDuration, slotDuration);
-      partDuration = Math.min(partDuration, adjustedTask.maxDuration);
-      partDuration = Math.max(
-        partDuration,
-        Math.min(adjustedTask.minDuration, remainingDuration)
-      );
-
-      // Ensure part duration is in 15-minute increments
-      partDuration = hoursToQuarterHours(partDuration);
-
-      // If the remaining duration is less than minDuration and we can't fit it
-      if (
-        remainingDuration < adjustedTask.minDuration &&
-        partDuration < remainingDuration
-      ) {
-        // Try to extend the current part or find a larger slot
-        const extendedDuration = Math.min(
-          adjustedTask.minDuration,
-          slotDuration
+      // Splittable: try to schedule the next part
+      let scheduledPart = false;
+      let tryTime = availableTimes[task.category];
+      let splitAttempts = 0;
+      while (task.remaining > 0 && splitAttempts < 50 && !scheduledPart) {
+        splitAttempts++;
+        let availableSlots = getAvailableSlots(
+          tryTime,
+          categoryHours,
+          scheduledEvents
         );
-        if (extendedDuration >= adjustedTask.minDuration) {
-          partDuration = hoursToQuarterHours(extendedDuration);
-        } else {
+        // If deadline is set, filter out slots that end after the deadline
+        if (task.deadline) {
+          availableSlots = availableSlots.filter(
+            (slot) =>
+              slot.end.isBefore(task.deadline) || slot.end.isSame(task.deadline)
+          );
+        }
+        if (availableSlots.length === 0) {
+          // Move to next day and try again, unless deadline prevents it
+          const nextTime = tryTime.add(1, 'day').startOf('day');
+          if (task.deadline && nextTime.isAfter(task.deadline)) {
+            logs.push({
+              type: 'warning',
+              message: `No available slots before deadline for task "${task.name}". Skipping remaining duration.`,
+            });
+            task.remaining = 0;
+            break;
+          }
+          tryTime = getNextAvailableTime(categoryHours, nextTime);
+          continue;
+        }
+        const slot = availableSlots[0];
+        if (!slot) {
+          // Defensive: should not happen, but skip if no slot
+          break;
+        }
+        const slotDuration = slot.end.diff(slot.start, 'hour', true);
+        let partDuration = Math.min(task.remaining, slotDuration);
+        partDuration = Math.min(partDuration, task.maxDuration);
+        partDuration = Math.max(
+          partDuration,
+          Math.min(task.minDuration, task.remaining)
+        );
+        partDuration = hoursToQuarterHours(partDuration);
+        // If the remaining duration is less than minDuration and we can't fit it
+        if (
+          task.remaining < task.minDuration &&
+          partDuration < task.remaining
+        ) {
+          const extendedDuration = Math.min(task.minDuration, slotDuration);
+          if (extendedDuration >= task.minDuration) {
+            partDuration = hoursToQuarterHours(extendedDuration);
+          } else {
+            logs.push({
+              type: 'warning',
+              message: `Cannot schedule remaining ${task.remaining}h of task "${task.name}" due to minimum duration constraint (${task.minDuration}h).`,
+            });
+            task.remaining = 0;
+            break;
+          }
+        }
+        const partStart = roundToQuarterHour(slot.start, false);
+        const partEnd = partStart.add(partDuration, 'hour');
+        if (partEnd.isAfter(slot.end)) {
+          const adjustedDuration = slot.end.diff(partStart, 'hour', true);
+          if (adjustedDuration < task.minDuration) {
+            logs.push({
+              type: 'error',
+              message: `Cannot fit minimum duration for task "${task.name}" part ${task.nextPart}.`,
+            });
+            task.remaining = 0;
+            break;
+          }
+          partDuration = hoursToQuarterHours(adjustedDuration);
+        }
+        const finalPartEnd = partStart.add(partDuration, 'hour');
+        // If this part would end after the deadline, skip scheduling
+        if (task.deadline && finalPartEnd.isAfter(task.deadline)) {
           logs.push({
             type: 'warning',
-            message: `Cannot schedule remaining ${remainingDuration}h of task "${task.name}" due to minimum duration constraint (${adjustedTask.minDuration}h).`,
+            message: `Cannot schedule part of task "${task.name}" because it would end after the deadline (${task.deadline.format('YYYY-MM-DD HH:mm')}). Skipping remaining duration.`,
           });
+          task.remaining = 0;
           break;
         }
-      }
-
-      // Ensure the part start time is rounded to 15-minute increment
-      const partStart = roundToQuarterHour(slot.start, false);
-      const partEnd = partStart.add(partDuration, 'hour');
-
-      // Verify the end time doesn't exceed the slot
-      if (partEnd.isAfter(slot.end)) {
-        const adjustedDuration = slot.end.diff(partStart, 'hour', true);
-
-        if (adjustedDuration < adjustedTask.minDuration) {
+        const totalParts = Math.ceil(task.duration / task.maxDuration);
+        const newEvent: Event = {
+          id: `event-${task.id}-part-${task.nextPart}`,
+          name:
+            totalParts > 1
+              ? `${task.name} (Part ${task.nextPart}/${totalParts})`
+              : task.name,
+          range: { start: partStart, end: finalPartEnd },
+          isPastDeadline: false,
+          taskId: task.id,
+          partNumber: totalParts > 1 ? task.nextPart : undefined,
+          totalParts: totalParts > 1 ? totalParts : undefined,
+        };
+        if (task.deadline && finalPartEnd.isAfter(task.deadline)) {
+          newEvent.isPastDeadline = true;
           logs.push({
-            type: 'error',
-            message: `Cannot fit minimum duration for task "${task.name}" part ${partNumber}.`,
+            type: 'warning',
+            message: `Part ${task.nextPart} of task "${task.name}" is scheduled past its deadline of ${task.deadline.format('YYYY-MM-DD HH:mm')}.`,
           });
-          break;
         }
-
-        partDuration = hoursToQuarterHours(adjustedDuration);
+        scheduledEvents.push(newEvent);
+        tryTime = roundToQuarterHour(finalPartEnd, true);
+        availableTimes[task.category] = tryTime;
+        task.remaining -= partDuration;
+        task.scheduledParts++;
+        task.nextPart++;
+        anyScheduled = true;
+        scheduledPart = true;
       }
-
-      const finalPartEnd = partStart.add(partDuration, 'hour');
-      const totalParts = Math.ceil(
-        adjustedTask.duration / adjustedTask.maxDuration
-      );
-
-      const newEvent: Event = {
-        id: `event-${task.id}-part-${partNumber}`,
-        name:
-          totalParts > 1
-            ? `${task.name} (Part ${partNumber}/${totalParts})`
-            : task.name,
-        range: { start: partStart, end: finalPartEnd },
-        isPastDeadline: false,
-        taskId: task.id,
-        partNumber: totalParts > 1 ? partNumber : undefined,
-        totalParts: totalParts > 1 ? totalParts : undefined,
-      };
-
-      // Check if this part is past the deadline
-      if (task.deadline && finalPartEnd.isAfter(task.deadline)) {
-        newEvent.isPastDeadline = true;
-        logs.push({
-          type: 'warning',
-          message: `Part ${partNumber} of task "${task.name}" is scheduled past its deadline of ${task.deadline.format('YYYY-MM-DD HH:mm')}.`,
-        });
-      }
-
-      taskParts.push(newEvent);
-      scheduledEvents.push(newEvent);
-
-      remainingDuration -= partDuration;
-      availableTimes[task.category] = roundToQuarterHour(finalPartEnd, true);
-      partNumber++;
     }
 
-    if (attempts >= maxAttempts) {
-      logs.push({
-        type: 'error',
-        message: `Task "${task.name}" could not be fully scheduled after ${maxAttempts} attempts.`,
-      });
-    }
+    // If no task could be scheduled in this round, break to avoid infinite loop
+    if (!anyScheduled) break;
+  }
 
-    if (taskParts.length > 1) {
+  // Log split info and unscheduled warnings
+  for (const task of taskPool) {
+    if (task.scheduledParts > 1) {
       logs.push({
         type: 'warning',
-        message: `Task "${task.name}" has been split into ${taskParts.length} parts due to duration constraints and available time slots.`,
+        message: `Task "${task.name}" has been split into ${task.scheduledParts} parts due to duration constraints and available time slots.`,
       });
     }
-
-    if (remainingDuration > 0) {
+    if (task.remaining > 0) {
       logs.push({
         type: 'warning',
-        message: `Task "${task.name}" could not be fully scheduled. ${remainingDuration}h remaining.`,
+        message: `Task "${task.name}" could not be fully scheduled. ${task.remaining}h remaining.`,
       });
     }
   }
diff --git a/packages/ai/src/scheduling/default.ts b/packages/ai/src/scheduling/default.ts
index 7ec7efdfa..b2e528e14 100644
--- a/packages/ai/src/scheduling/default.ts
+++ b/packages/ai/src/scheduling/default.ts
@@ -31,5 +31,6 @@ export const defaultTasks: Task[] = [
     maxDuration: 2,
     category: 'work',
     events: [],
+    allowSplit: true,
   },
 ];
diff --git a/packages/ai/src/scheduling/templates.ts b/packages/ai/src/scheduling/templates.ts
index cced1a251..cf046dce7 100644
--- a/packages/ai/src/scheduling/templates.ts
+++ b/packages/ai/src/scheduling/templates.ts
@@ -14,6 +14,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 1,
         category: 'meeting',
         events: [],
+        allowSplit: false,
       },
       {
         id: 'basic-2',
@@ -23,6 +24,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 3,
         category: 'work',
         events: [],
+        allowSplit: false,
       },
       {
         id: 'basic-3',
@@ -32,6 +34,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 2,
         category: 'work',
         events: [],
+        allowSplit: false,
       },
     ],
   },
@@ -47,6 +50,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 2,
         category: 'work',
         events: [],
+        allowSplit: true,
       },
       {
         id: 'split-2',
@@ -56,6 +60,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 1.5,
         category: 'personal',
         events: [],
+        allowSplit: true,
       },
       {
         id: 'split-3',
@@ -65,6 +70,7 @@ export const templateScenarios: TemplateScenario[] = [
         maxDuration: 1,
         category: 'work',
         events: [],
+        allowSplit: true,
       },
     ],
   },
diff --git a/packages/ai/src/scheduling/types.ts b/packages/ai/src/scheduling/types.ts
index 46dfbc329..1e7957e82 100644
--- a/packages/ai/src/scheduling/types.ts
+++ b/packages/ai/src/scheduling/types.ts
@@ -13,6 +13,8 @@ export interface Event {
   taskId: string;
   partNumber?: number;
   totalParts?: number;
+  locked?: boolean;
+  category?: 'work' | 'personal' | 'meeting';
 }
 
 export interface Task {
@@ -24,6 +26,7 @@ export interface Task {
   category: 'work' | 'personal' | 'meeting';
   events: Event[];
   deadline?: dayjs.Dayjs;
+  allowSplit?: boolean;
 }
 
 export interface ActiveHours {