diff --git a/alfy-bot-frontend/src/components/ui/confirm-dialog/ConfirmDialog.vue b/alfy-bot-frontend/src/components/ui/confirm-dialog/ConfirmDialog.vue
index b3da1ba..ba7b42b 100644
--- a/alfy-bot-frontend/src/components/ui/confirm-dialog/ConfirmDialog.vue
+++ b/alfy-bot-frontend/src/components/ui/confirm-dialog/ConfirmDialog.vue
@@ -7,6 +7,16 @@
           {{ options?.message }}
         </AlertDialogDescription>
       </AlertDialogHeader>
+      <label
+        v-if="options?.rememberKey"
+        class="flex items-center gap-2 px-1 text-sm"
+      >
+        <Checkbox
+          :model-value="rememberChecked"
+          @update:model-value="(v) => (rememberChecked = v === true)"
+        />
+        {{ options.rememberLabel }}
+      </label>
       <AlertDialogFooter>
         <AlertDialogCancel @click="handleCancel">
           {{ options?.cancelText || 'Отмена' }}
@@ -24,6 +34,7 @@
 
 <script setup lang="ts">
 import { useConfirm } from '@/composables/useConfirm'
+import { Checkbox } from '@/components/ui/checkbox'
 import {
   AlertDialog,
   AlertDialogAction,
@@ -35,5 +46,5 @@ import {
   AlertDialogTitle,
 } from '@/components/ui/alert-dialog'
 
-const { isOpen, options, handleConfirm, handleCancel } = useConfirm()
+const { isOpen, options, handleConfirm, handleCancel, rememberChecked } = useConfirm()
 </script>
diff --git a/alfy-bot-frontend/src/composables/useConfirm.ts b/alfy-bot-frontend/src/composables/useConfirm.ts
index c465658..a7bc31f 100644
--- a/alfy-bot-frontend/src/composables/useConfirm.ts
+++ b/alfy-bot-frontend/src/composables/useConfirm.ts
@@ -6,10 +6,13 @@ interface ConfirmOptions {
   confirmText?: string
   cancelText?: string
   variant?: 'default' | 'destructive'
+  rememberKey?: string
+  rememberLabel?: string
 }
 
 const isOpen = ref(false)
 const options = shallowRef<ConfirmOptions | null>(null)
+const rememberChecked = ref(false)
 let resolvePromise: ((value: boolean) => void) | null = null
 
 const resolve = (value: boolean) => {
@@ -22,6 +25,10 @@ const resolve = (value: boolean) => {
 
 export function useConfirm() {
   const confirm = (opts: ConfirmOptions): Promise<boolean> => {
+    if (opts.rememberKey && localStorage.getItem(opts.rememberKey) === '1') {
+      return Promise.resolve(true)
+    }
+    rememberChecked.value = false
     options.value = opts
     isOpen.value = true
     return new Promise((res) => {
@@ -29,8 +36,13 @@ export function useConfirm() {
     })
   }
 
-  const handleConfirm = () => resolve(true)
+  const handleConfirm = () => {
+    if (options.value?.rememberKey && rememberChecked.value) {
+      localStorage.setItem(options.value.rememberKey, '1')
+    }
+    resolve(true)
+  }
   const handleCancel = () => resolve(false)
 
-  return { isOpen, options, confirm, handleConfirm, handleCancel }
+  return { isOpen, options, confirm, handleConfirm, handleCancel, rememberChecked }
 }
diff --git a/alfy-bot-frontend/src/features/calendar/lib/calendar-events.spec.ts b/alfy-bot-frontend/src/features/calendar/lib/calendar-events.spec.ts
index ac2cc03..c3fd923 100644
--- a/alfy-bot-frontend/src/features/calendar/lib/calendar-events.spec.ts
+++ b/alfy-bot-frontend/src/features/calendar/lib/calendar-events.spec.ts
@@ -124,3 +124,159 @@ describe('tasksToCalendarEvents — past-due recurring skip-to-today', () => {
     expect(taskEvents[0]!.isVirtual).toBe(false)
   })
 })
+
+describe('tasksToCalendarEvents — this-only reschedule keeps series ghosts', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(local(2026, 4, 8, 12, 0))
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('real event at dueDate, ghosts from recurrenceAnchorDate (Mon 10:00 → Wed 15:00)', () => {
+    const weekly: RecurrenceRule = { frequency: 'weekly', interval: 1 }
+    const task = baseTask({
+      id: 'moved',
+      dueDate: local(2026, 4, 8, 15, 0),
+      recurrenceAnchorDate: local(2026, 4, 6, 10, 0),
+      recurrence: weekly,
+    })
+    const weekStart = local(2026, 4, 6, 0, 0)
+    const weekEnd = local(2026, 4, 19, 23, 59)
+
+    const events = tasksToCalendarEvents([task], weekStart, weekEnd)
+    const real = events.filter(e => !e.isVirtual)
+    const ghosts = events.filter(e => e.isVirtual)
+
+    expect(real).toHaveLength(1)
+    expect(real[0]!.date).toEqual(local(2026, 4, 8, 15, 0))
+
+    expect(ghosts).toHaveLength(1)
+    expect(ghosts[0]!.date).toEqual(local(2026, 4, 13, 10, 0))
+  })
+})
+
+describe('tasksToCalendarEvents — occupied series slots / ghosts from root', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(local(2026, 4, 6, 12, 0))
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  const weekly: RecurrenceRule = { frequency: 'weekly', interval: 1 }
+
+  it('не рисует ghost на дне проявленного sibling', () => {
+    const root = baseTask({
+      id: 'root-1',
+      dueDate: local(2026, 4, 6, 10, 0),
+      recurrence: weekly,
+    })
+    const materialized = baseTask({
+      id: 'mat-1',
+      recurringParentId: 'root-1',
+      dueDate: local(2026, 4, 13, 10, 0),
+      recurrence: weekly,
+      isAutoCreated: false,
+    })
+    const weekStart = local(2026, 4, 6, 0, 0)
+    const weekEnd = local(2026, 4, 19, 23, 59)
+
+    const events = tasksToCalendarEvents([root, materialized], weekStart, weekEnd)
+    const ghosts = events.filter(e => e.isVirtual)
+    const reals = events.filter(e => !e.isVirtual)
+
+    expect(reals.map(e => e.taskId).sort()).toEqual(['mat-1', 'root-1'])
+    expect(ghosts).toHaveLength(0)
+  })
+
+  it('ghosts от root, не от проявленной; занятый слот sibling не рисуется', () => {
+    const root = baseTask({
+      id: 'root-1',
+      dueDate: local(2026, 4, 6, 10, 0),
+      recurrence: weekly,
+      completed: true,
+      recurringCompletedCount: 1,
+    })
+    const current = baseTask({
+      id: 'inst-1',
+      recurringParentId: 'root-1',
+      dueDate: local(2026, 4, 13, 10, 0),
+      recurrence: weekly,
+      isAutoCreated: true,
+    })
+    const materialized = baseTask({
+      id: 'mat-1',
+      recurringParentId: 'root-1',
+      dueDate: local(2026, 4, 20, 10, 0),
+      recurrenceAnchorDate: local(2026, 4, 20, 10, 0),
+      recurrence: weekly,
+      isAutoCreated: false,
+    })
+    const weekStart = local(2026, 4, 6, 0, 0)
+    const weekEnd = local(2026, 4, 27, 23, 59)
+
+    const events = tasksToCalendarEvents(
+      [root, current, materialized],
+      weekStart,
+      weekEnd,
+    )
+    const ghosts = events.filter(e => e.isVirtual)
+    const reals = events.filter(e => !e.isVirtual)
+
+    expect(reals).toHaveLength(3)
+    expect(ghosts).toHaveLength(1)
+    expect(ghosts[0]!.date).toEqual(local(2026, 4, 27, 10, 0))
+    expect(ghosts[0]!.taskId.startsWith('inst-1__virtual__')).toBe(true)
+  })
+
+  it('this-only sibling занимает слот якоря, не dueDate', () => {
+    const root = baseTask({
+      id: 'root-1',
+      dueDate: local(2026, 4, 6, 10, 0),
+      recurrence: weekly,
+    })
+    const materialized = baseTask({
+      id: 'mat-1',
+      recurringParentId: 'root-1',
+      dueDate: local(2026, 4, 15, 15, 0),
+      recurrenceAnchorDate: local(2026, 4, 13, 10, 0),
+      recurrence: weekly,
+      isAutoCreated: false,
+    })
+    const weekStart = local(2026, 4, 6, 0, 0)
+    const weekEnd = local(2026, 4, 19, 23, 59)
+
+    const events = tasksToCalendarEvents([root, materialized], weekStart, weekEnd)
+    const ghosts = events.filter(e => e.isVirtual)
+    const reals = events.filter(e => !e.isVirtual)
+
+    expect(reals.map(e => e.date.getDate()).sort((a, b) => a - b)).toEqual([6, 15])
+    expect(ghosts).toHaveLength(0)
+  })
+
+  it('не рисует ghosts если в семье нет живого курсора (только overdue/completed)', () => {
+    const root = baseTask({
+      id: 'root-1',
+      dueDate: local(2026, 4, 6, 18, 0),
+      recurrence: weekly,
+      completed: true,
+    })
+    const overdue = baseTask({
+      id: 'ov-1',
+      recurringParentId: 'root-1',
+      dueDate: local(2026, 4, 8, 18, 0),
+      isOverdue: true,
+      recurrence: weekly,
+    })
+    const weekStart = local(2026, 4, 6, 0, 0)
+    const weekEnd = local(2026, 4, 19, 23, 59)
+
+    const events = tasksToCalendarEvents([root, overdue], weekStart, weekEnd)
+    expect(events.filter(e => e.isVirtual)).toHaveLength(0)
+  })
+})
diff --git a/alfy-bot-frontend/src/features/calendar/lib/calendar-events.ts b/alfy-bot-frontend/src/features/calendar/lib/calendar-events.ts
index 135b9ea..c3b50b2 100644
--- a/alfy-bot-frontend/src/features/calendar/lib/calendar-events.ts
+++ b/alfy-bot-frontend/src/features/calendar/lib/calendar-events.ts
@@ -1,10 +1,11 @@
-import { isSameDay } from 'date-fns'
+import { isSameDay, startOfDay } from 'date-fns'
 import type { Task } from '@/features/tasks/model/types'
 import type { CalendarEvent } from '../model/types'
 import { computeTaskDurationMinutes } from '@/features/tasks/lib/duration'
 import {
   computeNextDueDate,
   findNextOccurrenceOnOrAfter,
+  seriesDueDate,
 } from '@/features/tasks/model/recurrence'
 
 function taskToEvent(task: Task, date: Date, isVirtual = false): CalendarEvent {
@@ -31,56 +32,95 @@ function taskToEvent(task: Task, date: Date, isVirtual = false): CalendarEvent {
   }
 }
 
