diff --git a/backend/api.py b/backend/api.py
index 33b9d28..960d814 100644
--- a/backend/api.py
+++ b/backend/api.py
@@ -1,19 +1,13 @@
-from fastapi import APIRouter, Depends, HTTPException, Body
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, and_, or_
 from datetime import datetime, timedelta
-import pytz
-from typing import List, Union
 
-from backend.database import get_db, Task, Event, WeeklyTaskException
-from backend.models import (
-    TaskCreate, EventCreate, ScheduleResponse, ScheduleItem,
-    TaskResponse, EventResponse, UpdateRequest
-)
-from backend.utils import (
-    get_week_range, check_event_overlap, get_weekday_from_date,
-    materialize_weekly_tasks, format_date_russian
-)
+import pytz
+from fastapi import APIRouter, Depends, HTTPException, Body
+from sqlalchemy import and_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.database import get_db, Task, Event, WeeklyTaskException, EventException
+from backend.models import TaskCreate, EventCreate, ScheduleResponse, ScheduleItem, UpdateRequest
+from backend.utils import check_event_overlap, get_weekday_from_date, materialize_weekly_tasks, materialize_events
 
 router = APIRouter()
 
@@ -26,16 +20,18 @@ async def get_schedule(
     to_date: str,
     db: AsyncSession = Depends(get_db)
 ):
-    """Получить расписание в диапазоне дат"""
+    """Получить расписание в диапазоне дат."""
     try:
         from_dt = datetime.strptime(from_date, "%Y-%m-%d").date()
         to_dt = datetime.strptime(to_date, "%Y-%m-%d").date()
     except ValueError:
         raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")
-    
+
+    if to_dt < from_dt:
+        raise HTTPException(status_code=400, detail="to_date must be greater than or equal to from_date")
+
     items = []