-export function tasksToCalendarEvents(tasks: Task[], weekStart: Date, weekEnd: Date): CalendarEvent[] {
-  const events: CalendarEvent[] = []
+function familyId(task: Task): string {
+  return task.recurringParentId ?? task.id
+}
 
-  for (const task of tasks) {
-    if (!task.dueDate) continue
+function isLiveCursor(task: Task): boolean {
+  return !task.completed && !task.isOverdue
+}
 
-    const dueDate = new Date(task.dueDate)
-    const isRecurring = !!task.recurrence
+function occupiedSlotKeys(members: Task[]): Set<number> {
+  const keys = new Set<number>()
+  for (const member of members) {
+    const slot = seriesDueDate(member)
+    if (slot) keys.add(startOfDay(slot).getTime())
+    if (member.dueDate) keys.add(startOfDay(new Date(member.dueDate)).getTime())
+  }
+  return keys
+}
 
-    // Add the real event if it falls in range
-    if (dueDate >= weekStart && dueDate <= weekEnd) {
-      events.push(taskToEvent(task, dueDate))
-    }
+function emitGhosts(
+  root: Task,
+  occupied: Set<number>,
+  weekStart: Date,
+  weekEnd: Date,
+  events: CalendarEvent[],
+) {
+  if (!root.recurrence) return
+  const seriesDue = seriesDueDate(root)
+  if (!seriesDue) return
 
-    // Generate virtual future occurrences for uncompleted recurring tasks
-    if (isRecurring && !task.completed && task.recurrence) {
-      let current = dueDate
-      const completedCount = task.recurringCompletedCount ?? 0
-
-      // Skip-to-today: for past-due recurring tasks we must not project ghosts
-      // onto past dates between dueDate and today. Mirrors the backend
-      // findNextOccurrenceOnOrAfter logic in completeRecurringTask.
-      const startOfToday = new Date()
-      startOfToday.setHours(0, 0, 0, 0)
-      if (dueDate < startOfToday) {
-        const skipped = findNextOccurrenceOnOrAfter(
-          dueDate,
-          task.recurrence,
-          startOfToday,
-          completedCount,
-        )
-        if (!skipped) continue
-        current = skipped
-        if (skipped <= weekEnd && skipped >= weekStart && !isSameDay(skipped, dueDate)) {
-          events.push(taskToEvent(task, skipped, true))
-        }
-      }
+  const completedCount = root.recurringCompletedCount ?? 0
+
+  const maybeEmit = (date: Date) => {
+    if (date < weekStart || date > weekEnd) return
+    if (occupied.has(startOfDay(date).getTime())) return
+    events.push(taskToEvent(root, date, true))
+  }
 
-      for (let i = 0; i < 52; i++) {
-        const next = computeNextDueDate(current, task.recurrence, completedCount)
-        if (!next) break
-        if (next > weekEnd) break
+  let current = seriesDue
+  const startOfToday = new Date()
+  startOfToday.setHours(0, 0, 0, 0)
+  if (seriesDue < startOfToday) {
+    const skipped = findNextOccurrenceOnOrAfter(
+      seriesDue,
+      root.recurrence,
+      startOfToday,
+      completedCount,
+    )
+    if (!skipped) return
+    current = skipped
+    maybeEmit(skipped)
+  }
+
+  for (let i = 0; i < 52; i++) {
+    const next = computeNextDueDate(current, root.recurrence, completedCount)
+    if (!next) break
+    if (next > weekEnd) break
+    if (next >= weekStart) maybeEmit(next)
+    current = next
+  }
+}
 
-        if (next >= weekStart && !isSameDay(next, dueDate)) {
-          events.push(taskToEvent(task, next, true))
-        }
+export function tasksToCalendarEvents(tasks: Task[], weekStart: Date, weekEnd: Date): CalendarEvent[] {
+  const events: CalendarEvent[] = []
+  const families = new Map<string, Task[]>()
 
-        current = next
+  for (const task of tasks) {
+    if (task.dueDate) {
+      const dueDate = new Date(task.dueDate)
+      if (dueDate >= weekStart && dueDate <= weekEnd) {
+        events.push(taskToEvent(task, dueDate))
       }
     }
+
+    if (task.recurrence || task.recurringParentId) {
+      const id = familyId(task)
+      const members = families.get(id)
+      if (members) members.push(task)
+      else families.set(id, [task])
+    }
+  }
+
+  for (const [, members] of families) {
+    const live = members.filter(isLiveCursor)
+    const source =
+      live.find(t => !t.recurringParentId)
+      ?? live.find(t => t.isAutoCreated)
+      ?? live[0]
+    if (!source?.recurrence) continue
+    emitGhosts(source, occupiedSlotKeys(members), weekStart, weekEnd, events)
   }
 
   return events
diff --git a/alfy-bot-frontend/src/features/calendar/lib/layout-overlapping.ts b/alfy-bot-frontend/src/features/calendar/lib/layout-overlapping.ts
new file mode 100644
index 0000000..554b0c6
--- /dev/null
+++ b/alfy-bot-frontend/src/features/calendar/lib/layout-overlapping.ts
@@ -0,0 +1,90 @@
+import type { CalendarEvent } from '../model/types'
+
+/** Visual min height is 20px; hour row is 60px → 20 minutes. */
+export const MIN_VISUAL_MINUTES = 20
+
+export interface EventColumn {
+  col: number
+  cols: number
+}
+
+function visualEnd(event: CalendarEvent): number {
+  return event.startMinutes + Math.max(event.durationMinutes, MIN_VISUAL_MINUTES)
+}
+
+function layoutGroup(
+  group: CalendarEvent[],
+  result: Map<string, EventColumn>,
+): void {
+  const columns: CalendarEvent[][] = []
+  const colOf = new Map<string, number>()
+
+  for (const event of group) {
+    let placed = false
+    for (let i = 0; i < columns.length; i++) {
+      const last = columns[i]![columns[i]!.length - 1]!
+      if (visualEnd(last) <= event.startMinutes) {
+        columns[i]!.push(event)
+        colOf.set(event.taskId, i)
+        placed = true
+        break
+      }
+    }
+    if (!placed) {
+      colOf.set(event.taskId, columns.length)
+      columns.push([event])
+    }
+  }
+
+  const cols = columns.length
+  for (const event of group) {
+    result.set(event.taskId, { col: colOf.get(event.taskId)!, cols })
+  }
+}
+
+/** Outlook-style columns: overlapping events share width, touching ones stay full-width. */
+export function assignEventColumns(events: CalendarEvent[]): Map<string, EventColumn> {
+  const result = new Map<string, EventColumn>()
+  if (events.length === 0) return result
+
+  const sorted = [...events].sort(
+    (a, b) =>
+      a.startMinutes - b.startMinutes
+      || b.durationMinutes - a.durationMinutes
+      || a.taskId.localeCompare(b.taskId),
+  )
+
+  let group: CalendarEvent[] = []
+  let groupEnd = -1
+
+  const flush = () => {
+    if (group.length === 0) return
+    layoutGroup(group, result)
+    group = []
+    groupEnd = -1
+  }
+
+  for (const event of sorted) {
+    if (group.length > 0 && event.startMinutes >= groupEnd) flush()
+    group.push(event)
+    groupEnd = Math.max(groupEnd, visualEnd(event))
+  }
+  flush()
+  return result
+}
+
+const INSET_PX = 2
+
+export function eventColumnStyle(layout: EventColumn): Record<string, string | number> {
+  if (layout.cols <= 1) {
+    return { left: `${INSET_PX}px`, right: `${INSET_PX}px`, zIndex: 1 }
+  }
+  const leftPct = (layout.col / layout.cols) * 100
+  const widthPct = 100 / layout.cols
+  return {
+    left: `calc(${leftPct}% + ${INSET_PX}px)`,
+    width: `calc(${widthPct}% - ${INSET_PX * 2}px)`,
+    right: 'auto',
+    zIndex: layout.col + 1,
+  }
+}
diff --git a/alfy-bot-frontend/src/features/calendar/ui/AllDaySection.vue b/alfy-bot-frontend/src/features/calendar/ui/AllDaySection.vue
index e13a211..cc748a0 100644
--- a/alfy-bot-frontend/src/features/calendar/ui/AllDaySection.vue
+++ b/alfy-bot-frontend/src/features/calendar/ui/AllDaySection.vue
@@ -21,7 +21,7 @@
           v-for="event in getEventsForDay(day)"
           :key="event.taskId"
           :class="[
-            'text-[10px] px-1.5 py-0.5 rounded truncate max-w-full border',
+            'text-[10px] px-1.5 py-0.5 rounded max-w-full border flex items-center gap-0.5',
             event.task.isOverdue
               ? 'cursor-not-allowed'
               : event.isVirtual
@@ -34,12 +34,24 @@
                 : event.isVirtual
                   ? 'border-dashed border-border/60 bg-muted'
                   : chipClasses(event),
+            highlightedTaskId === event.taskId && 'ring-2 ring-primary',
           ]"
           :draggable="!event.isVirtual && !event.task.isOverdue"
           @dragstart="onDragStart($event, event)"
           @click.stop="$emit('open', event)"
         >
-          {{ event.title }}
+          <span class="truncate">{{ event.title }}</span>
+          <button
+            v-if="event.isVirtual"
+            type="button"
+            data-testid="materialize-occurrence"
+            class="shrink-0 rounded p-0.5 hover:bg-foreground/10"
+            aria-label="Проявить задачу"
+            @pointerdown.stop
+            @click.stop="$emit('materialize', event)"
+          >
+            <CalendarPlus :size="10" />
+          </button>
         </div>
       </div>
     </div>
@@ -48,9 +60,11 @@
 
 <script setup lang="ts">
 import { ref } from 'vue'
+import { CalendarPlus } from 'lucide-vue-next'
 import { isSameDay } from 'date-fns'
 import type { CalendarEvent, CalendarDropPayload } from '../model/types'
 import { getPriorityEventClasses, OVERDUE_EVENT_CLASSES } from '../lib/calendar-styles'
+import { highlightedTaskId } from '@/features/tasks/lib/use-recurring-reschedule'
 
 const props = defineProps<{
   visibleDays: Date[]
@@ -64,6 +78,7 @@ const emit = defineEmits<{
   drop: [payload: CalendarDropPayload]
   dragstart: [event: DragEvent, taskId: string]
   open: [event: CalendarEvent]
+  materialize: [event: CalendarEvent]
 }>()
 
 const dragOverDay = ref<string | null>(null)
diff --git a/alfy-bot-frontend/src/features/calendar/ui/CalendarEventBlock.vue b/alfy-bot-frontend/src/features/calendar/ui/CalendarEventBlock.vue
index fa55aa0..2396509 100644
--- a/alfy-bot-frontend/src/features/calendar/ui/CalendarEventBlock.vue
+++ b/alfy-bot-frontend/src/features/calendar/ui/CalendarEventBlock.vue
@@ -2,7 +2,7 @@
   <div
     data-calendar-event-block
     :class="[
-      'absolute left-0.5 right-0.5 rounded-md px-2 py-1 text-xs overflow-hidden border',
+      'absolute rounded-md px-2 py-1 text-xs overflow-hidden border',
       hidden ? 'invisible' : isOverdue ? 'cursor-not-allowed' : isVirtual ? 'cursor-default' : 'cursor-grab',
       isOverdue
         ? OVERDUE_EVENT_CLASSES
@@ -11,12 +11,13 @@
           : isVirtual
             ? 'border-dashed border-border bg-muted/40 text-muted-foreground dark:border-border/40 dark:bg-muted/60 dark:text-white dark:backdrop-blur-sm'
             : priorityClasses,
+      highlighted && 'ring-2 ring-inset ring-primary z-20',
     ]"
     :style="blockStyle"
     style="touch-action: none"
     @pointerdown="onPointerDown"
   >
-    <div :class="['font-medium truncate flex items-center gap-1', completed && 'line-through']">
+    <div :class="['font-medium flex items-center gap-1 min-w-0', completed && 'line-through']">
       <RoundCheckbox
         v-if="!isVirtual && !isOverdue"
         :model-value="completed"
@@ -26,7 +27,18 @@
         @update:model-value="emit('toggle', event.taskId)"
       />
       <Repeat v-if="event.isRecurring" :size="10" class="shrink-0" />
-      {{ event.title }}
+      <span class="truncate">{{ event.title }}</span>
+      <button
+        v-if="isVirtual"
+        type="button"
+        data-testid="materialize-occurrence"
+        class="ml-auto shrink-0 rounded p-0.5 hover:bg-foreground/10"
+        aria-label="Проявить задачу"
+        @pointerdown.stop
+        @click.stop="emit('materialize', event)"
+      >
+        <CalendarPlus :size="12" />
+      </button>
     </div>
     <div class="text-[10px] opacity-80">
       {{ timeLabel }}
@@ -46,10 +58,12 @@
 
 <script setup lang="ts">
 import { computed } from 'vue'
-import { Repeat, Timer } from 'lucide-vue-next'
+import { CalendarPlus, Repeat, Timer } from 'lucide-vue-next'
 import RoundCheckbox from '@/components/ui/roundCheckbox/RoundCheckbox.vue'
 import type { CalendarEvent } from '../model/types'
 import { getPriorityEventClasses, OVERDUE_EVENT_CLASSES } from '../lib/calendar-styles'
+import { eventColumnStyle, type EventColumn } from '../lib/layout-overlapping'
+import { highlightedTaskId } from '@/features/tasks/lib/use-recurring-reschedule'
 
 const HOUR_HEIGHT = 60
 const TOTAL_MINUTES = 24 * 60
@@ -57,18 +71,21 @@ const TOTAL_MINUTES = 24 * 60
 const props = defineProps<{
   event: CalendarEvent
   hidden?: boolean
+  layout?: EventColumn
 }>()
 
 const emit = defineEmits<{
   grab: [event: CalendarEvent, pointerEvent: PointerEvent]
   'resize-start': [event: CalendarEvent, pointerEvent: PointerEvent]
   toggle: [taskId: string]
+  materialize: [event: CalendarEvent]
 }>()
 
 const completed = computed(() => props.event.completed)
 const isVirtual = computed(() => !!props.event.isVirtual)
 const priorityClasses = computed(() => getPriorityEventClasses(props.event.priority))
 const isOverdue = computed(() => !!props.event.task.isOverdue)
+const highlighted = computed(() => highlightedTaskId.value === props.event.taskId)
 
 const blockStyle = computed(() => {
   const top = (props.event.startMinutes / TOTAL_MINUTES) * HOUR_HEIGHT * 24
@@ -76,6 +93,7 @@ const blockStyle = computed(() => {
   return {
     top: `${top}px`,
     height: `${height}px`,
+    ...eventColumnStyle(props.layout ?? { col: 0, cols: 1 }),
   }
 })
 
diff --git a/alfy-bot-frontend/src/features/calendar/ui/DayColumn.vue b/alfy-bot-frontend/src/features/calendar/ui/DayColumn.vue
index a1d31f1..ab5629f 100644
--- a/alfy-bot-frontend/src/features/calendar/ui/DayColumn.vue
+++ b/alfy-bot-frontend/src/features/calendar/ui/DayColumn.vue
@@ -12,17 +12,20 @@
       v-for="event in events"
       :key="event.taskId"
       :event="event"
+      :layout="columns.get(event.taskId)"
       :hidden="event.taskId === draggedTaskId"
       @grab="(ev, pe) => $emit('grab', ev, pe)"
       @resize-start="(ev, pe) => $emit('resize-start', ev, pe)"
       @toggle="(taskId) => $emit('toggle', taskId)"
+      @materialize="(event) => $emit('materialize', event)"
     />
   </div>
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
+import { computed, ref } from 'vue'
 import type { CalendarEvent, CalendarDropPayload } from '../model/types'
+import { assignEventColumns } from '../lib/layout-overlapping'
 import CalendarEventBlock from './CalendarEventBlock.vue'
 
 const props = defineProps<{
@@ -37,9 +40,11 @@ const emit = defineEmits<{
   grab: [event: CalendarEvent, pointerEvent: PointerEvent]
   'resize-start': [event: CalendarEvent, pointerEvent: PointerEvent]
   toggle: [taskId: string]
+  materialize: [event: CalendarEvent]
 }>()
 
 const isDragOver = ref(false)
+const columns = computed(() => assignEventColumns(props.events))
 
 function onDrop(e: DragEvent) {
   isDragOver.value = false
diff --git a/alfy-bot-frontend/src/features/calendar/ui/HourGrid.vue b/alfy-bot-frontend/src/features/calendar/ui/HourGrid.vue
index c1ef0a7..fb5b6b0 100644
--- a/alfy-bot-frontend/src/features/calendar/ui/HourGrid.vue
+++ b/alfy-bot-frontend/src/features/calendar/ui/HourGrid.vue
@@ -67,6 +67,7 @@
         @grab="onGrab"
         @resize-start="onResizeStart"
         @toggle="(taskId) => $emit('toggle', taskId)"
+        @materialize="(event) => $emit('materialize', event)"
       />
 
       <!-- Drag overlay ghost -->
@@ -122,6 +123,7 @@ const emit = defineEmits<{
   drop: [payload: CalendarDropPayload]
   open: [event: CalendarEvent]
   toggle: [taskId: string]
+  materialize: [event: CalendarEvent]
 }>()
 
 const trackRef = ref<HTMLElement | null>(null)
diff --git a/alfy-bot-frontend/src/features/calendar/ui/WeeklyCalendar.vue b/alfy-bot-frontend/src/features/calendar/ui/WeeklyCalendar.vue
index 080ca5d..9e82ff6 100644
--- a/alfy-bot-frontend/src/features/calendar/ui/WeeklyCalendar.vue
+++ b/alfy-bot-frontend/src/features/calendar/ui/WeeklyCalendar.vue
@@ -53,6 +53,7 @@
           @drop="onDrop"
           @dragstart="onDragStart"
           @open="onEventOpen"
+          @materialize="onMaterialize"
         />
 
         <!-- Hour grid -->
@@ -70,6 +71,7 @@
           @drop="onDrop"
           @open="onEventOpen"
           @toggle="onToggleTask"
+          @materialize="onMaterialize"
         />
 
       </div>
@@ -80,6 +82,8 @@
 <script setup lang="ts">
 import { ref, computed, onMounted } from 'vue'
 import { useTaskStore } from '@/features/tasks/model/task-store'
+import { useRecurringReschedule } from '@/features/tasks/lib/use-recurring-reschedule'
+import { useConfirm } from '@/composables/useConfirm'
 import { tasksToCalendarEvents } from '../lib/calendar-events'
 import { isToday, formatDayHeader, formatDateRange, getWeekStart, navigateWeek } from '../lib/week'
 import { useCalendarDnd } from '../lib/use-calendar-dnd'
@@ -97,6 +101,8 @@ const emit = defineEmits<{
 
 const taskStore = useTaskStore()
 const { startDrag } = useCalendarDnd()
+const { rescheduleDueDate } = useRecurringReschedule()
+const { confirm } = useConfirm()
 
 const gridRef = ref<HTMLElement | null>(null)
 const { visibleDays, dateRange, dayOffset, dateFromX, scrollToDate, onScroll } = useInfiniteDays(gridRef)
@@ -145,7 +151,9 @@ async function applyTaskMove(taskId: string, newDate: Date, startMinutes?: numbe
     date.setHours(0, 0, 0, 0)
   }
   try {
-    await taskStore.updateTask(taskId, { dueDate: date }, false)
+    const task = taskStore.tasks.find(t => t.id === taskId)
+    if (!task) return
+    await rescheduleDueDate(task, date)
   } catch (err) {
     console.error('Ошибка перемещения задачи:', err)
   }
@@ -177,6 +185,22 @@ function onEventOpen(event: CalendarEvent) {
   }
 }
 
+async function onMaterialize(event: CalendarEvent) {
+  const ok = await confirm({
+    title: 'Проявить задачу на этот день?',
+    message: 'На этом дне появится настоящая задача. Призрак пропадёт.',
+    confirmText: 'Проявить',
+    rememberKey: 'alfy:skip-materialize-confirm',
+    rememberLabel: 'Больше не показывать',
+  })
+  if (!ok) return
+  try {
+    await taskStore.materializeOccurrence(event.taskId)
+  } catch (err) {
+    console.error('Ошибка проявления задачи:', err)
+  }
+}
+
 function onDrop(payload: CalendarDropPayload) {
   if (payload.isVirtual) return
   applyTaskMove(payload.taskId, payload.newDate, payload.startMinutes)
diff --git a/alfy-bot-frontend/src/features/tasks/lib/use-recurring-reschedule.ts b/alfy-bot-frontend/src/features/tasks/lib/use-recurring-reschedule.ts
new file mode 100644
index 0000000..f616a7d
--- /dev/null
+++ b/alfy-bot-frontend/src/features/tasks/lib/use-recurring-reschedule.ts
@@ -0,0 +1,65 @@
+import { ref } from 'vue'
+import { useTaskStore } from '@/features/tasks/model/task-store'
+import { useConfirm } from '@/composables/useConfirm'
+import type { Task, TaskPatch } from '@/features/tasks/model/types'
+
+export const highlightedTaskId = ref<string | null>(null)
+
+export function shouldPromptReschedule(
+  task: Task | undefined,
+  newDueDate: Date | null | undefined,
+): boolean {
+  if (!task?.recurrence) return false
+  if (task.recurringParentId && !task.isAutoCreated) return false
+  if (task.completed || task.isOverdue) return false
+  if (newDueDate == null || !task.dueDate) return false
+  return task.dueDate.getTime() !== newDueDate.getTime()
+}
+
+export interface RescheduleDeps {
+  updateTask: (taskId: string, updates: TaskPatch, setLoading?: boolean) => Promise<unknown>
+  confirm: (opts: {
+    title: string
+    message: string
+    confirmText?: string
+    cancelText?: string
+  }) => Promise<boolean>
+}
+
+export function useRecurringReschedule(deps?: Partial<RescheduleDeps>) {
+  const store = deps?.updateTask ? null : useTaskStore()
+  const updateTask =
+    deps?.updateTask ??
+    ((id: string, updates: TaskPatch, setLoading?: boolean) =>
+      store!.updateTask(id, updates, setLoading))
+  const confirm = deps?.confirm ?? useConfirm().confirm
+
+  async function rescheduleDueDate(task: Task, newDueDate: Date | null) {
+    if (!shouldPromptReschedule(task, newDueDate)) {
+      await updateTask(task.id, { dueDate: newDueDate }, false)
+      return
+    }
+
+    highlightedTaskId.value = task.id
+    try {
+      await updateTask(
+        task.id,
+        { dueDate: newDueDate, rescheduleScope: 'this' },
+        false,
+      )
+      const shiftSubsequent = await confirm({
+        title: 'Сместить расписание?',
+        message: 'Сместить все последующие или оставить как есть?',
+        confirmText: 'Сместить все',
+        cancelText: 'Оставить как есть',
+      })
+      if (shiftSubsequent) {
+        await updateTask(task.id, { rescheduleScope: 'subsequent' }, false)
+      }
+    } finally {
+      highlightedTaskId.value = null
+    }
+  }
+
+  return { rescheduleDueDate, highlightedTaskId }
+}
diff --git a/alfy-bot-frontend/src/features/tasks/lib/use-task-detail-handlers.ts b/alfy-bot-frontend/src/features/tasks/lib/use-task-detail-handlers.ts
index d883aa6..2db171f 100644
--- a/alfy-bot-frontend/src/features/tasks/lib/use-task-detail-handlers.ts
+++ b/alfy-bot-frontend/src/features/tasks/lib/use-task-detail-handlers.ts
@@ -1,10 +1,11 @@
 import { ref, type Ref, isRef, toRef } from 'vue'
-import type { Task, ChecklistItem } from '../model/types'
+import type { Task, ChecklistItem, TaskPatch } from '../model/types'
+import { useRecurringReschedule, shouldPromptReschedule } from './use-recurring-reschedule'
 
 interface TaskStore {
   tasks: Task[] | Ref<Task[]>
   createTask: (taskData: Omit<Task, 'id' | 'pomodoroCompleted'>) => Promise<Task>
-  updateTask: (id: string, updates: Partial<Task>, setLoading?: boolean) => Promise<unknown>
+  updateTask: (id: string, updates: TaskPatch, setLoading?: boolean) => Promise<unknown>
   deleteTask: (id: string) => Promise<void>
   updateChecklist: (id: string, items: ChecklistItem[]) => Promise<void>
   updatePomodoroConfig: (id: string, config: Record<string, unknown> | null) => Promise<void>
@@ -23,6 +24,10 @@ export function useTaskDetailHandlers(store: TaskStore, confirm: ConfirmFn) {
   const autofocusTitle = ref(false)
   const pendingCreateTaskId = ref<string | null>(null)
   const tasks = isRef(store.tasks) ? store.tasks : toRef(store, 'tasks') as Ref<Task[]>
+  const { rescheduleDueDate } = useRecurringReschedule({
+    updateTask: (id, updates, setLoading) => store.updateTask(id, updates, setLoading),
+    confirm,
+  })
 
   function handleOpenTask(task: Task) {
     pendingCreateTaskId.value = null
@@ -84,12 +89,24 @@ export function useTaskDetailHandlers(store: TaskStore, confirm: ConfirmFn) {
     }
     const index = tasks.value.findIndex(t => t.id === updatedTask.id)
     const previous: Task | null = index !== -1 ? { ...tasks.value[index] } as Task : null
+    const optimistic: Task = shouldPromptReschedule(previous ?? undefined, updatedTask.dueDate ?? null)
+      ? {
+          ...updatedTask,
+          recurrenceAnchorDate: previous!.recurrenceAnchorDate ?? previous!.dueDate ?? null,
+        }
+      : updatedTask
 
-    if (index !== -1) tasks.value[index] = updatedTask
-    selectedTask.value = updatedTask
+    if (index !== -1) tasks.value[index] = optimistic
+    selectedTask.value = optimistic
 
     try {
-      await store.updateTask(updatedTask.id, updatedTask, false)
+      const prevDue = previous?.dueDate?.getTime() ?? null
+      const nextDue = updatedTask.dueDate?.getTime() ?? null
+      if (previous && prevDue !== nextDue) {
+        await rescheduleDueDate(previous, updatedTask.dueDate ?? null)
+      } else {
+        await store.updateTask(updatedTask.id, updatedTask, false)
+      }
     } catch {
       if (previous && index !== -1) {
         tasks.value[index] = previous
diff --git a/alfy-bot-frontend/src/features/tasks/model/recurrence.ts b/alfy-bot-frontend/src/features/tasks/model/recurrence.ts
index 7537bd9..79cc786 100644
--- a/alfy-bot-frontend/src/features/tasks/model/recurrence.ts
+++ b/alfy-bot-frontend/src/features/tasks/model/recurrence.ts
@@ -104,6 +104,13 @@ export function findNextOccurrenceOnOrAfter(
   )
 }
 
+export function seriesDueDate(task: {
+  dueDate?: Date | null
+  recurrenceAnchorDate?: Date | null
+}): Date | null {
+  return task.recurrenceAnchorDate ?? task.dueDate ?? null
+}
+
 function computeRawNext(currentDue: Date, rule: RecurrenceRule): Date {
   const { frequency, interval } = rule
 
diff --git a/alfy-bot-frontend/src/features/tasks/model/task-store.ts b/alfy-bot-frontend/src/features/tasks/model/task-store.ts
index a8b4b72..8b68e43 100644
--- a/alfy-bot-frontend/src/features/tasks/model/task-store.ts
+++ b/alfy-bot-frontend/src/features/tasks/model/task-store.ts
@@ -1,7 +1,7 @@
 import { ref, computed } from 'vue'
 import { defineStore } from 'pinia'
 import { api } from '@/api/client'
-import type { Task, ChecklistItem } from './types'
+import type { Task, ChecklistItem, TaskPatch } from './types'
 import { toDate } from '../lib/dateTime'
 
 function serializeDate(value: unknown): string | undefined {
@@ -14,7 +14,9 @@ function serializeDate(value: unknown): string | undefined {
 function serializeTaskDates<T extends Record<string, unknown>>(data: T): T {
   return {
     ...data,
-    ...(data.dueDate !== undefined && { dueDate: serializeDate(data.dueDate) }),
+    ...(data.dueDate !== undefined && {
+      dueDate: data.dueDate === null ? null : serializeDate(data.dueDate),
+    }),
     ...(data.deadline !== undefined && { deadline: serializeDate(data.deadline) }),
   }
 }
@@ -25,6 +27,9 @@ function parseTask(raw: Record<string, unknown>): Task {
   return {
     ...raw,
     dueDate: raw.dueDate ? new Date(raw.dueDate as string) : undefined,
+    recurrenceAnchorDate: raw.recurrenceAnchorDate
+      ? new Date(raw.recurrenceAnchorDate as string)
+      : null,
     deadline: raw.deadline ? new Date(raw.deadline as string) : undefined,
     isPomodoroTask: !!config,
     pomodoroCount: config?.pomodoroCount as number | undefined,
@@ -92,7 +97,7 @@ export const useTaskStore = defineStore('tasks', () => {
     }
   }
 
-  const updateTask = async (taskId: string, updates: Partial<Task>, setLoading = true) => {
+  const updateTask = async (taskId: string, updates: TaskPatch, setLoading = true) => {
     if (taskId.includes('__virtual__')) {
       console.warn('Attempted to update a virtual task instance, ignoring:', taskId)
       return
@@ -115,6 +120,7 @@ export const useTaskStore = defineStore('tasks', () => {
         isPomodoroTask, pomodoroCount, pomodoroDuration,
         shortBreak, longBreak, longBreakInterval, pomodoroCompleted,
         recurringCompletedCount, isAutoCreated, recurringParentId,
+        recurrenceAnchorDate,
         ...rest
       } = updates as Record<string, unknown>
       const { data } = await api.patch(`/tasks/${taskId}`, serializeTaskDates(rest))
@@ -182,13 +188,22 @@ export const useTaskStore = defineStore('tasks', () => {
     const task = tasks.value.find(t => t.id === taskId)
     if (!task) return
 
-    const taskToRestore = { ...task }
+    const snapshot = tasks.value.slice()
     tasks.value = tasks.value.filter(t => t.id !== taskId)
 
     try {
-      await api.delete(`/tasks/${taskId}`)
+      const { data } = await api.delete<{ deletedIds?: string[]; updated?: Record<string, unknown>[] }>(
+        `/tasks/${taskId}`,
+      )
+      const deletedIds = new Set(data?.deletedIds?.length ? data.deletedIds : [taskId])
+      tasks.value = snapshot
+        .filter(t => !deletedIds.has(t.id))
+        .map(t => {
+          const raw = data?.updated?.find(u => u.id === t.id)
+          return raw ? { ...t, ...parseTask(raw) } : t
+        })
     } catch (err) {
-      tasks.value.push(taskToRestore)
+      tasks.value = snapshot
       console.error('Ошибка удаления задачи:', err)
       throw err
     }
@@ -327,6 +342,31 @@ export const useTaskStore = defineStore('tasks', () => {
     }
   }
 
+  const materializeOccurrence = async (virtualTaskId: string) => {
+    const sep = '__virtual__'
+    const idx = virtualTaskId.indexOf(sep)
+    if (idx === -1) {
+      throw new Error('Not a virtual occurrence id')
+    }
+    const sourceId = virtualTaskId.slice(0, idx)
+    const timestamp = Number(virtualTaskId.slice(idx + sep.length))
+    if (!sourceId || !Number.isFinite(timestamp)) {
+      throw new Error('Invalid virtual occurrence id')
+    }
+
+    const { data } = await api.post(`/tasks/${sourceId}/materialize`, {
+      occurrenceDate: new Date(timestamp).toISOString(),
+    })
+    const created = parseTask(data as Record<string, unknown>)
+    const existingIndex = tasks.value.findIndex(t => t.id === created.id)
+    if (existingIndex === -1) {
+      tasks.value.unshift(created)
+    } else {
+      tasks.value[existingIndex] = created
+    }
+    return created
+  }
+
   const completedTasks = computed(() => tasks.value.filter(t => t.completed))
   const pendingTasks = computed(() => tasks.value.filter(t => !t.completed))
   const pomodoroTasks = computed(() => tasks.value.filter(t => t.isPomodoroTask))
@@ -351,5 +391,6 @@ export const useTaskStore = defineStore('tasks', () => {
     incrementPomodoro,
     updateChecklist,
     updatePomodoroConfig,
+    materializeOccurrence,
   }
 })
diff --git a/alfy-bot-frontend/src/features/tasks/model/types.ts b/alfy-bot-frontend/src/features/tasks/model/types.ts
index 221de69..93933a4 100644
--- a/alfy-bot-frontend/src/features/tasks/model/types.ts
+++ b/alfy-bot-frontend/src/features/tasks/model/types.ts
@@ -2,6 +2,8 @@ import type { RecurrenceRule } from './recurrence'
 
 export type Priority = 'high' | 'medium' | 'low'
 
+export type RescheduleScope = 'this' | 'subsequent'
+
 export interface ChecklistItem {
   id: string
   text: string
@@ -18,6 +20,7 @@ export interface Task {
   title: string
   completed: boolean
   dueDate?: Date
+  recurrenceAnchorDate?: Date | null
   deadline?: Date
   durationMinutes?: number
   priority?: Priority
@@ -62,3 +65,8 @@ export interface TaskCardEmits {
   (e: 'delete', id: string): void
   (e: 'open', task: Task): void
 }
+
+export type TaskPatch = Omit<Partial<Task>, 'dueDate'> & {
+  rescheduleScope?: RescheduleScope
+  dueDate?: Date | null
+}
diff --git a/alfy-bot-frontend/tests/composables/useConfirm.spec.ts b/alfy-bot-frontend/tests/composables/useConfirm.spec.ts
new file mode 100644
index 0000000..5d4b67a
--- /dev/null
+++ b/alfy-bot-frontend/tests/composables/useConfirm.spec.ts
@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useConfirm } from '@/composables/useConfirm'
+
+const KEY = 'alfy:skip-materialize-confirm'
+
+if (typeof globalThis.localStorage?.removeItem !== 'function') {
+  const store = new Map<string, string>()
+  globalThis.localStorage = {
+    getItem: (k: string) => store.get(k) ?? null,
+    setItem: (k: string, v: string) => void store.set(k, v),
+    removeItem: (k: string) => void store.delete(k),
+    clear: () => store.clear(),
+    key: (i: number) => [...store.keys()][i] ?? null,
+    get length() { return store.size },
+  } as Storage
+}
+
+describe('useConfirm — rememberKey', () => {
+  beforeEach(() => {
+    localStorage.removeItem(KEY)
+    const { isOpen, handleCancel } = useConfirm()
+    if (isOpen.value) handleCancel()
+  })
+
+  it('не открывает диалог, если localStorage[rememberKey] === "1"', async () => {
+    localStorage.setItem(KEY, '1')
+    const { confirm, isOpen } = useConfirm()
+
+    const result = await confirm({
+      title: 'Проявить?',
+      message: '',
+      rememberKey: KEY,
+    })
+
+    expect(result).toBe(true)
+    expect(isOpen.value).toBe(false)
+  })
+
+  it('открывает диалог, если ключа нет', async () => {
+    const { confirm, isOpen, handleCancel } = useConfirm()
+    const pending = confirm({
+      title: 'Проявить?',
+      message: '',
+      rememberKey: KEY,
+    })
+
+    expect(isOpen.value).toBe(true)
+    handleCancel()
+    expect(await pending).toBe(false)
+    expect(localStorage.getItem(KEY)).toBeNull()
+  })
+
+  it('пишет ключ только по Confirm, не по Cancel', async () => {
+    const { confirm, rememberChecked, handleConfirm, handleCancel } = useConfirm()
+
+    const cancelled = confirm({
+      title: 'Проявить?',
+      message: '',
+      rememberKey: KEY,
+      rememberLabel: 'Больше не показывать',
+    })
+    rememberChecked.value = true
+    handleCancel()
+    expect(await cancelled).toBe(false)
+    expect(localStorage.getItem(KEY)).toBeNull()
+
+    const confirmed = confirm({
+      title: 'Проявить?',
+      message: '',
+      rememberKey: KEY,
+    })
+    rememberChecked.value = true
+    handleConfirm()
+    expect(await confirmed).toBe(true)
+    expect(localStorage.getItem(KEY)).toBe('1')
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/calendar/lib/layout-overlapping.spec.ts b/alfy-bot-frontend/tests/features/calendar/lib/layout-overlapping.spec.ts
new file mode 100644
index 0000000..f21b254
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/calendar/lib/layout-overlapping.spec.ts
@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import {
+  assignEventColumns,
+  eventColumnStyle,
+  MIN_VISUAL_MINUTES,
+} from '@/features/calendar/lib/layout-overlapping'
+import type { CalendarEvent } from '@/features/calendar/model/types'
+import type { Task } from '@/features/tasks/model/types'
+
+const makeTask = (id: string): Task => ({
+  id,
+  title: id,
+  completed: false,
+  pomodoroCompleted: 0,
+})
+
+const ev = (
+  taskId: string,
+  startMinutes: number,
+  durationMinutes: number,
+): CalendarEvent => ({
+  taskId,
+  title: taskId,
+  date: new Date(2026, 3, 8),
+  startMinutes,
+  durationMinutes,
+  isAllDay: false,
+  task: makeTask(taskId),
+  completed: false,
+  resizable: true,
+})
+
+describe('assignEventColumns', () => {
+  it('одиночное событие: одна колонка на всю ширину', () => {
+    const layout = assignEventColumns([ev('a', 600, 60)])
+    expect(layout.get('a')).toEqual({ col: 0, cols: 1 })
+  })
+
+  it('два пересекающихся: две колонки', () => {
+    const layout = assignEventColumns([
+      ev('a', 600, 60),
+      ev('b', 630, 60),
+    ])
+    expect(layout.get('a')).toEqual({ col: 0, cols: 2 })
+    expect(layout.get('b')).toEqual({ col: 1, cols: 2 })
+  })
+
+  it('стык конец=начало: не пересекаются', () => {
+    const layout = assignEventColumns([
+      ev('a', 600, 60),
+      ev('b', 660, 60),
+    ])
+    expect(layout.get('a')).toEqual({ col: 0, cols: 1 })
+    expect(layout.get('b')).toEqual({ col: 0, cols: 1 })
+  })
+
+  it('C переиспользует колонку B после её конца', () => {
+    const layout = assignEventColumns([
+      ev('a', 600, 120),
+      ev('b', 600, 60),
+      ev('c', 660, 60),
+    ])
+    expect(layout.get('a')?.cols).toBe(2)
+    expect(layout.get('b')).toEqual({ col: 1, cols: 2 })
+    expect(layout.get('c')).toEqual({ col: 1, cols: 2 })
+  })
+
+  it('короткие события ближе MIN_VISUAL_MINUTES визуально пересекаются', () => {
+    const layout = assignEventColumns([
+      ev('a', 600, 5),
+      ev('b', 600 + MIN_VISUAL_MINUTES - 1, 5),
+    ])
+    expect(layout.get('a')?.cols).toBe(2)
+    expect(layout.get('b')?.cols).toBe(2)
+  })
+})
+
+describe('eventColumnStyle', () => {
+  it('одна колонка: left/right inset, без width', () => {
+    expect(eventColumnStyle({ col: 0, cols: 1 })).toEqual({
+      left: '2px',
+      right: '2px',
+      zIndex: 1,
+    })
+  })
+
+  it('вторая из двух: половина ширины со сдвигом', () => {
+    const style = eventColumnStyle({ col: 1, cols: 2 })
+    expect(style.left).toBe('calc(50% + 2px)')
+    expect(style.width).toBe('calc(50% - 4px)')
+    expect(style.right).toBe('auto')
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/calendar/ui/AllDaySection.spec.ts b/alfy-bot-frontend/tests/features/calendar/ui/AllDaySection.spec.ts
index ab676dd..4df9466 100644
--- a/alfy-bot-frontend/tests/features/calendar/ui/AllDaySection.spec.ts
+++ b/alfy-bot-frontend/tests/features/calendar/ui/AllDaySection.spec.ts
@@ -74,4 +74,17 @@ describe('AllDaySection', () => {
 
     expect(wrapper.emitted('dragstart')).toBeDefined()
   })
+
+  it('кнопка проявления только на virtual chip, click эмитит materialize', async () => {
+    const virtualEvent = makeEvent({ isVirtual: true, taskId: '1__virtual__1' })
+    const wrapper = mount(AllDaySection, {
+      props: { ...defaultProps, events: [virtualEvent] },
+    })
+    const btn = wrapper.find('[data-testid="materialize-occurrence"]')
+    expect(btn.exists()).toBe(true)
+    await btn.trigger('click')
+    expect(wrapper.emitted('materialize')![0]![0]).toMatchObject({
+      taskId: '1__virtual__1',
+    })
+  })
 })
diff --git a/alfy-bot-frontend/tests/features/calendar/ui/CalendarEventBlock.spec.ts b/alfy-bot-frontend/tests/features/calendar/ui/CalendarEventBlock.spec.ts
index 6981f84..6b5bb9b 100644
--- a/alfy-bot-frontend/tests/features/calendar/ui/CalendarEventBlock.spec.ts
+++ b/alfy-bot-frontend/tests/features/calendar/ui/CalendarEventBlock.spec.ts
@@ -1,8 +1,9 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, afterEach } from 'vitest'
 import { mount } from '@vue/test-utils'
 import CalendarEventBlock from '@/features/calendar/ui/CalendarEventBlock.vue'
 import type { CalendarEvent } from '@/features/calendar/model/types'
 import type { Task } from '@/features/tasks/model/types'
+import { highlightedTaskId } from '@/features/tasks/lib/use-recurring-reschedule'
 
 const makeTask = (overrides: Partial<Task> = {}): Task => ({
   id: '1',
@@ -60,6 +61,21 @@ describe('CalendarEventBlock', () => {
     expect(wrapper.emitted('grab')).toBeUndefined()
   })
 
+  it('кнопка CalendarPlus только на virtual, click эмитит materialize', async () => {
+    const virtual = mount(CalendarEventBlock, {
+      props: { event: makeEvent({ isVirtual: true }) },
+    })
+    const btn = virtual.find('[data-testid="materialize-occurrence"]')
+    expect(btn.exists()).toBe(true)
+    await btn.trigger('click')
+    expect(virtual.emitted('materialize')).toHaveLength(1)
+
+    const real = mount(CalendarEventBlock, {
+      props: { event: makeEvent({ isVirtual: false }) },
+    })
+    expect(real.find('[data-testid="materialize-occurrence"]').exists()).toBe(false)
+  })
+
   // === Resize handle тесты ===
 
   // Позитивные
@@ -111,4 +127,25 @@ describe('CalendarEventBlock', () => {
     })
     expect(wrapper.text()).not.toContain('мин')
   })
+
+  it('пересекающаяся колонка задаёт left/width, не на всю ширину', () => {
+    const wrapper = mount(CalendarEventBlock, {
+      props: { event: makeEvent(), layout: { col: 1, cols: 2 } },
+    })
+    const style = wrapper.attributes('style') ?? ''
+    expect(style).toContain('left: calc(50% + 2px)')
+    expect(style).toContain('width: calc(50% - 4px)')
+  })
+
+  it('подсвечивает блок когда highlightedTaskId совпадает', () => {
+    highlightedTaskId.value = '1'
+    const wrapper = mount(CalendarEventBlock, {
+      props: { event: makeEvent() },
+    })
+    expect(wrapper.classes()).toContain('ring-primary')
+  })
+
+  afterEach(() => {
+    highlightedTaskId.value = null
+  })
 })
diff --git a/alfy-bot-frontend/tests/features/tasks/lib/use-recurring-reschedule.spec.ts b/alfy-bot-frontend/tests/features/tasks/lib/use-recurring-reschedule.spec.ts
new file mode 100644
index 0000000..6c80fba
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/tasks/lib/use-recurring-reschedule.spec.ts
@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  shouldPromptReschedule,
+  useRecurringReschedule,
+  highlightedTaskId,
+} from '@/features/tasks/lib/use-recurring-reschedule'
+import type { Task } from '@/features/tasks/model/types'
+
+const monday = new Date(2026, 3, 6, 10, 0)
+const wednesday = new Date(2026, 3, 8, 15, 0)
+
+const makeTask = (overrides: Partial<Task> = {}): Task => ({
+  id: 't1',
+  title: 'Зарядка',
+  completed: false,
+  dueDate: monday,
+  recurrence: { frequency: 'weekly', interval: 1 },
+  ...overrides,
+})
+
+describe('shouldPromptReschedule', () => {
+  it('true for uncompleted recurring with a different dueDate', () => {
+    expect(shouldPromptReschedule(makeTask(), wednesday)).toBe(true)
+  })
+
+  it('false when dueDate did not change', () => {
+    expect(shouldPromptReschedule(makeTask(), new Date(monday.getTime()))).toBe(false)
+  })
+
+  it('false for non-recurring', () => {
+    expect(shouldPromptReschedule(makeTask({ recurrence: null }), wednesday)).toBe(false)
+  })
+
+  it('false when completed', () => {
+    expect(shouldPromptReschedule(makeTask({ completed: true }), wednesday)).toBe(false)
+  })
+
+  it('false when overdue', () => {
+    expect(shouldPromptReschedule(makeTask({ isOverdue: true }), wednesday)).toBe(false)
+  })
+
+  it('false when clearing dueDate', () => {
+    expect(shouldPromptReschedule(makeTask(), null)).toBe(false)
+  })
+
+  it('false for materialized child — она не ведёт сетку', () => {
+    expect(
+      shouldPromptReschedule(
+        makeTask({ recurringParentId: 'root-1', isAutoCreated: false }),
+        wednesday,
+      ),
+    ).toBe(false)
+  })
+
+  it('true for auto-created cursor после complete', () => {
+    expect(
+      shouldPromptReschedule(
+        makeTask({ recurringParentId: 'root-1', isAutoCreated: true }),
+        wednesday,
+      ),
+    ).toBe(true)
+  })
+})
+
+describe('useRecurringReschedule', () => {
+  let updateTask: ReturnType<typeof vi.fn>
+  let confirm: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    updateTask = vi.fn().mockResolvedValue(undefined)
+    confirm = vi.fn().mockResolvedValue(false)
+    highlightedTaskId.value = null
+  })
+
+  it('this-only: PATCH scope=this, then confirm cancel leaves series', async () => {
+    confirm.mockImplementation(async () => {
+      expect(highlightedTaskId.value).toBe('t1')
+      return false
+    })
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+    await rescheduleDueDate(makeTask(), wednesday)
+
+    expect(updateTask).toHaveBeenCalledTimes(1)
+    expect(updateTask).toHaveBeenCalledWith(
+      't1',
+      { dueDate: wednesday, rescheduleScope: 'this' },
+      false,
+    )
+    expect(confirm).toHaveBeenCalledWith(
+      expect.objectContaining({
+        confirmText: 'Сместить все',
+        cancelText: 'Оставить как есть',
+      }),
+    )
+    expect(highlightedTaskId.value).toBeNull()
+  })
+
+  it('subsequent: second PATCH clears the series via scope=subsequent', async () => {
+    confirm.mockResolvedValueOnce(true)
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+    await rescheduleDueDate(makeTask(), wednesday)
+
+    expect(updateTask).toHaveBeenCalledTimes(2)
+    expect(updateTask.mock.calls[1]).toEqual([
+      't1',
+      { rescheduleScope: 'subsequent' },
+      false,
+    ])
+  })
+
+  it('non-recurring: single PATCH without scope or modal', async () => {
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+    await rescheduleDueDate(makeTask({ recurrence: null }), wednesday)
+
+    expect(confirm).not.toHaveBeenCalled()
+    expect(updateTask).toHaveBeenCalledWith('t1', { dueDate: wednesday }, false)
+  })
+
+  it('materialized child: this-only без модалки', async () => {
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+    await rescheduleDueDate(
+      makeTask({ recurringParentId: 'root-1', isAutoCreated: false }),
+      wednesday,
+    )
+
+    expect(confirm).not.toHaveBeenCalled()
+    expect(updateTask).toHaveBeenCalledWith('t1', { dueDate: wednesday }, false)
+  })
+
+  it('auto-created cursor: модалка this/subsequent', async () => {
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+    await rescheduleDueDate(
+      makeTask({ recurringParentId: 'root-1', isAutoCreated: true }),
+      wednesday,
+    )
+
+    expect(confirm).toHaveBeenCalled()
+    expect(updateTask).toHaveBeenCalledWith(
+      't1',
+      { dueDate: wednesday, rescheduleScope: 'this' },
+      false,
+    )
+  })
+
+  it('второй сдвиг auto-created курсора снова показывает модалку', async () => {
+    const friday = new Date(2026, 3, 10, 12, 0)
+    const task = makeTask({ recurringParentId: 'root-1', isAutoCreated: true })
+    const { rescheduleDueDate } = useRecurringReschedule({ updateTask, confirm })
+
+    await rescheduleDueDate(task, wednesday)
+    await rescheduleDueDate({ ...task, dueDate: wednesday }, friday)
+
+    expect(confirm).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/tasks/lib/use-task-detail-handlers.spec.ts b/alfy-bot-frontend/tests/features/tasks/lib/use-task-detail-handlers.spec.ts
index 92839de..4986943 100644
--- a/alfy-bot-frontend/tests/features/tasks/lib/use-task-detail-handlers.spec.ts
+++ b/alfy-bot-frontend/tests/features/tasks/lib/use-task-detail-handlers.spec.ts
@@ -56,6 +56,28 @@ describe('useTaskDetailHandlers', () => {
     expect(store.updateTask).toHaveBeenCalledWith('1', task, false)
   })
 
+  it('handleUpdateTask при смене dueDate у recurring спрашивает про серию', async () => {
+    const monday = new Date(2026, 3, 6, 10, 0)
+    const wednesday = new Date(2026, 3, 8, 15, 0)
+    const original = makeTask({
+      id: '1',
+      dueDate: monday,
+      recurrence: { frequency: 'weekly', interval: 1 },
+    })
+    store = createMockStore([original])
+    confirmFn.mockResolvedValueOnce(false)
+    const { handleUpdateTask } = useTaskDetailHandlers(store as any, confirmFn)
+
+    await handleUpdateTask({ ...original, dueDate: wednesday })
+
+    expect(store.updateTask).toHaveBeenCalledWith(
+      '1',
+      { dueDate: wednesday, rescheduleScope: 'this' },
+      false,
+    )
+    expect(confirmFn).toHaveBeenCalled()
+  })
+
   it('handleDeleteFromDialog закрывает dialog, подтверждает и удаляет задачу', async () => {
     const { handleDeleteFromDialog, isDetailOpen, selectedTask, handleOpenTask } = setup()
     handleOpenTask(makeTask())
diff --git a/alfy-bot-frontend/tests/features/tasks/model/task-store-materialize.spec.ts b/alfy-bot-frontend/tests/features/tasks/model/task-store-materialize.spec.ts
new file mode 100644
index 0000000..4387e1b
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/tasks/model/task-store-materialize.spec.ts
@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { setActivePinia, createPinia } from 'pinia'
+import { useTaskStore } from '@/features/tasks/model/task-store'
+import { api } from '@/api/client'
+import type { Task } from '@/features/tasks/model/types'
+
+vi.mock('@/api/client', () => ({
+  api: {
+    get: vi.fn(),
+    post: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+    put: vi.fn(),
+  },
+}))
+
+describe('task store materializeOccurrence', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    vi.clearAllMocks()
+  })
+
+  it('парсит virtual id, POST /tasks/:id/materialize, кладёт задачу в стор', async () => {
+    const occurrence = new Date(2026, 3, 13, 10, 0)
+    const virtualId = `root-1__virtual__${occurrence.getTime()}`
+    const created: Task = {
+      id: 'mat-1',
+      title: 'Серия',
+      completed: false,
+      dueDate: occurrence,
+      recurringParentId: 'root-1',
+      isAutoCreated: false,
+    } as Task
+
+    vi.mocked(api.post).mockResolvedValue({ data: created })
+    const store = useTaskStore()
+
+    const result = await store.materializeOccurrence(virtualId)
+
+    expect(api.post).toHaveBeenCalledWith('/tasks/root-1/materialize', {
+      occurrenceDate: occurrence.toISOString(),
+    })
+    expect(result.id).toBe('mat-1')
+    expect(store.tasks[0]!.id).toBe('mat-1')
+  })
+})
diff --git a/alfy-bot/src/app.module.ts b/alfy-bot/src/app.module.ts
index 070bab3..ca91c8f 100644
--- a/alfy-bot/src/app.module.ts
+++ b/alfy-bot/src/app.module.ts
@@ -34,6 +34,7 @@ import {
 import { ScheduleMigrationService } from './shared/database/schedule-migration.service';
 import { QuestionMigrationService } from './shared/database/question-migration.service';
 import { AuthMethodMigrationService } from './shared/database/auth-method-migration.service';
+import { RecurringSeriesRepairService } from './shared/database/recurring-series-repair.service';
 import { SharedModule } from './shared/shared.module';
 
 const telegramImports = isTelegramEnabled()
@@ -87,6 +88,7 @@ const telegramImports = isTelegramEnabled()
     ScheduleMigrationService,
     QuestionMigrationService,
     AuthMethodMigrationService,
+    RecurringSeriesRepairService,
   ],
 })
 export class AppModule {}
diff --git a/alfy-bot/src/modules/task/domain/recurrence.utils.spec.ts b/alfy-bot/src/modules/task/domain/recurrence.utils.spec.ts
index 207ae4c..bc13d9a 100644
--- a/alfy-bot/src/modules/task/domain/recurrence.utils.spec.ts
+++ b/alfy-bot/src/modules/task/domain/recurrence.utils.spec.ts
@@ -5,6 +5,12 @@ import {
   buildNextInstance,
   isSeriesEnded,
   findNextOccurrenceOnOrAfter,
+  seriesDueDate,
+  applyDueDateReschedule,
+  retargetRecurrenceToDate,
+  isSameUtcDay,
+  isOccurrenceOnSeries,
+  findOccupyingInstance,
 } from './recurrence.utils';
 
 function d(iso: string): Date {
@@ -307,6 +313,15 @@ describe('buildNextInstance', () => {
     expect(instance.checklist).toBeNull();
   });
 
+  it('does not copy recurrenceAnchorDate — next instance starts on the series', () => {
+    const instance = buildNextInstance(
+      makeTask({ recurrenceAnchorDate: d('2026-04-05T10:00:00.000Z') }),
+      nextDueDate,
+      parentId,
+    );
+    expect(instance.recurrenceAnchorDate).toBeNull();
+  });
+
   it('null recurrence on task -> recurrence=null on instance', () => {
     const instance = buildNextInstance(
       makeTask({ recurrence: null }),
@@ -390,3 +405,227 @@ describe('findNextOccurrenceOnOrAfter', () => {
     expect(result).toBeNull();
   });
 });
+
+// ── seriesDueDate / applyDueDateReschedule ──────────────────────────
+
+describe('seriesDueDate', () => {
+  it('returns recurrenceAnchorDate when set', () => {
+    expect(
+      seriesDueDate({
+        dueDate: d('2026-04-08T15:00:00.000Z'),
+        recurrenceAnchorDate: d('2026-04-06T10:00:00.000Z'),
+      }),
+    ).toEqual(d('2026-04-06T10:00:00.000Z'));
+  });
+
+  it('falls back to dueDate when anchor is null', () => {
+    expect(
+      seriesDueDate({
+        dueDate: d('2026-04-06T10:00:00.000Z'),
+        recurrenceAnchorDate: null,
+      }),
+    ).toEqual(d('2026-04-06T10:00:00.000Z'));
+  });
+
+  it('returns null when both are null', () => {
+    expect(
+      seriesDueDate({ dueDate: null, recurrenceAnchorDate: null }),
+    ).toBeNull();
+  });
+});
+
+describe('applyDueDateReschedule', () => {
+  const monday = d('2026-04-06T10:00:00.000Z');
+  const wednesday = d('2026-04-08T15:00:00.000Z');
+  const friday = d('2026-04-10T12:00:00.000Z');
+  const weekly = makeRule({ frequency: 'weekly' });
+
+  it('this: sets anchor to old dueDate and moves dueDate', () => {
+    const result = applyDueDateReschedule(
+      { dueDate: monday, recurrenceAnchorDate: null, recurrence: weekly },
+      wednesday,
+      'this',
+    );
+    expect(result.dueDate).toEqual(wednesday);
+    expect(result.recurrenceAnchorDate).toEqual(monday);
+  });
+
+  it('this: does not overwrite an existing anchor on a second move', () => {
+    const result = applyDueDateReschedule(
+      {
+        dueDate: wednesday,
+        recurrenceAnchorDate: monday,
+        recurrence: weekly,
+      },
+      friday,
+      'this',
+    );
+    expect(result.dueDate).toEqual(friday);
+    expect(result.recurrenceAnchorDate).toEqual(monday);
+  });
+
+  it('subsequent: moves dueDate and clears anchor', () => {
+    const result = applyDueDateReschedule(
+      {
+        dueDate: wednesday,
+        recurrenceAnchorDate: monday,
+        recurrence: weekly,
+      },
+      friday,
+      'subsequent',
+    );
+    expect(result.dueDate).toEqual(friday);
+    expect(result.recurrenceAnchorDate).toBeNull();
+  });
+
+  it('clearing dueDate nulls both fields', () => {
+    const result = applyDueDateReschedule(
+      {
+        dueDate: wednesday,
+        recurrenceAnchorDate: monday,
+        recurrence: weekly,
+      },
+      null,
+      'this',
+    );
+    expect(result.dueDate).toBeNull();
+    expect(result.recurrenceAnchorDate).toBeNull();
+  });
+
+  it('this: collapsing back onto the anchor clears it', () => {
+    const result = applyDueDateReschedule(
+      {
+        dueDate: wednesday,
+        recurrenceAnchorDate: monday,
+        recurrence: weekly,
+      },
+      monday,
+      'this',
+    );
+    expect(result.dueDate).toEqual(monday);
+    expect(result.recurrenceAnchorDate).toBeNull();
+  });
+
+  it('non-recurring: moves dueDate and does not set an anchor', () => {
+    const result = applyDueDateReschedule(
+      { dueDate: monday, recurrenceAnchorDate: null, recurrence: null },
+      wednesday,
+      'this',
+    );
+    expect(result.dueDate).toEqual(wednesday);
+    expect(result.recurrenceAnchorDate).toBeNull();
+  });
+});
+
+describe('retargetRecurrenceToDate', () => {
+  const monday = d('2026-04-06T10:00:00.000Z');
+  const wednesday = d('2026-04-08T15:00:00.000Z');
+
+  it('weekly daysOfWeek: сдвигает набор дней на дельту weekday', () => {
+    expect(
+      retargetRecurrenceToDate(
+        makeRule({ frequency: 'weekly', daysOfWeek: [1] }),
+        monday,
+        wednesday,
+      ).daysOfWeek,
+    ).toEqual([3]);
+  });
+
+  it('weekly Mon/Wed/Fri → +2 дня: Wed/Fri/Sun', () => {
+    expect(
+      retargetRecurrenceToDate(
+        makeRule({ frequency: 'weekly', daysOfWeek: [1, 3, 5] }),
+        monday,
+        wednesday,
+      ).daysOfWeek,
+    ).toEqual([0, 3, 5]);
+  });
+
+  it('weekly без daysOfWeek: правило не меняется', () => {
+    const rule = makeRule({ frequency: 'weekly' });
+    expect(retargetRecurrenceToDate(rule, monday, wednesday)).toEqual(rule);
+  });
+
+  it('monthly: dayOfMonth = число toDate', () => {
+    expect(
+      retargetRecurrenceToDate(
+        makeRule({ frequency: 'monthly', dayOfMonth: 6 }),
+        monday,
+        wednesday,
+      ).dayOfMonth,
+    ).toBe(8);
+  });
+});
+
+describe('isSameUtcDay', () => {
+  it('true for same calendar day different time', () => {
+    expect(
+      isSameUtcDay(d('2026-04-13T10:00:00.000Z'), d('2026-04-13T15:30:00.000Z')),
+    ).toBe(true);
+  });
+
+  it('false for adjacent days', () => {
+    expect(
+      isSameUtcDay(d('2026-04-13T10:00:00.000Z'), d('2026-04-14T10:00:00.000Z')),
+    ).toBe(false);
+  });
+});
+
+describe('isOccurrenceOnSeries', () => {
+  const origin = d('2026-04-06T10:00:00.000Z');
+  const weekly = makeRule({ frequency: 'weekly' });
+
+  it('origin itself is not a future occurrence', () => {
+    expect(isOccurrenceOnSeries(origin, weekly, origin)).toBe(false);
+  });
+
+  it('next weekly step is on the series', () => {
+    expect(
+      isOccurrenceOnSeries(origin, weekly, d('2026-04-13T10:00:00.000Z')),
+    ).toBe(true);
+  });
+
+  it('off-grid day is not on the series', () => {
+    expect(
+      isOccurrenceOnSeries(origin, weekly, d('2026-04-08T10:00:00.000Z')),
+    ).toBe(false);
+  });
+
+  it('same calendar day different time still counts as on-series', () => {
+    expect(
+      isOccurrenceOnSeries(origin, weekly, d('2026-04-13T18:00:00.000Z')),
+    ).toBe(true);
+  });
+
+  it('слот дальше 52 интервалов от origin всё ещё на сетке', () => {
+    const daily = makeRule({ frequency: 'daily' });
+    expect(
+      isOccurrenceOnSeries(origin, daily, d('2026-06-05T10:00:00.000Z')),
+    ).toBe(true);
+  });
+});
+
+describe('findOccupyingInstance', () => {
+  const monday = d('2026-04-13T10:00:00.000Z');
+
+  it('finds a member whose series slot is that day', () => {
+    const members = [
+      { dueDate: d('2026-04-06T10:00:00.000Z'), recurrenceAnchorDate: null },
+      {
+        dueDate: d('2026-04-15T15:00:00.000Z'),
+        recurrenceAnchorDate: monday,
+      },
+    ];
+    const found = findOccupyingInstance(members, d('2026-04-13T10:00:00.000Z'));
+    expect(found).toBe(members[1]);
+  });
+
+  it('returns undefined when the slot is free', () => {
+    const members = [
+      { dueDate: d('2026-04-06T10:00:00.000Z'), recurrenceAnchorDate: null },
+    ];
+    expect(
+      findOccupyingInstance(members, d('2026-04-13T10:00:00.000Z')),
+    ).toBeUndefined();
+  });
+});
diff --git a/alfy-bot/src/modules/task/domain/recurrence.utils.ts b/alfy-bot/src/modules/task/domain/recurrence.utils.ts
index cdf46c0..bc9773d 100644
--- a/alfy-bot/src/modules/task/domain/recurrence.utils.ts
+++ b/alfy-bot/src/modules/task/domain/recurrence.utils.ts
@@ -1,12 +1,15 @@
 import type { RecurrenceRule } from '../../../shared/types/recurrence.types';
 import type { ChecklistData } from '../../../shared/types/checklist.types';
 
+export type RescheduleScope = 'this' | 'subsequent';
+
 /** Plain snapshot of task fields needed by domain logic — no ORM dependency. */
 export interface RecurringTaskSnapshot {
   title: string;
   description: string | null;
   priority: string | null;
   dueDate: Date | null;
+  recurrenceAnchorDate?: Date | null;
   deadline: Date | null;
   location: string | null;
   tags: string[] | null;
@@ -19,6 +22,76 @@ export interface RecurringTaskSnapshot {
   onMissed: 'shift' | 'freeze';
 }
 
+export interface SeriesDueFields {
+  dueDate: Date | null;
+  recurrenceAnchorDate: Date | null;
+}
+
+export interface Rescheduleable extends SeriesDueFields {
+  recurrence: RecurrenceRule | null;
+}
+
+/** Series slot used to project ghosts and spawn the next instance. */
+export function seriesDueDate(task: SeriesDueFields): Date | null {
+  return task.recurrenceAnchorDate ?? task.dueDate;
+}
+
+/**
+ * Move this instance and/or the series anchor.
+ * `this` keeps the original schedule; `subsequent` makes the new dueDate the series slot.
+ */
+export function applyDueDateReschedule(
+  task: Rescheduleable,
+  newDueDate: Date | null,
+  scope: RescheduleScope,
+): SeriesDueFields {
+  if (newDueDate === null) {
+    return { dueDate: null, recurrenceAnchorDate: null };
+  }
+
+  if (!task.recurrence) {
+    return { dueDate: newDueDate, recurrenceAnchorDate: null };
+  }
+
+  if (scope === 'subsequent') {
+    return { dueDate: newDueDate, recurrenceAnchorDate: null };
+  }
+
+  const anchor = task.recurrenceAnchorDate ?? task.dueDate;
+  if (anchor && anchor.getTime() === newDueDate.getTime()) {
+    return { dueDate: newDueDate, recurrenceAnchorDate: null };
+  }
+
+  return { dueDate: newDueDate, recurrenceAnchorDate: anchor };
+}
+
+/**
+ * Shift the rule so remaining occurrences follow `toDate`'s wall-clock
+ * weekday / day-of-month. Dates must already be in user wall-clock UTC fields.
+ */
+export function retargetRecurrenceToDate(
+  rule: RecurrenceRule,
+  fromSlot: Date,
+  toDate: Date,
+): RecurrenceRule {
+  if (rule.frequency === 'weekly' && rule.daysOfWeek && rule.daysOfWeek.length > 0) {
+    const delta = (toDate.getUTCDay() - fromSlot.getUTCDay() + 7) % 7;
+    if (delta === 0) return rule;
+    const daysOfWeek = [
+      ...new Set(rule.daysOfWeek.map((day) => (day + delta) % 7)),
+    ].sort((a, b) => a - b);
+    return { ...rule, daysOfWeek };
+  }
+
+  if (rule.frequency === 'monthly') {
+    const dayOfMonth = toDate.getUTCDate();
+    if (rule.dayOfMonth === dayOfMonth) return rule;
+    return { ...rule, dayOfMonth };
+  }
+
+  return rule;
+}
+
 export function isSeriesEnded(
   rule: RecurrenceRule,
   completedCount: number,
@@ -144,13 +217,14 @@ export interface NextInstanceData {
   description: string | null;
   priority: string | null;
   dueDate: Date;
+  recurrenceAnchorDate: null;
   deadline: Date | null;
   location: string | null;
   tags: string[] | null;
   recurrence: RecurrenceRule | null;
   recurringParentId: string;
   recurringCompletedCount: 0;
-  isAutoCreated: true;
+  isAutoCreated: boolean;
   completed: false;
   userId: number;
   projectId: string | null;
@@ -174,6 +248,7 @@ export function buildNextInstance(
     description: completedTask.description,
     priority: completedTask.priority,
     dueDate: nextDueDate,
+    recurrenceAnchorDate: null,
     deadline: completedTask.deadline,
     location: completedTask.location,
     tags: completedTask.tags ? [...completedTask.tags] : null,
@@ -223,6 +298,49 @@ export function findNextOccurrenceOnOrAfter(
   );
 }
 
+export function isSameUtcDay(a: Date, b: Date): boolean {
+  return (
+    a.getUTCFullYear() === b.getUTCFullYear() &&
+    a.getUTCMonth() === b.getUTCMonth() &&
+    a.getUTCDate() === b.getUTCDate()
+  );
+}
+
+/** True if `occurrenceDate` is a future step of the series starting at `originDue`. */
+export function isOccurrenceOnSeries(
+  originDue: Date,
+  rule: RecurrenceRule,
+  occurrenceDate: Date,
+  completedCount = 0,
+): boolean {
+  const startOfOccurrenceDay = new Date(occurrenceDate);
+  startOfOccurrenceDay.setUTCHours(0, 0, 0, 0);
+
+  let landed: Date | null;
+  try {
+    landed = findNextOccurrenceOnOrAfter(
+      originDue,
+      rule,
+      startOfOccurrenceDay,
+      completedCount,
+    );
+  } catch {
+    return false;
+  }
+
+  return landed !== null && isSameUtcDay(landed, occurrenceDate);
+}
+
+export function findOccupyingInstance<T extends SeriesDueFields>(
+  members: T[],
+  slotDate: Date,
+): T | undefined {
+  return members.find((member) => {
+    const slot = seriesDueDate(member);
+    return slot !== null && isSameUtcDay(slot, slotDate);
+  });
+}
+
 function resetChecklist(checklist: ChecklistData | null): ChecklistData | null {
   if (!checklist || !checklist.items || checklist.items.length === 0) {
     return null;
diff --git a/alfy-bot/src/modules/task/dto/materialize-occurrence.dto.ts b/alfy-bot/src/modules/task/dto/materialize-occurrence.dto.ts
new file mode 100644
index 0000000..b32ac5b
--- /dev/null
+++ b/alfy-bot/src/modules/task/dto/materialize-occurrence.dto.ts
@@ -0,0 +1,8 @@
+import { IsDateString } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class MaterializeOccurrenceDto {
+  @ApiProperty({ example: '2026-04-13T10:00:00.000Z' })
+  @IsDateString()
+  occurrenceDate: string;
+}
diff --git a/alfy-bot/src/modules/task/dto/update-task.dto.ts b/alfy-bot/src/modules/task/dto/update-task.dto.ts
index f35b633..d0579b9 100644
--- a/alfy-bot/src/modules/task/dto/update-task.dto.ts
+++ b/alfy-bot/src/modules/task/dto/update-task.dto.ts
@@ -1,5 +1,5 @@
 import { PartialType } from '@nestjs/swagger';
-import { IsBoolean, IsOptional } from 'class-validator';
+import { IsBoolean, IsIn, IsOptional } from 'class-validator';
 import { ApiPropertyOptional } from '@nestjs/swagger';
 import { CreateTaskDto } from './create-task.dto';
 
@@ -9,6 +9,11 @@ export class UpdateTaskDto extends PartialType(CreateTaskDto) {
   @IsBoolean()
   completed?: boolean;
 
+  @ApiPropertyOptional({ enum: ['this', 'subsequent'] })
+  @IsOptional()
+  @IsIn(['this', 'subsequent'])
+  rescheduleScope?: 'this' | 'subsequent';
+
   // Explicitly exclude checklist — use PUT /tasks/:id/checklist instead
   checklist?: never;
 
diff --git a/alfy-bot/src/modules/task/overdue-recurring.service.spec.ts b/alfy-bot/src/modules/task/overdue-recurring.service.spec.ts
index ec75990..4d43678 100644
--- a/alfy-bot/src/modules/task/overdue-recurring.service.spec.ts
+++ b/alfy-bot/src/modules/task/overdue-recurring.service.spec.ts
@@ -15,6 +15,7 @@ function makeTask(overrides: Partial<Task> = {}): Task {
     completed: false,
     priority: null,
     dueDate: null,
+    recurrenceAnchorDate: null,
     deadline: null,
     location: null,
     tags: null,
@@ -193,6 +194,36 @@ describe('OverdueRecurringService', () => {
       const [, successor] = repo.freezeAndCreateNext.mock.calls[0];
       expect(successor.pomodoroConfig).toBeUndefined();
     });
+
+    it('следующий слот занят проявленным → freeze без successor', async () => {
+      const candidate = makeTask({
+        id: 't1',
+        userId: 1,
+        dueDate: new Date('2026-04-28T09:00:00.000Z'),
+        completed: false,
+        isOverdue: false,
+        recurrence: dailyRule,
+        onMissed: 'freeze',
+        recurringParentId: null,
+        recurringCompletedCount: 0,
+      });
+      const occupying = makeTask({
+        id: 'mat-1',
+        recurringParentId: 't1',
+        dueDate: new Date('2026-04-29T09:00:00.000Z'),
+        isAutoCreated: false,
+      });
+      repo.findOverdueRecurringCandidates.mockResolvedValue([candidate]);
+      repo.findByParentId.mockResolvedValue([candidate, occupying]);
+
+      await service.processForUser(
+        1,
+        'UTC',
+        new Date('2026-04-29T00:00:00.000Z'),
+      );
+
+      expect(repo.freezeAndCreateNext).toHaveBeenCalledWith('t1', null);
+    });
   });
 
   describe('processForUser — shift branch', () => {
@@ -226,6 +257,67 @@ describe('OverdueRecurringService', () => {
       );
     });
 
+    it('this-only: next от якоря, якорь сбрасывается', async () => {
+      const candidate = makeTask({
+        id: 't1',
+        userId: 1,
+        dueDate: new Date('2026-04-28T15:00:00.000Z'),
+        recurrenceAnchorDate: new Date('2026-04-27T09:00:00.000Z'),
+        completed: false,
+        isOverdue: false,
+        recurrence: dailyRule,
+        onMissed: 'shift',
+        recurringParentId: null,
+        recurringCompletedCount: 0,
+      });
+      repo.findOverdueRecurringCandidates.mockResolvedValue([candidate]);
+
+      await service.processForUser(
+        1,
+        'UTC',
+        new Date('2026-04-29T00:00:00.000Z'),
+      );
+
+      const saved = repo.save.mock.calls[0][0];
+      expect(saved.dueDate.getTime()).toBe(
+        new Date('2026-04-29T09:00:00.000Z').getTime(),
+      );
+      expect(saved.recurrenceAnchorDate).toBeNull();
+    });
+
+    it('занятый слот → прыгает через него', async () => {
+      const candidate = makeTask({
+        id: 't1',
+        userId: 1,
+        dueDate: new Date('2026-04-28T09:00:00.000Z'),
+        completed: false,
+        isOverdue: false,
+        recurrence: dailyRule,
+        onMissed: 'shift',
+        recurringParentId: null,
+        recurringCompletedCount: 0,
+      });
+      const occupying = makeTask({
+        id: 'mat-1',
+        recurringParentId: 't1',
+        dueDate: new Date('2026-04-29T09:00:00.000Z'),
+        isAutoCreated: false,
+      });
+      repo.findOverdueRecurringCandidates.mockResolvedValue([candidate]);
+      repo.findByParentId.mockResolvedValue([candidate, occupying]);
+
+      await service.processForUser(
+        1,
+        'UTC',
+        new Date('2026-04-29T00:00:00.000Z'),
+      );
+
+      const saved = repo.save.mock.calls[0][0];
+      expect(saved.dueDate.getTime()).toBe(
+        new Date('2026-04-30T09:00:00.000Z').getTime(),
+      );
+    });
+
     it('серия закончилась → recurrence=null, dueDate без изменений', async () => {
       const originalDue = new Date('2026-04-28T09:00:00.000Z');
       const candidate = makeTask({
diff --git a/alfy-bot/src/modules/task/overdue-recurring.service.ts b/alfy-bot/src/modules/task/overdue-recurring.service.ts
index 21c0977..46d1b4d 100644
--- a/alfy-bot/src/modules/task/overdue-recurring.service.ts
+++ b/alfy-bot/src/modules/task/overdue-recurring.service.ts
@@ -6,6 +6,8 @@ import {
   buildNextInstance,
   computeNextDueDate,
   findNextOccurrenceOnOrAfter,
+  findOccupyingInstance,
+  seriesDueDate,
 } from './domain/recurrence.utils';
 import { shiftBackToUtc, shiftToUserWallClock } from './lib/timezone';
 
@@ -61,11 +63,30 @@ export class OverdueRecurringService {
         : task;
       const completedCount = rootTask?.recurringCompletedCount ?? 0;
 
-      const zonedDue = shiftToUserWallClock(task.dueDate!, tz);
+      const seriesDue = seriesDueDate({
+        dueDate: task.dueDate,
+        recurrenceAnchorDate: task.recurrenceAnchorDate ?? null,
+      });
+      const zonedDue = shiftToUserWallClock(seriesDue!, tz);
+
+      const members = await this.taskRepo.findByParentId(parentId, true);
+      const others = members.filter((m) => m.id !== task.id);
+      const slotOccupied = (slotZoned: Date) =>
+        !!findOccupyingInstance(
+          others.map((m) => ({
+            dueDate: m.dueDate ? shiftToUserWallClock(m.dueDate, tz) : null,
+            recurrenceAnchorDate: m.recurrenceAnchorDate
+              ? shiftToUserWallClock(m.recurrenceAnchorDate, tz)
+              : null,
+          })),
+          slotZoned,
+        );
 
       if (task.onMissed === 'freeze') {
         const nextZoned = computeNextDueDate(zonedDue, rule, completedCount);
-        const nextDate = nextZoned ? shiftBackToUtc(nextZoned, tz) : null;
+        const occupied = nextZoned ? slotOccupied(nextZoned) : false;
+        const nextDate =
+          nextZoned && !occupied ? shiftBackToUtc(nextZoned, tz) : null;
         let successorData: Partial<Task> | null = nextDate
           ? buildNextInstance(task, nextDate, parentId)
           : null;
@@ -84,12 +105,17 @@ export class OverdueRecurringService {
           startOfTodayLocal,
           completedCount,
         );
+        let cursor = nextZoned;
+        while (cursor && slotOccupied(cursor)) {
+          cursor = computeNextDueDate(cursor, rule, completedCount);
+        }
 
-        if (nextZoned === null) {
+        if (cursor === null) {
           task.recurrence = null;
           await this.taskRepo.save(task);
         } else {
-          task.dueDate = shiftBackToUtc(nextZoned, tz);
+          task.dueDate = shiftBackToUtc(cursor, tz);
+          task.recurrenceAnchorDate = null;
           await this.taskRepo.save(task);
         }
       }
diff --git a/alfy-bot/src/modules/task/task.controller.ts b/alfy-bot/src/modules/task/task.controller.ts
index 0650a9c..23c7d7f 100644
--- a/alfy-bot/src/modules/task/task.controller.ts
+++ b/alfy-bot/src/modules/task/task.controller.ts
@@ -25,6 +25,7 @@ import { UpdatePomodoroConfigDto } from './dto/update-pomodoro-config.dto';
 import { UpsertTimerSessionDto } from './dto/upsert-timer-session.dto';
 import { ReorderInboxTasksDto } from './dto/reorder-inbox-tasks.dto';
 import { MoveTaskToInboxDto } from './dto/move-task-inbox.dto';
+import { MaterializeOccurrenceDto } from './dto/materialize-occurrence.dto';
 
 interface AuthRequest extends Request {
   user: JwtPayload;
@@ -140,6 +141,16 @@ export class TaskController {
     return this.taskService.updatePomodoroConfig(req.user.sub, id, null);
   }
 
+  @Post(':id/materialize')
+  @ApiOperation({ summary: 'Проявить виртуальное вхождение повторяющейся задачи' })
+  async materialize(
+    @Request() req: AuthRequest,
+    @Param('id') id: string,
+    @Body() dto: MaterializeOccurrenceDto,
+  ) {
+    return this.taskService.materializeOccurrence(req.user.sub, id, dto);
+  }
+
   @Patch(':id')
   @ApiOperation({ summary: 'Обновить задачу' })
   async update(
diff --git a/alfy-bot/src/modules/task/task.service.spec.ts b/alfy-bot/src/modules/task/task.service.spec.ts
index 687889e..5084cda 100644
--- a/alfy-bot/src/modules/task/task.service.spec.ts
+++ b/alfy-bot/src/modules/task/task.service.spec.ts
@@ -16,6 +16,7 @@ function makeTask(overrides: Partial<Task> = {}): Task {
     completed: false,
     priority: null,
     dueDate: null,
+    recurrenceAnchorDate: null,
     deadline: null,
     location: null,
     tags: null,
@@ -242,6 +243,247 @@ describe('TaskService', () => {
     });
   });
 
+  describe('update — reschedule recurring dueDate', () => {
+    const monday = new Date('2026-04-06T10:00:00.000Z');
+    const wednesday = new Date('2026-04-08T15:00:00.000Z');
+    const weekly: RecurrenceRule = { frequency: 'weekly', interval: 1 };
+
+    it('default scope this: sets anchor to old dueDate', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: weekly,
+          dueDate: monday,
+          recurrenceAnchorDate: null,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        dueDate: wednesday.toISOString(),
+      });
+
+      expect(result.task.dueDate).toEqual(wednesday);
+      expect(result.task.recurrenceAnchorDate).toEqual(monday);
+    });
+
+    it('повторный this не перезаписывает якорь', async () => {
+      const friday = new Date('2026-04-10T12:00:00.000Z');
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: weekly,
+          dueDate: wednesday,
+          recurrenceAnchorDate: monday,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        dueDate: friday.toISOString(),
+        rescheduleScope: 'this',
+      });
+
+      expect(result.task.dueDate).toEqual(friday);
+      expect(result.task.recurrenceAnchorDate).toEqual(monday);
+    });
+
+    it('subsequent: dueDate новый, якорь сброшен', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: weekly,
+          dueDate: wednesday,
+          recurrenceAnchorDate: monday,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        dueDate: wednesday.toISOString(),
+        rescheduleScope: 'subsequent',
+      });
+
+      expect(result.task.dueDate).toEqual(wednesday);
+      expect(result.task.recurrenceAnchorDate).toBeNull();
+    });
+
+    it('subsequent с dueDate: daysOfWeek сдвигается на новый день', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: { frequency: 'weekly', interval: 1, daysOfWeek: [1] },
+          dueDate: monday,
+          recurrenceAnchorDate: null,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        dueDate: wednesday.toISOString(),
+        rescheduleScope: 'subsequent',
+      });
+
+      expect(result.task.recurrenceAnchorDate).toBeNull();
+      expect(result.task.recurrence).toEqual(
+        expect.objectContaining({ daysOfWeek: [3] }),
+      );
+    });
+
+    it('subsequent без dueDate: только сбрасывает якорь', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: weekly,
+          dueDate: wednesday,
+          recurrenceAnchorDate: monday,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        rescheduleScope: 'subsequent',
+      });
+
+      expect(result.task.dueDate).toEqual(wednesday);
+      expect(result.task.recurrenceAnchorDate).toBeNull();
+    });
+
+    it('subsequent без dueDate: daysOfWeek сдвигается с якоря на dueDate', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: { frequency: 'weekly', interval: 1, daysOfWeek: [1] },
+          dueDate: wednesday,
+          recurrenceAnchorDate: monday,
+        }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        rescheduleScope: 'subsequent',
+      });
+
+      expect(result.task.recurrenceAnchorDate).toBeNull();
+      expect(result.task.recurrence).toEqual(
+        expect.objectContaining({ daysOfWeek: [3] }),
+      );
+    });
+
+    it('reschedule auto-created курсора не сбрасывает isAutoCreated', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({
+          recurrence: weekly,
+          dueDate: monday,
+          recurringParentId: 'root-1',
+          isAutoCreated: true,
+        }),
+      );
+
+      const thisOnly = await service.update(1, 'task-1', {
+        dueDate: wednesday.toISOString(),
+        rescheduleScope: 'this',
+      });
+      expect(thisOnly.task.isAutoCreated).toBe(true);
+
+      repo.findById.mockResolvedValue(thisOnly.task);
+      const subsequent = await service.update(1, 'task-1', {
+        rescheduleScope: 'subsequent',
+      });
+      expect(subsequent.task.isAutoCreated).toBe(true);
+    });
+
+    it('non-recurring PATCH dueDate не ставит якорь', async () => {
+      repo.findById.mockResolvedValue(
+        makeTask({ recurrence: null, dueDate: monday }),
+      );
+
+      const result = await service.update(1, 'task-1', {
+        dueDate: wednesday.toISOString(),
+      });
+
+      expect(result.task.dueDate).toEqual(wednesday);
+      expect(result.task.recurrenceAnchorDate).toBeNull();
+    });
+  });
+
+  describe('materializeOccurrence', () => {
+    const weekly: RecurrenceRule = { frequency: 'weekly', interval: 1 };
+    const monday = new Date('2026-04-06T10:00:00.000Z');
+    const nextMonday = new Date('2026-04-13T10:00:00.000Z');
+
+    it('создаёт инстанс на слоте серии с isAutoCreated=false', async () => {
+      const source = makeTask({
+        id: 'root-1',
+        recurrence: weekly,
+        dueDate: monday,
+        completed: false,
+      });
+      repo.findById.mockResolvedValue(source);
+      repo.findByParentId.mockResolvedValue([source]);
+
+      const result = await service.materializeOccurrence(1, 'root-1', {
+        occurrenceDate: nextMonday.toISOString(),
+      });
+
+      expect(repo.create).toHaveBeenCalledTimes(1);
+      const arg = repo.create.mock.calls[0][0] as Partial<Task>;
+      expect(arg.dueDate).toEqual(nextMonday);
+      expect(arg.isAutoCreated).toBe(false);
+      expect(arg.recurringParentId).toBe('root-1');
+      expect(arg.recurrenceAnchorDate).toBeNull();
+      expect(result).toBeDefined();
+    });
+
+    it('completed root: проявляет слот по сетке первой машины', async () => {
+      const source = makeTask({
+        id: 'root-1',
+        recurrence: weekly,
+        dueDate: monday,
+        completed: true,
+        recurringCompletedCount: 1,
+      });
+      repo.findById.mockResolvedValue(source);
+      repo.findByParentId.mockResolvedValue([]);
+
+      await service.materializeOccurrence(1, 'root-1', {
+        occurrenceDate: nextMonday.toISOString(),
+      });
+
+      expect(repo.create).toHaveBeenCalledTimes(1);
+      const arg = repo.create.mock.calls[0][0] as Partial<Task>;
+      expect(arg.dueDate).toEqual(nextMonday);
+      expect(arg.isAutoCreated).toBe(false);
+      expect(arg.recurringParentId).toBe('root-1');
+    });
+
+    it('повтор того же дня → 400', async () => {
+      const source = makeTask({
+        id: 'root-1',
+        recurrence: weekly,
+        dueDate: monday,
+      });
+      const existing = makeTask({
+        id: 'mat-1',
+        recurringParentId: 'root-1',
+        dueDate: nextMonday,
+      });
+      repo.findById.mockResolvedValue(source);
+      repo.findByParentId.mockResolvedValue([source, existing]);
+
+      await expect(
+        service.materializeOccurrence(1, 'root-1', {
+          occurrenceDate: nextMonday.toISOString(),
+        }),
+      ).rejects.toThrow(BadRequestException);
+      expect(repo.create).not.toHaveBeenCalled();
+    });
+
+    it('день не на сетке серии → 400', async () => {
+      const source = makeTask({
+        id: 'root-1',
+        recurrence: weekly,
+        dueDate: monday,
+      });
+      repo.findById.mockResolvedValue(source);
+      repo.findByParentId.mockResolvedValue([source]);
+
+      await expect(
+        service.materializeOccurrence(1, 'root-1', {
+          occurrenceDate: new Date('2026-04-08T10:00:00.000Z').toISOString(),
+        }),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
   describe('updatePomodoroConfig', () => {
     it('обновляет конфиг при существующем', async () => {
       const config = makePomodoroConfig();
@@ -479,6 +721,80 @@ describe('TaskService', () => {
       // currentDue=April 5 10:00, daily rule → first valid >= April 29 00:00 is April 29 10:00.
       expect(instanceArg.dueDate).toEqual(new Date('2026-04-29T10:00:00.000Z'));
     });
+
+    it('complete после this-only: next instance от якоря, не от сдвинутого dueDate', async () => {
+      jest.setSystemTime(new Date('2026-04-08T15:00:00.000Z'));
+      const task = makeTask({
+        id: 'root-1',
+        recurrence: { frequency: 'weekly', interval: 1 },
+        dueDate: new Date('2026-04-08T15:00:00.000Z'),
+        recurrenceAnchorDate: new Date('2026-04-06T10:00:00.000Z'),
+        completed: false,
+        recurringParentId: null,
+        recurringCompletedCount: 0,
+      });
+      repo.findById.mockResolvedValue(task);
+      repo.findByParentId.mockResolvedValue([task]);
+
+      await service.update(1, 'root-1', { completed: true });
+
+      const instanceArg = repo.create.mock.calls[0][0] as Partial<Task>;
+      expect(instanceArg.dueDate).toEqual(new Date('2026-04-13T10:00:00.000Z'));
+      expect(instanceArg.recurrenceAnchorDate).toBeNull();
+    });
+
+    it('complete после subsequent: next по новой сетке, не по исходной', async () => {
+      jest.setSystemTime(new Date('2026-04-08T15:00:00.000Z'));
+      const task = makeTask({
+        id: 'inst-1',
+        recurrence: { frequency: 'weekly', interval: 1, daysOfWeek: [3] },
+        dueDate: new Date('2026-04-08T15:00:00.000Z'),
+        recurrenceAnchorDate: null,
+        completed: false,
+        recurringParentId: 'root-1',
+        isAutoCreated: false,
+        recurringCompletedCount: 0,
+      });
+      const root = makeTask({
+        id: 'root-1',
+        recurrence: { frequency: 'weekly', interval: 1, daysOfWeek: [1] },
+        dueDate: new Date('2026-04-06T10:00:00.000Z'),
+        completed: true,
+        recurringCompletedCount: 1,
+      });
+      repo.findById
+        .mockResolvedValueOnce(task)
+        .mockResolvedValueOnce(root);
+      repo.findByParentId.mockResolvedValue([task]);
+
+      await service.update(1, 'inst-1', { completed: true });
+
+      const instanceArg = repo.create.mock.calls[0][0] as Partial<Task>;
+      expect(instanceArg.dueDate).toEqual(new Date('2026-04-15T15:00:00.000Z'));
+      expect(instanceArg.recurrence).toEqual(
+        expect.objectContaining({ daysOfWeek: [3] }),
+      );
+    });
+
+    it('complete когда следующий слот проявлен: не create, count++, return occupying', async () => {
+      const task = rootTask();
+      const occupying = makeTask({
+        id: 'mat-1',
+        recurringParentId: 'root-1',
+        dueDate: new Date('2026-04-06T10:00:00.000Z'),
+        recurrence: dailyRule,
+        isAutoCreated: false,
+        completed: false,
+      });
+      repo.findById.mockResolvedValue(task);
+      repo.findByParentId.mockResolvedValue([task, occupying]);
+
+      const result = await service.update(1, 'root-1', { completed: true });
+
+      expect(repo.create).not.toHaveBeenCalled();
+      expect(result.nextInstance).toEqual(occupying);
+      expect(result.task.recurringCompletedCount).toBe(1);
+    });
   });
 
   describe('update — идемпотентность complete', () => {
@@ -502,6 +818,8 @@ describe('TaskService', () => {
         id: 'inst-1',
         recurringParentId: 'root-1',
         completed: false,
+        dueDate: new Date('2026-04-06T10:00:00.000Z'),
+        isAutoCreated: true,
       });
 
       repo.findById.mockResolvedValue(task);
@@ -511,6 +829,7 @@ describe('TaskService', () => {
 
       expect(repo.create).not.toHaveBeenCalled();
       expect(result.nextInstance).toEqual(existingNext);
+      expect(result.task.recurringCompletedCount).toBe(0);
     });
   });
 
@@ -798,33 +1117,86 @@ describe('TaskService', () => {
   });
 
   describe('delete — recurring задача', () => {
-    it('удаление корня -> вызывает deleteUncompletedInSeries + nullifyParentReference', async () => {
+    it('удаление корня -> сносит uncompleted семьи и чистит parentId', async () => {
       const task = makeTask({
         id: 'root-1',
         recurrence: dailyRule,
         recurringParentId: null,
       });
+      const child = makeTask({
+        id: 'inst-1',
+        recurrence: dailyRule,
+        recurringParentId: 'root-1',
+      });
 
       repo.findById.mockResolvedValue(task);
+      repo.findByParentId
+        .mockResolvedValueOnce([task, child])
+        .mockResolvedValueOnce([task]);
 
       await service.delete(1, 'root-1');
 
       expect(repo.deleteByParentId).toHaveBeenCalledWith('root-1', true);
       expect(repo.clearParentId).toHaveBeenCalledWith('root-1');
+      expect(repo.delete).toHaveBeenCalledWith('root-1', 1);
     });
 
-    it('удаление instance (не корня) -> НЕ вызывает deleteUncompletedInSeries', async () => {
-      const task = makeTask({
+    it('удаление не-последнего instance -> только эта строка', async () => {
+      const root = makeTask({
+        id: 'root-1',
+        recurrence: dailyRule,
+        recurringParentId: null,
+        completed: true,
+      });
+      const inst = makeTask({
         id: 'inst-1',
         recurrence: dailyRule,
         recurringParentId: 'root-1',
       });
+      const other = makeTask({
+        id: 'inst-2',
+        recurrence: dailyRule,
+        recurringParentId: 'root-1',
+      });
 
-      repo.findById.mockResolvedValue(task);
+      repo.findById.mockResolvedValue(inst);
+      repo.findByParentId.mockResolvedValue([root, inst, other]);
 
       await service.delete(1, 'inst-1');
 
       expect(repo.deleteByParentId).not.toHaveBeenCalled();
+      expect(repo.delete).toHaveBeenCalledWith('inst-1', 1);
+    });
+
+    it('удаление последнего live после completed root -> гасит recurrence у root', async () => {
+      const root = makeTask({
+        id: 'root-1',
+        recurrence: dailyRule,
+        recurringParentId: null,
+        completed: true,
+      });
+      const inst = makeTask({
+        id: 'inst-1',
+        recurrence: dailyRule,
+        recurringParentId: 'root-1',
+      });
+
+      repo.findById.mockResolvedValue(inst);
+      repo.findByParentId
+        .mockResolvedValueOnce([root, inst])
+        .mockResolvedValueOnce([root]);
+
+      const result = await service.delete(1, 'inst-1');
+
+      expect(repo.deleteByParentId).toHaveBeenCalledWith('root-1', true);
+      expect(repo.delete).not.toHaveBeenCalled();
+      expect(repo.save).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'root-1', recurrence: null }),
+      );
+      expect(result.deletedIds).toEqual(['inst-1']);
+      expect(result.updated[0]).toEqual(
+        expect.objectContaining({ id: 'root-1', recurrence: null }),
+      );
     });
 
     it('удаление обычной задачи без recurrence -> НЕ вызывает deleteUncompletedInSeries', async () => {
diff --git a/alfy-bot/src/modules/task/task.service.ts b/alfy-bot/src/modules/task/task.service.ts
index 3414d44..e1be008 100644
--- a/alfy-bot/src/modules/task/task.service.ts
+++ b/alfy-bot/src/modules/task/task.service.ts
@@ -8,23 +8,45 @@ import { Task, PomodoroConfig } from '../../shared/entities';
 import { TaskRepositoryPort } from './domain/task-repository.port';
 import { CreateTaskDto } from './dto/create-task.dto';
 import { UpdateTaskDto } from './dto/update-task.dto';
+import { MaterializeOccurrenceDto } from './dto/materialize-occurrence.dto';
 import { UpdateChecklistDto } from './dto/update-checklist.dto';
 import { UpdatePomodoroConfigDto } from './dto/update-pomodoro-config.dto';
 import { ReorderInboxTasksDto } from './dto/reorder-inbox-tasks.dto';
 import { MoveTaskToInboxDto } from './dto/move-task-inbox.dto';
 import {
+  applyDueDateReschedule,
   buildNextInstance,
   findNextOccurrenceOnOrAfter,
+  findOccupyingInstance,
+  isOccurrenceOnSeries,
+  seriesDueDate,
+  retargetRecurrenceToDate,
 } from './domain/recurrence.utils';
 import { UserSettingsPort } from './domain/user-settings.port';
 import { shiftToUserWallClock, shiftBackToUtc } from './lib/timezone';
 
+function clonePomodoroConfig(src: PomodoroConfig): PomodoroConfig {
+  const config = new PomodoroConfig();
+  config.pomodoroCount = src.pomodoroCount;
+  config.pomodoroDuration = src.pomodoroDuration;
+  config.shortBreak = src.shortBreak;
+  config.longBreak = src.longBreak;
+  config.longBreakInterval = src.longBreakInterval;
+  config.pomodoroCompleted = 0;
+  return config;
+}
+
 export interface UpdateTaskResponse {
   task: Task;
   nextInstance?: Task;
   deletedInstanceId?: string;
 }
 
+export interface DeleteTaskResponse {
+  deletedIds: string[];
+  updated: Task[];
+}
+
 @Injectable()
 export class TaskService {
   constructor(
@@ -75,6 +97,87 @@ export class TaskService {
     return this.taskRepo.create(taskData);
   }
 
+  async materializeOccurrence(
+    userId: number,
+    sourceId: string,
+    dto: MaterializeOccurrenceDto,
+  ): Promise<Task> {
+    if (sourceId.includes('__virtual__')) {
+      throw new BadRequestException(
+        'Virtual task instances cannot be modified directly.',
+      );
+    }
+
+    const source = await this.taskRepo.findById(sourceId, userId);
+    if (!source) throw new NotFoundException(`Task #${sourceId} not found`);
+
+    if (source.isOverdue) {
+      throw new BadRequestException('Overdue task cannot be modified.');
+    }
+    if (!source.recurrence) {
+      throw new BadRequestException(
+        'Only recurring tasks can materialize occurrences.',
+      );
+    }
+
+    const timezone = await this.userSettings.getTimezone(userId);
+    const parentId = source.recurringParentId ?? source.id;
+    const rootTask = source.recurringParentId
+      ? await this.taskRepo.findById(parentId, userId)
+      : source;
+    const origin = seriesDueDate({
+      dueDate: source.dueDate,
+      recurrenceAnchorDate: source.recurrenceAnchorDate ?? null,
+    });
+    if (!origin) {
+      throw new BadRequestException('Task has no series slot.');
+    }
+
+    const occurrenceUtc = new Date(dto.occurrenceDate);
+    const originZoned = shiftToUserWallClock(origin, timezone);
+    const occurrenceZoned = shiftToUserWallClock(occurrenceUtc, timezone);
+    const rule = source.recurrence;
+    if (!rule) {
+      throw new BadRequestException(
+        'Only recurring tasks can materialize occurrences.',
+      );
+    }
+    const completedCount = rootTask?.recurringCompletedCount ?? 0;
+
+    if (
+      !isOccurrenceOnSeries(
+        originZoned,
+        rule,
+        occurrenceZoned,
+        completedCount,
+      )
+    ) {
+      throw new BadRequestException(
+        'occurrenceDate is not on the series schedule.',
+      );
+    }
+
+    const members = await this.taskRepo.findByParentId(parentId, true);
+    const occupying = this.findOccupyingMember(
+      members,
+      occurrenceZoned,
+      timezone,
+    );
+    if (occupying) {
+      throw new BadRequestException('This series slot is already occupied.');
+    }
+
+    const instanceData = buildNextInstance(source, occurrenceUtc, parentId);
+    instanceData.isAutoCreated = false;
+    if (source.pomodoroConfig) {
+      (instanceData as any).pomodoroConfig = clonePomodoroConfig(
+        source.pomodoroConfig,
+      );
+    }
+
+    return this.taskRepo.create(instanceData);
+  }
+
   async update(
     userId: number,
     id: string,
@@ -86,7 +189,7 @@ export class TaskService {
       );
     }
 
-    const { dueDate, deadline, recurrence, ...rest } = dto;
+    const { dueDate, deadline, recurrence, rescheduleScope, ...rest } = dto;
 
     const task = await this.taskRepo.findById(id, userId);
     if (!task) throw new NotFoundException(`Task #${id} not found`);
@@ -107,14 +210,35 @@ export class TaskService {
       Object.entries(rest).filter(([, v]) => v !== undefined),
     );
     Object.assign(task, defined);
-    if (dueDate !== undefined)
-      task.dueDate = dueDate ? new Date(dueDate) : null;
+    if (dueDate !== undefined) {
+      const newDue = dueDate ? new Date(dueDate) : null;
+      if ((rescheduleScope ?? 'this') === 'subsequent') {
+        await this.retargetSubsequentRecurrence(task, newDue);
+      }
+      const next = applyDueDateReschedule(
+        {
+          dueDate: task.dueDate,
+          recurrenceAnchorDate: task.recurrenceAnchorDate ?? null,
+          recurrence: task.recurrence,
+        },
+        newDue,
+        rescheduleScope ?? 'this',
+      );
+      task.dueDate = next.dueDate;
+      task.recurrenceAnchorDate = next.recurrenceAnchorDate;
+    } else if (rescheduleScope === 'subsequent') {
+      await this.retargetSubsequentRecurrence(task, task.dueDate);
+      task.recurrenceAnchorDate = null;
+    }
     if (deadline !== undefined)
       task.deadline = deadline ? new Date(deadline) : null;
     if (recurrence !== undefined) task.recurrence = recurrence ?? null;
 
-    // Mark user-modified instances as not auto-created
-    if (task.recurringParentId && !dto.completed) {
+    // Content edits detach an auto-created row from "cursor" status.
+    // dueDate / rescheduleScope keep it as the live series cursor.
+    const isRescheduleUpdate =
+      dto.rescheduleScope !== undefined || dueDate !== undefined;
+    if (task.recurringParentId && !dto.completed && !isRescheduleUpdate) {
       task.isAutoCreated = false;
     }
 
@@ -130,29 +254,59 @@ export class TaskService {
     return { task: saved };
   }
 
+  private async retargetSubsequentRecurrence(
+    task: Task,
+    toUtc: Date | null,
+  ): Promise<void> {
+    const fromUtc = seriesDueDate({
+      dueDate: task.dueDate,
+      recurrenceAnchorDate: task.recurrenceAnchorDate ?? null,
+    });
+    if (!task.recurrence || !fromUtc || !toUtc) return;
+    const timezone = await this.userSettings.getTimezone(task.userId);
+    task.recurrence = retargetRecurrenceToDate(
+      task.recurrence,
+      shiftToUserWallClock(fromUtc, timezone),
+      shiftToUserWallClock(toUtc, timezone),
+    );
+  }
+
+  private findOccupyingMember(
+    members: Task[],
+    slotZoned: Date,
+    timezone: string,
+  ): Task | undefined {
+    const zoned = members.map((member) => ({
+      member,
+      dueDate: member.dueDate
+        ? shiftToUserWallClock(member.dueDate, timezone)
+        : null,
+      recurrenceAnchorDate: member.recurrenceAnchorDate
+        ? shiftToUserWallClock(member.recurrenceAnchorDate, timezone)
+        : null,
+    }));
+    const occupying = findOccupyingInstance(zoned, slotZoned);
+    return occupying?.member;
+  }
+
   private async completeRecurringTask(
     userId: number,
     task: Task,
   ): Promise<UpdateTaskResponse> {
     const parentId = task.recurringParentId ?? task.id;
-
-    // Idempotency: check if next instance already exists
     const uncompleted = await this.taskRepo.findByParentId(parentId, true);
-    const existingNext = uncompleted.find((t) => t.id !== task.id);
-
-    if (existingNext) {
-      task.completed = true;
-      const saved = await this.taskRepo.save(task);
-      return { task: saved, nextInstance: existingNext };
-    }
+    const siblings = uncompleted.filter((t) => t.id !== task.id);
 
-    // Compute next due date
     let nextInstance: Task | undefined;
 
-    if (task.dueDate && task.recurrence) {
+    const seriesDue = seriesDueDate({
+      dueDate: task.dueDate,
+      recurrenceAnchorDate: task.recurrenceAnchorDate ?? null,
+    });
+
+    if (seriesDue && task.recurrence) {
       const timezone = await this.userSettings.getTimezone(userId);
 
-      // Get the root task for completedCount
       const rootTask = task.recurringParentId
         ? await this.taskRepo.findById(parentId, userId)
         : task;
@@ -164,8 +318,7 @@ export class TaskService {
       const startOfTodayLocal = new Date(nowLocal);
       startOfTodayLocal.setUTCHours(0, 0, 0, 0);
 
-      // Shift to user's wall clock so domain sees correct calendar day
-      const zonedDue = shiftToUserWallClock(task.dueDate, timezone);
+      const zonedDue = shiftToUserWallClock(seriesDue, timezone);
       const nextZoned = findNextOccurrenceOnOrAfter(
         zonedDue,
         task.recurrence,
@@ -173,32 +326,38 @@ export class TaskService {
         countAfterComplete,
       );
       const nextDate = nextZoned ? shiftBackToUtc(nextZoned, timezone) : null;
-
-      if (nextDate) {
-        const instanceData = buildNextInstance(task, nextDate, parentId);
-
-        // Copy pomodoroConfig (cascade entity, not a domain concern)
-        if (task.pomodoroConfig) {
-          const config = new PomodoroConfig();
-          config.pomodoroCount = task.pomodoroConfig.pomodoroCount;
-          config.pomodoroDuration = task.pomodoroConfig.pomodoroDuration;
-          config.shortBreak = task.pomodoroConfig.shortBreak;
-          config.longBreak = task.pomodoroConfig.longBreak;
-          config.longBreakInterval = task.pomodoroConfig.longBreakInterval;
-          config.pomodoroCompleted = 0;
-          (instanceData as any).pomodoroConfig = config;
+      const occupying =
+        nextZoned &&
+        this.findOccupyingMember(siblings, nextZoned, timezone);
+
+      if (occupying) {
+        nextInstance = occupying;
+        if (!occupying.isAutoCreated && rootTask) {
+          rootTask.recurringCompletedCount = countAfterComplete;
+          if (rootTask.id !== task.id) {
+            await this.taskRepo.save(rootTask);
+          } else {
+            task.recurringCompletedCount = countAfterComplete;
+          }
+        }
+      } else {
+        if (nextDate) {
+          const instanceData = buildNextInstance(task, nextDate, parentId);
+          if (task.pomodoroConfig) {
+            (instanceData as any).pomodoroConfig = clonePomodoroConfig(
+              task.pomodoroConfig,
+            );
+          }
+          nextInstance = await this.taskRepo.create(instanceData);
         }
 
-        nextInstance = await this.taskRepo.create(instanceData);
-      }
-
-      // Increment completed count on root
-      if (rootTask) {
-        rootTask.recurringCompletedCount = completedCount + 1;
-        if (rootTask.id !== task.id) {
-          await this.taskRepo.save(rootTask);
-        } else {
-          task.recurringCompletedCount = completedCount + 1;
+        if (rootTask) {
+          rootTask.recurringCompletedCount = countAfterComplete;
+          if (rootTask.id !== task.id) {
+            await this.taskRepo.save(rootTask);
+          } else {
+            task.recurringCompletedCount = countAfterComplete;
+          }
         }
       }
     }
@@ -280,17 +439,62 @@ export class TaskService {
     await this.taskRepo.incrementPomodoroCompleted(taskId, increment);
   }
 
-  async delete(userId: number, id: string): Promise<void> {
+  async delete(userId: number, id: string): Promise<DeleteTaskResponse> {
     const task = await this.taskRepo.findById(id, userId);
 
-    // Cascade for recurring root tasks
-    if (task?.recurrence && !task.recurringParentId) {
-      await this.taskRepo.deleteByParentId(task.id, true);
-      await this.taskRepo.clearParentId(task.id);
+    if (task && (task.recurrence || task.recurringParentId)) {
+      return this.deleteRecurringFamilyMember(userId, task);
     }
 
     const deleted = await this.taskRepo.delete(id, userId);
     if (!deleted) throw new NotFoundException(`Task #${id} not found`);
+    return { deletedIds: [id], updated: [] };
+  }
+
+  private async deleteRecurringFamilyMember(
+    userId: number,
+    task: Task,
+  ): Promise<DeleteTaskResponse> {
+    const parentId = task.recurringParentId ?? task.id;
+    const family = await this.taskRepo.findByParentId(parentId, false);
+    const liveOthers = family.filter((t) => !t.completed && t.id !== task.id);
+    const isRoot = task.recurringParentId === null;
+    const shouldEndSeries = isRoot || liveOthers.length === 0;
+
+    if (!shouldEndSeries) {
+      const deleted = await this.taskRepo.delete(task.id, userId);
+      if (!deleted) throw new NotFoundException(`Task #${task.id} not found`);
+      return { deletedIds: [task.id], updated: [] };
+    }
+
+    const live = family.filter((t) => !t.completed);
+    const deletedIds = [...new Set([task.id, ...live.map((t) => t.id)])];
+
+    await this.taskRepo.deleteByParentId(parentId, true);
+
+    const leftover = await this.taskRepo.findByParentId(parentId, false);
+    const updated: Task[] = [];
+    for (const member of leftover) {
+      if (member.id === task.id) continue;
+      if (member.recurrence || member.recurringParentId) {
+        member.recurrence = null;
+        if (isRoot) member.recurringParentId = null;
+        updated.push(await this.taskRepo.save(member));
+      }
+    }
+
+    if (isRoot) {
+      await this.taskRepo.clearParentId(parentId);
+    }
+
+    const alreadyDeleted =
+      Boolean(task.recurringParentId) && !task.completed;
+    if (!alreadyDeleted) {
+      const deleted = await this.taskRepo.delete(task.id, userId);
+      if (!deleted) throw new NotFoundException(`Task #${task.id} not found`);
+    }
+
+    return { deletedIds, updated };
   }
 
   async reorderInboxTasks(
diff --git a/alfy-bot/src/shared/database/recurring-series-repair.service.ts b/alfy-bot/src/shared/database/recurring-series-repair.service.ts
new file mode 100644
index 0000000..fffc8bc
--- /dev/null
+++ b/alfy-bot/src/shared/database/recurring-series-repair.service.ts
@@ -0,0 +1,45 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { Task } from '../entities';
+
+/** Completed families with no live member still had recurrence → ghosts. Strip. */
+@Injectable()
+export class RecurringSeriesRepairService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(RecurringSeriesRepairService.name);
+
+  constructor(private readonly dataSource: DataSource) {}
+
+  async onApplicationBootstrap() {
+    const repo = this.dataSource.getRepository(Task);
+    const all = await repo.find();
+    const familyIds = new Set<string>();
+    for (const task of all) {
+      if (task.recurrence || task.recurringParentId) {
+        familyIds.add(task.recurringParentId ?? task.id);
+      }
+    }
+
+    let stripped = 0;
+    for (const familyId of familyIds) {
+      const members = all.filter(
+        (t) => t.id === familyId || t.recurringParentId === familyId,
+      );
+      const live = members.filter((t) => !t.completed && !t.isOverdue);
+      for (const member of members) {
+        if (!member.recurrence) continue;
+        const isDeadRoot = member.completed && !member.recurringParentId && live.length === 0;
+        const isCompletedChild = member.completed && Boolean(member.recurringParentId);
+        if (!isDeadRoot && !isCompletedChild) continue;
+        member.recurrence = null;
+        await repo.save(member);
+        stripped += 1;
+      }
+    }
+
+    if (stripped > 0) {
+      this.logger.log(
+        `Stripped recurrence from ${stripped} task(s) in dead series`,
+      );
+    }
+  }
+}
diff --git a/alfy-bot/src/shared/entities/task.entity.ts b/alfy-bot/src/shared/entities/task.entity.ts
index a0277bd..38aa181 100644
--- a/alfy-bot/src/shared/entities/task.entity.ts
+++ b/alfy-bot/src/shared/entities/task.entity.ts
@@ -38,6 +38,9 @@ export class Task {
   @Column({ type: 'datetime', nullable: true })
   dueDate: Date | null;
 
+  @Column({ type: 'datetime', nullable: true })
+  recurrenceAnchorDate: Date | null;
+
   @Column({ type: 'datetime', nullable: true })
   deadline: Date | null;