-    
-    # Получаем разовые tasks
+
     result = await db.execute(
         select(Task).where(
             and_(
@@ -51,34 +47,14 @@ async def get_schedule(
             kind="task",
             id=task.id,
             date=task.date,
+            source_date=task.date,
             title=task.title,
             repeat_weekly=False
         ))
-    
-    # Получаем events
-    result = await db.execute(
-        select(Event).where(
-            and_(
-                Event.date >= from_date,
-                Event.date <= to_date
-            )
-        )
-    )
-    events = result.scalars().all()
-    for event in events:
-        items.append(ScheduleItem(
-            kind="event",
-            id=event.id,
-            date=event.date,
-            title=event.title,
-            start_time=event.start_time,
-            duration_min=event.duration_min
-        ))
-    
-    # Материализуем weekly tasks
-    weekly_tasks = await materialize_weekly_tasks(db, from_date, to_date)
-    items.extend(weekly_tasks)
-    
+
+    items.extend(await materialize_weekly_tasks(db, from_date, to_date))
+    items.extend(await materialize_events(db, from_date, to_date))
+
     return ScheduleResponse(items=items)
 
 
@@ -88,74 +64,69 @@ async def create_item(
     data: dict = Body(...),
     db: AsyncSession = Depends(get_db)
 ):
-    """Создать task или event"""
+    """Создать task или event."""
     if kind == "task":
         try:
             task = TaskCreate(**data)
-        except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Invalid task data: {e}")
-        
-        # Создаём основную task
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Invalid task data: {exc}")
+
         new_task = Task(
             date=task.date,
             title=task.title,
             repeat_weekly=task.repeat_weekly
         )
-        
         if task.repeat_weekly:
-            weekday = get_weekday_from_date(task.date)
-            new_task.weekday = weekday
-        
+            new_task.weekday = get_weekday_from_date(task.date)
+
         db.add(new_task)
         await db.commit()
         await db.refresh(new_task)
-        
-        # Копирование на другие дни недели
+
         if task.copy_to_weekdays and not task.repeat_weekly:
             base_date = datetime.strptime(task.date, "%Y-%m-%d").date()
             base_weekday = base_date.weekday()
             for target_weekday in task.copy_to_weekdays:
-                # Вычисляем дату целевого дня недели в той же неделе
-                days_diff = (target_weekday - base_weekday) % 7
-                if days_diff > 0:  # только будущие дни
-                    target_date = base_date + timedelta(days=days_diff)
-                    copy_task = Task(
-                        date=target_date.strftime("%Y-%m-%d"),
-                        title=task.title,
-                        repeat_weekly=False
-                    )
-                    db.add(copy_task)
+                days_diff = target_weekday - base_weekday
+                if days_diff <= 0:
+                    continue
+                target_date = base_date + timedelta(days=days_diff)
+                db.add(Task(
+                    date=target_date.strftime("%Y-%m-%d"),
+                    title=task.title,
+                    repeat_weekly=False
+                ))
             await db.commit()
-        
+
         return {"id": new_task.id, "kind": "task"}
-    
-    elif kind == "event":
+
+    if kind == "event":
         try:
             event = EventCreate(**data)
-        except Exception as e:
-            raise HTTPException(status_code=400, detail=f"Invalid event data: {e}")
-        
-        # Проверка пересечений
-        overlap = await check_event_overlap(
-            db, event.date, event.start_time, event.duration_min, None
-        )
+        except Exception as exc:
+            raise HTTPException(status_code=400, detail=f"Invalid event data: {exc}")
+
+        overlap = await check_event_overlap(db, event.date, event.start_time, event.duration_min, None)
         if overlap:
             raise HTTPException(status_code=400, detail="Нельзя добавить: пересечение по времени")
-        
+
         new_event = Event(
             date=event.date,
             start_time=event.start_time,
             duration_min=event.duration_min,
-            title=event.title
+            title=event.title,
+            repeat_weekly=event.repeat_weekly
         )
+        if event.repeat_weekly:
+            new_event.weekday = get_weekday_from_date(event.date)
+
         db.add(new_event)
         await db.commit()
         await db.refresh(new_event)
-        
+
         return {"id": new_event.id, "kind": "event"}
-    
-    else:
-        raise HTTPException(status_code=400, detail="Invalid kind. Use 'task' or 'event'")
+
+    raise HTTPException(status_code=400, detail="Invalid kind. Use 'task' or 'event'")
 
 
 @router.put("/events/{item_id}")
@@ -164,130 +135,200 @@ async def update_item(
     update: UpdateRequest,
     db: AsyncSession = Depends(get_db)
 ):
-    """Обновить task или event"""
-    # Пробуем найти как task
+    """Обновить task или event."""
     result = await db.execute(select(Task).where(Task.id == item_id))
     task = result.scalar_one_or_none()
-    
+
     if task:
         if task.repeat_weekly and update.scope == "one_date":
-            # Создаём исключение для конкретной даты
-            weekday = get_weekday_from_date(task.date)
+            occurrence_date = update.occurrence_date or task.date
+            result = await db.execute(
+                select(WeeklyTaskException).where(
+                    and_(
+                        WeeklyTaskException.task_id == task.id,
+                        WeeklyTaskException.date == occurrence_date
+                    )
+                )
+            )
+            for existing_exception in result.scalars().all():
+                await db.delete(existing_exception)
             exception = WeeklyTaskException(
-                weekday=weekday,
-                date=task.date,
-                action="replace" if update.title else "delete",
-                replacement_title=update.title
+                task_id=task.id,
+                weekday=get_weekday_from_date(occurrence_date),
+                date=occurrence_date,
+                action="replace",
+                replacement_title=update.title or task.title,
+                replacement_date=update.date or occurrence_date
             )
             db.add(exception)
             await db.commit()
             return {"success": True, "action": "exception_created"}
-        
+
         if update.title:
-            if task.repeat_weekly and update.scope == "series":
-                # Обновляем все weekly tasks с этим weekday
-                await db.execute(
-                    Task.__table__.update()
-                    .where(Task.weekday == task.weekday)
-                    .values(title=update.title)
-                )
-            else:
-                task.title = update.title
-        
+            task.title = update.title
+        if update.date:
+            task.date = update.date
+            if task.repeat_weekly:
+                task.weekday = get_weekday_from_date(update.date)
+
         await db.commit()
         return {"success": True}
-    
-    # Пробуем найти как event
+
     result = await db.execute(select(Event).where(Event.id == item_id))
     event = result.scalar_one_or_none()
-    
-    if event:
-        new_date = update.date or event.date
-        new_start_time = update.start_time or event.start_time
-        new_duration = update.duration_min or event.duration_min
-        
-        # Проверка пересечений
+    if not event:
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    if event.repeat_weekly and update.scope == "one_date":
+        occurrence_date = update.occurrence_date or event.date
+        replacement_date = update.date or occurrence_date
+        replacement_start_time = update.start_time or event.start_time
+        replacement_duration = update.duration_min or event.duration_min
+
         overlap = await check_event_overlap(
-            db, new_date, new_start_time, new_duration, item_id
+            db,
+            replacement_date,
+            replacement_start_time,
+            replacement_duration,
+            item_id,
+            occurrence_date=occurrence_date
         )
         if overlap:
             raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")
-        
-        if update.title:
-            event.title = update.title
-        if update.date:
-            event.date = update.date
-        if update.start_time:
-            event.start_time = update.start_time
-        if update.duration_min:
-            event.duration_min = update.duration_min
-        
+
+        result = await db.execute(
+            select(EventException).where(
+                and_(
+                    EventException.event_id == event.id,
+                    EventException.date == occurrence_date
+                )
+            )
+        )
+        for existing_exception in result.scalars().all():
+            await db.delete(existing_exception)
+
+        db.add(EventException(
+            event_id=event.id,
+            date=occurrence_date,
+            action="replace",
+            replacement_title=update.title or event.title,
+            replacement_date=replacement_date,
+            replacement_start_time=replacement_start_time,
+            replacement_duration_min=replacement_duration
+        ))
         await db.commit()
-        return {"success": True}
-    
-    raise HTTPException(status_code=404, detail="Item not found")
+        return {"success": True, "action": "exception_created"}
+
+    new_date = update.date or event.date
+    new_start_time = update.start_time or event.start_time
+    new_duration = update.duration_min or event.duration_min
+
+    overlap = await check_event_overlap(db, new_date, new_start_time, new_duration, item_id)
+    if overlap:
+        raise HTTPException(status_code=400, detail="Нельзя изменить: пересечение по времени")
+
+    if update.title:
+        event.title = update.title
+    if update.date:
+        event.date = update.date
+        if event.repeat_weekly:
+            event.weekday = get_weekday_from_date(update.date)
+    if update.start_time:
+        event.start_time = update.start_time
+    if update.duration_min:
+        event.duration_min = update.duration_min
+
+    await db.commit()
+    return {"success": True}
 
 
 @router.delete("/events/{item_id}")
 async def delete_item(
     item_id: int,
     scope: str = None,
+    occurrence_date: str = None,
     db: AsyncSession = Depends(get_db)
 ):
-    """Удалить task или event"""
-    # Пробуем найти как task
+    """Удалить task или event."""
     result = await db.execute(select(Task).where(Task.id == item_id))
     task = result.scalar_one_or_none()
-    
+
     if task:
-        if task.repeat_weekly:
-            if scope == "one_date":
-                # Создаём исключение на удаление
-                weekday = get_weekday_from_date(task.date)
-                exception = WeeklyTaskException(
-                    weekday=weekday,
-                    date=task.date,
-                    action="delete"
+        if task.repeat_weekly and scope == "one_date":
+            delete_date = occurrence_date or task.date
+            result = await db.execute(
+                select(WeeklyTaskException).where(
+                    and_(
+                        WeeklyTaskException.task_id == task.id,
+                        WeeklyTaskException.date == delete_date
+                    )
                 )
-                db.add(exception)
-                await db.commit()
-                return {"success": True, "action": "exception_created"}
-            elif scope == "series":
-                # Удаляем все weekly tasks с этим weekday
-                await db.execute(
-                    Task.__table__.delete().where(Task.weekday == task.weekday)
-                )
-                await db.commit()
-                return {"success": True}
-        
+            )
+            for existing_exception in result.scalars().all():
+                await db.delete(existing_exception)
+            db.add(WeeklyTaskException(
+                task_id=task.id,
+                weekday=get_weekday_from_date(delete_date),
+                date=delete_date,
+                action="delete"
+            ))
+            await db.commit()
+            return {"success": True, "action": "exception_created"}
+
+        if task.repeat_weekly and scope == "series":
+            result = await db.execute(select(WeeklyTaskException).where(WeeklyTaskException.task_id == task.id))
+            for exception in result.scalars().all():
+                await db.delete(exception)
+
         await db.delete(task)
         await db.commit()
         return {"success": True}
-    
-    # Пробуем найти как event
+
     result = await db.execute(select(Event).where(Event.id == item_id))
     event = result.scalar_one_or_none()
-    
-    if event:
-        await db.delete(event)
+    if not event:
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    if event.repeat_weekly and scope == "one_date":
+        delete_date = occurrence_date or event.date
+        result = await db.execute(
+            select(EventException).where(
+                and_(
+                    EventException.event_id == event.id,
+                    EventException.date == delete_date
+                )
+            )
+        )
+        for existing_exception in result.scalars().all():
+            await db.delete(existing_exception)
+        db.add(EventException(
+            event_id=event.id,
+            date=delete_date,
+            action="delete"
+        ))
         await db.commit()
-        return {"success": True}
-    
-    raise HTTPException(status_code=404, detail="Item not found")
+        return {"success": True, "action": "exception_created"}
+
+    if event.repeat_weekly and scope == "series":
+        result = await db.execute(select(EventException).where(EventException.event_id == event.id))
+        for exception in result.scalars().all():
+            await db.delete(exception)
+
+    await db.delete(event)
+    await db.commit()
+    return {"success": True}
 
 
 @router.get("/backup")
 async def backup_database():
-    """Создать backup базы данных"""
-    import shutil
+    """Создать backup базы данных."""
     import os
-    from datetime import datetime
-    
+    import shutil
+
     db_path = os.getenv("DATABASE_PATH", "data/schedule.db")
     backup_path = f"{db_path}.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    
+
     if os.path.exists(db_path):
         shutil.copy2(db_path, backup_path)
         return {"success": True, "backup_path": backup_path}
     return {"success": False, "error": "Database not found"}
-
diff --git a/backend/database.py b/backend/database.py
index 5e46855..e1ab0e2 100644
--- a/backend/database.py
+++ b/backend/database.py
@@ -1,6 +1,6 @@
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy.orm import declarative_base, sessionmaker
-from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text
+from sqlalchemy.orm import declarative_base
+from sqlalchemy import Column, Integer, String, Boolean, text
 import os
 
 Base = declarative_base()
@@ -31,16 +31,33 @@ class Event(Base):
     start_time = Column(String)  # HH:MM
     duration_min = Column(Integer, nullable=False)
     title = Column(String, nullable=False)
+    repeat_weekly = Column(Boolean, default=False)
+    weekday = Column(Integer)  # 0=Monday, 6=Sunday, только для weekly events
 
 
 class WeeklyTaskException(Base):
     __tablename__ = "weekly_task_exceptions"
     
     id = Column(Integer, primary_key=True, index=True)
+    task_id = Column(Integer, index=True)
     weekday = Column(Integer, nullable=False)  # 0=Monday, 6=Sunday
     date = Column(String, nullable=False)  # YYYY-MM-DD
     action = Column(String, nullable=False)  # "delete" или "replace"
     replacement_title = Column(String)  # для action="replace"
+    replacement_date = Column(String)  # для переноса/замены одного вхождения
+
+
+class EventException(Base):
+    __tablename__ = "event_exceptions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    event_id = Column(Integer, index=True, nullable=False)
+    date = Column(String, nullable=False)
+    action = Column(String, nullable=False)  # "delete" или "replace"
+    replacement_title = Column(String)
+    replacement_date = Column(String)
+    replacement_start_time = Column(String)
+    replacement_duration_min = Column(Integer)
 
 
 class TelegramUser(Base):
@@ -53,6 +70,37 @@ class TelegramUser(Base):
 async def init_db():
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
+        await _run_migrations(conn)
+
+
+async def _run_migrations(conn):
+    table_columns = await _get_table_columns(conn)
+
+    task_columns = table_columns.get("tasks", set())
+    if "weekday" not in task_columns:
+        await conn.execute(text("ALTER TABLE tasks ADD COLUMN weekday INTEGER"))
+
+    event_columns = table_columns.get("events", set())
+    if "repeat_weekly" not in event_columns:
+        await conn.execute(text("ALTER TABLE events ADD COLUMN repeat_weekly BOOLEAN DEFAULT 0"))
+    if "weekday" not in event_columns:
+        await conn.execute(text("ALTER TABLE events ADD COLUMN weekday INTEGER"))
+
+    exception_columns = table_columns.get("weekly_task_exceptions", set())
+    if "task_id" not in exception_columns:
+        await conn.execute(text("ALTER TABLE weekly_task_exceptions ADD COLUMN task_id INTEGER"))
+    if "replacement_date" not in exception_columns:
+        await conn.execute(text("ALTER TABLE weekly_task_exceptions ADD COLUMN replacement_date TEXT"))
+
+
+async def _get_table_columns(conn):
+    table_names = ["tasks", "events", "weekly_task_exceptions", "event_exceptions"]
+    columns = {}
+    for table_name in table_names:
+        result = await conn.exec_driver_sql(f"PRAGMA table_info({table_name})")
+        rows = result.fetchall()
+        columns[table_name] = {row[1] for row in rows}
+    return columns
 
 
 async def get_db():
@@ -61,4 +109,3 @@ async def get_db():
             yield session
         finally:
             await session.close()
-
diff --git a/backend/models.py b/backend/models.py
index fc9eded..406dcde 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -1,7 +1,5 @@
 from pydantic import BaseModel
 from typing import Optional, Literal
-from datetime import date
-
 class TaskCreate(BaseModel):
     date: str  # YYYY-MM-DD
     title: str
@@ -13,6 +11,7 @@ class EventCreate(BaseModel):
     start_time: str  # HH:MM
     duration_min: int
     title: str
+    repeat_weekly: bool = False
 
 class TaskResponse(BaseModel):
     id: int
@@ -28,11 +27,13 @@ class EventResponse(BaseModel):
     duration_min: int
     title: str
     kind: Literal["event"] = "event"
+    repeat_weekly: bool = False
 
 class ScheduleItem(BaseModel):
     kind: Literal["task", "event"]
     id: int
     date: str
+    source_date: Optional[str] = None
     title: str
     start_time: Optional[str] = None
     duration_min: Optional[int] = None
@@ -46,5 +47,5 @@ class UpdateRequest(BaseModel):
     date: Optional[str] = None
     start_time: Optional[str] = None
     duration_min: Optional[int] = None
+    occurrence_date: Optional[str] = None
     scope: Optional[Literal["one_date", "series"]] = None  # для weekly tasks
-
diff --git a/backend/utils.py b/backend/utils.py
index 2f4d585..6d39c11 100644
--- a/backend/utils.py
+++ b/backend/utils.py
@@ -3,97 +3,182 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, and_
 import pytz
 
-from backend.database import Task, Event, WeeklyTaskException
+from backend.database import Task, Event, WeeklyTaskException, EventException
 from backend.models import ScheduleItem
 
 TZ = pytz.timezone("Europe/Moscow")
 
 
 def get_weekday_from_date(date_str: str) -> int:
-    """Получить день недели (0=Monday, 6=Sunday) из даты"""
+    """Получить день недели (0=Monday, 6=Sunday) из даты."""
     dt = datetime.strptime(date_str, "%Y-%m-%d")
     return dt.weekday()
 
 
 def get_week_range(date_str: str = None):
-    """Получить диапазон дат недели (понедельник-воскресенье)"""
+    """Получить диапазон дат недели (понедельник-воскресенье)."""
     if date_str:
         base_date = datetime.strptime(date_str, "%Y-%m-%d").date()
     else:
         base_date = datetime.now(TZ).date()
-    
-    # Находим понедельник
+
     days_since_monday = base_date.weekday()
     monday = base_date - timedelta(days=days_since_monday)
     sunday = monday + timedelta(days=6)
-    
+
     return monday.strftime("%Y-%m-%d"), sunday.strftime("%Y-%m-%d")
 
 
 def format_date_russian(date_str: str) -> str:
-    """Форматировать дату в русском формате: 'Вторник, 2 декабря'"""
+    """Форматировать дату в русском формате: 'Вторник, 2 декабря'."""
     dt = datetime.strptime(date_str, "%Y-%m-%d")
-    
+
     weekdays = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"]
     months = [
         "января", "февраля", "марта", "апреля", "мая", "июня",
         "июля", "августа", "сентября", "октября", "ноября", "декабря"
     ]
-    
+
     weekday = weekdays[dt.weekday()]
     month = months[dt.month - 1]
-    
+
     return f"{weekday}, {dt.day} {month}"
 
 
+def _time_to_minutes(value: str) -> int:
+    hour, minute = map(int, value.split(":"))
+    return hour * 60 + minute
+
+
 async def check_event_overlap(
     db: AsyncSession,
     date: str,
     start_time: str,
     duration_min: int,
-    exclude_id: int = None
+    exclude_id: int = None,
+    occurrence_date: str = None
 ) -> bool:
-    """Проверить пересечение по времени с другими events"""
-    # Парсим время начала
-    start_hour, start_min = map(int, start_time.split(":"))
-    start_minutes = start_hour * 60 + start_min
+    """Проверить пересечение по времени с разовыми и weekly events."""
+    start_minutes = _time_to_minutes(start_time)
     end_minutes = start_minutes + duration_min
-    
-    # Получаем все events на эту дату
-    query = select(Event).where(Event.date == date)
-    if exclude_id:
-        query = query.where(Event.id != exclude_id)
-    
-    result = await db.execute(query)
-    events = result.scalars().all()
-    
+
+    events = await materialize_events(db, date, date)
+
     for event in events:
-        ev_start_hour, ev_start_min = map(int, event.start_time.split(":"))
-        ev_start_minutes = ev_start_hour * 60 + ev_start_min
-        ev_end_minutes = ev_start_minutes + event.duration_min
-        
-        # Проверка пересечения интервалов
+        if exclude_id and event.id == exclude_id and (occurrence_date is None or event.date == occurrence_date):
+            continue
+
+        ev_start_minutes = _time_to_minutes(event.start_time)
+        ev_end_minutes = ev_start_minutes + (event.duration_min or 0)
         if not (end_minutes <= ev_start_minutes or start_minutes >= ev_end_minutes):
             return True
-    
+
     return False
 
 
+async def materialize_events(
+    db: AsyncSession,
+    from_date: str,
+    to_date: str
+) -> list[ScheduleItem]:
+    items = []
+
+    result = await db.execute(
+        select(Event).where(
+            and_(
+                Event.date >= from_date,
+                Event.date <= to_date,
+                Event.repeat_weekly == False
+            )
+        )
+    )
+    one_off_events = result.scalars().all()
+    for event in one_off_events:
+        items.append(ScheduleItem(
+            kind="event",
+            id=event.id,
+            date=event.date,
+            source_date=event.date,
+            title=event.title,
+            start_time=event.start_time,
+            duration_min=event.duration_min,
+            repeat_weekly=False
+        ))
+
+    result = await db.execute(select(Event).where(Event.repeat_weekly == True))
+    weekly_events = result.scalars().all()
+    if not weekly_events:
+        return items
+
+    result = await db.execute(
+        select(EventException).where(
+            and_(
+                EventException.date >= from_date,
+                EventException.date <= to_date
+            )
+        )
+    )
+    exceptions = result.scalars().all()
+    exception_dict = {(ex.event_id, ex.date): ex for ex in exceptions}
+
+    from_dt = datetime.strptime(from_date, "%Y-%m-%d").date()
+    to_dt = datetime.strptime(to_date, "%Y-%m-%d").date()
+    current_date = from_dt
+
+    while current_date <= to_dt:
+        date_str = current_date.strftime("%Y-%m-%d")
+        weekday = current_date.weekday()
+
+        for event in weekly_events:
+            base_date = datetime.strptime(event.date, "%Y-%m-%d").date()
+            if current_date < base_date or event.weekday != weekday:
+                continue
+
+            exception = exception_dict.get((event.id, date_str))
+            if exception:
+                if exception.action == "delete":
+                    continue
+                items.append(ScheduleItem(
+                    kind="event",
+                    id=event.id,
+                    date=exception.replacement_date or date_str,
+                    source_date=date_str,
+                    title=exception.replacement_title or event.title,
+                    start_time=exception.replacement_start_time or event.start_time,
+                    duration_min=exception.replacement_duration_min or event.duration_min,
+                    repeat_weekly=True
+                ))
+                continue
+
+            items.append(ScheduleItem(
+                kind="event",
+                id=event.id,
+                date=date_str,
+                source_date=date_str,
+                title=event.title,
+                start_time=event.start_time,
+                duration_min=event.duration_min,
+                repeat_weekly=True
+            ))
+
+        current_date += timedelta(days=1)
+
+    return items
+
+
 async def materialize_weekly_tasks(
     db: AsyncSession,
     from_date: str,
     to_date: str
 ) -> list[ScheduleItem]:
-    """Материализовать weekly tasks в диапазоне дат"""
-    from backend.database import Task, WeeklyTaskException
-    
+    """Материализовать weekly tasks в диапазоне дат."""
     items = []
-    
-    # Получаем все weekly tasks
+
     result = await db.execute(select(Task).where(Task.repeat_weekly == True))
     weekly_tasks = result.scalars().all()
-    
-    # Получаем все исключения
+    if not weekly_tasks:
+        return items
+
     result = await db.execute(
         select(WeeklyTaskException).where(
             and_(
@@ -103,44 +188,52 @@ async def materialize_weekly_tasks(
         )
     )
     exceptions = result.scalars().all()
-    exception_dict = {(ex.date, ex.weekday): ex for ex in exceptions}
-    
+    exception_dict = {}
+    for ex in exceptions:
+        if ex.task_id is not None:
+            exception_dict[(ex.task_id, ex.date)] = ex
+        else:
+            exception_dict[(None, ex.date, ex.weekday)] = ex
+
     from_dt = datetime.strptime(from_date, "%Y-%m-%d").date()
     to_dt = datetime.strptime(to_date, "%Y-%m-%d").date()
-    
+
     current_date = from_dt
     while current_date <= to_dt:
         date_str = current_date.strftime("%Y-%m-%d")
         weekday = current_date.weekday()
-        
+
         for task in weekly_tasks:
-            if task.weekday == weekday:
-                # Проверяем исключения
-                ex_key = (date_str, weekday)
-                if ex_key in exception_dict:
-                    exception = exception_dict[ex_key]
-                    if exception.action == "delete":
-                        continue  # Пропускаем эту дату
-                    elif exception.action == "replace":
-                        items.append(ScheduleItem(
-                            kind="task",
-                            id=task.id,
-                            date=date_str,
-                            title=exception.replacement_title,
-                            repeat_weekly=True
-                        ))
-                        continue
-                
-                # Обычная weekly task
+            base_date = datetime.strptime(task.date, "%Y-%m-%d").date()
+            if current_date < base_date or task.weekday != weekday:
+                continue
+
+            exception = exception_dict.get((task.id, date_str))
+            if not exception:
+                exception = exception_dict.get((None, date_str, weekday))
+
+            if exception:
+                if exception.action == "delete":
+                    continue
                 items.append(ScheduleItem(
                     kind="task",
                     id=task.id,
-                    date=date_str,
-                    title=task.title,
+                    date=exception.replacement_date or date_str,
+                    source_date=date_str,
+                    title=exception.replacement_title or task.title,
                     repeat_weekly=True
                 ))
-        
-        current_date += timedelta(days=1)
-    
-    return items
+                continue
 
+            items.append(ScheduleItem(
+                kind="task",
+                id=task.id,
+                date=date_str,
+                source_date=date_str,
+                title=task.title,
+                repeat_weekly=True
+            ))
+
+        current_date += timedelta(days=1)
+
+    return items
diff --git a/frontend/admin/index.html b/frontend/admin/index.html
index c7fd182..8e51da9 100644
--- a/frontend/admin/index.html
+++ b/frontend/admin/index.html
@@ -3,37 +3,58 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Админка - Расписание</title>
-    <link rel="stylesheet" href="/admin/static/style.css">
+    <title>Админка расписания</title>
+    <link rel="stylesheet" href="/admin/static/style.css?v=3">
 </head>
 <body>
-    <div class="container">
-        <header>
-            <h1>Админка расписания</h1>
-            <div class="week-navigation">
-                <button id="prev-week">← Предыдущая неделя</button>
-                <span id="week-range"></span>
-                <button id="next-week">Следующая неделя →</button>
+    <div class="app-shell">
+        <header class="hero">
+            <div>
+                <p class="eyebrow">Schedule Studio</p>
+                <h1>Редактор расписания</h1>
+                <p class="hero-copy">Планируйте задачи и занятия на несколько недель вперед, меняйте серии целиком и переносите встречи прямо мышкой по сетке времени.</p>
+            </div>
+            <div class="hero-actions">
+                <button id="today-btn" class="btn btn-secondary">Текущая неделя</button>
+                <button id="add-task-btn" class="btn btn-secondary">Новая задача</button>
+                <button id="add-event-btn" class="btn btn-primary">Новое занятие</button>
             </div>
         </header>
-        
-        <div class="actions">
-            <button id="add-task-btn" class="btn btn-primary">➕ Добавить задачу</button>
-            <button id="add-event-btn" class="btn btn-primary">➕ Добавить занятие</button>
+
+        <section class="toolbar">
+            <div class="week-navigation">
+                <button id="prev-week" class="nav-btn">← Назад</button>
+                <div>
+                    <div class="toolbar-label">Видимый диапазон</div>
+                    <div id="week-range" class="range-title"></div>
+                </div>
+                <button id="next-week" class="nav-btn">Вперед →</button>
+            </div>
+            <div class="legend">
+                <span class="legend-chip task-chip">Задачи</span>
+                <span class="legend-chip event-chip">Занятия</span>
+                <span class="legend-chip recurring-chip">Цикличные</span>
+            </div>
+        </section>
+
+        <section class="hint-panel">
+            <span>Клик по дню добавляет занятие.</span>
+            <span>`Ctrl/Cmd + клик` открывает создание задачи.</span>
+            <span>Перетаскивайте карточки занятий на новое время или другой день.</span>
+        </section>
+
+        <div class="schedule-scroll">
+            <main id="schedule-grid" class="schedule-grid"></main>
         </div>
-        
-        <div id="schedule-grid" class="schedule-grid"></div>
     </div>
-    
-    <!-- Модальное окно для добавления/редактирования -->
+
     <div id="modal" class="modal">
         <div class="modal-content">
-            <span class="close">&times;</span>
+            <button class="close" type="button" aria-label="Закрыть">×</button>
             <div id="modal-body"></div>
         </div>
     </div>
-    
-    <script src="/admin/static/script.js"></script>
+
+    <script src="/admin/static/script.js?v=3"></script>
 </body>
 </html>
-
diff --git a/frontend/admin/static/script.js b/frontend/admin/static/script.js
index c6833d4..b1a3d61 100644
--- a/frontend/admin/static/script.js
+++ b/frontend/admin/static/script.js
@@ -1,13 +1,20 @@
-let currentWeekStart = null;
+const MOSCOW_TIMEZONE = 'Europe/Moscow';
+const WEEKDAYS = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
+const MONTHS = ['января', 'февраля', 'марта', 'апреля', 'мая', 'июня', 'июля', 'августа', 'сентября', 'октября', 'ноября', 'декабря'];
+const VIEW_WEEKS = 4;
+const SLOT_MINUTES = 15;
+const START_HOUR = 8;
+const END_HOUR = 20;
+const PIXELS_PER_MINUTE = 0.8;
 
-const weekdays = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
-const weekdaysShort = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'];
+let currentRangeStart = null;
+let scheduleItems = [];
+let itemIndex = new Map();
 
-function getTodayInLondon() {
-    // Получаем текущую дату в таймзоне London
+function getMoscowDateString() {
     const now = new Date();
     const formatter = new Intl.DateTimeFormat('en-CA', {
-        timeZone: 'Europe/Moscow',
+        timeZone: MOSCOW_TIMEZONE,
         year: 'numeric',
         month: '2-digit',
         day: '2-digit'
@@ -15,227 +22,41 @@ function getTodayInLondon() {
     return formatter.format(now);
 }
 
-function getWeekStart(dateStr = null) {
-    if (!dateStr) {
-        dateStr = getTodayInLondon();
-    }
-    // Создаем дату из строки YYYY-MM-DD в локальном времени
-    const [year, month, day] = dateStr.split('-').map(Number);
-    const date = new Date(year, month - 1, day);
-    // getDay() возвращает 0=воскресенье, 1=понедельник, ..., 6=суббота
-    // Находим понедельник текущей недели
-    const dayOfWeek = date.getDay();
-    // Если воскресенье (0), идем на 6 дней назад, иначе на (dayOfWeek-1) дней назад
-    const diff = dayOfWeek === 0 ? -6 : -(dayOfWeek - 1);
-    const monday = new Date(date);
-    monday.setDate(date.getDate() + diff);
-    // Проверяем, что получился понедельник
-    if (monday.getDay() !== 1) {
-        console.error('Error: getWeekStart did not return Monday!', monday.getDay());
-    }
-    // Возвращаем в формате YYYY-MM-DD
-    const yearStr = monday.getFullYear();
-    const monthStr = String(monday.getMonth() + 1).padStart(2, '0');
-    const dayStr = String(monday.getDate()).padStart(2, '0');
-    return `${yearStr}-${monthStr}-${dayStr}`;
+function parseISODate(value) {
+    const [year, month, day] = value.split('-').map(Number);
+    return new Date(year, month - 1, day);
 }
 
-function formatDate(dateStr) {
-    // Создаем дату из строки YYYY-MM-DD в локальном времени
-    const [year, month, day] = dateStr.split('-').map(Number);
-    const date = new Date(year, month - 1, day);
-    // getDay() возвращает 0=воскресенье, 1=понедельник, ..., 6=суббота
-    // Конвертируем в формат где 0=понедельник, 6=воскресенье
-    const jsDay = date.getDay();
-    const weekdayIndex = jsDay === 0 ? 6 : jsDay - 1; // 0=пн, 6=вс
-    return `${weekdaysShort[weekdayIndex]}, ${date.getDate()}`;
+function formatISODate(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
 }
 
-function formatDateFull(dateStr) {
-    // Создаем дату из строки YYYY-MM-DD в локальном времени
-    const [year, month, day] = dateStr.split('-').map(Number);
-    const date = new Date(year, month - 1, day);
-    const months = ['января', 'февраля', 'марта', 'апреля', 'мая', 'июня', 
-                    'июля', 'августа', 'сентября', 'октября', 'ноября', 'декабря'];
-    // getDay() возвращает 0=воскресенье, 1=понедельник, ..., 6=суббота
-    // Конвертируем в формат где 0=понедельник, 6=воскресенье
-    const jsDay = date.getDay();
-    const weekdayIndex = jsDay === 0 ? 6 : jsDay - 1; // 0=пн, 6=вс
-    return `${weekdays[weekdayIndex]}, ${date.getDate()} ${months[date.getMonth()]}`;
+function addDays(dateStr, days) {
+    const date = parseISODate(dateStr);
+    date.setDate(date.getDate() + days);
+    return formatISODate(date);
 }
 
-function getWeekDates(startDate) {
-    // startDate должен быть понедельником (в формате YYYY-MM-DD)
-    const dates = [];
-    // Создаем дату из строки в локальном времени
-    const [year, month, day] = startDate.split('-').map(Number);
-    const start = new Date(year, month - 1, day);
-    // Убеждаемся, что это понедельник
-    const dayOfWeek = start.getDay();
-    if (dayOfWeek !== 1) {
-        // Если не понедельник, находим понедельник
-        const diff = dayOfWeek === 0 ? -6 : -(dayOfWeek - 1);
-        start.setDate(start.getDate() + diff);
-    }
-    // Возвращаем 7 дней: понедельник - воскресенье
-    const baseDate = new Date(start);
-    for (let i = 0; i < 7; i++) {
-        const date = new Date(baseDate);
-        date.setDate(baseDate.getDate() + i);
-        // Форматируем в YYYY-MM-DD
-        const yearStr = date.getFullYear();
-        const monthStr = String(date.getMonth() + 1).padStart(2, '0');
-        const dayStr = String(date.getDate()).padStart(2, '0');
-        dates.push(`${yearStr}-${monthStr}-${dayStr}`);
-    }
-    // Проверяем, что первый день - понедельник, последний - воскресенье
-    const [firstYear, firstMonth, firstDayNum] = dates[0].split('-').map(Number);
-    const firstDate = new Date(firstYear, firstMonth - 1, firstDayNum);
-    const [lastYear, lastMonth, lastDayNum] = dates[6].split('-').map(Number);
-    const lastDate = new Date(lastYear, lastMonth - 1, lastDayNum);
-    const firstDay = firstDate.getDay();
-    const lastDay = lastDate.getDay();
-    if (firstDay !== 1 || lastDay !== 0) {
-        console.error('Error: Week should start on Monday and end on Sunday!', {
-            first: dates[0], firstDay,
-            last: dates[6], lastDay
-        });
-    }
-    return dates;
+function startOfWeek(dateStr = null) {
+    const base = parseISODate(dateStr || getMoscowDateString());
+    const jsDay = base.getDay();
+    const diff = jsDay === 0 ? -6 : 1 - jsDay;
+    base.setDate(base.getDate() + diff);
+    return formatISODate(base);
 }
 
-async function loadSchedule() {
-    // Убеждаемся, что currentWeekStart - это понедельник
-    if (!currentWeekStart) {
-        currentWeekStart = getWeekStart();
-    } else {
-        currentWeekStart = getWeekStart(currentWeekStart);
-    }
-    
-    const weekDates = getWeekDates(currentWeekStart);
-    const fromDate = weekDates[0];
-    const toDate = weekDates[6];
-    
-    // Проверяем, что неделя начинается с понедельника и заканчивается воскресеньем
-    const [mondayYear, mondayMonth, mondayDay] = weekDates[0].split('-').map(Number);
-    const monday = new Date(mondayYear, mondayMonth - 1, mondayDay);
-    const [sundayYear, sundayMonth, sundayDay] = weekDates[6].split('-').map(Number);
-    const sunday = new Date(sundayYear, sundayMonth - 1, sundayDay);
-    if (monday.getDay() !== 1 || sunday.getDay() !== 0) {
-        console.error('Week should start on Monday and end on Sunday! Fixing...', {
-            monday: weekDates[0], mondayDay: monday.getDay(),
-            sunday: weekDates[6], sundayDay: sunday.getDay()
-        });
-        // Исправляем автоматически без рекурсии
-        currentWeekStart = getWeekStart();
-        const correctedWeekDates = getWeekDates(currentWeekStart);
-        // Используем исправленные даты напрямую
-        const correctedFromDate = correctedWeekDates[0];
-        const correctedToDate = correctedWeekDates[6];
-        
-        try {
-            const response = await fetch(`/api/schedule?from_date=${correctedFromDate}&to_date=${correctedToDate}`);
-            const data = await response.json();
-            renderSchedule(correctedWeekDates, data.items);
-            document.getElementById('week-range').textContent = 
-                `${formatDateFull(correctedWeekDates[0])} - ${formatDateFull(correctedWeekDates[6])}`;
-            updateWeekNavigationButtons();
-        } catch (error) {
-            console.error('Error loading schedule:', error);
-        }
-        return;
-    }
-    
-    try {
-        const response = await fetch(`/api/schedule?from_date=${fromDate}&to_date=${toDate}`);
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const data = await response.json();
-        
-        if (!data.items) {
-            console.error('Invalid response format:', data);
-            return;
-        }
-        
-        renderSchedule(weekDates, data.items);
-        
-        // Обновляем заголовок недели
-        document.getElementById('week-range').textContent = 
-            `${formatDateFull(weekDates[0])} - ${formatDateFull(weekDates[6])}`;
-        
-        // Обновляем кнопки навигации
-        updateWeekNavigationButtons();
-    } catch (error) {
-        console.error('Error loading schedule:', error);
-    }
+function getVisibleDates() {
+    return Array.from({ length: VIEW_WEEKS * 7 }, (_, index) => addDays(currentRangeStart, index));
 }
 
-function renderSchedule(weekDates, items) {
-    const grid = document.getElementById('schedule-grid');
-    if (!grid) {
-        console.error('Schedule grid not found!');
-        return;
-    }
-    grid.innerHTML = '';
-    
-    weekDates.forEach(dateStr => {
-        const dayItems = items.filter(item => item.date === dateStr);
-        
-        const column = document.createElement('div');
-        column.className = 'day-column';
-        
-        column.innerHTML = `
-            <div class="day-header">${formatDateFull(dateStr)}</div>
-            <div class="day-items" data-date="${dateStr}">
-                ${renderDayItems(dayItems)}
-            </div>
-        `;
-        
-        grid.appendChild(column);
-    });
-}
-
-function renderDayItems(items) {
-    if (items.length === 0) {
-        return '<div style="color: #999; font-style: italic; padding: 10px;">Нет записей</div>';
-    }
-    
-    const tasks = items.filter(item => item.kind === 'task');
-    const events = items.filter(item => item.kind === 'event');
-    
-    let html = '';
-    
-    // Tasks
-    tasks.forEach(task => {
-        html += `
-            <div class="item task" data-id="${task.id}" data-kind="task">
-                <div class="item-title">${task.title}</div>
-                ${task.repeat_weekly ? '<div style="font-size: 11px; color: #FF9800;">Повторяется</div>' : ''}
-                <div class="item-actions">
-                    <button class="btn-edit" onclick="editItem(${task.id}, 'task')">Изменить</button>
-                    <button class="btn-delete" onclick="deleteItem(${task.id}, 'task')">Удалить</button>
-                </div>
-            </div>
-        `;
-    });
-    
-    // Events
-    events.sort((a, b) => a.start_time.localeCompare(b.start_time)).forEach(event => {
-        const endTime = calculateEndTime(event.start_time, event.duration_min);
-        html += `
-            <div class="item event" data-id="${event.id}" data-kind="event">
-                <div class="item-time">${event.start_time}-${endTime}</div>
-                <div class="item-title">${event.title}</div>
-                <div class="item-actions">
-                    <button class="btn-edit" onclick="editItem(${event.id}, 'event')">Изменить</button>
-                    <button class="btn-delete" onclick="deleteItem(${event.id}, 'event')">Удалить</button>
-                </div>
-            </div>
-        `;
-    });
-    
-    return html;
+function formatDayLabel(dateStr) {
+    const date = parseISODate(dateStr);
+    const weekday = WEEKDAYS[(date.getDay() + 6) % 7];
+    return {
+        title: `${weekday}, ${date.getDate()} ${MONTHS[date.getMonth()]}`,
+        short: weekday.slice(0, 2),
+        monthDay: `${date.getDate()} ${MONTHS[date.getMonth()]}`
+    };
 }
 
 function calculateEndTime(startTime, durationMin) {
@@ -246,6 +67,268 @@ function calculateEndTime(startTime, durationMin) {
     return `${String(endHour).padStart(2, '0')}:${String(endMinute).padStart(2, '0')}`;
 }
 
+function timeToMinutes(time) {
+    const [hour, minute] = time.split(':').map(Number);
+    return hour * 60 + minute;
+}
+
+function minutesToTime(totalMinutes) {
+    const hour = Math.floor(totalMinutes / 60);
+    const minute = totalMinutes % 60;
+    return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
+function rebuildItemIndex() {
+    itemIndex = new Map();
+    scheduleItems.forEach((item) => {
+        itemIndex.set(`${item.kind}:${item.id}:${item.source_date || item.date}`, item);
+    });
+}
+
+async function loadSchedule() {
+    if (!currentRangeStart) {
+        currentRangeStart = startOfWeek();
+    }
+
+    const fromDate = currentRangeStart;
+    const toDate = addDays(currentRangeStart, VIEW_WEEKS * 7 - 1);
+
+    const response = await fetch(`/api/schedule?from_date=${fromDate}&to_date=${toDate}`);
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.detail || 'Не удалось загрузить расписание');
+    }
+
+    const data = await response.json();
+    scheduleItems = data.items || [];
+    rebuildItemIndex();
+    renderSchedule();
+}
+
+function renderSchedule() {
+    const grid = document.getElementById('schedule-grid');
+    const dates = getVisibleDates();
+    const today = getMoscowDateString();
+
+    grid.innerHTML = dates.map((dateStr) => {
+        const dayItems = scheduleItems.filter((item) => item.date === dateStr);
+        const tasks = dayItems.filter((item) => item.kind === 'task');
+        const events = dayItems
+            .filter((item) => item.kind === 'event')
+            .sort((a, b) => a.start_time.localeCompare(b.start_time));
+        const label = formatDayLabel(dateStr);
+        const weekNumber = Math.floor(dates.indexOf(dateStr) / 7) + 1;
+
+        return `
+            <section class="day-card ${dateStr === today ? 'is-today' : ''}">
+                <div class="day-header">
+                    <div>
+                        <h2 class="day-title">${label.title}</h2>
+                        <div class="day-subtitle">Неделя ${weekNumber} в текущем окне</div>
+                    </div>
+                    <div class="day-badge">${dateStr === today ? 'Сегодня' : label.short}</div>
+                </div>
+
+                <div class="task-section">
+                    <div class="section-label">Задачи</div>
+                    <div class="task-list">
+                        ${tasks.map(renderTaskCard).join('')}
+                    </div>
+                </div>
+
+                <div class="section-label">Занятия</div>
+                ${renderTimeline(dateStr, events)}
+            </section>
+        `;
+    }).join('');
+
+    document.getElementById('week-range').textContent = `${formatDayLabel(dates[0]).title} - ${formatDayLabel(dates[dates.length - 1]).title}`;
+    bindInteractiveHandlers();
+}
+
+function renderTaskCard(task) {
+    return `
+        <article class="task-item" data-item-key="${task.kind}:${task.id}:${task.date}">
+            <div class="task-title">${escapeHtml(task.title)}</div>
+            <div class="meta-text">${task.repeat_weekly ? 'Цикличная задача, обновления можно применить ко всей серии.' : 'Разовая задача.'}</div>
+            <div class="item-actions">
+                <button class="item-action edit" data-action="edit" data-kind="task" data-id="${task.id}" data-date="${task.source_date || task.date}">Изменить</button>
+                <button class="item-action delete" data-action="delete" data-kind="task" data-id="${task.id}" data-date="${task.source_date || task.date}">Удалить</button>
+            </div>
+        </article>
+    `;
+}
+
+function renderTimeline(dateStr, events) {
+    const hours = Array.from({ length: END_HOUR - START_HOUR + 1 }, (_, index) => START_HOUR + index);
+
+    return `
+        <div class="timeline">
+            <div class="timeline-dropzone" data-drop-date="${dateStr}">
+                ${hours.map((hour, index) => `
+                    <div class="timeline-hour" style="top:${index * 60 * PIXELS_PER_MINUTE}px;">
+                        <span class="timeline-hour-label">${String(hour).padStart(2, '0')}:00</span>
+                    </div>
+                `).join('')}
+                ${events.map((event) => renderEventBlock(event)).join('')}
+            </div>
+        </div>
+    `;
+}
+
+function renderEventBlock(event) {
+    const startMinutes = timeToMinutes(event.start_time) - START_HOUR * 60;
+    const top = Math.max(0, startMinutes * PIXELS_PER_MINUTE);
+    const height = Math.max(42, event.duration_min * PIXELS_PER_MINUTE);
+    const endTime = calculateEndTime(event.start_time, event.duration_min);
+    return `
+        <article
+            class="event-block ${event.repeat_weekly ? 'recurring' : ''}"
+            draggable="true"
+            data-kind="event"
+            data-id="${event.id}"
+            data-date="${event.source_date || event.date}"
+            style="top:${top}px;height:${height}px;"
+        >
+            <div class="event-time">${event.start_time} - ${endTime}</div>
+            <div class="event-title">${escapeHtml(event.title)}</div>
+            <div class="meta-text" style="color: rgba(255,255,255,0.82);">${event.repeat_weekly ? 'Цикличное занятие' : 'Разовое занятие'}</div>
+            <div class="item-actions">
+                <button class="item-action edit" data-action="edit" data-kind="event" data-id="${event.id}" data-date="${event.source_date || event.date}">Изменить</button>
+                <button class="item-action delete" data-action="delete" data-kind="event" data-id="${event.id}" data-date="${event.source_date || event.date}">Удалить</button>
+            </div>
+        </article>
+    `;
+}
+
+function bindInteractiveHandlers() {
+    document.removeEventListener('click', clearActiveItems);
+    document.addEventListener('click', clearActiveItems);
+
+    document.querySelectorAll('[data-action="edit"]').forEach((button) => {
+        button.addEventListener('click', (event) => {
+            event.stopPropagation();
+            openEditModal(button.dataset.kind, Number(button.dataset.id), button.dataset.date);
+        });
+    });
+
+    document.querySelectorAll('[data-action="delete"]').forEach((button) => {
+        button.addEventListener('click', (event) => {
+            event.stopPropagation();
+            deleteItem(button.dataset.kind, Number(button.dataset.id), button.dataset.date);
+        });
+    });
+
+    document.querySelectorAll('.task-item').forEach((item) => {
+        item.addEventListener('click', (event) => {
+            event.stopPropagation();
+            toggleActiveItem(item);
+        });
+    });
+
+    document.querySelectorAll('.event-block').forEach((block) => {
+        block.addEventListener('click', (event) => {
+            event.stopPropagation();
+            toggleActiveItem(block);
+        });
+    });
+
+    document.querySelectorAll('.day-card').forEach((card, index) => {
+        card.addEventListener('click', (event) => {
+            if (event.target.closest('button, .event-block, .task-item')) {
+                return;
+            }
+            const targetDate = getVisibleDates()[index];
+            if (event.ctrlKey || event.metaKey) {
+                showTaskModal({ date: targetDate });
+                return;
+            }
+            showEventModal({ date: targetDate });
+        });
+    });
+
+    document.querySelectorAll('.event-block').forEach((block) => {
+        block.addEventListener('dragstart', handleDragStart);
+        block.addEventListener('dragend', () => block.classList.remove('dragging'));
+    });
+
+    document.querySelectorAll('.timeline-dropzone').forEach((zone) => {
+        zone.addEventListener('dragover', (event) => event.preventDefault());
+        zone.addEventListener('drop', handleEventDrop);
+    });
+}
+
+function clearActiveItems() {
+    document.querySelectorAll('.task-item.is-active, .event-block.is-active').forEach((item) => {
+        item.classList.remove('is-active');
+    });
+}
+
+function toggleActiveItem(element) {
+    const isActive = element.classList.contains('is-active');
+    clearActiveItems();
+    if (!isActive) {
+        element.classList.add('is-active');
+    }
+}
+
+function handleDragStart(event) {
+    const block = event.currentTarget;
+    block.classList.add('dragging');
+    event.dataTransfer.setData('text/plain', JSON.stringify({
+        id: Number(block.dataset.id),
+        occurrenceDate: block.dataset.date
+    }));
+}
+
+async function handleEventDrop(event) {
+    event.preventDefault();
+    const raw = event.dataTransfer.getData('text/plain');
+    if (!raw) {
+        return;
+    }
+
+    const payload = JSON.parse(raw);
+    const item = itemIndex.get(`event:${payload.id}:${payload.occurrenceDate}`);
+    if (!item) {
+        return;
+    }
+
+    const rect = event.currentTarget.getBoundingClientRect();
+    const relativeY = Math.max(0, Math.min(rect.height, event.clientY - rect.top));
+    const minutesFromStart = Math.round((relativeY / PIXELS_PER_MINUTE) / SLOT_MINUTES) * SLOT_MINUTES;
+    const clampedMinutes = Math.min((END_HOUR - START_HOUR) * 60 - item.duration_min, Math.max(0, minutesFromStart));
+    const newTime = minutesToTime(START_HOUR * 60 + clampedMinutes);
+    const newDate = event.currentTarget.dataset.dropDate;
+
+    let scope = null;
+    if (item.repeat_weekly) {
+        scope = promptRecurringScope('Переместить только это занятие или всю серию?', true);
+        if (!scope) {
+            return;
+        }
+    }
+
+    await saveItemUpdate('event', item.id, {
+        occurrence_date: item.source_date || item.date,
+        date: newDate,
+        start_time: newTime,
+        duration_min: item.duration_min,
+        scope
+    });
+}
+
+function promptRecurringScope(message, allowCancel = false) {
+    const answer = window.prompt(`${message}\nВведите "1" для одного вхождения, "2" для всей серии.${allowCancel ? ' Оставьте пустым для отмены.' : ''}`, '2');
+    if (!answer && allowCancel) {
+        return null;
+    }
+    if (answer === '1') {
+        return 'one_date';
+    }
+    return 'series';
+}
+
 function showModal(content) {
     document.getElementById('modal-body').innerHTML = content;
     document.getElementById('modal').style.display = 'block';
@@ -255,388 +338,265 @@ function closeModal() {
     document.getElementById('modal').style.display = 'none';
 }
 
-function showAddTaskModal(selectedDate = null) {
-    const today = getTodayInLondon();
-    const todayWeekStart = getWeekStart(today);
-    const nextWeekStart = new Date(todayWeekStart + 'T00:00:00');
-    nextWeekStart.setDate(nextWeekStart.getDate() + 7);
-    const nextWeekStartStr = nextWeekStart.toISOString().split('T')[0];
-    
-    // Ограничиваем выбор дат: только текущая и следующая неделя
-    const minDate = todayWeekStart;
-    const maxDate = new Date(nextWeekStartStr + 'T00:00:00');
-    maxDate.setDate(maxDate.getDate() + 6); // Воскресенье следующей недели
-    const maxDateStr = maxDate.toISOString().split('T')[0];
-    
-    const selectedDateObj = selectedDate ? new Date(selectedDate + 'T00:00:00') : new Date(today + 'T00:00:00');
-    // getDay() возвращает 0=воскресенье, 1=понедельник, ..., 6=суббота
-    // Конвертируем в формат 0=понедельник, 6=воскресенье
-    const jsWeekday = selectedDateObj.getDay();
-    const selectedWeekday = jsWeekday === 0 ? 6 : jsWeekday - 1; // 0=пн, 6=вс
-    const remainingWeekdays = [];
-    
-    // Оставшиеся дни недели после выбранного (среда=2, четверг=3, пятница=4, суббота=5, воскресенье=6)
-    for (let i = selectedWeekday + 1; i <= 6; i++) {
-        remainingWeekdays.push(i);
+function buildScopeSelector(item) {
+    if (!item.repeat_weekly) {
+        return '';
     }
-    
-    const content = `
-        <h2>Добавить задачу</h2>
-        <form id="add-task-form">
-            <div class="form-group">
-                <label>Дата:</label>
-                <input type="date" id="task-date" value="${selectedDate || today}" min="${minDate}" max="${maxDateStr}" required>
+    return `
+        <div class="form-group full">
+            <label>Куда применить изменение</label>
+            <div class="scope-row">
+                <label class="scope-card">
+                    <input type="radio" name="edit-scope" value="series" checked>
+                    <span>
+                        <strong>Ко всей серии</strong><br>
+                        Изменение сразу применяется ко всем будущим одинаковым занятиям или задачам.
+                    </span>
+                </label>
+                <label class="scope-card">
+                    <input type="radio" name="edit-scope" value="one_date">
+                    <span>
+                        <strong>Только к этому дню</strong><br>
+                        Создается исключение, а остальная серия остается без изменений.
+                    </span>
+                </label>
             </div>
-            <div class="form-group">
-                <label>Название:</label>
-                <textarea id="task-title" required></textarea>
-            </div>
-            <div class="form-group">
-                <div class="checkbox-group">
-                    <input type="checkbox" id="task-repeat-weekly">
-                    <label for="task-repeat-weekly">Повторять каждую неделю</label>
+        </div>
+    `;
+}
+
+function showTaskModal(initial = {}, item = null) {
+    const isEdit = Boolean(item);
+    showModal(`
+        <h2 class="modal-title">${isEdit ? 'Изменить задачу' : 'Новая задача'}</h2>
+        <p class="modal-subtitle">У задач нет времени. Для цикличной задачи достаточно включить еженедельный повтор, и она будет появляться автоматически в каждом запросе расписания.</p>
+        <form id="task-form">
+            <div class="form-grid">
+                <div class="form-group">
+                    <label>Дата</label>
+                    <input type="date" id="task-date" value="${escapeAttribute(initial.date || getMoscowDateString())}" required>
                 </div>
-            </div>
-            <div class="form-group" id="copy-weekdays-group" style="display: none;">
-                <label>Добавить на другие дни недели:</label>
-                <div class="weekdays-select">
-                    ${remainingWeekdays.map(day => {
-                        // day в формате 0=пн, 6=вс, но weekdaysShort использует JS формат (0=вс)
-                        const jsDay = day === 6 ? 0 : day + 1;
-                        return `
-                        <label>
-                            <input type="checkbox" name="copy-weekday" value="${day}">
-                            ${weekdaysShort[jsDay]}
-                        </label>
-                    `;
-                    }).join('')}
+                <div class="form-group">
+                    <label>Тип</label>
+                    <div class="checkbox-card">
+                        <label><input type="checkbox" id="task-repeat-weekly" ${initial.repeat_weekly ? 'checked' : ''}> Повторять каждую неделю</label>
+                    </div>
                 </div>
+                <div class="form-group full">
+                    <label>Название</label>
+                    <textarea id="task-title" required>${escapeHtml(initial.title || '')}</textarea>
+                </div>
+                ${isEdit ? buildScopeSelector(item) : ''}
             </div>
-            <div style="margin-top: 20px;">
-                <button type="submit" class="btn btn-primary">Добавить</button>
-                <button type="button" class="btn" onclick="closeModal()">Отмена</button>
+            <div class="actions-row">
+                <button type="submit" class="btn btn-primary">${isEdit ? 'Сохранить' : 'Добавить'}</button>
+                <button type="button" class="btn btn-secondary" id="cancel-task">Отмена</button>
             </div>
         </form>
-    `;
-    
-    showModal(content);
-    
-    document.getElementById('task-repeat-weekly').addEventListener('change', function() {
-        document.getElementById('copy-weekdays-group').style.display = 
-            this.checked ? 'none' : 'block';
-    });
-    
-    document.getElementById('add-task-form').addEventListener('submit', async (e) => {
-        e.preventDefault();
-        const date = document.getElementById('task-date').value;
-        const title = document.getElementById('task-title').value;
-        const repeatWeekly = document.getElementById('task-repeat-weekly').checked;
-        const copyWeekdays = Array.from(document.querySelectorAll('input[name="copy-weekday"]:checked'))
-            .map(cb => parseInt(cb.value));
-        
-        try {
-            const response = await fetch('/api/events?kind=task', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({
-                    date,
-                    title,
-                    repeat_weekly: repeatWeekly,
-                    copy_to_weekdays: copyWeekdays.length > 0 ? copyWeekdays : null
-                })
-            });
-            
-            if (response.ok) {
-                const result = await response.json();
-                console.log('Task created:', result);
-                closeModal();
-                // Небольшая задержка перед обновлением, чтобы БД успела сохранить
-                setTimeout(() => {
-                    loadSchedule().catch(err => console.error('Error reloading schedule:', err));
-                }, 100);
-            } else {
-                const error = await response.json();
-                console.error('Error creating task:', error);
-                alert('Ошибка: ' + (error.detail || 'Неизвестная ошибка'));
-            }
-        } catch (error) {
-            console.error('Exception creating task:', error);
-            alert('Ошибка при добавлении задачи: ' + error.message);
+    `);
+
+    document.getElementById('cancel-task').addEventListener('click', closeModal);
+    document.getElementById('task-form').addEventListener('submit', async (event) => {
+        event.preventDefault();
+        const payload = {
+            date: document.getElementById('task-date').value,
+            title: document.getElementById('task-title').value.trim(),
+            repeat_weekly: document.getElementById('task-repeat-weekly').checked
+        };
+
+        if (isEdit) {
+            payload.occurrence_date = item.source_date || item.date;
+            payload.scope = item.repeat_weekly ? document.querySelector('input[name="edit-scope"]:checked').value : null;
+            await saveItemUpdate('task', item.id, payload);
+        } else {
+            await createItem('task', payload);
         }
     });
 }
 
-function showAddEventModal(selectedDate = null) {
-    const today = getTodayInLondon();
-    const todayWeekStart = getWeekStart(today);
-    const nextWeekStart = new Date(todayWeekStart + 'T00:00:00');
-    nextWeekStart.setDate(nextWeekStart.getDate() + 7);
-    const nextWeekStartStr = nextWeekStart.toISOString().split('T')[0];
-    
-    // Ограничиваем выбор дат: только текущая и следующая неделя
-    const minDate = todayWeekStart;
-    const maxDate = new Date(nextWeekStartStr + 'T00:00:00');
-    maxDate.setDate(maxDate.getDate() + 6); // Воскресенье следующей недели
-    const maxDateStr = maxDate.toISOString().split('T')[0];
-    
-    const content = `
-        <h2>Добавить занятие</h2>
-        <form id="add-event-form">
-            <div class="form-group">
-                <label>Дата:</label>
-                <input type="date" id="event-date" value="${selectedDate || today}" min="${minDate}" max="${maxDateStr}" required>
-            </div>
-            <div class="form-group">
-                <label>Время начала:</label>
-                <div style="display: flex; gap: 10px;">
-                    <select id="event-hour" required>
-                        ${Array.from({length: 13}, (_, i) => i + 8).map(h => 
-                            `<option value="${String(h).padStart(2, '0')}">${String(h).padStart(2, '0')}</option>`
-                        ).join('')}
-                    </select>
-                    <select id="event-minute" required>
-                        <option value="00">00</option>
-                        <option value="15">15</option>
-                        <option value="30">30</option>
-                        <option value="45">45</option>
+function showEventModal(initial = {}, item = null) {
+    const isEdit = Boolean(item);
+    const duration = initial.duration_min || 60;
+    showModal(`
+        <h2 class="modal-title">${isEdit ? 'Изменить занятие' : 'Новое занятие'}</h2>
+        <p class="modal-subtitle">Занятия можно сделать цикличными на каждый выбранный день недели. Дальше серия будет достраиваться автоматически по диапазону, который вы открываете в календаре.</p>
+        <form id="event-form">
+            <div class="form-grid">
+                <div class="form-group">
+                    <label>Дата</label>
+                    <input type="date" id="event-date" value="${escapeAttribute(initial.date || getMoscowDateString())}" required>
+                </div>
+                <div class="form-group">
+                    <label>Время начала</label>
+                    <input type="time" id="event-start-time" step="900" min="08:00" max="20:00" value="${escapeAttribute(initial.start_time || '09:00')}" required>
+                </div>
+                <div class="form-group">
+                    <label>Длительность, минут</label>
+                    <select id="event-duration">
+                        ${[15, 30, 45, 60, 75, 90, 120, 150, 180].map((value) => `<option value="${value}" ${value === duration ? 'selected' : ''}>${value}</option>`).join('')}
                     </select>
                 </div>
-            </div>
-            <div class="form-group">
-                <label>Длительность:</label>
-                <div style="display: flex; gap: 10px;">
-                    <select id="event-duration-hour">
-                        <option value="0">0</option>
-                        <option value="1">1</option>
-                        <option value="2">2</option>
-                        <option value="3">3</option>
-                    </select>
-                    <select id="event-duration-minute">
-                        <option value="00">00</option>
-                        <option value="15">15</option>
-                        <option value="30">30</option>
-                        <option value="45">45</option>
-                    </select>
+                <div class="form-group">
+                    <label>Тип</label>
+                    <div class="checkbox-card">
+                        <label><input type="checkbox" id="event-repeat-weekly" ${initial.repeat_weekly ? 'checked' : ''}> Повторять каждую неделю</label>
+                    </div>
                 </div>
+                <div class="form-group full">
+                    <label>Название</label>
+                    <textarea id="event-title" required>${escapeHtml(initial.title || '')}</textarea>
+                </div>
+                ${isEdit ? buildScopeSelector(item) : ''}
             </div>
-            <div class="form-group">
-                <label>Название:</label>
-                <textarea id="event-title" required></textarea>
-            </div>
-            <div style="margin-top: 20px;">
-                <button type="submit" class="btn btn-primary">Добавить</button>
-                <button type="button" class="btn" onclick="closeModal()">Отмена</button>
+            <div class="actions-row">
+                <button type="submit" class="btn btn-primary">${isEdit ? 'Сохранить' : 'Добавить'}</button>
+                <button type="button" class="btn btn-secondary" id="cancel-event">Отмена</button>
             </div>
         </form>
-    `;
-    
-    showModal(content);
-    
-    document.getElementById('add-event-form').addEventListener('submit', async (e) => {
-        e.preventDefault();
-        const date = document.getElementById('event-date').value;
-        const hour = document.getElementById('event-hour').value;
-        const minute = document.getElementById('event-minute').value;
-        const durHour = parseInt(document.getElementById('event-duration-hour').value);
-        const durMin = parseInt(document.getElementById('event-duration-minute').value);
-        const title = document.getElementById('event-title').value;
-        
-        const durationMin = durHour * 60 + durMin;
-        if (durationMin === 0) {
-            alert('Длительность должна быть минимум 15 минут');
+    `);
+
+    document.getElementById('cancel-event').addEventListener('click', closeModal);
+    document.getElementById('event-form').addEventListener('submit', async (event) => {
+        event.preventDefault();
+        const payload = {
+            date: document.getElementById('event-date').value,
+            start_time: document.getElementById('event-start-time').value,
+            duration_min: Number(document.getElementById('event-duration').value),
+            title: document.getElementById('event-title').value.trim(),
+            repeat_weekly: document.getElementById('event-repeat-weekly').checked
+        };
+
+        if (isEdit) {
+            payload.occurrence_date = item.source_date || item.date;
+            payload.scope = item.repeat_weekly ? document.querySelector('input[name="edit-scope"]:checked').value : null;
+            await saveItemUpdate('event', item.id, payload);
+        } else {
+            await createItem('event', payload);
+        }
+    });
+}
+
+async function createItem(kind, payload) {
+    const response = await fetch(`/api/events?kind=${kind}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        alert(error.detail || 'Не удалось создать запись');
+        return;
+    }
+
+    closeModal();
+    await loadSchedule();
+}
+
+async function saveItemUpdate(kind, id, payload) {
+    const response = await fetch(`/api/events/${id}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        alert(error.detail || 'Не удалось изменить запись');
+        return;
+    }
+
+    closeModal();
+    await loadSchedule();
+}
+
+async function openEditModal(kind, id, occurrenceDate) {
+    const item = itemIndex.get(`${kind}:${id}:${occurrenceDate}`);
+    if (!item) {
+        return;
+    }
+    if (kind === 'task') {
+        showTaskModal(item, item);
+    } else {
+        showEventModal(item, item);
+    }
+}
+
+async function deleteItem(kind, id, occurrenceDate) {
+    const item = itemIndex.get(`${kind}:${id}:${occurrenceDate}`);
+    if (!item) {
+        return;
+    }
+
+    let scope = null;
+    if (item.repeat_weekly) {
+        scope = promptRecurringScope('Удалить только это вхождение или всю серию?', true);
+        if (!scope) {
             return;
         }
-        
-        try {
-            const response = await fetch('/api/events?kind=event', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({
-                    date,
-                    start_time: `${hour}:${minute}`,
-                    duration_min: durationMin,
-                    title
-                })
-            });
-            
-            if (response.ok) {
-                const result = await response.json();
-                console.log('Event created:', result);
-                closeModal();
-                // Небольшая задержка перед обновлением, чтобы БД успела сохранить
-                setTimeout(() => {
-                    loadSchedule().catch(err => console.error('Error reloading schedule:', err));
-                }, 100);
-            } else {
-                const error = await response.json();
-                console.error('Error creating event:', error);
-                alert('Ошибка: ' + (error.detail || 'Неизвестная ошибка'));
-            }
-        } catch (error) {
-            console.error('Exception creating event:', error);
-            alert('Ошибка при добавлении занятия: ' + error.message);
-        }
-    });
-}
-
-async function editItem(id, kind) {
-    // TODO: Реализовать редактирование
-    alert('Редактирование будет реализовано позже');
-}
-
-async function deleteItem(id, kind) {
-    if (!confirm('Удалить эту запись?')) return;
-    
-    try {
-        const response = await fetch(`/api/events/${id}`, {
-            method: 'DELETE'
-        });
-        
-        if (response.ok) {
-            // Небольшая задержка перед обновлением
-            setTimeout(() => {
-                loadSchedule().catch(err => console.error('Error reloading schedule:', err));
-            }, 100);
-        } else {
-            const error = await response.json();
-            alert('Ошибка при удалении: ' + (error.detail || 'Неизвестная ошибка'));
-        }
-    } catch (error) {
-        alert('Ошибка при удалении: ' + error.message);
-        console.error(error);
     }
+
+    const url = new URL(`/api/events/${id}`, window.location.origin);
+    if (scope) {
+        url.searchParams.set('scope', scope);
+    }
+    if (item.repeat_weekly) {
+        url.searchParams.set('occurrence_date', occurrenceDate);
+    }
+
+    const response = await fetch(url.toString(), { method: 'DELETE' });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        alert(error.detail || 'Не удалось удалить запись');
+        return;
+    }
+    await loadSchedule();
 }
 
-function updateWeekNavigationButtons() {
-    const today = getTodayInLondon();
-    const todayWeekStart = getWeekStart(today);
-    
-    // Вычисляем следующую неделю
-    const [year, month, day] = todayWeekStart.split('-').map(Number);
-    const nextWeekStartDate = new Date(year, month - 1, day);
-    nextWeekStartDate.setDate(nextWeekStartDate.getDate() + 7);
-    const nextWeekStartStr = `${nextWeekStartDate.getFullYear()}-${String(nextWeekStartDate.getMonth() + 1).padStart(2, '0')}-${String(nextWeekStartDate.getDate()).padStart(2, '0')}`;
-    
-    // Создаем даты для сравнения
-    const [currYear, currMonth, currDay] = currentWeekStart.split('-').map(Number);
-    const currentWeekStartDate = new Date(currYear, currMonth - 1, currDay);
-    
-    const [todayYear, todayMonth, todayDay] = todayWeekStart.split('-').map(Number);
-    const todayWeekStartDate = new Date(todayYear, todayMonth - 1, todayDay);
-    
-    const [nextYear, nextMonth, nextDay] = nextWeekStartStr.split('-').map(Number);
-    const nextWeekStartDateObj = new Date(nextYear, nextMonth - 1, nextDay);
-    
-    // Отключаем кнопку "предыдущая неделя", если уже на текущей неделе
-    const prevButton = document.getElementById('prev-week');
-    if (currentWeekStartDate.getTime() <= todayWeekStartDate.getTime()) {
-        prevButton.disabled = true;
-        prevButton.style.opacity = '0.5';
-        prevButton.style.cursor = 'not-allowed';
-    } else {
-        prevButton.disabled = false;
-        prevButton.style.opacity = '1';
-        prevButton.style.cursor = 'pointer';
-    }
-    
-    // Отключаем кнопку "следующая неделя", если уже на следующей неделе
-    const nextButton = document.getElementById('next-week');
-    if (currentWeekStartDate.getTime() >= nextWeekStartDateObj.getTime()) {
-        nextButton.disabled = true;
-        nextButton.style.opacity = '0.5';
-        nextButton.style.cursor = 'not-allowed';
-    } else {
-        nextButton.disabled = false;
-        nextButton.style.opacity = '1';
-        nextButton.style.cursor = 'pointer';
-    }
+function escapeHtml(value) {
+    return String(value)
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
 }
 
-// Инициализация
-document.addEventListener('DOMContentLoaded', () => {
-    currentWeekStart = getWeekStart();
-    loadSchedule();
-    updateWeekNavigationButtons();
-    
-    document.getElementById('prev-week').addEventListener('click', () => {
-        const today = getTodayInLondon();
-        const todayWeekStart = getWeekStart(today);
-        
-        // Создаем даты для сравнения
-        const [currYear, currMonth, currDay] = currentWeekStart.split('-').map(Number);
-        const currentWeekStartDate = new Date(currYear, currMonth - 1, currDay);
-        
-        const [todayYear, todayMonth, todayDay] = todayWeekStart.split('-').map(Number);
-        const todayWeekStartDate = new Date(todayYear, todayMonth - 1, todayDay);
-        
-        // Разрешаем только текущую и следующую неделю
-        // Если текущая неделя - это сегодняшняя неделя, не разрешаем идти назад
-        if (currentWeekStartDate.getTime() <= todayWeekStartDate.getTime()) {
-            console.log('Already on current week, cannot go back');
-            return; // Уже на текущей неделе, нельзя идти назад
-        }
-        
-        // Переходим на предыдущую неделю
-        const prevWeekDate = new Date(currYear, currMonth - 1, currDay);
-        prevWeekDate.setDate(prevWeekDate.getDate() - 7);
-        currentWeekStart = `${prevWeekDate.getFullYear()}-${String(prevWeekDate.getMonth() + 1).padStart(2, '0')}-${String(prevWeekDate.getDate()).padStart(2, '0')}`;
-        // Убеждаемся, что это понедельник
-        currentWeekStart = getWeekStart(currentWeekStart);
-        console.log('Moving to previous week:', currentWeekStart);
-        loadSchedule();
+function escapeAttribute(value) {
+    return escapeHtml(value);
+}
+
+document.addEventListener('DOMContentLoaded', async () => {
+    currentRangeStart = startOfWeek();
+
+    document.getElementById('prev-week').addEventListener('click', async () => {
+        currentRangeStart = addDays(currentRangeStart, -7);
+        await loadSchedule();
     });
-    
-    document.getElementById('next-week').addEventListener('click', () => {
-        const today = getTodayInLondon();
-        const todayWeekStart = getWeekStart(today);
-        
-        // Вычисляем следующую неделю от текущей
-        const [year, month, day] = currentWeekStart.split('-').map(Number);
-        const nextWeekDate = new Date(year, month - 1, day);
-        nextWeekDate.setDate(nextWeekDate.getDate() + 7);
-        const nextWeekStartStr = `${nextWeekDate.getFullYear()}-${String(nextWeekDate.getMonth() + 1).padStart(2, '0')}-${String(nextWeekDate.getDate()).padStart(2, '0')}`;
-        
-        // Вычисляем максимально допустимую следующую неделю (от сегодня)
-        const [todayYear, todayMonth, todayDay] = todayWeekStart.split('-').map(Number);
-        const maxNextWeekDate = new Date(todayYear, todayMonth - 1, todayDay);
-        maxNextWeekDate.setDate(maxNextWeekDate.getDate() + 7);
-        const maxNextWeekStr = `${maxNextWeekDate.getFullYear()}-${String(maxNextWeekDate.getMonth() + 1).padStart(2, '0')}-${String(maxNextWeekDate.getDate()).padStart(2, '0')}`;
-        
-        // Разрешаем только текущую и следующую неделю
-        if (nextWeekStartStr > maxNextWeekStr) {
-            console.log('Already on next week, cannot go further');
-            return; // Уже на следующей неделе, нельзя идти дальше
-        }
-        
-        // Переходим на следующую неделю
-        currentWeekStart = nextWeekStartStr;
-        // Убеждаемся, что это понедельник
-        currentWeekStart = getWeekStart(currentWeekStart);
-        console.log('Moving to next week:', currentWeekStart);
-        loadSchedule();
+
+    document.getElementById('next-week').addEventListener('click', async () => {
+        currentRangeStart = addDays(currentRangeStart, 7);
+        await loadSchedule();
     });
-    
-    document.getElementById('add-task-btn').addEventListener('click', () => showAddTaskModal());
-    document.getElementById('add-event-btn').addEventListener('click', () => showAddEventModal());
-    
+
+    document.getElementById('today-btn').addEventListener('click', async () => {
+        currentRangeStart = startOfWeek();
+        await loadSchedule();
+    });
+
+    document.getElementById('add-task-btn').addEventListener('click', () => showTaskModal());
+    document.getElementById('add-event-btn').addEventListener('click', () => showEventModal());
     document.querySelector('.close').addEventListener('click', closeModal);
-    window.addEventListener('click', (e) => {
-        const modal = document.getElementById('modal');
-        if (e.target === modal) {
+    window.addEventListener('click', (event) => {
+        if (event.target.id === 'modal') {
             closeModal();
         }
     });
-    
-    // Клик по дню для добавления
-    document.addEventListener('click', (e) => {
-        if (e.target.closest('.day-items')) {
-            const date = e.target.closest('.day-items').dataset.date;
-            if (e.ctrlKey || e.metaKey) {
-                showAddEventModal(date);
-            } else if (e.shiftKey) {
-                showAddTaskModal(date);
-            }
-        }
-    });
-});
 
+    try {
+        await loadSchedule();
+    } catch (error) {
+        console.error(error);
+        alert(error.message);
+    }
+});
diff --git a/frontend/admin/static/style.css b/frontend/admin/static/style.css
index a71cea9..e630e0c 100644
--- a/frontend/admin/static/style.css
+++ b/frontend/admin/static/style.css
@@ -1,264 +1,513 @@
+:root {
+    --bg: #f6efe5;
+    --paper: rgba(255, 252, 248, 0.88);
+    --paper-strong: #fffaf2;
+    --text: #1f2937;
+    --muted: #6b7280;
+    --line: rgba(123, 92, 62, 0.18);
+    --brand: #d97706;
+    --brand-deep: #9a3412;
+    --task: #15803d;
+    --event: #0f766e;
+    --accent: #f59e0b;
+    --shadow: 0 20px 55px rgba(101, 67, 33, 0.12);
+}
+
 * {
+    box-sizing: border-box;
     margin: 0;
     padding: 0;
-    box-sizing: border-box;
 }
 
 body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
-    background: #f5f5f5;
-    padding: 20px;
+    min-height: 100vh;
+    font-family: Georgia, "Times New Roman", serif;
+    color: var(--text);
+    background:
+        radial-gradient(circle at top left, rgba(217, 119, 6, 0.18), transparent 28%),
+        radial-gradient(circle at bottom right, rgba(15, 118, 110, 0.14), transparent 22%),
+        linear-gradient(180deg, #f9f4ec 0%, #efe5d5 100%);
+    padding: 18px;
 }
 
-.container {
-    max-width: 1400px;
+.app-shell {
+    max-width: 100%;
     margin: 0 auto;
 }
 
-header {
-    background: white;
-    padding: 20px;
-    border-radius: 8px;
-    margin-bottom: 20px;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+.hero,
+.toolbar,
+.hint-panel,
+.day-card,
+.modal-content {
+    backdrop-filter: blur(14px);
+    background: var(--paper);
+    border: 1px solid rgba(255, 255, 255, 0.55);
+    box-shadow: var(--shadow);
 }
 
-header h1 {
-    margin-bottom: 15px;
-    color: #333;
-}
-
-.week-navigation {
+.hero {
+    border-radius: 30px;
+    padding: 32px;
     display: flex;
-    align-items: center;
-    gap: 20px;
-}
-
-.week-navigation button {
-    padding: 8px 16px;
-    background: #4CAF50;
-    color: white;
-    border: none;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 14px;
-}
-
-.week-navigation button:hover {
-    background: #45a049;
-}
-
-#week-range {
-    font-weight: 600;
-    color: #555;
-}
-
-.actions {
+    justify-content: space-between;
+    gap: 24px;
+    align-items: flex-start;
     margin-bottom: 20px;
-    display: flex;
-    gap: 10px;
 }
 
-.btn {
-    padding: 10px 20px;
+.eyebrow {
+    text-transform: uppercase;
+    letter-spacing: 0.2em;
+    font-size: 12px;
+    color: var(--brand-deep);
+    margin-bottom: 10px;
+}
+
+.hero h1 {
+    font-size: clamp(34px, 4vw, 56px);
+    line-height: 0.95;
+    margin-bottom: 14px;
+}
+
+.hero-copy {
+    max-width: 760px;
+    font-size: 18px;
+    line-height: 1.5;
+    color: var(--muted);
+}
+
+.hero-actions,
+.week-navigation,
+.legend,
+.hint-panel,
+.task-list,
+.item-actions,
+.scope-row,
+.form-row {
+    display: flex;
+    gap: 12px;
+}
+
+.hero-actions {
+    flex-wrap: wrap;
+    justify-content: flex-end;
+}
+
+.btn,
+.nav-btn {
     border: none;
-    border-radius: 4px;
-    cursor: pointer;
+    border-radius: 999px;
+    padding: 12px 18px;
     font-size: 14px;
+    cursor: pointer;
+    transition: transform 0.18s ease, opacity 0.18s ease, background 0.18s ease;
+}
+
+.btn:hover,
+.nav-btn:hover {
+    transform: translateY(-1px);
 }
 
 .btn-primary {
-    background: #2196F3;
+    background: linear-gradient(135deg, var(--brand) 0%, var(--brand-deep) 100%);
     color: white;
 }
 
-.btn-primary:hover {
-    background: #0b7dda;
+.btn-secondary,
+.nav-btn {
+    background: rgba(255, 248, 236, 0.95);
+    color: var(--text);
+    border: 1px solid rgba(123, 92, 62, 0.16);
+}
+
+.toolbar {
+    border-radius: 24px;
+    padding: 18px 22px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 16px;
+}
+
+.toolbar-label {
+    color: var(--muted);
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.15em;
+    margin-bottom: 4px;
+}
+
+.range-title {
+    font-size: 20px;
+    font-weight: 700;
+}
+
+.legend {
+    flex-wrap: wrap;
+}
+
+.legend-chip {
+    padding: 8px 12px;
+    border-radius: 999px;
+    font-size: 13px;
+    border: 1px solid transparent;
+}
+
+.task-chip {
+    background: rgba(21, 128, 61, 0.12);
+    color: var(--task);
+}
+
+.event-chip {
+    background: rgba(15, 118, 110, 0.12);
+    color: var(--event);
+}
+
+.recurring-chip {
+    background: rgba(245, 158, 11, 0.16);
+    color: var(--brand-deep);
+}
+
+.hint-panel {
+    border-radius: 20px;
+    padding: 14px 18px;
+    margin-bottom: 22px;
+    flex-wrap: wrap;
+    color: var(--muted);
+    font-size: 14px;
 }
 
 .schedule-grid {
     display: grid;
-    grid-template-columns: repeat(7, 1fr);
-    gap: 15px;
+    grid-template-columns: repeat(7, minmax(220px, 1fr));
+    gap: 14px;
+    padding-bottom: 8px;
+    min-width: 1624px;
 }
 
-.day-column {
-    background: white;
-    border-radius: 8px;
-    padding: 15px;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+.schedule-scroll {
+    overflow-x: auto;
+    overflow-y: visible;
+    padding-bottom: 10px;
+    scrollbar-width: thin;
+}
+
+.day-card {
+    border-radius: 26px;
+    padding: 16px;
+    min-height: 820px;
+    position: relative;
+}
+
+.day-card.is-today {
+    outline: 2px solid rgba(217, 119, 6, 0.28);
 }
 
 .day-header {
-    font-weight: 600;
-    font-size: 16px;
-    margin-bottom: 15px;
-    padding-bottom: 10px;
-    border-bottom: 2px solid #4CAF50;
-    color: #333;
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 16px;
+    gap: 12px;
 }
 
-.day-items {
-    min-height: 200px;
+.day-title {
+    font-size: 22px;
+    line-height: 1.1;
 }
 
-.item {
-    background: #f9f9f9;
-    padding: 10px;
-    margin-bottom: 8px;
-    border-radius: 4px;
-    border-left: 3px solid #4CAF50;
-    cursor: pointer;
-    transition: background 0.2s;
+.day-subtitle {
+    color: var(--muted);
+    margin-top: 6px;
+    font-size: 13px;
 }
 
-.item:hover {
-    background: #f0f0f0;
-}
-
-.item.task {
-    border-left-color: #FF9800;
-}
-
-.item.event {
-    border-left-color: #2196F3;
-}
-
-.item-title {
-    font-weight: 500;
-    margin-bottom: 4px;
-}
-
-.item-time {
+.day-badge {
+    border-radius: 999px;
+    background: rgba(217, 119, 6, 0.12);
+    color: var(--brand-deep);
+    padding: 8px 10px;
     font-size: 12px;
-    color: #666;
+    white-space: nowrap;
+}
+
+.task-section {
+    margin-bottom: 18px;
+}
+
+.section-label {
+    font-size: 12px;
+    text-transform: uppercase;
+    letter-spacing: 0.15em;
+    color: var(--muted);
+    margin-bottom: 10px;
+}
+
+.task-list {
+    flex-direction: column;
+}
+
+.task-item,
+.empty-state {
+    border-radius: 18px;
+    padding: 12px 14px;
+}
+
+.task-item {
+    background: rgba(21, 128, 61, 0.08);
+    border: 1px solid rgba(21, 128, 61, 0.16);
+}
+
+.task-title,
+.event-title {
+    font-size: 15px;
+    font-weight: 700;
+    line-height: 1.3;
+}
+
+.meta-text {
+    color: var(--muted);
+    font-size: 12px;
+    margin-top: 6px;
 }
 
 .item-actions {
-    margin-top: 8px;
-    display: flex;
-    gap: 5px;
+    margin-top: 10px;
+    flex-wrap: wrap;
+    display: none;
 }
 
-.item-actions button {
-    padding: 4px 8px;
-    font-size: 11px;
+.task-item.is-active .item-actions,
+.event-block.is-active .item-actions {
+    display: flex;
+}
+
+.item-action {
     border: none;
-    border-radius: 3px;
+    border-radius: 999px;
+    padding: 6px 10px;
+    font-size: 12px;
     cursor: pointer;
 }
 
-.btn-edit {
-    background: #FFC107;
-    color: #333;
+.item-action.edit {
+    background: rgba(15, 118, 110, 0.12);
+    color: var(--event);
 }
 
-.btn-delete {
-    background: #f44336;
+.item-action.delete {
+    background: rgba(154, 52, 18, 0.12);
+    color: var(--brand-deep);
+}
+
+.timeline {
+    position: relative;
+    height: 576px;
+    border-radius: 22px;
+    background: linear-gradient(180deg, rgba(255, 255, 255, 0.9) 0%, rgba(252, 246, 238, 0.95) 100%);
+    border: 1px solid var(--line);
+    overflow: hidden;
+}
+
+.timeline-dropzone {
+    position: absolute;
+    inset: 0;
+}
+
+.timeline-hour {
+    position: absolute;
+    left: 0;
+    right: 0;
+    height: 48px;
+    border-top: 1px solid rgba(123, 92, 62, 0.12);
+}
+
+.timeline-hour-label {
+    position: absolute;
+    top: -8px;
+    left: 10px;
+    font-size: 11px;
+    color: var(--muted);
+    background: rgba(255, 250, 242, 0.9);
+    padding: 0 4px;
+}
+
+.event-block {
+    position: absolute;
+    left: 14px;
+    right: 14px;
+    border-radius: 18px;
+    padding: 12px 14px;
+    background: linear-gradient(160deg, rgba(15, 118, 110, 0.92), rgba(17, 94, 89, 0.84));
     color: white;
+    box-shadow: 0 12px 24px rgba(15, 118, 110, 0.22);
+    cursor: grab;
+    user-select: none;
+    transition: transform 0.18s ease, box-shadow 0.18s ease, opacity 0.18s ease;
+}
+
+.event-block.recurring {
+    outline: 2px solid rgba(245, 158, 11, 0.55);
+}
+
+.event-block.is-active {
+    transform: scale(1.01);
+    box-shadow: 0 18px 32px rgba(15, 118, 110, 0.28);
+}
+
+.event-block.dragging {
+    opacity: 0.5;
+}
+
+.event-time {
+    font-size: 12px;
+    opacity: 0.82;
+    margin-bottom: 6px;
+}
+
+.empty-state {
+    color: var(--muted);
+    border: 1px dashed rgba(123, 92, 62, 0.2);
+    background: rgba(255, 255, 255, 0.35);
 }
 
-/* Модальное окно */
 .modal {
     display: none;
     position: fixed;
+    inset: 0;
+    background: rgba(41, 28, 16, 0.38);
     z-index: 1000;
-    left: 0;
-    top: 0;
-    width: 100%;
-    height: 100%;
-    background-color: rgba(0,0,0,0.5);
+    padding: 24px;
 }
 
 .modal-content {
-    background-color: white;
-    margin: 5% auto;
-    padding: 30px;
-    border-radius: 8px;
-    width: 90%;
-    max-width: 500px;
+    width: min(720px, 100%);
+    max-height: calc(100vh - 48px);
+    overflow-y: auto;
+    margin: 0 auto;
+    border-radius: 28px;
+    padding: 28px;
     position: relative;
 }
 
 .close {
     position: absolute;
-    right: 20px;
-    top: 15px;
-    font-size: 28px;
-    font-weight: bold;
-    color: #aaa;
+    top: 18px;
+    right: 18px;
+    width: 40px;
+    height: 40px;
+    border-radius: 999px;
+    border: none;
+    background: rgba(123, 92, 62, 0.08);
     cursor: pointer;
+    font-size: 24px;
 }
 
-.close:hover {
-    color: #000;
+.modal-title {
+    font-size: 30px;
+    margin-bottom: 8px;
+}
+
+.modal-subtitle {
+    color: var(--muted);
+    margin-bottom: 22px;
+    line-height: 1.5;
+}
+
+.form-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 14px;
 }
 
 .form-group {
-    margin-bottom: 15px;
+    margin-bottom: 14px;
+}
+
+.form-group.full {
+    grid-column: 1 / -1;
 }
 
 .form-group label {
     display: block;
-    margin-bottom: 5px;
-    font-weight: 500;
-    color: #333;
+    margin-bottom: 6px;
+    font-size: 13px;
+    color: var(--muted);
 }
 
 .form-group input,
-.form-group select,
-.form-group textarea {
+.form-group textarea,
+.form-group select {
     width: 100%;
-    padding: 8px;
-    border: 1px solid #ddd;
-    border-radius: 4px;
-    font-size: 14px;
+    padding: 12px 14px;
+    border-radius: 16px;
+    border: 1px solid rgba(123, 92, 62, 0.18);
+    background: rgba(255, 255, 255, 0.85);
+    font-size: 15px;
+    font-family: inherit;
 }
 
 .form-group textarea {
-    min-height: 80px;
+    min-height: 108px;
     resize: vertical;
 }
 
-.checkbox-group {
-    display: flex;
-    align-items: center;
-    gap: 8px;
+.checkbox-card,
+.scope-card {
+    border-radius: 18px;
+    border: 1px solid rgba(123, 92, 62, 0.14);
+    background: rgba(255, 250, 242, 0.8);
+    padding: 14px;
 }
 
-.checkbox-group input[type="checkbox"] {
+.checkbox-card input,
+.scope-card input {
     width: auto;
 }
 
-.weekdays-select {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px;
-    margin-top: 10px;
+.scope-row {
+    flex-direction: column;
 }
 
-.weekdays-select label {
+.scope-card {
     display: flex;
-    align-items: center;
-    gap: 5px;
-    font-weight: normal;
+    gap: 10px;
+    align-items: flex-start;
+}
+
+.actions-row {
+    display: flex;
+    gap: 10px;
+    margin-top: 18px;
+    flex-wrap: wrap;
 }
 
 @media (max-width: 1200px) {
     .schedule-grid {
-        grid-template-columns: repeat(4, 1fr);
+        min-width: 1624px;
     }
 }
 
-@media (max-width: 768px) {
-    .schedule-grid {
-        grid-template-columns: repeat(2, 1fr);
+@media (max-width: 860px) {
+    body {
+        padding: 16px;
     }
-}
 
-@media (max-width: 480px) {
-    .schedule-grid {
+    .hero,
+    .toolbar {
+        flex-direction: column;
+        align-items: stretch;
+    }
+
+    .form-grid {
         grid-template-columns: 1fr;
     }
 }
 
+@media (max-width: 560px) {
+    .timeline {
+        height: 520px;
+    }
+}
diff --git a/frontend/public/index.html b/frontend/public/index.html
index 7afba69..93a397a 100644
--- a/frontend/public/index.html
+++ b/frontend/public/index.html
@@ -4,22 +4,33 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Расписание</title>
-    <link rel="stylesheet" href="/static/style.css">
+    <link rel="stylesheet" href="/static/style.css?v=3">
 </head>
 <body>
-    <div class="container">
-        <div id="today-section" class="day-section">
-            <h1 class="day-title" id="today-title">Сегодня</h1>
-            <div id="today-content"></div>
-        </div>
-        
-        <div id="tomorrow-section" class="day-section">
-            <h1 class="day-title" id="tomorrow-title">Завтра</h1>
-            <div id="tomorrow-content"></div>
-        </div>
-    </div>
-    
-    <script src="/static/script.js?v=2"></script>
+    <main class="board">
+        <section class="board-hero">
+            <p class="board-label">Сегодня и завтра</p>
+            <h1>Расписание на ближайшие дни</h1>
+            <p class="board-copy">Задачи отображаются сверху, занятия ниже по времени. Данные обновляются автоматически каждые пять минут.</p>
+        </section>
+
+        <section class="days-grid">
+            <article id="today-section" class="day-panel">
+                <div class="panel-head">
+                    <h2 class="day-title" id="today-title">Сегодня</h2>
+                </div>
+                <div id="today-content"></div>
+            </article>
+
+            <article id="tomorrow-section" class="day-panel">
+                <div class="panel-head">
+                    <h2 class="day-title" id="tomorrow-title">Завтра</h2>
+                </div>
+                <div id="tomorrow-content"></div>
+            </article>
+        </section>
+    </main>
+
+    <script src="/static/script.js?v=3"></script>
 </body>
 </html>
-
diff --git a/frontend/public/static/script.js b/frontend/public/static/script.js
index 2b67ca3..4fb34ab 100644
--- a/frontend/public/static/script.js
+++ b/frontend/public/static/script.js
@@ -1,88 +1,35 @@
-const TZ = 'Europe/Moscow';
+const MOSCOW_TIMEZONE = 'Europe/Moscow';
+const WEEKDAYS = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
+const MONTHS = ['января', 'февраля', 'марта', 'апреля', 'мая', 'июня', 'июля', 'августа', 'сентября', 'октября', 'ноября', 'декабря'];
 
-function formatDate(dateStr) {
-    const date = new Date(dateStr + 'T00:00:00');
-    // getDay() возвращает 0=воскресенье, 1=понедельник, ..., 6=суббота
-    // Конвертируем в формат где 0=понедельник
-    const jsDay = date.getDay();
-    const weekdayIndex = jsDay === 0 ? 6 : jsDay - 1; // 0=пн, 6=вс
-    const weekdays = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'];
-    const months = ['января', 'февраля', 'марта', 'апреля', 'мая', 'июня', 
-                    'июля', 'августа', 'сентября', 'октября', 'ноября', 'декабря'];
-    
-    const weekday = weekdays[weekdayIndex];
-    const day = date.getDate();
-    const month = months[date.getMonth()];
-    
-    return `${weekday}, ${day} ${month}`;
-}
-
-function getTodayInMoscow() {
-    // Получаем текущую дату в таймзоне Moscow
-    const now = new Date();
+function getMoscowDateString() {
     const formatter = new Intl.DateTimeFormat('en-CA', {
-        timeZone: 'Europe/Moscow',
+        timeZone: MOSCOW_TIMEZONE,
         year: 'numeric',
         month: '2-digit',
         day: '2-digit'
     });
-    return formatter.format(now);
+    return formatter.format(new Date());
 }
 
-function getTomorrowInLondon() {
-    const today = getTodayInMoscow();
-    const date = new Date(today);
-    date.setDate(date.getDate() + 1);
-    return date.toISOString().split('T')[0];
+function parseISODate(value) {
+    const [year, month, day] = value.split('-').map(Number);
+    return new Date(year, month - 1, day);
 }
 
-function renderDay(container, titleEl, dateStr, items, isToday = false, isTomorrow = false) {
-    let titleText = formatDate(dateStr);
-    if (isToday) {
-        // Преобразуем "Вторник, 30 декабря" в "Сегодня вторник, 30 декабря"
-        const parts = titleText.split(', ');
-        if (parts.length === 2) {
-            titleText = `Сегодня ${parts[0].toLowerCase()}, ${parts[1]}`;
-        }
-    } else if (isTomorrow) {
-        // Преобразуем "Среда, 31 декабря" в "Завтра среда, 31 декабря"
-        const parts = titleText.split(', ');
-        if (parts.length === 2) {
-            titleText = `Завтра ${parts[0].toLowerCase()}, ${parts[1]}`;
-        }
-    }
-    titleEl.textContent = titleText;
-    
-    const tasks = items.filter(item => item.kind === 'task');
-    const events = items.filter(item => item.kind === 'event');
-    
-    let html = '';
-    
-    if (tasks.length > 0) {
-        html += '<div class="tasks-list">';
-        tasks.forEach(task => {
-            html += `<div class="task-item">• ${task.title}</div>`;
-        });
-        html += '</div>';
-    }
-    
-    if (events.length > 0) {
-        html += '<div class="events-list">';
-        events.sort((a, b) => a.start_time.localeCompare(b.start_time)).forEach(event => {
-            const endTime = calculateEndTime(event.start_time, event.duration_min);
-            html += `<div class="event-item">
-                <span class="event-time">${event.start_time}-${endTime}</span>
-                <span class="event-title">${event.title}</span>
-            </div>`;
-        });
-        html += '</div>';
-    }
-    
-    if (tasks.length === 0 && events.length === 0) {
-        html = '<div class="empty-message">На этот день расписания нет.</div>';
-    }
-    
-    container.innerHTML = html;
+function formatISODate(date) {
+    return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+}
+
+function addDays(dateStr, days) {
+    const date = parseISODate(dateStr);
+    date.setDate(date.getDate() + days);
+    return formatISODate(date);
+}
+
+function formatDate(dateStr) {
+    const date = parseISODate(dateStr);
+    return `${WEEKDAYS[(date.getDay() + 6) % 7]}, ${date.getDate()} ${MONTHS[date.getMonth()]}`;
 }
 
 function calculateEndTime(startTime, durationMin) {
@@ -93,49 +40,79 @@ function calculateEndTime(startTime, durationMin) {
     return `${String(endHour).padStart(2, '0')}:${String(endMinute).padStart(2, '0')}`;
 }
 
-async function loadSchedule() {
-    const today = getTodayInMoscow();
-    const tomorrow = getTomorrowInLondon();
-    
-    console.log('Loading schedule from', today, 'to', tomorrow);
-    
-    try {
-        const response = await fetch(`/api/schedule?from_date=${today}&to_date=${tomorrow}`);
-        const data = await response.json();
-        
-        console.log('Received items:', data.items);
-        
-        const todayItems = data.items.filter(item => item.date === today);
-        const tomorrowItems = data.items.filter(item => item.date === tomorrow);
-        
-        console.log('Today items:', todayItems);
-        console.log('Tomorrow items:', tomorrowItems);
-        
-        renderDay(
-            document.getElementById('today-content'),
-            document.getElementById('today-title'),
-            today,
-            todayItems,
-            true,  // isToday
-            false
-        );
-        
-        renderDay(
-            document.getElementById('tomorrow-content'),
-            document.getElementById('tomorrow-title'),
-            tomorrow,
-            tomorrowItems,
-            false,
-            true   // isTomorrow
-        );
-    } catch (error) {
-        console.error('Error loading schedule:', error);
+function renderDay(container, titleEl, dateStr, items, options = {}) {
+    let titleText = formatDate(dateStr);
+    if (options.today) {
+        titleText = `Сегодня, ${titleText.toLowerCase()}`;
+    } else if (options.tomorrow) {
+        titleText = `Завтра, ${titleText.toLowerCase()}`;
     }
+    titleEl.textContent = titleText;
+
+    const tasks = items.filter((item) => item.kind === 'task');
+    const events = items
+        .filter((item) => item.kind === 'event')
+        .sort((a, b) => a.start_time.localeCompare(b.start_time));
+
+    if (!tasks.length && !events.length) {
+        container.innerHTML = '<div class="empty-message">На этот день расписания нет.</div>';
+        return;
+    }
+
+    const tasksHtml = tasks.length ? `
+        <div class="tasks-list">
+            ${tasks.map((task) => `<div class="task-item">${task.repeat_weekly ? 'Каждую неделю: ' : ''}${escapeHtml(task.title)}</div>`).join('')}
+        </div>
+    ` : '';
+
+    const eventsHtml = events.length ? `
+        <div class="events-list">
+            ${events.map((event) => `
+                <div class="event-item">
+                    <span class="event-time">${event.start_time}-${calculateEndTime(event.start_time, event.duration_min)}</span>
+                    <span class="event-title">${escapeHtml(event.title)}</span>
+                </div>
+            `).join('')}
+        </div>
+    ` : '';
+
+    container.innerHTML = `${tasksHtml}${eventsHtml}`;
 }
 
-// Загружаем расписание при загрузке страницы
-loadSchedule();
+function escapeHtml(value) {
+    return String(value)
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
 
-// Автообновление каждые 5 минут
-setInterval(loadSchedule, 5 * 60 * 1000);
+async function loadSchedule() {
+    const today = getMoscowDateString();
+    const tomorrow = addDays(today, 1);
 
+    const response = await fetch(`/api/schedule?from_date=${today}&to_date=${tomorrow}`);
+    if (!response.ok) {
+        throw new Error('Не удалось загрузить расписание');
+    }
+
+    const data = await response.json();
+    renderDay(
+        document.getElementById('today-content'),
+        document.getElementById('today-title'),
+        today,
+        data.items.filter((item) => item.date === today),
+        { today: true }
+    );
+    renderDay(
+        document.getElementById('tomorrow-content'),
+        document.getElementById('tomorrow-title'),
+        tomorrow,
+        data.items.filter((item) => item.date === tomorrow),
+        { tomorrow: true }
+    );
+}
+
+loadSchedule().catch((error) => console.error(error));
+setInterval(() => loadSchedule().catch((error) => console.error(error)), 5 * 60 * 1000);
diff --git a/frontend/public/static/style.css b/frontend/public/static/style.css
index 125b646..b944432 100644
--- a/frontend/public/static/style.css
+++ b/frontend/public/static/style.css
@@ -1,100 +1,153 @@
+:root {
+    --bg: #f4efe8;
+    --panel: rgba(255, 251, 246, 0.9);
+    --text: #1f2937;
+    --muted: #6b7280;
+    --task: #166534;
+    --event: #0f766e;
+    --line: rgba(123, 92, 62, 0.18);
+}
+
 * {
+    box-sizing: border-box;
     margin: 0;
     padding: 0;
-    box-sizing: border-box;
 }
 
 body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
-    background: #f5f5f5;
-    padding: 20px;
-    font-size: 24px;
-    line-height: 1.6;
+    min-height: 100vh;
+    font-family: Georgia, "Times New Roman", serif;
+    color: var(--text);
+    background:
+        radial-gradient(circle at top left, rgba(245, 158, 11, 0.16), transparent 28%),
+        radial-gradient(circle at bottom right, rgba(15, 118, 110, 0.14), transparent 22%),
+        linear-gradient(180deg, #faf4eb 0%, #efe4d2 100%);
+    padding: 24px;
 }
 
-.container {
-    max-width: 1200px;
+.board {
+    max-width: 1440px;
     margin: 0 auto;
 }
 
-.day-section {
-    background: white;
-    border-radius: 12px;
-    padding: 30px;
-    margin-bottom: 30px;
-    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+.board-hero,
+.day-panel {
+    background: var(--panel);
+    border: 1px solid rgba(255, 255, 255, 0.6);
+    box-shadow: 0 18px 45px rgba(101, 67, 33, 0.12);
+    backdrop-filter: blur(14px);
+}
+
+.board-hero {
+    border-radius: 28px;
+    padding: 28px;
+    margin-bottom: 20px;
+}
+
+.board-label {
+    text-transform: uppercase;
+    letter-spacing: 0.18em;
+    font-size: 12px;
+    color: #92400e;
+    margin-bottom: 10px;
+}
+
+.board-hero h1 {
+    font-size: clamp(34px, 5vw, 62px);
+    line-height: 0.95;
+    margin-bottom: 12px;
+}
+
+.board-copy {
+    max-width: 780px;
+    color: var(--muted);
+    font-size: 22px;
+    line-height: 1.4;
+}
+
+.days-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 20px;
+}
+
+.day-panel {
+    border-radius: 28px;
+    padding: 28px;
+}
+
+.panel-head {
+    border-bottom: 1px solid var(--line);
+    padding-bottom: 16px;
+    margin-bottom: 18px;
 }
 
 .day-title {
     font-size: 36px;
-    font-weight: 600;
-    color: #333;
-    margin-bottom: 20px;
-    padding-bottom: 15px;
-    border-bottom: 3px solid #4CAF50;
+    line-height: 1.1;
+}
+
+.tasks-list,
+.events-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
 }
 
 .tasks-list {
-    margin-bottom: 30px;
+    margin-bottom: 18px;
+}
+
+.task-item,
+.event-item,
+.empty-message {
+    border-radius: 18px;
+    padding: 16px 18px;
 }
 
 .task-item {
+    background: rgba(22, 101, 52, 0.08);
+    border: 1px solid rgba(22, 101, 52, 0.14);
     font-size: 28px;
-    padding: 15px 0;
-    color: #555;
-    border-bottom: 1px solid #eee;
-}
-
-.task-item:last-child {
-    border-bottom: none;
-}
-
-.events-list {
-    margin-top: 20px;
 }
 
 .event-item {
+    display: grid;
+    grid-template-columns: 160px 1fr;
+    gap: 14px;
+    background: rgba(15, 118, 110, 0.08);
+    border: 1px solid rgba(15, 118, 110, 0.14);
     font-size: 28px;
-    padding: 15px 0;
-    color: #333;
-    border-bottom: 1px solid #eee;
-    display: flex;
-    align-items: center;
-    gap: 15px;
-}
-
-.event-item:last-child {
-    border-bottom: none;
+    align-items: start;
 }
 
 .event-time {
-    font-weight: 600;
-    color: #4CAF50;
-    min-width: 120px;
-}
-
-.event-title {
-    flex: 1;
+    color: var(--event);
+    font-weight: 700;
 }
 
 .empty-message {
-    color: #999;
-    font-style: italic;
-    padding: 20px 0;
+    color: var(--muted);
+    border: 1px dashed var(--line);
+    font-size: 24px;
 }
 
-@media (max-width: 768px) {
-    body {
-        font-size: 20px;
-        padding: 15px;
+@media (max-width: 900px) {
+    .days-grid {
+        grid-template-columns: 1fr;
     }
-    
+
     .day-title {
         font-size: 28px;
     }
-    
-    .task-item, .event-item {
-        font-size: 22px;
+
+    .board-copy,
+    .task-item,
+    .event-item {
+        font-size: 20px;
+    }
+
+    .event-item {
+        grid-template-columns: 1fr;
     }
 }
-